@metamask-previews/keyring-controller 27.1.1-preview-4f4c98e → 27.1.1-preview-eb263b0ee

package/dist/KeyringController.cjs

@@ -0,0 +1,2018 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _KeyringController_instances, _KeyringController_controllerOperationMutex, _KeyringController_vaultOperationMutex, _KeyringController_keyringBuilders, _KeyringController_keyringV2Builders, _KeyringController_encryptor, _KeyringController_keyrings, _KeyringController_unsupportedKeyrings, _KeyringController_encryptionKey, _KeyringController_verifyEncryptionKey, _KeyringController_verifyCredentials, _KeyringController_getKeyringForAccount, _KeyringController_getKeyringEntryForAccount, _KeyringController_findKeyringIndexForAccount, _KeyringController_getKeyringEntriesByType, _KeyringController_assertNoUnsafeDirectKeyringAccess, _KeyringController_registerMessageHandlers, _KeyringController_selectKeyringEntry, _KeyringController_getKeyringById, _KeyringController_getKeyringEntryById, _KeyringController_getKeyringByIdOrDefault, _KeyringController_getKeyringMetadata, _KeyringController_getKeyringBuilderForType, _KeyringController_getKeyringV2BuilderForType, _KeyringController_createNewVaultWithKeyring, _KeyringController_deriveAndSetEncryptionKey, _KeyringController_setEncryptionKey, _KeyringController_verifySeedPhrase, _KeyringController_getUpdatedKeyrings, _KeyringController_getSerializedKeyrings, _KeyringController_getSessionState, _KeyringController_restoreSerializedKeyrings, _KeyringController_unlockKeyrings, _KeyringController_updateVault, _KeyringController_isNewEncryptionAvailable, _KeyringController_getAccountsFromKeyrings, _KeyringController_createKeyringWithFirstAccount, _KeyringController_newKeyring, _KeyringController_createKeyring, _KeyringController_cleanUpEmptiedKeyringsAfter, _KeyringController_clearKeyrings, _KeyringController_restoreKeyring, _KeyringController_destroyKeyring, _KeyringController_assertNoDuplicateAccounts, _KeyringController_setUnlocked, _KeyringController_assertIsUnlocked, _KeyringController_persistOrRollback, _KeyringController_withRollback, _KeyringController_assertControllerMutexIsLocked, _KeyringController_isPrimaryKeyring, _KeyringController_assertNotRemovingPrimaryKeyring, _KeyringController_withControllerLock, _KeyringController_withVaultLock;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyringController = exports.getDefaultKeyringState = exports.keyringBuilderFactory = exports.SignTypedDataVersion = exports.AccountImportStrategy = exports.isCustodyKeyring = exports.KeyringTypes = void 0;
+const util_1 = require("@ethereumjs/util");
+const base_controller_1 = require("@metamask/base-controller");
+const eth_hd_keyring_1 = require("@metamask/eth-hd-keyring");
+const v2_1 = require("@metamask/eth-hd-keyring/v2");
+const eth_sig_util_1 = require("@metamask/eth-sig-util");
+const eth_simple_keyring_1 = __importDefault(require("@metamask/eth-simple-keyring"));
+const v2_2 = require("@metamask/eth-simple-keyring/v2");
+const utils_1 = require("@metamask/utils");
+const async_mutex_1 = require("async-mutex");
+const ethereumjs_wallet_1 = __importStar(require("ethereumjs-wallet"));
+const lodash_1 = require("lodash");
+// When generating a ULID within the same millisecond, monotonicFactory provides some guarantees regarding sort order.
+const ulid_1 = require("ulid");
+const constants_js_1 = require("./constants.cjs");
+const errors_js_1 = require("./errors.cjs");
+const name = 'KeyringController';
+const MESSENGER_EXPOSED_METHODS = [
+    'signMessage',
+    'signEip7702Authorization',
+    'signPersonalMessage',
+    'signTransaction',
+    'signTypedMessage',
+    'decryptMessage',
+    'getEncryptionPublicKey',
+    'getAccounts',
+    'getKeyringsByType',
+    'getKeyringForAccount',
+    'persistAllKeyrings',
+    'prepareUserOperation',
+    'patchUserOperation',
+    'signUserOperation',
+    'addNewAccount',
+    'withController',
+    'withKeyring',
+    'withKeyringUnsafe',
+    'withKeyringV2',
+    'withKeyringV2Unsafe',
+    'addNewKeyring',
+    'createNewVaultAndKeychain',
+    'createNewVaultAndRestore',
+    'removeAccount',
+    'isUnlocked',
+    'exportSeedPhrase',
+    'changePassword',
+    'exportAccount',
+    'exportEncryptionKey',
+    'getAccountKeyringType',
+    'importAccountWithStrategy',
+    'setLocked',
+    'submitEncryptionKey',
+    'submitPassword',
+    'verifyPassword',
+];
+/**
+ * Available keyring types
+ *
+ * @deprecated Use `KeyringType` from `@metamask/keyring-api/v2` instead. This enum will be removed
+ * in a future release once V2 is fully adopted. Only use it if the keyring you are trying to access
+ * has no V2 builder available yet.
+ */
+var KeyringTypes;
+(function (KeyringTypes) {
+    // Changing this would be a breaking change, and not worth the effort at this
+    // time, so we disable the linting rule for this block.
+    /* eslint-disable @typescript-eslint/naming-convention */
+    KeyringTypes["simple"] = "Simple Key Pair";
+    KeyringTypes["hd"] = "HD Key Tree";
+    KeyringTypes["qr"] = "QR Hardware Wallet Device";
+    KeyringTypes["trezor"] = "Trezor Hardware";
+    KeyringTypes["oneKey"] = "OneKey Hardware";
+    KeyringTypes["ledger"] = "Ledger Hardware";
+    KeyringTypes["lattice"] = "Lattice Hardware";
+    KeyringTypes["snap"] = "Snap Keyring";
+    KeyringTypes["money"] = "Money Keyring";
+    /* eslint-enable @typescript-eslint/naming-convention */
+})(KeyringTypes || (exports.KeyringTypes = KeyringTypes = {}));
+/**
+ * Custody keyring types are a special case, as they are not a single type
+ * but they all start with the prefix "Custody".
+ *
+ * @param keyringType - The type of the keyring.
+ * @returns Whether the keyring type is a custody keyring.
+ */
+const isCustodyKeyring = (keyringType) => {
+    return keyringType.startsWith('Custody');
+};
+exports.isCustodyKeyring = isCustodyKeyring;
+/**
+ * A strategy for importing an account
+ */
+var AccountImportStrategy;
+(function (AccountImportStrategy) {
+    // Changing this would be a breaking change, and not worth the effort at this
+    // time, so we disable the linting rule for this block.
+    /* eslint-disable @typescript-eslint/naming-convention */
+    AccountImportStrategy["privateKey"] = "privateKey";
+    AccountImportStrategy["json"] = "json";
+    /* eslint-enable @typescript-eslint/naming-convention */
+})(AccountImportStrategy || (exports.AccountImportStrategy = AccountImportStrategy = {}));
+/**
+ * The `signTypedMessage` version
+ *
+ * @see https://docs.metamask.io/guide/signing-data.html
+ */
+var SignTypedDataVersion;
+(function (SignTypedDataVersion) {
+    SignTypedDataVersion["V1"] = "V1";
+    SignTypedDataVersion["V3"] = "V3";
+    SignTypedDataVersion["V4"] = "V4";
+})(SignTypedDataVersion || (exports.SignTypedDataVersion = SignTypedDataVersion = {}));
+/**
+ * Get builder function for `Keyring`
+ *
+ * Returns a builder function for `Keyring` with a `type` property.
+ *
+ * @param KeyringConstructor - The Keyring class for the builder.
+ * @returns A builder function for the given Keyring.
+ */
+function keyringBuilderFactory(KeyringConstructor) {
+    const builder = () => new KeyringConstructor();
+    builder.type = KeyringConstructor.type;
+    return builder;
+}
+exports.keyringBuilderFactory = keyringBuilderFactory;
+const defaultKeyringBuilders = [
+    // todo: keyring types are mismatched, this should be fixed in they keyrings themselves
+    // @ts-expect-error keyring types are mismatched
+    keyringBuilderFactory(eth_simple_keyring_1.default),
+    keyringBuilderFactory(eth_hd_keyring_1.HdKeyring),
+];
+const hdKeyringV2Builder = Object.assign((keyring, metadata) => new v2_1.HdKeyring({
+    legacyKeyring: keyring,
+    entropySource: metadata.id,
+}), { type: KeyringTypes.hd });
+const simpleKeyringV2Builder = Object.assign((keyring) => new v2_2.SimpleKeyring({
+    legacyKeyring: keyring,
+}), { type: KeyringTypes.simple });
+const defaultKeyringV2Builders = [
+    simpleKeyringV2Builder,
+    hdKeyringV2Builder,
+];
+const getDefaultKeyringState = () => {
+    return {
+        isUnlocked: false,
+        keyrings: [],
+    };
+};
+exports.getDefaultKeyringState = getDefaultKeyringState;
+/**
+ * Assert that the given keyring has an exportable
+ * mnemonic.
+ *
+ * @param keyring - The keyring to check
+ * @throws When the keyring does not have a mnemonic
+ */
+function assertHasUint8ArrayMnemonic(keyring) {
+    if (!((0, utils_1.hasProperty)(keyring, 'mnemonic') && keyring.mnemonic instanceof Uint8Array)) {
+        throw new errors_js_1.KeyringControllerError("Can't get mnemonic bytes from keyring");
+    }
+}
+/**
+ * Assert that the provided password is a valid non-empty string.
+ *
+ * @param password - The password to check.
+ * @throws If the password is not a valid string.
+ */
+function assertIsValidPassword(password) {
+    if (typeof password !== 'string') {
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.WrongPasswordType);
+    }
+    if (!password?.length) {
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.InvalidEmptyPassword);
+    }
+}
+/**
+ * Assert that the provided encryption key is a valid non-empty string.
+ *
+ * @param encryptionKey - The encryption key to check.
+ * @throws If the encryption key is not a valid string.
+ */
+function assertIsEncryptionKeySet(encryptionKey) {
+    if (!encryptionKey) {
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.EncryptionKeyNotSet);
+    }
+}
+/**
+ * Checks if the provided value is a serialized keyrings array.
+ *
+ * @param array - The value to check.
+ * @returns True if the value is a serialized keyrings array.
+ */
+function isSerializedKeyringsArray(array) {
+    return (typeof array === 'object' &&
+        Array.isArray(array) &&
+        array.every((value) => value.type && (0, utils_1.isValidJson)(value.data)));
+}
+/**
+ * Display For Keyring
+ *
+ * Is used for adding the current keyrings to the state object.
+ *
+ * @param keyringWithMetadata - The keyring and its metadata.
+ * @param keyringWithMetadata.keyring - The keyring to display.
+ * @param keyringWithMetadata.metadata - The metadata of the keyring.
+ * @returns A keyring display object, with type and accounts properties.
+ */
+async function displayForKeyring({ keyring, metadata, }) {
+    const accounts = await keyring.getAccounts();
+    return {
+        type: keyring.type,
+        // Cast to `string[]` here is safe here because `accounts` has no nullish
+        // values, and `normalize` returns `string` unless given a nullish value
+        accounts: accounts.map(normalize),
+        metadata,
+    };
+}
+/**
+ * Check if address is an ethereum address
+ *
+ * @param address - An address.
+ * @returns Returns true if the address is an ethereum one, false otherwise.
+ */
+function isEthAddress(address) {
+    // We first check if it's a matching `Hex` string, so that is narrows down
+    // `address` as an `Hex` type, allowing us to use `isValidHexAddress`
+    return (
+    // NOTE: This function only checks for lowercased strings
+    (0, utils_1.isStrictHexString)(address.toLowerCase()) &&
+        // This checks for lowercased addresses and checksum addresses too
+        (0, utils_1.isValidHexAddress)(address));
+}
+/**
+ * Normalize ethereum or non-EVM address.
+ *
+ * @param address - Ethereum or non-EVM address.
+ * @returns The normalized address.
+ */
+function normalize(address) {
+    // Since the `KeyringController` is only dealing with address, we have
+    // no other way to get the associated account type with this address. So we
+    // are down to check the actual address format for now
+    // TODO: Find a better way to not have those runtime checks based on the
+    //       address value!
+    return isEthAddress(address) ? (0, eth_sig_util_1.normalize)(address) : address;
+}
+/**
+ * Controller responsible for establishing and managing user identity.
+ *
+ * This class is a wrapper around the `eth-keyring-controller` package. The
+ * `eth-keyring-controller` manages the "vault", which is an encrypted store of private keys, and
+ * it manages the wallet "lock" state. This wrapper class has convenience methods for interacting
+ * with the internal keyring controller and handling certain complex operations that involve the
+ * keyrings.
+ */
+class KeyringController extends base_controller_1.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 messenger.
+     * @param options.state - Initial state to set on this controller.
+     */
+    constructor(options) {
+        const { encryptor, keyringBuilders, keyringV2Builders, messenger, state } = options;
+        super({
+            name,
+            metadata: {
+                vault: {
+                    includeInStateLogs: false,
+                    persist: true,
+                    includeInDebugSnapshot: false,
+                    usedInUi: false,
+                },
+                isUnlocked: {
+                    includeInStateLogs: true,
+                    persist: false,
+                    includeInDebugSnapshot: true,
+                    usedInUi: true,
+                },
+                keyrings: {
+                    includeInStateLogs: true,
+                    persist: false,
+                    includeInDebugSnapshot: false,
+                    usedInUi: true,
+                },
+                encryptionKey: {
+                    includeInStateLogs: false,
+                    persist: false,
+                    includeInDebugSnapshot: false,
+                    usedInUi: false,
+                },
+                encryptionSalt: {
+                    includeInStateLogs: false,
+                    persist: false,
+                    includeInDebugSnapshot: false,
+                    usedInUi: false,
+                },
+            },
+            messenger,
+            state: {
+                ...(0, exports.getDefaultKeyringState)(),
+                ...state,
+            },
+        });
+        _KeyringController_instances.add(this);
+        _KeyringController_controllerOperationMutex.set(this, new async_mutex_1.Mutex());
+        _KeyringController_vaultOperationMutex.set(this, new async_mutex_1.Mutex());
+        _KeyringController_keyringBuilders.set(this, void 0);
+        _KeyringController_keyringV2Builders.set(this, void 0);
+        _KeyringController_encryptor.set(this, void 0);
+        _KeyringController_keyrings.set(this, void 0);
+        _KeyringController_unsupportedKeyrings.set(this, void 0);
+        _KeyringController_encryptionKey.set(this, void 0);
+        __classPrivateFieldSet(this, _KeyringController_keyringBuilders, keyringBuilders
+            ? keyringBuilders.concat(defaultKeyringBuilders)
+            : defaultKeyringBuilders, "f");
+        __classPrivateFieldSet(this, _KeyringController_keyringV2Builders, keyringV2Builders
+            ? keyringV2Builders.concat(defaultKeyringV2Builders)
+            : defaultKeyringV2Builders, "f");
+        __classPrivateFieldSet(this, _KeyringController_encryptor, encryptor, "f");
+        __classPrivateFieldSet(this, _KeyringController_keyrings, [], "f");
+        __classPrivateFieldSet(this, _KeyringController_unsupportedKeyrings, [], "f");
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_registerMessageHandlers).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 the added account address.
+     */
+    async addNewAccount(accountCount) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
+            const primaryKeyring = this.getKeyringsByType('HD Key Tree')[0];
+            if (!primaryKeyring) {
+                throw new errors_js_1.KeyringControllerError('No HD keyring found');
+            }
+            const oldAccounts = await primaryKeyring.getAccounts();
+            if (accountCount && oldAccounts.length !== accountCount) {
+                if (accountCount > oldAccounts.length) {
+                    throw new errors_js_1.KeyringControllerError('Account out of sequence');
+                }
+                // we return the account already existing at index `accountCount`
+                const existingAccount = oldAccounts[accountCount];
+                if (!existingAccount) {
+                    throw new errors_js_1.KeyringControllerError(`Can't find account at index ${accountCount}`);
+                }
+                return existingAccount;
+            }
+            const [addedAccountAddress] = await primaryKeyring.addAccounts(1);
+            await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_verifySeedPhrase).call(this);
+            return 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 the added account address
+     */
+    async addNewAccountForKeyring(keyring, accountCount) {
+        // READ THIS CAREFULLY:
+        // We still uses `Hex` here, since we are not using this method when creating
+        // and account using a "Snap Keyring". This function assume the `keyring` is
+        // ethereum compatible, but "Snap Keyring" might not be.
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
+            const oldAccounts = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getAccountsFromKeyrings).call(this);
+            if (accountCount && oldAccounts.length !== accountCount) {
+                if (accountCount > oldAccounts.length) {
+                    throw new errors_js_1.KeyringControllerError('Account out of sequence');
+                }
+                const existingAccount = oldAccounts[accountCount];
+                (0, utils_1.assertIsStrictHexString)(existingAccount);
+                return existingAccount;
+            }
+            await keyring.addAccounts(1);
+            const addedAccountAddress = (await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getAccountsFromKeyrings).call(this)).find((selectedAddress) => !oldAccounts.includes(selectedAddress));
+            (0, utils_1.assertIsStrictHexString)(addedAccountAddress);
+            return addedAccountAddress;
+        });
+    }
+    /**
+     * 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 when the operation ends successfully.
+     */
+    async createNewVaultAndRestore(password, seed) {
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
+            assertIsValidPassword(password);
+            await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_createNewVaultWithKeyring).call(this, password, {
+                type: KeyringTypes.hd,
+                opts: {
+                    mnemonic: seed,
+                    numberOfAccounts: 1,
+                },
+            });
+        });
+    }
+    /**
+     * Create a new vault and primary keyring.
+     *
+     * This only works if keyrings are empty. If there is a pre-existing unlocked vault, calling this will have no effect.
+     * If there is a pre-existing locked vault, it will be replaced.
+     *
+     * @param password - Password to unlock the new vault.
+     * @returns Promise resolving when the operation ends successfully.
+     */
+    async createNewVaultAndKeychain(password) {
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
+            const accounts = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getAccountsFromKeyrings).call(this);
+            if (!accounts.length) {
+                await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_createNewVaultWithKeyring).call(this, password, {
+                    type: KeyringTypes.hd,
+                });
+            }
+        });
+    }
+    /**
+     * 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 new keyring metadata.
+     */
+    async addNewKeyring(type, opts) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringMetadata).call(this, await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_newKeyring).call(this, type, opts)));
+    }
+    /**
+     * 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 errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.VaultError);
+        }
+        await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").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 credentials - Object holding either the `password` or the vault
+     * `encryptionKey`.
+     * @param keyringId - The id of the keyring.
+     * @returns Promise resolving to the seed phrase.
+     */
+    async exportSeedPhrase(credentials, keyringId) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_verifyCredentials).call(this, credentials);
+        const selectedKeyring = __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringByIdOrDefault).call(this, keyringId);
+        if (!selectedKeyring) {
+            throw new errors_js_1.KeyringControllerError('Keyring not found');
+        }
+        assertHasUint8ArrayMnemonic(selectedKeyring);
+        return selectedKeyring.mnemonic;
+    }
+    /**
+     * Gets the private key from the keyring controlling an address.
+     *
+     * @param credentials - Object holding either the `password` or the vault
+     * `encryptionKey`.
+     * @param address - Address to export.
+     * @returns Promise resolving to the private key for an address.
+     */
+    async exportAccount(credentials, address) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_verifyCredentials).call(this, credentials);
+        const keyring = (await this.getKeyringForAccount(address));
+        if (!keyring.exportAccount) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.UnsupportedExportAccount);
+        }
+        return await keyring.exportAccount(normalize(address));
+    }
+    /**
+     * Returns the public addresses of all accounts from every keyring.
+     *
+     * @returns A promise resolving to an array of addresses.
+     */
+    async getAccounts() {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        return this.state.keyrings.reduce((accounts, keyring) => accounts.concat(keyring.accounts), []);
+    }
+    /**
+     * 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) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        const address = (0, eth_sig_util_1.normalize)(account);
+        const keyring = (await this.getKeyringForAccount(account));
+        if (!keyring.getEncryptionPublicKey) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.UnsupportedGetEncryptionPublicKey);
+        }
+        return await keyring.getEncryptionPublicKey(address, 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) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        const address = (0, eth_sig_util_1.normalize)(messageParams.from);
+        const keyring = (await this.getKeyringForAccount(address));
+        if (!keyring.decryptMessage) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.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. Use `withKeyring` instead.
+     * @param account - An account address.
+     * @returns Promise resolving to keyring of the `account` if one exists.
+     */
+    async getKeyringForAccount(account) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        const keyring = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringForAccount).call(this, account);
+        if (keyring) {
+            return keyring;
+        }
+        if (__classPrivateFieldGet(this, _KeyringController_keyrings, "f").length === 0) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.NoKeyring);
+        }
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.KeyringNotFound);
+    }
+    /**
+     * 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. Use `withKeyring` instead.
+     * @param type - Keyring type name.
+     * @returns An array of keyrings of the given type.
+     */
+    getKeyringsByType(type) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringEntriesByType).call(this, { v2: false, type }).map(({ keyring }) => keyring);
+    }
+    /**
+     * Persist all serialized keyrings in the vault.
+     *
+     * @deprecated This method is being phased out in favor of `withKeyring`.
+     * @returns Promise resolving with `true` value when the
+     * operation completes.
+     */
+    async persistAllKeyrings() {
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withRollback).call(this, async () => {
+            __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+            await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_updateVault).call(this);
+            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 the imported account address.
+     */
+    async importAccountWithStrategy(strategy, 
+    // TODO: Replace `any` with type
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    args) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
+            let privateKey;
+            switch (strategy) {
+                case AccountImportStrategy.privateKey: {
+                    const [importedKey] = args;
+                    if (!importedKey) {
+                        throw new errors_js_1.KeyringControllerError('Cannot import an empty key.');
+                    }
+                    const prefixed = (0, utils_1.add0x)(importedKey);
+                    let bufferedPrivateKey;
+                    try {
+                        bufferedPrivateKey = (0, utils_1.hexToBytes)(prefixed);
+                    }
+                    catch {
+                        throw new errors_js_1.KeyringControllerError('Cannot import invalid private key.');
+                    }
+                    if (!(0, util_1.isValidPrivate)(bufferedPrivateKey) ||
+                        // ensures that the key is 64 bytes long
+                        (0, util_1.getBinarySize)(prefixed) !== 64 + '0x'.length) {
+                        throw new errors_js_1.KeyringControllerError('Cannot import invalid private key.');
+                    }
+                    privateKey = (0, utils_1.remove0x)(prefixed);
+                    break;
+                }
+                case AccountImportStrategy.json: {
+                    let wallet;
+                    const [input, password] = args;
+                    try {
+                        wallet = ethereumjs_wallet_1.thirdparty.fromEtherWallet(input, password);
+                    }
+                    catch {
+                        wallet = wallet ?? (await ethereumjs_wallet_1.default.fromV3(input, password, true));
+                    }
+                    privateKey = (0, utils_1.bytesToHex)(new Uint8Array(wallet.getPrivateKey()));
+                    break;
+                }
+                default:
+                    throw new errors_js_1.KeyringControllerError(`Unexpected import strategy: '${String(strategy)}'`);
+            }
+            const newKeyring = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_newKeyring).call(this, KeyringTypes.simple, [
+                privateKey,
+            ]);
+            const accounts = await newKeyring.getAccounts();
+            return accounts[0];
+        });
+    }
+    /**
+     * Removes an account from keyring state.
+     *
+     * @param address - Address of the account to remove.
+     * @fires KeyringController:accountRemoved
+     * @returns Promise resolving when the account is removed.
+     */
+    async removeAccount(address) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
+            const keyringIndex = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_findKeyringIndexForAccount).call(this, address);
+            if (keyringIndex === -1) {
+                throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.NoKeyring);
+            }
+            const { keyring, keyringV2 } = __classPrivateFieldGet(this, _KeyringController_keyrings, "f")[keyringIndex];
+            const isPrimaryKeyring = keyringIndex === 0;
+            const shouldRemoveKeyring = (await keyring.getAccounts()).length === 1;
+            // Primary keyring should never be removed, so we need to keep at least one account in it
+            if (isPrimaryKeyring && shouldRemoveKeyring) {
+                throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.LastAccountInPrimaryKeyring);
+            }
+            // Not all the keyrings support this, so we have to check
+            if (!keyring.removeAccount) {
+                throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.UnsupportedRemoveAccount);
+            }
+            // FIXME #1: We do cast to `Hex` to make the type checker happy here, and
+            // because `Keyring<State>.removeAccount` requires address to be `Hex`.
+            // Those types would need to be updated for a full non-EVM support.
+            //
+            // FIXME #2: The `removeAccount` method of snaps keyring is async. We have
+            // to update the interface of the other keyrings to be async as well.
+            // eslint-disable-next-line @typescript-eslint/await-thenable
+            await keyring.removeAccount(address);
+            if (shouldRemoveKeyring) {
+                __classPrivateFieldGet(this, _KeyringController_keyrings, "f").splice(keyringIndex, 1);
+                await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_destroyKeyring).call(this, keyring, keyringV2);
+            }
+        });
+        this.messenger.publish(`${name}:accountRemoved`, address);
+    }
+    /**
+     * Deallocates all secrets and locks the wallet.
+     *
+     * @returns Promise resolving when the operation completes.
+     */
+    async setLocked() {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withRollback).call(this, async () => {
+            __classPrivateFieldSet(this, _KeyringController_encryptionKey, undefined, "f");
+            await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_clearKeyrings).call(this);
+            this.update((state) => {
+                state.isUnlocked = false;
+                state.keyrings = [];
+                delete state.encryptionKey;
+                delete state.encryptionSalt;
+            });
+            this.messenger.publish(`${name}:lock`);
+        });
+    }
+    /**
+     * 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) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        if (!messageParams.data) {
+            throw new errors_js_1.KeyringControllerError("Can't sign an empty message");
+        }
+        const address = (0, eth_sig_util_1.normalize)(messageParams.from);
+        const keyring = (await this.getKeyringForAccount(address));
+        if (!keyring.signMessage) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.UnsupportedSignMessage);
+        }
+        return await keyring.signMessage(address, messageParams.data);
+    }
+    /**
+     * Signs EIP-7702 Authorization message by calling down into a specific keyring.
+     *
+     * @param params - EIP7702AuthorizationParams object to sign.
+     * @returns Promise resolving to an EIP-7702 Authorization signature.
+     * @throws Will throw UnsupportedSignEIP7702Authorization if the keyring does not support signing EIP-7702 Authorization messages.
+     */
+    async signEip7702Authorization(params) {
+        const from = (0, eth_sig_util_1.normalize)(params.from);
+        const keyring = (await this.getKeyringForAccount(from));
+        if (!keyring.signEip7702Authorization) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.UnsupportedSignEip7702Authorization);
+        }
+        const { chainId, nonce } = params;
+        const contractAddress = (0, eth_sig_util_1.normalize)(params.contractAddress);
+        if (contractAddress === undefined) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.MissingEip7702AuthorizationContractAddress);
+        }
+        return await keyring.signEip7702Authorization(from, [
+            chainId,
+            contractAddress,
+            nonce,
+        ]);
+    }
+    /**
+     * 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) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        const address = (0, eth_sig_util_1.normalize)(messageParams.from);
+        const keyring = (await this.getKeyringForAccount(address));
+        if (!keyring.signPersonalMessage) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.UnsupportedSignPersonalMessage);
+        }
+        const normalizedData = normalize(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) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        try {
+            if (![
+                SignTypedDataVersion.V1,
+                SignTypedDataVersion.V3,
+                SignTypedDataVersion.V4,
+            ].includes(version)) {
+                throw new errors_js_1.KeyringControllerError(`Unexpected signTypedMessage version: '${version}'`);
+            }
+            // Cast to `Hex` here is safe here because `messageParams.from` is not nullish.
+            // `normalize` returns `Hex` unless given a nullish value.
+            const address = (0, eth_sig_util_1.normalize)(messageParams.from);
+            const keyring = (await this.getKeyringForAccount(address));
+            if (!keyring.signTypedData) {
+                throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.UnsupportedSignTypedMessage);
+            }
+            return await keyring.signTypedData(address, version !== SignTypedDataVersion.V1 &&
+                typeof messageParams.data === 'string'
+                ? JSON.parse(messageParams.data)
+                : messageParams.data, { version });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error
+                ? `${error.name}: ${error.message}`
+                : String(error);
+            throw new errors_js_1.KeyringControllerError(`Keyring Controller signTypedMessage: ${errorMessage}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * 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) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        const address = (0, eth_sig_util_1.normalize)(from);
+        const keyring = (await this.getKeyringForAccount(address));
+        if (!keyring.signTransaction) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.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.
+     * @param executionContext - The execution context to use for the UserOperation.
+     * @returns A pseudo-UserOperation that can be used to construct a real.
+     */
+    async prepareUserOperation(from, transactions, executionContext) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        const address = (0, eth_sig_util_1.normalize)(from);
+        const keyring = (await this.getKeyringForAccount(address));
+        if (!keyring.prepareUserOperation) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.UnsupportedPrepareUserOperation);
+        }
+        return await keyring.prepareUserOperation(address, transactions, executionContext);
+    }
+    /**
+     * Patches properties of a UserOperation. Currently, only the
+     * `paymasterAndData` can be patched.
+     *
+     * @param from - Address of the sender.
+     * @param userOp - UserOperation to patch.
+     * @param executionContext - The execution context to use for the UserOperation.
+     * @returns A patch to apply to the UserOperation.
+     */
+    async patchUserOperation(from, userOp, executionContext) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        const address = (0, eth_sig_util_1.normalize)(from);
+        const keyring = (await this.getKeyringForAccount(address));
+        if (!keyring.patchUserOperation) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.UnsupportedPatchUserOperation);
+        }
+        return await keyring.patchUserOperation(address, userOp, executionContext);
+    }
+    /**
+     * Signs an UserOperation.
+     *
+     * @param from - Address of the sender.
+     * @param userOp - UserOperation to sign.
+     * @param executionContext - The execution context to use for the UserOperation.
+     * @returns The signature of the UserOperation.
+     */
+    async signUserOperation(from, userOp, executionContext) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        const address = (0, eth_sig_util_1.normalize)(from);
+        const keyring = (await this.getKeyringForAccount(address));
+        if (!keyring.signUserOperation) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.UnsupportedSignUserOperation);
+        }
+        return await keyring.signUserOperation(address, userOp, executionContext);
+    }
+    /**
+     * Changes the password used to encrypt the vault.
+     *
+     * @param password - The new password.
+     * @returns Promise resolving when the operation completes.
+     */
+    changePassword(password) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
+            assertIsValidPassword(password);
+            await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_deriveAndSetEncryptionKey).call(this, password, {
+                ignoreExistingVault: true,
+            });
+        });
+    }
+    /**
+     * Attempts to decrypt the current vault and load its keyrings, using the
+     * given encryption key and salt. The optional salt can be used to check for
+     * consistency with the vault salt.
+     *
+     * @param encryptionKey - Key to unlock the keychain.
+     * @param encryptionSalt - Optional salt to unlock the keychain.
+     * @returns Promise resolving when the operation completes.
+     */
+    async submitEncryptionKey(encryptionKey, encryptionSalt) {
+        const { hasChanged } = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withRollback).call(this, async () => {
+            const result = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_unlockKeyrings).call(this, {
+                encryptionKey,
+                encryptionSalt,
+            });
+            __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_setUnlocked).call(this);
+            return result;
+        });
+        try {
+            // if new metadata has been generated during login, we
+            // can attempt to upgrade the vault.
+            await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withRollback).call(this, async () => {
+                if (hasChanged) {
+                    await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_updateVault).call(this);
+                }
+            });
+        }
+        catch (error) {
+            // We don't want to throw an error if the upgrade fails
+            // since the controller is already unlocked.
+            console.error('Failed to update vault during login:', error);
+        }
+    }
+    /**
+     * Exports the vault encryption key.
+     *
+     * @returns The vault encryption key.
+     */
+    async exportEncryptionKey() {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        return await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withControllerLock).call(this, async () => {
+            assertIsEncryptionKeySet(__classPrivateFieldGet(this, _KeyringController_encryptionKey, "f")?.serialized);
+            return __classPrivateFieldGet(this, _KeyringController_encryptionKey, "f").serialized;
+        });
+    }
+    /**
+     * Attempts to decrypt the current vault and load its keyrings,
+     * using the given password.
+     *
+     * @param password - Password to unlock the keychain.
+     * @returns Promise resolving when the operation completes.
+     */
+    async submitPassword(password) {
+        const { hasChanged } = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withRollback).call(this, async () => {
+            const result = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_unlockKeyrings).call(this, { password });
+            __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_setUnlocked).call(this);
+            return result;
+        });
+        try {
+            // If there are stronger encryption params available, or
+            // if the keyring state has changed during deserialization, we
+            // can attempt to upgrade the vault.
+            await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withRollback).call(this, async () => {
+                if (hasChanged || __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_isNewEncryptionAvailable).call(this)) {
+                    await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_deriveAndSetEncryptionKey).call(this, password, {
+                        // If the vault is being upgraded, we want to ignore the metadata
+                        // that is already in the vault, so we can effectively
+                        // re-encrypt the vault with the new encryption config.
+                        ignoreExistingVault: true,
+                    });
+                    await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_updateVault).call(this);
+                }
+            });
+        }
+        catch (error) {
+            // We don't want to throw an error if the upgrade fails
+            // since the controller is already unlocked.
+            console.error('Failed to update vault during login:', error);
+        }
+    }
+    /**
+     * Verifies the that the seed phrase restores the current keychain's accounts.
+     *
+     * @param keyringId - The id of the keyring to verify.
+     * @returns Promise resolving to the seed phrase as Uint8Array.
+     */
+    async verifySeedPhrase(keyringId) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withControllerLock).call(this, async () => __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_verifySeedPhrase).call(this, keyringId));
+    }
+    async withKeyring(selector, operation, options = {
+        createIfMissing: false,
+    }) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
+            let entry = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_selectKeyringEntry).call(this, {
+                v2: false,
+                selector,
+            });
+            if (!entry && 'type' in selector && options.createIfMissing) {
+                const newKeyring = (await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_newKeyring).call(this, selector.type, options.createWithData));
+                entry = __classPrivateFieldGet(this, _KeyringController_keyrings, "f").find(({ keyring }) => keyring === newKeyring);
+            }
+            if (!entry) {
+                throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.KeyringNotFound);
+            }
+            const { metadata } = entry;
+            const keyring = entry.keyring;
+            return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertNoUnsafeDirectKeyringAccess).call(this, await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_cleanUpEmptiedKeyringsAfter).call(this, async () => operation({ keyring, metadata })), keyring);
+        });
+    }
+    /**
+     * Select a keyring and execute the given operation with the selected
+     * keyring, **without** acquiring the controller's mutual exclusion lock.
+     *
+     * ## When to use this method
+     *
+     * This method is an escape hatch for read-only access to keyring data that
+     * is immutable once the keyring is initialized. A typical safe use case is
+     * reading the `mnemonic` from an `HdKeyring`: the mnemonic is set during
+     * `deserialize()` and never mutated afterwards, so it can safely be read
+     * without holding the lock.
+     *
+     * ## Why it is "unsafe"
+     *
+     * The "unsafe" designation mirrors the semantics of `unsafe { }` blocks in
+     * Rust: the method itself does not enforce thread-safety guarantees. By
+     * calling this method the **caller** explicitly takes responsibility for
+     * ensuring that:
+     *
+     * - The operation is **read-only** — no state is mutated.
+     * - The data being read is **immutable** after the keyring is initialized,
+     *   so concurrent locked operations cannot alter it while this callback
+     *   runs.
+     *
+     * Do **not** use this method to:
+     * - Mutate keyring state (add accounts, sign, etc.) — use `withKeyring`.
+     * - Read mutable fields that could change during concurrent operations.
+     *
+     * @param selector - Keyring selector object.
+     * @param operation - Read-only function to execute with the selected keyring.
+     * @returns Promise resolving to the result of the function execution.
+     * @template SelectedKeyring - The type of the selected keyring.
+     * @template CallbackResult - The type of the value resolved by the callback function.
+     */
+    async withKeyringUnsafe(selector, operation) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        const entry = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_selectKeyringEntry).call(this, { v2: false, selector });
+        if (!entry) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.KeyringNotFound);
+        }
+        const { metadata } = entry;
+        const keyring = entry.keyring;
+        // Even if this method is "unsafe", we still want to prevent returning
+        // the keyring directly.
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertNoUnsafeDirectKeyringAccess).call(this, await operation({ keyring, metadata }), keyring);
+    }
+    /**
+     * Select a keyring using its `KeyringV2` adapter, and execute
+     * the given operation with the wrapped keyring as a mutually
+     * exclusive atomic operation.
+     *
+     * The cached `KeyringV2` adapter is retrieved from the keyring
+     * entry.
+     *
+     * A `KeyringV2Builder` for the selected keyring's type must exist
+     * (either as a default or registered via the `keyringV2Builders`
+     * constructor option); otherwise an error is thrown.
+     *
+     * The method automatically persists changes at the end of the
+     * function execution, or rolls back the changes if an error
+     * is thrown.
+     *
+     * @param selector - Keyring selector object.
+     * @param operation - Function to execute with the wrapped V2 keyring.
+     * @returns Promise resolving to the result of the function execution.
+     * @template CallbackResult - The type of the value resolved by the callback function.
+     */
+    async withKeyringV2(selector, operation) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
+            const entry = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_selectKeyringEntry).call(this, {
+                v2: true,
+                selector,
+            });
+            if (!entry) {
+                throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.KeyringNotFound);
+            }
+            if (!entry.keyringV2) {
+                throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.KeyringV2NotSupported);
+            }
+            const { metadata } = entry;
+            const keyring = entry.keyringV2;
+            return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertNoUnsafeDirectKeyringAccess).call(this, await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_cleanUpEmptiedKeyringsAfter).call(this, async () => operation({
+                keyring,
+                metadata,
+            })), keyring);
+        });
+    }
+    /**
+     * Select a keyring, wrap it in a `KeyringV2` adapter, and execute
+     * the given read-only operation **without** acquiring the controller's
+     * mutual exclusion lock.
+     *
+     * ## When to use this method
+     *
+     * This method is an escape hatch for read-only access to keyring data that
+     * is immutable once the keyring is initialized. A typical safe use case is
+     * reading immutable fields from a `KeyringV2` adapter: data that is set
+     * during initialization and never mutated afterwards.
+     *
+     * ## Why it is "unsafe"
+     *
+     * The "unsafe" designation mirrors the semantics of `unsafe { }` blocks in
+     * Rust: the method itself does not enforce thread-safety guarantees. By
+     * calling this method the **caller** explicitly takes responsibility for
+     * ensuring that:
+     *
+     * - The operation is **read-only** — no state is mutated.
+     * - The data being read is **immutable** after the keyring is initialized,
+     *   so concurrent locked operations cannot alter it while this callback
+     *   runs.
+     *
+     * Do **not** use this method to:
+     * - Mutate keyring state (add accounts, sign, etc.) — use `withKeyringV2`.
+     * - Read mutable fields that could change during concurrent operations.
+     *
+     * @param selector - Keyring selector object.
+     * @param operation - Read-only function to execute with the wrapped V2 keyring.
+     * @returns Promise resolving to the result of the function execution.
+     * @template SelectedKeyring - The type of the selected V2 keyring.
+     * @template CallbackResult - The type of the value resolved by the callback function.
+     */
+    async withKeyringV2Unsafe(selector, operation) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        const entry = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_selectKeyringEntry).call(this, {
+            v2: true,
+            selector,
+        });
+        if (!entry) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.KeyringNotFound);
+        }
+        if (!entry.keyringV2) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.KeyringV2NotSupported);
+        }
+        const { metadata } = entry;
+        const keyring = entry.keyringV2;
+        // Even if this method is "unsafe", we still want to prevent returning
+        // the keyring directly.
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertNoUnsafeDirectKeyringAccess).call(this, await operation({ keyring, metadata }), keyring);
+    }
+    /**
+     * Execute an operation against all keyrings as a mutually exclusive atomic
+     * operation. The operation receives a {@link RestrictedController} instance
+     * that exposes a read-only live view of all keyrings as well as
+     * `addNewKeyring` and `removeKeyring` methods to stage mutations.
+     *
+     * The method automatically persists changes at the end of the function
+     * execution, or rolls back the changes if an error is thrown.
+     *
+     * @param operation - Function to execute with the restricted controller.
+     * @returns Promise resolving to the result of the function execution.
+     * @template CallbackResult - The type of the value resolved by the callback function.
+     */
+    async withController(operation) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_persistOrRollback).call(this, async () => {
+            // Track created and removed keyrings during the operation execution.
+            const createdEntries = new Set();
+            const removedEntries = new Set();
+            // Copy of the current keyrings that is mutated during the operation execution.
+            const restrictedEntries = [...__classPrivateFieldGet(this, _KeyringController_keyrings, "f")];
+            // The restricted controller proxies the current keyrings and allows staging
+            // mutations that are only applied to the real keyrings if the operation
+            // completes successfully. This allows us to have a single source of truth
+            // for the keyrings during the operation execution, and to automatically
+            // roll back any changes if an error is thrown.
+            const restrictedController = {
+                // We freeze the array to prevent direct mutations, but the keyring instances
+                // themselves are not frozen, allowing safe read-only access.
+                get keyrings() {
+                    return Object.freeze([...restrictedEntries]);
+                },
+                // Method to create a new keyring and adds it to the restricted entries.
+                addNewKeyring: async (type, opts) => {
+                    const entry = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_createKeyring).call(this, type, opts);
+                    restrictedEntries.push(entry);
+                    createdEntries.add(entry);
+                    return entry;
+                },
+                // Method to remove a keyring from the restricted entries.
+                removeKeyring: async (id) => {
+                    const index = restrictedEntries.findIndex((entry) => entry.metadata.id === id);
+                    if (index === -1) {
+                        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.KeyringNotFound);
+                    }
+                    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertNotRemovingPrimaryKeyring).call(this, restrictedEntries[index], restrictedEntries);
+                    const [removed] = restrictedEntries.splice(index, 1);
+                    removedEntries.add(removed);
+                },
+            };
+            const destroyKeyrings = async (entries) => {
+                await Promise.all([...entries].map(({ keyring, keyringV2 }) => __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_destroyKeyring).call(this, keyring, keyringV2)));
+            };
+            let result;
+            try {
+                result = await operation(restrictedController);
+            }
+            catch (error) {
+                await destroyKeyrings(createdEntries);
+                throw error;
+            }
+            await destroyKeyrings(removedEntries);
+            // We update the real keyrings only after the operation completes successfully, so that
+            // they will be persisted in the vault.
+            __classPrivateFieldSet(this, _KeyringController_keyrings, restrictedEntries, "f");
+            // As usual, we want to prevent returning direct references to keyring instances, so we check
+            // the result for any unsafe direct access before returning.
+            for (const { keyring, keyringV2 } of [
+                ...__classPrivateFieldGet(this, _KeyringController_keyrings, "f"),
+                // We also check for keyrings that got removed during the operation, since the result could
+                // still have references to them.
+                ...removedEntries,
+            ]) {
+                __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertNoUnsafeDirectKeyringAccess).call(this, result, keyring);
+                if (keyringV2) {
+                    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertNoUnsafeDirectKeyringAccess).call(this, result, keyringV2);
+                }
+            }
+            return result;
+        });
+    }
+    /**
+     * Gets the type of the keyring that manages the specified account.
+     *
+     * @param account - The account address to look up.
+     * @returns A promise that resolves to the type of the keyring managing the account.
+     */
+    async getAccountKeyringType(account) {
+        __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+        const keyring = (await this.getKeyringForAccount(account));
+        return keyring.type;
+    }
+}
+exports.KeyringController = KeyringController;
+_KeyringController_controllerOperationMutex = new WeakMap(), _KeyringController_vaultOperationMutex = new WeakMap(), _KeyringController_keyringBuilders = new WeakMap(), _KeyringController_keyringV2Builders = new WeakMap(), _KeyringController_encryptor = new WeakMap(), _KeyringController_keyrings = new WeakMap(), _KeyringController_unsupportedKeyrings = new WeakMap(), _KeyringController_encryptionKey = new WeakMap(), _KeyringController_instances = new WeakSet(), _KeyringController_verifyEncryptionKey = 
+/**
+ * Method to verify a given encryption key validity. Throws an error if the
+ * encryption key is invalid, i.e. it cannot decrypt the vault.
+ *
+ * @param encryptionKey - Serialized vault encryption key.
+ * @param encryptionSalt - Optional salt to verify against the vault. When
+ * omitted, the salt serialized alongside the vault is used.
+ */
+async function _KeyringController_verifyEncryptionKey(encryptionKey, encryptionSalt) {
+    if (!this.state.vault) {
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.VaultError);
+    }
+    const parsedEncryptedVault = JSON.parse(this.state.vault);
+    const salt = encryptionSalt ?? parsedEncryptedVault.salt;
+    if (parsedEncryptedVault.salt !== salt) {
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.ExpiredCredentials);
+    }
+    const key = await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").importKey(encryptionKey);
+    await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").decryptWithKey(key, parsedEncryptedVault);
+}, _KeyringController_verifyCredentials = 
+/**
+ * Verifies export credentials by checking either the wallet password or the
+ * vault encryption key.
+ *
+ * @param credentials - Object holding either the `password` or the vault
+ * `encryptionKey`.
+ */
+async function _KeyringController_verifyCredentials(credentials) {
+    // eslint-disable-next-line no-restricted-syntax
+    if ('password' in credentials) {
+        await this.verifyPassword(credentials.password);
+    }
+    else {
+        await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_verifyEncryptionKey).call(this, credentials.encryptionKey, credentials.encryptionSalt);
+    }
+}, _KeyringController_getKeyringForAccount = async function _KeyringController_getKeyringForAccount(account) {
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+    const entry = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringEntryForAccount).call(this, account);
+    return entry?.keyring;
+}, _KeyringController_getKeyringEntryForAccount = async function _KeyringController_getKeyringEntryForAccount(account) {
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+    const keyringIndex = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_findKeyringIndexForAccount).call(this, account);
+    if (keyringIndex > -1) {
+        return __classPrivateFieldGet(this, _KeyringController_keyrings, "f")[keyringIndex];
+    }
+    return undefined;
+}, _KeyringController_findKeyringIndexForAccount = async function _KeyringController_findKeyringIndexForAccount(account) {
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+    const address = account.toLowerCase();
+    const accountsPerKeyring = await Promise.all(__classPrivateFieldGet(this, _KeyringController_keyrings, "f").map(({ keyring }) => keyring.getAccounts()));
+    return accountsPerKeyring.findIndex((accounts) => accounts.map((a) => a.toLowerCase()).includes(address));
+}, _KeyringController_getKeyringEntriesByType = function _KeyringController_getKeyringEntriesByType({ v2, type, }) {
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertIsUnlocked).call(this);
+    return __classPrivateFieldGet(this, _KeyringController_keyrings, "f").filter(({ keyring, keyringV2 }) => v2 ? keyringV2?.type === type : keyring.type === type);
+}, _KeyringController_assertNoUnsafeDirectKeyringAccess = function _KeyringController_assertNoUnsafeDirectKeyringAccess(value, keyring) {
+    if (Object.is(value, keyring)) {
+        // Access to a keyring instance outside of controller safeguards
+        // should be discouraged, as it can lead to unexpected behavior.
+        // This error is thrown to prevent consumers using `withKeyring`
+        // as a way to get a reference to a keyring instance.
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.UnsafeDirectKeyringAccess);
+    }
+    return value;
+}, _KeyringController_registerMessageHandlers = function _KeyringController_registerMessageHandlers() {
+    this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+}, _KeyringController_selectKeyringEntry = 
+/**
+ * Select a keyring entry using a selector without acquiring the controller lock.
+ *
+ * @param options - Selection options.
+ * @param options.v2 - Tag to indicate whether the selector is for a V2 keyring.
+ * @param options.selector - Keyring selector object.
+ * @returns The selected keyring entry, or `undefined` if no match is found.
+ * @template SelectedKeyring - The expected type of the selected keyring.
+ * @template SelectedKeyringV2 - The expected type of the selected keyring (v2).
+ */
+async function _KeyringController_selectKeyringEntry({ v2, selector, }) {
+    let entry;
+    if ('address' in selector) {
+        entry = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringEntryForAccount).call(this, selector.address);
+    }
+    else if ('type' in selector) {
+        const entries = v2
+            ? __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringEntriesByType).call(this, { v2: true, type: selector.type })
+            : __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringEntriesByType).call(this, { v2: false, type: selector.type });
+        entry = entries[selector.index ?? 0];
+    }
+    else if ('id' in selector) {
+        entry = __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringEntryById).call(this, selector.id);
+    }
+    else if ('filter' in selector) {
+        entry = __classPrivateFieldGet(this, _KeyringController_keyrings, "f").find(({ keyring, keyringV2, metadata }) => {
+            // If v2, then we'll use the v2 selector which expects a `KeyringV2` instance.
+            if (v2) {
+                // However, some keyrings do not have a v2 wrapper, so we just skip them.
+                if (!keyringV2) {
+                    return false;
+                }
+                return selector.filter(keyringV2, metadata);
+            }
+            return selector.filter(keyring, metadata);
+        });
+    }
+    return entry;
+}, _KeyringController_getKeyringById = function _KeyringController_getKeyringById(keyringId) {
+    return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringEntryById).call(this, keyringId)?.keyring;
+}, _KeyringController_getKeyringEntryById = function _KeyringController_getKeyringEntryById(keyringId) {
+    return __classPrivateFieldGet(this, _KeyringController_keyrings, "f").find(({ metadata }) => metadata.id === keyringId);
+}, _KeyringController_getKeyringByIdOrDefault = function _KeyringController_getKeyringByIdOrDefault(keyringId) {
+    if (!keyringId) {
+        return __classPrivateFieldGet(this, _KeyringController_keyrings, "f")[0]?.keyring;
+    }
+    return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringById).call(this, keyringId);
+}, _KeyringController_getKeyringMetadata = function _KeyringController_getKeyringMetadata(keyring) {
+    const keyringWithMetadata = __classPrivateFieldGet(this, _KeyringController_keyrings, "f").find((candidate) => candidate.keyring === keyring);
+    if (!keyringWithMetadata) {
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.KeyringNotFound);
+    }
+    return keyringWithMetadata.metadata;
+}, _KeyringController_getKeyringBuilderForType = function _KeyringController_getKeyringBuilderForType(type) {
+    return __classPrivateFieldGet(this, _KeyringController_keyringBuilders, "f").find((keyringBuilder) => keyringBuilder.type === type);
+}, _KeyringController_getKeyringV2BuilderForType = function _KeyringController_getKeyringV2BuilderForType(type) {
+    return __classPrivateFieldGet(this, _KeyringController_keyringV2Builders, "f").find((builder) => builder.type === type);
+}, _KeyringController_createNewVaultWithKeyring = 
+/**
+ * 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.
+ */
+async function _KeyringController_createNewVaultWithKeyring(password, keyring) {
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertControllerMutexIsLocked).call(this);
+    if (typeof password !== 'string') {
+        throw new TypeError(constants_js_1.KeyringControllerErrorMessage.WrongPasswordType);
+    }
+    this.update((state) => {
+        delete state.encryptionKey;
+        delete state.encryptionSalt;
+    });
+    await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_deriveAndSetEncryptionKey).call(this, password, {
+        ignoreExistingVault: true,
+    });
+    await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_clearKeyrings).call(this);
+    await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_createKeyringWithFirstAccount).call(this, keyring.type, keyring.opts);
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_setUnlocked).call(this);
+}, _KeyringController_deriveAndSetEncryptionKey = 
+/**
+ * Derive the vault encryption key from the provided password, and
+ * assign it to the instance variable for later use with cryptographic
+ * functions.
+ *
+ * When the controller has a vault in its state, the key is derived
+ * using the salt from the vault. If the vault is empty, a new salt
+ * is generated and used to derive the key.
+ *
+ * If `options.ignoreExistingVault` is set to `true`, the existing
+ * vault is completely ignored: the new key won't be able to decrypt
+ * the existing vault, and should be used to re-encrypt it.
+ *
+ * @param password - The password to use for decryption or derivation.
+ * @param options - Options for the key derivation.
+ * @param options.ignoreExistingVault - Whether to ignore the existing vault salt and key metadata
+ */
+async function _KeyringController_deriveAndSetEncryptionKey(password, options = {
+    ignoreExistingVault: false,
+}) {
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertControllerMutexIsLocked).call(this);
+    const { vault } = this.state;
+    if (typeof password !== 'string') {
+        throw new TypeError(constants_js_1.KeyringControllerErrorMessage.WrongPasswordType);
+    }
+    let serializedEncryptionKey, salt;
+    if (vault && !options.ignoreExistingVault) {
+        // The `decryptWithDetail` method is being used here instead of
+        // `keyFromPassword` + `exportKey` to let the encryptor handle
+        // any legacy encryption formats and metadata that might be
+        // present (or absent) in the vault.
+        const { exportedKeyString, salt: existingSalt } = await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").decryptWithDetail(password, vault);
+        serializedEncryptionKey = exportedKeyString;
+        salt = existingSalt;
+    }
+    else {
+        salt = __classPrivateFieldGet(this, _KeyringController_encryptor, "f").generateSalt();
+        serializedEncryptionKey = await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").exportKey(await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").keyFromPassword(password, salt, true));
+    }
+    __classPrivateFieldSet(this, _KeyringController_encryptionKey, {
+        salt,
+        serialized: serializedEncryptionKey,
+    }, "f");
+}, _KeyringController_setEncryptionKey = function _KeyringController_setEncryptionKey(encryptionKey, keyDerivationSalt) {
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertControllerMutexIsLocked).call(this);
+    if (typeof encryptionKey !== 'string' ||
+        typeof keyDerivationSalt !== 'string') {
+        throw new TypeError(constants_js_1.KeyringControllerErrorMessage.WrongEncryptionKeyType);
+    }
+    const { vault } = this.state;
+    if (vault && JSON.parse(vault).salt !== keyDerivationSalt) {
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.ExpiredCredentials);
+    }
+    __classPrivateFieldSet(this, _KeyringController_encryptionKey, {
+        salt: keyDerivationSalt,
+        serialized: encryptionKey,
+    }, "f");
+}, _KeyringController_verifySeedPhrase = 
+/**
+ * Internal non-exclusive method to verify the seed phrase.
+ *
+ * @param keyringId - The id of the keyring to verify the seed phrase for.
+ * @returns A promise resolving to the seed phrase as Uint8Array.
+ */
+async function _KeyringController_verifySeedPhrase(keyringId) {
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertControllerMutexIsLocked).call(this);
+    const keyring = __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringByIdOrDefault).call(this, keyringId);
+    if (!keyring) {
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.KeyringNotFound);
+    }
+    if (keyring.type !== KeyringTypes.hd) {
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.UnsupportedVerifySeedPhrase);
+    }
+    assertHasUint8ArrayMnemonic(keyring);
+    const seedWords = keyring.mnemonic;
+    const accounts = await keyring.getAccounts();
+    /* istanbul ignore if */
+    if (accounts.length === 0) {
+        throw new errors_js_1.KeyringControllerError('Cannot verify an empty keyring.');
+    }
+    // The HD Keyring Builder is a default keyring builder
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const hdKeyringBuilder = __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringBuilderForType).call(this, KeyringTypes.hd);
+    const hdKeyring = hdKeyringBuilder();
+    // @ts-expect-error @metamask/eth-hd-keyring correctly handles
+    // Uint8Array seed phrases in the `deserialize` method.
+    await hdKeyring.deserialize({
+        mnemonic: seedWords,
+        numberOfAccounts: accounts.length,
+    });
+    const testAccounts = await hdKeyring.getAccounts();
+    /* istanbul ignore if */
+    if (testAccounts.length !== accounts.length) {
+        throw new errors_js_1.KeyringControllerError('Seed phrase imported incorrect number of accounts.');
+    }
+    testAccounts.forEach((account, i) => {
+        /* istanbul ignore if */
+        if (account.toLowerCase() !== accounts[i].toLowerCase()) {
+            throw new errors_js_1.KeyringControllerError('Seed phrase imported different accounts.');
+        }
+    });
+    return seedWords;
+}, _KeyringController_getUpdatedKeyrings = 
+/**
+ * Get the updated array of each keyring's type and
+ * accounts list.
+ *
+ * @returns A promise resolving to the updated keyrings array.
+ */
+async function _KeyringController_getUpdatedKeyrings() {
+    return Promise.all(__classPrivateFieldGet(this, _KeyringController_keyrings, "f").map(displayForKeyring));
+}, _KeyringController_getSerializedKeyrings = 
+/**
+ * Serialize the current array of keyring instances,
+ * including unsupported keyrings by default.
+ *
+ * @param options - Method options.
+ * @param options.includeUnsupported - Whether to include unsupported keyrings.
+ * @returns The serialized keyrings.
+ */
+async function _KeyringController_getSerializedKeyrings({ includeUnsupported } = {
+    includeUnsupported: true,
+}) {
+    const serializedKeyrings = await Promise.all(__classPrivateFieldGet(this, _KeyringController_keyrings, "f").map(async ({ keyring, metadata }) => {
+        return {
+            type: keyring.type,
+            data: await keyring.serialize(),
+            metadata,
+        };
+    }));
+    if (includeUnsupported) {
+        serializedKeyrings.push(...__classPrivateFieldGet(this, _KeyringController_unsupportedKeyrings, "f"));
+    }
+    return serializedKeyrings;
+}, _KeyringController_getSessionState = 
+/**
+ * Get a snapshot of session data held by instance variables.
+ *
+ * @returns An object with serialized keyrings, keyrings metadata,
+ * and the user password.
+ */
+async function _KeyringController_getSessionState() {
+    return {
+        keyrings: await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getSerializedKeyrings).call(this),
+        encryptionKey: __classPrivateFieldGet(this, _KeyringController_encryptionKey, "f"),
+    };
+}, _KeyringController_restoreSerializedKeyrings = 
+/**
+ * Restore a serialized keyrings array.
+ *
+ * @param serializedKeyrings - The serialized keyrings array.
+ * @returns The restored keyrings.
+ */
+async function _KeyringController_restoreSerializedKeyrings(serializedKeyrings) {
+    await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_clearKeyrings).call(this);
+    const keyrings = [];
+    let hasChanged = false;
+    for (const serializedKeyring of serializedKeyrings) {
+        const result = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_restoreKeyring).call(this, serializedKeyring);
+        if (result) {
+            const { keyring, metadata } = result;
+            keyrings.push({ keyring, metadata });
+            if (result.hasChanged) {
+                hasChanged = true;
+            }
+        }
+    }
+    return { keyrings, hasChanged };
+}, _KeyringController_unlockKeyrings = 
+/**
+ * Unlock Keyrings, decrypting the vault and deserializing all
+ * keyrings contained in it, using a password or an encryption key with salt.
+ *
+ * @param credentials - The credentials to unlock the keyrings.
+ * @returns A promise resolving to the deserialized keyrings array.
+ */
+async function _KeyringController_unlockKeyrings(credentials) {
+    return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withVaultLock).call(this, async () => {
+        if (!this.state.vault) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.VaultError);
+        }
+        const parsedEncryptedVault = JSON.parse(this.state.vault);
+        if ('password' in credentials) {
+            await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_deriveAndSetEncryptionKey).call(this, credentials.password);
+        }
+        else {
+            __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_setEncryptionKey).call(this, credentials.encryptionKey, credentials.encryptionSalt ?? parsedEncryptedVault.salt);
+        }
+        const encryptionKey = __classPrivateFieldGet(this, _KeyringController_encryptionKey, "f")?.serialized;
+        if (!encryptionKey) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.MissingCredentials);
+        }
+        const key = await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").importKey(encryptionKey);
+        const vault = await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").decryptWithKey(key, parsedEncryptedVault);
+        if (!isSerializedKeyringsArray(vault)) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.VaultDataError);
+        }
+        const { keyrings, hasChanged } = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_restoreSerializedKeyrings).call(this, vault);
+        const updatedKeyrings = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getUpdatedKeyrings).call(this);
+        this.update((state) => {
+            state.keyrings = updatedKeyrings;
+            state.encryptionKey = encryptionKey;
+            state.encryptionSalt = __classPrivateFieldGet(this, _KeyringController_encryptionKey, "f")?.salt;
+        });
+        return { keyrings, hasChanged };
+    });
+}, _KeyringController_updateVault = function _KeyringController_updateVault() {
+    return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withVaultLock).call(this, async () => {
+        // Ensure no duplicate accounts are persisted.
+        await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertNoDuplicateAccounts).call(this);
+        if (!__classPrivateFieldGet(this, _KeyringController_encryptionKey, "f")) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.MissingCredentials);
+        }
+        const serializedKeyrings = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getSerializedKeyrings).call(this);
+        if (!serializedKeyrings.some((keyring) => keyring.type === KeyringTypes.hd)) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.NoHdKeyring);
+        }
+        const key = await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").importKey(__classPrivateFieldGet(this, _KeyringController_encryptionKey, "f").serialized);
+        const encryptedVault = await __classPrivateFieldGet(this, _KeyringController_encryptor, "f").encryptWithKey(key, serializedKeyrings);
+        // We need to include the salt used to derive
+        // the encryption key, to be able to derive it
+        // from password again.
+        encryptedVault.salt = __classPrivateFieldGet(this, _KeyringController_encryptionKey, "f").salt;
+        const updatedState = {
+            vault: JSON.stringify(encryptedVault),
+            encryptionKey: __classPrivateFieldGet(this, _KeyringController_encryptionKey, "f").serialized,
+            encryptionSalt: __classPrivateFieldGet(this, _KeyringController_encryptionKey, "f").salt,
+        };
+        const updatedKeyrings = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getUpdatedKeyrings).call(this);
+        this.update((state) => {
+            state.vault = updatedState.vault;
+            state.keyrings = updatedKeyrings;
+            state.encryptionKey = updatedState.encryptionKey;
+            state.encryptionSalt = updatedState.encryptionSalt;
+        });
+        return true;
+    });
+}, _KeyringController_isNewEncryptionAvailable = function _KeyringController_isNewEncryptionAvailable() {
+    const { vault } = this.state;
+    if (!vault || !__classPrivateFieldGet(this, _KeyringController_encryptor, "f").isVaultUpdated) {
+        return false;
+    }
+    return !__classPrivateFieldGet(this, _KeyringController_encryptor, "f").isVaultUpdated(vault);
+}, _KeyringController_getAccountsFromKeyrings = 
+/**
+ * Retrieves all the accounts from keyrings instances
+ * that are currently in memory.
+ *
+ * @param additionalKeyrings - Additional keyrings to include in the search.
+ * @returns A promise resolving to an array of accounts.
+ */
+async function _KeyringController_getAccountsFromKeyrings(additionalKeyrings = []) {
+    const keyrings = __classPrivateFieldGet(this, _KeyringController_keyrings, "f").map(({ keyring }) => keyring);
+    const keyringArrays = await Promise.all([...keyrings, ...additionalKeyrings].map(async (keyring) => keyring.getAccounts()));
+    const addresses = keyringArrays.reduce((res, arr) => {
+        return res.concat(arr);
+    }, []);
+    // Cast to `string[]` here is safe here because `addresses` has no nullish
+    // values, and `normalize` returns `string` unless given a nullish value
+    return addresses.map(normalize);
+}, _KeyringController_createKeyringWithFirstAccount = 
+/**
+ * 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.
+ */
+async function _KeyringController_createKeyringWithFirstAccount(type, opts) {
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertControllerMutexIsLocked).call(this);
+    const keyring = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_newKeyring).call(this, type, opts);
+    const [firstAccount] = await keyring.getAccounts();
+    if (!firstAccount) {
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.NoFirstAccount);
+    }
+    return firstAccount;
+}, _KeyringController_newKeyring = 
+/**
+ * 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`.
+ *
+ * The internal keyring and keyring metadata arrays are updated with the new
+ * keyring as well.
+ *
+ * @param type - The type of keyring to add.
+ * @param data - Keyring initialization options.
+ * @returns The new keyring.
+ * @throws If the keyring includes duplicated accounts.
+ */
+async function _KeyringController_newKeyring(type, data) {
+    const { keyring, keyringV2, metadata } = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_createKeyring).call(this, type, data);
+    __classPrivateFieldGet(this, _KeyringController_keyrings, "f").push({ keyring, keyringV2, metadata });
+    return keyring;
+}, _KeyringController_createKeyring = 
+/**
+ * Instantiate, initialize and return a keyring of the given `type` using the
+ * given `opts`. The keyring is built using the keyring builder registered
+ * for the given `type`.
+ *
+ * The keyring might be new, or it might be restored from the vault. This
+ * function should only be called from `#newKeyring` or `#restoreKeyring`,
+ * for the "new" and "restore" cases respectively.
+ *
+ * The internal keyring and keyring metadata arrays are *not* updated, the
+ * caller is expected to update them.
+ *
+ * @param type - The type of keyring to add.
+ * @param data - Keyring initialization options.
+ * @param metadata - Keyring metadata if available.
+ * @returns The new keyring.
+ * @throws If the keyring includes duplicated accounts.
+ */
+async function _KeyringController_createKeyring(type, data, metadata) {
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertControllerMutexIsLocked).call(this);
+    const keyringMetadata = metadata ?? getDefaultKeyringMetadata();
+    const keyringBuilder = __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringBuilderForType).call(this, type);
+    if (!keyringBuilder) {
+        throw new errors_js_1.KeyringControllerError(`${constants_js_1.KeyringControllerErrorMessage.NoKeyringBuilder}. Keyring type: ${type}`);
+    }
+    const keyring = keyringBuilder();
+    if (data) {
+        // @ts-expect-error Enforce data type after updating clients
+        await keyring.deserialize(data);
+    }
+    if (keyring.init) {
+        await keyring.init();
+    }
+    if (type === KeyringTypes.hd &&
+        (!(0, utils_1.isObject)(data) || !data.mnemonic)) {
+        if (!keyring.generateRandomMnemonic) {
+            throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.UnsupportedGenerateRandomMnemonic);
+        }
+        // NOTE: Not all keyrings implement this method in a asynchronous-way. Using `await` for
+        // non-thenable will still be valid (despite not being really useful). It allows us to cover both
+        // cases and allow retro-compatibility too.
+        await keyring.generateRandomMnemonic();
+        await keyring.addAccounts(1);
+    }
+    // We now create the keyring V2 wrappers and store them in memory.
+    const keyringBuilderV2 = __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getKeyringV2BuilderForType).call(this, type);
+    let keyringV2;
+    if (keyringBuilderV2) {
+        keyringV2 = keyringBuilderV2(keyring, keyringMetadata);
+    }
+    return { keyring, keyringV2, metadata: keyringMetadata };
+}, _KeyringController_cleanUpEmptiedKeyringsAfter = 
+/**
+ * Run the given operation and afterwards clean up any keyring whose
+ * account list transitioned from non-empty to empty during the operation.
+ *
+ * This mirrors the cleanup behavior of {@link KeyringController.removeAccount}
+ * for code paths where the consumer mutates a keyring directly via
+ * {@link KeyringController.withKeyring} or
+ * {@link KeyringController.withKeyringV2}: if the consumer drains the last
+ * account from a keyring, the now-empty keyring is removed from
+ * {@link KeyringController.#keyrings} and destroyed before persistence runs.
+ *
+ * Pre-existing empty keyrings (e.g. those created intentionally via
+ * {@link KeyringController.addNewKeyring} without subsequent account
+ * creation) are left alone, as are keyrings created within the operation
+ * itself (they are not part of the pre-operation snapshot). The primary
+ * keyring (see {@link KeyringController.#isPrimaryKeyring}) is also preserved
+ * unconditionally to keep `removeAccount`'s primary-keyring invariant intact.
+ *
+ * @param operation - The operation to execute.
+ * @returns The result of the operation.
+ * @template Result - The type of the value resolved by the operation.
+ */
+async function _KeyringController_cleanUpEmptiedKeyringsAfter(operation) {
+    // Only the primary keyring exists, which is never auto-removed, so there
+    // is nothing to clean up regardless of what the operation does.
+    if (__classPrivateFieldGet(this, _KeyringController_keyrings, "f").length <= 1) {
+        return operation();
+    }
+    const wasNonEmpty = new WeakSet();
+    await Promise.all(__classPrivateFieldGet(this, _KeyringController_keyrings, "f").map(async ({ keyring }) => {
+        if ((await keyring.getAccounts()).length > 0) {
+            wasNonEmpty.add(keyring);
+        }
+    }));
+    const result = await operation();
+    const isNowEmpty = await Promise.all(__classPrivateFieldGet(this, _KeyringController_keyrings, "f").map(async ({ keyring }) => (await keyring.getAccounts()).length === 0));
+    const emptied = __classPrivateFieldGet(this, _KeyringController_keyrings, "f").filter((entry, index) => !__classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_isPrimaryKeyring).call(this, entry, __classPrivateFieldGet(this, _KeyringController_keyrings, "f")) &&
+        wasNonEmpty.has(entry.keyring) &&
+        isNowEmpty[index]);
+    if (emptied.length > 0) {
+        const removed = new Set(emptied);
+        __classPrivateFieldSet(this, _KeyringController_keyrings, __classPrivateFieldGet(this, _KeyringController_keyrings, "f").filter((entry) => !removed.has(entry)), "f");
+        await Promise.all(emptied.map(({ keyring, keyringV2 }) => __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_destroyKeyring).call(this, keyring, keyringV2)));
+    }
+    return result;
+}, _KeyringController_clearKeyrings = 
+/**
+ * Remove all managed keyrings, destroying all their
+ * instances in memory.
+ */
+async function _KeyringController_clearKeyrings() {
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertControllerMutexIsLocked).call(this);
+    for (const { keyring, keyringV2 } of __classPrivateFieldGet(this, _KeyringController_keyrings, "f")) {
+        await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_destroyKeyring).call(this, keyring, keyringV2);
+    }
+    __classPrivateFieldSet(this, _KeyringController_keyrings, [], "f");
+    __classPrivateFieldSet(this, _KeyringController_unsupportedKeyrings, [], "f");
+}, _KeyringController_restoreKeyring = 
+/**
+ * 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.
+ */
+async function _KeyringController_restoreKeyring(serialized) {
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertControllerMutexIsLocked).call(this);
+    try {
+        const { type, data, metadata: serializedMetadata } = serialized;
+        // Track if we need to trigger a vault update.
+        let hasChanged = false;
+        // If metadata is missing, assume the data is from an installation before we had
+        // keyring metadata.
+        let metadata = serializedMetadata;
+        if (!metadata) {
+            hasChanged = true;
+            metadata = getDefaultKeyringMetadata();
+        }
+        const oldState = JSON.stringify(data);
+        const { keyring, keyringV2 } = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_createKeyring).call(this, type, data, metadata);
+        const newState = JSON.stringify(await keyring.serialize());
+        hasChanged || (hasChanged = oldState !== newState);
+        await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertNoDuplicateAccounts).call(this, [keyring]);
+        // The keyring is added to the keyrings array only if it's successfully restored
+        // and the metadata is successfully added to the controller
+        __classPrivateFieldGet(this, _KeyringController_keyrings, "f").push({
+            keyring,
+            keyringV2,
+            metadata,
+        });
+        return { keyring, keyringV2, metadata, hasChanged };
+    }
+    catch (error) {
+        console.error(error);
+        __classPrivateFieldGet(this, _KeyringController_unsupportedKeyrings, "f").push(serialized);
+        return undefined;
+    }
+}, _KeyringController_destroyKeyring = 
+/**
+ * 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.
+ * @param keyringV2 - The keyring v2 to destroy (if any).
+ */
+async function _KeyringController_destroyKeyring(keyring, keyringV2) {
+    await keyring.destroy?.();
+    if (keyringV2) {
+        await keyringV2.destroy?.();
+    }
+}, _KeyringController_assertNoDuplicateAccounts = 
+/**
+ * Assert that there are no duplicate accounts in the keyrings.
+ *
+ * @param additionalKeyrings - Additional keyrings to include in the check.
+ * @throws If there are duplicate accounts.
+ */
+async function _KeyringController_assertNoDuplicateAccounts(additionalKeyrings = []) {
+    const accounts = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getAccountsFromKeyrings).call(this, additionalKeyrings);
+    if (new Set(accounts).size !== accounts.length) {
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.DuplicatedAccount);
+    }
+}, _KeyringController_setUnlocked = function _KeyringController_setUnlocked() {
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertControllerMutexIsLocked).call(this);
+    this.update((state) => {
+        state.isUnlocked = true;
+    });
+    this.messenger.publish(`${name}:unlock`);
+}, _KeyringController_assertIsUnlocked = function _KeyringController_assertIsUnlocked() {
+    if (!this.state.isUnlocked) {
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.ControllerLocked);
+    }
+}, _KeyringController_persistOrRollback = 
+/**
+ * Execute the given function after acquiring the controller lock
+ * and save the vault to state after it (only if needed), or rollback to their
+ * previous state in case of error.
+ *
+ * @param callback - The function to execute.
+ * @returns The result of the function.
+ */
+async function _KeyringController_persistOrRollback(callback) {
+    return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withRollback).call(this, async ({ releaseLock }) => {
+        const oldState = JSON.stringify(await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getSessionState).call(this));
+        const callbackResult = await callback({ releaseLock });
+        const newState = JSON.stringify(await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getSessionState).call(this));
+        // State is committed only if the operation is successful and need to trigger a vault update.
+        if (oldState !== newState) {
+            await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_updateVault).call(this);
+        }
+        return callbackResult;
+    });
+}, _KeyringController_withRollback = 
+/**
+ * Execute the given function after acquiring the controller lock
+ * and rollback keyrings and password states in case of error.
+ *
+ * @param callback - The function to execute atomically.
+ * @returns The result of the function.
+ */
+async function _KeyringController_withRollback(callback) {
+    return __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_withControllerLock).call(this, async ({ releaseLock }) => {
+        const currentSerializedKeyrings = await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_getSerializedKeyrings).call(this);
+        const currentEncryptionKey = (0, lodash_1.cloneDeep)(__classPrivateFieldGet(this, _KeyringController_encryptionKey, "f"));
+        try {
+            return await callback({ releaseLock });
+        }
+        catch (error) {
+            // Keyrings and encryption credentials are restored to their previous state
+            __classPrivateFieldSet(this, _KeyringController_encryptionKey, currentEncryptionKey, "f");
+            await __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_restoreSerializedKeyrings).call(this, currentSerializedKeyrings);
+            throw error;
+        }
+    });
+}, _KeyringController_assertControllerMutexIsLocked = function _KeyringController_assertControllerMutexIsLocked() {
+    if (!__classPrivateFieldGet(this, _KeyringController_controllerOperationMutex, "f").isLocked()) {
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.ControllerLockRequired);
+    }
+}, _KeyringController_isPrimaryKeyring = function _KeyringController_isPrimaryKeyring(entry, keyrings) {
+    return (keyrings[0] === entry &&
+        entry.keyring.type === KeyringTypes.hd);
+}, _KeyringController_assertNotRemovingPrimaryKeyring = function _KeyringController_assertNotRemovingPrimaryKeyring(entry, keyrings) {
+    if (__classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_isPrimaryKeyring).call(this, entry, keyrings)) {
+        throw new errors_js_1.KeyringControllerError(constants_js_1.KeyringControllerErrorMessage.CannotRemovePrimaryKeyring);
+    }
+}, _KeyringController_withControllerLock = 
+/**
+ * Lock the controller mutex before executing the given function,
+ * and release it after the function is resolved or after an
+ * error is thrown.
+ *
+ * This wrapper ensures that each mutable operation that interacts with the
+ * controller and that changes its state is executed in a mutually exclusive way,
+ * preventing unsafe concurrent access that could lead to unpredictable behavior.
+ *
+ * @param callback - The function to execute while the controller mutex is locked.
+ * @returns The result of the function.
+ */
+async function _KeyringController_withControllerLock(callback) {
+    return withLock(__classPrivateFieldGet(this, _KeyringController_controllerOperationMutex, "f"), callback);
+}, _KeyringController_withVaultLock = 
+/**
+ * Lock the vault mutex before executing the given function,
+ * and release it after the function is resolved or after an
+ * error is thrown.
+ *
+ * This ensures that each operation that interacts with the vault
+ * is executed in a mutually exclusive way.
+ *
+ * @param callback - The function to execute while the vault mutex is locked.
+ * @returns The result of the function.
+ */
+async function _KeyringController_withVaultLock(callback) {
+    __classPrivateFieldGet(this, _KeyringController_instances, "m", _KeyringController_assertControllerMutexIsLocked).call(this);
+    return withLock(__classPrivateFieldGet(this, _KeyringController_vaultOperationMutex, "f"), callback);
+};
+/**
+ * Lock the given mutex before executing the given function,
+ * and release it after the function is resolved or after an
+ * error is thrown.
+ *
+ * @param mutex - The mutex to lock.
+ * @param callback - The function to execute while the mutex is locked.
+ * @returns The result of the function.
+ */
+async function withLock(mutex, callback) {
+    const releaseLock = await mutex.acquire();
+    try {
+        return await callback({ releaseLock });
+    }
+    finally {
+        releaseLock();
+    }
+}
+/**
+ * Generate a new keyring metadata object.
+ *
+ * @returns Keyring metadata.
+ */
+function getDefaultKeyringMetadata() {
+    return { id: (0, ulid_1.ulid)(), name: '' };
+}
+exports.default = KeyringController;
+//# sourceMappingURL=KeyringController.cjs.map