@0xsequence/relayer 0.31.0 → 0.35.0

package/dist/0xsequence-relayer.cjs.prod.js

@@ -3,9 +3,9 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var ethers = require('ethers');
-var providers = require('@ethersproject/providers');
 var abi = require('@0xsequence/abi');
 var transactions = require('@0xsequence/transactions');
+var providers = require('@ethersproject/providers');
 var config = require('@0xsequence/config');
 var utils$1 = require('ethers/lib/utils');
 var utils = require('@0xsequence/utils');
@@ -66,8 +66,14 @@ class BaseRelayer {
     };
   }
 
-  async prepareTransactions(config$1, context, signature, ...transactions$1) {
-    //, gasLimit?: ethers.BigNumberish }> {
+  async prependWalletDeploy(signedTransactions) {
+    const {
+      config: config$1,
+      context,
+      transactions: transactions$1,
+      nonce,
+      signature
+    } = signedTransactions;
     const walletAddress = config.addressOf(config$1, context);
     const walletInterface = new utils$1.Interface(abi.walletContracts.mainModule.abi);
 
@@ -80,28 +86,61 @@ class BaseRelayer {
     if (this.bundleCreation && !(await this.isWalletDeployed(walletAddress))) {
       return {
         to: context.guestModule,
-        data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode([_extends({}, this.prepareWalletDeploy(config$1, context), {
-          delegateCall: false,
-          revertOnError: false,
-          gasLimit: this.creationGasLimit,
-          value: ethers.ethers.constants.Zero
-        }), {
-          delegateCall: false,
-          revertOnError: true,
-          gasLimit: ethers.ethers.constants.Zero,
-          to: walletAddress,
-          value: ethers.ethers.constants.Zero,
-          data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode(transactions$1), transactions.readSequenceNonce(...transactions$1), await encodedSignature])
-        }]), 0, []])
+        execute: {
+          transactions: [_extends({}, this.prepareWalletDeploy(config$1, context), {
+            delegateCall: false,
+            revertOnError: false,
+            gasLimit: this.creationGasLimit,
+            value: ethers.ethers.constants.Zero
+          }), {
+            delegateCall: false,
+            revertOnError: true,
+            gasLimit: ethers.ethers.constants.Zero,
+            to: walletAddress,
+            value: ethers.ethers.constants.Zero,
+            data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode(transactions$1), nonce, await encodedSignature])
+          }],
+          nonce: ethers.ethers.constants.Zero,
+          signature: '0x'
+        }
       };
     } else {
       return {
         to: walletAddress,
-        data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode(transactions$1), transactions.readSequenceNonce(...transactions$1), await encodedSignature])
+        execute: {
+          transactions: transactions$1,
+          nonce: ethers.ethers.BigNumber.from(nonce),
+          signature: await encodedSignature
+        }
       };
     }
   }
 
+  async prepareTransactions(config, context, signature, ...transactions$1) {
+    //, gasLimit?: ethers.BigNumberish }> {
+    const nonce = transactions.readSequenceNonce(...transactions$1);
+
+    if (!nonce) {
+      throw new Error('Unable to prepare transactions without a defined nonce');
+    }
+
+    const {
+      to,
+      execute
+    } = await this.prependWalletDeploy({
+      config,
+      context,
+      transactions: transactions$1,
+      nonce,
+      signature
+    });
+    const walletInterface = new utils$1.Interface(abi.walletContracts.mainModule.abi);
+    return {
+      to,
+      data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode(execute.transactions), execute.nonce, execute.signature])
+    };
+  }
+
 }
 
 const DEFAULT_GAS_LIMIT = ethers.ethers.BigNumber.from(800000);
@@ -129,11 +168,10 @@ class ProviderRelayer extends BaseRelayer {
     this.fromBlockLog = opts.fromBlockLog;
   }
 
-  async estimateGasLimits(config$1, context, ...transactions) {
+  async simulate(wallet, ...transactions) {
     var _this = this;
 
-    const walletAddr = config.addressOf(config$1, context);
-    const gasCosts = await Promise.all(transactions.map(async function (tx) {
+    return (await Promise.all(transactions.map(async function (tx) {
       // Respect gasLimit request of the transaction (as long as its not 0)
       if (tx.gasLimit && !ethers.ethers.BigNumber.from(tx.gasLimit || 0).eq(ethers.ethers.constants.Zero)) {
         return tx.gasLimit;
@@ -145,7 +183,7 @@ class ProviderRelayer extends BaseRelayer {
       } // Fee can't be estimated for self-called if wallet hasn't been deployed
 
 
-      if (tx.to === walletAddr && !(await _this.isWalletDeployed(walletAddr))) {
+      if (tx.to === wallet && !(await _this.isWalletDeployed(wallet))) {
         return DEFAULT_GAS_LIMIT;
       }
 
@@ -156,16 +194,25 @@ class ProviderRelayer extends BaseRelayer {
 
 
       return _this.provider.estimateGas({
-        from: walletAddr,
+        from: wallet,
         to: tx.to,
         data: tx.data,
         value: tx.value
       });
+    }))).map(gasLimit => ({
+      executed: true,
+      succeeded: true,
+      gasLimit: ethers.ethers.BigNumber.from(gasLimit).toNumber(),
+      gasUsed: ethers.ethers.BigNumber.from(gasLimit).toNumber()
+    }));
+  }
+
+  async estimateGasLimits(config$1, context, ...transactions) {
+    const walletAddr = config.addressOf(config$1, context);
+    const results = await this.simulate(walletAddr, ...transactions);
+    return transactions.map((t, i) => _extends({}, t, {
+      gasLimit: results[i].gasLimit
     }));
-    return transactions.map((t, i) => {
-      t.gasLimit = gasCosts[i];
-      return t;
-    });
   }
 
   async getNonce(config$1, context, space, blockTag) {
@@ -273,18 +320,26 @@ class LocalRelayer extends ProviderRelayer {
       throw new Error('LocalRelayer requires the context.guestModule address');
     }
 
-    const txRequest = await this.prepareTransactions(signedTxs.config, signedTxs.context, signedTxs.signature, ...signedTxs.transactions); // TODO: think about computing gas limit individually, summing together and passing across
+    const {
+      to,
+      execute
+    } = await this.prependWalletDeploy(signedTxs);
+    const walletInterface = new ethers.ethers.utils.Interface(abi.walletContracts.mainModule.abi);
+    const data = walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode(execute.transactions), execute.nonce, execute.signature]); // TODO: think about computing gas limit individually, summing together and passing across
     // NOTE: we expect that all txns have set their gasLimit ahead of time through proper estimation
     // const gasLimit = signedTxs.transactions.reduce((sum, tx) => sum.add(tx.gasLimit), ethers.BigNumber.from(0))
     // txRequest.gasLimit = gasLimit
 
-    return this.signer.sendTransaction(txRequest);
+    return this.signer.sendTransaction({
+      to,
+      data
+    });
   }
 
 }
 
 /* eslint-disable */
-// sequence-relayer v0.4.0 fc9652e2bc0c3df8d1ce0b4a8e24ab8790e4dae2
+// sequence-relayer v0.4.0 7dbfaf5c04cf28e9259ff1a9bf3274c8d73be5dd
 // --
 // This file has been generated by https://github.com/webrpc/webrpc using gen/typescript
 // Do not edit by hand. Update your webrpc schema and re-generate.
@@ -293,7 +348,7 @@ const WebRPCVersion = 'v1'; // Schema version of your RIDL schema
 
 const WebRPCSchemaVersion = 'v0.4.0'; // Schema hash generated from your RIDL schema
 
-const WebRPCSchemaHash = 'fc9652e2bc0c3df8d1ce0b4a8e24ab8790e4dae2'; //
+const WebRPCSchemaHash = '7dbfaf5c04cf28e9259ff1a9bf3274c8d73be5dd'; //
 // Types
 //
 
@@ -425,6 +480,16 @@ class Relayer {
       });
     };
 
+    this.simulate = (args, headers) => {
+      return this.fetch(this.url('Simulate'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            results: _data.results
+          };
+        });
+      });
+    };
+
     this.updateMetaTxnGasLimits = (args, headers) => {
       return this.fetch(this.url('UpdateMetaTxnGasLimits'), createHTTPRequest(args, headers)).then(res => {
         return buildResponse(res).then(_data => {
@@ -446,6 +511,16 @@ class Relayer {
       });
     };
 
+    this.feeOptions = (args, headers) => {
+      return this.fetch(this.url('FeeOptions'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            options: _data.options
+          };
+        });
+      });
+    };
+
     this.getMetaTxnNetworkFeeOptions = (args, headers) => {
       return this.fetch(this.url('GetMetaTxnNetworkFeeOptions'), createHTTPRequest(args, headers)).then(res => {
         return buildResponse(res).then(_data => {
@@ -565,6 +640,15 @@ class RpcRelayer extends BaseRelayer {
     return result;
   }
 
+  async simulate(wallet, ...transactions$1) {
+    const coder = ethers.ethers.utils.defaultAbiCoder;
+    const encoded = coder.encode([transactions.MetaTransactionsType], [transactions.sequenceTxAbiEncode(transactions$1)]);
+    return (await this.service.simulate({
+      wallet,
+      transactions: encoded
+    })).results;
+  }
+
   async estimateGasLimits(config$1, context, ...transactions$1) {
     utils.logger.info(`[rpc-relayer/estimateGasLimits] estimate gas limits request ${JSON.stringify(transactions$1)}`);
 
@@ -609,23 +693,39 @@ class RpcRelayer extends BaseRelayer {
     if (feeTokens.isFeeRequired) {
       const symbols = feeTokens.tokens.map(token => token.symbol).join(', ');
       utils.logger.info(`[rpc-relayer/gasRefundOptions] relayer fees are required, accepted tokens are ${symbols}`);
-      const addr = config.addressOf(config$1, context);
-      const prevNonce = transactions.readSequenceNonce(...transactions$1); // Set temporal nonce to simulate meta-txn
+      const wallet = config.addressOf(config$1, context);
+      let nonce = transactions.readSequenceNonce(...transactions$1);
+
+      if (nonce === undefined) {
+        nonce = await this.getNonce(config$1, context);
+      }
 
-      if (prevNonce === undefined) {
-        transactions$1 = transactions.appendNonce(transactions$1, await this.getNonce(config$1, context));
+      if (!this.provider) {
+        utils.logger.warn(`[rpc-relayer/gasRefundOptions] provider not set, needed for stub signature`);
+        throw new Error('provider is not set');
       }
 
-      const coder = ethers.ethers.utils.defaultAbiCoder;
-      const encoded = coder.encode([transactions.MetaTransactionsType], [transactions.sequenceTxAbiEncode(transactions$1)]);
-      const res = await this.service.getMetaTxnNetworkFeeOptions({
-        walletConfig: _extends({}, config$1, {
-          address: addr
-        }),
-        payload: encoded
+      const {
+        to,
+        execute
+      } = await this.prependWalletDeploy({
+        config: config$1,
+        context,
+        transactions: transactions$1,
+        nonce,
+        signature: config.buildStubSignature(this.provider, config$1)
+      });
+      const walletInterface = new ethers.ethers.utils.Interface(abi.walletContracts.mainModule.abi);
+      const data = walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode(execute.transactions), execute.nonce, execute.signature]);
+      const {
+        options
+      } = await this.service.feeOptions({
+        wallet,
+        to,
+        data
       });
-      utils.logger.info(`[rpc-relayer/gasRefundOptions] got refund options ${JSON.stringify(res.options)}`);
-      return res.options;
+      utils.logger.info(`[rpc-relayer/gasRefundOptions] got refund options ${JSON.stringify(options)}`);
+      return options;
     } else {
       utils.logger.info(`[rpc-relayer/gasRefundOptions] relayer fees are not required`);
       return [];
@@ -654,13 +754,18 @@ class RpcRelayer extends BaseRelayer {
       throw new Error('provider is not set');
     }
 
-    const addr = config.addressOf(signedTxs.config, signedTxs.context);
-    const prep = await this.prepareTransactions(signedTxs.config, signedTxs.context, signedTxs.signature, ...signedTxs.transactions);
+    const {
+      to: contract,
+      execute
+    } = await this.prependWalletDeploy(signedTxs);
+    const walletAddress = config.addressOf(signedTxs.config, signedTxs.context);
+    const walletInterface = new ethers.ethers.utils.Interface(abi.walletContracts.mainModule.abi);
+    const input = walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode(execute.transactions), execute.nonce, execute.signature]);
     const metaTxn = await this.service.sendMetaTxn({
       call: {
-        contract: prep.to,
-        input: prep.data,
-        walletAddress: addr
+        walletAddress,
+        contract,
+        input
       }
     });
     utils.logger.info(`[rpc-relayer/relay] got relay result ${JSON.stringify(metaTxn)}`);

package/dist/0xsequence-relayer.esm.js

@@ -1,8 +1,8 @@
 import { ethers, providers, Signer } from 'ethers';
-import { Provider } from '@ethersproject/providers';
 import { walletContracts } from '@0xsequence/abi';
-import { sequenceTxAbiEncode, readSequenceNonce, encodeNonce, computeMetaTxnHash, appendNonce, MetaTransactionsType, decodeNonce } from '@0xsequence/transactions';
-import { imageHash, addressOf, encodeSignature } from '@0xsequence/config';
+import { sequenceTxAbiEncode, readSequenceNonce, encodeNonce, computeMetaTxnHash, MetaTransactionsType, appendNonce, decodeNonce } from '@0xsequence/transactions';
+import { Provider } from '@ethersproject/providers';
+import { imageHash, addressOf, encodeSignature, buildStubSignature } from '@0xsequence/config';
 import { Interface } from 'ethers/lib/utils';
 import { isBigNumberish, logger } from '@0xsequence/utils';
 import fetchPonyfill from 'fetch-ponyfill';
@@ -58,8 +58,14 @@ class BaseRelayer {
     };
   }
 
-  async prepareTransactions(config, context, signature, ...transactions) {
-    //, gasLimit?: ethers.BigNumberish }> {
+  async prependWalletDeploy(signedTransactions) {
+    const {
+      config,
+      context,
+      transactions,
+      nonce,
+      signature
+    } = signedTransactions;
     const walletAddress = addressOf(config, context);
     const walletInterface = new Interface(walletContracts.mainModule.abi);
 
@@ -72,28 +78,61 @@ class BaseRelayer {
     if (this.bundleCreation && !(await this.isWalletDeployed(walletAddress))) {
       return {
         to: context.guestModule,
-        data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [sequenceTxAbiEncode([_extends({}, this.prepareWalletDeploy(config, context), {
-          delegateCall: false,
-          revertOnError: false,
-          gasLimit: this.creationGasLimit,
-          value: ethers.constants.Zero
-        }), {
-          delegateCall: false,
-          revertOnError: true,
-          gasLimit: ethers.constants.Zero,
-          to: walletAddress,
-          value: ethers.constants.Zero,
-          data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [sequenceTxAbiEncode(transactions), readSequenceNonce(...transactions), await encodedSignature])
-        }]), 0, []])
+        execute: {
+          transactions: [_extends({}, this.prepareWalletDeploy(config, context), {
+            delegateCall: false,
+            revertOnError: false,
+            gasLimit: this.creationGasLimit,
+            value: ethers.constants.Zero
+          }), {
+            delegateCall: false,
+            revertOnError: true,
+            gasLimit: ethers.constants.Zero,
+            to: walletAddress,
+            value: ethers.constants.Zero,
+            data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [sequenceTxAbiEncode(transactions), nonce, await encodedSignature])
+          }],
+          nonce: ethers.constants.Zero,
+          signature: '0x'
+        }
       };
     } else {
       return {
         to: walletAddress,
-        data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [sequenceTxAbiEncode(transactions), readSequenceNonce(...transactions), await encodedSignature])
+        execute: {
+          transactions,
+          nonce: ethers.BigNumber.from(nonce),
+          signature: await encodedSignature
+        }
       };
     }
   }
 
+  async prepareTransactions(config, context, signature, ...transactions) {
+    //, gasLimit?: ethers.BigNumberish }> {
+    const nonce = readSequenceNonce(...transactions);
+
+    if (!nonce) {
+      throw new Error('Unable to prepare transactions without a defined nonce');
+    }
+
+    const {
+      to,
+      execute
+    } = await this.prependWalletDeploy({
+      config,
+      context,
+      transactions,
+      nonce,
+      signature
+    });
+    const walletInterface = new Interface(walletContracts.mainModule.abi);
+    return {
+      to,
+      data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [sequenceTxAbiEncode(execute.transactions), execute.nonce, execute.signature])
+    };
+  }
+
 }
 
 const DEFAULT_GAS_LIMIT = ethers.BigNumber.from(800000);
@@ -121,11 +160,10 @@ class ProviderRelayer extends BaseRelayer {
     this.fromBlockLog = opts.fromBlockLog;
   }
 
-  async estimateGasLimits(config, context, ...transactions) {
+  async simulate(wallet, ...transactions) {
     var _this = this;
 
-    const walletAddr = addressOf(config, context);
-    const gasCosts = await Promise.all(transactions.map(async function (tx) {
+    return (await Promise.all(transactions.map(async function (tx) {
       // Respect gasLimit request of the transaction (as long as its not 0)
       if (tx.gasLimit && !ethers.BigNumber.from(tx.gasLimit || 0).eq(ethers.constants.Zero)) {
         return tx.gasLimit;
@@ -137,7 +175,7 @@ class ProviderRelayer extends BaseRelayer {
       } // Fee can't be estimated for self-called if wallet hasn't been deployed
 
 
-      if (tx.to === walletAddr && !(await _this.isWalletDeployed(walletAddr))) {
+      if (tx.to === wallet && !(await _this.isWalletDeployed(wallet))) {
         return DEFAULT_GAS_LIMIT;
       }
 
@@ -148,16 +186,25 @@ class ProviderRelayer extends BaseRelayer {
 
 
       return _this.provider.estimateGas({
-        from: walletAddr,
+        from: wallet,
         to: tx.to,
         data: tx.data,
         value: tx.value
       });
+    }))).map(gasLimit => ({
+      executed: true,
+      succeeded: true,
+      gasLimit: ethers.BigNumber.from(gasLimit).toNumber(),
+      gasUsed: ethers.BigNumber.from(gasLimit).toNumber()
+    }));
+  }
+
+  async estimateGasLimits(config, context, ...transactions) {
+    const walletAddr = addressOf(config, context);
+    const results = await this.simulate(walletAddr, ...transactions);
+    return transactions.map((t, i) => _extends({}, t, {
+      gasLimit: results[i].gasLimit
     }));
-    return transactions.map((t, i) => {
-      t.gasLimit = gasCosts[i];
-      return t;
-    });
   }
 
   async getNonce(config, context, space, blockTag) {
@@ -265,18 +312,26 @@ class LocalRelayer extends ProviderRelayer {
       throw new Error('LocalRelayer requires the context.guestModule address');
     }
 
-    const txRequest = await this.prepareTransactions(signedTxs.config, signedTxs.context, signedTxs.signature, ...signedTxs.transactions); // TODO: think about computing gas limit individually, summing together and passing across
+    const {
+      to,
+      execute
+    } = await this.prependWalletDeploy(signedTxs);
+    const walletInterface = new ethers.utils.Interface(walletContracts.mainModule.abi);
+    const data = walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [sequenceTxAbiEncode(execute.transactions), execute.nonce, execute.signature]); // TODO: think about computing gas limit individually, summing together and passing across
     // NOTE: we expect that all txns have set their gasLimit ahead of time through proper estimation
     // const gasLimit = signedTxs.transactions.reduce((sum, tx) => sum.add(tx.gasLimit), ethers.BigNumber.from(0))
     // txRequest.gasLimit = gasLimit
 
-    return this.signer.sendTransaction(txRequest);
+    return this.signer.sendTransaction({
+      to,
+      data
+    });
   }
 
 }
 
 /* eslint-disable */
-// sequence-relayer v0.4.0 fc9652e2bc0c3df8d1ce0b4a8e24ab8790e4dae2
+// sequence-relayer v0.4.0 7dbfaf5c04cf28e9259ff1a9bf3274c8d73be5dd
 // --
 // This file has been generated by https://github.com/webrpc/webrpc using gen/typescript
 // Do not edit by hand. Update your webrpc schema and re-generate.
@@ -285,7 +340,7 @@ const WebRPCVersion = 'v1'; // Schema version of your RIDL schema
 
 const WebRPCSchemaVersion = 'v0.4.0'; // Schema hash generated from your RIDL schema
 
-const WebRPCSchemaHash = 'fc9652e2bc0c3df8d1ce0b4a8e24ab8790e4dae2'; //
+const WebRPCSchemaHash = '7dbfaf5c04cf28e9259ff1a9bf3274c8d73be5dd'; //
 // Types
 //
 
@@ -417,6 +472,16 @@ class Relayer {
       });
     };
 
+    this.simulate = (args, headers) => {
+      return this.fetch(this.url('Simulate'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            results: _data.results
+          };
+        });
+      });
+    };
+
     this.updateMetaTxnGasLimits = (args, headers) => {
       return this.fetch(this.url('UpdateMetaTxnGasLimits'), createHTTPRequest(args, headers)).then(res => {
         return buildResponse(res).then(_data => {
@@ -438,6 +503,16 @@ class Relayer {
       });
     };
 
+    this.feeOptions = (args, headers) => {
+      return this.fetch(this.url('FeeOptions'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            options: _data.options
+          };
+        });
+      });
+    };
+
     this.getMetaTxnNetworkFeeOptions = (args, headers) => {
       return this.fetch(this.url('GetMetaTxnNetworkFeeOptions'), createHTTPRequest(args, headers)).then(res => {
         return buildResponse(res).then(_data => {
@@ -557,6 +632,15 @@ class RpcRelayer extends BaseRelayer {
     return result;
   }
 
+  async simulate(wallet, ...transactions) {
+    const coder = ethers.utils.defaultAbiCoder;
+    const encoded = coder.encode([MetaTransactionsType], [sequenceTxAbiEncode(transactions)]);
+    return (await this.service.simulate({
+      wallet,
+      transactions: encoded
+    })).results;
+  }
+
   async estimateGasLimits(config, context, ...transactions) {
     logger.info(`[rpc-relayer/estimateGasLimits] estimate gas limits request ${JSON.stringify(transactions)}`);
 
@@ -601,23 +685,39 @@ class RpcRelayer extends BaseRelayer {
     if (feeTokens.isFeeRequired) {
       const symbols = feeTokens.tokens.map(token => token.symbol).join(', ');
       logger.info(`[rpc-relayer/gasRefundOptions] relayer fees are required, accepted tokens are ${symbols}`);
-      const addr = addressOf(config, context);
-      const prevNonce = readSequenceNonce(...transactions); // Set temporal nonce to simulate meta-txn
+      const wallet = addressOf(config, context);
+      let nonce = readSequenceNonce(...transactions);
+
+      if (nonce === undefined) {
+        nonce = await this.getNonce(config, context);
+      }
 
-      if (prevNonce === undefined) {
-        transactions = appendNonce(transactions, await this.getNonce(config, context));
+      if (!this.provider) {
+        logger.warn(`[rpc-relayer/gasRefundOptions] provider not set, needed for stub signature`);
+        throw new Error('provider is not set');
       }
 
-      const coder = ethers.utils.defaultAbiCoder;
-      const encoded = coder.encode([MetaTransactionsType], [sequenceTxAbiEncode(transactions)]);
-      const res = await this.service.getMetaTxnNetworkFeeOptions({
-        walletConfig: _extends({}, config, {
-          address: addr
-        }),
-        payload: encoded
+      const {
+        to,
+        execute
+      } = await this.prependWalletDeploy({
+        config,
+        context,
+        transactions,
+        nonce,
+        signature: buildStubSignature(this.provider, config)
+      });
+      const walletInterface = new ethers.utils.Interface(walletContracts.mainModule.abi);
+      const data = walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [sequenceTxAbiEncode(execute.transactions), execute.nonce, execute.signature]);
+      const {
+        options
+      } = await this.service.feeOptions({
+        wallet,
+        to,
+        data
       });
-      logger.info(`[rpc-relayer/gasRefundOptions] got refund options ${JSON.stringify(res.options)}`);
-      return res.options;
+      logger.info(`[rpc-relayer/gasRefundOptions] got refund options ${JSON.stringify(options)}`);
+      return options;
     } else {
       logger.info(`[rpc-relayer/gasRefundOptions] relayer fees are not required`);
       return [];
@@ -646,13 +746,18 @@ class RpcRelayer extends BaseRelayer {
       throw new Error('provider is not set');
     }
 
-    const addr = addressOf(signedTxs.config, signedTxs.context);
-    const prep = await this.prepareTransactions(signedTxs.config, signedTxs.context, signedTxs.signature, ...signedTxs.transactions);
+    const {
+      to: contract,
+      execute
+    } = await this.prependWalletDeploy(signedTxs);
+    const walletAddress = addressOf(signedTxs.config, signedTxs.context);
+    const walletInterface = new ethers.utils.Interface(walletContracts.mainModule.abi);
+    const input = walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [sequenceTxAbiEncode(execute.transactions), execute.nonce, execute.signature]);
     const metaTxn = await this.service.sendMetaTxn({
       call: {
-        contract: prep.to,
-        input: prep.data,
-        walletAddress: addr
+        walletAddress,
+        contract,
+        input
       }
     });
     logger.info(`[rpc-relayer/relay] got relay result ${JSON.stringify(metaTxn)}`);

package/dist/declarations/src/base-relayer.d.ts

@@ -1,7 +1,7 @@
 import { ethers, providers } from "ethers";
 import { WalletContext } from '@0xsequence/network';
 import { WalletConfig, DecodedSignature } from '@0xsequence/config';
-import { Transaction } from '@0xsequence/transactions';
+import { SignedTransactions, Transaction } from '@0xsequence/transactions';
 import { Optionals } from '@0xsequence/utils';
 import { Provider } from "@ethersproject/providers";
 export interface BaseRelayerOptions {
@@ -21,6 +21,14 @@ export declare class BaseRelayer {
         to: string;
         data: string;
     };
+    prependWalletDeploy(signedTransactions: Pick<SignedTransactions, 'config' | 'context' | 'transactions' | 'nonce' | 'signature'>): Promise<{
+        to: string;
+        execute: {
+            transactions: Transaction[];
+            nonce: ethers.BigNumber;
+            signature: string;
+        };
+    }>;
     prepareTransactions(config: WalletConfig, context: WalletContext, signature: string | Promise<string> | DecodedSignature | Promise<DecodedSignature>, ...transactions: Transaction[]): Promise<{
         to: string;
         data: string;