@0xsequence/relayer 0.43.34 → 1.0.1

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

@@ -3,10 +3,9 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var ethers = require('ethers');
-var abi = require('@0xsequence/abi');
-var transactions = require('@0xsequence/transactions');
 var utils = require('@0xsequence/utils');
-var config = require('@0xsequence/config');
+var abi = require('@0xsequence/abi');
+var core = require('@0xsequence/core');
 
 function _extends() {
   _extends = Object.assign ? Object.assign.bind() : function (target) {
@@ -23,105 +22,6 @@ function _extends() {
   return _extends.apply(this, arguments);
 }
 
-function isBaseRelayerOptions(obj) {
-  return obj.bundleCreation !== undefined && typeof obj.bundleCreation === 'boolean' || obj.creationGasLimit !== undefined && utils.isBigNumberish(obj.creationGasLimit) || obj.provider !== undefined && (ethers.providers.Provider.isProvider(obj.provider) || typeof obj.provider === 'string');
-}
-const BaseRelayerDefaults = {
-  bundleCreation: true,
-  creationGasLimit: ethers.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.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$1, context) {
-    const factoryInterface = new ethers.utils.Interface(abi.walletContracts.factory.abi);
-    return {
-      to: context.factory,
-      data: factoryInterface.encodeFunctionData(factoryInterface.getFunction('deploy'), [context.mainModule, config.imageHash(config$1)])
-    };
-  }
-  async prependWalletDeploy(signedTransactions) {
-    const {
-      config: config$1,
-      context,
-      transactions: transactions$1,
-      nonce,
-      signature
-    } = signedTransactions;
-    const walletAddress = config.addressOf(config$1, context);
-    const walletInterface = new ethers.utils.Interface(abi.walletContracts.mainModule.abi);
-    const encodedSignature = async function () {
-      const sig = await signature;
-      if (typeof sig === 'string') return sig;
-      return config.encodeSignature(sig);
-    }();
-    if (this.bundleCreation && !(await this.isWalletDeployed(walletAddress))) {
-      return {
-        to: context.guestModule,
-        execute: {
-          transactions: [_extends({}, this.prepareWalletDeploy(config$1, context), {
-            delegateCall: false,
-            revertOnError: false,
-            gasLimit: this.creationGasLimit,
-            value: ethers.ethers.constants.Zero
-          }), {
-            delegateCall: false,
-            revertOnError: true,
-            gasLimit: ethers.ethers.constants.Zero,
-            to: walletAddress,
-            value: ethers.ethers.constants.Zero,
-            data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode(transactions$1), nonce, await encodedSignature])
-          }],
-          nonce: ethers.ethers.constants.Zero,
-          signature: '0x'
-        }
-      };
-    } else {
-      return {
-        to: walletAddress,
-        execute: {
-          transactions: transactions$1,
-          nonce: ethers.ethers.BigNumber.from(nonce),
-          signature: await encodedSignature
-        }
-      };
-    }
-  }
-  async prepareTransactions(config, context, signature, ...transactions$1) {
-    //, gasLimit?: ethers.BigNumberish }> {
-    const nonce = transactions.readSequenceNonce(...transactions$1);
-    if (!nonce) {
-      throw new Error('Unable to prepare transactions without a defined nonce');
-    }
-    const {
-      to,
-      execute
-    } = await this.prependWalletDeploy({
-      config,
-      context,
-      transactions: transactions$1,
-      nonce,
-      signature
-    });
-    const walletInterface = new ethers.utils.Interface(abi.walletContracts.mainModule.abi);
-    return {
-      to,
-      data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode(execute.transactions), execute.nonce, execute.signature])
-    };
-  }
-}
-
 const DEFAULT_GAS_LIMIT = ethers.ethers.BigNumber.from(800000);
 const ProviderRelayerDefaults = {
   waitPollRate: 1000,
@@ -131,18 +31,10 @@ const ProviderRelayerDefaults = {
 function isProviderRelayerOptions(obj) {
   return obj.provider !== undefined && ethers.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;
@@ -158,7 +50,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.ethers.utils.arrayify(code).length === 0))) {
         return DEFAULT_GAS_LIMIT;
       }
       if (!_this.provider) {
@@ -180,28 +72,26 @@ class ProviderRelayer extends BaseRelayer {
       gasLimit: ethers.ethers.BigNumber.from(gasLimit).toNumber()
     }));
   }
-  async getNonce(config$1, context, space, blockTag) {
+  async getNonce(address, space, blockTag) {
     if (!this.provider) {
       throw new Error('provider is not set');
     }
-    const addr = config.addressOf(config$1, 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.ethers.Contract(addr, abi.walletContracts.mainModule.abi, this.provider);
+    const module = new ethers.ethers.Contract(address, abi.walletContracts.mainModule.abi, this.provider);
     const nonce = await module.readNonce(space, {
       blockTag: blockTag
     });
-    return transactions.encodeNonce(space, nonce);
+    return core.commons.transaction.encodeNonce(space, nonce);
   }
   async wait(metaTxnId, timeout, delay = this.waitPollRate, maxFails = 5) {
     var _this2 = this;
     if (typeof metaTxnId !== 'string') {
-      utils.logger.info('computing id', metaTxnId.config, metaTxnId.context, metaTxnId.chainId, ...metaTxnId.transactions);
-      metaTxnId = transactions.computeMetaTxnHash(config.addressOf(metaTxnId.config, metaTxnId.context), metaTxnId.chainId, ...metaTxnId.transactions);
+      metaTxnId = core.commons.transaction.intendedTransactionID(metaTxnId);
     }
     let timedOut = false;
     const retry = async function retry(f, errorMessage) {
@@ -289,31 +179,23 @@ class LocalRelayer extends ProviderRelayer {
     } : _extends({}, options, {
       provider: options.signer.provider
     }));
-    this.signer = void 0;
-    this.txnOptions = void 0;
     this.signer = ethers.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.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) {
@@ -323,15 +205,7 @@ class LocalRelayer extends ProviderRelayer {
     if (quote !== undefined) {
       utils.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.ethers.utils.Interface(abi.walletContracts.mainModule.abi);
-    const data = walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode(execute.transactions), execute.nonce, execute.signature]);
+    const data = core.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
@@ -339,9 +213,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();
@@ -372,8 +248,7 @@ const WebRPCSchemaHash = "752f4f4274ca80d2fd974b5b44ed8245dfe40554";
 // Types
 //
 
-let ETHTxnStatus;
-(function (ETHTxnStatus) {
+let ETHTxnStatus = /*#__PURE__*/function (ETHTxnStatus) {
   ETHTxnStatus["UNKNOWN"] = "UNKNOWN";
   ETHTxnStatus["DROPPED"] = "DROPPED";
   ETHTxnStatus["QUEUED"] = "QUEUED";
@@ -381,34 +256,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 => {
@@ -630,29 +504,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.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.ethers.providers.Provider.isProvider(options.provider) ? options.provider : new ethers.ethers.providers.StaticJsonRpcProvider(utils.getDefaultConnectionInfo(options.provider.url));
   }
   async waitReceipt(metaTxnId, delay = 1000, maxFails = 5, isCancelled) {
     if (typeof metaTxnId !== 'string') {
-      utils.logger.info('computing id', metaTxnId.config, metaTxnId.context, metaTxnId.chainId, ...metaTxnId.transactions);
-      metaTxnId = transactions.computeMetaTxnHash(config.addressOf(metaTxnId.config, metaTxnId.context), metaTxnId.chainId, ...metaTxnId.transactions);
+      metaTxnId = core.commons.transaction.intendedTransactionID(metaTxnId);
     }
     utils.logger.info(`[rpc-relayer/waitReceipt] waiting for ${metaTxnId}`);
     let fails = 0;
@@ -680,15 +552,15 @@ class RpcRelayer extends BaseRelayer {
     }
     throw new Error(`Cancelled waiting for transaction receipt ${metaTxnId}`);
   }
-  async simulate(wallet, ...transactions$1) {
+  async simulate(wallet, ...transactions) {
     const coder = ethers.ethers.utils.defaultAbiCoder;
-    const encoded = coder.encode([transactions.MetaTransactionsType], [transactions.sequenceTxAbiEncode(transactions$1)]);
+    const encoded = coder.encode([core.commons.transaction.MetaTransactionsType], [core.commons.transaction.sequenceTxAbiEncode(transactions)]);
     return (await this.service.simulate({
       wallet,
       transactions: encoded
     })).results;
   }
-  async getFeeOptions(config$1, context, ...transactions$1) {
+  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
@@ -696,34 +568,22 @@ class RpcRelayer extends BaseRelayer {
     if (feeTokens.isFeeRequired) {
       const symbols = feeTokens.tokens.map(token => token.symbol).join(', ');
       utils.logger.info(`[rpc-relayer/getFeeOptions] relayer fees are required, accepted tokens are ${symbols}`);
-      const wallet = config.addressOf(config$1, context);
-      let nonce = transactions.readSequenceNonce(...transactions$1);
-      if (nonce === undefined) {
-        nonce = await this.getNonce(config$1, context);
-      }
+      const nonce = await this.getNonce(address);
       if (!this.provider) {
         utils.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: config$1,
-        context,
-        transactions: transactions$1,
-        nonce,
-        signature: config.buildStubSignature(this.provider, config$1)
-      });
-      const walletInterface = new ethers.ethers.utils.Interface(abi.walletContracts.mainModule.abi);
-      const data = walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode(execute.transactions), execute.nonce, execute.signature]);
       const {
         options,
         quote
       } = await this.service.feeOptions({
-        wallet,
-        to,
-        data
+        wallet: address,
+        to: address,
+        data: core.commons.transaction.encodeBundleExecData({
+          entrypoint: address,
+          transactions,
+          nonce
+        })
       });
       utils.logger.info(`[rpc-relayer/getFeeOptions] got refund options ${JSON.stringify(options)}`);
       return {
@@ -740,23 +600,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.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$1, context, space) {
-    const addr = config.addressOf(config$1, context);
-    utils.logger.info(`[rpc-relayer/getNonce] get nonce for wallet ${addr} space: ${space}`);
+  async getNonce(address, space) {
+    utils.logger.info(`[rpc-relayer/getNonce] get nonce for wallet ${address} space: ${space}`);
     const encodedNonce = space !== undefined ? ethers.ethers.BigNumber.from(space).toHexString() : undefined;
     const resp = await this.service.getMetaTxnNonce({
-      walletContractAddress: addr,
+      walletContractAddress: address,
       space: encodedNonce
     });
     const nonce = ethers.ethers.BigNumber.from(resp.nonce);
-    const [decodedSpace, decodedNonce] = transactions.decodeNonce(nonce);
-    utils.logger.info(`[rpc-relayer/getNonce] got next nonce for wallet ${addr} ${decodedNonce} space: ${decodedSpace}`);
+    const [decodedSpace, decodedNonce] = core.commons.transaction.decodeNonce(nonce);
+    utils.logger.info(`[rpc-relayer/getNonce] got next nonce for wallet ${address} ${decodedNonce} space: ${decodedSpace}`);
     return nonce;
   }
   async relay(signedTxs, quote, waitForReceipt = true) {
@@ -774,29 +650,23 @@ class RpcRelayer extends BaseRelayer {
       utils.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 = config.addressOf(signedTxs.config, signedTxs.context);
-    const walletInterface = new ethers.ethers.utils.Interface(abi.walletContracts.mainModule.abi);
-    const input = walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode(execute.transactions), execute.nonce, execute.signature]);
+    const data = core.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
     });
     utils.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) {
@@ -804,7 +674,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');
@@ -833,7 +703,7 @@ class RpcRelayer extends BaseRelayer {
       blockHash: txReceipt.blockHash,
       blockNumber: ethers.ethers.BigNumber.from(txReceipt.blockNumber).toNumber(),
       confirmations: 1,
-      from: typeof metaTxnId === 'string' ? undefined : config.addressOf(metaTxnId.config, metaTxnId.context),
+      from: typeof metaTxnId === 'string' ? undefined : metaTxnId.intent.wallet,
       hash: txReceipt.transactionHash,
       raw: receipt.txnReceipt,
       receipt: txReceipt,
@@ -850,18 +720,21 @@ 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';
 }
 
-exports.BaseRelayer = BaseRelayer;
-exports.BaseRelayerDefaults = BaseRelayerDefaults;
 exports.LocalRelayer = LocalRelayer;
 exports.ProviderRelayer = ProviderRelayer;
 exports.ProviderRelayerDefaults = ProviderRelayerDefaults;
 exports.RpcRelayer = RpcRelayer;
 exports.RpcRelayerProto = relayer_gen;
-exports.isBaseRelayerOptions = isBaseRelayerOptions;
 exports.isLocalRelayerOptions = isLocalRelayerOptions;
 exports.isProviderRelayerOptions = isProviderRelayerOptions;
 exports.isRelayer = isRelayer;