@0xsequence/relayer 0.31.0 → 0.35.0

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # @0xsequence/relayer
 
+## 0.35.0
+
+### Minor Changes
+
+- - config: add buildStubSignature
+  - provider: add checks to signing cases for wallet deployment and config statuses
+  - provider: add prompt for wallet deployment
+  - relayer: add BaseRelayer.prependWalletDeploy
+  - relayer: add Relayer.feeOptions
+  - relayer: account for wallet deployment in fee estimation
+  - transactions: add fromTransactionish
+  - wallet: add Account.prependConfigUpdate
+  - wallet: add Account.getFeeOptions
+
+### Patch Changes
+
+- Updated dependencies
+  - @0xsequence/abi@0.35.0
+  - @0xsequence/config@0.35.0
+  - @0xsequence/transactions@0.35.0
+  - @0xsequence/utils@0.35.0
+
+## 0.34.0
+
+### Minor Changes
+
+- - upgrade deps
+
+### Patch Changes
+
+- Updated dependencies
+  - @0xsequence/abi@0.34.0
+  - @0xsequence/config@0.34.0
+  - @0xsequence/transactions@0.34.0
+  - @0xsequence/utils@0.34.0
+
+## 0.33.2
+
+### Patch Changes
+
+- Updated dependencies
+  - @0xsequence/transactions@0.33.2
+
+## 0.31.1
+
+### Patch Changes
+
+- relayer: add Relayer.simulate
+
 ## 0.31.0
 
 ### Minor Changes

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

@@ -3,9 +3,9 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var ethers = require('ethers');
-var providers = require('@ethersproject/providers');
 var abi = require('@0xsequence/abi');
 var transactions = require('@0xsequence/transactions');
+var providers = require('@ethersproject/providers');
 var config = require('@0xsequence/config');
 var utils$1 = require('ethers/lib/utils');
 var utils = require('@0xsequence/utils');
@@ -66,8 +66,14 @@ class BaseRelayer {
     };
   }
 
-  async prepareTransactions(config$1, context, signature, ...transactions$1) {
-    //, gasLimit?: ethers.BigNumberish }> {
+  async prependWalletDeploy(signedTransactions) {
+    const {
+      config: config$1,
+      context,
+      transactions: transactions$1,
+      nonce,
+      signature
+    } = signedTransactions;
     const walletAddress = config.addressOf(config$1, context);
     const walletInterface = new utils$1.Interface(abi.walletContracts.mainModule.abi);
 
@@ -80,28 +86,61 @@ class BaseRelayer {
     if (this.bundleCreation && !(await this.isWalletDeployed(walletAddress))) {
       return {
         to: context.guestModule,
-        data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode([_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), transactions.readSequenceNonce(...transactions$1), await encodedSignature])
-        }]), 0, []])
+        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,
-        data: walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode(transactions$1), transactions.readSequenceNonce(...transactions$1), await encodedSignature])
+        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 utils$1.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);
@@ -129,11 +168,10 @@ class ProviderRelayer extends BaseRelayer {
     this.fromBlockLog = opts.fromBlockLog;
   }
 
-  async estimateGasLimits(config$1, context, ...transactions) {
+  async simulate(wallet, ...transactions) {
     var _this = this;
 
-    const walletAddr = config.addressOf(config$1, context);
-    const gasCosts = await Promise.all(transactions.map(async function (tx) {
+    return (await Promise.all(transactions.map(async function (tx) {
       // Respect gasLimit request of the transaction (as long as its not 0)
       if (tx.gasLimit && !ethers.ethers.BigNumber.from(tx.gasLimit || 0).eq(ethers.ethers.constants.Zero)) {
         return tx.gasLimit;
@@ -145,7 +183,7 @@ class ProviderRelayer extends BaseRelayer {
       } // 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;
       }
 
@@ -156,16 +194,25 @@ class ProviderRelayer extends BaseRelayer {
 
 
       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.ethers.BigNumber.from(gasLimit).toNumber(),
+      gasUsed: ethers.ethers.BigNumber.from(gasLimit).toNumber()
+    }));
+  }
+
+  async estimateGasLimits(config$1, context, ...transactions) {
+    const walletAddr = config.addressOf(config$1, context);
+    const results = await this.simulate(walletAddr, ...transactions);
+    return transactions.map((t, i) => _extends({}, t, {
+      gasLimit: results[i].gasLimit
     }));
-    return transactions.map((t, i) => {
-      t.gasLimit = gasCosts[i];
-      return t;
-    });
   }
 
   async getNonce(config$1, context, space, blockTag) {
@@ -273,18 +320,26 @@ class LocalRelayer extends ProviderRelayer {
       throw new Error('LocalRelayer requires the context.guestModule address');
     }
 
-    const txRequest = await this.prepareTransactions(signedTxs.config, signedTxs.context, signedTxs.signature, ...signedTxs.transactions); // TODO: think about computing gas limit individually, summing together and passing across
+    const {
+      to,
+      execute
+    } = await this.prependWalletDeploy(signedTxs);
+    const walletInterface = new ethers.ethers.utils.Interface(abi.walletContracts.mainModule.abi);
+    const data = walletInterface.encodeFunctionData(walletInterface.getFunction('execute'), [transactions.sequenceTxAbiEncode(execute.transactions), execute.nonce, execute.signature]); // TODO: think about computing gas limit individually, summing together and passing across
     // NOTE: we expect that all txns have set their gasLimit ahead of time through proper estimation
     // const gasLimit = signedTxs.transactions.reduce((sum, tx) => sum.add(tx.gasLimit), ethers.BigNumber.from(0))
     // txRequest.gasLimit = gasLimit
 
-    return this.signer.sendTransaction(txRequest);
+    return this.signer.sendTransaction({
+      to,
+      data
+    });
   }
 
 }
 
 /* eslint-disable */
-// sequence-relayer v0.4.0 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.
@@ -293,7 +348,7 @@ const WebRPCVersion = 'v1'; // Schema version of your RIDL schema
 
 const WebRPCSchemaVersion = 'v0.4.0'; // Schema hash generated from your RIDL schema
 
-const WebRPCSchemaHash = 'fc9652e2bc0c3df8d1ce0b4a8e24ab8790e4dae2'; //
+const WebRPCSchemaHash = '7dbfaf5c04cf28e9259ff1a9bf3274c8d73be5dd'; //
 // Types
 //
 
@@ -425,6 +480,16 @@ class Relayer {
       });
     };
 
+    this.simulate = (args, headers) => {
+      return this.fetch(this.url('Simulate'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            results: _data.results
+          };
+        });
+      });
+    };
+
     this.updateMetaTxnGasLimits = (args, headers) => {
       return this.fetch(this.url('UpdateMetaTxnGasLimits'), createHTTPRequest(args, headers)).then(res => {
         return buildResponse(res).then(_data => {
@@ -446,6 +511,16 @@ class Relayer {
       });
     };
 
+    this.feeOptions = (args, headers) => {
+      return this.fetch(this.url('FeeOptions'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            options: _data.options
+          };
+        });
+      });
+    };
+
     this.getMetaTxnNetworkFeeOptions = (args, headers) => {
       return this.fetch(this.url('GetMetaTxnNetworkFeeOptions'), createHTTPRequest(args, headers)).then(res => {
         return buildResponse(res).then(_data => {
@@ -565,6 +640,15 @@ class RpcRelayer extends BaseRelayer {
     return result;
   }
 
+  async simulate(wallet, ...transactions$1) {
+    const coder = ethers.ethers.utils.defaultAbiCoder;
+    const encoded = coder.encode([transactions.MetaTransactionsType], [transactions.sequenceTxAbiEncode(transactions$1)]);
+    return (await this.service.simulate({
+      wallet,
+      transactions: encoded
+    })).results;
+  }
+
   async estimateGasLimits(config$1, context, ...transactions$1) {
     utils.logger.info(`[rpc-relayer/estimateGasLimits] estimate gas limits request ${JSON.stringify(transactions$1)}`);
 
@@ -609,23 +693,39 @@ class RpcRelayer extends BaseRelayer {
     if (feeTokens.isFeeRequired) {
       const symbols = feeTokens.tokens.map(token => token.symbol).join(', ');
       utils.logger.info(`[rpc-relayer/gasRefundOptions] relayer fees are required, accepted tokens are ${symbols}`);
-      const addr = config.addressOf(config$1, context);
-      const prevNonce = transactions.readSequenceNonce(...transactions$1); // Set temporal nonce to simulate meta-txn
+      const wallet = config.addressOf(config$1, context);
+      let nonce = transactions.readSequenceNonce(...transactions$1);
+
+      if (nonce === undefined) {
+        nonce = await this.getNonce(config$1, context);
+      }
 
-      if (prevNonce === undefined) {
-        transactions$1 = transactions.appendNonce(transactions$1, await this.getNonce(config$1, context));
+      if (!this.provider) {
+        utils.logger.warn(`[rpc-relayer/gasRefundOptions] provider not set, needed for stub signature`);
+        throw new Error('provider is not set');
       }
 
-      const coder = ethers.ethers.utils.defaultAbiCoder;
-      const encoded = coder.encode([transactions.MetaTransactionsType], [transactions.sequenceTxAbiEncode(transactions$1)]);
-      const res = await this.service.getMetaTxnNetworkFeeOptions({
-        walletConfig: _extends({}, config$1, {
-          address: addr
-        }),
-        payload: encoded
+      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
+      } = await this.service.feeOptions({
+        wallet,
+        to,
+        data
       });
-      utils.logger.info(`[rpc-relayer/gasRefundOptions] got refund options ${JSON.stringify(res.options)}`);
-      return res.options;
+      utils.logger.info(`[rpc-relayer/gasRefundOptions] got refund options ${JSON.stringify(options)}`);
+      return options;
     } else {
       utils.logger.info(`[rpc-relayer/gasRefundOptions] relayer fees are not required`);
       return [];
@@ -654,13 +754,18 @@ class RpcRelayer extends BaseRelayer {
       throw new Error('provider is not set');
     }
 
-    const addr = config.addressOf(signedTxs.config, signedTxs.context);
-    const prep = await this.prepareTransactions(signedTxs.config, signedTxs.context, signedTxs.signature, ...signedTxs.transactions);
+    const {
+      to: contract,
+      execute
+    } = await this.prependWalletDeploy(signedTxs);
+    const walletAddress = 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 metaTxn = await this.service.sendMetaTxn({
       call: {
-        contract: prep.to,
-        input: prep.data,
-        walletAddress: addr
+        walletAddress,
+        contract,
+        input
       }
     });
     utils.logger.info(`[rpc-relayer/relay] got relay result ${JSON.stringify(metaTxn)}`);