@0xsequence/relayer 0.34.0 → 0.35.3

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, MetaTransactionsType, appendNonce, decodeNonce } from '@0xsequence/transactions';
-import { imageHash, addressOf, encodeSignature } from '@0xsequence/config';
+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);
@@ -273,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 1598ae8045a4f054fefc0fa3b244f61f75a7c8bd
+// 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 +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 = '1598ae8045a4f054fefc0fa3b244f61f75a7c8bd'; //
+const WebRPCSchemaHash = '7dbfaf5c04cf28e9259ff1a9bf3274c8d73be5dd'; //
 // Types
 //
 
@@ -456,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 => {
@@ -628,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 (prevNonce === undefined) {
-        transactions = appendNonce(transactions, await this.getNonce(config, context));
+      if (nonce === undefined) {
+        nonce = await this.getNonce(config, context);
       }
 
-      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
+      if (!this.provider) {
+        logger.warn(`[rpc-relayer/gasRefundOptions] provider not set, needed for stub signature`);
+        throw new Error('provider is not set');
+      }
+
+      const {
+        to,
+        execute
+      } = await this.prependWalletDeploy({
+        config,
+        context,
+        transactions,
+        nonce,
+        signature: buildStubSignature(this.provider, config)
       });
-      logger.info(`[rpc-relayer/gasRefundOptions] got refund options ${JSON.stringify(res.options)}`);
-      return res.options;
+      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(options)}`);
+      return options;
     } else {
       logger.info(`[rpc-relayer/gasRefundOptions] relayer fees are not required`);
       return [];
@@ -673,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;

package/dist/declarations/src/rpc-relayer/relayer.gen.d.ts

@@ -1,6 +1,6 @@
 export declare const WebRPCVersion = "v1";
 export declare const WebRPCSchemaVersion = "v0.4.0";
-export declare const WebRPCSchemaHash = "1598ae8045a4f054fefc0fa3b244f61f75a7c8bd";
+export declare const WebRPCSchemaHash = "7dbfaf5c04cf28e9259ff1a9bf3274c8d73be5dd";
 export declare enum ETHTxnStatus {
     UNKNOWN = "UNKNOWN",
     DROPPED = "DROPPED",
@@ -80,6 +80,9 @@ export interface MetaTxnLog {
     txnStatus: ETHTxnStatus;
     txnRevertReason: string;
     requeues: number;
+    queuedAt: string;
+    sentAt: string;
+    minedAt: string;
     target: string;
     input: string;
     txnArgs: {
@@ -196,6 +199,7 @@ export interface Relayer {
     simulate(args: SimulateArgs, headers?: object): Promise<SimulateReturn>;
     updateMetaTxnGasLimits(args: UpdateMetaTxnGasLimitsArgs, headers?: object): Promise<UpdateMetaTxnGasLimitsReturn>;
     feeTokens(headers?: object): Promise<FeeTokensReturn>;
+    feeOptions(args: FeeOptionsArgs, headers?: object): Promise<FeeOptionsReturn>;
     getMetaTxnNetworkFeeOptions(args: GetMetaTxnNetworkFeeOptionsArgs, headers?: object): Promise<GetMetaTxnNetworkFeeOptionsReturn>;
     sentTransactions(args: SentTransactionsArgs, headers?: object): Promise<SentTransactionsReturn>;
     pendingTransactions(args: PendingTransactionsArgs, headers?: object): Promise<PendingTransactionsReturn>;
@@ -266,6 +270,14 @@ export interface FeeTokensReturn {
     isFeeRequired: boolean;
     tokens: Array<FeeToken>;
 }
+export interface FeeOptionsArgs {
+    wallet: string;
+    to: string;
+    data: string;
+}
+export interface FeeOptionsReturn {
+    options: Array<FeeOption>;
+}
 export interface GetMetaTxnNetworkFeeOptionsArgs {
     walletConfig: WalletConfig;
     payload: string;
@@ -305,6 +317,7 @@ export declare class Relayer implements Relayer {
     simulate: (args: SimulateArgs, headers?: object | undefined) => Promise<SimulateReturn>;
     updateMetaTxnGasLimits: (args: UpdateMetaTxnGasLimitsArgs, headers?: object | undefined) => Promise<UpdateMetaTxnGasLimitsReturn>;
     feeTokens: (headers?: object | undefined) => Promise<FeeTokensReturn>;
+    feeOptions: (args: FeeOptionsArgs, headers?: object | undefined) => Promise<FeeOptionsReturn>;
     getMetaTxnNetworkFeeOptions: (args: GetMetaTxnNetworkFeeOptionsArgs, headers?: object | undefined) => Promise<GetMetaTxnNetworkFeeOptionsReturn>;
     sentTransactions: (args: SentTransactionsArgs, headers?: object | undefined) => Promise<SentTransactionsReturn>;
     pendingTransactions: (args: PendingTransactionsArgs, headers?: object | undefined) => Promise<PendingTransactionsReturn>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/relayer",
-  "version": "0.34.0",
+  "version": "0.35.3",
   "description": "relayer sub-package for Sequence",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/relayer",
   "source": "src/index.ts",
@@ -17,10 +17,10 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@0xsequence/abi": "^0.34.0",
-    "@0xsequence/config": "^0.34.0",
-    "@0xsequence/transactions": "^0.34.0",
-    "@0xsequence/utils": "^0.34.0",
+    "@0xsequence/abi": "^0.35.3",
+    "@0xsequence/config": "^0.35.3",
+    "@0xsequence/transactions": "^0.35.3",
+    "@0xsequence/utils": "^0.35.3",
     "@ethersproject/providers": "^5.5.1",
     "ethers": "^5.5.2",
     "fetch-ponyfill": "^7.1.0"

package/src/base-relayer.ts

@@ -3,7 +3,7 @@ import { Interface } from "ethers/lib/utils"
 import { walletContracts } from '@0xsequence/abi'
 import { WalletContext } from '@0xsequence/network'
 import { WalletConfig, addressOf, imageHash, DecodedSignature, encodeSignature } from '@0xsequence/config'
-import { Transaction, sequenceTxAbiEncode, readSequenceNonce } from '@0xsequence/transactions'
+import { SignedTransactions, Transaction, sequenceTxAbiEncode, readSequenceNonce } from '@0xsequence/transactions'
 import { isBigNumberish, Optionals } from '@0xsequence/utils'
 import { Provider } from "@ethersproject/providers"
 
@@ -58,12 +58,10 @@ export class BaseRelayer {
     }
   }
 
-  async prepareTransactions(
-    config: WalletConfig,
-    context: WalletContext,
-    signature: string | Promise<string> | DecodedSignature | Promise<DecodedSignature>,
-    ...transactions: Transaction[]
-  ): Promise<{ to: string, data: string  }> { //, gasLimit?: ethers.BigNumberish }> {
+  async prependWalletDeploy(
+    signedTransactions: Pick<SignedTransactions, 'config' | 'context' | 'transactions' | 'nonce' | 'signature'>
+  ): Promise<{ to: string, execute: { transactions: Transaction[], nonce: ethers.BigNumber, signature: string } }> {
+    const { config, context, transactions, nonce, signature } = signedTransactions
     const walletAddress = addressOf(config, context)
     const walletInterface = new Interface(walletContracts.mainModule.abi)
 
@@ -77,8 +75,8 @@ export class BaseRelayer {
     if (this.bundleCreation && !(await this.isWalletDeployed(walletAddress))) {
       return {
         to: context.guestModule!,
-        data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [
-          sequenceTxAbiEncode([
+        execute: {
+          transactions: [
             {
               ...this.prepareWalletDeploy(config, context),
               delegateCall: false,
@@ -95,25 +93,46 @@ export class BaseRelayer {
               data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), 
                 [
                   sequenceTxAbiEncode(transactions),
-                  readSequenceNonce(...transactions),
+                  nonce,
                   await encodedSignature
                 ]
               )
             }
-          ]), 0, []
-        ])
+          ],
+          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: WalletConfig,
+    context: WalletContext,
+    signature: string | Promise<string> | DecodedSignature | Promise<DecodedSignature>,
+    ...transactions: Transaction[]
+  ): Promise<{ to: string, data: string  }> { //, 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
+      ])
+    }
+  }
 }

package/src/local-relayer.ts

@@ -1,6 +1,7 @@
 import { TransactionResponse } from '@ethersproject/providers'
 import { Signer as AbstractSigner, ethers } from 'ethers'
-import { SignedTransactions, Transaction } from '@0xsequence/transactions'
+import { walletContracts } from '@0xsequence/abi'
+import { SignedTransactions, Transaction, sequenceTxAbiEncode } from '@0xsequence/transactions'
 import { WalletContext } from '@0xsequence/network'
 import { WalletConfig } from '@0xsequence/config'
 import { FeeOption, Relayer } from '.'
@@ -46,13 +47,20 @@ export class LocalRelayer extends ProviderRelayer implements Relayer {
       throw new Error('LocalRelayer requires the context.guestModule address')
     }
 
-    const txRequest = await this.prepareTransactions(signedTxs.config, signedTxs.context, signedTxs.signature, ...signedTxs.transactions)
+    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 })
   }
 }

package/src/rpc-relayer/index.ts

@@ -1,6 +1,7 @@
 import { TransactionResponse } from '@ethersproject/providers'
 import { ethers } from 'ethers'
 import fetchPonyfill from 'fetch-ponyfill'
+import { walletContracts } from '@0xsequence/abi'
 import {
   Transaction,
   readSequenceNonce,
@@ -14,7 +15,7 @@ import {
 import { BaseRelayer, BaseRelayerOptions } from '../base-relayer'
 import { FeeOption, Relayer, SimulateResult } from '..'
 import { WalletContext } from '@0xsequence/network'
-import { WalletConfig, addressOf } from '@0xsequence/config'
+import { WalletConfig, addressOf, buildStubSignature } from '@0xsequence/config'
 import { logger } from '@0xsequence/utils'
 import * as proto from './relayer.gen'
 
@@ -122,23 +123,37 @@ export class RpcRelayer extends BaseRelayer implements Relayer {
       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)
+      const wallet = addressOf(config, context)
 
-      // Set temporal nonce to simulate meta-txn
-      if (prevNonce === undefined) {
-        transactions = appendNonce(transactions, await this.getNonce(config, context))
+      let nonce = readSequenceNonce(...transactions)
+      if (nonce === undefined) {
+        nonce = await this.getNonce(config, context)
       }
 
-      const coder = ethers.utils.defaultAbiCoder
-      const encoded = coder.encode([MetaTransactionsType], [sequenceTxAbiEncode(transactions)])
-      const res = await this.service.getMetaTxnNetworkFeeOptions({
-        walletConfig: { ...config, address: addr },
-        payload: encoded
+      if (!this.provider) {
+        logger.warn(`[rpc-relayer/gasRefundOptions] provider not set, needed for stub signature`)
+        throw new Error('provider is not set')
+      }
+
+      const { to, execute } = await this.prependWalletDeploy({
+        config,
+        context,
+        transactions,
+        nonce,
+        signature: buildStubSignature(this.provider, config)
       })
 
-      logger.info(`[rpc-relayer/gasRefundOptions] got refund options ${JSON.stringify(res.options)}`)
-      return res.options
+      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(options)}`)
+      return options
     } else {
       logger.info(`[rpc-relayer/gasRefundOptions] relayer fees are not required`)
       return []
@@ -164,20 +179,17 @@ export class RpcRelayer extends BaseRelayer implements Relayer {
       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 metaTxn = await this.service.sendMetaTxn({
-      call: {
-        contract: prep.to,
-        input: prep.data,
-        walletAddress: addr
-      }
-    })
+    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: { walletAddress, contract, input } })
 
     logger.info(`[rpc-relayer/relay] got relay result ${JSON.stringify(metaTxn)}`)
 

package/src/rpc-relayer/relayer.gen.ts

@@ -1,5 +1,5 @@
 /* eslint-disable */
-// sequence-relayer v0.4.0 1598ae8045a4f054fefc0fa3b244f61f75a7c8bd
+// 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.
@@ -11,7 +11,7 @@ export const WebRPCVersion = 'v1'
 export const WebRPCSchemaVersion = 'v0.4.0'
 
 // Schema hash generated from your RIDL schema
-export const WebRPCSchemaHash = '1598ae8045a4f054fefc0fa3b244f61f75a7c8bd'
+export const WebRPCSchemaHash = '7dbfaf5c04cf28e9259ff1a9bf3274c8d73be5dd'
 
 //
 // Types
@@ -106,6 +106,9 @@ export interface MetaTxnLog {
   txnStatus: ETHTxnStatus
   txnRevertReason: string
   requeues: number
+  queuedAt: string
+  sentAt: string
+  minedAt: string
   target: string
   input: string
   txnArgs: { [key: string]: any }
@@ -229,6 +232,7 @@ export interface Relayer {
   simulate(args: SimulateArgs, headers?: object): Promise<SimulateReturn>
   updateMetaTxnGasLimits(args: UpdateMetaTxnGasLimitsArgs, headers?: object): Promise<UpdateMetaTxnGasLimitsReturn>
   feeTokens(headers?: object): Promise<FeeTokensReturn>
+  feeOptions(args: FeeOptionsArgs, headers?: object): Promise<FeeOptionsReturn>
   getMetaTxnNetworkFeeOptions(args: GetMetaTxnNetworkFeeOptionsArgs, headers?: object): Promise<GetMetaTxnNetworkFeeOptionsReturn>
   sentTransactions(args: SentTransactionsArgs, headers?: object): Promise<SentTransactionsReturn>
   pendingTransactions(args: PendingTransactionsArgs, headers?: object): Promise<PendingTransactionsReturn>
@@ -305,6 +309,15 @@ export interface FeeTokensReturn {
   isFeeRequired: boolean
   tokens: Array<FeeToken>
 }
+export interface FeeOptionsArgs {
+  wallet: string
+  to: string
+  data: string
+}
+
+export interface FeeOptionsReturn {
+  options: Array<FeeOption>
+}
 export interface GetMetaTxnNetworkFeeOptionsArgs {
   walletConfig: WalletConfig
   payload: string
@@ -460,6 +473,16 @@ export class Relayer implements Relayer {
     })
   }
 
+  feeOptions = (args: FeeOptionsArgs, headers?: object): Promise<FeeOptionsReturn> => {
+    return this.fetch(this.url('FeeOptions'), createHTTPRequest(args, headers)).then(res => {
+      return buildResponse(res).then(_data => {
+        return {
+          options: <Array<FeeOption>>_data.options
+        }
+      })
+    })
+  }
+
   getMetaTxnNetworkFeeOptions = (
     args: GetMetaTxnNetworkFeeOptionsArgs,
     headers?: object