@metamask/accounts-controller 39.1.1 → 40.0.0

package/dist/AccountsController.cjs

@@ -1,771 +0,0 @@
-"use strict";
-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 _AccountsController_instances, _AccountsController_getAccountExpect, _AccountsController_assertAccountCanBeRenamed, _AccountsController_getInternalAccountForNonSnapAccount, _AccountsController_getSnapKeyring, _AccountsController_getAccountFromSnapKeyringV1, _AccountsController_getAccountFromSnapKeyringV2, _AccountsController_handleOnSnapKeyringAccountEvent, _AccountsController_handleOnKeyringStateChange, _AccountsController_update, _AccountsController_getLastSelectedAccount, _AccountsController_getLastSelectedIndex, _AccountsController_getInternalAccountFromAddressAndType, _AccountsController_handleOnMultichainNetworkDidChange, _AccountsController_subscribeToMessageEvents;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AccountsController = exports.EMPTY_ACCOUNT = exports.getDefaultAccountsControllerState = void 0;
-const base_controller_1 = require("@metamask/base-controller");
-const eth_snap_keyring_1 = require("@metamask/eth-snap-keyring");
-const v2_1 = require("@metamask/eth-snap-keyring/v2");
-const keyring_api_1 = require("@metamask/keyring-api");
-const v2_2 = require("@metamask/keyring-api/v2");
-const v2_3 = require("@metamask/keyring-sdk/v2");
-const keyring_utils_1 = require("@metamask/keyring-utils");
-const utils_1 = require("@metamask/utils");
-const lodash_1 = require("lodash");
-const logger_js_1 = require("./logger.cjs");
-const utils_js_1 = require("./utils.cjs");
-const controllerName = 'AccountsController';
-const MESSENGER_EXPOSED_METHODS = [
-    'setSelectedAccount',
-    'setAccountName',
-    'setAccountNameAndSelectAccount',
-    'listAccounts',
-    'listMultichainAccounts',
-    'updateAccounts',
-    'getSelectedAccount',
-    'getSelectedMultichainAccount',
-    'getAccountByAddress',
-    'getAccount',
-    'getAccounts',
-    'updateAccountMetadata',
-    'loadBackup',
-    'clearState',
-];
-const accountsControllerMetadata = {
-    internalAccounts: {
-        includeInStateLogs: true,
-        persist: true,
-        includeInDebugSnapshot: false,
-        usedInUi: true,
-    },
-    accountIdByAddress: {
-        includeInStateLogs: false,
-        persist: false,
-        includeInDebugSnapshot: false,
-        usedInUi: true,
-    },
-};
-/**
- * Returns the default state for the AccountsController.
- *
- * @deprecated This function is deprecated and will be removed in a future version.
- * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
- * @returns The default AccountsController state.
- */
-function getDefaultAccountsControllerState() {
-    return {
-        internalAccounts: {
-            accounts: {},
-            selectedAccount: '',
-        },
-        accountIdByAddress: {},
-    };
-}
-exports.getDefaultAccountsControllerState = getDefaultAccountsControllerState;
-/**
- * @deprecated This constant is deprecated and will be removed in a future version.
- * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
- */
-exports.EMPTY_ACCOUNT = {
-    id: '',
-    address: '',
-    options: {},
-    methods: [],
-    type: keyring_api_1.EthAccountType.Eoa,
-    scopes: [keyring_api_1.EthScope.Eoa],
-    metadata: {
-        name: '',
-        keyring: {
-            type: '',
-        },
-        importTime: 0,
-    },
-};
-/**
- * Controller that manages internal accounts.
- * The accounts controller is responsible for creating and managing internal accounts.
- * It also provides convenience methods for accessing and updating the internal accounts.
- * The accounts controller also listens for keyring state changes and updates the internal accounts accordingly.
- * The accounts controller also listens for snap state changes and updates the internal accounts accordingly.
- *
- * @deprecated This class is deprecated and will be removed in a future version.
- * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
- */
-class AccountsController extends base_controller_1.BaseController {
-    /**
-     * Constructor for AccountsController.
-     *
-     * @param options - The controller options.
-     * @param options.messenger - The messenger object.
-     * @param options.state - Initial state to set on this controller
-     */
-    constructor({ messenger, state, }) {
-        const accountIdByAddress = (0, utils_js_1.constructAccountIdByAddress)(state?.internalAccounts?.accounts ?? {});
-        super({
-            messenger,
-            name: controllerName,
-            metadata: accountsControllerMetadata,
-            state: {
-                ...getDefaultAccountsControllerState(),
-                ...state,
-                accountIdByAddress,
-            },
-        });
-        _AccountsController_instances.add(this);
-        this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
-        __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_subscribeToMessageEvents).call(this);
-    }
-    /**
-     * Returns the internal account object for the given account ID, if it exists.
-     *
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
-     * @param accountId - The ID of the account to retrieve.
-     * @returns The internal account object, or undefined if the account does not exist.
-     */
-    getAccount(accountId) {
-        return this.state.internalAccounts.accounts[accountId];
-    }
-    /**
-     * Returns the internal account objects for the given account IDs, if they exist.
-     *
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
-     * @param accountIds - The IDs of the accounts to retrieve.
-     * @returns The internal account objects, or undefined if the account(s) do not exist.
-     */
-    getAccounts(accountIds) {
-        return accountIds.map((accountId) => this.getAccount(accountId));
-    }
-    /**
-     * Returns an array of all evm internal accounts.
-     *
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
-     * @returns An array of InternalAccount objects.
-     */
-    listAccounts() {
-        const accounts = Object.values(this.state.internalAccounts.accounts);
-        return accounts.filter((account) => (0, keyring_api_1.isEvmAccountType)(account.type));
-    }
-    /**
-     * Returns an array of all internal accounts.
-     *
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
-     * @param chainId - The chain ID.
-     * @returns An array of InternalAccount objects.
-     */
-    listMultichainAccounts(chainId) {
-        const accounts = Object.values(this.state.internalAccounts.accounts);
-        if (!chainId) {
-            return accounts;
-        }
-        if (!(0, utils_1.isCaipChainId)(chainId)) {
-            throw new Error(`Invalid CAIP-2 chain ID: ${String(chainId)}`);
-        }
-        return accounts.filter((account) => (0, keyring_utils_1.isScopeEqualToAny)(chainId, account.scopes));
-    }
-    /**
-     * Returns the last selected EVM account.
-     *
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
-     * @returns The selected internal account.
-     */
-    getSelectedAccount() {
-        const { internalAccounts: { selectedAccount }, } = this.state;
-        // Edge case where the extension is setup but the srp is not yet created
-        // certain ui elements will query the selected address before any accounts are created.
-        if (!selectedAccount) {
-            return exports.EMPTY_ACCOUNT;
-        }
-        const account = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getAccountExpect).call(this, selectedAccount);
-        if ((0, keyring_api_1.isEvmAccountType)(account.type)) {
-            return account;
-        }
-        const accounts = this.listAccounts();
-        if (!accounts.length) {
-            // ! Should never reach this.
-            throw new Error('No EVM accounts');
-        }
-        // This will never be undefined because we have already checked if accounts.length is > 0
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getLastSelectedAccount).call(this, accounts);
-    }
-    /**
-     * __WARNING The return value may be undefined if there isn't an account for that chain id.__
-     *
-     * Retrieves the last selected account by chain ID.
-     *
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
-     * @param chainId - The chain ID to filter the accounts.
-     * @returns The last selected account compatible with the specified chain ID or undefined.
-     */
-    getSelectedMultichainAccount(chainId) {
-        const { internalAccounts: { selectedAccount }, } = this.state;
-        // Edge case where the extension is setup but the srp is not yet created
-        // certain ui elements will query the selected address before any accounts are created.
-        if (!selectedAccount) {
-            return exports.EMPTY_ACCOUNT;
-        }
-        if (!chainId) {
-            return __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getAccountExpect).call(this, selectedAccount);
-        }
-        const accounts = this.listMultichainAccounts(chainId);
-        return __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getLastSelectedAccount).call(this, accounts);
-    }
-    /**
-     * Returns the account with the specified address.
-     * ! This method will only return the first account that matches the address
-     *
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
-     * @param address - The address of the account to retrieve.
-     * @returns The account with the specified address, or undefined if not found.
-     */
-    getAccountByAddress(address) {
-        // We need to have a fallback as a cache miss might be attributed to a checksummed address being passed.
-        let accountId = this.state.accountIdByAddress[address];
-        if (!accountId) {
-            // FIXME: We should not need lower-cased addresses, but some consumers might
-            // still be using non-normalized addresses. For now we keep it
-            // for convenience, but we will need to remove this fallback
-            // at some point.
-            // NOTE: We should only hit that branch for EVM accounts only.
-            const lowercasedAddress = address.toLowerCase();
-            accountId = this.state.accountIdByAddress[lowercasedAddress];
-            if (accountId) {
-                (0, logger_js_1.projectLogger)(`Cache missed for account ID: ${accountId}, received address: "${address}", matched address: "${lowercasedAddress}"`);
-            }
-        }
-        return accountId ? this.getAccount(accountId) : undefined;
-    }
-    /**
-     * Sets the selected account by its ID.
-     *
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
-     * @param accountId - The ID of the account to be selected.
-     */
-    setSelectedAccount(accountId) {
-        const account = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getAccountExpect).call(this, accountId);
-        if (this.state.internalAccounts.selectedAccount === account.id) {
-            return;
-        }
-        __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_update).call(this, (state) => {
-            const { internalAccounts } = state;
-            internalAccounts.accounts[account.id].metadata.lastSelected = Date.now();
-            internalAccounts.selectedAccount = account.id;
-        });
-    }
-    /**
-     * Sets the name of the account with the given ID.
-     *
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
-     * @param accountId - The ID of the account to set the name for.
-     * @param accountName - The new name for the account.
-     * @throws An error if an account with the same name already exists.
-     */
-    setAccountName(accountId, accountName) {
-        // This will check for name uniqueness and fire the `accountRenamed` event
-        // if the account has been renamed.
-        this.updateAccountMetadata(accountId, {
-            name: accountName,
-            nameLastUpdatedAt: Date.now(),
-        });
-    }
-    /**
-     * Sets the name of the account with the given ID and select it.
-     *
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
-     * @param accountId - The ID of the account to set the name for and select.
-     * @param accountName - The new name for the account.
-     * @throws An error if an account with the same name already exists.
-     */
-    setAccountNameAndSelectAccount(accountId, accountName) {
-        const account = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getAccountExpect).call(this, accountId);
-        __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_assertAccountCanBeRenamed).call(this, account, accountName);
-        const internalAccount = {
-            ...account,
-            metadata: {
-                ...account.metadata,
-                name: accountName,
-                nameLastUpdatedAt: Date.now(),
-                lastSelected: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getLastSelectedIndex).call(this),
-            },
-        };
-        __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_update).call(this, (state) => {
-            state.internalAccounts.accounts[account.id] = internalAccount;
-            state.internalAccounts.selectedAccount = account.id;
-        });
-        this.messenger.publish('AccountsController:accountRenamed', internalAccount);
-    }
-    /**
-     * Updates the metadata of the account with the given ID.
-     *
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
-     * @param accountId - The ID of the account for which the metadata will be updated.
-     * @param metadata - The new metadata for the account.
-     */
-    updateAccountMetadata(accountId, metadata) {
-        const account = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getAccountExpect).call(this, accountId);
-        if (metadata.name) {
-            __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_assertAccountCanBeRenamed).call(this, account, metadata.name);
-        }
-        const internalAccount = {
-            ...account,
-            metadata: { ...account.metadata, ...metadata },
-        };
-        __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_update).call(this, (state) => {
-            state.internalAccounts.accounts[accountId] = internalAccount;
-        });
-        if (metadata.name) {
-            this.messenger.publish('AccountsController:accountRenamed', internalAccount);
-        }
-    }
-    /**
-     * Updates the internal accounts list by retrieving normal and snap accounts,
-     * removing duplicates, and updating the metadata of each account.
-     *
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
-     * @returns A Promise that resolves when the accounts have been updated.
-     */
-    async updateAccounts() {
-        (0, logger_js_1.projectLogger)('Synchronizing accounts with keyrings...');
-        const keyringAccountIndexes = new Map();
-        const existingInternalAccounts = this.state.internalAccounts.accounts;
-        const internalAccounts = {};
-        const { keyrings } = this.messenger.call('KeyringController:getState');
-        for (const keyring of keyrings) {
-            // Money accounts are not treated as real accounts, they are owned by the `MoneyAccountController`, so
-            // we need to filter them out here.
-            if ((0, utils_js_1.isMoneyKeyringType)(keyring.type)) {
-                continue;
-            }
-            const keyringTypeName = (0, utils_js_1.keyringTypeToName)(keyring.type);
-            for (const address of keyring.accounts) {
-                const internalAccount = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getInternalAccountFromAddressAndType).call(this, address, keyring);
-                // This should never really happen, but if for some reason we're not
-                // able to get the Snap keyring reference, this would return an
-                // undefined account.
-                // So we just skip it, even though, this should not really happen.
-                if (!internalAccount) {
-                    continue;
-                }
-                // Get current index for this keyring (we use human indexing, so start at 1).
-                const keyringAccountIndex = keyringAccountIndexes.get(keyringTypeName) ?? 1;
-                const existingAccount = existingInternalAccounts[internalAccount.id];
-                internalAccounts[internalAccount.id] = {
-                    ...internalAccount,
-                    metadata: {
-                        ...internalAccount.metadata,
-                        // Re-use existing metadata if any.
-                        name: existingAccount?.metadata.name ??
-                            `${keyringTypeName} ${keyringAccountIndex}`,
-                        importTime: existingAccount?.metadata.importTime ?? Date.now(),
-                        lastSelected: existingAccount?.metadata.lastSelected ?? 0,
-                    },
-                };
-                // Increment the account index for this keyring.
-                keyringAccountIndexes.set(keyringTypeName, keyringAccountIndex + 1);
-            }
-        }
-        __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_update).call(this, (state) => {
-            state.internalAccounts.accounts = internalAccounts;
-            state.accountIdByAddress = (0, utils_js_1.constructAccountIdByAddress)(internalAccounts);
-        });
-        (0, logger_js_1.projectLogger)('Accounts synchronized!');
-    }
-    /**
-     * Loads the backup state of the accounts controller.
-     *
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
-     * @param backup - The backup state to load.
-     */
-    loadBackup(backup) {
-        if (backup.internalAccounts) {
-            const accountIdByAddress = (0, utils_js_1.constructAccountIdByAddress)(backup.internalAccounts.accounts);
-            this.update((currentState) => {
-                currentState.internalAccounts = backup.internalAccounts;
-                currentState.accountIdByAddress = accountIdByAddress;
-            });
-        }
-    }
-    /**
-     * Clears the controller state and resets to default values.
-     *
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use `AccountTreeController`, `MultichainAccountService`, or the Keyring API v2 instead.
-     */
-    clearState() {
-        this.update(() => {
-            return getDefaultAccountsControllerState();
-        });
-    }
-}
-exports.AccountsController = AccountsController;
-_AccountsController_instances = new WeakSet(), _AccountsController_getAccountExpect = function _AccountsController_getAccountExpect(accountId) {
-    const account = this.getAccount(accountId);
-    if (account === undefined) {
-        throw new Error(`Account Id "${accountId}" not found`);
-    }
-    return account;
-}, _AccountsController_assertAccountCanBeRenamed = function _AccountsController_assertAccountCanBeRenamed(account, accountName) {
-    if (this.listMultichainAccounts().find((internalAccount) => internalAccount.metadata.name === accountName &&
-        internalAccount.id !== account.id)) {
-        throw new Error('Account name already exists');
-    }
-}, _AccountsController_getInternalAccountForNonSnapAccount = function _AccountsController_getInternalAccountForNonSnapAccount(address, keyring) {
-    const id = (0, utils_js_1.getUUIDFromAddressOfNormalAccount)(address);
-    // We might have an account for this ID already, so we'll just re-use
-    // the same metadata
-    const account = this.getAccount(id);
-    const metadata = {
-        name: account?.metadata.name ?? '',
-        ...(account?.metadata.nameLastUpdatedAt
-            ? {
-                nameLastUpdatedAt: account?.metadata.nameLastUpdatedAt,
-            }
-            : {}),
-        importTime: account?.metadata.importTime ?? Date.now(),
-        lastSelected: account?.metadata.lastSelected ?? 0,
-        keyring: {
-            type: keyring.type,
-        },
-    };
-    let options = {};
-    if ((0, utils_js_1.isHdKeyringType)(keyring.type)) {
-        // We need to find the account index from its HD keyring.
-        const groupIndex = (0, utils_js_1.getEvmGroupIndexFromAddressIndex)(keyring, address);
-        // If for some reason, we cannot find this address, then the caller made a mistake
-        // and it did not use the proper keyring object. For now, we do not fail and just
-        // consider this account as "simple account".
-        if (groupIndex !== undefined) {
-            // NOTE: We are not using the `hdPath` from the associated keyring here and
-            // getting the keyring instance here feels a bit overkill.
-            // This will be naturally fixed once every keyring start using `KeyringAccount` and implement the keyring API.
-            const derivationPath = (0, utils_js_1.getEvmDerivationPathForIndex)(groupIndex);
-            // Those are "legacy options" and they were used before `KeyringAccount` added
-            // support for type options. We keep those temporarily until we update everything
-            // to use the new typed options.
-            const legacyOptions = {
-                entropySource: keyring.metadata.id,
-                derivationPath,
-                groupIndex,
-            };
-            // New typed entropy options. This is required for multichain accounts.
-            const entropyOptions = {
-                entropy: {
-                    type: keyring_api_1.KeyringAccountEntropyTypeOption.Mnemonic,
-                    id: keyring.metadata.id,
-                    derivationPath,
-                    groupIndex,
-                },
-            };
-            options = {
-                ...legacyOptions,
-                ...entropyOptions,
-            };
-        }
-    }
-    return {
-        id,
-        address,
-        options,
-        methods: [
-            keyring_api_1.EthMethod.PersonalSign,
-            keyring_api_1.EthMethod.Sign,
-            keyring_api_1.EthMethod.SignTransaction,
-            keyring_api_1.EthMethod.SignTypedDataV1,
-            keyring_api_1.EthMethod.SignTypedDataV3,
-            keyring_api_1.EthMethod.SignTypedDataV4,
-        ],
-        scopes: [keyring_api_1.EthScope.Eoa],
-        type: keyring_api_1.EthAccountType.Eoa,
-        metadata,
-    };
-}, _AccountsController_getSnapKeyring = function _AccountsController_getSnapKeyring() {
-    const [snapKeyring] = this.messenger.call('KeyringController:getKeyringsByType', eth_snap_keyring_1.SnapKeyring.type);
-    // Snap keyring is not available until the first account is created in the keyring
-    // controller, so this might be undefined.
-    return snapKeyring;
-}, _AccountsController_getAccountFromSnapKeyringV1 = function _AccountsController_getAccountFromSnapKeyringV1(address) {
-    const snapKeyring = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getSnapKeyring).call(this);
-    // We need the Snap keyring to retrieve the account from its address.
-    if (!snapKeyring) {
-        return undefined;
-    }
-    // This might be undefined if the Snap deleted the account before
-    // reaching that point.
-    return snapKeyring.getAccountByAddress(address);
-}, _AccountsController_getAccountFromSnapKeyringV2 = function _AccountsController_getAccountFromSnapKeyringV2(address) {
-    const keyrings = this.messenger.call('KeyringController:getKeyringsByType', v2_2.KeyringType.Snap);
-    // Snap keyring v2 are "per-Snaps" (and can be accessed using their v1 adapter), so we need to
-    // iterate over all of them to find the account.
-    // NOTE: `:getKeyringsByType` will only return v1 instances, that's why we need to use their v1
-    // adapter + `unwrap` method to get the reference to their v2 instance.
-    for (const keyring of keyrings) {
-        if (keyring instanceof v2_3.KeyringV1Adapter) {
-            // NOTE: We already filtering by `KeyringType.Snap`, so we are sure that those adapters
-            // are wrapping a Snap keyring v2.
-            const adapter = keyring;
-            const keyringV2 = adapter.unwrap();
-            // We use the synchronous method here since this method is used during `:stateChange` that are
-            // use synchronous handlers.
-            const account = keyringV2.lookupByAddress(address);
-            if (account) {
-                return {
-                    ...account,
-                    // We still have to use internal account for now, so we inject some metadata.
-                    metadata: {
-                        name: '',
-                        importTime: Date.now(),
-                        lastSelected: 0,
-                        keyring: {
-                            type: v2_2.KeyringType.Snap,
-                        },
-                        snap: {
-                            id: keyringV2.snapId,
-                        },
-                    },
-                };
-            }
-        }
-    }
-    return undefined;
-}, _AccountsController_handleOnSnapKeyringAccountEvent = function _AccountsController_handleOnSnapKeyringAccountEvent(event, ...payload) {
-    this.messenger.publish(event, ...payload);
-}, _AccountsController_handleOnKeyringStateChange = function _AccountsController_handleOnKeyringStateChange({ isUnlocked, keyrings, }) {
-    // TODO: Change when accountAdded event is added to the keyring controller.
-    // We check for keyrings length to be greater than 0 because the extension client may try execute
-    // submit password twice and clear the keyring state.
-    // https://github.com/MetaMask/KeyringController/blob/2d73a4deed8d013913f6ef0c9f5c0bb7c614f7d3/src/KeyringController.ts#L910
-    if (!isUnlocked || keyrings.length === 0) {
-        return;
-    }
-    (0, logger_js_1.projectLogger)('Synchronizing accounts with keyrings (through :stateChange)...');
-    // State patches.
-    const patch = {
-        previous: {},
-        added: [],
-        updated: [],
-        removed: [],
-    };
-    // Create a map (with lower-cased addresses) of all existing accounts.
-    for (const account of this.listMultichainAccounts()) {
-        const address = account.address.toLowerCase();
-        patch.previous[address] = account;
-    }
-    // Go over all keyring changes and create patches out of it.
-    const addresses = new Set();
-    for (const keyring of keyrings) {
-        // Money accounts are not treated as real accounts, they are owned by the `MoneyAccountController`, so
-        // we need to filter them out here.
-        if ((0, utils_js_1.isMoneyKeyringType)(keyring.type)) {
-            continue;
-        }
-        for (const accountAddress of keyring.accounts) {
-            // Lower-case address to use it in the `previous` map.
-            const address = accountAddress.toLowerCase();
-            const account = patch.previous[address];
-            if (account) {
-                // If the account exists before, this might be an update.
-                patch.updated.push(account);
-            }
-            else {
-                // Otherwise, that's a new account.
-                patch.added.push({
-                    address,
-                    keyring,
-                });
-            }
-            // Keep track of those address to check for removed accounts later.
-            addresses.add(address);
-        }
-    }
-    // We might have accounts associated with removed keyrings, so we iterate
-    // over all previous known accounts and check against the keyring addresses.
-    for (const [address, account] of Object.entries(patch.previous)) {
-        // If a previous address is not part of the new addesses, then it got removed.
-        if (!addresses.has(address)) {
-            patch.removed.push(account);
-        }
-    }
-    // Diff that we will use to publish events afterward.
-    const diff = {
-        removed: [],
-        added: [],
-    };
-    __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_update).call(this, (state) => {
-        const { internalAccounts, accountIdByAddress } = state;
-        for (const account of patch.removed) {
-            delete internalAccounts.accounts[account.id];
-            delete accountIdByAddress[account.address];
-            diff.removed.push(account.id);
-        }
-        for (const added of patch.added) {
-            const account = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getInternalAccountFromAddressAndType).call(this, added.address, added.keyring);
-            if (account) {
-                const accounts = Object.values(internalAccounts.accounts);
-                // If it's the first account, we need to select it.
-                const lastSelected = accounts.length === 0 ? __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getLastSelectedIndex).call(this) : 0;
-                internalAccounts.accounts[account.id] = {
-                    ...account,
-                    metadata: {
-                        ...account.metadata,
-                        importTime: Date.now(),
-                        lastSelected,
-                    },
-                };
-                accountIdByAddress[account.address] = account.id;
-                diff.added.push(internalAccounts.accounts[account.id]);
-            }
-        }
-    }, 
-    // Will get executed after the update, but before re-selecting an account in case
-    // the current one is not valid anymore.
-    () => {
-        // Now publish events
-        for (const id of diff.removed) {
-            this.messenger.publish('AccountsController:accountRemoved', id);
-        }
-        if (diff.removed.length > 0) {
-            this.messenger.publish('AccountsController:accountsRemoved', diff.removed);
-        }
-        for (const account of diff.added) {
-            this.messenger.publish('AccountsController:accountAdded', account);
-        }
-        if (diff.added.length > 0) {
-            this.messenger.publish('AccountsController:accountsAdded', diff.added);
-        }
-    });
-    (0, logger_js_1.projectLogger)('Accounts synchronized (through :stateChange)!');
-    // NOTE: Since we also track "updated" accounts with our patches, we could fire a new event
-    // like `accountUpdated` (we would still need to check if anything really changed on the account).
-}, _AccountsController_update = function _AccountsController_update(callback, beforeAutoSelectAccount) {
-    // The currently selected account might get deleted during the update, so keep track
-    // of it before doing any change.
-    const previouslySelectedAccount = this.state.internalAccounts.selectedAccount;
-    this.update((state) => {
-        callback(state);
-        // If the account no longer exists (or none is selected), we need to re-select another one.
-        const { internalAccounts } = state;
-        if (!internalAccounts.accounts[previouslySelectedAccount]) {
-            const accounts = Object.values(internalAccounts.accounts);
-            // Get the lastly selected account (according to the current accounts).
-            const lastSelectedAccount = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getLastSelectedAccount).call(this, accounts);
-            if (lastSelectedAccount) {
-                internalAccounts.selectedAccount = lastSelectedAccount.id;
-                internalAccounts.accounts[lastSelectedAccount.id].metadata.lastSelected = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getLastSelectedIndex).call(this);
-            }
-            else {
-                // It will be undefined if there are no accounts.
-                internalAccounts.selectedAccount = '';
-            }
-        }
-    });
-    // We might want to do some pre-work before selecting a new account.
-    beforeAutoSelectAccount?.();
-    // Now, we compare the newly selected account, and we send event if different.
-    const { selectedAccount } = this.state.internalAccounts;
-    if (selectedAccount && selectedAccount !== previouslySelectedAccount) {
-        const account = this.getSelectedMultichainAccount();
-        // The account should always be defined at this point, since we have already checked for
-        // `selectedAccount` to be non-empty.
-        if (account) {
-            if ((0, keyring_api_1.isEvmAccountType)(account.type)) {
-                this.messenger.publish('AccountsController:selectedEvmAccountChange', account);
-            }
-            this.messenger.publish('AccountsController:selectedAccountChange', account);
-        }
-    }
-}, _AccountsController_getLastSelectedAccount = function _AccountsController_getLastSelectedAccount(accounts) {
-    const [accountToSelect] = accounts.sort((accountA, accountB) => {
-        // sort by lastSelected descending
-        return ((accountB.metadata.lastSelected ?? 0) -
-            (accountA.metadata.lastSelected ?? 0));
-    });
-    return accountToSelect;
-}, _AccountsController_getLastSelectedIndex = function _AccountsController_getLastSelectedIndex() {
-    // NOTE: For now we use the current date, since we know this value
-    // will always be higher than any already selected account index.
-    return Date.now();
-}, _AccountsController_getInternalAccountFromAddressAndType = function _AccountsController_getInternalAccountFromAddressAndType(address, keyring) {
-    const isSnapKeyringV1 = (0, utils_js_1.isSnapKeyringType)(keyring.type);
-    const isSnapKeyringV2 = (0, utils_js_1.isSnapKeyringV2Type)(keyring.type);
-    if (isSnapKeyringV1 || isSnapKeyringV2) {
-        let account;
-        if (isSnapKeyringV1) {
-            account = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getAccountFromSnapKeyringV1).call(this, address);
-        }
-        else {
-            account = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getAccountFromSnapKeyringV2).call(this, address);
-        }
-        if (account) {
-            // We force the copy here, to avoid mutating the reference returned by the Snap keyring.
-            account = (0, lodash_1.cloneDeep)(account);
-            // MIGRATION: To avoid any existing Snap account migration, we are
-            // just "adding" the new typed options that we need for multichain
-            // accounts. Ultimately, we would need a real Snap account migrations
-            // (being handled by each Snaps).
-            if ((0, utils_js_1.isHdSnapKeyringAccount)(account)) {
-                const options = {
-                    ...account.options,
-                    entropy: {
-                        type: keyring_api_1.KeyringAccountEntropyTypeOption.Mnemonic,
-                        id: account.options.entropySource,
-                        groupIndex: account.options.index,
-                        derivationPath: account.options.derivationPath,
-                    },
-                };
-                // Inject the new typed options to the internal account copy.
-                account.options = options;
-            }
-        }
-        return account;
-    }
-    return __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getInternalAccountForNonSnapAccount).call(this, address, keyring);
-}, _AccountsController_handleOnMultichainNetworkDidChange = function _AccountsController_handleOnMultichainNetworkDidChange(id) {
-    let accountId;
-    // We only support non-EVM Caip chain IDs at the moment. Ex Solana and Bitcoin
-    // MultichainNetworkController will handle throwing an error if the Caip chain ID is not supported
-    if ((0, utils_1.isCaipChainId)(id)) {
-        // Update selected account to non evm account
-        const lastSelectedNonEvmAccount = this.getSelectedMultichainAccount(id);
-        // @ts-expect-error - This should never be undefined, otherwise it's a bug that should be handled
-        accountId = lastSelectedNonEvmAccount.id;
-    }
-    else {
-        // Update selected account to evm account
-        const lastSelectedEvmAccount = this.getSelectedAccount();
-        accountId = lastSelectedEvmAccount.id;
-    }
-    if (this.state.internalAccounts.selectedAccount === accountId) {
-        return;
-    }
-    this.update((currentState) => {
-        currentState.internalAccounts.accounts[accountId].metadata.lastSelected =
-            Date.now();
-        currentState.internalAccounts.selectedAccount = accountId;
-    });
-    // DO NOT publish AccountsController:setSelectedAccount to prevent circular listener loops
-}, _AccountsController_subscribeToMessageEvents = function _AccountsController_subscribeToMessageEvents() {
-    this.messenger.subscribe('KeyringController:stateChange', (keyringState) => __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_handleOnKeyringStateChange).call(this, keyringState));
-    this.messenger.subscribe('SnapAccountService:accountAssetListUpdated', (snapAccountEvent) => __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_handleOnSnapKeyringAccountEvent).call(this, 'AccountsController:accountAssetListUpdated', snapAccountEvent));
-    this.messenger.subscribe('SnapAccountService:accountBalancesUpdated', (snapAccountEvent) => __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_handleOnSnapKeyringAccountEvent).call(this, 'AccountsController:accountBalancesUpdated', snapAccountEvent));
-    this.messenger.subscribe('SnapAccountService:accountTransactionsUpdated', (snapAccountEvent) => __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_handleOnSnapKeyringAccountEvent).call(this, 'AccountsController:accountTransactionsUpdated', snapAccountEvent));
-    // Handle account change when multichain network is changed
-    this.messenger.subscribe('MultichainNetworkController:networkDidChange', (id) => __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_handleOnMultichainNetworkDidChange).call(this, id));
-};
-//# sourceMappingURL=AccountsController.cjs.map