@0xsequence/account 0.0.0-20230217200148

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

@@ -0,0 +1,483 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var migration = require('@0xsequence/migration');
+var ethers = require('ethers');
+var core = require('@0xsequence/core');
+var wallet = require('@0xsequence/wallet');
+var relayer = require('@0xsequence/relayer');
+var utils = require('@0xsequence/utils');
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+class Chain0Reader {
+  async isDeployed(_wallet) {
+    return false;
+  }
+  async implementation(_wallet) {
+    return undefined;
+  }
+  async imageHash(_wallet) {
+    return undefined;
+  }
+  async nonce(_wallet, _space) {
+    return ethers.ethers.constants.Zero;
+  }
+  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.address = ethers.ethers.utils.getAddress(options.address);
+    this.contexts = options.contexts;
+    this.tracker = options.tracker;
+    this.networks = options.networks;
+    this.orchestrator = options.orchestrator;
+    this.migrations = options.migrations || migration.defaults.DefaultMigrations;
+    this.migrator = new migration.migrator.Migrator(options.tracker, this.migrations, this.contexts);
+  }
+  static async new(options) {
+    var _options$migrations;
+    const mig = new migration.migrator.Migrator(options.tracker, (_options$migrations = options.migrations) != null ? _options$migrations : migration.defaults.DefaultMigrations, options.contexts);
+    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 = core.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
+    });
+  }
+  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 = ethers.ethers.BigNumber.from(chainId);
+    const found = this.networks.find(n => tcid.eq(n.chainId));
+    if (!found) throw new Error(`Network not found for chainId ${chainId}`);
+    return found;
+  }
+  provider(chainId) {
+    const found = this.network(chainId);
+    if (!found.provider && !found.rpcUrl) throw new Error(`Provider not found for chainId ${chainId}`);
+    return found.provider || new ethers.ethers.providers.JsonRpcProvider(found.rpcUrl);
+  }
+  reader(chainId) {
+    if (ethers.ethers.constants.Zero.eq(chainId)) return new Chain0Reader();
+
+    // TODO: Networks should be able to provide a reader directly
+    // and we should default to the on-chain reader
+    return new core.commons.reader.OnChainReader(this.provider(chainId));
+  }
+  relayer(chainId) {
+    const found = this.network(chainId);
+    if (!found.relayer) throw new Error(`Relayer not found for chainId ${chainId}`);
+    if (relayer.isRelayer(found.relayer)) return found.relayer;
+    return new relayer.RpcRelayer(found.relayer);
+  }
+  setOrchestrator(orchestrator) {
+    this.orchestrator = orchestrator;
+  }
+  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 = core.universal.coderFor(status.version);
+    return this.walletFor(chainId, this.contextFor(status.version), status.config, coder);
+  }
+  walletFor(chainId, context, config, coders) {
+    return new wallet.Wallet({
+      config,
+      context,
+      chainId,
+      coders,
+      address: this.address,
+      orchestrator: this.orchestrator,
+      reader: this.reader(chainId)
+    });
+  }
+
+  // Gets the current on-chain version of the wallet
+  // on a given network
+  async onchainVersionInfo(chainId) {
+    // First we need to use the tracker to get the counterfactual imageHash
+    const firstImageHash = await this.tracker.imageHashOfCounterfactualWallet({
+      wallet: this.address
+    });
+    if (!firstImageHash) {
+      throw new Error(`Counterfactual imageHash not found for wallet ${this.address}`);
+    }
+    const current = await migration.version.versionOf(this.address, firstImageHash.imageHash, this.contexts, this.reader(chainId));
+
+    // To find the first version, we need to try the firstImageHash
+    // with every context, and find the first one that matches
+    const first = migration.version.counterfactualVersion(this.address, firstImageHash.imageHash, Object.values(this.contexts));
+    return {
+      first: _extends({}, firstImageHash, {
+        version: first
+      }),
+      current
+    };
+  }
+
+  // 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) {
+    const isDeployedPromise = this.reader(chainId).isDeployed(this.address);
+    const onChainVersionInfoPromise = this.onchainVersionInfo(chainId);
+    let onChainImageHash = await this.reader(chainId).imageHash(this.address);
+    if (!onChainImageHash) {
+      const counterfactualImageHash = await this.tracker.imageHashOfCounterfactualWallet({
+        wallet: this.address
+      });
+      onChainImageHash = counterfactualImageHash == null ? void 0 : counterfactualImageHash.imageHash;
+    }
+    if (!onChainImageHash) {
+      throw new Error(`On-chain imageHash not found for wallet ${this.address}`);
+    }
+    const onChainConfig = await this.tracker.configOfImageHash({
+      imageHash: onChainImageHash
+    });
+    if (!onChainConfig) {
+      throw new Error(`On-chain config not found for imageHash ${onChainImageHash}`);
+    }
+    const {
+      current: onChainVersion,
+      first: onChainFirstInfo
+    } = await onChainVersionInfoPromise;
+    let fromImageHash = onChainImageHash;
+    let version = 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;
+      version = 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 checkpoint = core.universal.coderFor(version).config.checkpointOf(config);
+    return {
+      original: onChainFirstInfo,
+      onChain: {
+        imageHash: onChainImageHash,
+        config: onChainConfig,
+        version: onChainVersion,
+        deployed: isDeployed
+      },
+      fullyMigrated: version === this.version,
+      signedMigrations,
+      version,
+      presignedConfigurations: presigned,
+      imageHash,
+      config,
+      checkpoint,
+      canOnchainValidate: version === this.version && isDeployed
+    };
+  }
+  mustBeFullyMigrated(status) {
+    if (!status.fullyMigrated) {
+      throw new Error(`Wallet ${this.address} is not fully migrated`);
+    }
+  }
+  decorateTransactions(bundle, status) {
+    const bootstrapBundle = this.buildBootstrapTransactions(status);
+    if (bootstrapBundle.transactions.length === 0) {
+      return bundle;
+    }
+    return {
+      entrypoint: bootstrapBundle.entrypoint,
+      chainId: bundle.chainId,
+      intent: bundle.intent,
+      transactions: [...bootstrapBundle.transactions, {
+        to: bundle.entrypoint,
+        data: core.commons.transaction.encodeBundleExecData(bundle),
+        gasLimit: 0,
+        delegateCall: false,
+        revertOnError: true,
+        value: 0
+      }]
+    };
+  }
+  decorateSignature(signature, status) {
+    if (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.encode(chainedSignature);
+  }
+  async publishWitness() {
+    const digest = ethers.ethers.utils.keccak256(ethers.ethers.utils.toUtf8Bytes(`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) {
+    // 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);
+    const wallet = this.walletForStatus(chainId, status);
+    const signature = await wallet.signDigest(digest);
+    return decorate ? this.decorateSignature(signature, status) : signature;
+  }
+  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).add(1)
+    }));
+    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
+    return this.tracker.savePresignedConfiguration({
+      wallet: this.address,
+      nextConfig: config,
+      signature
+    });
+  }
+
+  /**
+   *  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.
+   * 
+   */
+  buildBootstrapTransactions(status) {
+    const transactions = [];
+
+    // Add wallet deployment if needed
+    if (!status.onChain.deployed) {
+      // Wallet deployment will vary depending on the version
+      // so we need to use the context to get the correct deployment
+      const deployTransaction = wallet.Wallet.buildDeployTransaction(status.original.context, status.original.imageHash);
+      transactions.push(...deployTransaction.transactions);
+    }
+
+    // Get pending migrations
+    transactions.push(...status.signedMigrations.map(m => ({
+      to: m.tx.entrypoint,
+      data: core.commons.transaction.encodeBundleExecData(m.tx),
+      value: 0,
+      gasLimit: 0,
+      revertOnError: true,
+      delegateCall: false
+    })));
+
+    // Everything is encoded as a bundle
+    // using the GuestModule of the account version
+    const {
+      guestModule
+    } = this.contextFor(status.version);
+    return {
+      entrypoint: guestModule,
+      transactions
+    };
+  }
+  async bootstrapTransactions(chainId) {
+    const status = await this.status(chainId);
+    return this.buildBootstrapTransactions(status);
+  }
+  async doBootstrap(chainId, feeQuote) {
+    const bootstrapTxs = await this.bootstrapTransactions(chainId);
+    const intended = core.commons.transaction.intendTransactionBundle(bootstrapTxs, this.address, chainId, ethers.ethers.utils.hexlify(ethers.ethers.utils.randomBytes(32)));
+    return this.relayer(chainId).relay(intended, feeQuote);
+  }
+  signMessage(message, chainId) {
+    return this.signDigest(ethers.ethers.utils.keccak256(message), chainId);
+  }
+  async signTransactions(txs, chainId) {
+    const status = await this.status(chainId);
+    this.mustBeFullyMigrated(status);
+    const wallet = this.walletForStatus(chainId, status);
+    const signed = await wallet.signTransactions(txs);
+    return _extends({}, signed, {
+      signature: 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 signed = await this.migrator.signNextMigration(this.address, status.version, wallet, editConfig(wallet.config));
+    if (!signed) return false;
+    await this.tracker.saveMigration(this.address, signed, this.contexts);
+    return true;
+  }
+  async signAllMigrations(editConfig) {
+    return Promise.all(this.networks.map(n => this.signMigrations(n.chainId, editConfig)));
+  }
+  async isMigratedAllChains() {
+    const statuses = await Promise.all(this.networks.map(n => this.status(n.chainId)));
+    return statuses.every(s => s.fullyMigrated);
+  }
+  async sendSignedTransactions(signedBundle, chainId, quote) {
+    const status = await this.status(signedBundle.chainId);
+    this.mustBeFullyMigrated(status);
+    const decoratedBundle = this.decorateTransactions(signedBundle, status);
+    return this.relayer(chainId).relay(decoratedBundle, quote);
+  }
+  async sendTransaction(txs, chainId, quote, skipLazyUpdate = false) {
+    if (!skipLazyUpdate) {
+      // if onchain wallet config is not up to date
+      // then we should append an extra transaction that updates it
+      // to the latest "lazy" state
+      const status = await this.status(chainId);
+      if (status.onChain.imageHash !== status.imageHash) {
+        const wallet = this.walletForStatus(chainId, status);
+        const updateConfig = await wallet.buildUpdateConfigurationTransaction(status.config);
+        txs = [Array.isArray(txs) ? txs : [txs], updateConfig.transactions].flat();
+      }
+    }
+    const signed = await this.signTransactions(txs, chainId);
+    return this.sendSignedTransactions(signed, chainId, quote);
+  }
+  async signTypedData(domain, types, message, chainId) {
+    const digest = utils.encodeTypedDataDigest({
+      domain,
+      types,
+      message
+    });
+    return this.signDigest(digest, chainId);
+  }
+  async getAllSigners() {
+    var _this = this;
+    const networks = this.networks;
+
+    // Getting all 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 statuses = await Promise.all(networks.map(n => this.status(n.chainId, true)));
+    const allSigners = [];
+
+    // We need to get the signers for each status
+    await Promise.all(statuses.map(async function (status, inet) {
+      const chainId = networks[inet].chainId;
+      return Promise.all(status.presignedConfigurations.map(async function (update, iconf) {
+        const isLast = iconf === status.presignedConfigurations.length - 1;
+        const config = await _this.tracker.configOfImageHash({
+          imageHash: update.nextImageHash
+        });
+        if (!config) {
+          console.warn(`AllSigners may be incomplete, config not found for imageHash ${update.nextImageHash}`);
+          return;
+        }
+        const coder = core.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;
+  }
+}
+
+exports.Account = Account;