ETH - Pre-Paid smart contract so users don't pay transactions

Question

I'm developing a "corporate" DApp, therefore the employees don't have any reason to "spend" their ether/gas for interacting with the contract...

Is there any way to enable each transaction to be auto-paid by the contract itself? If not how would you address this problem? I cannot pass ETH to employees, because they might "spend it", and, at the same time, why would they use their own ETH?

Thank you all for any suggestion.

Cheers

Answer 1

You could implement some kind of meta-transaction system. Instead of signing directly a transaction, the employees sign a message containing the input parameters of the smart contract method, let's say inputA, inputB, and inputC.

Basis

• In the frontend ask the user for the inputs.

• Hash the inputs plus a random parameter : web3.utils.soliditySha3(inputA, inputB, inputC, random);. The random parameter prevents hash collisions if the same user signs twice the same data.

• Ask the user to sign the hash with them private key.

• You receive the signature, the user inputs, and the random parameter in your backend and inject them in the contract by signing the transaction with the application private key. The prototype of your solidity function should be something like this :

  function myFunction(uint256 inputA, address inputB, uint256 inputC, uint256 random, address userAddress, bytes32 r, 
  bytes32 s, uint8 v) public;
  

• Inside the function, hash the parameters and verify the user signature :

  bytes32 hash = keccak256(abi.encodePacked(inputA, inputB, inputC, random));
  require(ecrecover(hash, v, r, s) == userAddress);
  

Requirements to implement such logic

This kind of system has some requirements :

• That's the application which signs and sends the transaction in the backend on behalf of the user so you need to create an admin account and manage yourself the private key.
• You pay for the transactions so you need sufficient Ethers to cover the fees.
• You have to implement some kind of nonce management system to handle multiple concurrent requests.

Further remarks

Note that this system is poorly decentralized as the user does not sign directly the transaction. However, in the worst case, the application could only decide to not broadcast the transaction. There is no way to execute a malicious transaction as all input parameters are pre-signed by the user.

Answer 2

At the moment, Ethereum does not support models where the transactions would be paid by someone else.

Some smart contract based wallets like Pillar and Argent has built complex infrastructure to address this problem. The wallet itself is a smart contract that can do the action that user has signed with his or her key. However the transaction ETH gas cost is covered from the hot wallet of the service provider. The provider than bills the user based to the consumed ETH by dollar/other token.

So you can create very complex logic to dance around this limitation. But it sounds like your user case is relatively straightforward and more of an issue of not trusting the organisation employees. I would assume you can retoactively fire the emplyoees who lose their ETH.

Answer 3

There is EIP-2771 to enable meta-transactions in your smart contract and let others pay for the gas fees. https://eips.ethereum.org/EIPS/eip-2771

Tools that use this are:

• Gelato - https://docs.gelato.network/developer-products/gelato-relay-sdk
• Infura ITX - https://docs.infura.io/infura/features/itx-transactions
• OpenZeppelin - https://docs.openzeppelin.com/contracts/4.x/api/metatx
• GSN - https://docs.opengsn.org/