@0xsequence/account 2.3.18 → 2.3.20

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

@@ -0,0 +1,1100 @@
+import { walletContracts } from '@0xsequence/abi';
+import { commons, universal } from '@0xsequence/core';
+import { defaults, migrator, version } from '@0xsequence/migration';
+import { ChainId } from '@0xsequence/network';
+import { proto, isRelayer, RpcRelayer } from '@0xsequence/relayer';
+import { toHexString, getFetchRequest, encodeTypedDataDigest } from '@0xsequence/utils';
+import { Wallet } from '@0xsequence/wallet';
+import { ethers, MessagePrefix } from 'ethers';
+
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
+function encodeGasRefundTransaction(option) {
+  if (!option) return [];
+  const value = BigInt(option.value);
+  switch (option.token.type) {
+    case proto.FeeTokenType.UNKNOWN:
+      return [{
+        delegateCall: false,
+        revertOnError: true,
+        gasLimit: option.gasLimit,
+        to: option.to,
+        value: toHexString(value),
+        data: '0x'
+      }];
+    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.Interface([{
+          constant: false,
+          inputs: [{
+            type: 'address'
+          }, {
+            type: 'uint256'
+          }],
+          name: 'transfer',
+          outputs: [],
+          type: 'function'
+        }]).encodeFunctionData('transfer', [option.to, toHexString(value)])
+      }];
+    default:
+      throw new Error(`Unhandled fee token type ${option.token.type}`);
+  }
+}
+class AccountSigner {
+  constructor(account, chainId, options) {
+    this.account = account;
+    this.chainId = chainId;
+    this.options = options;
+  }
+  get provider() {
+    return this.account.providerFor(this.chainId);
+  }
+  async getAddress() {
+    return this.account.address;
+  }
+
+  /**
+   * Signs a message.
+   *
+   * This method will sign the message using the account associated with this signer
+   * and the specified chain ID. The message is already being prefixed with the EIP-191 prefix.
+   *
+   * @param message - The message to sign. Can be a string or BytesLike.
+   * @returns A Promise that resolves to the signature as a hexadecimal string
+   *
+   * @example
+   * ```typescript
+   * const signer = account.getSigner(chainId)
+   *
+   * const message = "Hello, Sequence!";
+   * const signature = await signer.signMessage(message);
+   * console.log(signature);
+   * // => "0x123abc..." (hexadecimal signature)
+   */
+  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');
+  }
+  signTypedData(domain, types, value) {
+    var _this$options$cantVal2, _this$options2;
+    return this.account.signTypedData(domain, types, value, this.chainId, (_this$options$cantVal2 = (_this$options2 = this.options) == null ? void 0 : _this$options2.cantValidateBehavior) != null ? _this$options$cantVal2 : '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 >= BigInt(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 >= BigInt(option.value)) {
+          return option;
+        }
+      } else ;
+    }
+    throw new Error('No fee option available - not enough balance');
+  }
+  async sendTransaction(txs, options) {
+    var _this$options$stubSig, _this$options3, _this$options$selectF, _this$options4, _this$options5;
+    const prepare = await this.account.prepareTransactions({
+      txs,
+      chainId: this.chainId,
+      stubSignatureOverrides: (_this$options$stubSig = (_this$options3 = this.options) == null ? void 0 : _this$options3.stubSignatureOverrides) != null ? _this$options$stubSig : new Map(),
+      simulateForFeeOptions: options == null ? void 0 : options.simulateForFeeOptions
+    });
+    const selectMethod = (_this$options$selectF = (_this$options4 = this.options) == null ? void 0 : _this$options4.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$options5 = this.options) == null ? void 0 : _this$options5.nonceSpace) !== undefined ? {
+      nonceSpace: this.options.nonceSpace
+    } : undefined); // Will always have a transaction response
+  }
+  getBalance(blockTag) {
+    return this.provider.getBalance(this.account.address, blockTag);
+  }
+  call(transaction, blockTag) {
+    return this.provider.call(_extends({}, 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(Number(this.chainId));
+  }
+  getGasPrice() {
+    throw new Error('Method not implemented.');
+  }
+  getFeeData() {
+    throw new Error('Method not implemented.');
+  }
+  getNonce(blockTag) {
+    throw new Error('Method not implemented.');
+  }
+  populateCall(tx) {
+    throw new Error('Method not implemented.');
+  }
+  checkTransaction(transaction) {
+    throw new Error('Method not implemented.');
+  }
+  async populateTransaction(tx) {
+    throw new Error('Method not implemented.');
+  }
+  _checkProvider(operation) {
+    throw new Error('Method not implemented.');
+  }
+}
+
+class Chain0Reader {
+  async isDeployed(_wallet) {
+    return false;
+  }
+  async implementation(_wallet) {
+    return undefined;
+  }
+  async imageHash(_wallet) {
+    return undefined;
+  }
+  async nonce(_wallet, _space) {
+    return 0n;
+  }
+  async isValidSignature(_wallet, _digest, _signature) {
+    throw new Error('Method not supported.');
+  }
+}
+class Account {
+  constructor(options) {
+    this.address = void 0;
+    this.networks = void 0;
+    this.tracker = void 0;
+    this.contexts = void 0;
+    this.migrator = void 0;
+    this.migrations = void 0;
+    this.orchestrator = void 0;
+    this.jwt = void 0;
+    this.projectAccessKey = void 0;
+    this.address = ethers.getAddress(options.address);
+    this.contexts = options.contexts;
+    this.tracker = options.tracker;
+    this.networks = options.networks;
+    this.orchestrator = options.orchestrator;
+    this.jwt = options.jwt;
+    this.projectAccessKey = options.projectAccessKey;
+    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);
+    const lastMigration = mig.lastMigration();
+    const lastCoder = lastMigration.configCoder;
+    const config = lastCoder.fromSimple(options.config);
+    const imageHash = lastCoder.imageHashOf(config);
+    const context = options.contexts[lastMigration.version];
+    const address = commons.context.addressOf(context, imageHash);
+    await options.tracker.saveCounterfactualWallet({
+      config,
+      context: Object.values(options.contexts)
+    });
+    return new Account({
+      address,
+      tracker: options.tracker,
+      contexts: options.contexts,
+      networks: options.networks,
+      orchestrator: options.orchestrator,
+      migrations: options.migrations,
+      projectAccessKey: options.projectAccessKey
+    });
+  }
+  getAddress() {
+    return Promise.resolve(this.address);
+  }
+  get version() {
+    return this.migrator.lastMigration().version;
+  }
+  get coders() {
+    const lastMigration = this.migrator.lastMigration();
+    return {
+      signature: lastMigration.signatureCoder,
+      config: lastMigration.configCoder
+    };
+  }
+  network(chainId) {
+    const tcid = BigInt(chainId);
+    const found = this.networks.find(n => tcid === BigInt(n.chainId));
+    if (!found) throw new Error(`Network not found for chainId ${chainId}`);
+    return found;
+  }
+  providerFor(chainId) {
+    const found = this.network(chainId);
+    if (!found.provider && !found.rpcUrl) {
+      throw new Error(`Provider not found for chainId ${chainId}`);
+    }
+    const network = new ethers.Network(found.name, found.chainId);
+    return found.provider || new ethers.JsonRpcProvider(getFetchRequest(found.rpcUrl, this.projectAccessKey, this.jwt), network, {
+      staticNetwork: network
+    });
+  }
+  reader(chainId) {
+    if (BigInt(chainId) === 0n) {
+      return new Chain0Reader();
+    }
+
+    // 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.providerFor(chainId));
+  }
+  relayer(chainId) {
+    const found = this.network(chainId);
+    if (!found.relayer) throw new Error(`Relayer not found for chainId ${chainId}`);
+    if (isRelayer(found.relayer)) return found.relayer;
+    return new RpcRelayer(_extends({}, found.relayer, {
+      projectAccessKey: this.projectAccessKey,
+      jwtAuth: this.jwt
+    }));
+  }
+  setOrchestrator(orchestrator) {
+    this.orchestrator = orchestrator;
+  }
+  setJwt(jwt) {
+    this.jwt = jwt;
+  }
+  contextFor(version) {
+    const ctx = this.contexts[version];
+    if (!ctx) throw new Error(`Context not found for version ${version}`);
+    return ctx;
+  }
+  walletForStatus(chainId, status) {
+    const coder = universal.coderFor(status.version);
+    return this.walletFor(chainId, this.contextFor(status.version), status.config, coder);
+  }
+  walletFor(chainId, context, config, coders) {
+    const isNetworkZero = BigInt(chainId) === 0n;
+    return new Wallet({
+      config,
+      context,
+      chainId,
+      coders,
+      relayer: isNetworkZero ? undefined : this.relayer(chainId),
+      address: this.address,
+      orchestrator: this.orchestrator,
+      reader: this.reader(chainId)
+    });
+  }
+
+  // Get the status of the account on a given network
+  // this does the following process:
+  // 1. Get the current on-chain status of the wallet (version + imageHash)
+  // 2. Get any pending migrations that have been signed by the wallet
+  // 3. Get any pending configuration updates that have been signed by the wallet
+  // 4. Fetch reverse lookups for both on-chain and pending configurations
+  async status(chainId, longestPath = false) {
+    var _this = this;
+    const isDeployedPromise = this.reader(chainId).isDeployed(this.address);
+    const counterfactualImageHashPromise = this.tracker.imageHashOfCounterfactualWallet({
+      wallet: this.address
+    }).then(r => {
+      if (!r) throw new Error(`Counterfactual imageHash not found for wallet ${this.address}`);
+      return r;
+    });
+    const counterFactualVersionPromise = counterfactualImageHashPromise.then(r => {
+      return version.counterfactualVersion(this.address, r.imageHash, Object.values(this.contexts));
+    });
+    const onChainVersionPromise = async function () {
+      const isDeployed = await isDeployedPromise;
+      if (!isDeployed) return counterFactualVersionPromise;
+      const implementation = await _this.reader(chainId).implementation(_this.address);
+      if (!implementation) throw new Error(`Implementation not found for wallet ${_this.address}`);
+      const versions = Object.values(_this.contexts);
+      for (let i = 0; i < versions.length; i++) {
+        if (versions[i].mainModule === implementation || versions[i].mainModuleUpgradable === implementation) {
+          return versions[i].version;
+        }
+      }
+      throw new Error(`Version not found for implementation ${implementation}`);
+    }();
+    const onChainImageHashPromise = async function () {
+      const deployedImageHash = await _this.reader(chainId).imageHash(_this.address);
+      if (deployedImageHash) return deployedImageHash;
+      const counterfactualImageHash = await counterfactualImageHashPromise;
+      if (counterfactualImageHash) return counterfactualImageHash.imageHash;
+      throw new Error(`On-chain imageHash not found for wallet ${_this.address}`);
+    }();
+    const onChainConfigPromise = async function () {
+      const onChainImageHash = await onChainImageHashPromise;
+      const onChainConfig = await _this.tracker.configOfImageHash({
+        imageHash: onChainImageHash
+      });
+      if (onChainConfig) return onChainConfig;
+      throw new Error(`On-chain config not found for imageHash ${onChainImageHash}`);
+    }();
+    const onChainVersion = await onChainVersionPromise;
+    const onChainImageHash = await onChainImageHashPromise;
+    let fromImageHash = onChainImageHash;
+    let lastVersion = onChainVersion;
+    let signedMigrations = [];
+    if (onChainVersion !== this.version) {
+      // We either need to use the presigned configuration updates, or we haven't performed
+      // any updates yet, so we can only use the on-chain imageHash as-is
+      const presignedMigrate = await this.migrator.getAllMigratePresignedTransaction({
+        address: this.address,
+        fromImageHash: onChainImageHash,
+        fromVersion: onChainVersion,
+        chainId
+      });
+
+      // The migrator returns the original version and imageHash
+      // if no presigned migration is found, so no need to check here
+      fromImageHash = presignedMigrate.lastImageHash;
+      lastVersion = presignedMigrate.lastVersion;
+      signedMigrations = presignedMigrate.signedMigrations;
+    }
+    const presigned = await this.tracker.loadPresignedConfiguration({
+      wallet: this.address,
+      fromImageHash: fromImageHash,
+      longestPath
+    });
+    const imageHash = presigned && presigned.length > 0 ? presigned[presigned.length - 1].nextImageHash : fromImageHash;
+    const config = await this.tracker.configOfImageHash({
+      imageHash
+    });
+    if (!config) {
+      throw new Error(`Config not found for imageHash ${imageHash}`);
+    }
+    const isDeployed = await isDeployedPromise;
+    const counterfactualImageHash = await counterfactualImageHashPromise;
+    const checkpoint = universal.coderFor(lastVersion).config.checkpointOf(config);
+    return {
+      original: _extends({}, counterfactualImageHash, {
+        version: await counterFactualVersionPromise
+      }),
+      onChain: {
+        imageHash: onChainImageHash,
+        config: await onChainConfigPromise,
+        version: onChainVersion,
+        deployed: isDeployed
+      },
+      fullyMigrated: lastVersion === this.version,
+      signedMigrations,
+      version: lastVersion,
+      presignedConfigurations: presigned,
+      imageHash,
+      config,
+      checkpoint,
+      canOnchainValidate: onChainVersion === this.version && isDeployed
+    };
+  }
+  mustBeFullyMigrated(status) {
+    if (!status.fullyMigrated) {
+      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) {
+    txs = Array.isArray(txs) ? txs : [txs];
+    // if onchain wallet config is not up to date
+    // then we should append an extra transaction that updates it
+    // to the latest "lazy" state
+    if (status.onChain.imageHash !== status.imageHash) {
+      const wallet = this.walletForStatus(chainId, status);
+      const updateConfig = await wallet.buildUpdateConfigurationTransaction(status.config);
+      txs = [...txs, ...updateConfig.transactions];
+    }
+
+    // On immutable chains, we add the WalletProxyHook
+    const {
+      proxyImplementationHook
+    } = this.contexts[status.config.version];
+    if (proxyImplementationHook && (chainId === ChainId.IMMUTABLE_ZKEVM || chainId === ChainId.IMMUTABLE_ZKEVM_TESTNET)) {
+      const provider = this.providerFor(chainId);
+      if (provider) {
+        const hook = new ethers.Contract(this.address, walletContracts.walletProxyHook.abi, provider);
+        let implementation;
+        try {
+          implementation = await hook.PROXY_getImplementation();
+        } catch (e) {
+          // Handle below
+          console.log('Error getting implementation address', e);
+        }
+        if (!implementation || implementation === ethers.ZeroAddress) {
+          console.log('Adding wallet proxy hook');
+          const hooksInterface = new ethers.Interface(walletContracts.moduleHooks.abi);
+          const tx = {
+            to: this.address,
+            data: hooksInterface.encodeFunctionData(hooksInterface.getFunction('addHook'), ['0x90611127', proxyImplementationHook]),
+            gasLimit: 50000,
+            // Expected ~28k gas. Buffer added
+            delegateCall: false,
+            revertOnError: false,
+            value: 0
+          };
+          txs = [tx, ...txs];
+        }
+      }
+    }
+    return txs;
+  }
+  async decorateTransactions(bundles, status, chainId) {
+    var _chainId, _bundles$;
+    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,
+      chainId,
+      // Intent of the first bundle is used
+      intent: (_bundles$ = bundles[0]) == null ? void 0 : _bundles$.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) {
+      const id = commons.transaction.subdigestOfGuestModuleTransactions(this.contexts[this.version].guestModule, chainId, decoratedBundle.transactions);
+      if (decoratedBundle.intent === undefined) {
+        decoratedBundle.intent = {
+          id,
+          wallet: this.address
+        };
+      } else {
+        decoratedBundle.intent.id = id;
+      }
+    }
+    return decoratedBundle;
+  }
+  async decorateSignature(signature, status) {
+    if (!status.presignedConfigurations || status.presignedConfigurations.length === 0) {
+      return signature;
+    }
+    const coder = this.coders.signature;
+    const chain = status.presignedConfigurations.map(c => c.signature);
+    const chainedSignature = coder.chainSignatures(signature, chain);
+    return coder.trim(chainedSignature);
+  }
+  async publishWitnessFor(signers, chainId = 0) {
+    const digest = ethers.id(`This is a Sequence account woo! ${Date.now()}`);
+    const status = await this.status(chainId);
+    const allOfAll = this.coders.config.fromSimple({
+      threshold: signers.length,
+      checkpoint: 0,
+      signers: signers.map(s => ({
+        address: s,
+        weight: 1
+      }))
+    });
+    const wallet = this.walletFor(chainId, status.original.context, allOfAll, this.coders);
+    const signature = await wallet.signDigest(digest);
+    const decoded = this.coders.signature.decode(signature);
+    const signatures = this.coders.signature.signaturesOfDecoded(decoded);
+    if (signatures.length === 0) {
+      throw new Error('No signatures found');
+    }
+    return this.tracker.saveWitnesses({
+      wallet: this.address,
+      digest,
+      chainId,
+      signatures
+    });
+  }
+  async publishWitness() {
+    const digest = ethers.id(`This is a Sequence account woo! ${Date.now()}`);
+    const signature = await this.signDigest(digest, 0, false);
+    const decoded = this.coders.signature.decode(signature);
+    const signatures = this.coders.signature.signaturesOfDecoded(decoded);
+    return this.tracker.saveWitnesses({
+      wallet: this.address,
+      digest,
+      chainId: 0,
+      signatures
+    });
+  }
+  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 = BigInt(chainId) === 0n ? 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
+    // revert early, since there is no point in signing a digest now
+    if (!status.canOnchainValidate && cantValidateBehavior === 'throw') {
+      throw new Error('Wallet cannot validate onchain');
+    }
+    const wallet = this.walletForStatus(chainId, status);
+    const signature = await wallet.signDigest(digest, metadata);
+    const decorated = decorate ? this.decorateSignature(signature, status) : signature;
+
+    // If the wallet can't validate onchain then we
+    // need to prefix the decorated signature with all deployments and migrations
+    // aka doing a bootstrap using EIP-6492
+    if (!status.canOnchainValidate) {
+      switch (cantValidateBehavior) {
+        // NOTICE: We covered this case before signing the digest
+        // case 'throw':
+        //   throw new Error('Wallet cannot validate on-chain')
+        case 'ignore':
+          return decorated;
+        case 'eip6492':
+          return this.buildEIP6492Signature(await decorated, status, chainId);
+      }
+    }
+    return decorated;
+  }
+  buildOnChainSignature(digest) {
+    const subdigest = commons.signature.subdigestOf({
+      digest: ethers.hexlify(digest),
+      chainId: 0,
+      address: this.address
+    });
+    const hexSubdigest = ethers.hexlify(subdigest);
+    const config = this.coders.config.fromSimple({
+      // Threshold *only* needs to be > 0, this is not a magic number
+      // we only use 2 ** 15 because it may lead to lower gas costs in some chains
+      threshold: 32768,
+      checkpoint: 0,
+      signers: [],
+      subdigests: [hexSubdigest]
+    });
+    const walletInterface = new ethers.Interface(walletContracts.mainModule.abi);
+    const bundle = {
+      entrypoint: this.address,
+      transactions: [{
+        to: this.address,
+        data: walletInterface.encodeFunctionData(
+        // *NEVER* use updateImageHash here, as it would effectively destroy the wallet
+        // setExtraImageHash sets an additional imageHash, without changing the current one
+        'setExtraImageHash', [this.coders.config.imageHashOf(config),
+        // 2 ** 255 instead of max uint256, to have more zeros in the calldata
+        '57896044618658097711785492504343953926634992332820282019728792003956564819968']),
+        // Conservative gas limit, used because the current relayer
+        // has trouble estimating gas for this transaction
+        gasLimit: 250000
+      }]
+    };
+
+    // Fire and forget request to save the config
+    this.tracker.saveWalletConfig({
+      config
+    });
+
+    // Encode a signature proof for the given subdigest
+    // use `chainId = 0` to make it simpler, as this signature is only a proof
+    const signature = this.coders.signature.encodeSigners(config, new Map(), [hexSubdigest], 0).encoded;
+    return {
+      bundle,
+      signature
+    };
+  }
+  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');
+    }
+    const encoded = ethers.AbiCoder.defaultAbiCoder().encode(['address', 'bytes', 'bytes'], [bootstrapBundle.entrypoint, commons.transaction.encodeBundleExecData(bootstrapBundle), signature]);
+    return ethers.solidityPacked(['bytes', 'bytes32'], [encoded, commons.EIP6492.EIP_6492_SUFFIX]);
+  }
+  async editConfig(changes) {
+    const currentConfig = await this.status(0).then(s => s.config);
+    const newConfig = this.coders.config.editConfig(currentConfig, _extends({}, changes, {
+      checkpoint: this.coders.config.checkpointOf(currentConfig) + 1n
+    }));
+    return this.updateConfig(newConfig);
+  }
+  async updateConfig(config) {
+    // config should be for the current version of the wallet
+    if (!this.coders.config.isWalletConfig(config)) {
+      throw new Error(`Invalid config for wallet ${this.address}`);
+    }
+    const nextImageHash = this.coders.config.imageHashOf(config);
+
+    // sign an update config struct
+    const updateStruct = this.coders.signature.hashSetImageHash(nextImageHash);
+
+    // sign the update struct, using chain id 0
+    const signature = await this.signDigest(updateStruct, 0, false);
+
+    // save the presigned transaction to the sessions tracker
+    await this.tracker.savePresignedConfiguration({
+      wallet: this.address,
+      nextConfig: config,
+      signature,
+      referenceChainId: 1
+    });
+
+    // safety check, tracker should have a reverse lookup for the imageHash
+    // outside of the local cache
+    const reverseConfig = await this.tracker.configOfImageHash({
+      imageHash: nextImageHash,
+      noCache: true
+    });
+    if (!reverseConfig || this.coders.config.imageHashOf(reverseConfig) !== nextImageHash) {
+      throw Error(`Reverse lookup failed for imageHash ${nextImageHash}`);
+    }
+  }
+
+  /**
+   *  This method is used to bootstrap the wallet on a given chain.
+   *  this deploys the wallets and executes all the necessary transactions
+   *  for that wallet to start working with the given version.
+   *
+   *  This usually involves: (a) deploying the wallet, (b) executing migrations
+   *
+   *  Notice: It should NOT explicitly include chained signatures. Unless internally used
+   *  by any of the migrations.
+   *
+   */
+  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) {
+      let gasLimit;
+      switch (BigInt(chainId)) {
+        case BigInt(ChainId.SKALE_NEBULA):
+          gasLimit = 10000000n;
+          break;
+        case BigInt(ChainId.SOMNIA_TESTNET):
+          gasLimit = 10000000n;
+          break;
+      }
+
+      // Wallet deployment will vary depending on the version
+      // so we need to use the context to get the correct deployment
+      const deployTransaction = Wallet.buildDeployTransaction(status.original.context, status.original.imageHash, gasLimit);
+      transactions.push(...deployTransaction.transactions);
+    }
+
+    // Get pending migrations
+    transactions.push(...status.signedMigrations.map(m => ({
+      to: m.tx.entrypoint,
+      data: commons.transaction.encodeBundleExecData(m.tx),
+      value: 0,
+      gasLimit: 0,
+      revertOnError: true,
+      delegateCall: false
+    })));
+
+    // Build the transaction intent, if the transaction has migrations
+    // then we should use one of the intents of the migrations (anyone will do)
+    // if it doesn't, then the only intent we could use if the GuestModule one
+    // ... but this may fail if the relayer uses a different GuestModule
+    const id = status.signedMigrations.length > 0 ? status.signedMigrations[0].tx.intent.id : commons.transaction.subdigestOfGuestModuleTransactions(this.contexts[this.version].guestModule, chainId, transactions);
+
+    // Everything is encoded as a bundle
+    // using the GuestModule of the account version
+    const {
+      guestModule
+    } = this.contextFor(status.version);
+    return {
+      entrypoint: guestModule,
+      transactions,
+      chainId,
+      intent: {
+        id,
+        wallet: this.address
+      }
+    };
+  }
+  async bootstrapTransactions(chainId, prestatus) {
+    const status = prestatus || (await this.status(chainId));
+    return this.buildBootstrapTransactions(status, chainId);
+  }
+  async doBootstrap(chainId, feeQuote, prestatus) {
+    const bootstrapTxs = await this.bootstrapTransactions(chainId, prestatus);
+    return this.relayer(chainId).relay(_extends({}, bootstrapTxs, {
+      chainId
+    }), feeQuote);
+  }
+
+  /**
+   * Signs a message.
+   *
+   * This method will sign the message using the account associated with this signer
+   * and the specified chain ID. If the message is already prefixed with the EIP-191
+   * prefix, it will be hashed directly. Otherwise, it will be prefixed before hashing.
+   *
+   * @param message - The message to sign. Can be a string or BytesLike.
+   * @param chainId - The chain ID to use for signing
+   * @param cantValidateBehavior - Behavior when the wallet cannot validate on-chain
+   * @returns A Promise that resolves to the signature as a hexadecimal string
+   */
+  signMessage(message, chainId, cantValidateBehavior = 'ignore') {
+    const messageHex = ethers.hexlify(message);
+    const prefixHex = ethers.hexlify(ethers.toUtf8Bytes(MessagePrefix));
+    let digest;
+
+    // We check if the message is already prefixed with EIP-191
+    // This will avoid breaking changes for codebases where the message is already prefixed
+    if (messageHex.substring(2).startsWith(prefixHex.substring(2))) {
+      digest = ethers.keccak256(message);
+    } else {
+      digest = ethers.hashMessage(message);
+    }
+    return this.signDigest(digest, chainId, true, cantValidateBehavior);
+  }
+  async signTransactions(txs, chainId, pstatus, options) {
+    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 nonceOptions = options != null && options.serial ? {
+      serial: true
+    } : (options == null ? void 0 : options.nonceSpace) !== undefined ? {
+      space: options.nonceSpace
+    } : undefined;
+    const signed = await wallet.signTransactions(txs, nonceOptions, metadata);
+    return _extends({}, signed, {
+      signature: await this.decorateSignature(signed.signature, status)
+    });
+  }
+  async signMigrations(chainId, editConfig) {
+    const status = await this.status(chainId);
+    if (status.fullyMigrated) return false;
+    const wallet = this.walletForStatus(chainId, status);
+    const nextConfig = editConfig(wallet.config);
+    const signed = await this.migrator.signNextMigration(this.address, status.version, wallet, nextConfig);
+    if (!signed) return false;
+
+    // Make sure the tracker has a copy of the config
+    // before attempting to save the migration
+    // otherwise if this second step fails the tracker could end up
+    // with a migration to an unknown config
+    await this.tracker.saveWalletConfig({
+      config: nextConfig
+    });
+    const nextCoder = universal.coderFor(nextConfig.version).config;
+    const nextImageHash = nextCoder.imageHashOf(nextConfig);
+    const reverseConfig = await this.tracker.configOfImageHash({
+      imageHash: nextImageHash,
+      noCache: true
+    });
+    if (!reverseConfig || nextCoder.imageHashOf(reverseConfig) !== nextImageHash) {
+      throw Error(`Reverse lookup failed for imageHash ${nextImageHash}`);
+    }
+    await this.tracker.saveMigration(this.address, signed, this.contexts);
+    return true;
+  }
+  async signAllMigrations(editConfig) {
+    var _this2 = this;
+    const failedChains = [];
+    const signedMigrations = await Promise.all(this.networks.map(async function (n) {
+      try {
+        // Signing migrations for each chain
+        return await _this2.signMigrations(n.chainId, editConfig);
+      } catch (error) {
+        console.warn(`Failed to sign migrations for chain ${n.chainId}`, error);
+
+        // Adding failed chainId to the failedChains array
+        failedChains.push(n.chainId);
+        // Using null as a placeholder for failed chains
+        return null;
+      }
+    }));
+
+    // Filter out null values to get only the successful signed migrations
+    const successfulSignedMigrations = signedMigrations.filter(migration => migration !== null);
+    return {
+      signedMigrations: successfulSignedMigrations,
+      failedChains
+    };
+  }
+  async isMigratedAllChains() {
+    var _this3 = this;
+    const failedChains = [];
+    const statuses = await Promise.all(this.networks.map(async function (n) {
+      try {
+        return await _this3.status(n.chainId);
+      } catch (error) {
+        failedChains.push(n.chainId);
+        console.warn(`Failed to get status for chain ${n.chainId}`, error);
+
+        // default to true for failed chains
+        return {
+          fullyMigrated: true
+        };
+      }
+    }));
+    const migratedAllChains = statuses.every(s => s.fullyMigrated);
+    return {
+      migratedAllChains,
+      failedChains
+    };
+  }
+  async sendSignedTransactions(signedBundle, chainId, quote, pstatus, callback, projectAccessKey) {
+    if (!Array.isArray(signedBundle)) {
+      return this.sendSignedTransactions([signedBundle], chainId, quote, pstatus, callback, projectAccessKey);
+    }
+    const status = pstatus || (await this.status(chainId));
+    this.mustBeFullyMigrated(status);
+    const decoratedBundle = await this.decorateTransactions(signedBundle, status, chainId);
+    callback == null || callback(decoratedBundle);
+    return this.relayer(chainId).relay(decoratedBundle, quote, undefined, projectAccessKey);
+  }
+  async fillGasLimits(txs, chainId, status) {
+    const wallet = this.walletForStatus(chainId, status || (await this.status(chainId)));
+    return wallet.fillGasLimits(txs);
+  }
+  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);
+    const transactions = commons.transaction.fromTransactionish(this.address, predecorated);
+
+    // We can't sign the transactions (because we don't want to bother the user)
+    // so we use the latest configuration to build a "stub" signature, the relayer
+    // knows to ignore the wallet signatures
+    const stubSignature = wallet.coders.config.buildStubSignature(wallet.config, stubSignatureOverrides);
+
+    // Now we can decorate the transactions as always, but we need to manually build the signed bundle
+    const intentId = ethers.hexlify(ethers.randomBytes(32));
+    const signedBundle = {
+      chainId,
+      intent: {
+        id: intentId,
+        wallet: this.address
+      },
+      signature: stubSignature,
+      transactions,
+      entrypoint: this.address,
+      nonce: 0 // The relayer also ignored the nonce
+    };
+    const decoratedBundle = await this.decorateTransactions(signedBundle, wstatus);
+    const data = commons.transaction.encodeBundleExecData(decoratedBundle);
+    const res = await this.relayer(chainId).getFeeOptionsRaw(decoratedBundle.entrypoint, data, options);
+    return _extends({}, res, {
+      decorated: decoratedBundle
+    });
+  }
+  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, {
+      simulate: args.simulateForFeeOptions,
+      projectAccessKey: args.projectAccessKey
+    });
+    const flatDecorated = commons.transaction.unwind(this.address, gasRefundQuote.decorated.transactions);
+    return {
+      transactions,
+      flatDecorated,
+      feeOptions: gasRefundQuote.options,
+      feeQuote: gasRefundQuote.quote
+    };
+  }
+  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 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));
+    return this.sendSignedTransactions(bundles, chainId, quote, undefined, callback, options == null ? void 0 : options.projectAccessKey);
+  }
+  async signTypedData(domain, types, message, chainId, cantValidateBehavior = 'ignore') {
+    const digest = encodeTypedDataDigest({
+      domain,
+      types,
+      message
+    });
+    return this.signDigest(digest, chainId, true, cantValidateBehavior);
+  }
+  async getSigners() {
+    var _this4 = this;
+    const last = ts => ts.length ? ts[ts.length - 1] : undefined;
+    return (await Promise.all(this.networks.map(async function ({
+      chainId,
+      name
+    }) {
+      try {
+        var _last;
+        const status = await _this4.status(chainId);
+        let latestImageHash = (_last = last(status.presignedConfigurations)) == null ? void 0 : _last.nextImageHash;
+        if (!latestImageHash) {
+          if (status.onChain.version !== status.version) {
+            const migration = last(status.signedMigrations);
+            if (migration) {
+              const {
+                toVersion,
+                toConfig
+              } = migration;
+              const _coder = universal.genericCoderFor(toVersion);
+              latestImageHash = _coder.config.imageHashOf(toConfig);
+            }
+          }
+        }
+        if (!latestImageHash) {
+          latestImageHash = status.onChain.imageHash;
+        }
+        const latestConfig = await _this4.tracker.configOfImageHash({
+          imageHash: latestImageHash
+        });
+        if (!latestConfig) {
+          throw new Error(`unable to find config for image hash ${latestImageHash}`);
+        }
+        const coder = universal.genericCoderFor(latestConfig.version);
+        const signers = coder.config.signersOf(latestConfig);
+        return signers.map(signer => _extends({}, signer, {
+          network: chainId
+        }));
+      } catch (error) {
+        console.warn(`unable to get signers on network ${chainId} ${name}`, error);
+        return [];
+      }
+    }))).flat();
+  }
+  async getAllSigners() {
+    var _this5 = this;
+    const allSigners = [];
+
+    // We need to get the signers for each status
+    await Promise.all(this.networks.map(async function (network) {
+      const chainId = network.chainId;
+
+      // Getting the status with `longestPath` set to true will give us all the possible configurations
+      // between the current onChain config and the latest config, including the ones "flagged for removal"
+      const status = await _this5.status(chainId, true);
+      const fullChain = [status.onChain.imageHash, ...(status.onChain.version !== status.version ? status.signedMigrations.map(m => universal.coderFor(m.toVersion).config.imageHashOf(m.toConfig)) : []), ...status.presignedConfigurations.map(update => update.nextImageHash)];
+      return Promise.all(fullChain.map(async function (nextImageHash, iconf) {
+        const isLast = iconf === fullChain.length - 1;
+        const config = await _this5.tracker.configOfImageHash({
+          imageHash: nextImageHash
+        });
+        if (!config) {
+          console.warn(`AllSigners may be incomplete, config not found for imageHash ${nextImageHash}`);
+          return;
+        }
+        const coder = universal.genericCoderFor(config.version);
+        const signers = coder.config.signersOf(config);
+        signers.forEach(signer => {
+          const exists = allSigners.find(s => s.address === signer.address && s.network === chainId);
+          if (exists && isLast && exists.flaggedForRemoval) {
+            exists.flaggedForRemoval = false;
+            return;
+          }
+          if (exists) return;
+          allSigners.push({
+            address: signer.address,
+            weight: signer.weight,
+            network: chainId,
+            flaggedForRemoval: !isLast
+          });
+        });
+      }));
+    }));
+    return allSigners;
+  }
+}
+function isAccount(value) {
+  return value instanceof Account;
+}
+
+export { Account, isAccount };