@metamask-previews/accounts-controller 27.0.0-preview-bf2d2c4c → 27.0.0-preview-8ea9b81f

package/dist/AccountsController.mjs

@@ -3,7 +3,7 @@ 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_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";
@@ -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.
@@ -213,19 +214,19 @@ export class AccountsController extends BaseController {
                 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.
+        const internalAccount = {
+            ...account,
+            metadata: { ...account.metadata, ...metadata },
+        };
+        __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_update).call(this, (state) => {
+            // FIXME: 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);
-            }
+            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 +265,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;
         });
     }
     /**
@@ -344,6 +332,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 +344,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.
@@ -407,104 +398,153 @@ 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
@@ -545,43 +585,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