@metamask-previews/accounts-controller 27.0.0-preview-aa7690c1 → 27.0.0-preview-b881bfc9

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_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;
+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;
 import { BaseController } from "@metamask/base-controller";
 import { SnapKeyring } from "@metamask/eth-snap-keyring";
 import { EthAccountType, EthMethod, EthScope, isEvmAccountType } from "@metamask/keyring-api";
@@ -123,15 +123,14 @@ 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 (selectedAccount === '') {
+        if (this.state.internalAccounts.selectedAccount === '') {
             return EMPTY_ACCOUNT;
         }
-        const account = this.getAccountExpect(selectedAccount);
-        if (isEvmAccountType(account.type)) {
-            return account;
+        const selectedAccount = this.getAccountExpect(this.state.internalAccounts.selectedAccount);
+        if (isEvmAccountType(selectedAccount.type)) {
+            return selectedAccount;
         }
         const accounts = this.listAccounts();
         if (!accounts.length) {
@@ -151,14 +150,13 @@ 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 (selectedAccount === '') {
+        if (this.state.internalAccounts.selectedAccount === '') {
             return EMPTY_ACCOUNT;
         }
         if (!chainId) {
-            return this.getAccountExpect(selectedAccount);
+            return this.getAccountExpect(this.state.internalAccounts.selectedAccount);
         }
         const accounts = this.listMultichainAccounts(chainId);
         return __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getLastSelectedAccount).call(this, accounts);
@@ -180,11 +178,12 @@ export class AccountsController extends BaseController {
      */
     setSelectedAccount(accountId) {
         const account = this.getAccountExpect(accountId);
-        __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;
+        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.
@@ -214,19 +213,19 @@ export class AccountsController extends BaseController {
                 internalAccount.id !== accountId)) {
             throw new Error('Account name already exists');
         }
-        const internalAccount = {
-            ...account,
-            metadata: { ...account.metadata, ...metadata },
-        };
-        this.update((state) => {
-            // FIXME: Do not remove this comment - This error is flaky: Comment out or restore the `ts-expect-error` directive below as needed.
+        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
-            state.internalAccounts.accounts[accountId] = internalAccount;
+            currentState.internalAccounts.accounts[accountId] = internalAccount;
+            if (metadata.name) {
+                this.messagingSystem.publish('AccountsController:accountRenamed', internalAccount);
+            }
         });
-        if (metadata.name) {
-            this.messagingSystem.publish('AccountsController:accountRenamed', internalAccount);
-        }
     }
     /**
      * Updates the internal accounts list by retrieving normal and snap accounts,
@@ -265,8 +264,21 @@ export class AccountsController extends BaseController {
             };
             return internalAccountMap;
         }, {});
-        __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_update).call(this, (state) => {
-            state.internalAccounts.accounts = accounts;
+        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 = '';
+                }
+            }
         });
     }
     /**
@@ -332,11 +344,6 @@ _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.
@@ -344,11 +351,13 @@ _AccountsController_instances = new WeakSet(), _AccountsController_generateInter
  * @returns A promise that resolves to an array of InternalAccount objects.
  */
 async function _AccountsController_listSnapAccounts() {
-    const keyring = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getSnapKeyring).call(this);
-    if (!keyring) {
+    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 [];
     }
-    return keyring.listAccounts();
+    const snapAccounts = snapKeyring.listAccounts();
+    return snapAccounts;
 }, _AccountsController_listNormalAccounts = 
 /**
  * Returns a list of normal accounts.
@@ -398,153 +407,104 @@ async function _AccountsController_listNormalAccounts() {
     return internalAccounts;
 }, _AccountsController_handleOnSnapKeyringAccountEvent = function _AccountsController_handleOnSnapKeyringAccountEvent(event, ...payload) {
     this.messagingSystem.publish(event, ...payload);
-}, _AccountsController_handleOnKeyringStateChange = function _AccountsController_handleOnKeyringStateChange({ isUnlocked, keyrings, }) {
-    // TODO: Change when accountAdded event is added to the keyring controller.
+}, _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 (!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;
-        }
-        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);
+    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 {
-                // Otherwise, that's a new account.
-                patch.added.push({
-                    address,
-                    type: keyring.type,
-                });
+                updatedNormalKeyringAddresses.push(...keyring.accounts.map((address) => {
+                    return {
+                        address,
+                        type: keyring.type,
+                    };
+                }));
             }
-            // Keep track of those address to check for removed accounts later.
-            addresses.add(address);
         }
-    }
-    // We might have accounts associated with removed keyrings, so we iterate
-    // over all previous known accounts and check against the keyring addresses.
-    for (const 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);
+        const { previousNormalInternalAccounts, previousSnapInternalAccounts } = this.listMultichainAccounts().reduce((accumulator, account) => {
+            if (account.metadata.keyring.type === KeyringTypes.snap) {
+                accumulator.previousSnapInternalAccounts.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);
+            else {
+                accumulator.previousNormalInternalAccounts.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]);
-                }
+            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);
             }
         }
-    });
-    // 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);
+        // 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);
             }
-            else {
-                // It will be undefined if there are no accounts.
-                internalAccounts.selectedAccount = '';
+        }
+        // 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);
             }
         }
-    });
-    // 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);
+        // 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.messagingSystem.publish('AccountsController:selectedAccountChange', 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
@@ -585,18 +545,43 @@ 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_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;
+}, _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;
         }
-        // This might be undefined if the Snap deleted the account before
-        // reaching that point.
-        return keyring.getAccountByAddress(address);
     }
-    return __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_generateInternalAccountForNonSnapAccount).call(this, address, type);
+    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_handleOnMultichainNetworkDidChange = function _AccountsController_handleOnMultichainNetworkDidChange(id) {
     let accountId;
     // We only support non-EVM Caip chain IDs at the moment. Ex Solana and Bitcoin