@0xsequence/relayer 0.43.34 → 1.0.1

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

@@ -1,8 +1,7 @@
-import { ethers, providers, utils, Signer } from 'ethers';
+import { ethers, providers, Signer } from 'ethers';
+import { logger, getDefaultConnectionInfo } from '@0xsequence/utils';
 import { walletContracts } from '@0xsequence/abi';
-import { sequenceTxAbiEncode, readSequenceNonce, encodeNonce, computeMetaTxnHash, MetaTransactionsType, decodeNonce } from '@0xsequence/transactions';
-import { isBigNumberish, logger } from '@0xsequence/utils';
-import { imageHash, addressOf, encodeSignature, buildStubSignature } from '@0xsequence/config';
+import { commons } from '@0xsequence/core';
 
 function _extends() {
   _extends = Object.assign ? Object.assign.bind() : function (target) {
@@ -19,105 +18,6 @@ function _extends() {
   return _extends.apply(this, arguments);
 }
 
-function isBaseRelayerOptions(obj) {
-  return obj.bundleCreation !== undefined && typeof obj.bundleCreation === 'boolean' || obj.creationGasLimit !== undefined && isBigNumberish(obj.creationGasLimit) || obj.provider !== undefined && (providers.Provider.isProvider(obj.provider) || typeof obj.provider === 'string');
-}
-const BaseRelayerDefaults = {
-  bundleCreation: true,
-  creationGasLimit: ethers.constants.Two.pow(17)
-};
-class BaseRelayer {
-  constructor(options) {
-    this.provider = void 0;
-    this.bundleCreation = void 0;
-    this.creationGasLimit = void 0;
-    const opts = _extends({}, BaseRelayerDefaults, options);
-    this.bundleCreation = opts.bundleCreation;
-    this.provider = opts.provider;
-    this.creationGasLimit = ethers.BigNumber.from(opts.creationGasLimit);
-  }
-  async isWalletDeployed(walletAddress) {
-    if (!this.provider) throw new Error('Bundled creation provider not found');
-    return (await this.provider.getCode(walletAddress)) !== '0x';
-  }
-  prepareWalletDeploy(config, context) {
-    const factoryInterface = new utils.Interface(walletContracts.factory.abi);
-    return {
-      to: context.factory,
-      data: factoryInterface.encodeFunctionData(factoryInterface.getFunction('deploy'), [context.mainModule, imageHash(config)])
-    };
-  }
-  async prependWalletDeploy(signedTransactions) {
-    const {
-      config,
-      context,
-      transactions,
-      nonce,
-      signature
-    } = signedTransactions;
-    const walletAddress = addressOf(config, context);
-    const walletInterface = new utils.Interface(walletContracts.mainModule.abi);
-    const encodedSignature = async function () {
-      const sig = await signature;
-      if (typeof sig === 'string') return sig;
-      return encodeSignature(sig);
-    }();
-    if (this.bundleCreation && !(await this.isWalletDeployed(walletAddress))) {
-      return {
-        to: context.guestModule,
-        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,
-        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 utils.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);
 const ProviderRelayerDefaults = {
   waitPollRate: 1000,
@@ -127,18 +27,10 @@ const ProviderRelayerDefaults = {
 function isProviderRelayerOptions(obj) {
   return obj.provider !== undefined && providers.Provider.isProvider(obj.provider);
 }
-class ProviderRelayer extends BaseRelayer {
+class ProviderRelayer {
   constructor(options) {
-    super(options);
-    this.provider = void 0;
-    this.waitPollRate = void 0;
-    this.deltaBlocksLog = void 0;
-    this.fromBlockLog = void 0;
     const opts = _extends({}, ProviderRelayerDefaults, options);
     this.provider = opts.provider;
-    this.waitPollRate = opts.waitPollRate;
-    this.deltaBlocksLog = opts.deltaBlocksLog;
-    this.fromBlockLog = opts.fromBlockLog;
   }
   async simulate(wallet, ...transactions) {
     var _this = this;
@@ -154,7 +46,7 @@ class ProviderRelayer extends BaseRelayer {
       }
 
       // 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;
       }
       if (!_this.provider) {
@@ -176,28 +68,26 @@ class ProviderRelayer extends BaseRelayer {
       gasLimit: ethers.BigNumber.from(gasLimit).toNumber()
     }));
   }
-  async getNonce(config, context, space, blockTag) {
+  async getNonce(address, space, blockTag) {
     if (!this.provider) {
       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;
     }
     if (space === undefined) {
       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, timeout, delay = this.waitPollRate, maxFails = 5) {
     var _this2 = this;
     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;
     const retry = async function retry(f, errorMessage) {
@@ -285,31 +175,23 @@ class LocalRelayer extends ProviderRelayer {
     } : _extends({}, options, {
       provider: options.signer.provider
     }));
-    this.signer = void 0;
-    this.txnOptions = void 0;
     this.signer = Signer.isSigner(options) ? options : options.signer;
     if (!this.signer.provider) throw new Error("Signer must have a provider");
   }
-  async deployWallet(config, context) {
-    // 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(_extends({}, walletDeployTxn, {
-      gasLimit: ethers.constants.Two.pow(17)
-    }));
+  async getFeeOptions(_address, ..._transactions) {
+    return {
+      options: []
+    };
   }
-  async getFeeOptions(_config, _context, ..._transactions) {
+  async getFeeOptionsRaw(_entrypoint, _data) {
     return {
       options: []
     };
   }
-  async gasRefundOptions(config, context, ...transactions) {
+  async gasRefundOptions(address, ...transactions) {
     const {
       options
-    } = await this.getFeeOptions(config, context, ...transactions);
+    } = await this.getFeeOptions(address, ...transactions);
     return options;
   }
   setTransactionOptions(transactionRequest) {
@@ -319,15 +201,7 @@ class LocalRelayer extends ProviderRelayer {
     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
@@ -335,9 +209,11 @@ class LocalRelayer extends ProviderRelayer {
     // txRequest.gasLimit = gasLimit
 
     const responsePromise = this.signer.sendTransaction(_extends({
-      to,
+      to: signedTxs.entrypoint,
       data
-    }, this.txnOptions));
+    }, this.txnOptions, {
+      gasLimit: 9000000
+    }));
     if (waitForReceipt) {
       const response = await responsePromise;
       response.receipt = await response.wait();
@@ -368,8 +244,7 @@ const WebRPCSchemaHash = "752f4f4274ca80d2fd974b5b44ed8245dfe40554";
 // Types
 //
 
-let ETHTxnStatus;
-(function (ETHTxnStatus) {
+let ETHTxnStatus = /*#__PURE__*/function (ETHTxnStatus) {
   ETHTxnStatus["UNKNOWN"] = "UNKNOWN";
   ETHTxnStatus["DROPPED"] = "DROPPED";
   ETHTxnStatus["QUEUED"] = "QUEUED";
@@ -377,34 +252,33 @@ let ETHTxnStatus;
   ETHTxnStatus["SUCCEEDED"] = "SUCCEEDED";
   ETHTxnStatus["PARTIALLY_FAILED"] = "PARTIALLY_FAILED";
   ETHTxnStatus["FAILED"] = "FAILED";
-})(ETHTxnStatus || (ETHTxnStatus = {}));
-let TransferType;
-(function (TransferType) {
+  return ETHTxnStatus;
+}({});
+let TransferType = /*#__PURE__*/function (TransferType) {
   TransferType["SEND"] = "SEND";
   TransferType["RECEIVE"] = "RECEIVE";
   TransferType["BRIDGE_DEPOSIT"] = "BRIDGE_DEPOSIT";
   TransferType["BRIDGE_WITHDRAW"] = "BRIDGE_WITHDRAW";
   TransferType["BURN"] = "BURN";
   TransferType["UNKNOWN"] = "UNKNOWN";
-})(TransferType || (TransferType = {}));
-let FeeTokenType;
-(function (FeeTokenType) {
+  return TransferType;
+}({});
+let FeeTokenType = /*#__PURE__*/function (FeeTokenType) {
   FeeTokenType["UNKNOWN"] = "UNKNOWN";
   FeeTokenType["ERC20_TOKEN"] = "ERC20_TOKEN";
   FeeTokenType["ERC1155_TOKEN"] = "ERC1155_TOKEN";
-})(FeeTokenType || (FeeTokenType = {}));
-let SortOrder;
-(function (SortOrder) {
+  return FeeTokenType;
+}({});
+let SortOrder = /*#__PURE__*/function (SortOrder) {
   SortOrder["DESC"] = "DESC";
   SortOrder["ASC"] = "ASC";
-})(SortOrder || (SortOrder = {}));
+  return SortOrder;
+}({});
 //
 // Client
 //
 class Relayer {
   constructor(hostname, fetch) {
-    this.hostname = void 0;
-    this.fetch = void 0;
     this.path = '/rpc/Relayer/';
     this.ping = headers => {
       return this.fetch(this.url('Ping'), createHTTPRequest({}, headers)).then(res => {
@@ -626,29 +500,27 @@ var relayer_gen = /*#__PURE__*/Object.freeze({
   WebRPCVersion: WebRPCVersion,
   WebRPCSchemaVersion: WebRPCSchemaVersion,
   WebRPCSchemaHash: WebRPCSchemaHash,
-  get ETHTxnStatus () { return ETHTxnStatus; },
-  get TransferType () { return TransferType; },
-  get FeeTokenType () { return FeeTokenType; },
-  get SortOrder () { return SortOrder; },
+  ETHTxnStatus: ETHTxnStatus,
+  TransferType: TransferType,
+  FeeTokenType: FeeTokenType,
+  SortOrder: SortOrder,
   Relayer: Relayer
 });
 
 const FINAL_STATUSES = [ETHTxnStatus.DROPPED, ETHTxnStatus.SUCCEEDED, ETHTxnStatus.PARTIALLY_FAILED, ETHTxnStatus.FAILED];
 const FAILED_STATUSES = [ETHTxnStatus.DROPPED, ETHTxnStatus.PARTIALLY_FAILED, ETHTxnStatus.FAILED];
 function isRpcRelayerOptions(obj) {
-  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;
-class RpcRelayer extends BaseRelayer {
+class RpcRelayer {
   constructor(options) {
-    super(options);
-    this.service = void 0;
     this.service = new 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, delay = 1000, maxFails = 5, isCancelled) {
     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}`);
     let fails = 0;
@@ -678,13 +550,13 @@ class RpcRelayer extends BaseRelayer {
   }
   async simulate(wallet, ...transactions) {
     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, context, ...transactions) {
+  async getFeeOptions(address, ...transactions) {
     // 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
     // with http cache response for this endpoint and service-worker.. lots of approaches
@@ -692,34 +564,22 @@ class RpcRelayer extends BaseRelayer {
     if (feeTokens.isFeeRequired) {
       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 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
+        wallet: address,
+        to: address,
+        data: commons.transaction.encodeBundleExecData({
+          entrypoint: address,
+          transactions,
+          nonce
+        })
       });
       logger.info(`[rpc-relayer/getFeeOptions] got refund options ${JSON.stringify(options)}`);
       return {
@@ -736,23 +596,39 @@ class RpcRelayer extends BaseRelayer {
       };
     }
   }
-  async gasRefundOptions(config, context, ...transactions) {
+  async getFeeOptionsRaw(entrypoint, data) {
+    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, ...transactions) {
     const {
       options
-    } = await this.getFeeOptions(config, context, ...transactions);
+    } = await this.getFeeOptions(address, ...transactions);
     return options;
   }
-  async getNonce(config, context, space) {
-    const addr = addressOf(config, context);
-    logger.info(`[rpc-relayer/getNonce] get nonce for wallet ${addr} space: ${space}`);
+  async getNonce(address, space) {
+    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,
+      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, quote, waitForReceipt = true) {
@@ -770,29 +646,23 @@ class RpcRelayer extends BaseRelayer {
       logger.warn(`[rpc-relayer/relay] provider not set, failed relay`);
       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 data = commons.transaction.encodeBundleExecData(signedTxs);
     const metaTxn = await this.service.sendMetaTxn({
       call: {
-        walletAddress,
-        contract,
-        input
+        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 => Promise.reject(new Error('impossible'))
       };
       const wait = async function wait(confirmations) {
@@ -800,7 +670,7 @@ class RpcRelayer extends BaseRelayer {
         if (!_this.provider) {
           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 = waitResponse.receipt) == null ? void 0 : _waitResponse$receipt.transactionHash;
         if (!transactionHash) {
           throw new Error('cannot wait for receipt, unknown native transaction hash');
@@ -829,7 +699,7 @@ class RpcRelayer extends BaseRelayer {
       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,
@@ -846,8 +716,14 @@ class MetaTransactionResponseException {
   }
 }
 
+// A fee quote is simply an opaque value that can be obtained via Relayer.getFeeOptions(), and
+// returned back to the same relayer via Relayer.relay(). Fee quotes should be treated as an
+// implementation detail of the relayer that produces them.
+//
+// This interface exists for type-safety purposes to protect against passing non-FeeQuotes to
+// Relayer.relay(), or any other functions that call it indirectly (e.g. Account.sendTransaction).
 function isRelayer(cand) {
   return typeof cand === 'object' && typeof cand.simulate === 'function' && typeof cand.getFeeOptions === 'function' && typeof cand.gasRefundOptions === 'function' && typeof cand.getNonce === 'function' && typeof cand.relay === 'function' && typeof cand.wait === 'function';
 }
 
-export { BaseRelayer, BaseRelayerDefaults, LocalRelayer, ProviderRelayer, ProviderRelayerDefaults, RpcRelayer, relayer_gen as RpcRelayerProto, isBaseRelayerOptions, isLocalRelayerOptions, isProviderRelayerOptions, isRelayer, isRpcRelayerOptions, relayer_gen as proto };
+export { LocalRelayer, ProviderRelayer, ProviderRelayerDefaults, RpcRelayer, relayer_gen as RpcRelayerProto, isLocalRelayerOptions, isProviderRelayerOptions, isRelayer, isRpcRelayerOptions, relayer_gen as proto };

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

@@ -1,21 +1,22 @@
 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(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]>;
-    getFeeOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<{
+    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, blockTag?: providers.BlockTag): Promise<ethers.BigNumberish>;
-    relay(signedTxs: SignedTransactions, quote?: FeeQuote, waitForReceipt?: boolean): Promise<TransactionResponse>;
-    wait(metaTxnId: string | SignedTransactions, timeout?: number, delay?: number, maxFails?: number): Promise<TransactionResponse>;
+    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, blockTag?: providers.BlockTag): Promise<ethers.BigNumberish>;
+    relay(signedTxs: commons.transaction.IntendedTransactionBundle, quote?: FeeQuote, waitForReceipt?: boolean): Promise<commons.transaction.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/dist/declarations/src/local-relayer.d.ts

@@ -1,9 +1,7 @@
-import { Signer as AbstractSigner, providers } from 'ethers';
-import { SignedTransactions, Transaction, TransactionResponse } from '@0xsequence/transactions';
-import { WalletContext } from '@0xsequence/network';
-import { WalletConfig } from '@0xsequence/config';
+import { Signer as AbstractSigner, providers, BytesLike } from 'ethers';
 import { FeeOption, FeeQuote, Relayer } from '.';
 import { ProviderRelayer, ProviderRelayerOptions } from './provider-relayer';
+import { commons } from '@0xsequence/core';
 export type LocalRelayerOptions = Omit<ProviderRelayerOptions, "provider"> & {
     signer: AbstractSigner;
 };
@@ -12,11 +10,13 @@ export declare class LocalRelayer extends ProviderRelayer implements Relayer {
     private signer;
     private txnOptions;
     constructor(options: LocalRelayerOptions | AbstractSigner);
-    deployWallet(config: WalletConfig, context: WalletContext): Promise<TransactionResponse>;
-    getFeeOptions(_config: WalletConfig, _context: WalletContext, ..._transactions: Transaction[]): Promise<{
+    getFeeOptions(_address: string, ..._transactions: commons.transaction.Transaction[]): Promise<{
         options: FeeOption[];
     }>;
-    gasRefundOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<FeeOption[]>;
+    getFeeOptionsRaw(_entrypoint: string, _data: BytesLike): Promise<{
+        options: FeeOption[];
+    }>;
+    gasRefundOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<FeeOption[]>;
     setTransactionOptions(transactionRequest: providers.TransactionRequest): void;
-    relay(signedTxs: SignedTransactions, quote?: FeeQuote, waitForReceipt?: boolean): Promise<TransactionResponse<providers.TransactionReceipt>>;
+    relay(signedTxs: commons.transaction.IntendedTransactionBundle, quote?: FeeQuote, waitForReceipt?: boolean): Promise<commons.transaction.TransactionResponse<providers.TransactionReceipt>>;
 }

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

@@ -1,33 +1,34 @@
 import { ethers, providers } from 'ethers';
-import { SignedTransactions, Transaction, TransactionResponse } from '@0xsequence/transactions';
-import { WalletContext } from '@0xsequence/network';
-import { WalletConfig } from '@0xsequence/config';
-import { BaseRelayer, BaseRelayerOptions } from './base-relayer';
 import { FeeOption, FeeQuote, Relayer, SimulateResult } from '.';
-import { Optionals, Mask } from '@0xsequence/utils';
-export interface ProviderRelayerOptions extends BaseRelayerOptions {
+import { Optionals } from '@0xsequence/utils';
+import { commons } from '@0xsequence/core';
+export interface ProviderRelayerOptions {
     provider: providers.Provider;
     waitPollRate?: number;
     deltaBlocksLog?: number;
     fromBlockLog?: number;
 }
-export declare const ProviderRelayerDefaults: Required<Optionals<Mask<ProviderRelayerOptions, BaseRelayerOptions>>>;
+export declare const ProviderRelayerDefaults: Required<Optionals<ProviderRelayerOptions>>;
 export declare function isProviderRelayerOptions(obj: any): obj is ProviderRelayerOptions;
-export declare abstract class ProviderRelayer extends BaseRelayer implements Relayer {
+export declare abstract class ProviderRelayer implements Relayer {
     provider: providers.Provider;
     waitPollRate: number;
     deltaBlocksLog: number;
     fromBlockLog: number;
     constructor(options: ProviderRelayerOptions);
-    abstract getFeeOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<{
+    abstract getFeeOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<{
         options: FeeOption[];
         quote?: FeeQuote;
     }>;
-    abstract gasRefundOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<FeeOption[]>;
-    abstract relay(signedTxs: SignedTransactions, quote?: FeeQuote, waitForReceipt?: boolean): Promise<TransactionResponse>;
-    simulate(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]>;
-    getNonce(config: WalletConfig, context: WalletContext, space?: ethers.BigNumberish, blockTag?: providers.BlockTag): Promise<ethers.BigNumberish>;
-    wait(metaTxnId: string | SignedTransactions, timeout?: number, delay?: number, maxFails?: number): Promise<providers.TransactionResponse & {
+    abstract getFeeOptionsRaw(entrypoint: string, data: ethers.utils.BytesLike): Promise<{
+        options: FeeOption[];
+        quote?: FeeQuote;
+    }>;
+    abstract gasRefundOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<FeeOption[]>;
+    abstract relay(signedTxs: commons.transaction.IntendedTransactionBundle, quote?: FeeQuote, waitForReceipt?: boolean): Promise<commons.transaction.TransactionResponse>;
+    simulate(wallet: string, ...transactions: commons.transaction.Transaction[]): Promise<SimulateResult[]>;
+    getNonce(address: string, space?: ethers.BigNumberish, blockTag?: providers.BlockTag): Promise<ethers.BigNumberish>;
+    wait(metaTxnId: string | commons.transaction.SignedTransactionBundle, timeout?: number, delay?: number, maxFails?: number): Promise<providers.TransactionResponse & {
         receipt: providers.TransactionReceipt;
     }>;
 }