@0xsequence/account 1.2.8 → 1.3.0

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

@@ -126,21 +126,23 @@ class AccountSigner {
     }
     throw new Error('No fee option available - not enough balance');
   }
-  async sendTransaction(txsPromise) {
+  async sendTransaction(txsPromise, options) {
     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()
+      stubSignatureOverrides: (_this$options$stubSig = (_this$options2 = this.options) == null ? void 0 : _this$options2.stubSignatureOverrides) != null ? _this$options$stubSig : new Map(),
+      simulateForFeeOptions: options == null ? void 0 : options.simulateForFeeOptions
     });
     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);
+    } : undefined); // Will always have a transaction response
   }
+
   getBalance(blockTag) {
     return this.provider.getBalance(this.account.address, blockTag);
   }
@@ -409,6 +411,19 @@ class Account {
       throw new Error(`Wallet ${this.address} is not fully migrated`);
     }
   }
+  async predecorateSignedTransactions(status, chainId) {
+    // Request signed predecorate transactions from child wallets
+    const bundles = await this.orchestrator.predecorateSignedTransactions({
+      chainId
+    });
+    // Get signed predecorate transaction
+    const predecorated = await this.predecorateTransactions([], status, chainId);
+    if (core.commons.transaction.fromTransactionish(this.address, predecorated).length > 0) {
+      // Sign it
+      bundles.push(await this.signTransactions(predecorated, chainId));
+    }
+    return bundles;
+  }
   async predecorateTransactions(txs, status, chainId) {
     // if onchain wallet config is not up to date
     // then we should append an extra transaction that updates it
@@ -420,34 +435,49 @@ class Account {
     }
     return txs;
   }
-  decorateTransactions(bundle, status) {
-    const bootstrapBundle = this.buildBootstrapTransactions(status, bundle.chainId);
-    if (bootstrapBundle.transactions.length === 0) {
-      return bundle;
+  async decorateTransactions(bundles, status, chainId) {
+    var _chainId;
+    if (!Array.isArray(bundles)) {
+      // Recurse with array
+      return this.decorateTransactions([bundles], status, chainId);
     }
+
+    // Default to chainId of first bundle when not supplied
+    chainId = (_chainId = chainId) != null ? _chainId : bundles[0].chainId;
+    const bootstrapBundle = await this.buildBootstrapTransactions(status, chainId);
+    const hasBootstrapTxs = bootstrapBundle.transactions.length > 0;
+    if (!hasBootstrapTxs && bundles.length === 1) {
+      return bundles[0];
+    }
+
+    // Intent defaults to first bundle when no bootstrap transaction
+    const {
+      entrypoint
+    } = hasBootstrapTxs ? bootstrapBundle : bundles[0];
     const decoratedBundle = {
-      entrypoint: bootstrapBundle.entrypoint,
-      chainId: bundle.chainId,
-      intent: bundle.intent,
-      transactions: [...bootstrapBundle.transactions, {
+      entrypoint,
+      chainId,
+      // Intent of the first bundle is used
+      intent: bundles[0].intent,
+      transactions: [...bootstrapBundle.transactions, ...bundles.map(bundle => ({
         to: bundle.entrypoint,
         data: core.commons.transaction.encodeBundleExecData(bundle),
         gasLimit: 0,
         delegateCall: false,
         revertOnError: true,
         value: 0
-      }]
+      }))]
     };
 
     // Re-compute the meta-transaction id to use the guest module subdigest
     if (!status.onChain.deployed) {
-      decoratedBundle.intent.id = core.commons.transaction.subdigestOfGuestModuleTransactions(this.contexts[this.version].guestModule, decoratedBundle.chainId, decoratedBundle.transactions);
+      decoratedBundle.intent.id = core.commons.transaction.subdigestOfGuestModuleTransactions(this.contexts[this.version].guestModule, chainId, decoratedBundle.transactions);
     }
     return decoratedBundle;
   }
-  decorateSignature(signature, status) {
+  async decorateSignature(signature, status) {
     if (!status.presignedConfigurations || status.presignedConfigurations.length === 0) {
-      return new Promise(resolve => resolve(signature));
+      return signature;
     }
     const coder = this.coders.signature;
     const chain = status.presignedConfigurations.map(c => c.signature);
@@ -466,14 +496,13 @@ class Account {
       signatures
     });
   }
-  async signDigest(digest, chainId, decorate = true, cantValidateBehavior = 'ignore') {
+  async signDigest(digest, chainId, decorate = true, cantValidateBehavior = 'ignore', metadata) {
     // If we are signing a digest for chainId zero then we can never be fully migrated
     // because Sequence v1 doesn't allow for signing a message on "all chains"
 
     // So we ignore the state on "chain zero" and instead use one of the states of the networks
     // wallet-webapp should ensure the wallet is as migrated as possible, trying to mimic
     // the behaviour of being migrated on all chains
-
     const chainRef = ethers.ethers.constants.Zero.eq(chainId) ? this.networks[0].chainId : chainId;
     const status = await this.status(chainRef);
     this.mustBeFullyMigrated(status);
@@ -484,7 +513,7 @@ class Account {
       throw new Error('Wallet cannot validate onchain');
     }
     const wallet = this.walletForStatus(chainId, status);
-    const signature = await wallet.signDigest(digest);
+    const signature = await wallet.signDigest(digest, metadata);
     const decorated = decorate ? this.decorateSignature(signature, status) : signature;
 
     // If the wallet can't validate onchain then we
@@ -503,8 +532,8 @@ class Account {
     }
     return decorated;
   }
-  buildEIP6492Signature(signature, status, chainId) {
-    const bootstrapBundle = this.buildBootstrapTransactions(status, chainId);
+  async buildEIP6492Signature(signature, status, chainId) {
+    const bootstrapBundle = await this.buildBootstrapTransactions(status, chainId);
     if (bootstrapBundle.transactions.length === 0) {
       throw new Error('Cannot build EIP-6492 signature without bootstrap transactions');
     }
@@ -560,8 +589,12 @@ class Account {
    *  by any of the migrations.
    *
    */
-  buildBootstrapTransactions(status, chainId) {
-    const transactions = [];
+  async buildBootstrapTransactions(status, chainId) {
+    var _bundle$transactions;
+    const bundle = await this.orchestrator.buildDeployTransaction({
+      chainId
+    });
+    const transactions = (_bundle$transactions = bundle == null ? void 0 : bundle.transactions) != null ? _bundle$transactions : [];
 
     // Add wallet deployment if needed
     if (!status.onChain.deployed) {
@@ -570,6 +603,7 @@ class Account {
       const deployTransaction = wallet.Wallet.buildDeployTransaction(status.original.context, status.original.imageHash);
       transactions.push(...deployTransaction.transactions);
     }
+    transactions.length;
 
     // Get pending migrations
     transactions.push(...status.signedMigrations.map(m => ({
@@ -619,9 +653,20 @@ class Account {
     const status = pstatus || (await this.status(chainId));
     this.mustBeFullyMigrated(status);
     const wallet = this.walletForStatus(chainId, status);
+    const metadata = {
+      address: this.address,
+      digest: '',
+      // Set in wallet.signTransactions
+      chainId,
+      config: {
+        version: this.version
+      },
+      decorate: true,
+      cantValidateBehavior: 'ignore'
+    };
     const signed = await wallet.signTransactions(txs, (options == null ? void 0 : options.nonceSpace) && {
       space: options == null ? void 0 : options.nonceSpace
-    });
+    }, metadata);
     return _extends({}, signed, {
       signature: await this.decorateSignature(signed.signature, status)
     });
@@ -700,9 +745,12 @@ class Account {
     };
   }
   async sendSignedTransactions(signedBundle, chainId, quote, pstatus, callback) {
-    const status = pstatus || (await this.status(signedBundle.chainId));
+    if (!Array.isArray(signedBundle)) {
+      return this.sendSignedTransactions([signedBundle], chainId, quote, pstatus, callback);
+    }
+    const status = pstatus || (await this.status(signedBundle[0].chainId));
     this.mustBeFullyMigrated(status);
-    const decoratedBundle = this.decorateTransactions(signedBundle, status);
+    const decoratedBundle = await this.decorateTransactions(signedBundle, status);
     callback == null ? void 0 : callback(decoratedBundle);
     return this.relayer(chainId).relay(decoratedBundle, quote);
   }
@@ -710,7 +758,7 @@ class Account {
     const wallet = this.walletForStatus(chainId, status || (await this.status(chainId)));
     return wallet.fillGasLimits(txs);
   }
-  async gasRefundQuotes(txs, chainId, stubSignatureOverrides, status) {
+  async gasRefundQuotes(txs, chainId, stubSignatureOverrides, status, options) {
     const wstatus = status || (await this.status(chainId));
     const wallet = this.walletForStatus(chainId, wstatus);
     const predecorated = await this.predecorateTransactions(txs, wstatus, chainId);
@@ -735,9 +783,9 @@ class Account {
       nonce: 0 // The relayer also ignored the nonce
     };
 
-    const decoratedBundle = this.decorateTransactions(signedBundle, wstatus);
+    const decoratedBundle = await this.decorateTransactions(signedBundle, wstatus);
     const data = core.commons.transaction.encodeBundleExecData(decoratedBundle);
-    const res = await this.relayer(chainId).getFeeOptionsRaw(decoratedBundle.entrypoint, data);
+    const res = await this.relayer(chainId).getFeeOptionsRaw(decoratedBundle.entrypoint, data, options);
     return _extends({}, res, {
       decorated: decoratedBundle
     });
@@ -745,7 +793,9 @@ class Account {
   async prepareTransactions(args) {
     const status = await this.status(args.chainId);
     const transactions = await this.fillGasLimits(args.txs, args.chainId, status);
-    const gasRefundQuote = await this.gasRefundQuotes(transactions, args.chainId, args.stubSignatureOverrides, status);
+    const gasRefundQuote = await this.gasRefundQuotes(transactions, args.chainId, args.stubSignatureOverrides, status, {
+      simulate: args.simulateForFeeOptions
+    });
     const flatDecorated = core.commons.transaction.unwind(this.address, gasRefundQuote.decorated.transactions);
     return {
       transactions,
@@ -757,9 +807,21 @@ class Account {
   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, undefined, options);
-    // TODO: is it safe to pass status again here?
-    return this.sendSignedTransactions(signed, chainId, quote, undefined, callback);
+    const hasTxs = core.commons.transaction.fromTransactionish(this.address, predecorated).length > 0;
+    const signed = hasTxs ? await this.signTransactions(predecorated, chainId, undefined, options) : undefined;
+    const childBundles = await this.orchestrator.predecorateSignedTransactions({
+      chainId
+    });
+    const bundles = [];
+    if (signed !== undefined && signed.transactions.length > 0) {
+      bundles.push(signed);
+    }
+    bundles.push(...childBundles.filter(b => b.transactions.length > 0));
+    if (bundles.length === 0) {
+      // Nothing to send?
+      return;
+    }
+    return this.sendSignedTransactions(bundles, chainId, quote, undefined, callback);
   }
   async signTypedData(domain, types, message, chainId, cantValidateBehavior = 'ignore') {
     const digest = utils.encodeTypedDataDigest({

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

@@ -126,21 +126,23 @@ class AccountSigner {
     }
     throw new Error('No fee option available - not enough balance');
   }
-  async sendTransaction(txsPromise) {
+  async sendTransaction(txsPromise, options) {
     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()
+      stubSignatureOverrides: (_this$options$stubSig = (_this$options2 = this.options) == null ? void 0 : _this$options2.stubSignatureOverrides) != null ? _this$options$stubSig : new Map(),
+      simulateForFeeOptions: options == null ? void 0 : options.simulateForFeeOptions
     });
     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);
+    } : undefined); // Will always have a transaction response
   }
+
   getBalance(blockTag) {
     return this.provider.getBalance(this.account.address, blockTag);
   }
@@ -409,6 +411,19 @@ class Account {
       throw new Error(`Wallet ${this.address} is not fully migrated`);
     }
   }
+  async predecorateSignedTransactions(status, chainId) {
+    // Request signed predecorate transactions from child wallets
+    const bundles = await this.orchestrator.predecorateSignedTransactions({
+      chainId
+    });
+    // Get signed predecorate transaction
+    const predecorated = await this.predecorateTransactions([], status, chainId);
+    if (core.commons.transaction.fromTransactionish(this.address, predecorated).length > 0) {
+      // Sign it
+      bundles.push(await this.signTransactions(predecorated, chainId));
+    }
+    return bundles;
+  }
   async predecorateTransactions(txs, status, chainId) {
     // if onchain wallet config is not up to date
     // then we should append an extra transaction that updates it
@@ -420,34 +435,49 @@ class Account {
     }
     return txs;
   }
-  decorateTransactions(bundle, status) {
-    const bootstrapBundle = this.buildBootstrapTransactions(status, bundle.chainId);
-    if (bootstrapBundle.transactions.length === 0) {
-      return bundle;
+  async decorateTransactions(bundles, status, chainId) {
+    var _chainId;
+    if (!Array.isArray(bundles)) {
+      // Recurse with array
+      return this.decorateTransactions([bundles], status, chainId);
     }
+
+    // Default to chainId of first bundle when not supplied
+    chainId = (_chainId = chainId) != null ? _chainId : bundles[0].chainId;
+    const bootstrapBundle = await this.buildBootstrapTransactions(status, chainId);
+    const hasBootstrapTxs = bootstrapBundle.transactions.length > 0;
+    if (!hasBootstrapTxs && bundles.length === 1) {
+      return bundles[0];
+    }
+
+    // Intent defaults to first bundle when no bootstrap transaction
+    const {
+      entrypoint
+    } = hasBootstrapTxs ? bootstrapBundle : bundles[0];
     const decoratedBundle = {
-      entrypoint: bootstrapBundle.entrypoint,
-      chainId: bundle.chainId,
-      intent: bundle.intent,
-      transactions: [...bootstrapBundle.transactions, {
+      entrypoint,
+      chainId,
+      // Intent of the first bundle is used
+      intent: bundles[0].intent,
+      transactions: [...bootstrapBundle.transactions, ...bundles.map(bundle => ({
         to: bundle.entrypoint,
         data: core.commons.transaction.encodeBundleExecData(bundle),
         gasLimit: 0,
         delegateCall: false,
         revertOnError: true,
         value: 0
-      }]
+      }))]
     };
 
     // Re-compute the meta-transaction id to use the guest module subdigest
     if (!status.onChain.deployed) {
-      decoratedBundle.intent.id = core.commons.transaction.subdigestOfGuestModuleTransactions(this.contexts[this.version].guestModule, decoratedBundle.chainId, decoratedBundle.transactions);
+      decoratedBundle.intent.id = core.commons.transaction.subdigestOfGuestModuleTransactions(this.contexts[this.version].guestModule, chainId, decoratedBundle.transactions);
     }
     return decoratedBundle;
   }
-  decorateSignature(signature, status) {
+  async decorateSignature(signature, status) {
     if (!status.presignedConfigurations || status.presignedConfigurations.length === 0) {
-      return new Promise(resolve => resolve(signature));
+      return signature;
     }
     const coder = this.coders.signature;
     const chain = status.presignedConfigurations.map(c => c.signature);
@@ -466,14 +496,13 @@ class Account {
       signatures
     });
   }
-  async signDigest(digest, chainId, decorate = true, cantValidateBehavior = 'ignore') {
+  async signDigest(digest, chainId, decorate = true, cantValidateBehavior = 'ignore', metadata) {
     // If we are signing a digest for chainId zero then we can never be fully migrated
     // because Sequence v1 doesn't allow for signing a message on "all chains"
 
     // So we ignore the state on "chain zero" and instead use one of the states of the networks
     // wallet-webapp should ensure the wallet is as migrated as possible, trying to mimic
     // the behaviour of being migrated on all chains
-
     const chainRef = ethers.ethers.constants.Zero.eq(chainId) ? this.networks[0].chainId : chainId;
     const status = await this.status(chainRef);
     this.mustBeFullyMigrated(status);
@@ -484,7 +513,7 @@ class Account {
       throw new Error('Wallet cannot validate onchain');
     }
     const wallet = this.walletForStatus(chainId, status);
-    const signature = await wallet.signDigest(digest);
+    const signature = await wallet.signDigest(digest, metadata);
     const decorated = decorate ? this.decorateSignature(signature, status) : signature;
 
     // If the wallet can't validate onchain then we
@@ -503,8 +532,8 @@ class Account {
     }
     return decorated;
   }
-  buildEIP6492Signature(signature, status, chainId) {
-    const bootstrapBundle = this.buildBootstrapTransactions(status, chainId);
+  async buildEIP6492Signature(signature, status, chainId) {
+    const bootstrapBundle = await this.buildBootstrapTransactions(status, chainId);
     if (bootstrapBundle.transactions.length === 0) {
       throw new Error('Cannot build EIP-6492 signature without bootstrap transactions');
     }
@@ -560,8 +589,12 @@ class Account {
    *  by any of the migrations.
    *
    */
-  buildBootstrapTransactions(status, chainId) {
-    const transactions = [];
+  async buildBootstrapTransactions(status, chainId) {
+    var _bundle$transactions;
+    const bundle = await this.orchestrator.buildDeployTransaction({
+      chainId
+    });
+    const transactions = (_bundle$transactions = bundle == null ? void 0 : bundle.transactions) != null ? _bundle$transactions : [];
 
     // Add wallet deployment if needed
     if (!status.onChain.deployed) {
@@ -570,6 +603,7 @@ class Account {
       const deployTransaction = wallet.Wallet.buildDeployTransaction(status.original.context, status.original.imageHash);
       transactions.push(...deployTransaction.transactions);
     }
+    transactions.length;
 
     // Get pending migrations
     transactions.push(...status.signedMigrations.map(m => ({
@@ -619,9 +653,20 @@ class Account {
     const status = pstatus || (await this.status(chainId));
     this.mustBeFullyMigrated(status);
     const wallet = this.walletForStatus(chainId, status);
+    const metadata = {
+      address: this.address,
+      digest: '',
+      // Set in wallet.signTransactions
+      chainId,
+      config: {
+        version: this.version
+      },
+      decorate: true,
+      cantValidateBehavior: 'ignore'
+    };
     const signed = await wallet.signTransactions(txs, (options == null ? void 0 : options.nonceSpace) && {
       space: options == null ? void 0 : options.nonceSpace
-    });
+    }, metadata);
     return _extends({}, signed, {
       signature: await this.decorateSignature(signed.signature, status)
     });
@@ -700,9 +745,12 @@ class Account {
     };
   }
   async sendSignedTransactions(signedBundle, chainId, quote, pstatus, callback) {
-    const status = pstatus || (await this.status(signedBundle.chainId));
+    if (!Array.isArray(signedBundle)) {
+      return this.sendSignedTransactions([signedBundle], chainId, quote, pstatus, callback);
+    }
+    const status = pstatus || (await this.status(signedBundle[0].chainId));
     this.mustBeFullyMigrated(status);
-    const decoratedBundle = this.decorateTransactions(signedBundle, status);
+    const decoratedBundle = await this.decorateTransactions(signedBundle, status);
     callback == null ? void 0 : callback(decoratedBundle);
     return this.relayer(chainId).relay(decoratedBundle, quote);
   }
@@ -710,7 +758,7 @@ class Account {
     const wallet = this.walletForStatus(chainId, status || (await this.status(chainId)));
     return wallet.fillGasLimits(txs);
   }
-  async gasRefundQuotes(txs, chainId, stubSignatureOverrides, status) {
+  async gasRefundQuotes(txs, chainId, stubSignatureOverrides, status, options) {
     const wstatus = status || (await this.status(chainId));
     const wallet = this.walletForStatus(chainId, wstatus);
     const predecorated = await this.predecorateTransactions(txs, wstatus, chainId);
@@ -735,9 +783,9 @@ class Account {
       nonce: 0 // The relayer also ignored the nonce
     };
 
-    const decoratedBundle = this.decorateTransactions(signedBundle, wstatus);
+    const decoratedBundle = await this.decorateTransactions(signedBundle, wstatus);
     const data = core.commons.transaction.encodeBundleExecData(decoratedBundle);
-    const res = await this.relayer(chainId).getFeeOptionsRaw(decoratedBundle.entrypoint, data);
+    const res = await this.relayer(chainId).getFeeOptionsRaw(decoratedBundle.entrypoint, data, options);
     return _extends({}, res, {
       decorated: decoratedBundle
     });
@@ -745,7 +793,9 @@ class Account {
   async prepareTransactions(args) {
     const status = await this.status(args.chainId);
     const transactions = await this.fillGasLimits(args.txs, args.chainId, status);
-    const gasRefundQuote = await this.gasRefundQuotes(transactions, args.chainId, args.stubSignatureOverrides, status);
+    const gasRefundQuote = await this.gasRefundQuotes(transactions, args.chainId, args.stubSignatureOverrides, status, {
+      simulate: args.simulateForFeeOptions
+    });
     const flatDecorated = core.commons.transaction.unwind(this.address, gasRefundQuote.decorated.transactions);
     return {
       transactions,
@@ -757,9 +807,21 @@ class Account {
   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, undefined, options);
-    // TODO: is it safe to pass status again here?
-    return this.sendSignedTransactions(signed, chainId, quote, undefined, callback);
+    const hasTxs = core.commons.transaction.fromTransactionish(this.address, predecorated).length > 0;
+    const signed = hasTxs ? await this.signTransactions(predecorated, chainId, undefined, options) : undefined;
+    const childBundles = await this.orchestrator.predecorateSignedTransactions({
+      chainId
+    });
+    const bundles = [];
+    if (signed !== undefined && signed.transactions.length > 0) {
+      bundles.push(signed);
+    }
+    bundles.push(...childBundles.filter(b => b.transactions.length > 0));
+    if (bundles.length === 0) {
+      // Nothing to send?
+      return;
+    }
+    return this.sendSignedTransactions(bundles, chainId, quote, undefined, callback);
   }
   async signTypedData(domain, types, message, chainId, cantValidateBehavior = 'ignore') {
     const digest = utils.encodeTypedDataDigest({

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

@@ -122,21 +122,23 @@ class AccountSigner {
     }
     throw new Error('No fee option available - not enough balance');
   }
-  async sendTransaction(txsPromise) {
+  async sendTransaction(txsPromise, options) {
     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()
+      stubSignatureOverrides: (_this$options$stubSig = (_this$options2 = this.options) == null ? void 0 : _this$options2.stubSignatureOverrides) != null ? _this$options$stubSig : new Map(),
+      simulateForFeeOptions: options == null ? void 0 : options.simulateForFeeOptions
     });
     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);
+    } : undefined); // Will always have a transaction response
   }
+
   getBalance(blockTag) {
     return this.provider.getBalance(this.account.address, blockTag);
   }
@@ -405,6 +407,19 @@ class Account {
       throw new Error(`Wallet ${this.address} is not fully migrated`);
     }
   }
+  async predecorateSignedTransactions(status, chainId) {
+    // Request signed predecorate transactions from child wallets
+    const bundles = await this.orchestrator.predecorateSignedTransactions({
+      chainId
+    });
+    // Get signed predecorate transaction
+    const predecorated = await this.predecorateTransactions([], status, chainId);
+    if (commons.transaction.fromTransactionish(this.address, predecorated).length > 0) {
+      // Sign it
+      bundles.push(await this.signTransactions(predecorated, chainId));
+    }
+    return bundles;
+  }
   async predecorateTransactions(txs, status, chainId) {
     // if onchain wallet config is not up to date
     // then we should append an extra transaction that updates it
@@ -416,34 +431,49 @@ class Account {
     }
     return txs;
   }
-  decorateTransactions(bundle, status) {
-    const bootstrapBundle = this.buildBootstrapTransactions(status, bundle.chainId);
-    if (bootstrapBundle.transactions.length === 0) {
-      return bundle;
+  async decorateTransactions(bundles, status, chainId) {
+    var _chainId;
+    if (!Array.isArray(bundles)) {
+      // Recurse with array
+      return this.decorateTransactions([bundles], status, chainId);
     }
+
+    // Default to chainId of first bundle when not supplied
+    chainId = (_chainId = chainId) != null ? _chainId : bundles[0].chainId;
+    const bootstrapBundle = await this.buildBootstrapTransactions(status, chainId);
+    const hasBootstrapTxs = bootstrapBundle.transactions.length > 0;
+    if (!hasBootstrapTxs && bundles.length === 1) {
+      return bundles[0];
+    }
+
+    // Intent defaults to first bundle when no bootstrap transaction
+    const {
+      entrypoint
+    } = hasBootstrapTxs ? bootstrapBundle : bundles[0];
     const decoratedBundle = {
-      entrypoint: bootstrapBundle.entrypoint,
-      chainId: bundle.chainId,
-      intent: bundle.intent,
-      transactions: [...bootstrapBundle.transactions, {
+      entrypoint,
+      chainId,
+      // Intent of the first bundle is used
+      intent: bundles[0].intent,
+      transactions: [...bootstrapBundle.transactions, ...bundles.map(bundle => ({
         to: bundle.entrypoint,
         data: commons.transaction.encodeBundleExecData(bundle),
         gasLimit: 0,
         delegateCall: false,
         revertOnError: true,
         value: 0
-      }]
+      }))]
     };
 
     // Re-compute the meta-transaction id to use the guest module subdigest
     if (!status.onChain.deployed) {
-      decoratedBundle.intent.id = commons.transaction.subdigestOfGuestModuleTransactions(this.contexts[this.version].guestModule, decoratedBundle.chainId, decoratedBundle.transactions);
+      decoratedBundle.intent.id = commons.transaction.subdigestOfGuestModuleTransactions(this.contexts[this.version].guestModule, chainId, decoratedBundle.transactions);
     }
     return decoratedBundle;
   }
-  decorateSignature(signature, status) {
+  async decorateSignature(signature, status) {
     if (!status.presignedConfigurations || status.presignedConfigurations.length === 0) {
-      return new Promise(resolve => resolve(signature));
+      return signature;
     }
     const coder = this.coders.signature;
     const chain = status.presignedConfigurations.map(c => c.signature);
@@ -462,14 +492,13 @@ class Account {
       signatures
     });
   }
-  async signDigest(digest, chainId, decorate = true, cantValidateBehavior = 'ignore') {
+  async signDigest(digest, chainId, decorate = true, cantValidateBehavior = 'ignore', metadata) {
     // If we are signing a digest for chainId zero then we can never be fully migrated
     // because Sequence v1 doesn't allow for signing a message on "all chains"
 
     // So we ignore the state on "chain zero" and instead use one of the states of the networks
     // wallet-webapp should ensure the wallet is as migrated as possible, trying to mimic
     // the behaviour of being migrated on all chains
-
     const chainRef = ethers.constants.Zero.eq(chainId) ? this.networks[0].chainId : chainId;
     const status = await this.status(chainRef);
     this.mustBeFullyMigrated(status);
@@ -480,7 +509,7 @@ class Account {
       throw new Error('Wallet cannot validate onchain');
     }
     const wallet = this.walletForStatus(chainId, status);
-    const signature = await wallet.signDigest(digest);
+    const signature = await wallet.signDigest(digest, metadata);
     const decorated = decorate ? this.decorateSignature(signature, status) : signature;
 
     // If the wallet can't validate onchain then we
@@ -499,8 +528,8 @@ class Account {
     }
     return decorated;
   }
-  buildEIP6492Signature(signature, status, chainId) {
-    const bootstrapBundle = this.buildBootstrapTransactions(status, chainId);
+  async buildEIP6492Signature(signature, status, chainId) {
+    const bootstrapBundle = await this.buildBootstrapTransactions(status, chainId);
     if (bootstrapBundle.transactions.length === 0) {
       throw new Error('Cannot build EIP-6492 signature without bootstrap transactions');
     }
@@ -556,8 +585,12 @@ class Account {
    *  by any of the migrations.
    *
    */
-  buildBootstrapTransactions(status, chainId) {
-    const transactions = [];
+  async buildBootstrapTransactions(status, chainId) {
+    var _bundle$transactions;
+    const bundle = await this.orchestrator.buildDeployTransaction({
+      chainId
+    });
+    const transactions = (_bundle$transactions = bundle == null ? void 0 : bundle.transactions) != null ? _bundle$transactions : [];
 
     // Add wallet deployment if needed
     if (!status.onChain.deployed) {
@@ -566,6 +599,7 @@ class Account {
       const deployTransaction = Wallet.buildDeployTransaction(status.original.context, status.original.imageHash);
       transactions.push(...deployTransaction.transactions);
     }
+    transactions.length;
 
     // Get pending migrations
     transactions.push(...status.signedMigrations.map(m => ({
@@ -615,9 +649,20 @@ class Account {
     const status = pstatus || (await this.status(chainId));
     this.mustBeFullyMigrated(status);
     const wallet = this.walletForStatus(chainId, status);
+    const metadata = {
+      address: this.address,
+      digest: '',
+      // Set in wallet.signTransactions
+      chainId,
+      config: {
+        version: this.version
+      },
+      decorate: true,
+      cantValidateBehavior: 'ignore'
+    };
     const signed = await wallet.signTransactions(txs, (options == null ? void 0 : options.nonceSpace) && {
       space: options == null ? void 0 : options.nonceSpace
-    });
+    }, metadata);
     return _extends({}, signed, {
       signature: await this.decorateSignature(signed.signature, status)
     });
@@ -696,9 +741,12 @@ class Account {
     };
   }
   async sendSignedTransactions(signedBundle, chainId, quote, pstatus, callback) {
-    const status = pstatus || (await this.status(signedBundle.chainId));
+    if (!Array.isArray(signedBundle)) {
+      return this.sendSignedTransactions([signedBundle], chainId, quote, pstatus, callback);
+    }
+    const status = pstatus || (await this.status(signedBundle[0].chainId));
     this.mustBeFullyMigrated(status);
-    const decoratedBundle = this.decorateTransactions(signedBundle, status);
+    const decoratedBundle = await this.decorateTransactions(signedBundle, status);
     callback == null ? void 0 : callback(decoratedBundle);
     return this.relayer(chainId).relay(decoratedBundle, quote);
   }
@@ -706,7 +754,7 @@ class Account {
     const wallet = this.walletForStatus(chainId, status || (await this.status(chainId)));
     return wallet.fillGasLimits(txs);
   }
-  async gasRefundQuotes(txs, chainId, stubSignatureOverrides, status) {
+  async gasRefundQuotes(txs, chainId, stubSignatureOverrides, status, options) {
     const wstatus = status || (await this.status(chainId));
     const wallet = this.walletForStatus(chainId, wstatus);
     const predecorated = await this.predecorateTransactions(txs, wstatus, chainId);
@@ -731,9 +779,9 @@ class Account {
       nonce: 0 // The relayer also ignored the nonce
     };
 
-    const decoratedBundle = this.decorateTransactions(signedBundle, wstatus);
+    const decoratedBundle = await this.decorateTransactions(signedBundle, wstatus);
     const data = commons.transaction.encodeBundleExecData(decoratedBundle);
-    const res = await this.relayer(chainId).getFeeOptionsRaw(decoratedBundle.entrypoint, data);
+    const res = await this.relayer(chainId).getFeeOptionsRaw(decoratedBundle.entrypoint, data, options);
     return _extends({}, res, {
       decorated: decoratedBundle
     });
@@ -741,7 +789,9 @@ class Account {
   async prepareTransactions(args) {
     const status = await this.status(args.chainId);
     const transactions = await this.fillGasLimits(args.txs, args.chainId, status);
-    const gasRefundQuote = await this.gasRefundQuotes(transactions, args.chainId, args.stubSignatureOverrides, status);
+    const gasRefundQuote = await this.gasRefundQuotes(transactions, args.chainId, args.stubSignatureOverrides, status, {
+      simulate: args.simulateForFeeOptions
+    });
     const flatDecorated = commons.transaction.unwind(this.address, gasRefundQuote.decorated.transactions);
     return {
       transactions,
@@ -753,9 +803,21 @@ class Account {
   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, undefined, options);
-    // TODO: is it safe to pass status again here?
-    return this.sendSignedTransactions(signed, chainId, quote, undefined, callback);
+    const hasTxs = commons.transaction.fromTransactionish(this.address, predecorated).length > 0;
+    const signed = hasTxs ? await this.signTransactions(predecorated, chainId, undefined, options) : undefined;
+    const childBundles = await this.orchestrator.predecorateSignedTransactions({
+      chainId
+    });
+    const bundles = [];
+    if (signed !== undefined && signed.transactions.length > 0) {
+      bundles.push(signed);
+    }
+    bundles.push(...childBundles.filter(b => b.transactions.length > 0));
+    if (bundles.length === 0) {
+      // Nothing to send?
+      return;
+    }
+    return this.sendSignedTransactions(bundles, chainId, quote, undefined, callback);
   }
   async signTypedData(domain, types, message, chainId, cantValidateBehavior = 'ignore') {
     const digest = encodeTypedDataDigest({

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

@@ -76,11 +76,12 @@ export declare class Account {
     walletFor(chainId: ethers.BigNumberish, context: commons.context.WalletContext, config: commons.config.Config, coders: typeof this.coders): Wallet;
     status(chainId: ethers.BigNumberish, longestPath?: boolean): Promise<AccountStatus>;
     private mustBeFullyMigrated;
+    predecorateSignedTransactions(status: AccountStatus, chainId: ethers.BigNumberish): Promise<commons.transaction.SignedTransactionBundle[]>;
     predecorateTransactions(txs: commons.transaction.Transactionish, status: AccountStatus, chainId: ethers.BigNumberish): Promise<commons.transaction.Transactionish>;
-    decorateTransactions(bundle: commons.transaction.IntendedTransactionBundle, status: AccountStatus): commons.transaction.IntendedTransactionBundle;
+    decorateTransactions(bundles: commons.transaction.IntendedTransactionBundle | commons.transaction.IntendedTransactionBundle[], status: AccountStatus, chainId?: ethers.BigNumberish): Promise<commons.transaction.IntendedTransactionBundle>;
     decorateSignature<T extends ethers.BytesLike>(signature: T, status: Partial<Pick<AccountStatus, 'presignedConfigurations'>>): Promise<T | string>;
     publishWitness(): Promise<void>;
-    signDigest(digest: ethers.BytesLike, chainId: ethers.BigNumberish, decorate?: boolean, cantValidateBehavior?: 'ignore' | 'eip6492' | 'throw'): Promise<string>;
+    signDigest(digest: ethers.BytesLike, chainId: ethers.BigNumberish, decorate?: boolean, cantValidateBehavior?: 'ignore' | 'eip6492' | 'throw', metadata?: object): Promise<string>;
     private buildEIP6492Signature;
     editConfig(changes: {
         add?: commons.config.SimpleSigner[];
@@ -99,7 +100,7 @@ export declare class Account {
      *  by any of the migrations.
      *
      */
-    buildBootstrapTransactions(status: AccountStatus, chainId: ethers.BigNumberish): commons.transaction.IntendedTransactionBundle;
+    buildBootstrapTransactions(status: AccountStatus, chainId: ethers.BigNumberish): Promise<commons.transaction.IntendedTransactionBundle>;
     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>;
@@ -115,9 +116,11 @@ export declare class Account {
         migratedAllChains: boolean;
         failedChains: number[];
     }>;
-    sendSignedTransactions(signedBundle: commons.transaction.IntendedTransactionBundle, chainId: ethers.BigNumberish, quote?: FeeQuote, pstatus?: AccountStatus, callback?: (bundle: commons.transaction.IntendedTransactionBundle) => void): Promise<ethers.providers.TransactionResponse>;
+    sendSignedTransactions(signedBundle: commons.transaction.IntendedTransactionBundle | commons.transaction.IntendedTransactionBundle[], chainId: ethers.BigNumberish, quote?: FeeQuote, pstatus?: AccountStatus, callback?: (bundle: commons.transaction.IntendedTransactionBundle) => void): Promise<ethers.providers.TransactionResponse>;
     fillGasLimits(txs: commons.transaction.Transactionish, chainId: ethers.BigNumberish, status?: AccountStatus): Promise<commons.transaction.SimulatedTransaction[]>;
-    gasRefundQuotes(txs: commons.transaction.Transactionish, chainId: ethers.BigNumberish, stubSignatureOverrides: Map<string, string>, status?: AccountStatus): Promise<{
+    gasRefundQuotes(txs: commons.transaction.Transactionish, chainId: ethers.BigNumberish, stubSignatureOverrides: Map<string, string>, status?: AccountStatus, options?: {
+        simulate?: boolean;
+    }): Promise<{
         options: FeeOption[];
         quote?: FeeQuote;
         decorated: commons.transaction.IntendedTransactionBundle;
@@ -126,10 +129,11 @@ export declare class Account {
         txs: commons.transaction.Transactionish;
         chainId: ethers.BigNumberish;
         stubSignatureOverrides: Map<string, string>;
+        simulateForFeeOptions?: boolean;
     }): Promise<PreparedTransactions>;
     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>;
+    }): Promise<ethers.providers.TransactionResponse | undefined>;
     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

@@ -19,7 +19,9 @@ export declare class AccountSigner implements ethers.Signer {
     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>;
+    sendTransaction(txsPromise: ethers.utils.Deferrable<ethers.providers.TransactionRequest> | commons.transaction.Transactionish, options?: {
+        simulateForFeeOptions?: boolean;
+    }): 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>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/account",
-  "version": "1.2.8",
+  "version": "1.3.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.2.8",
-    "@0xsequence/migration": "1.2.8",
-    "@0xsequence/sessions": "1.2.8",
-    "@0xsequence/relayer": "1.2.8",
-    "@0xsequence/utils": "1.2.8",
-    "@0xsequence/network": "1.2.8",
-    "@0xsequence/wallet": "1.2.8"
+    "@0xsequence/core": "1.3.0",
+    "@0xsequence/migration": "1.3.0",
+    "@0xsequence/network": "1.3.0",
+    "@0xsequence/relayer": "1.3.0",
+    "@0xsequence/utils": "1.3.0",
+    "@0xsequence/sessions": "1.3.0",
+    "@0xsequence/wallet": "1.3.0"
   },
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "nyc": "^15.1.0",
-    "@0xsequence/signhub": "1.2.8",
-    "@0xsequence/tests": "1.2.8"
+    "@0xsequence/signhub": "1.3.0",
+    "@0xsequence/tests": "1.3.0"
   },
   "files": [
     "src",

package/src/account.ts

@@ -1,4 +1,5 @@
 import { commons, universal } from '@0xsequence/core'
+import { WalletSignRequestMetadata } from '@0xsequence/core/src/commons'
 import { migrator, defaults, version } from '@0xsequence/migration'
 import { ChainId, NetworkConfig } from '@0xsequence/network'
 import { FeeOption, FeeQuote, isRelayer, Relayer, RpcRelayer } from '@0xsequence/relayer'
@@ -352,6 +353,21 @@ export class Account {
     }
   }
 
+  async predecorateSignedTransactions(
+    status: AccountStatus,
+    chainId: ethers.BigNumberish
+  ): Promise<commons.transaction.SignedTransactionBundle[]> {
+    // Request signed predecorate transactions from child wallets
+    const bundles = await this.orchestrator.predecorateSignedTransactions({ chainId })
+    // Get signed predecorate transaction
+    const predecorated = await this.predecorateTransactions([], status, chainId)
+    if (commons.transaction.fromTransactionish(this.address, predecorated).length > 0) {
+      // Sign it
+      bundles.push(await this.signTransactions(predecorated, chainId))
+    }
+    return bundles
+  }
+
   async predecorateTransactions(
     txs: commons.transaction.Transactionish,
     status: AccountStatus,
@@ -369,29 +385,46 @@ export class Account {
     return txs
   }
 
-  decorateTransactions(
-    bundle: commons.transaction.IntendedTransactionBundle,
-    status: AccountStatus
-  ): commons.transaction.IntendedTransactionBundle {
-    const bootstrapBundle = this.buildBootstrapTransactions(status, bundle.chainId)
-    if (bootstrapBundle.transactions.length === 0) {
-      return bundle
+  async decorateTransactions(
+    bundles: commons.transaction.IntendedTransactionBundle | commons.transaction.IntendedTransactionBundle[],
+    status: AccountStatus,
+    chainId?: ethers.BigNumberish
+  ): Promise<commons.transaction.IntendedTransactionBundle> {
+    if (!Array.isArray(bundles)) {
+      // Recurse with array
+      return this.decorateTransactions([bundles], status, chainId)
     }
 
+    // Default to chainId of first bundle when not supplied
+    chainId = chainId ?? bundles[0].chainId
+
+    const bootstrapBundle = await this.buildBootstrapTransactions(status, chainId)
+    const hasBootstrapTxs = bootstrapBundle.transactions.length > 0
+
+    if (!hasBootstrapTxs && bundles.length === 1) {
+      return bundles[0]
+    }
+
+    // Intent defaults to first bundle when no bootstrap transaction
+    const { entrypoint } = hasBootstrapTxs ? bootstrapBundle : bundles[0]
+
     const decoratedBundle = {
-      entrypoint: bootstrapBundle.entrypoint,
-      chainId: bundle.chainId,
-      intent: bundle.intent,
+      entrypoint,
+      chainId,
+      // Intent of the first bundle is used
+      intent: bundles[0].intent,
       transactions: [
         ...bootstrapBundle.transactions,
-        {
-          to: bundle.entrypoint,
-          data: commons.transaction.encodeBundleExecData(bundle),
-          gasLimit: 0,
-          delegateCall: false,
-          revertOnError: true,
-          value: 0
-        }
+        ...bundles.map(
+          (bundle): commons.transaction.Transaction => ({
+            to: bundle.entrypoint,
+            data: commons.transaction.encodeBundleExecData(bundle),
+            gasLimit: 0,
+            delegateCall: false,
+            revertOnError: true,
+            value: 0
+          })
+        )
       ]
     }
 
@@ -399,7 +432,7 @@ export class Account {
     if (!status.onChain.deployed) {
       decoratedBundle.intent.id = commons.transaction.subdigestOfGuestModuleTransactions(
         this.contexts[this.version].guestModule,
-        decoratedBundle.chainId,
+        chainId,
         decoratedBundle.transactions
       )
     }
@@ -407,12 +440,12 @@ export class Account {
     return decoratedBundle
   }
 
-  decorateSignature<T extends ethers.BytesLike>(
+  async decorateSignature<T extends ethers.BytesLike>(
     signature: T,
     status: Partial<Pick<AccountStatus, 'presignedConfigurations'>>
   ): Promise<T | string> {
     if (!status.presignedConfigurations || status.presignedConfigurations.length === 0) {
-      return new Promise(resolve => resolve(signature))
+      return signature
     }
 
     const coder = this.coders.signature
@@ -434,7 +467,8 @@ export class Account {
     digest: ethers.BytesLike,
     chainId: ethers.BigNumberish,
     decorate: boolean = true,
-    cantValidateBehavior: 'ignore' | 'eip6492' | 'throw' = 'ignore'
+    cantValidateBehavior: 'ignore' | 'eip6492' | 'throw' = 'ignore',
+    metadata?: object
   ): Promise<string> {
     // If we are signing a digest for chainId zero then we can never be fully migrated
     // because Sequence v1 doesn't allow for signing a message on "all chains"
@@ -442,10 +476,8 @@ export class Account {
     // So we ignore the state on "chain zero" and instead use one of the states of the networks
     // wallet-webapp should ensure the wallet is as migrated as possible, trying to mimic
     // the behaviour of being migrated on all chains
-
     const chainRef = ethers.constants.Zero.eq(chainId) ? this.networks[0].chainId : chainId
     const status = await this.status(chainRef)
-
     this.mustBeFullyMigrated(status)
 
     // Check if we can validate onchain and what to do if we can't
@@ -455,7 +487,7 @@ export class Account {
     }
 
     const wallet = this.walletForStatus(chainId, status)
-    const signature = await wallet.signDigest(digest)
+    const signature = await wallet.signDigest(digest, metadata)
 
     const decorated = decorate ? this.decorateSignature(signature, status) : signature
 
@@ -478,8 +510,8 @@ export class Account {
     return decorated
   }
 
-  private buildEIP6492Signature(signature: string, status: AccountStatus, chainId: ethers.BigNumberish): string {
-    const bootstrapBundle = this.buildBootstrapTransactions(status, chainId)
+  private async buildEIP6492Signature(signature: string, status: AccountStatus, chainId: ethers.BigNumberish): Promise<string> {
+    const bootstrapBundle = await this.buildBootstrapTransactions(status, chainId)
     if (bootstrapBundle.transactions.length === 0) {
       throw new Error('Cannot build EIP-6492 signature without bootstrap transactions')
     }
@@ -550,8 +582,12 @@ export class Account {
    *  by any of the migrations.
    *
    */
-  buildBootstrapTransactions(status: AccountStatus, chainId: ethers.BigNumberish): commons.transaction.IntendedTransactionBundle {
-    const transactions: commons.transaction.Transaction[] = []
+  async buildBootstrapTransactions(
+    status: AccountStatus,
+    chainId: ethers.BigNumberish
+  ): Promise<commons.transaction.IntendedTransactionBundle> {
+    const bundle = await this.orchestrator.buildDeployTransaction({ chainId })
+    const transactions: commons.transaction.Transaction[] = bundle?.transactions ?? []
 
     // Add wallet deployment if needed
     if (!status.onChain.deployed) {
@@ -561,6 +597,7 @@ export class Account {
 
       transactions.push(...deployTransaction.transactions)
     }
+    const len = transactions.length
 
     // Get pending migrations
     transactions.push(
@@ -622,7 +659,17 @@ export class Account {
     this.mustBeFullyMigrated(status)
 
     const wallet = this.walletForStatus(chainId, status)
-    const signed = await wallet.signTransactions(txs, options?.nonceSpace && { space: options?.nonceSpace })
+
+    const metadata: WalletSignRequestMetadata = {
+      address: this.address,
+      digest: '', // Set in wallet.signTransactions
+      chainId,
+      config: { version: this.version },
+      decorate: true,
+      cantValidateBehavior: 'ignore'
+    }
+
+    const signed = await wallet.signTransactions(txs, options?.nonceSpace && { space: options?.nonceSpace }, metadata)
 
     return {
       ...signed,
@@ -707,16 +754,19 @@ export class Account {
   }
 
   async sendSignedTransactions(
-    signedBundle: commons.transaction.IntendedTransactionBundle,
+    signedBundle: commons.transaction.IntendedTransactionBundle | commons.transaction.IntendedTransactionBundle[],
     chainId: ethers.BigNumberish,
     quote?: FeeQuote,
     pstatus?: AccountStatus,
     callback?: (bundle: commons.transaction.IntendedTransactionBundle) => void
   ): Promise<ethers.providers.TransactionResponse> {
-    const status = pstatus || (await this.status(signedBundle.chainId))
+    if (!Array.isArray(signedBundle)) {
+      return this.sendSignedTransactions([signedBundle], chainId, quote, pstatus, callback)
+    }
+    const status = pstatus || (await this.status(signedBundle[0].chainId))
     this.mustBeFullyMigrated(status)
 
-    const decoratedBundle = this.decorateTransactions(signedBundle, status)
+    const decoratedBundle = await this.decorateTransactions(signedBundle, status)
     callback?.(decoratedBundle)
 
     return this.relayer(chainId).relay(decoratedBundle, quote)
@@ -735,7 +785,10 @@ export class Account {
     txs: commons.transaction.Transactionish,
     chainId: ethers.BigNumberish,
     stubSignatureOverrides: Map<string, string>,
-    status?: AccountStatus
+    status?: AccountStatus,
+    options?: {
+      simulate?: boolean
+    }
   ): Promise<{
     options: FeeOption[]
     quote?: FeeQuote
@@ -766,9 +819,9 @@ export class Account {
       nonce: 0 // The relayer also ignored the nonce
     }
 
-    const decoratedBundle = this.decorateTransactions(signedBundle, wstatus)
+    const decoratedBundle = await this.decorateTransactions(signedBundle, wstatus)
     const data = commons.transaction.encodeBundleExecData(decoratedBundle)
-    const res = await this.relayer(chainId).getFeeOptionsRaw(decoratedBundle.entrypoint, data)
+    const res = await this.relayer(chainId).getFeeOptionsRaw(decoratedBundle.entrypoint, data, options)
     return { ...res, decorated: decoratedBundle }
   }
 
@@ -776,11 +829,14 @@ export class Account {
     txs: commons.transaction.Transactionish
     chainId: ethers.BigNumberish
     stubSignatureOverrides: Map<string, string>
+    simulateForFeeOptions?: boolean
   }): Promise<PreparedTransactions> {
     const status = await this.status(args.chainId)
 
     const transactions = await this.fillGasLimits(args.txs, args.chainId, status)
-    const gasRefundQuote = await this.gasRefundQuotes(transactions, args.chainId, args.stubSignatureOverrides, status)
+    const gasRefundQuote = await this.gasRefundQuotes(transactions, args.chainId, args.stubSignatureOverrides, status, {
+      simulate: args.simulateForFeeOptions
+    })
     const flatDecorated = commons.transaction.unwind(this.address, gasRefundQuote.decorated.transactions)
 
     return {
@@ -800,13 +856,27 @@ export class Account {
     options?: {
       nonceSpace?: ethers.BigNumberish
     }
-  ): Promise<ethers.providers.TransactionResponse> {
+  ): Promise<ethers.providers.TransactionResponse | undefined> {
     const status = await this.status(chainId)
 
     const predecorated = skipPreDecorate ? txs : await this.predecorateTransactions(txs, status, 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)
+    const hasTxs = commons.transaction.fromTransactionish(this.address, predecorated).length > 0
+    const signed = hasTxs ? await this.signTransactions(predecorated, chainId, undefined, options) : undefined
+
+    const childBundles = await this.orchestrator.predecorateSignedTransactions({ chainId })
+
+    const bundles: commons.transaction.SignedTransactionBundle[] = []
+    if (signed !== undefined && signed.transactions.length > 0) {
+      bundles.push(signed)
+    }
+    bundles.push(...childBundles.filter(b => b.transactions.length > 0))
+
+    if (bundles.length === 0) {
+      // Nothing to send?
+      return
+    }
+
+    return this.sendSignedTransactions(bundles, chainId, quote, undefined, callback)
   }
 
   async signTypedData(

package/src/orchestrator/wrapper.ts

@@ -0,0 +1,85 @@
+import { commons } from '@0xsequence/core'
+import { signers, Status } from '@0xsequence/signhub'
+import { ethers } from 'ethers'
+import { Account } from '../account'
+
+export type MetadataWithChainId = {
+  chainId: ethers.BigNumberish
+}
+
+// Implements a wrapper for using Sequence accounts as nested signers in the signhub orchestrator.
+export class AccountOrchestratorWrapper implements signers.SapientSigner {
+  constructor(public account: Account) {}
+
+  async getAddress(): Promise<string> {
+    return this.account.address
+  }
+
+  getChainIdFromMetadata(metadata: object): ethers.BigNumber {
+    try {
+      const { chainId } = metadata as MetadataWithChainId
+      return ethers.BigNumber.from(chainId)
+    } catch (err) {
+      // Invalid metadata object
+      throw new Error('AccountOrchestratorWrapper only supports metadata with chain id')
+    }
+  }
+
+  async buildDeployTransaction(metadata: object): Promise<commons.transaction.TransactionBundle | undefined> {
+    const chainId = this.getChainIdFromMetadata(metadata)
+    const status = await this.account.status(chainId)
+    return this.account.buildBootstrapTransactions(status, chainId)
+  }
+
+  async predecorateSignedTransactions(metadata: object): Promise<commons.transaction.SignedTransactionBundle[]> {
+    const chainId = this.getChainIdFromMetadata(metadata)
+    const status = await this.account.status(chainId)
+    return this.account.predecorateSignedTransactions(status, chainId)
+  }
+
+  async decorateTransactions(
+    bundle: commons.transaction.IntendedTransactionBundle,
+    metadata: object
+  ): Promise<commons.transaction.IntendedTransactionBundle> {
+    const chainId = this.getChainIdFromMetadata(metadata)
+    const status = await this.account.status(chainId)
+    return this.account.decorateTransactions(bundle, status)
+  }
+
+  async requestSignature(
+    _id: string,
+    message: ethers.utils.BytesLike,
+    metadata: object,
+    callbacks: {
+      onSignature: (signature: ethers.utils.BytesLike) => void
+      onRejection: (error: string) => void
+      onStatus: (situation: string) => void
+    }
+  ): Promise<boolean> {
+    if (!commons.isWalletSignRequestMetadata(metadata)) {
+      throw new Error('AccountOrchestratorWrapper only supports wallet metadata requests')
+    }
+
+    const { chainId, decorate } = metadata
+    // EIP-6492 not supported on nested signatures
+    // Default to throw instead of ignore. Ignoring should be explicit
+    const cantValidateBehavior = metadata.cantValidateBehavior ?? 'throw'
+
+    // For Sequence nested signatures we must use `signDigest` and not `signMessage`
+    // otherwise the account will hash the digest and the signature will be invalid.
+    try {
+      callbacks.onSignature(await this.account.signDigest(message, chainId, decorate, cantValidateBehavior, metadata))
+    } catch (err) {
+      callbacks.onRejection('Unable to sign account')
+      return false
+    }
+
+    return true
+  }
+
+  notifyStatusChange(_i: string, _s: Status, _m: object): void {}
+
+  suffix(): ethers.utils.BytesLike {
+    return [3]
+  }
+}

package/src/signer.ts

@@ -125,7 +125,10 @@ export class AccountSigner implements ethers.Signer {
   }
 
   async sendTransaction(
-    txsPromise: ethers.utils.Deferrable<ethers.providers.TransactionRequest> | commons.transaction.Transactionish
+    txsPromise: ethers.utils.Deferrable<ethers.providers.TransactionRequest> | commons.transaction.Transactionish,
+    options?: {
+      simulateForFeeOptions?: boolean
+    }
   ): Promise<ethers.providers.TransactionResponse> {
     const txs = isDeferrable(txsPromise)
       ? await ethers.utils.resolveProperties(txsPromise as ethers.utils.Deferrable<ethers.providers.TransactionRequest>)
@@ -134,7 +137,8 @@ export class AccountSigner implements ethers.Signer {
     const prepare = await this.account.prepareTransactions({
       txs,
       chainId: this.chainId,
-      stubSignatureOverrides: this.options?.stubSignatureOverrides ?? new Map()
+      stubSignatureOverrides: this.options?.stubSignatureOverrides ?? new Map(),
+      simulateForFeeOptions: options?.simulateForFeeOptions
     })
 
     const selectMethod = this.options?.selectFee ?? this.defaultSelectFee.bind(this)
@@ -153,7 +157,7 @@ export class AccountSigner implements ethers.Signer {
             nonceSpace: this.options.nonceSpace
           }
         : undefined
-    )
+    ) as Promise<ethers.providers.TransactionResponse> // Will always have a transaction response
   }
 
   getBalance(blockTag?: ethers.providers.BlockTag | undefined): Promise<ethers.BigNumber> {