@0xsequence/account 1.1.14 → 1.2.0

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

@@ -24,6 +24,166 @@ function _extends() {
   return _extends.apply(this, arguments);
 }
 
+function isPromise(value) {
+  return !!value && typeof value.then === 'function';
+}
+function isDeferrable(value) {
+  // The value is deferrable if any of the properties is a Promises
+  if (typeof value === "object") {
+    return Object.keys(value).some(key => isPromise(value[key]));
+  }
+  return false;
+}
+
+function encodeGasRefundTransaction(option) {
+  if (!option) return [];
+  const value = ethers.ethers.BigNumber.from(option.value);
+  switch (option.token.type) {
+    case relayer.proto.FeeTokenType.UNKNOWN:
+      return [{
+        delegateCall: false,
+        revertOnError: true,
+        gasLimit: option.gasLimit,
+        to: option.to,
+        value: value.toHexString(),
+        data: []
+      }];
+    case relayer.proto.FeeTokenType.ERC20_TOKEN:
+      if (!option.token.contractAddress) {
+        throw new Error(`No contract address for ERC-20 fee option`);
+      }
+      return [{
+        delegateCall: false,
+        revertOnError: true,
+        gasLimit: option.gasLimit,
+        to: option.token.contractAddress,
+        value: 0,
+        data: new ethers.ethers.utils.Interface([{
+          "constant": false,
+          "inputs": [{
+            "type": "address"
+          }, {
+            "type": "uint256"
+          }],
+          "name": "transfer",
+          "outputs": [],
+          "type": "function"
+        }]).encodeFunctionData('transfer', [option.to, value.toHexString()])
+      }];
+    default:
+      throw new Error(`Unhandled fee token type ${option.token.type}`);
+  }
+}
+class AccountSigner {
+  constructor(account, chainId, options) {
+    this._isSigner = true;
+    this.account = account;
+    this.chainId = chainId;
+    this.options = options;
+  }
+  get provider() {
+    return this.account.providerFor(this.chainId);
+  }
+  async getAddress() {
+    return this.account.address;
+  }
+  signMessage(message) {
+    var _this$options$cantVal, _this$options;
+    return this.account.signMessage(message, this.chainId, (_this$options$cantVal = (_this$options = this.options) == null ? void 0 : _this$options.cantValidateBehavior) != null ? _this$options$cantVal : 'throw');
+  }
+  async defaultSelectFee(_txs, options) {
+    // If no options, return undefined
+    if (options.length === 0) return undefined;
+
+    // If there are multiple options, try them one by one
+    // until we find one that satisfies the balance requirement
+    const balanceOfAbi = [{
+      "constant": true,
+      "inputs": [{
+        "type": "address"
+      }],
+      "name": "balanceOf",
+      "outputs": [{
+        "type": "uint256"
+      }],
+      "type": "function"
+    }];
+    for (const option of options) {
+      if (option.token.type === relayer.proto.FeeTokenType.UNKNOWN) {
+        // Native token
+        const balance = await this.getBalance();
+        if (balance.gte(ethers.ethers.BigNumber.from(option.value))) {
+          return option;
+        }
+      } else if (option.token.contractAddress && option.token.type === relayer.proto.FeeTokenType.ERC20_TOKEN) {
+        // ERC20 token
+        const token = new ethers.ethers.Contract(option.token.contractAddress, balanceOfAbi, this.provider);
+        const balance = await token.balanceOf(this.account.address);
+        if (balance.gte(ethers.ethers.BigNumber.from(option.value))) {
+          return option;
+        }
+      } else ;
+    }
+    throw new Error("No fee option available - not enough balance");
+  }
+  async sendTransaction(txsPromise) {
+    var _this$options$stubSig, _this$options2, _this$options$selectF, _this$options3, _this$options4;
+    const txs = isDeferrable(txsPromise) ? await ethers.ethers.utils.resolveProperties(txsPromise) : txsPromise;
+    const prepare = await this.account.prepareTransactions({
+      txs,
+      chainId: this.chainId,
+      stubSignatureOverrides: (_this$options$stubSig = (_this$options2 = this.options) == null ? void 0 : _this$options2.stubSignatureOverrides) != null ? _this$options$stubSig : new Map()
+    });
+    const selectMethod = (_this$options$selectF = (_this$options3 = this.options) == null ? void 0 : _this$options3.selectFee) != null ? _this$options$selectF : this.defaultSelectFee.bind(this);
+    const feeOption = await selectMethod(txs, prepare.feeOptions);
+    const finalTransactions = [...prepare.transactions, ...encodeGasRefundTransaction(feeOption)];
+    return this.account.sendTransaction(finalTransactions, this.chainId, prepare.feeQuote, undefined, undefined, (_this$options4 = this.options) != null && _this$options4.nonceSpace ? {
+      nonceSpace: this.options.nonceSpace
+    } : undefined);
+  }
+  getBalance(blockTag) {
+    return this.provider.getBalance(this.account.address, blockTag);
+  }
+  call(transaction, blockTag) {
+    return this.provider.call(transaction, blockTag);
+  }
+  async resolveName(name) {
+    const res = await this.provider.resolveName(name);
+    if (!res) throw new Error(`Could not resolve name ${name}`);
+    return res;
+  }
+  connect(_provider) {
+    throw new Error("Method not implemented.");
+  }
+  signTransaction(transaction) {
+    throw new Error("Method not implemented.");
+  }
+  getTransactionCount(blockTag) {
+    throw new Error("Method not implemented.");
+  }
+  estimateGas(transaction) {
+    throw new Error("Method not implemented.");
+  }
+  getChainId() {
+    return Promise.resolve(ethers.ethers.BigNumber.from(this.chainId).toNumber());
+  }
+  getGasPrice() {
+    throw new Error("Method not implemented.");
+  }
+  getFeeData() {
+    throw new Error("Method not implemented.");
+  }
+  checkTransaction(transaction) {
+    throw new Error("Method not implemented.");
+  }
+  populateTransaction(transaction) {
+    throw new Error("Method not implemented.");
+  }
+  _checkProvider(operation) {
+    throw new Error("Method not implemented.");
+  }
+}
+
 class Chain0Reader {
   async isDeployed(_wallet) {
     return false;
@@ -51,6 +211,9 @@ class Account {
     this.migrations = options.migrations || migration.defaults.DefaultMigrations;
     this.migrator = new migration.migrator.Migrator(options.tracker, this.migrations, this.contexts);
   }
+  getSigner(chainId, options) {
+    return new AccountSigner(this, chainId, options);
+  }
   static async new(options) {
     var _options$migrations;
     const mig = new migration.migrator.Migrator(options.tracker, (_options$migrations = options.migrations) != null ? _options$migrations : migration.defaults.DefaultMigrations, options.contexts);
@@ -92,7 +255,7 @@ class Account {
     if (!found) throw new Error(`Network not found for chainId ${chainId}`);
     return found;
   }
-  provider(chainId) {
+  providerFor(chainId) {
     const found = this.network(chainId);
     if (!found.provider && !found.rpcUrl) throw new Error(`Provider not found for chainId ${chainId}`);
     return found.provider || new ethers.ethers.providers.StaticJsonRpcProvider(utils.getDefaultConnectionInfo(found.rpcUrl), {
@@ -105,7 +268,7 @@ class Account {
 
     // TODO: Networks should be able to provide a reader directly
     // and we should default to the on-chain reader
-    return new core.commons.reader.OnChainReader(this.provider(chainId));
+    return new core.commons.reader.OnChainReader(this.providerFor(chainId));
   }
   relayer(chainId) {
     const found = this.network(chainId);
@@ -452,11 +615,13 @@ class Account {
   signMessage(message, chainId, cantValidateBehavior = 'ignore') {
     return this.signDigest(ethers.ethers.utils.keccak256(message), chainId, true, cantValidateBehavior);
   }
-  async signTransactions(txs, chainId, pstatus) {
+  async signTransactions(txs, chainId, pstatus, options) {
     const status = pstatus || (await this.status(chainId));
     this.mustBeFullyMigrated(status);
     const wallet = this.walletForStatus(chainId, status);
-    const signed = await wallet.signTransactions(txs);
+    const signed = await wallet.signTransactions(txs, (options == null ? void 0 : options.nonceSpace) && {
+      space: options == null ? void 0 : options.nonceSpace
+    });
     return _extends({}, signed, {
       signature: await this.decorateSignature(signed.signature, status)
     });
@@ -589,10 +754,10 @@ class Account {
       feeQuote: gasRefundQuote.quote
     };
   }
-  async sendTransaction(txs, chainId, quote, skipPreDecorate = false, callback) {
+  async sendTransaction(txs, chainId, quote, skipPreDecorate = false, callback, options) {
     const status = await this.status(chainId);
     const predecorated = skipPreDecorate ? txs : await this.predecorateTransactions(txs, status, chainId);
-    const signed = await this.signTransactions(predecorated, chainId);
+    const signed = await this.signTransactions(predecorated, chainId, undefined, options);
     // TODO: is it safe to pass status again here?
     return this.sendSignedTransactions(signed, chainId, quote, undefined, callback);
   }

package/dist/0xsequence-account.cjs.prod.js

@@ -24,6 +24,166 @@ function _extends() {
   return _extends.apply(this, arguments);
 }
 
+function isPromise(value) {
+  return !!value && typeof value.then === 'function';
+}
+function isDeferrable(value) {
+  // The value is deferrable if any of the properties is a Promises
+  if (typeof value === "object") {
+    return Object.keys(value).some(key => isPromise(value[key]));
+  }
+  return false;
+}
+
+function encodeGasRefundTransaction(option) {
+  if (!option) return [];
+  const value = ethers.ethers.BigNumber.from(option.value);
+  switch (option.token.type) {
+    case relayer.proto.FeeTokenType.UNKNOWN:
+      return [{
+        delegateCall: false,
+        revertOnError: true,
+        gasLimit: option.gasLimit,
+        to: option.to,
+        value: value.toHexString(),
+        data: []
+      }];
+    case relayer.proto.FeeTokenType.ERC20_TOKEN:
+      if (!option.token.contractAddress) {
+        throw new Error(`No contract address for ERC-20 fee option`);
+      }
+      return [{
+        delegateCall: false,
+        revertOnError: true,
+        gasLimit: option.gasLimit,
+        to: option.token.contractAddress,
+        value: 0,
+        data: new ethers.ethers.utils.Interface([{
+          "constant": false,
+          "inputs": [{
+            "type": "address"
+          }, {
+            "type": "uint256"
+          }],
+          "name": "transfer",
+          "outputs": [],
+          "type": "function"
+        }]).encodeFunctionData('transfer', [option.to, value.toHexString()])
+      }];
+    default:
+      throw new Error(`Unhandled fee token type ${option.token.type}`);
+  }
+}
+class AccountSigner {
+  constructor(account, chainId, options) {
+    this._isSigner = true;
+    this.account = account;
+    this.chainId = chainId;
+    this.options = options;
+  }
+  get provider() {
+    return this.account.providerFor(this.chainId);
+  }
+  async getAddress() {
+    return this.account.address;
+  }
+  signMessage(message) {
+    var _this$options$cantVal, _this$options;
+    return this.account.signMessage(message, this.chainId, (_this$options$cantVal = (_this$options = this.options) == null ? void 0 : _this$options.cantValidateBehavior) != null ? _this$options$cantVal : 'throw');
+  }
+  async defaultSelectFee(_txs, options) {
+    // If no options, return undefined
+    if (options.length === 0) return undefined;
+
+    // If there are multiple options, try them one by one
+    // until we find one that satisfies the balance requirement
+    const balanceOfAbi = [{
+      "constant": true,
+      "inputs": [{
+        "type": "address"
+      }],
+      "name": "balanceOf",
+      "outputs": [{
+        "type": "uint256"
+      }],
+      "type": "function"
+    }];
+    for (const option of options) {
+      if (option.token.type === relayer.proto.FeeTokenType.UNKNOWN) {
+        // Native token
+        const balance = await this.getBalance();
+        if (balance.gte(ethers.ethers.BigNumber.from(option.value))) {
+          return option;
+        }
+      } else if (option.token.contractAddress && option.token.type === relayer.proto.FeeTokenType.ERC20_TOKEN) {
+        // ERC20 token
+        const token = new ethers.ethers.Contract(option.token.contractAddress, balanceOfAbi, this.provider);
+        const balance = await token.balanceOf(this.account.address);
+        if (balance.gte(ethers.ethers.BigNumber.from(option.value))) {
+          return option;
+        }
+      } else ;
+    }
+    throw new Error("No fee option available - not enough balance");
+  }
+  async sendTransaction(txsPromise) {
+    var _this$options$stubSig, _this$options2, _this$options$selectF, _this$options3, _this$options4;
+    const txs = isDeferrable(txsPromise) ? await ethers.ethers.utils.resolveProperties(txsPromise) : txsPromise;
+    const prepare = await this.account.prepareTransactions({
+      txs,
+      chainId: this.chainId,
+      stubSignatureOverrides: (_this$options$stubSig = (_this$options2 = this.options) == null ? void 0 : _this$options2.stubSignatureOverrides) != null ? _this$options$stubSig : new Map()
+    });
+    const selectMethod = (_this$options$selectF = (_this$options3 = this.options) == null ? void 0 : _this$options3.selectFee) != null ? _this$options$selectF : this.defaultSelectFee.bind(this);
+    const feeOption = await selectMethod(txs, prepare.feeOptions);
+    const finalTransactions = [...prepare.transactions, ...encodeGasRefundTransaction(feeOption)];
+    return this.account.sendTransaction(finalTransactions, this.chainId, prepare.feeQuote, undefined, undefined, (_this$options4 = this.options) != null && _this$options4.nonceSpace ? {
+      nonceSpace: this.options.nonceSpace
+    } : undefined);
+  }
+  getBalance(blockTag) {
+    return this.provider.getBalance(this.account.address, blockTag);
+  }
+  call(transaction, blockTag) {
+    return this.provider.call(transaction, blockTag);
+  }
+  async resolveName(name) {
+    const res = await this.provider.resolveName(name);
+    if (!res) throw new Error(`Could not resolve name ${name}`);
+    return res;
+  }
+  connect(_provider) {
+    throw new Error("Method not implemented.");
+  }
+  signTransaction(transaction) {
+    throw new Error("Method not implemented.");
+  }
+  getTransactionCount(blockTag) {
+    throw new Error("Method not implemented.");
+  }
+  estimateGas(transaction) {
+    throw new Error("Method not implemented.");
+  }
+  getChainId() {
+    return Promise.resolve(ethers.ethers.BigNumber.from(this.chainId).toNumber());
+  }
+  getGasPrice() {
+    throw new Error("Method not implemented.");
+  }
+  getFeeData() {
+    throw new Error("Method not implemented.");
+  }
+  checkTransaction(transaction) {
+    throw new Error("Method not implemented.");
+  }
+  populateTransaction(transaction) {
+    throw new Error("Method not implemented.");
+  }
+  _checkProvider(operation) {
+    throw new Error("Method not implemented.");
+  }
+}
+
 class Chain0Reader {
   async isDeployed(_wallet) {
     return false;
@@ -51,6 +211,9 @@ class Account {
     this.migrations = options.migrations || migration.defaults.DefaultMigrations;
     this.migrator = new migration.migrator.Migrator(options.tracker, this.migrations, this.contexts);
   }
+  getSigner(chainId, options) {
+    return new AccountSigner(this, chainId, options);
+  }
   static async new(options) {
     var _options$migrations;
     const mig = new migration.migrator.Migrator(options.tracker, (_options$migrations = options.migrations) != null ? _options$migrations : migration.defaults.DefaultMigrations, options.contexts);
@@ -92,7 +255,7 @@ class Account {
     if (!found) throw new Error(`Network not found for chainId ${chainId}`);
     return found;
   }
-  provider(chainId) {
+  providerFor(chainId) {
     const found = this.network(chainId);
     if (!found.provider && !found.rpcUrl) throw new Error(`Provider not found for chainId ${chainId}`);
     return found.provider || new ethers.ethers.providers.StaticJsonRpcProvider(utils.getDefaultConnectionInfo(found.rpcUrl), {
@@ -105,7 +268,7 @@ class Account {
 
     // TODO: Networks should be able to provide a reader directly
     // and we should default to the on-chain reader
-    return new core.commons.reader.OnChainReader(this.provider(chainId));
+    return new core.commons.reader.OnChainReader(this.providerFor(chainId));
   }
   relayer(chainId) {
     const found = this.network(chainId);
@@ -452,11 +615,13 @@ class Account {
   signMessage(message, chainId, cantValidateBehavior = 'ignore') {
     return this.signDigest(ethers.ethers.utils.keccak256(message), chainId, true, cantValidateBehavior);
   }
-  async signTransactions(txs, chainId, pstatus) {
+  async signTransactions(txs, chainId, pstatus, options) {
     const status = pstatus || (await this.status(chainId));
     this.mustBeFullyMigrated(status);
     const wallet = this.walletForStatus(chainId, status);
-    const signed = await wallet.signTransactions(txs);
+    const signed = await wallet.signTransactions(txs, (options == null ? void 0 : options.nonceSpace) && {
+      space: options == null ? void 0 : options.nonceSpace
+    });
     return _extends({}, signed, {
       signature: await this.decorateSignature(signed.signature, status)
     });
@@ -589,10 +754,10 @@ class Account {
       feeQuote: gasRefundQuote.quote
     };
   }
-  async sendTransaction(txs, chainId, quote, skipPreDecorate = false, callback) {
+  async sendTransaction(txs, chainId, quote, skipPreDecorate = false, callback, options) {
     const status = await this.status(chainId);
     const predecorated = skipPreDecorate ? txs : await this.predecorateTransactions(txs, status, chainId);
-    const signed = await this.signTransactions(predecorated, chainId);
+    const signed = await this.signTransactions(predecorated, chainId, undefined, options);
     // TODO: is it safe to pass status again here?
     return this.sendSignedTransactions(signed, chainId, quote, undefined, callback);
   }

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

@@ -1,6 +1,6 @@
 import { commons, universal } from '@0xsequence/core';
 import { defaults, migrator, version } from '@0xsequence/migration';
-import { isRelayer, RpcRelayer } from '@0xsequence/relayer';
+import { proto, isRelayer, RpcRelayer } from '@0xsequence/relayer';
 import { getDefaultConnectionInfo, encodeTypedDataDigest } from '@0xsequence/utils';
 import { Wallet } from '@0xsequence/wallet';
 import { ethers } from 'ethers';
@@ -20,6 +20,166 @@ function _extends() {
   return _extends.apply(this, arguments);
 }
 
+function isPromise(value) {
+  return !!value && typeof value.then === 'function';
+}
+function isDeferrable(value) {
+  // The value is deferrable if any of the properties is a Promises
+  if (typeof value === "object") {
+    return Object.keys(value).some(key => isPromise(value[key]));
+  }
+  return false;
+}
+
+function encodeGasRefundTransaction(option) {
+  if (!option) return [];
+  const value = ethers.BigNumber.from(option.value);
+  switch (option.token.type) {
+    case proto.FeeTokenType.UNKNOWN:
+      return [{
+        delegateCall: false,
+        revertOnError: true,
+        gasLimit: option.gasLimit,
+        to: option.to,
+        value: value.toHexString(),
+        data: []
+      }];
+    case proto.FeeTokenType.ERC20_TOKEN:
+      if (!option.token.contractAddress) {
+        throw new Error(`No contract address for ERC-20 fee option`);
+      }
+      return [{
+        delegateCall: false,
+        revertOnError: true,
+        gasLimit: option.gasLimit,
+        to: option.token.contractAddress,
+        value: 0,
+        data: new ethers.utils.Interface([{
+          "constant": false,
+          "inputs": [{
+            "type": "address"
+          }, {
+            "type": "uint256"
+          }],
+          "name": "transfer",
+          "outputs": [],
+          "type": "function"
+        }]).encodeFunctionData('transfer', [option.to, value.toHexString()])
+      }];
+    default:
+      throw new Error(`Unhandled fee token type ${option.token.type}`);
+  }
+}
+class AccountSigner {
+  constructor(account, chainId, options) {
+    this._isSigner = true;
+    this.account = account;
+    this.chainId = chainId;
+    this.options = options;
+  }
+  get provider() {
+    return this.account.providerFor(this.chainId);
+  }
+  async getAddress() {
+    return this.account.address;
+  }
+  signMessage(message) {
+    var _this$options$cantVal, _this$options;
+    return this.account.signMessage(message, this.chainId, (_this$options$cantVal = (_this$options = this.options) == null ? void 0 : _this$options.cantValidateBehavior) != null ? _this$options$cantVal : 'throw');
+  }
+  async defaultSelectFee(_txs, options) {
+    // If no options, return undefined
+    if (options.length === 0) return undefined;
+
+    // If there are multiple options, try them one by one
+    // until we find one that satisfies the balance requirement
+    const balanceOfAbi = [{
+      "constant": true,
+      "inputs": [{
+        "type": "address"
+      }],
+      "name": "balanceOf",
+      "outputs": [{
+        "type": "uint256"
+      }],
+      "type": "function"
+    }];
+    for (const option of options) {
+      if (option.token.type === proto.FeeTokenType.UNKNOWN) {
+        // Native token
+        const balance = await this.getBalance();
+        if (balance.gte(ethers.BigNumber.from(option.value))) {
+          return option;
+        }
+      } else if (option.token.contractAddress && option.token.type === proto.FeeTokenType.ERC20_TOKEN) {
+        // ERC20 token
+        const token = new ethers.Contract(option.token.contractAddress, balanceOfAbi, this.provider);
+        const balance = await token.balanceOf(this.account.address);
+        if (balance.gte(ethers.BigNumber.from(option.value))) {
+          return option;
+        }
+      } else ;
+    }
+    throw new Error("No fee option available - not enough balance");
+  }
+  async sendTransaction(txsPromise) {
+    var _this$options$stubSig, _this$options2, _this$options$selectF, _this$options3, _this$options4;
+    const txs = isDeferrable(txsPromise) ? await ethers.utils.resolveProperties(txsPromise) : txsPromise;
+    const prepare = await this.account.prepareTransactions({
+      txs,
+      chainId: this.chainId,
+      stubSignatureOverrides: (_this$options$stubSig = (_this$options2 = this.options) == null ? void 0 : _this$options2.stubSignatureOverrides) != null ? _this$options$stubSig : new Map()
+    });
+    const selectMethod = (_this$options$selectF = (_this$options3 = this.options) == null ? void 0 : _this$options3.selectFee) != null ? _this$options$selectF : this.defaultSelectFee.bind(this);
+    const feeOption = await selectMethod(txs, prepare.feeOptions);
+    const finalTransactions = [...prepare.transactions, ...encodeGasRefundTransaction(feeOption)];
+    return this.account.sendTransaction(finalTransactions, this.chainId, prepare.feeQuote, undefined, undefined, (_this$options4 = this.options) != null && _this$options4.nonceSpace ? {
+      nonceSpace: this.options.nonceSpace
+    } : undefined);
+  }
+  getBalance(blockTag) {
+    return this.provider.getBalance(this.account.address, blockTag);
+  }
+  call(transaction, blockTag) {
+    return this.provider.call(transaction, blockTag);
+  }
+  async resolveName(name) {
+    const res = await this.provider.resolveName(name);
+    if (!res) throw new Error(`Could not resolve name ${name}`);
+    return res;
+  }
+  connect(_provider) {
+    throw new Error("Method not implemented.");
+  }
+  signTransaction(transaction) {
+    throw new Error("Method not implemented.");
+  }
+  getTransactionCount(blockTag) {
+    throw new Error("Method not implemented.");
+  }
+  estimateGas(transaction) {
+    throw new Error("Method not implemented.");
+  }
+  getChainId() {
+    return Promise.resolve(ethers.BigNumber.from(this.chainId).toNumber());
+  }
+  getGasPrice() {
+    throw new Error("Method not implemented.");
+  }
+  getFeeData() {
+    throw new Error("Method not implemented.");
+  }
+  checkTransaction(transaction) {
+    throw new Error("Method not implemented.");
+  }
+  populateTransaction(transaction) {
+    throw new Error("Method not implemented.");
+  }
+  _checkProvider(operation) {
+    throw new Error("Method not implemented.");
+  }
+}
+
 class Chain0Reader {
   async isDeployed(_wallet) {
     return false;
@@ -47,6 +207,9 @@ class Account {
     this.migrations = options.migrations || defaults.DefaultMigrations;
     this.migrator = new migrator.Migrator(options.tracker, this.migrations, this.contexts);
   }
+  getSigner(chainId, options) {
+    return new AccountSigner(this, chainId, options);
+  }
   static async new(options) {
     var _options$migrations;
     const mig = new migrator.Migrator(options.tracker, (_options$migrations = options.migrations) != null ? _options$migrations : defaults.DefaultMigrations, options.contexts);
@@ -88,7 +251,7 @@ class Account {
     if (!found) throw new Error(`Network not found for chainId ${chainId}`);
     return found;
   }
-  provider(chainId) {
+  providerFor(chainId) {
     const found = this.network(chainId);
     if (!found.provider && !found.rpcUrl) throw new Error(`Provider not found for chainId ${chainId}`);
     return found.provider || new ethers.providers.StaticJsonRpcProvider(getDefaultConnectionInfo(found.rpcUrl), {
@@ -101,7 +264,7 @@ class Account {
 
     // TODO: Networks should be able to provide a reader directly
     // and we should default to the on-chain reader
-    return new commons.reader.OnChainReader(this.provider(chainId));
+    return new commons.reader.OnChainReader(this.providerFor(chainId));
   }
   relayer(chainId) {
     const found = this.network(chainId);
@@ -448,11 +611,13 @@ class Account {
   signMessage(message, chainId, cantValidateBehavior = 'ignore') {
     return this.signDigest(ethers.utils.keccak256(message), chainId, true, cantValidateBehavior);
   }
-  async signTransactions(txs, chainId, pstatus) {
+  async signTransactions(txs, chainId, pstatus, options) {
     const status = pstatus || (await this.status(chainId));
     this.mustBeFullyMigrated(status);
     const wallet = this.walletForStatus(chainId, status);
-    const signed = await wallet.signTransactions(txs);
+    const signed = await wallet.signTransactions(txs, (options == null ? void 0 : options.nonceSpace) && {
+      space: options == null ? void 0 : options.nonceSpace
+    });
     return _extends({}, signed, {
       signature: await this.decorateSignature(signed.signature, status)
     });
@@ -585,10 +750,10 @@ class Account {
       feeQuote: gasRefundQuote.quote
     };
   }
-  async sendTransaction(txs, chainId, quote, skipPreDecorate = false, callback) {
+  async sendTransaction(txs, chainId, quote, skipPreDecorate = false, callback, options) {
     const status = await this.status(chainId);
     const predecorated = skipPreDecorate ? txs : await this.predecorateTransactions(txs, status, chainId);
-    const signed = await this.signTransactions(predecorated, chainId);
+    const signed = await this.signTransactions(predecorated, chainId, undefined, options);
     // TODO: is it safe to pass status again here?
     return this.sendSignedTransactions(signed, chainId, quote, undefined, callback);
   }

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

@@ -1,11 +1,12 @@
 import { commons } from '@0xsequence/core';
 import { migrator } from '@0xsequence/migration';
-import { NetworkConfig } from '@0xsequence/network';
+import { ChainId, NetworkConfig } from '@0xsequence/network';
 import { FeeOption, FeeQuote, Relayer } from '@0xsequence/relayer';
 import { tracker } from '@0xsequence/sessions';
 import { Orchestrator } from '@0xsequence/signhub';
 import { Wallet } from '@0xsequence/wallet';
 import { ethers, TypedDataDomain, TypedDataField } from 'ethers';
+import { AccountSigner, AccountSignerOptions } from "./signer.js";
 export type AccountStatus = {
     original: {
         version: number;
@@ -50,6 +51,7 @@ export declare class Account {
     readonly migrations: migrator.Migrations;
     private orchestrator;
     constructor(options: AccountOptions);
+    getSigner(chainId: ChainId, options?: AccountSignerOptions): AccountSigner;
     static new(options: {
         config: commons.config.SimpleConfig;
         tracker: tracker.ConfigTracker & migrator.PresignedMigrationTracker;
@@ -65,7 +67,7 @@ export declare class Account {
         config: commons.config.ConfigCoder;
     };
     network(chainId: ethers.BigNumberish): NetworkConfig;
-    provider(chainId: ethers.BigNumberish): ethers.providers.Provider;
+    providerFor(chainId: ethers.BigNumberish): ethers.providers.Provider;
     reader(chainId: ethers.BigNumberish): commons.reader.Reader;
     relayer(chainId: ethers.BigNumberish): Relayer;
     setOrchestrator(orchestrator: Orchestrator): void;
@@ -101,7 +103,9 @@ export declare class Account {
     bootstrapTransactions(chainId: ethers.BigNumberish, prestatus?: AccountStatus): Promise<Omit<commons.transaction.IntendedTransactionBundle, 'chainId'>>;
     doBootstrap(chainId: ethers.BigNumberish, feeQuote?: FeeQuote, prestatus?: AccountStatus): Promise<commons.transaction.TransactionResponse<any>>;
     signMessage(message: ethers.BytesLike, chainId: ethers.BigNumberish, cantValidateBehavior?: 'ignore' | 'eip6492' | 'throw'): Promise<string>;
-    signTransactions(txs: commons.transaction.Transactionish, chainId: ethers.BigNumberish, pstatus?: AccountStatus): Promise<commons.transaction.SignedTransactionBundle>;
+    signTransactions(txs: commons.transaction.Transactionish, chainId: ethers.BigNumberish, pstatus?: AccountStatus, options?: {
+        nonceSpace?: ethers.BigNumberish;
+    }): Promise<commons.transaction.SignedTransactionBundle>;
     signMigrations(chainId: ethers.BigNumberish, editConfig: (prevConfig: commons.config.Config) => commons.config.Config): Promise<boolean>;
     signAllMigrations(editConfig: (prevConfig: commons.config.Config) => commons.config.Config): Promise<{
         signedMigrations: Array<any>;
@@ -123,7 +127,9 @@ export declare class Account {
         chainId: ethers.BigNumberish;
         stubSignatureOverrides: Map<string, string>;
     }): Promise<PreparedTransactions>;
-    sendTransaction(txs: commons.transaction.Transactionish, chainId: ethers.BigNumberish, quote?: FeeQuote, skipPreDecorate?: boolean, callback?: (bundle: commons.transaction.IntendedTransactionBundle) => void): Promise<ethers.providers.TransactionResponse>;
+    sendTransaction(txs: commons.transaction.Transactionish, chainId: ethers.BigNumberish, quote?: FeeQuote, skipPreDecorate?: boolean, callback?: (bundle: commons.transaction.IntendedTransactionBundle) => void, options?: {
+        nonceSpace?: ethers.BigNumberish;
+    }): Promise<ethers.providers.TransactionResponse>;
     signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, message: Record<string, any>, chainId: ethers.BigNumberish, cantValidateBehavior?: 'ignore' | 'eip6492' | 'throw'): Promise<string>;
     getAllSigners(): Promise<{
         address: string;

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

@@ -0,0 +1,36 @@
+import { ChainId } from "@0xsequence/network";
+import { Account } from "./account.js";
+import { ethers } from "ethers";
+import { commons } from "@0xsequence/core";
+import { FeeOption } from "@0xsequence/relayer";
+export type AccountSignerOptions = {
+    nonceSpace?: ethers.BigNumberish;
+    cantValidateBehavior?: 'ignore' | 'eip6492' | 'throw';
+    stubSignatureOverrides?: Map<string, string>;
+    selectFee?: (txs: ethers.utils.Deferrable<ethers.providers.TransactionRequest> | commons.transaction.Transactionish, options: FeeOption[]) => Promise<FeeOption | undefined>;
+};
+export declare class AccountSigner implements ethers.Signer {
+    account: Account;
+    chainId: ChainId;
+    readonly options?: AccountSignerOptions | undefined;
+    readonly _isSigner = true;
+    constructor(account: Account, chainId: ChainId, options?: AccountSignerOptions | undefined);
+    get provider(): ethers.providers.Provider;
+    getAddress(): Promise<string>;
+    signMessage(message: string | ethers.utils.Bytes): Promise<string>;
+    private defaultSelectFee;
+    sendTransaction(txsPromise: ethers.utils.Deferrable<ethers.providers.TransactionRequest> | commons.transaction.Transactionish): Promise<ethers.providers.TransactionResponse>;
+    getBalance(blockTag?: ethers.providers.BlockTag | undefined): Promise<ethers.BigNumber>;
+    call(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>, blockTag?: ethers.providers.BlockTag | undefined): Promise<string>;
+    resolveName(name: string): Promise<string>;
+    connect(_provider: ethers.providers.Provider): ethers.Signer;
+    signTransaction(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>): Promise<string>;
+    getTransactionCount(blockTag?: ethers.providers.BlockTag | undefined): Promise<number>;
+    estimateGas(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>): Promise<ethers.BigNumber>;
+    getChainId(): Promise<number>;
+    getGasPrice(): Promise<ethers.BigNumber>;
+    getFeeData(): Promise<ethers.providers.FeeData>;
+    checkTransaction(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>): ethers.utils.Deferrable<ethers.providers.TransactionRequest>;
+    populateTransaction(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>): Promise<ethers.providers.TransactionRequest>;
+    _checkProvider(operation?: string | undefined): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/account",
-  "version": "1.1.14",
+  "version": "1.2.0",
   "description": "tools for migrating sequence wallets to new versions",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/account",
   "source": "src/index.ts",
@@ -10,19 +10,19 @@
   "license": "Apache-2.0",
   "dependencies": {
     "ethers": "^5.5.2",
-    "@0xsequence/core": "1.1.14",
-    "@0xsequence/migration": "1.1.14",
-    "@0xsequence/network": "1.1.14",
-    "@0xsequence/sessions": "1.1.14",
-    "@0xsequence/relayer": "1.1.14",
-    "@0xsequence/utils": "1.1.14",
-    "@0xsequence/wallet": "1.1.14"
+    "@0xsequence/core": "1.2.0",
+    "@0xsequence/migration": "1.2.0",
+    "@0xsequence/relayer": "1.2.0",
+    "@0xsequence/network": "1.2.0",
+    "@0xsequence/sessions": "1.2.0",
+    "@0xsequence/utils": "1.2.0",
+    "@0xsequence/wallet": "1.2.0"
   },
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "nyc": "^15.1.0",
-    "@0xsequence/signhub": "1.1.14",
-    "@0xsequence/tests": "1.1.14"
+    "@0xsequence/signhub": "1.2.0",
+    "@0xsequence/tests": "1.2.0"
   },
   "files": [
     "src",

package/src/account.ts

@@ -1,12 +1,13 @@
 import { commons, universal } from '@0xsequence/core'
 import { migrator, defaults, version } from '@0xsequence/migration'
-import { NetworkConfig } from '@0xsequence/network'
+import { ChainId, NetworkConfig } from '@0xsequence/network'
 import { FeeOption, FeeQuote, isRelayer, Relayer, RpcRelayer } from '@0xsequence/relayer'
 import { tracker } from '@0xsequence/sessions'
 import { Orchestrator } from '@0xsequence/signhub'
 import { encodeTypedDataDigest, getDefaultConnectionInfo } from '@0xsequence/utils'
 import { Wallet } from '@0xsequence/wallet'
 import { ethers, TypedDataDomain, TypedDataField } from 'ethers'
+import { AccountSigner, AccountSignerOptions } from './signer'
 
 export type AccountStatus = {
   original: {
@@ -106,6 +107,10 @@ export class Account {
     this.migrator = new migrator.Migrator(options.tracker, this.migrations, this.contexts)
   }
 
+  getSigner(chainId: ChainId, options?: AccountSignerOptions): AccountSigner {
+    return new AccountSigner(this, chainId, options)
+  }
+
   static async new(options: {
     config: commons.config.SimpleConfig
     tracker: tracker.ConfigTracker & migrator.PresignedMigrationTracker
@@ -163,7 +168,7 @@ export class Account {
     return found
   }
 
-  provider(chainId: ethers.BigNumberish): ethers.providers.Provider {
+  providerFor(chainId: ethers.BigNumberish): ethers.providers.Provider {
     const found = this.network(chainId)
     if (!found.provider && !found.rpcUrl) throw new Error(`Provider not found for chainId ${chainId}`)
     return (
@@ -180,7 +185,7 @@ export class Account {
 
     // TODO: Networks should be able to provide a reader directly
     // and we should default to the on-chain reader
-    return new commons.reader.OnChainReader(this.provider(chainId))
+    return new commons.reader.OnChainReader(this.providerFor(chainId))
   }
 
   relayer(chainId: ethers.BigNumberish): Relayer {
@@ -608,13 +613,16 @@ export class Account {
   async signTransactions(
     txs: commons.transaction.Transactionish,
     chainId: ethers.BigNumberish,
-    pstatus?: AccountStatus
+    pstatus?: AccountStatus,
+    options?: {
+      nonceSpace?: ethers.BigNumberish
+    }
   ): Promise<commons.transaction.SignedTransactionBundle> {
     const status = pstatus || (await this.status(chainId))
     this.mustBeFullyMigrated(status)
 
     const wallet = this.walletForStatus(chainId, status)
-    const signed = await wallet.signTransactions(txs)
+    const signed = await wallet.signTransactions(txs, options?.nonceSpace && { space: options?.nonceSpace })
 
     return {
       ...signed,
@@ -788,11 +796,15 @@ export class Account {
     chainId: ethers.BigNumberish,
     quote?: FeeQuote,
     skipPreDecorate: boolean = false,
-    callback?: (bundle: commons.transaction.IntendedTransactionBundle) => void
+    callback?: (bundle: commons.transaction.IntendedTransactionBundle) => void,
+    options?: {
+      nonceSpace?: ethers.BigNumberish
+    }
   ): Promise<ethers.providers.TransactionResponse> {
     const status = await this.status(chainId)
+
     const predecorated = skipPreDecorate ? txs : await this.predecorateTransactions(txs, status, chainId)
-    const signed = await this.signTransactions(predecorated, chainId)
+    const signed = await this.signTransactions(predecorated, chainId, undefined, options)
     // TODO: is it safe to pass status again here?
     return this.sendSignedTransactions(signed, chainId, quote, undefined, callback)
   }

package/src/signer.ts

@@ -0,0 +1,221 @@
+import { ChainId } from "@0xsequence/network"
+import { Account } from "./account"
+import { ethers } from "ethers"
+import { commons } from "@0xsequence/core"
+import { FeeOption, proto } from "@0xsequence/relayer"
+import { isDeferrable } from "./utils"
+
+export type AccountSignerOptions = {
+  nonceSpace?: ethers.BigNumberish,
+  cantValidateBehavior?: 'ignore' | 'eip6492' | 'throw',
+  stubSignatureOverrides?: Map<string, string>,
+  selectFee?: (
+    txs: ethers.utils.Deferrable<ethers.providers.TransactionRequest> | commons.transaction.Transactionish,
+    options: FeeOption[]
+  ) => Promise<FeeOption | undefined>
+}
+
+function encodeGasRefundTransaction(option?: FeeOption) {
+  if (!option) return []
+
+  const value = ethers.BigNumber.from(option.value)
+
+  switch (option.token.type) {
+    case proto.FeeTokenType.UNKNOWN:
+      return [{
+        delegateCall: false,
+        revertOnError: true,
+        gasLimit: option.gasLimit,
+        to: option.to,
+        value: value.toHexString(),
+        data: []
+      }]
+
+    case proto.FeeTokenType.ERC20_TOKEN:
+      if (!option.token.contractAddress) {
+        throw new Error(`No contract address for ERC-20 fee option`)
+      }
+
+      return [{
+        delegateCall: false,
+        revertOnError: true,
+        gasLimit: option.gasLimit,
+        to: option.token.contractAddress,
+        value: 0,
+        data: new ethers.utils.Interface([{
+          "constant": false,
+          "inputs": [
+            {"type": "address"},
+            {"type": "uint256"}
+          ],
+          "name": "transfer",
+          "outputs": [],
+          "type": "function"
+        }]).encodeFunctionData('transfer', [option.to, value.toHexString()])
+      }]
+
+    default:
+      throw new Error(`Unhandled fee token type ${option.token.type}`)
+  }
+}
+
+export class AccountSigner implements ethers.Signer {
+  public readonly _isSigner = true
+
+  constructor (
+    public account: Account,
+    public chainId: ChainId,
+    public readonly options?: AccountSignerOptions
+  ) {}
+
+  get provider() {
+    return this.account.providerFor(this.chainId)
+  }
+
+  async getAddress(): Promise<string> {
+    return this.account.address
+  }
+
+  signMessage(
+    message: string | ethers.utils.Bytes
+  ): Promise<string> {
+    return this.account.signMessage(
+      message,
+      this.chainId,
+      this.options?.cantValidateBehavior ?? 'throw'
+    )
+  }
+
+  private async defaultSelectFee(
+    _txs: ethers.utils.Deferrable<ethers.providers.TransactionRequest> | commons.transaction.Transactionish,
+    options: FeeOption[]
+  ): Promise<FeeOption | undefined> {
+    // If no options, return undefined
+    if (options.length === 0) return undefined
+
+    // If there are multiple options, try them one by one
+    // until we find one that satisfies the balance requirement
+    const balanceOfAbi = [{
+      "constant": true,
+      "inputs": [{"type": "address"}],
+      "name": "balanceOf",
+      "outputs": [{"type": "uint256"}],
+      "type": "function"
+    }]
+    
+    for (const option of options) {
+      if (option.token.type === proto.FeeTokenType.UNKNOWN) {
+        // Native token
+        const balance = await this.getBalance()
+        if (balance.gte(ethers.BigNumber.from(option.value))) {
+          return option
+        }
+      } else if (option.token.contractAddress && option.token.type === proto.FeeTokenType.ERC20_TOKEN) {
+        // ERC20 token
+        const token = new ethers.Contract(option.token.contractAddress, balanceOfAbi, this.provider)
+        const balance = await token.balanceOf(this.account.address)
+        if (balance.gte(ethers.BigNumber.from(option.value))) {
+          return option
+        }
+      } else {
+        // Unsupported token type
+      }
+    }
+
+    throw new Error("No fee option available - not enough balance")
+  }
+
+  async sendTransaction(
+    txsPromise: ethers.utils.Deferrable<ethers.providers.TransactionRequest> | commons.transaction.Transactionish
+  ): Promise<ethers.providers.TransactionResponse> {
+    const txs = isDeferrable(txsPromise) ? (
+      await ethers.utils.resolveProperties(txsPromise as ethers.utils.Deferrable<ethers.providers.TransactionRequest>))
+      : txsPromise
+
+    const prepare = await this.account.prepareTransactions({
+      txs,
+      chainId: this.chainId,
+      stubSignatureOverrides: this.options?.stubSignatureOverrides ?? new Map()
+    })
+
+    const selectMethod = this.options?.selectFee ?? this.defaultSelectFee.bind(this)
+    const feeOption = await selectMethod(txs, prepare.feeOptions)
+
+    const finalTransactions = [
+      ...prepare.transactions,
+      ...encodeGasRefundTransaction(feeOption)
+    ]
+
+    return this.account.sendTransaction(
+      finalTransactions,
+      this.chainId,
+      prepare.feeQuote,
+      undefined,
+      undefined,
+      this.options?.nonceSpace ? {
+        nonceSpace: this.options.nonceSpace
+      } : undefined
+    )
+  }
+
+  getBalance(blockTag?: ethers.providers.BlockTag | undefined): Promise<ethers.BigNumber> {
+    return this.provider.getBalance(this.account.address, blockTag)
+  }
+
+  call(
+    transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>,
+    blockTag?: ethers.providers.BlockTag | undefined
+  ): Promise<string> {
+    return this.provider.call(transaction, blockTag)
+  }
+
+  async resolveName(name: string): Promise<string> {
+    const res = await this.provider.resolveName(name)
+    if (!res) throw new Error(`Could not resolve name ${name}`)
+    return res
+  }
+
+  connect(_provider: ethers.providers.Provider): ethers.Signer {
+    throw new Error("Method not implemented.")
+  }
+
+  signTransaction(
+    transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>
+  ): Promise<string> {
+    throw new Error("Method not implemented.")
+  }
+
+  getTransactionCount(blockTag?: ethers.providers.BlockTag | undefined): Promise<number> {
+    throw new Error("Method not implemented.")
+  }
+
+  estimateGas(
+    transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>
+  ): Promise<ethers.BigNumber> {
+    throw new Error("Method not implemented.")
+  }
+
+  getChainId(): Promise<number> {
+    return Promise.resolve(ethers.BigNumber.from(this.chainId).toNumber())
+  }
+
+  getGasPrice(): Promise<ethers.BigNumber> {
+    throw new Error("Method not implemented.")
+  }
+
+  getFeeData(): Promise<ethers.providers.FeeData> {
+    throw new Error("Method not implemented.")
+  }
+
+  checkTransaction(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>): ethers.utils.Deferrable<ethers.providers.TransactionRequest> {
+    throw new Error("Method not implemented.")
+  }
+
+  populateTransaction(transaction: ethers.utils.Deferrable<ethers.providers.TransactionRequest>): Promise<ethers.providers.TransactionRequest> {
+    throw new Error("Method not implemented.")
+  }
+
+  _checkProvider(operation?: string | undefined): void {
+    throw new Error("Method not implemented.")
+  }
+}

package/src/utils.ts

@@ -0,0 +1,14 @@
+import { ethers } from "ethers"
+
+function isPromise(value: any): value is Promise<any> {
+  return !!value && typeof value.then === 'function'
+}
+
+export function isDeferrable<T>(value: any): value is ethers.utils.Deferrable<T> {
+  // The value is deferrable if any of the properties is a Promises
+  if (typeof(value) === "object") {
+    return Object.keys(value).some((key) => isPromise(value[key]))
+  }
+
+  return false
+}