@0xsequence/relayer 0.31.0 → 0.35.0

package/dist/declarations/src/index.d.ts

@@ -4,6 +4,7 @@ import { WalletContext } from '@0xsequence/network';
 import { WalletConfig } from '@0xsequence/config';
 import { proto } from './rpc-relayer';
 export interface Relayer {
+    simulate(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]>;
     estimateGasLimits(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<Transaction[]>;
     gasRefundOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<FeeOption[]>;
     getNonce(config: WalletConfig, context: WalletContext, space?: ethers.BigNumberish, blockTag?: providers.BlockTag): Promise<ethers.BigNumberish>;
@@ -15,5 +16,6 @@ export * from './base-relayer';
 export * from './provider-relayer';
 export * from './rpc-relayer';
 export { proto as RpcRelayerProto } from './rpc-relayer';
+export declare type SimulateResult = proto.SimulateResult;
 export declare type FeeOption = proto.FeeOption;
 export declare function isRelayer(cand: any): cand is Relayer;

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

@@ -4,7 +4,7 @@ import { SignedTransactions, Transaction } from '@0xsequence/transactions';
 import { WalletContext } from '@0xsequence/network';
 import { WalletConfig } from '@0xsequence/config';
 import { BaseRelayer, BaseRelayerOptions } from './base-relayer';
-import { FeeOption, Relayer } from '.';
+import { FeeOption, Relayer, SimulateResult } from '.';
 import { Optionals, Mask } from '@0xsequence/utils';
 export interface ProviderRelayerOptions extends BaseRelayerOptions {
     provider: Provider;
@@ -22,6 +22,7 @@ export declare abstract class ProviderRelayer extends BaseRelayer implements Rel
     constructor(options: ProviderRelayerOptions);
     abstract gasRefundOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<FeeOption[]>;
     abstract relay(signedTxs: SignedTransactions): Promise<TransactionResponse>;
+    simulate(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]>;
     estimateGasLimits(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<Transaction[]>;
     getNonce(config: WalletConfig, context: WalletContext, space?: ethers.BigNumberish, blockTag?: BlockTag): Promise<ethers.BigNumberish>;
     wait(metaTxnId: string | SignedTransactions, timeout: number): Promise<providers.TransactionResponse & {

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

@@ -2,7 +2,7 @@ import { TransactionResponse } from '@ethersproject/providers';
 import { ethers } from 'ethers';
 import { Transaction, SignedTransactions } from '@0xsequence/transactions';
 import { BaseRelayer, BaseRelayerOptions } from '../base-relayer';
-import { FeeOption, Relayer } from '..';
+import { FeeOption, Relayer, SimulateResult } from '..';
 import { WalletContext } from '@0xsequence/network';
 import { WalletConfig } from '@0xsequence/config';
 import * as proto from './relayer.gen';
@@ -15,6 +15,7 @@ export declare class RpcRelayer extends BaseRelayer implements Relayer {
     private readonly service;
     constructor(options: RpcRelayerOptions);
     waitReceipt(metaTxnHash: string | SignedTransactions, wait?: number): Promise<proto.GetMetaTxnReceiptReturn>;
+    simulate(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]>;
     estimateGasLimits(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<Transaction[]>;
     gasRefundOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<FeeOption[]>;
     getNonce(config: WalletConfig, context: WalletContext, space?: ethers.BigNumberish): Promise<ethers.BigNumberish>;

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 = "fc9652e2bc0c3df8d1ce0b4a8e24ab8790e4dae2";
+export declare const WebRPCSchemaHash = "7dbfaf5c04cf28e9259ff1a9bf3274c8d73be5dd";
 export declare enum ETHTxnStatus {
     UNKNOWN = "UNKNOWN",
     DROPPED = "DROPPED",
@@ -79,6 +79,10 @@ export interface MetaTxnLog {
     metaTxnID?: string;
     txnStatus: ETHTxnStatus;
     txnRevertReason: string;
+    requeues: number;
+    queuedAt: string;
+    sentAt: string;
+    minedAt: string;
     target: string;
     input: string;
     txnArgs: {
@@ -145,6 +149,14 @@ export interface SentTransactionsFilter {
     pending?: boolean;
     failed?: boolean;
 }
+export interface SimulateResult {
+    executed: boolean;
+    succeeded: boolean;
+    result?: string;
+    reason?: string;
+    gasUsed: number;
+    gasLimit: number;
+}
 export interface FeeOption {
     token: FeeToken;
     to: string;
@@ -184,8 +196,10 @@ export interface Relayer {
     sendMetaTxn(args: SendMetaTxnArgs, headers?: object): Promise<SendMetaTxnReturn>;
     getMetaTxnNonce(args: GetMetaTxnNonceArgs, headers?: object): Promise<GetMetaTxnNonceReturn>;
     getMetaTxnReceipt(args: GetMetaTxnReceiptArgs, headers?: object): Promise<GetMetaTxnReceiptReturn>;
+    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>;
@@ -235,6 +249,13 @@ export interface GetMetaTxnReceiptArgs {
 export interface GetMetaTxnReceiptReturn {
     receipt: MetaTxnReceipt;
 }
+export interface SimulateArgs {
+    wallet: string;
+    transactions: string;
+}
+export interface SimulateReturn {
+    results: Array<SimulateResult>;
+}
 export interface UpdateMetaTxnGasLimitsArgs {
     walletAddress: string;
     walletConfig: WalletConfig;
@@ -249,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;
@@ -285,8 +314,10 @@ export declare class Relayer implements Relayer {
     sendMetaTxn: (args: SendMetaTxnArgs, headers?: object | undefined) => Promise<SendMetaTxnReturn>;
     getMetaTxnNonce: (args: GetMetaTxnNonceArgs, headers?: object | undefined) => Promise<GetMetaTxnNonceReturn>;
     getMetaTxnReceipt: (args: GetMetaTxnReceiptArgs, headers?: object | undefined) => Promise<GetMetaTxnReceiptReturn>;
+    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.31.0",
+  "version": "0.35.0",
   "description": "relayer sub-package for Sequence",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/relayer",
   "source": "src/index.ts",
@@ -17,12 +17,12 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@0xsequence/abi": "^0.31.0",
-    "@0xsequence/config": "^0.31.0",
-    "@0xsequence/transactions": "^0.31.0",
-    "@0xsequence/utils": "^0.31.0",
-    "@ethersproject/providers": "^5.5.0",
-    "ethers": "^5.5.1",
+    "@0xsequence/abi": "^0.35.0",
+    "@0xsequence/config": "^0.35.0",
+    "@0xsequence/transactions": "^0.35.0",
+    "@0xsequence/utils": "^0.35.0",
+    "@ethersproject/providers": "^5.5.1",
+    "ethers": "^5.5.2",
     "fetch-ponyfill": "^7.1.0"
   },
   "peerDependencies": {},

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/index.ts

@@ -5,6 +5,8 @@ import { WalletConfig } from '@0xsequence/config'
 import { proto } from './rpc-relayer'
 
 export interface Relayer {
+  // simulate returns the execution results for a list of transactions.
+  simulate(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]>
 
   // estimateGasLimits will estimate the gas utilization from the transaction
   // before submission.
@@ -39,6 +41,7 @@ export * from './base-relayer'
 export * from './provider-relayer'
 export * from './rpc-relayer'
 export { proto as RpcRelayerProto } from './rpc-relayer'
+export type SimulateResult = proto.SimulateResult
 export type FeeOption = proto.FeeOption
 
 export function isRelayer(cand: any): cand is Relayer {

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/provider-relayer.ts

@@ -5,7 +5,7 @@ import { computeMetaTxnHash, encodeNonce, SignedTransactions, Transaction } from
 import { WalletContext } from '@0xsequence/network'
 import { WalletConfig, addressOf } from '@0xsequence/config'
 import { BaseRelayer, BaseRelayerOptions } from './base-relayer'
-import { FeeOption, Relayer } from '.'
+import { FeeOption, Relayer, SimulateResult } from '.'
 import { Optionals, Mask } from '@0xsequence/utils'
 
 const DEFAULT_GAS_LIMIT = ethers.BigNumber.from(800000)
@@ -45,14 +45,8 @@ export abstract class ProviderRelayer extends BaseRelayer implements Relayer {
   abstract gasRefundOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<FeeOption[]>
   abstract relay(signedTxs: SignedTransactions): Promise<TransactionResponse>
 
-  async estimateGasLimits(
-    config: WalletConfig,
-    context: WalletContext,
-    ...transactions: Transaction[]
-  ): Promise<Transaction[]> {
-    const walletAddr = addressOf(config, context)
-
-    const gasCosts = await Promise.all(transactions.map(async tx => {
+  async simulate(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]> {
+    return (await Promise.all(transactions.map(async 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
@@ -64,7 +58,7 @@ export abstract class ProviderRelayer extends BaseRelayer implements Relayer {
       }
 
       // 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
       }
 
@@ -75,17 +69,27 @@ export abstract class ProviderRelayer extends BaseRelayer implements Relayer {
       // TODO: If the wallet address has been deployed, gas limits can be
       // estimated with more accurately by using self-calls with the batch transactions one by one
       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()
     }))
+  }
 
-    return transactions.map((t, i) => {
-      t.gasLimit = gasCosts[i]
-      return t
-    })
+  async estimateGasLimits(
+    config: WalletConfig,
+    context: WalletContext,
+    ...transactions: Transaction[]
+  ): Promise<Transaction[]> {
+    const walletAddr = addressOf(config, context)
+    const results = await this.simulate(walletAddr, ...transactions)
+    return transactions.map((t, i) => ({ ...t, gasLimit: results[i].gasLimit }))
   }
 
   async getNonce(

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,
@@ -12,9 +13,9 @@ import {
   decodeNonce
 } from '@0xsequence/transactions'
 import { BaseRelayer, BaseRelayerOptions } from '../base-relayer'
-import { FeeOption, Relayer } from '..'
+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'
 
@@ -66,6 +67,12 @@ export class RpcRelayer extends BaseRelayer implements Relayer {
     return result
   }
 
+  async simulate(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]> {
+    const coder = ethers.utils.defaultAbiCoder
+    const encoded = coder.encode([MetaTransactionsType], [sequenceTxAbiEncode(transactions)])
+    return (await this.service.simulate({ wallet, transactions: encoded })).results
+  }
+
   async estimateGasLimits(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<Transaction[]> {
     logger.info(`[rpc-relayer/estimateGasLimits] estimate gas limits request ${JSON.stringify(transactions)}`)
 
@@ -116,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)
+
+      let nonce = readSequenceNonce(...transactions)
+      if (nonce === undefined) {
+        nonce = await this.getNonce(config, context)
+      }
 
-      // Set temporal nonce to simulate meta-txn
-      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: { ...config, address: addr },
-        payload: encoded
+      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 []
@@ -158,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 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.
@@ -11,7 +11,7 @@ export const WebRPCVersion = 'v1'
 export const WebRPCSchemaVersion = 'v0.4.0'
 
 // Schema hash generated from your RIDL schema
-export const WebRPCSchemaHash = 'fc9652e2bc0c3df8d1ce0b4a8e24ab8790e4dae2'
+export const WebRPCSchemaHash = '7dbfaf5c04cf28e9259ff1a9bf3274c8d73be5dd'
 
 //
 // Types
@@ -105,6 +105,10 @@ export interface MetaTxnLog {
   metaTxnID?: string
   txnStatus: ETHTxnStatus
   txnRevertReason: string
+  requeues: number
+  queuedAt: string
+  sentAt: string
+  minedAt: string
   target: string
   input: string
   txnArgs: { [key: string]: any }
@@ -173,6 +177,15 @@ export interface SentTransactionsFilter {
   failed?: boolean
 }
 
+export interface SimulateResult {
+  executed: boolean
+  succeeded: boolean
+  result?: string
+  reason?: string
+  gasUsed: number
+  gasLimit: number
+}
+
 export interface FeeOption {
   token: FeeToken
   to: string
@@ -216,8 +229,10 @@ export interface Relayer {
   sendMetaTxn(args: SendMetaTxnArgs, headers?: object): Promise<SendMetaTxnReturn>
   getMetaTxnNonce(args: GetMetaTxnNonceArgs, headers?: object): Promise<GetMetaTxnNonceReturn>
   getMetaTxnReceipt(args: GetMetaTxnReceiptArgs, headers?: object): Promise<GetMetaTxnReceiptReturn>
+  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>
@@ -271,6 +286,14 @@ export interface GetMetaTxnReceiptArgs {
 export interface GetMetaTxnReceiptReturn {
   receipt: MetaTxnReceipt
 }
+export interface SimulateArgs {
+  wallet: string
+  transactions: string
+}
+
+export interface SimulateReturn {
+  results: Array<SimulateResult>
+}
 export interface UpdateMetaTxnGasLimitsArgs {
   walletAddress: string
   walletConfig: WalletConfig
@@ -286,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
@@ -410,6 +442,16 @@ export class Relayer implements Relayer {
     })
   }
 
+  simulate = (args: SimulateArgs, headers?: object): Promise<SimulateReturn> => {
+    return this.fetch(this.url('Simulate'), createHTTPRequest(args, headers)).then(res => {
+      return buildResponse(res).then(_data => {
+        return {
+          results: <Array<SimulateResult>>_data.results
+        }
+      })
+    })
+  }
+
   updateMetaTxnGasLimits = (args: UpdateMetaTxnGasLimitsArgs, headers?: object): Promise<UpdateMetaTxnGasLimitsReturn> => {
     return this.fetch(this.url('UpdateMetaTxnGasLimits'), createHTTPRequest(args, headers)).then(res => {
       return buildResponse(res).then(_data => {
@@ -431,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