@metamask/accounts-controller 27.0.0 → 28.0.0

package/dist/AccountsController.mjs

@@ -3,14 +3,14 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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_handleOnSnapKeyringAccountEvent, _AccountsController_handleOnKeyringStateChange, _AccountsController_handleOnSnapStateChange, _AccountsController_getAccountsByKeyringType, _AccountsController_getLastSelectedAccount, _AccountsController_getLastSelectedIndex, _AccountsController_handleNewAccountAdded, _AccountsController_publishAccountChangeEvent, _AccountsController_handleAccountRemoved, _AccountsController_handleOnMultichainNetworkDidChange, _AccountsController_populateExistingMetadata, _AccountsController_subscribeToMessageEvents, _AccountsController_registerMessageHandlers;
+var _AccountsController_instances, _AccountsController_assertAccountCanBeRenamed, _AccountsController_generateInternalAccountForNonSnapAccount, _AccountsController_getSnapKeyring, _AccountsController_listSnapAccounts, _AccountsController_listNormalAccounts, _AccountsController_handleOnSnapKeyringAccountEvent, _AccountsController_handleOnKeyringStateChange, _AccountsController_update, _AccountsController_handleOnSnapStateChange, _AccountsController_getAccountsByKeyringType, _AccountsController_getLastSelectedAccount, _AccountsController_getLastSelectedIndex, _AccountsController_getInternalAccountFromAddressAndType, _AccountsController_handleOnMultichainNetworkDidChange, _AccountsController_populateExistingMetadata, _AccountsController_subscribeToMessageEvents, _AccountsController_registerMessageHandlers;
 import { BaseController } from "@metamask/base-controller";
 import { SnapKeyring } from "@metamask/eth-snap-keyring";
 import { EthAccountType, EthMethod, EthScope, isEvmAccountType } from "@metamask/keyring-api";
 import { KeyringTypes } from "@metamask/keyring-controller";
 import { isScopeEqualToAny } from "@metamask/keyring-utils";
 import { isCaipChainId } from "@metamask/utils";
-import { getUUIDFromAddressOfNormalAccount, isNormalKeyringType, keyringTypeToName } from "./utils.mjs";
+import { getDerivationPathForIndex, getUUIDFromAddressOfNormalAccount, isHdKeyringType, isNormalKeyringType, keyringTypeToName } from "./utils.mjs";
 const controllerName = 'AccountsController';
 const accountsControllerMetadata = {
     internalAccounts: {
@@ -123,14 +123,15 @@ export class AccountsController extends BaseController {
      * @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 (this.state.internalAccounts.selectedAccount === '') {
+        if (selectedAccount === '') {
             return EMPTY_ACCOUNT;
         }
-        const selectedAccount = this.getAccountExpect(this.state.internalAccounts.selectedAccount);
-        if (isEvmAccountType(selectedAccount.type)) {
-            return selectedAccount;
+        const account = this.getAccountExpect(selectedAccount);
+        if (isEvmAccountType(account.type)) {
+            return account;
         }
         const accounts = this.listAccounts();
         if (!accounts.length) {
@@ -150,13 +151,14 @@ export class AccountsController extends BaseController {
      * @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 (this.state.internalAccounts.selectedAccount === '') {
+        if (selectedAccount === '') {
             return EMPTY_ACCOUNT;
         }
         if (!chainId) {
-            return this.getAccountExpect(this.state.internalAccounts.selectedAccount);
+            return this.getAccountExpect(selectedAccount);
         }
         const accounts = this.listMultichainAccounts(chainId);
         return __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getLastSelectedAccount).call(this, accounts);
@@ -178,12 +180,11 @@ export class AccountsController extends BaseController {
      */
     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_update).call(this, (state) => {
+            const { internalAccounts } = state;
+            internalAccounts.accounts[account.id].metadata.lastSelected = Date.now();
+            internalAccounts.selectedAccount = account.id;
         });
-        __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_publishAccountChangeEvent).call(this, account);
     }
     /**
      * Sets the name of the account with the given ID.
@@ -200,6 +201,37 @@ export class AccountsController extends BaseController {
             nameLastUpdatedAt: Date.now(),
         });
     }
+    /**
+     * Sets the name of the account with the given ID and select it.
+     *
+     * @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 = this.getAccountExpect(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) => {
+            // FIXME: Using the state as-is cause the following error: "Type instantiation is excessively
+            // deep and possibly infinite.ts(2589)" (https://github.com/MetaMask/utils/issues/168)
+            // Using a type-cast workaround this error and is slightly better than using a @ts-expect-error
+            // which sometimes fail when compiling locally.
+            state.internalAccounts.accounts[account.id] =
+                internalAccount;
+            state.internalAccounts.selectedAccount =
+                account.id;
+        });
+        this.messagingSystem.publish('AccountsController:accountRenamed', internalAccount);
+    }
     /**
      * Updates the metadata of the account with the given ID.
      *
@@ -208,24 +240,24 @@ export class AccountsController extends BaseController {
      */
     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');
+        if (metadata.name) {
+            __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_assertAccountCanBeRenamed).call(this, account, metadata.name);
         }
-        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);
-            }
+        const internalAccount = {
+            ...account,
+            metadata: { ...account.metadata, ...metadata },
+        };
+        __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_update).call(this, (state) => {
+            // FIXME: Using the state as-is cause the following error: "Type instantiation is excessively
+            // deep and possibly infinite.ts(2589)" (https://github.com/MetaMask/utils/issues/168)
+            // Using a type-cast workaround this error and is slightly better than using a @ts-expect-error
+            // which sometimes fail when compiling locally.
+            state.internalAccounts.accounts[accountId] =
+                internalAccount;
         });
+        if (metadata.name) {
+            this.messagingSystem.publish('AccountsController:accountRenamed', internalAccount);
+        }
     }
     /**
      * Updates the internal accounts list by retrieving normal and snap accounts,
@@ -264,21 +296,8 @@ export class AccountsController extends BaseController {
             };
             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 = '';
-                }
-            }
+        __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_update).call(this, (state) => {
+            state.internalAccounts.accounts = accounts;
         });
     }
     /**
@@ -321,7 +340,12 @@ export class AccountsController extends BaseController {
         return `${keyringName} ${index}`;
     }
 }
-_AccountsController_instances = new WeakSet(), _AccountsController_generateInternalAccountForNonSnapAccount = function _AccountsController_generateInternalAccountForNonSnapAccount(address, type) {
+_AccountsController_instances = new WeakSet(), _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_generateInternalAccountForNonSnapAccount = function _AccountsController_generateInternalAccountForNonSnapAccount(address, type) {
     return {
         id: getUUIDFromAddressOfNormalAccount(address),
         address,
@@ -344,6 +368,11 @@ _AccountsController_instances = new WeakSet(), _AccountsController_generateInter
             },
         },
     };
+}, _AccountsController_getSnapKeyring = function _AccountsController_getSnapKeyring() {
+    const [snapKeyring] = this.messagingSystem.call('KeyringController:getKeyringsByType', 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_listSnapAccounts = 
 /**
  * Returns a list of internal accounts created using the SnapKeyring.
@@ -351,13 +380,11 @@ _AccountsController_instances = new WeakSet(), _AccountsController_generateInter
  * @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) {
+    const keyring = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getSnapKeyring).call(this);
+    if (!keyring) {
         return [];
     }
-    const snapAccounts = snapKeyring.listAccounts();
-    return snapAccounts;
+    return keyring.listAccounts();
 }, _AccountsController_listNormalAccounts = 
 /**
  * Returns a list of normal accounts.
@@ -368,20 +395,30 @@ async function _AccountsController_listSnapAccounts() {
  */
 async function _AccountsController_listNormalAccounts() {
     const internalAccounts = [];
-    const { keyrings } = await this.messagingSystem.call('KeyringController:getState');
-    for (const keyring of keyrings) {
+    const { keyrings, keyringsMetadata } = this.messagingSystem.call('KeyringController:getState');
+    for (const [keyringIndex, keyring] of keyrings.entries()) {
         const keyringType = keyring.type;
         if (!isNormalKeyringType(keyringType)) {
             // We only consider "normal accounts" here, so keep looping
             continue;
         }
-        for (const address of keyring.accounts) {
+        for (const [accountIndex, address] of keyring.accounts.entries()) {
             const id = getUUIDFromAddressOfNormalAccount(address);
+            let options = {};
+            if (isHdKeyringType(keyring.type)) {
+                options = {
+                    entropySource: keyringsMetadata[keyringIndex].id,
+                    // 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.
+                    derivationPath: getDerivationPathForIndex(accountIndex),
+                };
+            }
             const nameLastUpdatedAt = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, id, 'nameLastUpdatedAt');
             internalAccounts.push({
                 id,
                 address,
-                options: {},
+                options,
                 methods: [
                     EthMethod.PersonalSign,
                     EthMethod.Sign,
@@ -407,122 +444,178 @@ async function _AccountsController_listNormalAccounts() {
     return internalAccounts;
 }, _AccountsController_handleOnSnapKeyringAccountEvent = function _AccountsController_handleOnSnapKeyringAccountEvent(event, ...payload) {
     this.messagingSystem.publish(event, ...payload);
-}, _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
+}, _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 (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,
-                    };
-                }));
-            }
+    if (!isUnlocked || keyrings.length === 0) {
+        return;
+    }
+    // State patches.
+    const generatePatch = () => {
+        return {
+            previous: {},
+            added: [],
+            updated: [],
+            removed: [],
+        };
+    };
+    const patches = {
+        snap: generatePatch(),
+        normal: generatePatch(),
+    };
+    // Gets the patch object based on the keyring type (since Snap accounts and other accounts
+    // are handled differently).
+    const patchOf = (type) => {
+        if (type === KeyringTypes.snap) {
+            return patches.snap;
         }
-        const { previousNormalInternalAccounts, previousSnapInternalAccounts } = this.listMultichainAccounts().reduce((accumulator, account) => {
-            if (account.metadata.keyring.type === KeyringTypes.snap) {
-                accumulator.previousSnapInternalAccounts.push(account);
+        return patches.normal;
+    };
+    // Create a map (with lower-cased addresses) of all existing accounts.
+    for (const account of this.listMultichainAccounts()) {
+        const address = account.address.toLowerCase();
+        const patch = patchOf(account.metadata.keyring.type);
+        patch.previous[address] = account;
+    }
+    // Go over all keyring changes and create patches out of it.
+    const addresses = new Set();
+    for (const keyring of keyrings) {
+        const patch = patchOf(keyring.type);
+        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 {
-                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);
+                // Otherwise, that's a new account.
+                patch.added.push({
+                    address,
+                    type: keyring.type,
+                });
             }
+            // Keep track of those address to check for removed accounts later.
+            addresses.add(address);
         }
-        // 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);
+    }
+    // We might have accounts associated with removed keyrings, so we iterate
+    // over all previous known accounts and check against the keyring addresses.
+    for (const patch of [patches.snap, patches.normal]) {
+        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);
             }
         }
-        // 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);
+    }
+    // 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 } = state;
+        for (const patch of [patches.snap, patches.normal]) {
+            for (const account of patch.removed) {
+                delete internalAccounts.accounts[account.id];
+                diff.removed.push(account.id);
             }
-        }
-        // 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);
+            for (const added of patch.added) {
+                const account = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getInternalAccountFromAddressAndType).call(this, added.address, added.type);
+                if (account) {
+                    // Re-compute the list of accounts everytime, so we can make sure new names
+                    // are also considered.
+                    const accounts = Object.values(internalAccounts.accounts);
+                    // Get next account name available for this given keyring.
+                    const name = this.getNextAvailableAccountName(account.metadata.keyring.type, 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,
+                            name,
+                            importTime: Date.now(),
+                            lastSelected,
+                        },
+                    };
+                    diff.added.push(internalAccounts.accounts[account.id]);
+                }
             }
         }
-        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);
-                }
+    });
+    // Now publish events
+    for (const id of diff.removed) {
+        this.messagingSystem.publish('AccountsController:accountRemoved', id);
+    }
+    for (const account of diff.added) {
+        this.messagingSystem.publish('AccountsController:accountAdded', account);
+    }
+    // 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) {
+    // 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);
             }
-            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);
-                }
+            else {
+                // It will be undefined if there are no accounts.
+                internalAccounts.selectedAccount = '';
             }
-            // 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 = '';
-                }
+        }
+    });
+    // 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 (isEvmAccountType(account.type)) {
+                this.messagingSystem.publish('AccountsController:selectedEvmAccountChange', account);
             }
-        });
+            this.messagingSystem.publish('AccountsController:selectedAccountChange', account);
+        }
     }
 }, _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;
+    const accounts = [];
+    for (const account of this.listMultichainAccounts()) {
+        if (account.metadata.snap) {
+            const snap = snaps[account.metadata.snap.id];
+            const enabled = snap.enabled && !snap.blocked;
+            const metadata = account.metadata.snap;
+            if (metadata.enabled !== enabled) {
+                accounts.push({ id: account.id, enabled });
+            }
+        }
+    }
+    if (accounts.length > 0) {
+        this.update((state) => {
+            for (const { id, enabled } of accounts) {
+                const account = state.internalAccounts.accounts[id];
+                if (account.metadata.snap) {
+                    account.metadata.snap.enabled = enabled;
                 }
             }
         });
-    });
+    }
 }, _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
@@ -545,43 +638,18 @@ async function _AccountsController_listNormalAccounts() {
     // 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;
+}, _AccountsController_getInternalAccountFromAddressAndType = function _AccountsController_getInternalAccountFromAddressAndType(address, type) {
+    if (type === KeyringTypes.snap) {
+        const keyring = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getSnapKeyring).call(this);
+        // We need the Snap keyring to retrieve the account from its address.
+        if (!keyring) {
+            return undefined;
         }
+        // This might be undefined if the Snap deleted the account before
+        // reaching that point.
+        return keyring.getAccountByAddress(address);
     }
-    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;
+    return __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_generateInternalAccountForNonSnapAccount).call(this, address, type);
 }, _AccountsController_handleOnMultichainNetworkDidChange = function _AccountsController_handleOnMultichainNetworkDidChange(id) {
     let accountId;
     // We only support non-EVM Caip chain IDs at the moment. Ex Solana and Bitcoin
@@ -619,6 +687,7 @@ async function _AccountsController_listNormalAccounts() {
     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}:setAccountNameAndSelectAccount`, this.setAccountNameAndSelectAccount.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));