@0xsequence/relayer 0.43.33 → 1.0.0

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

@@ -1,28 +1,33 @@
 import { ethers } from 'ethers';
-import { Transaction, SignedTransactions, TransactionResponse } from '@0xsequence/transactions';
-import { BaseRelayer, BaseRelayerOptions } from '../base-relayer';
 import { FeeOption, FeeQuote, Relayer, SimulateResult } from '..';
-import { WalletContext } from '@0xsequence/network';
-import { WalletConfig } from '@0xsequence/config';
 import * as proto from './relayer.gen';
+import { commons } from '@0xsequence/core';
 export { proto };
-export interface RpcRelayerOptions extends BaseRelayerOptions {
+export interface RpcRelayerOptions {
+    provider: ethers.providers.Provider | {
+        url: string;
+    };
     url: string;
 }
 export declare function isRpcRelayerOptions(obj: any): obj is RpcRelayerOptions;
-export declare class RpcRelayer extends BaseRelayer implements Relayer {
+export declare class RpcRelayer implements Relayer {
     private readonly service;
+    readonly provider: ethers.providers.Provider;
     constructor(options: RpcRelayerOptions);
-    waitReceipt(metaTxnId: string | SignedTransactions, delay?: number, maxFails?: number, isCancelled?: () => boolean): Promise<proto.GetMetaTxnReceiptReturn>;
-    simulate(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]>;
-    getFeeOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<{
+    waitReceipt(metaTxnId: string | commons.transaction.SignedTransactionBundle, delay?: number, maxFails?: number, isCancelled?: () => boolean): Promise<proto.GetMetaTxnReceiptReturn>;
+    simulate(wallet: string, ...transactions: commons.transaction.Transaction[]): Promise<SimulateResult[]>;
+    getFeeOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<{
         options: FeeOption[];
         quote?: FeeQuote;
     }>;
-    gasRefundOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<FeeOption[]>;
-    getNonce(config: WalletConfig, context: WalletContext, space?: ethers.BigNumberish): Promise<ethers.BigNumberish>;
-    relay(signedTxs: SignedTransactions, quote?: FeeQuote, waitForReceipt?: boolean): Promise<TransactionResponse<RelayerTxReceipt>>;
-    wait(metaTxnId: string | SignedTransactions, timeout?: number, delay?: number, maxFails?: number): Promise<TransactionResponse<RelayerTxReceipt>>;
+    getFeeOptionsRaw(entrypoint: string, data: ethers.utils.BytesLike): Promise<{
+        options: FeeOption[];
+        quote?: FeeQuote;
+    }>;
+    gasRefundOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<FeeOption[]>;
+    getNonce(address: string, space?: ethers.BigNumberish): Promise<ethers.BigNumberish>;
+    relay(signedTxs: commons.transaction.IntendedTransactionBundle, quote?: FeeQuote, waitForReceipt?: boolean): Promise<commons.transaction.TransactionResponse<RelayerTxReceipt>>;
+    wait(metaTxnId: string | commons.transaction.SignedTransactionBundle, timeout?: number, delay?: number, maxFails?: number): Promise<commons.transaction.TransactionResponse<RelayerTxReceipt>>;
 }
 export type RelayerTxReceipt = {
     blockHash: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/relayer",
-  "version": "0.43.33",
+  "version": "1.0.0",
   "description": "relayer sub-package for Sequence",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/relayer",
   "source": "src/index.ts",
@@ -9,18 +9,18 @@
   "author": "Horizon Blockchain Games",
   "license": "Apache-2.0",
   "dependencies": {
-    "@0xsequence/abi": "^0.43.33",
-    "@0xsequence/config": "^0.43.33",
-    "@0xsequence/network": "^0.43.33",
-    "@0xsequence/transactions": "^0.43.33",
-    "@0xsequence/utils": "^0.43.33"
+    "@0xsequence/abi": "1.0.0",
+    "@0xsequence/utils": "1.0.0",
+    "@0xsequence/core": "1.0.0"
   },
   "peerDependencies": {
     "ethers": ">=5.5 < 6"
   },
   "devDependencies": {
-    "@0xsequence/wallet-contracts": "1.10.0",
-    "ethers": "^5.7.2"
+    "@0xsequence/wallet-contracts": "^1.10.0",
+    "ethers": "^5.7.2",
+    "@0xsequence/signhub": "1.0.0",
+    "@0xsequence/tests": "1.0.0"
   },
   "files": [
     "src",

package/src/index.ts

@@ -1,48 +1,52 @@
 import { ethers, providers } from 'ethers'
-import { SignedTransactions, Transaction, TransactionResponse } from '@0xsequence/transactions'
-import { WalletContext } from '@0xsequence/network'
-import { WalletConfig } from '@0xsequence/config'
 import { proto } from './rpc-relayer'
 
+import { commons } from '@0xsequence/core'
+
 export interface Relayer {
   // simulate returns the execution results for a list of transactions.
-  simulate(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]>
+  simulate(wallet: string, ...transactions: commons.transaction.Transaction[]): Promise<SimulateResult[]>
 
   // getFeeOptions returns the fee options that the relayer will accept as payment.
   // If a quote is returned, it may be passed back to the relayer for dispatch.
   getFeeOptions(
-    config: WalletConfig,
-    context: WalletContext,
-    ...transactions: Transaction[]
+    address: string,
+    ...transactions: commons.transaction.Transaction[]
   ): Promise<{ options: FeeOption[], quote?: FeeQuote }>
 
+  // getFeeOptionsRaw returns the fee options that the relayer will accept as payment.
+  // If a quote is returned, it may be passed back to the relayer for dispatch.
+  // It doesn't make any assumptions about the transaction format.
+  getFeeOptionsRaw(
+    entrypoint: string,
+    data: ethers.utils.BytesLike
+  ): Promise<{ options: FeeOption[]; quote?: FeeQuote }>
+
   // gasRefundOptions returns the transactions which can be included to refund a
   // relayer for submitting your transaction to a network.
   gasRefundOptions(
-    config: WalletConfig,
-    context: WalletContext,
-    ...transactions: Transaction[]
+    address: string,
+    ...transactions: commons.transaction.Transaction[]
   ): Promise<FeeOption[]>
 
   // getNonce returns the transaction count/nonce for a wallet, encoded with nonce space.
   // If space is undefined, the relayer can choose a nonce space to encode the result with.
   // Otherwise, the relayer must return a nonce encoded for the given nonce space.
-  getNonce(config: WalletConfig, context: WalletContext, space?: ethers.BigNumberish, blockTag?: providers.BlockTag): Promise<ethers.BigNumberish>
+  getNonce(address: string, space?: ethers.BigNumberish, blockTag?: providers.BlockTag): Promise<ethers.BigNumberish>
 
   // relayer will submit the transaction(s) to the network and return the transaction response.
   // The quote should be the one returned from getFeeOptions, if any.
   // waitForReceipt must default to true.
-  relay(signedTxs: SignedTransactions, quote?: FeeQuote, waitForReceipt?: boolean): Promise<TransactionResponse>
+  relay(signedTxs: commons.transaction.IntendedTransactionBundle, quote?: FeeQuote, waitForReceipt?: boolean): Promise<commons.transaction.TransactionResponse>
 
   // wait for transaction confirmation
   // timeout is the maximum time to wait for the transaction response
   // delay is the polling interval, i.e. the time to wait between requests
   // maxFails is the maximum number of hard failures to tolerate before giving up
-  wait(metaTxnId: string | SignedTransactions, timeout?: number, delay?: number, maxFails?: number): Promise<TransactionResponse>
+  wait(metaTxnId: string | commons.transaction.SignedTransactionBundle, timeout?: number, delay?: number, maxFails?: number): Promise<commons.transaction.TransactionResponse>
 }
 
 export * from './local-relayer'
-export * from './base-relayer'
 export * from './provider-relayer'
 export * from './rpc-relayer'
 export { proto as RpcRelayerProto } from './rpc-relayer'

package/src/local-relayer.ts

@@ -1,11 +1,8 @@
-import { Signer as AbstractSigner, ethers, providers } from 'ethers'
-import { walletContracts } from '@0xsequence/abi'
-import { SignedTransactions, Transaction, sequenceTxAbiEncode, TransactionResponse } from '@0xsequence/transactions'
-import { WalletContext } from '@0xsequence/network'
-import { WalletConfig } from '@0xsequence/config'
+import { Signer as AbstractSigner, providers, BytesLike } from 'ethers'
 import { logger } from '@0xsequence/utils'
 import { FeeOption, FeeQuote, Relayer } from '.'
 import { ProviderRelayer, ProviderRelayerOptions } from './provider-relayer'
+import { commons } from '@0xsequence/core'
 
 export type LocalRelayerOptions = Omit<ProviderRelayerOptions, "provider"> & {
   signer: AbstractSigner
@@ -25,30 +22,22 @@ export class LocalRelayer extends ProviderRelayer implements Relayer {
     if (!this.signer.provider) throw new Error("Signer must have a provider")
   }
 
-  async deployWallet(config: WalletConfig, context: WalletContext): Promise<TransactionResponse> {
-    // NOTE: on hardhat some tests fail on HookCallerMock when not passing gasLimit directly as below,
-    // and using eth_gasEstimate. Perhaps review HookCallerMock.sol and fix it to avoid what looks
-    // like an infinite loop?
-    const walletDeployTxn = this.prepareWalletDeploy(config, context)
-
-    // NOTE: for hardhat to pass, we have to set the gasLimit directly, as its unable to estimate
-    return this.signer.sendTransaction({ ...walletDeployTxn, gasLimit: ethers.constants.Two.pow(17) } )
-  }
-
   async getFeeOptions(
-    _config: WalletConfig,
-    _context: WalletContext,
-    ..._transactions: Transaction[]
+    _address: string,
+    ..._transactions: commons.transaction.Transaction[]
   ): Promise<{ options: FeeOption[] }> {
     return { options: [] }
   }
 
+  async getFeeOptionsRaw(_entrypoint: string, _data: BytesLike): Promise<{ options: FeeOption[] }> {
+    return { options: [] }
+  }
+
   async gasRefundOptions(
-    config: WalletConfig,
-    context: WalletContext,
-    ...transactions: Transaction[]
+    address: string,
+    ...transactions:commons.transaction.Transaction[]
   ): Promise<FeeOption[]> {
-    const { options } = await this.getFeeOptions(config, context, ...transactions)
+    const { options } = await this.getFeeOptions(address, ...transactions)
     return options
   }
 
@@ -56,33 +45,30 @@ export class LocalRelayer extends ProviderRelayer implements Relayer {
     this.txnOptions = transactionRequest
   }
 
-  async relay(signedTxs: SignedTransactions, quote?: FeeQuote, waitForReceipt: boolean = true): Promise<TransactionResponse<providers.TransactionReceipt>> {
+  async relay(
+    signedTxs: commons.transaction.IntendedTransactionBundle,
+    quote?: FeeQuote, waitForReceipt: boolean = true
+  ): Promise<commons.transaction.TransactionResponse<providers.TransactionReceipt>> {
     if (quote !== undefined) {
       logger.warn(`LocalRelayer doesn't accept fee quotes`)
     }
-
-    if (!signedTxs.context.guestModule || signedTxs.context.guestModule.length !== 42) {
-      throw new Error('LocalRelayer requires the context.guestModule address')
-    }
-
-    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
-    ])
+  
+    const data = commons.transaction.encodeBundleExecData(signedTxs)
 
     // 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
 
-    const responsePromise = this.signer.sendTransaction({ to, data, ...this.txnOptions })
+    const responsePromise = this.signer.sendTransaction({
+      to: signedTxs.entrypoint,
+      data,
+      ...this.txnOptions,
+      gasLimit: 9000000
+    })
 
     if (waitForReceipt) {
-      const response: TransactionResponse = await responsePromise
+      const response: commons.transaction.TransactionResponse = await responsePromise
       response.receipt = await response.wait()
       return response
     } else {

package/src/provider-relayer.ts

@@ -1,22 +1,19 @@
 import { ethers, providers } from 'ethers'
 import { walletContracts } from '@0xsequence/abi'
-import { computeMetaTxnHash, encodeNonce, SignedTransactions, Transaction, TransactionResponse } from '@0xsequence/transactions'
-import { WalletContext } from '@0xsequence/network'
-import { WalletConfig, addressOf } from '@0xsequence/config'
-import { BaseRelayer, BaseRelayerOptions } from './base-relayer'
 import { FeeOption, FeeQuote, Relayer, SimulateResult } from '.'
-import { logger, Optionals, Mask } from '@0xsequence/utils'
+import { logger, Optionals } from '@0xsequence/utils'
+import { commons } from '@0xsequence/core'
 
 const DEFAULT_GAS_LIMIT = ethers.BigNumber.from(800000)
 
-export interface ProviderRelayerOptions extends BaseRelayerOptions {
+export interface ProviderRelayerOptions {
   provider: providers.Provider,
   waitPollRate?: number,
   deltaBlocksLog?: number,
   fromBlockLog?: number
 }
 
-export const ProviderRelayerDefaults: Required<Optionals<Mask<ProviderRelayerOptions, BaseRelayerOptions>>> = {
+export const ProviderRelayerDefaults: Required<Optionals<ProviderRelayerOptions>> = {
   waitPollRate: 1000,
   deltaBlocksLog: 12,
   fromBlockLog: -1024
@@ -26,36 +23,35 @@ export function isProviderRelayerOptions(obj: any): obj is ProviderRelayerOption
   return obj.provider !== undefined && providers.Provider.isProvider(obj.provider)
 }
 
-export abstract class ProviderRelayer extends BaseRelayer implements Relayer {
+export abstract class ProviderRelayer implements Relayer {
   public provider: providers.Provider
   public waitPollRate: number
   public deltaBlocksLog: number
   public fromBlockLog: number
 
   constructor(options: ProviderRelayerOptions) {
-    super(options)
     const opts = { ...ProviderRelayerDefaults, ...options }
     this.provider = opts.provider
-    this.waitPollRate = opts.waitPollRate
-    this.deltaBlocksLog = opts.deltaBlocksLog
-    this.fromBlockLog = opts.fromBlockLog
   }
 
   abstract getFeeOptions(
-    config: WalletConfig,
-    context: WalletContext,
-    ...transactions: Transaction[]
+    address: string,
+    ...transactions: commons.transaction.Transaction[]
+  ): Promise<{ options: FeeOption[], quote?: FeeQuote }>
+
+  abstract getFeeOptionsRaw(
+    entrypoint: string,
+    data: ethers.utils.BytesLike
   ): Promise<{ options: FeeOption[], quote?: FeeQuote }>
 
   abstract gasRefundOptions(
-    config: WalletConfig,
-    context: WalletContext,
-    ...transactions: Transaction[]
+    address: string,
+    ...transactions: commons.transaction.Transaction[]
   ): Promise<FeeOption[]>
 
-  abstract relay(signedTxs: SignedTransactions, quote?: FeeQuote, waitForReceipt?: boolean): Promise<TransactionResponse>
+  abstract relay(signedTxs: commons.transaction.IntendedTransactionBundle, quote?: FeeQuote, waitForReceipt?: boolean): Promise<commons.transaction.TransactionResponse>
 
-  async simulate(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]> {
+  async simulate(wallet: string, ...transactions: commons.transaction.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)) {
@@ -68,7 +64,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 === wallet && !(await this.isWalletDeployed(wallet))) {
+      if (tx.to === wallet && await this.provider.getCode(wallet).then((code) => ethers.utils.arrayify(code).length === 0)) {
         return DEFAULT_GAS_LIMIT
       }
 
@@ -93,8 +89,7 @@ export abstract class ProviderRelayer extends BaseRelayer implements Relayer {
   }
 
   async getNonce(
-    config: WalletConfig,
-    context: WalletContext,
+    address: string,
     space?: ethers.BigNumberish,
     blockTag?: providers.BlockTag
   ): Promise<ethers.BigNumberish> {
@@ -102,9 +97,7 @@ export abstract class ProviderRelayer extends BaseRelayer implements Relayer {
       throw new Error('provider is not set')
     }
 
-    const addr = addressOf(config, context)
-
-    if ((await this.provider.getCode(addr)) === '0x') {
+    if ((await this.provider.getCode(address)) === '0x') {
       return 0
     }
 
@@ -112,21 +105,19 @@ export abstract class ProviderRelayer extends BaseRelayer implements Relayer {
       space = 0
     }
 
-    const module = new ethers.Contract(addr, walletContracts.mainModule.abi, this.provider)
+    const module = new ethers.Contract(address, walletContracts.mainModule.abi, this.provider)
     const nonce = await module.readNonce(space, { blockTag: blockTag })
-    return encodeNonce(space, nonce)
+    return commons.transaction.encodeNonce(space, nonce)
   }
 
   async wait(
-    metaTxnId: string | SignedTransactions,
+    metaTxnId: string | commons.transaction.SignedTransactionBundle,
     timeout?: number,
     delay: number = this.waitPollRate,
     maxFails: number = 5
   ): Promise<providers.TransactionResponse & { receipt: providers.TransactionReceipt }> {
     if (typeof metaTxnId !== 'string') {
-      logger.info('computing id', metaTxnId.config, metaTxnId.context, metaTxnId.chainId, ...metaTxnId.transactions)
-
-      metaTxnId = computeMetaTxnHash(addressOf(metaTxnId.config, metaTxnId.context), metaTxnId.chainId, ...metaTxnId.transactions)
+      metaTxnId = commons.transaction.intendedTransactionID(metaTxnId)
     }
 
     let timedOut = false

package/src/rpc-relayer/index.ts

@@ -1,22 +1,8 @@
 import { ethers } from 'ethers'
-import { walletContracts } from '@0xsequence/abi'
-import {
-  Transaction,
-  readSequenceNonce,
-  appendNonce,
-  MetaTransactionsType,
-  sequenceTxAbiEncode,
-  SignedTransactions,
-  computeMetaTxnHash,
-  decodeNonce,
-  TransactionResponse
-} from '@0xsequence/transactions'
-import { BaseRelayer, BaseRelayerOptions } from '../base-relayer'
 import { FeeOption, FeeQuote, Relayer, SimulateResult } from '..'
-import { WalletContext } from '@0xsequence/network'
-import { WalletConfig, addressOf, buildStubSignature } from '@0xsequence/config'
-import { logger } from '@0xsequence/utils'
 import * as proto from './relayer.gen'
+import { commons } from '@0xsequence/core'
+import { getDefaultConnectionInfo, logger } from '@0xsequence/utils'
 
 export { proto }
 
@@ -29,34 +15,41 @@ const FINAL_STATUSES = [
 
 const FAILED_STATUSES = [proto.ETHTxnStatus.DROPPED, proto.ETHTxnStatus.PARTIALLY_FAILED, proto.ETHTxnStatus.FAILED]
 
-export interface RpcRelayerOptions extends BaseRelayerOptions {
+export interface RpcRelayerOptions {
+  provider: ethers.providers.Provider | { url: string }
   url: string
 }
 
 export function isRpcRelayerOptions(obj: any): obj is RpcRelayerOptions {
-  return obj.url !== undefined && typeof obj.url === 'string'
+  return (
+    obj.url !== undefined &&
+    typeof obj.url === 'string' &&
+    obj.provider !== undefined &&
+    ethers.providers.Provider.isProvider(obj.provider)
+  )
 }
 
 const fetch = typeof global === 'object' ? global.fetch : window.fetch
 
-export class RpcRelayer extends BaseRelayer implements Relayer {
+export class RpcRelayer implements Relayer {
   private readonly service: proto.Relayer
+  public readonly provider: ethers.providers.Provider
 
   constructor(options: RpcRelayerOptions) {
-    super(options)
     this.service = new proto.Relayer(options.url, fetch)
+    this.provider = ethers.providers.Provider.isProvider(options.provider)
+      ? options.provider
+      : new ethers.providers.StaticJsonRpcProvider(getDefaultConnectionInfo(options.provider.url))
   }
 
   async waitReceipt(
-    metaTxnId: string | SignedTransactions,
+    metaTxnId: string | commons.transaction.SignedTransactionBundle,
     delay: number = 1000,
     maxFails: number = 5,
     isCancelled?: () => boolean
   ): Promise<proto.GetMetaTxnReceiptReturn> {
     if (typeof metaTxnId !== 'string') {
-      logger.info('computing id', metaTxnId.config, metaTxnId.context, metaTxnId.chainId, ...metaTxnId.transactions)
-
-      metaTxnId = computeMetaTxnHash(addressOf(metaTxnId.config, metaTxnId.context), metaTxnId.chainId, ...metaTxnId.transactions)
+      metaTxnId = commons.transaction.intendedTransactionID(metaTxnId)
     }
 
     logger.info(`[rpc-relayer/waitReceipt] waiting for ${metaTxnId}`)
@@ -91,16 +84,18 @@ export class RpcRelayer extends BaseRelayer implements Relayer {
     throw new Error(`Cancelled waiting for transaction receipt ${metaTxnId}`)
   }
 
-  async simulate(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]> {
+  async simulate(wallet: string, ...transactions: commons.transaction.Transaction[]): Promise<SimulateResult[]> {
     const coder = ethers.utils.defaultAbiCoder
-    const encoded = coder.encode([MetaTransactionsType], [sequenceTxAbiEncode(transactions)])
+    const encoded = coder.encode(
+      [commons.transaction.MetaTransactionsType],
+      [commons.transaction.sequenceTxAbiEncode(transactions)]
+    )
     return (await this.service.simulate({ wallet, transactions: encoded })).results
   }
 
   async getFeeOptions(
-    config: WalletConfig,
-    context: WalletContext,
-    ...transactions: Transaction[]
+    address: string,
+    ...transactions: commons.transaction.Transaction[]
   ): Promise<{ options: FeeOption[]; quote?: FeeQuote }> {
     // NOTE/TODO: for a given `service` the feeTokens will not change between execution, so we should memoize this value
     // for a short-period of time, perhaps for 1 day or in memory. Perhaps one day we can make this happen automatically
@@ -111,35 +106,23 @@ export class RpcRelayer extends BaseRelayer implements Relayer {
       const symbols = feeTokens.tokens.map(token => token.symbol).join(', ')
       logger.info(`[rpc-relayer/getFeeOptions] relayer fees are required, accepted tokens are ${symbols}`)
 
-      const wallet = addressOf(config, context)
-
-      let nonce = readSequenceNonce(...transactions)
-      if (nonce === undefined) {
-        nonce = await this.getNonce(config, context)
-      }
+      const nonce = await this.getNonce(address)
 
       if (!this.provider) {
         logger.warn(`[rpc-relayer/getFeeOptions] 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)
+      const { options, quote } = await this.service.feeOptions({
+        wallet: address,
+        to: address,
+        data: commons.transaction.encodeBundleExecData({
+          entrypoint: address,
+          transactions,
+          nonce
+        })
       })
 
-      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, quote } = await this.service.feeOptions({ wallet, to, data })
-
       logger.info(`[rpc-relayer/getFeeOptions] got refund options ${JSON.stringify(options)}`)
       return { options, quote: { _tag: 'FeeQuote', _quote: quote } }
     } else {
@@ -148,27 +131,36 @@ export class RpcRelayer extends BaseRelayer implements Relayer {
     }
   }
 
-  async gasRefundOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<FeeOption[]> {
-    const { options } = await this.getFeeOptions(config, context, ...transactions)
+  async getFeeOptionsRaw(entrypoint: string, data: ethers.utils.BytesLike): Promise<{ options: FeeOption[]; quote?: FeeQuote }> {
+    const { options, quote } = await this.service.feeOptions({
+      wallet: entrypoint,
+      to: entrypoint,
+      data: ethers.utils.hexlify(data)
+    })
+
+    return { options, quote: { _tag: 'FeeQuote', _quote: quote } }
+  }
+
+  async gasRefundOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<FeeOption[]> {
+    const { options } = await this.getFeeOptions(address, ...transactions)
     return options
   }
 
-  async getNonce(config: WalletConfig, context: WalletContext, space?: ethers.BigNumberish): Promise<ethers.BigNumberish> {
-    const addr = addressOf(config, context)
-    logger.info(`[rpc-relayer/getNonce] get nonce for wallet ${addr} space: ${space}`)
+  async getNonce(address: string, space?: ethers.BigNumberish): Promise<ethers.BigNumberish> {
+    logger.info(`[rpc-relayer/getNonce] get nonce for wallet ${address} space: ${space}`)
     const encodedNonce = space !== undefined ? ethers.BigNumber.from(space).toHexString() : undefined
-    const resp = await this.service.getMetaTxnNonce({ walletContractAddress: addr, space: encodedNonce })
+    const resp = await this.service.getMetaTxnNonce({ walletContractAddress: address, space: encodedNonce })
     const nonce = ethers.BigNumber.from(resp.nonce)
-    const [decodedSpace, decodedNonce] = decodeNonce(nonce)
-    logger.info(`[rpc-relayer/getNonce] got next nonce for wallet ${addr} ${decodedNonce} space: ${decodedSpace}`)
+    const [decodedSpace, decodedNonce] = commons.transaction.decodeNonce(nonce)
+    logger.info(`[rpc-relayer/getNonce] got next nonce for wallet ${address} ${decodedNonce} space: ${decodedSpace}`)
     return nonce
   }
 
   async relay(
-    signedTxs: SignedTransactions,
+    signedTxs: commons.transaction.IntendedTransactionBundle,
     quote?: FeeQuote,
     waitForReceipt: boolean = true
-  ): Promise<TransactionResponse<RelayerTxReceipt>> {
+  ): Promise<commons.transaction.TransactionResponse<RelayerTxReceipt>> {
     logger.info(
       `[rpc-relayer/relay] relaying signed meta-transactions ${JSON.stringify(signedTxs)} with quote ${JSON.stringify(quote)}`
     )
@@ -187,27 +179,25 @@ export class RpcRelayer extends BaseRelayer implements Relayer {
       throw new Error('provider is not set')
     }
 
-    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 }, quote: typecheckedQuote })
+    const data = commons.transaction.encodeBundleExecData(signedTxs)
+    const metaTxn = await this.service.sendMetaTxn({
+      call: {
+        walletAddress: signedTxs.intent.wallet,
+        contract: signedTxs.entrypoint,
+        input: data
+      },
+      quote: typecheckedQuote
+    })
 
     logger.info(`[rpc-relayer/relay] got relay result ${JSON.stringify(metaTxn)}`)
 
     if (waitForReceipt) {
-      return this.wait(metaTxn.txnHash)
+      return this.wait(signedTxs.intent.id)
     } else {
       const response = {
-        hash: metaTxn.txnHash,
+        hash: signedTxs.intent.id,
         confirmations: 0,
-        from: walletAddress,
+        from: signedTxs.intent.wallet,
         wait: (_confirmations?: number): Promise<ethers.providers.TransactionReceipt> => Promise.reject(new Error('impossible'))
       }
 
@@ -216,7 +206,7 @@ export class RpcRelayer extends BaseRelayer implements Relayer {
           throw new Error('cannot wait for receipt, relayer has no provider set')
         }
 
-        const waitResponse = await this.wait(metaTxn.txnHash)
+        const waitResponse = await this.wait(signedTxs.intent.id)
         const transactionHash = waitResponse.receipt?.transactionHash
 
         if (!transactionHash) {
@@ -230,16 +220,16 @@ export class RpcRelayer extends BaseRelayer implements Relayer {
 
       response.wait = wait
 
-      return response as TransactionResponse
+      return response as commons.transaction.TransactionResponse
     }
   }
 
   async wait(
-    metaTxnId: string | SignedTransactions,
+    metaTxnId: string | commons.transaction.SignedTransactionBundle,
     timeout?: number,
     delay: number = 1000,
     maxFails: number = 5
-  ): Promise<TransactionResponse<RelayerTxReceipt>> {
+  ): Promise<commons.transaction.TransactionResponse<RelayerTxReceipt>> {
     let timedOut = false
 
     const { receipt } = await (timeout !== undefined
@@ -264,12 +254,12 @@ export class RpcRelayer extends BaseRelayer implements Relayer {
       blockHash: txReceipt.blockHash,
       blockNumber: ethers.BigNumber.from(txReceipt.blockNumber).toNumber(),
       confirmations: 1,
-      from: typeof metaTxnId === 'string' ? undefined : addressOf(metaTxnId.config, metaTxnId.context),
+      from: typeof metaTxnId === 'string' ? undefined : metaTxnId.intent.wallet,
       hash: txReceipt.transactionHash,
       raw: receipt.txnReceipt,
       receipt: txReceipt, // extended type which is Sequence-specific. Contains the decoded metaTxReceipt
       wait: async (confirmations?: number) => this.provider!.waitForTransaction(txReceipt.transactionHash, confirmations)
-    } as TransactionResponse
+    } as commons.transaction.TransactionResponse
   }
 }