@metamask-previews/keyring-controller 13.0.0-preview.e5c396b → 14.0.1-preview-d4ae797

package/dist/chunk-BVSGYW4D.js

@@ -0,0 +1,1290 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+
+
+
+var _chunkCHLPTPMZjs = require('./chunk-CHLPTPMZ.js');
+
+// src/KeyringController.ts
+var _util = require('@ethereumjs/util');
+var _basecontroller = require('@metamask/base-controller');
+var _browserpassworder = require('@metamask/browser-passworder'); var encryptorUtils = _interopRequireWildcard(_browserpassworder);
+var _ethhdkeyring = require('@metamask/eth-hd-keyring'); var _ethhdkeyring2 = _interopRequireDefault(_ethhdkeyring);
+var _ethsigutil = require('@metamask/eth-sig-util');
+var _ethsimplekeyring = require('@metamask/eth-simple-keyring'); var _ethsimplekeyring2 = _interopRequireDefault(_ethsimplekeyring);
+
+
+
+
+
+
+
+
+
+var _utils = require('@metamask/utils');
+var _asyncmutex = require('async-mutex');
+var _ethereumjswallet = require('ethereumjs-wallet'); var _ethereumjswallet2 = _interopRequireDefault(_ethereumjswallet);
+var name = "KeyringController";
+var KeyringTypes = /* @__PURE__ */ ((KeyringTypes2) => {
+  KeyringTypes2["simple"] = "Simple Key Pair";
+  KeyringTypes2["hd"] = "HD Key Tree";
+  KeyringTypes2["qr"] = "QR Hardware Wallet Device";
+  KeyringTypes2["trezor"] = "Trezor Hardware";
+  KeyringTypes2["ledger"] = "Ledger Hardware";
+  KeyringTypes2["lattice"] = "Lattice Hardware";
+  KeyringTypes2["snap"] = "Snap Keyring";
+  return KeyringTypes2;
+})(KeyringTypes || {});
+var isCustodyKeyring = (keyringType) => {
+  return keyringType.startsWith("Custody");
+};
+var AccountImportStrategy = /* @__PURE__ */ ((AccountImportStrategy2) => {
+  AccountImportStrategy2["privateKey"] = "privateKey";
+  AccountImportStrategy2["json"] = "json";
+  return AccountImportStrategy2;
+})(AccountImportStrategy || {});
+var SignTypedDataVersion = /* @__PURE__ */ ((SignTypedDataVersion2) => {
+  SignTypedDataVersion2["V1"] = "V1";
+  SignTypedDataVersion2["V3"] = "V3";
+  SignTypedDataVersion2["V4"] = "V4";
+  return SignTypedDataVersion2;
+})(SignTypedDataVersion || {});
+function keyringBuilderFactory(KeyringConstructor) {
+  const builder = () => new KeyringConstructor();
+  builder.type = KeyringConstructor.type;
+  return builder;
+}
+var defaultKeyringBuilders = [
+  keyringBuilderFactory(_ethsimplekeyring2.default),
+  keyringBuilderFactory(_ethhdkeyring2.default)
+];
+var getDefaultKeyringState = () => {
+  return {
+    isUnlocked: false,
+    keyrings: []
+  };
+};
+function assertHasUint8ArrayMnemonic(keyring) {
+  if (!(_utils.hasProperty.call(void 0, keyring, "mnemonic") && keyring.mnemonic instanceof Uint8Array)) {
+    throw new Error("Can't get mnemonic bytes from keyring");
+  }
+}
+function assertIsExportableKeyEncryptor(encryptor) {
+  if (!("importKey" in encryptor && typeof encryptor.importKey === "function" && "decryptWithKey" in encryptor && typeof encryptor.decryptWithKey === "function" && "encryptWithKey" in encryptor && typeof encryptor.encryptWithKey === "function")) {
+    throw new Error("KeyringController - The encryptor does not support encryption key export." /* UnsupportedEncryptionKeyExport */);
+  }
+}
+function isSerializedKeyringsArray(array) {
+  return typeof array === "object" && Array.isArray(array) && array.every((value) => value.type && _utils.isValidJson.call(void 0, value.data));
+}
+async function displayForKeyring(keyring) {
+  const accounts = await keyring.getAccounts();
+  return {
+    type: keyring.type,
+    // Cast to `Hex[]` here is safe here because `accounts` has no nullish
+    // values, and `normalize` returns `Hex` unless given a nullish value
+    accounts: accounts.map(_ethsigutil.normalize)
+  };
+}
+var _keyringBuilders, _keyrings, _unsupportedKeyrings, _password, _encryptor, _cacheEncryptionKey, _qrKeyringStateListener, _registerMessageHandlers, registerMessageHandlers_fn, _getKeyringBuilderForType, getKeyringBuilderForType_fn, _addQRKeyring, addQRKeyring_fn, _subscribeToQRKeyringEvents, subscribeToQRKeyringEvents_fn, _unsubscribeFromQRKeyringsEvents, unsubscribeFromQRKeyringsEvents_fn, _createNewVaultWithKeyring, createNewVaultWithKeyring_fn, _updateKeyringsInState, updateKeyringsInState_fn, _unlockKeyrings, unlockKeyrings_fn, _createKeyringWithFirstAccount, createKeyringWithFirstAccount_fn, _newKeyring, newKeyring_fn, _clearKeyrings, clearKeyrings_fn, _restoreKeyring, restoreKeyring_fn, _destroyKeyring, destroyKeyring_fn, _removeEmptyKeyrings, removeEmptyKeyrings_fn, _checkForDuplicate, checkForDuplicate_fn, _setUnlocked, setUnlocked_fn, _getMemState, getMemState_fn;
+var KeyringController = class extends _basecontroller.BaseController {
+  /**
+   * Creates a KeyringController instance.
+   *
+   * @param options - Initial options used to configure this controller
+   * @param options.encryptor - An optional object for defining encryption schemes.
+   * @param options.keyringBuilders - Set a new name for account.
+   * @param options.cacheEncryptionKey - Whether to cache or not encryption key.
+   * @param options.messenger - A restricted controller messenger.
+   * @param options.state - Initial state to set on this controller.
+   */
+  constructor(options) {
+    const {
+      encryptor = encryptorUtils,
+      keyringBuilders,
+      messenger,
+      state
+    } = options;
+    super({
+      name,
+      metadata: {
+        vault: { persist: true, anonymous: false },
+        isUnlocked: { persist: false, anonymous: true },
+        keyrings: { persist: false, anonymous: false },
+        encryptionKey: { persist: false, anonymous: false },
+        encryptionSalt: { persist: false, anonymous: false }
+      },
+      messenger,
+      state: {
+        ...getDefaultKeyringState(),
+        ...state
+      }
+    });
+    /**
+     * Constructor helper for registering this controller's messaging system
+     * actions.
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _registerMessageHandlers);
+    /**
+     * Get the keyring builder for the given `type`.
+     *
+     * @param type - The type of keyring to get the builder for.
+     * @returns The keyring builder, or undefined if none exists.
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _getKeyringBuilderForType);
+    /**
+     * Add qr hardware keyring.
+     *
+     * @returns The added keyring
+     * @throws If a QRKeyring builder is not provided
+     * when initializing the controller
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _addQRKeyring);
+    /**
+     * Subscribe to a QRKeyring state change events and
+     * forward them through the messaging system.
+     *
+     * @param qrKeyring - The QRKeyring instance to subscribe to
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _subscribeToQRKeyringEvents);
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _unsubscribeFromQRKeyringsEvents);
+    /**
+     * Create new vault with an initial keyring
+     *
+     * Destroys any old encrypted storage,
+     * creates a new encrypted store with the given password,
+     * creates a new wallet with 1 account.
+     *
+     * @fires KeyringController:unlock
+     * @param password - The password to encrypt the vault with.
+     * @param keyring - A object containing the params to instantiate a new keyring.
+     * @param keyring.type - The keyring type.
+     * @param keyring.opts - Optional parameters required to instantiate the keyring.
+     * @returns A promise that resolves to the state.
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _createNewVaultWithKeyring);
+    /**
+     * Update the controller state with its current keyrings.
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _updateKeyringsInState);
+    /**
+     * Unlock Keyrings, decrypting the vault and deserializing all
+     * keyrings contained in it, using a password or an encryption key with salt.
+     *
+     * @param password - The keyring controller password.
+     * @param encryptionKey - An exported key string to unlock keyrings with.
+     * @param encryptionSalt - The salt used to encrypt the vault.
+     * @returns A promise resolving to the deserialized keyrings array.
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _unlockKeyrings);
+    /**
+     * Create a new keyring, ensuring that the first account is
+     * also created.
+     *
+     * @param type - Keyring type to instantiate.
+     * @param opts - Optional parameters required to instantiate the keyring.
+     * @returns A promise that resolves if the operation is successful.
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _createKeyringWithFirstAccount);
+    /**
+     * Instantiate, initialize and return a new keyring of the given `type`,
+     * using the given `opts`. The keyring is built using the keyring builder
+     * registered for the given `type`.
+     *
+     * @param type - The type of keyring to add.
+     * @param data - The data to restore a previously serialized keyring.
+     * @returns The new keyring.
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _newKeyring);
+    /**
+     * Remove all managed keyrings, destroying all their
+     * instances in memory.
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _clearKeyrings);
+    /**
+     * Restore a Keyring from a provided serialized payload.
+     * On success, returns the resulting keyring instance.
+     *
+     * @param serialized - The serialized keyring.
+     * @returns The deserialized keyring or undefined if the keyring type is unsupported.
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _restoreKeyring);
+    /**
+     * Destroy Keyring
+     *
+     * Some keyrings support a method called `destroy`, that destroys the
+     * keyring along with removing all its event listeners and, in some cases,
+     * clears the keyring bridge iframe from the DOM.
+     *
+     * @param keyring - The keyring to destroy.
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _destroyKeyring);
+    /**
+     * Remove empty keyrings.
+     *
+     * Loops through the keyrings and removes the ones with empty accounts
+     * (usually after removing the last / only account) from a keyring.
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _removeEmptyKeyrings);
+    /**
+     * Checks for duplicate keypairs, using the the first account in the given
+     * array. Rejects if a duplicate is found.
+     *
+     * Only supports 'Simple Key Pair'.
+     *
+     * @param type - The key pair type to check for.
+     * @param newAccountArray - Array of new accounts.
+     * @returns The account, if no duplicate is found.
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _checkForDuplicate);
+    /**
+     * Set the `isUnlocked` to true and notify listeners
+     * through the messenger.
+     *
+     * @fires KeyringController:unlock
+     */
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _setUnlocked);
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _getMemState);
+    this.mutex = new (0, _asyncmutex.Mutex)();
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _keyringBuilders, void 0);
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _keyrings, void 0);
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _unsupportedKeyrings, void 0);
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _password, void 0);
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _encryptor, void 0);
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _cacheEncryptionKey, void 0);
+    _chunkCHLPTPMZjs.__privateAdd.call(void 0, this, _qrKeyringStateListener, void 0);
+    _chunkCHLPTPMZjs.__privateSet.call(void 0, this, _keyringBuilders, keyringBuilders ? defaultKeyringBuilders.concat(keyringBuilders) : defaultKeyringBuilders);
+    _chunkCHLPTPMZjs.__privateSet.call(void 0, this, _encryptor, encryptor);
+    _chunkCHLPTPMZjs.__privateSet.call(void 0, this, _keyrings, []);
+    _chunkCHLPTPMZjs.__privateSet.call(void 0, this, _unsupportedKeyrings, []);
+    _chunkCHLPTPMZjs.__privateSet.call(void 0, this, _cacheEncryptionKey, Boolean(options.cacheEncryptionKey));
+    if (_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _cacheEncryptionKey)) {
+      assertIsExportableKeyEncryptor(encryptor);
+    }
+    _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _registerMessageHandlers, registerMessageHandlers_fn).call(this);
+  }
+  /**
+   * Adds a new account to the default (first) HD seed phrase keyring.
+   *
+   * @param accountCount - Number of accounts before adding a new one, used to
+   * make the method idempotent.
+   * @returns Promise resolving to keyring current state and added account
+   * address.
+   */
+  async addNewAccount(accountCount) {
+    const primaryKeyring = this.getKeyringsByType("HD Key Tree")[0];
+    if (!primaryKeyring) {
+      throw new Error("No HD keyring found");
+    }
+    const oldAccounts = await this.getAccounts();
+    if (accountCount && oldAccounts.length !== accountCount) {
+      if (accountCount > oldAccounts.length) {
+        throw new Error("Account out of sequence");
+      }
+      const primaryKeyringAccounts = await primaryKeyring.getAccounts();
+      return {
+        keyringState: _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _getMemState, getMemState_fn).call(this),
+        addedAccountAddress: primaryKeyringAccounts[accountCount]
+      };
+    }
+    const addedAccountAddress = await this.addNewAccountForKeyring(
+      primaryKeyring
+    );
+    await this.verifySeedPhrase();
+    return {
+      keyringState: _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _getMemState, getMemState_fn).call(this),
+      addedAccountAddress
+    };
+  }
+  /**
+   * Adds a new account to the specified keyring.
+   *
+   * @param keyring - Keyring to add the account to.
+   * @param accountCount - Number of accounts before adding a new one, used to make the method idempotent.
+   * @returns Promise resolving to keyring current state and added account
+   */
+  async addNewAccountForKeyring(keyring, accountCount) {
+    const oldAccounts = await this.getAccounts();
+    if (accountCount && oldAccounts.length !== accountCount) {
+      if (accountCount > oldAccounts.length) {
+        throw new Error("Account out of sequence");
+      }
+      const existingAccount = oldAccounts[accountCount];
+      _utils.assertIsStrictHexString.call(void 0, existingAccount);
+      return existingAccount;
+    }
+    await keyring.addAccounts(1);
+    await this.persistAllKeyrings();
+    const addedAccountAddress = (await this.getAccounts()).find(
+      (selectedAddress) => !oldAccounts.includes(selectedAddress)
+    );
+    _utils.assertIsStrictHexString.call(void 0, addedAccountAddress);
+    return addedAccountAddress;
+  }
+  /**
+   * Adds a new account to the default (first) HD seed phrase keyring without updating identities in preferences.
+   *
+   * @returns Promise resolving to current state when the account is added.
+   */
+  async addNewAccountWithoutUpdate() {
+    const primaryKeyring = this.getKeyringsByType("HD Key Tree")[0];
+    if (!primaryKeyring) {
+      throw new Error("No HD keyring found");
+    }
+    await primaryKeyring.addAccounts(1);
+    await this.persistAllKeyrings();
+    await this.verifySeedPhrase();
+    return _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _getMemState, getMemState_fn).call(this);
+  }
+  /**
+   * Effectively the same as creating a new keychain then populating it
+   * using the given seed phrase.
+   *
+   * @param password - Password to unlock keychain.
+   * @param seed - A BIP39-compliant seed phrase as Uint8Array,
+   * either as a string or an array of UTF-8 bytes that represent the string.
+   * @returns Promise resolving to the restored keychain object.
+   */
+  async createNewVaultAndRestore(password, seed) {
+    const releaseLock = await this.mutex.acquire();
+    if (!password || !password.length) {
+      throw new Error("Invalid password");
+    }
+    try {
+      await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _createNewVaultWithKeyring, createNewVaultWithKeyring_fn).call(this, password, {
+        type: "HD Key Tree" /* hd */,
+        opts: {
+          mnemonic: seed,
+          numberOfAccounts: 1
+        }
+      });
+      return _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _getMemState, getMemState_fn).call(this);
+    } finally {
+      releaseLock();
+    }
+  }
+  /**
+   * Create a new primary keychain and wipe any previous keychains.
+   *
+   * @param password - Password to unlock the new vault.
+   * @returns Newly-created keychain object.
+   */
+  async createNewVaultAndKeychain(password) {
+    const releaseLock = await this.mutex.acquire();
+    try {
+      const accounts = await this.getAccounts();
+      if (!accounts.length) {
+        await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _createNewVaultWithKeyring, createNewVaultWithKeyring_fn).call(this, password, {
+          type: "HD Key Tree" /* hd */
+        });
+      }
+      return _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _getMemState, getMemState_fn).call(this);
+    } finally {
+      releaseLock();
+    }
+  }
+  /**
+   * Adds a new keyring of the given `type`.
+   *
+   * @param type - Keyring type name.
+   * @param opts - Keyring options.
+   * @throws If a builder for the given `type` does not exist.
+   * @returns Promise resolving to the added keyring.
+   */
+  async addNewKeyring(type, opts) {
+    if (type === "QR Hardware Wallet Device" /* qr */) {
+      return this.getOrAddQRKeyring();
+    }
+    const keyring = await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _newKeyring, newKeyring_fn).call(this, type, opts);
+    if (type === "HD Key Tree" /* hd */ && (!_utils.isObject.call(void 0, opts) || !opts.mnemonic)) {
+      if (!keyring.generateRandomMnemonic) {
+        throw new Error(
+          "KeyringController - The current keyring does not support the method generateRandomMnemonic." /* UnsupportedGenerateRandomMnemonic */
+        );
+      }
+      keyring.generateRandomMnemonic();
+      await keyring.addAccounts(1);
+    }
+    const accounts = await keyring.getAccounts();
+    await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _checkForDuplicate, checkForDuplicate_fn).call(this, type, accounts);
+    _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _keyrings).push(keyring);
+    await this.persistAllKeyrings();
+    return keyring;
+  }
+  /**
+   * Method to verify a given password validity. Throws an
+   * error if the password is invalid.
+   *
+   * @param password - Password of the keyring.
+   */
+  async verifyPassword(password) {
+    if (!this.state.vault) {
+      throw new Error("KeyringController - Cannot unlock without a previous vault." /* VaultError */);
+    }
+    await _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _encryptor).decrypt(password, this.state.vault);
+  }
+  /**
+   * Returns the status of the vault.
+   *
+   * @returns Boolean returning true if the vault is unlocked.
+   */
+  isUnlocked() {
+    return this.state.isUnlocked;
+  }
+  /**
+   * Gets the seed phrase of the HD keyring.
+   *
+   * @param password - Password of the keyring.
+   * @returns Promise resolving to the seed phrase.
+   */
+  async exportSeedPhrase(password) {
+    await this.verifyPassword(password);
+    assertHasUint8ArrayMnemonic(_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _keyrings)[0]);
+    return _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _keyrings)[0].mnemonic;
+  }
+  /**
+   * Gets the private key from the keyring controlling an address.
+   *
+   * @param password - Password of the keyring.
+   * @param address - Address to export.
+   * @returns Promise resolving to the private key for an address.
+   */
+  async exportAccount(password, address) {
+    await this.verifyPassword(password);
+    const keyring = await this.getKeyringForAccount(
+      address
+    );
+    if (!keyring.exportAccount) {
+      throw new Error("`KeyringController - The keyring for the current address does not support the method exportAccount" /* UnsupportedExportAccount */);
+    }
+    return await keyring.exportAccount(_ethsigutil.normalize.call(void 0, address));
+  }
+  /**
+   * Returns the public addresses of all accounts for the current keyring.
+   *
+   * @returns A promise resolving to an array of addresses.
+   */
+  async getAccounts() {
+    const keyrings = _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _keyrings);
+    const keyringArrays = await Promise.all(
+      keyrings.map(async (keyring) => keyring.getAccounts())
+    );
+    const addresses = keyringArrays.reduce((res, arr) => {
+      return res.concat(arr);
+    }, []);
+    return addresses.map(_ethsigutil.normalize);
+  }
+  /**
+   * Get encryption public key.
+   *
+   * @param account - An account address.
+   * @param opts - Additional encryption options.
+   * @throws If the `account` does not exist or does not support the `getEncryptionPublicKey` method
+   * @returns Promise resolving to encyption public key of the `account` if one exists.
+   */
+  async getEncryptionPublicKey(account, opts) {
+    const normalizedAddress = _ethsigutil.normalize.call(void 0, account);
+    const keyring = await this.getKeyringForAccount(
+      account
+    );
+    if (!keyring.getEncryptionPublicKey) {
+      throw new Error("KeyringController - The keyring for the current address does not support the method getEncryptionPublicKey." /* UnsupportedGetEncryptionPublicKey */);
+    }
+    return await keyring.getEncryptionPublicKey(normalizedAddress, opts);
+  }
+  /**
+   * Attempts to decrypt the provided message parameters.
+   *
+   * @param messageParams - The decryption message parameters.
+   * @param messageParams.from - The address of the account you want to use to decrypt the message.
+   * @param messageParams.data - The encrypted data that you want to decrypt.
+   * @returns The raw decryption result.
+   */
+  async decryptMessage(messageParams) {
+    const address = _ethsigutil.normalize.call(void 0, messageParams.from);
+    const keyring = await this.getKeyringForAccount(
+      address
+    );
+    if (!keyring.decryptMessage) {
+      throw new Error("KeyringController - The keyring for the current address does not support the method decryptMessage." /* UnsupportedDecryptMessage */);
+    }
+    return keyring.decryptMessage(address, messageParams.data);
+  }
+  /**
+   * Returns the currently initialized keyring that manages
+   * the specified `address` if one exists.
+   *
+   * @deprecated Use of this method is discouraged as actions executed directly on
+   * keyrings are not being reflected in the KeyringController state and not
+   * persisted in the vault.
+   * @param account - An account address.
+   * @returns Promise resolving to keyring of the `account` if one exists.
+   */
+  async getKeyringForAccount(account) {
+    const hexed = _ethsigutil.normalize.call(void 0, account);
+    const candidates = await Promise.all(
+      _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _keyrings).map(async (keyring) => {
+        return Promise.all([keyring, keyring.getAccounts()]);
+      })
+    );
+    const winners = candidates.filter((candidate) => {
+      const accounts = candidate[1].map(_ethsigutil.normalize);
+      return accounts.includes(hexed);
+    });
+    if (winners.length && winners[0]?.length) {
+      return winners[0][0];
+    }
+    let errorInfo = "";
+    if (!_utils.isValidHexAddress.call(void 0, hexed)) {
+      errorInfo = "The address passed in is invalid/empty";
+    } else if (!candidates.length) {
+      errorInfo = "There are no keyrings";
+    } else if (!winners.length) {
+      errorInfo = "There are keyrings, but none match the address";
+    }
+    throw new Error(
+      `${"KeyringController - No keyring found" /* NoKeyring */}. Error info: ${errorInfo}`
+    );
+  }
+  /**
+   * Returns all keyrings of the given type.
+   *
+   * @deprecated Use of this method is discouraged as actions executed directly on
+   * keyrings are not being reflected in the KeyringController state and not
+   * persisted in the vault.
+   * @param type - Keyring type name.
+   * @returns An array of keyrings of the given type.
+   */
+  getKeyringsByType(type) {
+    return _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _keyrings).filter((keyring) => keyring.type === type);
+  }
+  /**
+   * Persist all serialized keyrings in the vault.
+   *
+   * @returns Promise resolving with `true` value when the
+   * operation completes.
+   */
+  async persistAllKeyrings() {
+    const { encryptionKey, encryptionSalt } = this.state;
+    if (!_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _password) && !encryptionKey) {
+      throw new Error("KeyringController - Cannot persist vault without password and encryption key" /* MissingCredentials */);
+    }
+    const serializedKeyrings = await Promise.all(
+      _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _keyrings).map(async (keyring) => {
+        const [type, data] = await Promise.all([
+          keyring.type,
+          keyring.serialize()
+        ]);
+        return { type, data };
+      })
+    );
+    serializedKeyrings.push(..._chunkCHLPTPMZjs.__privateGet.call(void 0, this, _unsupportedKeyrings));
+    let vault;
+    let newEncryptionKey;
+    if (_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _cacheEncryptionKey)) {
+      assertIsExportableKeyEncryptor(_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _encryptor));
+      if (encryptionKey) {
+        const key = await _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _encryptor).importKey(encryptionKey);
+        const vaultJSON = await _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _encryptor).encryptWithKey(
+          key,
+          serializedKeyrings
+        );
+        vaultJSON.salt = encryptionSalt;
+        vault = JSON.stringify(vaultJSON);
+      } else if (_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _password)) {
+        const { vault: newVault, exportedKeyString } = await _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _encryptor).encryptWithDetail(
+          _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _password),
+          serializedKeyrings
+        );
+        vault = newVault;
+        newEncryptionKey = exportedKeyString;
+      }
+    } else {
+      if (typeof _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _password) !== "string") {
+        throw new TypeError("KeyringController - Password must be of type string." /* WrongPasswordType */);
+      }
+      vault = await _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _encryptor).encrypt(_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _password), serializedKeyrings);
+    }
+    if (!vault) {
+      throw new Error("KeyringController - Cannot persist vault without vault information" /* MissingVaultData */);
+    }
+    this.update((state) => {
+      state.vault = vault;
+    });
+    await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _updateKeyringsInState, updateKeyringsInState_fn).call(this);
+    if (newEncryptionKey) {
+      this.update((state) => {
+        state.encryptionKey = newEncryptionKey;
+        state.encryptionSalt = JSON.parse(vault).salt;
+      });
+    }
+    return true;
+  }
+  /**
+   * Imports an account with the specified import strategy.
+   *
+   * @param strategy - Import strategy name.
+   * @param args - Array of arguments to pass to the underlying stategy.
+   * @throws Will throw when passed an unrecognized strategy.
+   * @returns Promise resolving to keyring current state and imported account
+   * address.
+   */
+  async importAccountWithStrategy(strategy, args) {
+    let privateKey;
+    switch (strategy) {
+      case "privateKey":
+        const [importedKey] = args;
+        if (!importedKey) {
+          throw new Error("Cannot import an empty key.");
+        }
+        const prefixed = _utils.add0x.call(void 0, importedKey);
+        let bufferedPrivateKey;
+        try {
+          bufferedPrivateKey = _util.toBuffer.call(void 0, prefixed);
+        } catch {
+          throw new Error("Cannot import invalid private key.");
+        }
+        if (!_util.isValidPrivate.call(void 0, bufferedPrivateKey) || // ensures that the key is 64 bytes long
+        _util.getBinarySize.call(void 0, prefixed) !== 64 + "0x".length) {
+          throw new Error("Cannot import invalid private key.");
+        }
+        privateKey = _utils.remove0x.call(void 0, prefixed);
+        break;
+      case "json":
+        let wallet;
+        const [input, password] = args;
+        try {
+          wallet = _ethereumjswallet.thirdparty.fromEtherWallet(input, password);
+        } catch (e) {
+          wallet = wallet || await _ethereumjswallet2.default.fromV3(input, password, true);
+        }
+        privateKey = _utils.bytesToHex.call(void 0, wallet.getPrivateKey());
+        break;
+      default:
+        throw new Error(`Unexpected import strategy: '${strategy}'`);
+    }
+    const newKeyring = await this.addNewKeyring("Simple Key Pair" /* simple */, [
+      privateKey
+    ]);
+    const accounts = await newKeyring.getAccounts();
+    return {
+      keyringState: _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _getMemState, getMemState_fn).call(this),
+      importedAccountAddress: accounts[0]
+    };
+  }
+  /**
+   * Removes an account from keyring state.
+   *
+   * @param address - Address of the account to remove.
+   * @fires KeyringController:accountRemoved
+   * @returns Promise resolving current state when this account removal completes.
+   */
+  async removeAccount(address) {
+    const keyring = await this.getKeyringForAccount(
+      address
+    );
+    if (!keyring.removeAccount) {
+      throw new Error("`KeyringController - The keyring for the current address does not support the method removeAccount" /* UnsupportedRemoveAccount */);
+    }
+    await keyring.removeAccount(address);
+    const accounts = await keyring.getAccounts();
+    if (accounts.length === 0) {
+      await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _removeEmptyKeyrings, removeEmptyKeyrings_fn).call(this);
+    }
+    await this.persistAllKeyrings();
+    this.messagingSystem.publish(`${name}:accountRemoved`, address);
+    return _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _getMemState, getMemState_fn).call(this);
+  }
+  /**
+   * Deallocates all secrets and locks the wallet.
+   *
+   * @returns Promise resolving to current state.
+   */
+  async setLocked() {
+    _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _unsubscribeFromQRKeyringsEvents, unsubscribeFromQRKeyringsEvents_fn).call(this);
+    _chunkCHLPTPMZjs.__privateSet.call(void 0, this, _password, void 0);
+    this.update((state) => {
+      state.isUnlocked = false;
+      state.keyrings = [];
+    });
+    await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _clearKeyrings, clearKeyrings_fn).call(this);
+    this.messagingSystem.publish(`${name}:lock`);
+    return _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _getMemState, getMemState_fn).call(this);
+  }
+  /**
+   * Signs message by calling down into a specific keyring.
+   *
+   * @param messageParams - PersonalMessageParams object to sign.
+   * @returns Promise resolving to a signed message string.
+   */
+  async signMessage(messageParams) {
+    if (!messageParams.data) {
+      throw new Error("Can't sign an empty message");
+    }
+    const address = _ethsigutil.normalize.call(void 0, messageParams.from);
+    const keyring = await this.getKeyringForAccount(
+      address
+    );
+    if (!keyring.signMessage) {
+      throw new Error("KeyringController - The keyring for the current address does not support the method signMessage." /* UnsupportedSignMessage */);
+    }
+    return await keyring.signMessage(address, messageParams.data);
+  }
+  /**
+   * Signs personal message by calling down into a specific keyring.
+   *
+   * @param messageParams - PersonalMessageParams object to sign.
+   * @returns Promise resolving to a signed message string.
+   */
+  async signPersonalMessage(messageParams) {
+    const address = _ethsigutil.normalize.call(void 0, messageParams.from);
+    const keyring = await this.getKeyringForAccount(
+      address
+    );
+    if (!keyring.signPersonalMessage) {
+      throw new Error("KeyringController - The keyring for the current address does not support the method signPersonalMessage." /* UnsupportedSignPersonalMessage */);
+    }
+    const normalizedData = _ethsigutil.normalize.call(void 0, messageParams.data);
+    return await keyring.signPersonalMessage(address, normalizedData);
+  }
+  /**
+   * Signs typed message by calling down into a specific keyring.
+   *
+   * @param messageParams - TypedMessageParams object to sign.
+   * @param version - Compatibility version EIP712.
+   * @throws Will throw when passed an unrecognized version.
+   * @returns Promise resolving to a signed message string or an error if any.
+   */
+  async signTypedMessage(messageParams, version) {
+    try {
+      if (![
+        "V1" /* V1 */,
+        "V3" /* V3 */,
+        "V4" /* V4 */
+      ].includes(version)) {
+        throw new Error(`Unexpected signTypedMessage version: '${version}'`);
+      }
+      const address = _ethsigutil.normalize.call(void 0, messageParams.from);
+      const keyring = await this.getKeyringForAccount(
+        address
+      );
+      if (!keyring.signTypedData) {
+        throw new Error("KeyringController - The keyring for the current address does not support the method signTypedMessage." /* UnsupportedSignTypedMessage */);
+      }
+      return await keyring.signTypedData(
+        address,
+        version !== "V1" /* V1 */ && typeof messageParams.data === "string" ? JSON.parse(messageParams.data) : messageParams.data,
+        { version }
+      );
+    } catch (error) {
+      throw new Error(`Keyring Controller signTypedMessage: ${error}`);
+    }
+  }
+  /**
+   * Signs a transaction by calling down into a specific keyring.
+   *
+   * @param transaction - Transaction object to sign. Must be a `ethereumjs-tx` transaction instance.
+   * @param from - Address to sign from, should be in keychain.
+   * @param opts - An optional options object.
+   * @returns Promise resolving to a signed transaction string.
+   */
+  async signTransaction(transaction, from, opts) {
+    const address = _ethsigutil.normalize.call(void 0, from);
+    const keyring = await this.getKeyringForAccount(
+      address
+    );
+    if (!keyring.signTransaction) {
+      throw new Error("KeyringController - The keyring for the current address does not support the method signTransaction." /* UnsupportedSignTransaction */);
+    }
+    return await keyring.signTransaction(address, transaction, opts);
+  }
+  /**
+   * Convert a base transaction to a base UserOperation.
+   *
+   * @param from - Address of the sender.
+   * @param transactions - Base transactions to include in the UserOperation.
+   * @returns A pseudo-UserOperation that can be used to construct a real.
+   */
+  async prepareUserOperation(from, transactions) {
+    const address = _ethsigutil.normalize.call(void 0, from);
+    const keyring = await this.getKeyringForAccount(
+      address
+    );
+    if (!keyring.prepareUserOperation) {
+      throw new Error("KeyringController - The keyring for the current address does not support the method prepareUserOperation." /* UnsupportedPrepareUserOperation */);
+    }
+    return await keyring.prepareUserOperation(address, transactions);
+  }
+  /**
+   * Patches properties of a UserOperation. Currently, only the
+   * `paymasterAndData` can be patched.
+   *
+   * @param from - Address of the sender.
+   * @param userOp - UserOperation to patch.
+   * @returns A patch to apply to the UserOperation.
+   */
+  async patchUserOperation(from, userOp) {
+    const address = _ethsigutil.normalize.call(void 0, from);
+    const keyring = await this.getKeyringForAccount(
+      address
+    );
+    if (!keyring.patchUserOperation) {
+      throw new Error("KeyringController - The keyring for the current address does not support the method patchUserOperation." /* UnsupportedPatchUserOperation */);
+    }
+    return await keyring.patchUserOperation(address, userOp);
+  }
+  /**
+   * Signs an UserOperation.
+   *
+   * @param from - Address of the sender.
+   * @param userOp - UserOperation to sign.
+   * @returns The signature of the UserOperation.
+   */
+  async signUserOperation(from, userOp) {
+    const address = _ethsigutil.normalize.call(void 0, from);
+    const keyring = await this.getKeyringForAccount(
+      address
+    );
+    if (!keyring.signUserOperation) {
+      throw new Error("KeyringController - The keyring for the current address does not support the method signUserOperation." /* UnsupportedSignUserOperation */);
+    }
+    return await keyring.signUserOperation(address, userOp);
+  }
+  /**
+   * Attempts to decrypt the current vault and load its keyrings,
+   * using the given encryption key and salt.
+   *
+   * @param encryptionKey - Key to unlock the keychain.
+   * @param encryptionSalt - Salt to unlock the keychain.
+   * @returns Promise resolving to the current state.
+   */
+  async submitEncryptionKey(encryptionKey, encryptionSalt) {
+    _chunkCHLPTPMZjs.__privateSet.call(void 0, this, _keyrings, await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _unlockKeyrings, unlockKeyrings_fn).call(this, void 0, encryptionKey, encryptionSalt));
+    _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _setUnlocked, setUnlocked_fn).call(this);
+    const qrKeyring = this.getQRKeyring();
+    if (qrKeyring) {
+      _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _subscribeToQRKeyringEvents, subscribeToQRKeyringEvents_fn).call(this, qrKeyring);
+    }
+    return _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _getMemState, getMemState_fn).call(this);
+  }
+  /**
+   * Attempts to decrypt the current vault and load its keyrings,
+   * using the given password.
+   *
+   * @param password - Password to unlock the keychain.
+   * @returns Promise resolving to the current state.
+   */
+  async submitPassword(password) {
+    _chunkCHLPTPMZjs.__privateSet.call(void 0, this, _keyrings, await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _unlockKeyrings, unlockKeyrings_fn).call(this, password));
+    _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _setUnlocked, setUnlocked_fn).call(this);
+    const qrKeyring = this.getQRKeyring();
+    if (qrKeyring) {
+      _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _subscribeToQRKeyringEvents, subscribeToQRKeyringEvents_fn).call(this, qrKeyring);
+    }
+    return _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _getMemState, getMemState_fn).call(this);
+  }
+  /**
+   * Verifies the that the seed phrase restores the current keychain's accounts.
+   *
+   * @returns Promise resolving to the seed phrase as Uint8Array.
+   */
+  async verifySeedPhrase() {
+    const primaryKeyring = this.getKeyringsByType("HD Key Tree" /* hd */)[0];
+    if (!primaryKeyring) {
+      throw new Error("No HD keyring found.");
+    }
+    assertHasUint8ArrayMnemonic(primaryKeyring);
+    const seedWords = primaryKeyring.mnemonic;
+    const accounts = await primaryKeyring.getAccounts();
+    if (accounts.length === 0) {
+      throw new Error("Cannot verify an empty keyring.");
+    }
+    const hdKeyringBuilder = _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _getKeyringBuilderForType, getKeyringBuilderForType_fn).call(this, "HD Key Tree" /* hd */);
+    const hdKeyring = hdKeyringBuilder();
+    await hdKeyring.deserialize({
+      mnemonic: seedWords,
+      numberOfAccounts: accounts.length
+    });
+    const testAccounts = await hdKeyring.getAccounts();
+    if (testAccounts.length !== accounts.length) {
+      throw new Error("Seed phrase imported incorrect number of accounts.");
+    }
+    testAccounts.forEach((account, i) => {
+      if (account.toLowerCase() !== accounts[i].toLowerCase()) {
+        throw new Error("Seed phrase imported different accounts.");
+      }
+    });
+    return seedWords;
+  }
+  // QR Hardware related methods
+  /**
+   * Get QR Hardware keyring.
+   *
+   * @returns The QR Keyring if defined, otherwise undefined
+   */
+  getQRKeyring() {
+    return this.getKeyringsByType("QR Hardware Wallet Device" /* qr */)[0];
+  }
+  /**
+   * Get QR hardware keyring. If it doesn't exist, add it.
+   *
+   * @returns The added keyring
+   */
+  async getOrAddQRKeyring() {
+    return this.getQRKeyring() || await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _addQRKeyring, addQRKeyring_fn).call(this);
+  }
+  // TODO: Replace `any` with type
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async restoreQRKeyring(serialized) {
+    (await this.getOrAddQRKeyring()).deserialize(serialized);
+    await this.persistAllKeyrings();
+  }
+  async resetQRKeyringState() {
+    (await this.getOrAddQRKeyring()).resetStore();
+  }
+  async getQRKeyringState() {
+    return (await this.getOrAddQRKeyring()).getMemStore();
+  }
+  async submitQRCryptoHDKey(cryptoHDKey) {
+    (await this.getOrAddQRKeyring()).submitCryptoHDKey(cryptoHDKey);
+  }
+  async submitQRCryptoAccount(cryptoAccount) {
+    (await this.getOrAddQRKeyring()).submitCryptoAccount(cryptoAccount);
+  }
+  async submitQRSignature(requestId, ethSignature) {
+    (await this.getOrAddQRKeyring()).submitSignature(requestId, ethSignature);
+  }
+  async cancelQRSignRequest() {
+    (await this.getOrAddQRKeyring()).cancelSignRequest();
+  }
+  /**
+   * Cancels qr keyring sync.
+   */
+  async cancelQRSynchronization() {
+    (await this.getOrAddQRKeyring()).cancelSync();
+  }
+  async connectQRHardware(page) {
+    try {
+      const keyring = await this.getOrAddQRKeyring();
+      let accounts;
+      switch (page) {
+        case -1:
+          accounts = await keyring.getPreviousPage();
+          break;
+        case 1:
+          accounts = await keyring.getNextPage();
+          break;
+        default:
+          accounts = await keyring.getFirstPage();
+      }
+      return accounts.map((account) => {
+        return {
+          ...account,
+          balance: "0x0"
+        };
+      });
+    } catch (e) {
+      throw new Error(`Unspecified error when connect QR Hardware, ${e}`);
+    }
+  }
+  async unlockQRHardwareWalletAccount(index) {
+    const keyring = await this.getOrAddQRKeyring();
+    keyring.setAccountToUnlock(index);
+    await this.addNewAccountForKeyring(keyring);
+    await this.persistAllKeyrings();
+  }
+  async getAccountKeyringType(account) {
+    const keyring = await this.getKeyringForAccount(
+      account
+    );
+    return keyring.type;
+  }
+  async forgetQRDevice() {
+    const keyring = await this.getOrAddQRKeyring();
+    const allAccounts = await this.getAccounts();
+    keyring.forgetDevice();
+    const remainingAccounts = await this.getAccounts();
+    const removedAccounts = allAccounts.filter(
+      (address) => !remainingAccounts.includes(address)
+    );
+    await this.persistAllKeyrings();
+    return { removedAccounts, remainingAccounts };
+  }
+};
+_keyringBuilders = new WeakMap();
+_keyrings = new WeakMap();
+_unsupportedKeyrings = new WeakMap();
+_password = new WeakMap();
+_encryptor = new WeakMap();
+_cacheEncryptionKey = new WeakMap();
+_qrKeyringStateListener = new WeakMap();
+_registerMessageHandlers = new WeakSet();
+registerMessageHandlers_fn = function() {
+  this.messagingSystem.registerActionHandler(
+    `${name}:signMessage`,
+    this.signMessage.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    `${name}:signPersonalMessage`,
+    this.signPersonalMessage.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    `${name}:signTypedMessage`,
+    this.signTypedMessage.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    `${name}:decryptMessage`,
+    this.decryptMessage.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    `${name}:getEncryptionPublicKey`,
+    this.getEncryptionPublicKey.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    `${name}:getAccounts`,
+    this.getAccounts.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    `${name}:getKeyringsByType`,
+    this.getKeyringsByType.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    `${name}:getKeyringForAccount`,
+    this.getKeyringForAccount.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    `${name}:persistAllKeyrings`,
+    this.persistAllKeyrings.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    `${name}:prepareUserOperation`,
+    this.prepareUserOperation.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    `${name}:patchUserOperation`,
+    this.patchUserOperation.bind(this)
+  );
+  this.messagingSystem.registerActionHandler(
+    `${name}:signUserOperation`,
+    this.signUserOperation.bind(this)
+  );
+};
+_getKeyringBuilderForType = new WeakSet();
+getKeyringBuilderForType_fn = function(type) {
+  return _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _keyringBuilders).find(
+    (keyringBuilder) => keyringBuilder.type === type
+  );
+};
+_addQRKeyring = new WeakSet();
+addQRKeyring_fn = async function() {
+  const qrKeyring = await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _newKeyring, newKeyring_fn).call(this, "QR Hardware Wallet Device" /* qr */, {
+    accounts: []
+  });
+  const accounts = await qrKeyring.getAccounts();
+  await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _checkForDuplicate, checkForDuplicate_fn).call(this, "QR Hardware Wallet Device" /* qr */, accounts);
+  _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _keyrings).push(qrKeyring);
+  await this.persistAllKeyrings();
+  _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _subscribeToQRKeyringEvents, subscribeToQRKeyringEvents_fn).call(this, qrKeyring);
+  return qrKeyring;
+};
+_subscribeToQRKeyringEvents = new WeakSet();
+subscribeToQRKeyringEvents_fn = function(qrKeyring) {
+  _chunkCHLPTPMZjs.__privateSet.call(void 0, this, _qrKeyringStateListener, (state) => {
+    this.messagingSystem.publish(`${name}:qrKeyringStateChange`, state);
+  });
+  qrKeyring.getMemStore().subscribe(_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _qrKeyringStateListener));
+};
+_unsubscribeFromQRKeyringsEvents = new WeakSet();
+unsubscribeFromQRKeyringsEvents_fn = function() {
+  const qrKeyrings = this.getKeyringsByType(
+    "QR Hardware Wallet Device" /* qr */
+  );
+  qrKeyrings.forEach((qrKeyring) => {
+    if (_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _qrKeyringStateListener)) {
+      qrKeyring.getMemStore().unsubscribe(_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _qrKeyringStateListener));
+    }
+  });
+};
+_createNewVaultWithKeyring = new WeakSet();
+createNewVaultWithKeyring_fn = async function(password, keyring) {
+  if (typeof password !== "string") {
+    throw new TypeError("KeyringController - Password must be of type string." /* WrongPasswordType */);
+  }
+  _chunkCHLPTPMZjs.__privateSet.call(void 0, this, _password, password);
+  await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _clearKeyrings, clearKeyrings_fn).call(this);
+  await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _createKeyringWithFirstAccount, createKeyringWithFirstAccount_fn).call(this, keyring.type, keyring.opts);
+  _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _setUnlocked, setUnlocked_fn).call(this);
+  return _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _getMemState, getMemState_fn).call(this);
+};
+_updateKeyringsInState = new WeakSet();
+updateKeyringsInState_fn = async function() {
+  const keyrings = await Promise.all(_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _keyrings).map(displayForKeyring));
+  this.update((state) => {
+    state.keyrings = keyrings;
+  });
+};
+_unlockKeyrings = new WeakSet();
+unlockKeyrings_fn = async function(password, encryptionKey, encryptionSalt) {
+  const encryptedVault = this.state.vault;
+  if (!encryptedVault) {
+    throw new Error("KeyringController - Cannot unlock without a previous vault." /* VaultError */);
+  }
+  await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _clearKeyrings, clearKeyrings_fn).call(this);
+  let vault;
+  if (_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _cacheEncryptionKey)) {
+    assertIsExportableKeyEncryptor(_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _encryptor));
+    if (password) {
+      const result = await _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _encryptor).decryptWithDetail(
+        password,
+        encryptedVault
+      );
+      vault = result.vault;
+      _chunkCHLPTPMZjs.__privateSet.call(void 0, this, _password, password);
+      this.update((state) => {
+        state.encryptionKey = result.exportedKeyString;
+        state.encryptionSalt = result.salt;
+      });
+    } else {
+      const parsedEncryptedVault = JSON.parse(encryptedVault);
+      if (encryptionSalt !== parsedEncryptedVault.salt) {
+        throw new Error("KeyringController - Encryption key and salt provided are expired" /* ExpiredCredentials */);
+      }
+      if (typeof encryptionKey !== "string") {
+        throw new TypeError("KeyringController - Password must be of type string." /* WrongPasswordType */);
+      }
+      const key = await _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _encryptor).importKey(encryptionKey);
+      vault = await _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _encryptor).decryptWithKey(key, parsedEncryptedVault);
+      this.update((state) => {
+        state.encryptionKey = encryptionKey;
+        state.encryptionSalt = encryptionSalt;
+      });
+    }
+  } else {
+    if (typeof password !== "string") {
+      throw new TypeError("KeyringController - Password must be of type string." /* WrongPasswordType */);
+    }
+    vault = await _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _encryptor).decrypt(password, encryptedVault);
+    _chunkCHLPTPMZjs.__privateSet.call(void 0, this, _password, password);
+  }
+  if (!isSerializedKeyringsArray(vault)) {
+    throw new Error("KeyringController - The decrypted vault has an unexpected shape." /* VaultDataError */);
+  }
+  await Promise.all(vault.map(_chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _restoreKeyring, restoreKeyring_fn).bind(this)));
+  await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _updateKeyringsInState, updateKeyringsInState_fn).call(this);
+  if (_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _password) && (!_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _cacheEncryptionKey) || !encryptionKey) && _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _encryptor).isVaultUpdated && !_chunkCHLPTPMZjs.__privateGet.call(void 0, this, _encryptor).isVaultUpdated(encryptedVault)) {
+    await this.persistAllKeyrings();
+  }
+  return _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _keyrings);
+};
+_createKeyringWithFirstAccount = new WeakSet();
+createKeyringWithFirstAccount_fn = async function(type, opts) {
+  const keyring = await this.addNewKeyring(type, opts);
+  const [firstAccount] = await keyring.getAccounts();
+  if (!firstAccount) {
+    throw new Error("KeyringController - First Account not found." /* NoFirstAccount */);
+  }
+};
+_newKeyring = new WeakSet();
+newKeyring_fn = async function(type, data) {
+  const keyringBuilder = _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _getKeyringBuilderForType, getKeyringBuilderForType_fn).call(this, type);
+  if (!keyringBuilder) {
+    throw new Error(
+      `${"KeyringController - No keyringBuilder found for keyring" /* NoKeyringBuilder */}. Keyring type: ${type}`
+    );
+  }
+  const keyring = keyringBuilder();
+  await keyring.deserialize(data);
+  if (keyring.init) {
+    await keyring.init();
+  }
+  return keyring;
+};
+_clearKeyrings = new WeakSet();
+clearKeyrings_fn = async function() {
+  for (const keyring of _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _keyrings)) {
+    await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _destroyKeyring, destroyKeyring_fn).call(this, keyring);
+  }
+  _chunkCHLPTPMZjs.__privateSet.call(void 0, this, _keyrings, []);
+  this.update((state) => {
+    state.keyrings = [];
+  });
+};
+_restoreKeyring = new WeakSet();
+restoreKeyring_fn = async function(serialized) {
+  try {
+    const { type, data } = serialized;
+    const keyring = await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _newKeyring, newKeyring_fn).call(this, type, data);
+    await keyring.getAccounts();
+    _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _keyrings).push(keyring);
+    return keyring;
+  } catch (_) {
+    _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _unsupportedKeyrings).push(serialized);
+    return void 0;
+  }
+};
+_destroyKeyring = new WeakSet();
+destroyKeyring_fn = async function(keyring) {
+  await keyring.destroy?.();
+};
+_removeEmptyKeyrings = new WeakSet();
+removeEmptyKeyrings_fn = async function() {
+  const validKeyrings = [];
+  await Promise.all(
+    _chunkCHLPTPMZjs.__privateGet.call(void 0, this, _keyrings).map(async (keyring) => {
+      const accounts = await keyring.getAccounts();
+      if (accounts.length > 0) {
+        validKeyrings.push(keyring);
+      } else {
+        await _chunkCHLPTPMZjs.__privateMethod.call(void 0, this, _destroyKeyring, destroyKeyring_fn).call(this, keyring);
+      }
+    })
+  );
+  _chunkCHLPTPMZjs.__privateSet.call(void 0, this, _keyrings, validKeyrings);
+};
+_checkForDuplicate = new WeakSet();
+checkForDuplicate_fn = async function(type, newAccountArray) {
+  const accounts = await this.getAccounts();
+  switch (type) {
+    case "Simple Key Pair" /* simple */: {
+      const isIncluded = Boolean(
+        accounts.find(
+          (key) => newAccountArray[0] && (key === newAccountArray[0] || key === _utils.remove0x.call(void 0, newAccountArray[0]))
+        )
+      );
+      if (isIncluded) {
+        throw new Error("KeyringController - The account you are trying to import is a duplicate" /* DuplicatedAccount */);
+      }
+      return newAccountArray;
+    }
+    default: {
+      return newAccountArray;
+    }
+  }
+};
+_setUnlocked = new WeakSet();
+setUnlocked_fn = function() {
+  this.update((state) => {
+    state.isUnlocked = true;
+  });
+  this.messagingSystem.publish(`${name}:unlock`);
+};
+_getMemState = new WeakSet();
+getMemState_fn = function() {
+  return {
+    isUnlocked: this.state.isUnlocked,
+    keyrings: this.state.keyrings
+  };
+};
+var KeyringController_default = KeyringController;
+
+
+
+
+
+
+
+
+
+
+exports.KeyringTypes = KeyringTypes; exports.isCustodyKeyring = isCustodyKeyring; exports.AccountImportStrategy = AccountImportStrategy; exports.SignTypedDataVersion = SignTypedDataVersion; exports.keyringBuilderFactory = keyringBuilderFactory; exports.getDefaultKeyringState = getDefaultKeyringState; exports.KeyringController = KeyringController; exports.KeyringController_default = KeyringController_default;
+//# sourceMappingURL=chunk-BVSGYW4D.js.map