@metamask/accounts-controller 18.1.1 → 18.2.1

package/dist/AccountsController.mjs

@@ -1,11 +1,606 @@
-import {
-  AccountsController,
-  EMPTY_ACCOUNT
-} from "./chunk-ZPUB3DMH.mjs";
-import "./chunk-Y2QVUNIA.mjs";
-import "./chunk-ZNSHBDHA.mjs";
-export {
-  AccountsController,
-  EMPTY_ACCOUNT
+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_generateInternalAccountForNonSnapAccount, _AccountsController_listSnapAccounts, _AccountsController_listNormalAccounts, _AccountsController_handleOnKeyringStateChange, _AccountsController_handleOnSnapStateChange, _AccountsController_getAccountsByKeyringType, _AccountsController_getLastSelectedAccount, _AccountsController_isAccountCompatibleWithChain, _AccountsController_getLastSelectedIndex, _AccountsController_handleNewAccountAdded, _AccountsController_publishAccountChangeEvent, _AccountsController_handleAccountRemoved, _AccountsController_populateExistingMetadata, _AccountsController_registerMessageHandlers;
+import { BaseController } from "@metamask/base-controller";
+import $metamaskethsnapkeyring from "@metamask/eth-snap-keyring";
+const { SnapKeyring } = $metamaskethsnapkeyring;
+import $metamaskkeyringapi from "@metamask/keyring-api";
+const { EthAccountType, EthMethod, isEvmAccountType } = $metamaskkeyringapi;
+import { KeyringTypes } from "@metamask/keyring-controller";
+import { isCaipChainId, parseCaipChainId } from "@metamask/utils";
+import { getUUIDFromAddressOfNormalAccount, isNormalKeyringType, keyringTypeToName } from "./utils.mjs";
+const controllerName = 'AccountsController';
+const accountsControllerMetadata = {
+    internalAccounts: {
+        persist: true,
+        anonymous: false,
+    },
+};
+const defaultState = {
+    internalAccounts: {
+        accounts: {},
+        selectedAccount: '',
+    },
+};
+export const EMPTY_ACCOUNT = {
+    id: '',
+    address: '',
+    options: {},
+    methods: [],
+    type: EthAccountType.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.
+ *
+ */
+export class AccountsController extends 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, }) {
+        super({
+            messenger,
+            name: controllerName,
+            metadata: accountsControllerMetadata,
+            state: {
+                ...defaultState,
+                ...state,
+            },
+        });
+        _AccountsController_instances.add(this);
+        this.messagingSystem.subscribe('SnapController:stateChange', (snapStateState) => __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_handleOnSnapStateChange).call(this, snapStateState));
+        this.messagingSystem.subscribe('KeyringController:stateChange', (keyringState) => __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_handleOnKeyringStateChange).call(this, keyringState));
+        __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_registerMessageHandlers).call(this);
+    }
+    /**
+     * Returns the internal account object for the given account ID, if it exists.
+     *
+     * @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 an array of all evm internal accounts.
+     *
+     * @returns An array of InternalAccount objects.
+     */
+    listAccounts() {
+        const accounts = Object.values(this.state.internalAccounts.accounts);
+        return accounts.filter((account) => isEvmAccountType(account.type));
+    }
+    /**
+     * Returns an array of all internal accounts.
+     *
+     * @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 (!isCaipChainId(chainId)) {
+            throw new Error(`Invalid CAIP-2 chain ID: ${String(chainId)}`);
+        }
+        return accounts.filter((account) => __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_isAccountCompatibleWithChain).call(this, account, chainId));
+    }
+    /**
+     * Returns the internal account object for the given account ID.
+     *
+     * @param accountId - The ID of the account to retrieve.
+     * @returns The internal account object.
+     * @throws An error if the account ID is not found.
+     */
+    getAccountExpect(accountId) {
+        const account = this.getAccount(accountId);
+        if (account === undefined) {
+            throw new Error(`Account Id "${accountId}" not found`);
+        }
+        return account;
+    }
+    /**
+     * Returns the last selected EVM account.
+     *
+     * @returns The selected internal account.
+     */
+    getSelectedAccount() {
+        // 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 (this.state.internalAccounts.selectedAccount === '') {
+            return EMPTY_ACCOUNT;
+        }
+        const selectedAccount = this.getAccountExpect(this.state.internalAccounts.selectedAccount);
+        if (isEvmAccountType(selectedAccount.type)) {
+            return selectedAccount;
+        }
+        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.
+     *
+     * @param chainId - The chain ID to filter the accounts.
+     * @returns The last selected account compatible with the specified chain ID or undefined.
+     */
+    getSelectedMultichainAccount(chainId) {
+        // 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 (this.state.internalAccounts.selectedAccount === '') {
+            return EMPTY_ACCOUNT;
+        }
+        if (!chainId) {
+            return this.getAccountExpect(this.state.internalAccounts.selectedAccount);
+        }
+        if (!isCaipChainId(chainId)) {
+            throw new Error(`Invalid CAIP-2 chain ID: ${chainId}`);
+        }
+        const accounts = Object.values(this.state.internalAccounts.accounts).filter((account) => __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_isAccountCompatibleWithChain).call(this, account, 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
+     * @param address - The address of the account to retrieve.
+     * @returns The account with the specified address, or undefined if not found.
+     */
+    getAccountByAddress(address) {
+        return this.listMultichainAccounts().find((account) => account.address.toLowerCase() === address.toLowerCase());
+    }
+    /**
+     * Sets the selected account by its ID.
+     *
+     * @param accountId - The ID of the account to be selected.
+     */
+    setSelectedAccount(accountId) {
+        const account = this.getAccountExpect(accountId);
+        this.update((currentState) => {
+            currentState.internalAccounts.accounts[account.id].metadata.lastSelected =
+                Date.now();
+            currentState.internalAccounts.selectedAccount = account.id;
+        });
+        __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_publishAccountChangeEvent).call(this, account);
+    }
+    /**
+     * Sets the name of the account with the given ID.
+     *
+     * @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(),
+        });
+    }
+    /**
+     * Updates the metadata of the account with the given ID.
+     *
+     * @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 = this.getAccountExpect(accountId);
+        if (metadata.name &&
+            this.listMultichainAccounts().find((internalAccount) => internalAccount.metadata.name === metadata.name &&
+                internalAccount.id !== accountId)) {
+            throw new Error('Account name already exists');
+        }
+        this.update((currentState) => {
+            const internalAccount = {
+                ...account,
+                metadata: { ...account.metadata, ...metadata },
+            };
+            // Do not remove this comment - This error is flaky: Comment out or restore the `ts-expect-error` directive below as needed.
+            // See: https://github.com/MetaMask/utils/issues/168
+            // // @ts-expect-error Known issue - `Json` causes recursive error in immer `Draft`/`WritableDraft` types
+            currentState.internalAccounts.accounts[accountId] = internalAccount;
+            if (metadata.name) {
+                this.messagingSystem.publish('AccountsController:accountRenamed', internalAccount);
+            }
+        });
+    }
+    /**
+     * Updates the internal accounts list by retrieving normal and snap accounts,
+     * removing duplicates, and updating the metadata of each account.
+     *
+     * @returns A Promise that resolves when the accounts have been updated.
+     */
+    async updateAccounts() {
+        const snapAccounts = await __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_listSnapAccounts).call(this);
+        const normalAccounts = await __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_listNormalAccounts).call(this);
+        // keyring type map.
+        const keyringTypes = new Map();
+        const previousAccounts = this.state.internalAccounts.accounts;
+        const accounts = [
+            ...normalAccounts,
+            ...snapAccounts,
+        ].reduce((internalAccountMap, internalAccount) => {
+            const keyringTypeName = keyringTypeToName(internalAccount.metadata.keyring.type);
+            const keyringAccountIndex = keyringTypes.get(keyringTypeName) ?? 0;
+            if (keyringAccountIndex) {
+                keyringTypes.set(keyringTypeName, keyringAccountIndex + 1);
+            }
+            else {
+                keyringTypes.set(keyringTypeName, 1);
+            }
+            const existingAccount = previousAccounts[internalAccount.id];
+            internalAccountMap[internalAccount.id] = {
+                ...internalAccount,
+                metadata: {
+                    ...internalAccount.metadata,
+                    name: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, existingAccount?.id, 'name') ??
+                        `${keyringTypeName} ${keyringAccountIndex + 1}`,
+                    importTime: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, existingAccount?.id, 'importTime') ??
+                        Date.now(),
+                    lastSelected: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, existingAccount?.id, 'lastSelected') ?? 0,
+                },
+            };
+            return internalAccountMap;
+        }, {});
+        this.update((currentState) => {
+            currentState.internalAccounts.accounts = accounts;
+            if (!currentState.internalAccounts.accounts[currentState.internalAccounts.selectedAccount]) {
+                const lastSelectedAccount = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getLastSelectedAccount).call(this, Object.values(accounts));
+                if (lastSelectedAccount) {
+                    currentState.internalAccounts.selectedAccount =
+                        lastSelectedAccount.id;
+                    currentState.internalAccounts.accounts[lastSelectedAccount.id].metadata.lastSelected = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getLastSelectedIndex).call(this);
+                    __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_publishAccountChangeEvent).call(this, lastSelectedAccount);
+                }
+                else {
+                    // It will be undefined if there are no accounts
+                    currentState.internalAccounts.selectedAccount = '';
+                }
+            }
+        });
+    }
+    /**
+     * Loads the backup state of the accounts controller.
+     *
+     * @param backup - The backup state to load.
+     */
+    loadBackup(backup) {
+        if (backup.internalAccounts) {
+            this.update((currentState) => {
+                currentState.internalAccounts = backup.internalAccounts;
+            });
+        }
+    }
+    /**
+     * Returns the next account number for a given keyring type.
+     * @param keyringType - The type of keyring.
+     * @param accounts - Existing accounts to check for the next available account number.
+     * @returns An object containing the account prefix and index to use.
+     */
+    getNextAvailableAccountName(keyringType = KeyringTypes.hd, accounts) {
+        const keyringName = keyringTypeToName(keyringType);
+        const keyringAccounts = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getAccountsByKeyringType).call(this, keyringType, accounts);
+        const lastDefaultIndexUsedForKeyringType = keyringAccounts.reduce((maxInternalAccountIndex, internalAccount) => {
+            // We **DO NOT USE** `\d+` here to only consider valid "human"
+            // number (rounded decimal number)
+            const match = new RegExp(`${keyringName} ([0-9]+)$`, 'u').exec(internalAccount.metadata.name);
+            if (match) {
+                // Quoting `RegExp.exec` documentation:
+                // > The returned array has the matched text as the first item, and then one item for
+                // > each capturing group of the matched text.
+                // So use `match[1]` to get the captured value
+                const internalAccountIndex = parseInt(match[1], 10);
+                return Math.max(maxInternalAccountIndex, internalAccountIndex);
+            }
+            return maxInternalAccountIndex;
+        }, 0);
+        const index = Math.max(keyringAccounts.length + 1, 
+        // ESLint is confused; this is a number.
+        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
+        lastDefaultIndexUsedForKeyringType + 1);
+        return `${keyringName} ${index}`;
+    }
+}
+_AccountsController_instances = new WeakSet(), _AccountsController_generateInternalAccountForNonSnapAccount = function _AccountsController_generateInternalAccountForNonSnapAccount(address, type) {
+    return {
+        id: getUUIDFromAddressOfNormalAccount(address),
+        address,
+        options: {},
+        methods: [
+            EthMethod.PersonalSign,
+            EthMethod.Sign,
+            EthMethod.SignTransaction,
+            EthMethod.SignTypedDataV1,
+            EthMethod.SignTypedDataV3,
+            EthMethod.SignTypedDataV4,
+        ],
+        type: EthAccountType.Eoa,
+        metadata: {
+            name: '',
+            importTime: Date.now(),
+            keyring: {
+                type,
+            },
+        },
+    };
+}, _AccountsController_listSnapAccounts = 
+/**
+ * Returns a list of internal accounts created using the SnapKeyring.
+ *
+ * @returns A promise that resolves to an array of InternalAccount objects.
+ */
+async function _AccountsController_listSnapAccounts() {
+    const [snapKeyring] = this.messagingSystem.call('KeyringController:getKeyringsByType', SnapKeyring.type);
+    // snap keyring is not available until the first account is created in the keyring controller
+    if (!snapKeyring) {
+        return [];
+    }
+    const snapAccounts = snapKeyring.listAccounts();
+    return snapAccounts;
+}, _AccountsController_listNormalAccounts = 
+/**
+ * Returns a list of normal accounts.
+ * Note: listNormalAccounts is a temporary method until the keyrings all implement the InternalAccount interface.
+ * Once all keyrings implement the InternalAccount interface, this method can be removed and getAccounts can be used instead.
+ *
+ * @returns A Promise that resolves to an array of InternalAccount objects.
+ */
+async function _AccountsController_listNormalAccounts() {
+    const addresses = await this.messagingSystem.call('KeyringController:getAccounts');
+    const internalAccounts = [];
+    for (const address of addresses) {
+        const keyring = await this.messagingSystem.call('KeyringController:getKeyringForAccount', address);
+        const keyringType = keyring.type;
+        if (!isNormalKeyringType(keyringType)) {
+            // We only consider "normal accounts" here, so keep looping
+            continue;
+        }
+        const id = getUUIDFromAddressOfNormalAccount(address);
+        const nameLastUpdatedAt = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, id, 'nameLastUpdatedAt');
+        internalAccounts.push({
+            id,
+            address,
+            options: {},
+            methods: [
+                EthMethod.PersonalSign,
+                EthMethod.Sign,
+                EthMethod.SignTransaction,
+                EthMethod.SignTypedDataV1,
+                EthMethod.SignTypedDataV3,
+                EthMethod.SignTypedDataV4,
+            ],
+            type: EthAccountType.Eoa,
+            metadata: {
+                name: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, id, 'name') ?? '',
+                ...(nameLastUpdatedAt && { nameLastUpdatedAt }),
+                importTime: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, id, 'importTime') ?? Date.now(),
+                lastSelected: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, id, 'lastSelected') ?? 0,
+                keyring: {
+                    type: keyring.type,
+                },
+            },
+        });
+    }
+    return internalAccounts;
+}, _AccountsController_handleOnKeyringStateChange = function _AccountsController_handleOnKeyringStateChange(keyringState) {
+    // check if there are any new accounts added
+    // 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 (keyringState.isUnlocked && keyringState.keyrings.length > 0) {
+        const updatedNormalKeyringAddresses = [];
+        const updatedSnapKeyringAddresses = [];
+        for (const keyring of keyringState.keyrings) {
+            if (keyring.type === KeyringTypes.snap) {
+                updatedSnapKeyringAddresses.push(...keyring.accounts.map((address) => {
+                    return {
+                        address,
+                        type: keyring.type,
+                    };
+                }));
+            }
+            else {
+                updatedNormalKeyringAddresses.push(...keyring.accounts.map((address) => {
+                    return {
+                        address,
+                        type: keyring.type,
+                    };
+                }));
+            }
+        }
+        const { previousNormalInternalAccounts, previousSnapInternalAccounts } = this.listMultichainAccounts().reduce((accumulator, account) => {
+            if (account.metadata.keyring.type === KeyringTypes.snap) {
+                accumulator.previousSnapInternalAccounts.push(account);
+            }
+            else {
+                accumulator.previousNormalInternalAccounts.push(account);
+            }
+            return accumulator;
+        }, {
+            previousNormalInternalAccounts: [],
+            previousSnapInternalAccounts: [],
+        });
+        const addedAccounts = [];
+        const deletedAccounts = [];
+        // snap account ids are random uuid while normal accounts
+        // are determininistic based on the address
+        // ^NOTE: This will be removed when normal accounts also implement internal accounts
+        // finding all the normal accounts that were added
+        for (const account of updatedNormalKeyringAddresses) {
+            if (!this.state.internalAccounts.accounts[getUUIDFromAddressOfNormalAccount(account.address)]) {
+                addedAccounts.push(account);
+            }
+        }
+        // finding all the snap accounts that were added
+        for (const account of updatedSnapKeyringAddresses) {
+            if (!previousSnapInternalAccounts.find((internalAccount) => internalAccount.address.toLowerCase() ===
+                account.address.toLowerCase())) {
+                addedAccounts.push(account);
+            }
+        }
+        // finding all the normal accounts that were deleted
+        for (const account of previousNormalInternalAccounts) {
+            if (!updatedNormalKeyringAddresses.find(({ address }) => address.toLowerCase() === account.address.toLowerCase())) {
+                deletedAccounts.push(account);
+            }
+        }
+        // finding all the snap accounts that were deleted
+        for (const account of previousSnapInternalAccounts) {
+            if (!updatedSnapKeyringAddresses.find(({ address }) => address.toLowerCase() === account.address.toLowerCase())) {
+                deletedAccounts.push(account);
+            }
+        }
+        this.update((currentState) => {
+            if (deletedAccounts.length > 0) {
+                for (const account of deletedAccounts) {
+                    currentState.internalAccounts.accounts = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_handleAccountRemoved).call(this, currentState.internalAccounts.accounts, account.id);
+                }
+            }
+            if (addedAccounts.length > 0) {
+                for (const account of addedAccounts) {
+                    currentState.internalAccounts.accounts =
+                        __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_handleNewAccountAdded).call(this, currentState.internalAccounts.accounts, account);
+                }
+            }
+            // We don't use list accounts because it is not the updated state yet.
+            const existingAccounts = Object.values(currentState.internalAccounts.accounts);
+            // handle if the selected account was deleted
+            if (!currentState.internalAccounts.accounts[this.state.internalAccounts.selectedAccount]) {
+                const lastSelectedAccount = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getLastSelectedAccount).call(this, existingAccounts);
+                if (lastSelectedAccount) {
+                    currentState.internalAccounts.selectedAccount =
+                        lastSelectedAccount.id;
+                    currentState.internalAccounts.accounts[lastSelectedAccount.id].metadata.lastSelected = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getLastSelectedIndex).call(this);
+                    __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_publishAccountChangeEvent).call(this, lastSelectedAccount);
+                }
+                else {
+                    // It will be undefined if there are no accounts
+                    currentState.internalAccounts.selectedAccount = '';
+                }
+            }
+        });
+    }
+}, _AccountsController_handleOnSnapStateChange = function _AccountsController_handleOnSnapStateChange(snapState) {
+    // only check if snaps changed in status
+    const { snaps } = snapState;
+    const accounts = this.listMultichainAccounts().filter((account) => account.metadata.snap);
+    this.update((currentState) => {
+        accounts.forEach((account) => {
+            const currentAccount = currentState.internalAccounts.accounts[account.id];
+            if (currentAccount.metadata.snap) {
+                const snapId = currentAccount.metadata.snap.id;
+                const storedSnap = snaps[snapId];
+                if (storedSnap) {
+                    currentAccount.metadata.snap.enabled =
+                        storedSnap.enabled && !storedSnap.blocked;
+                }
+            }
+        });
+    });
+}, _AccountsController_getAccountsByKeyringType = function _AccountsController_getAccountsByKeyringType(keyringType, accounts) {
+    return (accounts ?? this.listMultichainAccounts()).filter((internalAccount) => {
+        // We do consider `hd` and `simple` keyrings to be of same type. So we check those 2 types
+        // to group those accounts together!
+        if (keyringType === KeyringTypes.hd ||
+            keyringType === KeyringTypes.simple) {
+            return (internalAccount.metadata.keyring.type === KeyringTypes.hd ||
+                internalAccount.metadata.keyring.type === KeyringTypes.simple);
+        }
+        return internalAccount.metadata.keyring.type === keyringType;
+    });
+}, _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_isAccountCompatibleWithChain = function _AccountsController_isAccountCompatibleWithChain(account, chainId) {
+    // TODO: Change this logic to not use account's type
+    // Because we currently only use type, we can only use namespace for now.
+    return account.type.startsWith(parseCaipChainId(chainId).namespace);
+}, _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_handleNewAccountAdded = function _AccountsController_handleNewAccountAdded(accountsState, account) {
+    let newAccount;
+    if (account.type !== KeyringTypes.snap) {
+        newAccount = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_generateInternalAccountForNonSnapAccount).call(this, account.address, account.type);
+    }
+    else {
+        const [snapKeyring] = this.messagingSystem.call('KeyringController:getKeyringsByType', SnapKeyring.type);
+        newAccount = snapKeyring.getAccountByAddress(account.address);
+        // The snap deleted the account before the keyring controller could add it
+        if (!newAccount) {
+            return accountsState;
+        }
+    }
+    const isFirstAccount = Object.keys(accountsState).length === 0;
+    // Get next account name available for this given keyring
+    const accountName = this.getNextAvailableAccountName(newAccount.metadata.keyring.type, Object.values(accountsState));
+    const newAccountWithUpdatedMetadata = {
+        ...newAccount,
+        metadata: {
+            ...newAccount.metadata,
+            name: accountName,
+            importTime: Date.now(),
+            lastSelected: isFirstAccount ? __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getLastSelectedIndex).call(this) : 0,
+        },
+    };
+    accountsState[newAccount.id] = newAccountWithUpdatedMetadata;
+    this.messagingSystem.publish('AccountsController:accountAdded', newAccountWithUpdatedMetadata);
+    return accountsState;
+}, _AccountsController_publishAccountChangeEvent = function _AccountsController_publishAccountChangeEvent(account) {
+    if (isEvmAccountType(account.type)) {
+        this.messagingSystem.publish('AccountsController:selectedEvmAccountChange', account);
+    }
+    this.messagingSystem.publish('AccountsController:selectedAccountChange', account);
+}, _AccountsController_handleAccountRemoved = function _AccountsController_handleAccountRemoved(accountsState, accountId) {
+    delete accountsState[accountId];
+    this.messagingSystem.publish('AccountsController:accountRemoved', accountId);
+    return accountsState;
+}, _AccountsController_populateExistingMetadata = function _AccountsController_populateExistingMetadata(accountId, metadataKey, account) {
+    const internalAccount = account ?? this.getAccount(accountId);
+    return internalAccount ? internalAccount.metadata[metadataKey] : undefined;
+}, _AccountsController_registerMessageHandlers = function _AccountsController_registerMessageHandlers() {
+    this.messagingSystem.registerActionHandler(`${controllerName}:setSelectedAccount`, this.setSelectedAccount.bind(this));
+    this.messagingSystem.registerActionHandler(`${controllerName}:listAccounts`, this.listAccounts.bind(this));
+    this.messagingSystem.registerActionHandler(`${controllerName}:listMultichainAccounts`, this.listMultichainAccounts.bind(this));
+    this.messagingSystem.registerActionHandler(`${controllerName}:setAccountName`, this.setAccountName.bind(this));
+    this.messagingSystem.registerActionHandler(`${controllerName}:updateAccounts`, this.updateAccounts.bind(this));
+    this.messagingSystem.registerActionHandler(`${controllerName}:getSelectedAccount`, this.getSelectedAccount.bind(this));
+    this.messagingSystem.registerActionHandler(`${controllerName}:getSelectedMultichainAccount`, this.getSelectedMultichainAccount.bind(this));
+    this.messagingSystem.registerActionHandler(`${controllerName}:getAccountByAddress`, this.getAccountByAddress.bind(this));
+    this.messagingSystem.registerActionHandler(`${controllerName}:getNextAvailableAccountName`, this.getNextAvailableAccountName.bind(this));
+    this.messagingSystem.registerActionHandler(`AccountsController:getAccount`, this.getAccount.bind(this));
+    this.messagingSystem.registerActionHandler(`AccountsController:updateAccountMetadata`, this.updateAccountMetadata.bind(this));
 };
 //# sourceMappingURL=AccountsController.mjs.map