What's the best way to broadcast the user transaction signed by a different user?

[aaitor]

So the scenario is a user wants to send a transaction but not paying for the gas, because that transaction will be send by a different account. The flow is:

1. The publisher creates and signs the transaction

      unsignedTx = await registryContract[functionName].populateTransaction(...functionArgs)      
      assert.isDefined(unsignedTx)
      signedTx = await publisherSigner.signTransaction(unsignedTx)
     // The publisher stores the signed transaction off-chain

2. The relayer broadcast the

      const tx = Transaction.from(signedTx)
      // Here add gas, nonce, etc to the transaction

      const txResponse = await relayerProvider.broadcastTransaction(tx.serialized)

Is this assumption right?
If not what would be the best way to do it?
Thanks in advance.

[zemse]

With the normal transactions (type 0, 1, 2 so far), the signer of the tx has to pay the tx fee.

For transferring ERC20 tokens that supports permit function, you can have user sign the permit request, and then a relayer can sign the tx to a contract that spends those tokens.

If you want to improve ETH gas fee payment UX in general, unfortunately that's a problem and best solution which most people are betting on is account abstraction. You can have a look at ERC 4337 related developments.

[aaitor]

Thanks @zemse for the answer.

Yes, in parallel to this I'm evaluating doing the same with meta-tx or with smart accounts.

The potential benefit of doing this directly with "regular" transactions (but as you said it seems not possible) is the timing to broadcast a transaction. It means you can have a relayer writing stuff on-chain when is required to be on-chain (and not before) just picking up a signed transaction from an off-chain repository. Meta-tx and AA allow to subsidize the gas but don't provide that flexibility directly.