@metamask/accounts-controller 31.0.0 → 32.0.1

package/dist/AccountsController.mjs

@@ -3,14 +3,16 @@ 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_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;
+var _AccountsController_instances, _AccountsController_assertAccountCanBeRenamed, _AccountsController_getInternalAccountForNonSnapAccount, _AccountsController_getSnapKeyring, _AccountsController_handleOnSnapKeyringAccountEvent, _AccountsController_handleOnKeyringStateChange, _AccountsController_update, _AccountsController_handleOnSnapStateChange, _AccountsController_getAccountsByKeyringType, _AccountsController_getLastSelectedAccount, _AccountsController_getLastSelectedIndex, _AccountsController_getInternalAccountFromAddressAndType, _AccountsController_handleOnMultichainNetworkDidChange, _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 { EthAccountType, EthMethod, EthScope, isEvmAccountType, KeyringAccountEntropyTypeOption } from "@metamask/keyring-api";
 import { KeyringTypes } from "@metamask/keyring-controller";
 import { isScopeEqualToAny } from "@metamask/keyring-utils";
 import { isCaipChainId } from "@metamask/utils";
-import { getDerivationPathForIndex, getUUIDFromAddressOfNormalAccount, isHdKeyringType, isNormalKeyringType, keyringTypeToName } from "./utils.mjs";
+import $lodash from "lodash";
+const { cloneDeep } = $lodash;
+import { getEvmDerivationPathForIndex, getEvmGroupIndexFromAddressIndex, getUUIDFromAddressOfNormalAccount, isHdKeyringType, isHdSnapKeyringAccount, isSimpleKeyringType, isSnapKeyringType, keyringTypeToName } from "./utils.mjs";
 const controllerName = 'AccountsController';
 const accountsControllerMetadata = {
     internalAccounts: {
@@ -266,38 +268,41 @@ export class AccountsController extends BaseController {
      * @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 keyringAccountIndexes = new Map();
+        const existingInternalAccounts = this.state.internalAccounts.accounts;
+        const internalAccounts = {};
+        const { keyrings } = this.messagingSystem.call('KeyringController:getState');
+        for (const keyring of keyrings) {
+            const keyringTypeName = keyringTypeToName(keyring.type);
+            for (const address of keyring.accounts) {
+                const internalAccount = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getInternalAccountFromAddressAndType).call(this, address, keyring);
+                // This should never really happen, but if for some reason we're not
+                // able to get the Snap keyring reference, this would return an
+                // undefined account.
+                // So we just skip it, even though, this should not really happen.
+                if (!internalAccount) {
+                    continue;
+                }
+                // Get current index for this keyring (we use human indexing, so start at 1).
+                const keyringAccountIndex = keyringAccountIndexes.get(keyringTypeName) ?? 1;
+                const existingAccount = existingInternalAccounts[internalAccount.id];
+                internalAccounts[internalAccount.id] = {
+                    ...internalAccount,
+                    metadata: {
+                        ...internalAccount.metadata,
+                        // Re-use existing metadata if any.
+                        name: existingAccount?.metadata.name ??
+                            `${keyringTypeName} ${keyringAccountIndex}`,
+                        importTime: existingAccount?.metadata.importTime ?? Date.now(),
+                        lastSelected: existingAccount?.metadata.lastSelected ?? 0,
+                    },
+                };
+                // Increment the account index for this keyring.
+                keyringAccountIndexes.set(keyringTypeName, keyringAccountIndex + 1);
             }
-            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;
-        }, {});
+        }
         __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_update).call(this, (state) => {
-            state.internalAccounts.accounts = accounts;
+            state.internalAccounts.accounts = internalAccounts;
         });
     }
     /**
@@ -345,11 +350,63 @@ _AccountsController_instances = new WeakSet(), _AccountsController_assertAccount
         internalAccount.id !== account.id)) {
         throw new Error('Account name already exists');
     }
-}, _AccountsController_generateInternalAccountForNonSnapAccount = function _AccountsController_generateInternalAccountForNonSnapAccount(address, type) {
+}, _AccountsController_getInternalAccountForNonSnapAccount = function _AccountsController_getInternalAccountForNonSnapAccount(address, keyring) {
+    const id = getUUIDFromAddressOfNormalAccount(address);
+    // We might have an account for this ID already, so we'll just re-use
+    // the same metadata
+    const account = this.getAccount(id);
+    const metadata = {
+        name: account?.metadata.name ?? '',
+        ...(account?.metadata.nameLastUpdatedAt
+            ? {
+                nameLastUpdatedAt: account?.metadata.nameLastUpdatedAt,
+            }
+            : {}),
+        importTime: account?.metadata.importTime ?? Date.now(),
+        lastSelected: account?.metadata.lastSelected ?? 0,
+        keyring: {
+            type: keyring.type,
+        },
+    };
+    let options = {};
+    if (isHdKeyringType(keyring.type)) {
+        // We need to find the account index from its HD keyring.
+        const groupIndex = getEvmGroupIndexFromAddressIndex(keyring, address);
+        // If for some reason, we cannot find this address, then the caller made a mistake
+        // and it did not use the proper keyring object. For now, we do not fail and just
+        // consider this account as "simple account".
+        if (groupIndex !== undefined) {
+            // NOTE: We are not using the `hdPath` from the associated keyring here and
+            // getting the keyring instance here feels a bit overkill.
+            // This will be naturally fixed once every keyring start using `KeyringAccount` and implement the keyring API.
+            const derivationPath = getEvmDerivationPathForIndex(groupIndex);
+            // Those are "legacy options" and they were used before `KeyringAccount` added
+            // support for type options. We keep those temporarily until we update everything
+            // to use the new typed options.
+            const legacyOptions = {
+                entropySource: keyring.metadata.id,
+                derivationPath,
+                groupIndex,
+            };
+            // New typed entropy options. This is required for multichain accounts.
+            const entropyOptions = {
+                entropy: {
+                    type: KeyringAccountEntropyTypeOption.Mnemonic,
+                    id: keyring.metadata.id,
+                    derivationPath,
+                    groupIndex,
+                },
+            };
+            options = {
+                ...legacyOptions,
+                ...entropyOptions,
+            };
+        }
+    }
     return {
-        id: getUUIDFromAddressOfNormalAccount(address),
+        id,
         address,
-        options: {},
+        options,
         methods: [
             EthMethod.PersonalSign,
             EthMethod.Sign,
@@ -360,88 +417,13 @@ _AccountsController_instances = new WeakSet(), _AccountsController_assertAccount
         ],
         scopes: [EthScope.Eoa],
         type: EthAccountType.Eoa,
-        metadata: {
-            name: '',
-            importTime: Date.now(),
-            keyring: {
-                type,
-            },
-        },
+        metadata,
     };
 }, _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.
- *
- * @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) {
-        return [];
-    }
-    return keyring.listAccounts();
-}, _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 internalAccounts = [];
-    const { keyrings } = this.messagingSystem.call('KeyringController:getState');
-    for (const keyring of keyrings) {
-        const keyringType = keyring.type;
-        if (!isNormalKeyringType(keyringType)) {
-            // We only consider "normal accounts" here, so keep looping
-            continue;
-        }
-        for (const [accountIndex, address] of keyring.accounts.entries()) {
-            const id = getUUIDFromAddressOfNormalAccount(address);
-            let options = {};
-            if (isHdKeyringType(keyring.type)) {
-                options = {
-                    entropySource: keyring.metadata.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,
-                methods: [
-                    EthMethod.PersonalSign,
-                    EthMethod.Sign,
-                    EthMethod.SignTransaction,
-                    EthMethod.SignTypedDataV1,
-                    EthMethod.SignTypedDataV3,
-                    EthMethod.SignTypedDataV4,
-                ],
-                scopes: [EthScope.Eoa],
-                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: keyringType,
-                    },
-                },
-            });
-        }
-    }
-    return internalAccounts;
 }, _AccountsController_handleOnSnapKeyringAccountEvent = function _AccountsController_handleOnSnapKeyringAccountEvent(event, ...payload) {
     this.messagingSystem.publish(event, ...payload);
 }, _AccountsController_handleOnKeyringStateChange = function _AccountsController_handleOnKeyringStateChange({ isUnlocked, keyrings, }) {
@@ -468,7 +450,7 @@ async function _AccountsController_listNormalAccounts() {
     // 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) {
+        if (isSnapKeyringType(type)) {
             return patches.snap;
         }
         return patches.normal;
@@ -495,11 +477,7 @@ async function _AccountsController_listNormalAccounts() {
                 // Otherwise, that's a new account.
                 patch.added.push({
                     address,
-                    type: keyring.type,
-                    // Automatically injects `entropySource` for HD accounts only.
-                    options: keyring.type === KeyringTypes.hd
-                        ? { entropySource: keyring.metadata.id }
-                        : {},
+                    keyring,
                 });
             }
             // Keep track of those address to check for removed accounts later.
@@ -529,7 +507,7 @@ async function _AccountsController_listNormalAccounts() {
                 diff.removed.push(account.id);
             }
             for (const added of patch.added) {
-                const account = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getInternalAccountFromAddressAndType).call(this, added.address, added.type);
+                const account = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getInternalAccountFromAddressAndType).call(this, added.address, added.keyring);
                 if (account) {
                     // Re-compute the list of accounts everytime, so we can make sure new names
                     // are also considered.
@@ -546,10 +524,6 @@ async function _AccountsController_listNormalAccounts() {
                             importTime: Date.now(),
                             lastSelected,
                         },
-                        options: {
-                            ...account.options,
-                            ...added.options,
-                        },
                     };
                     diff.added.push(internalAccounts.accounts[account.id]);
                 }
@@ -634,10 +608,9 @@ async function _AccountsController_listNormalAccounts() {
     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);
+        if (isHdKeyringType(keyringType) || isSimpleKeyringType(keyringType)) {
+            return (isHdKeyringType(internalAccount.metadata.keyring.type) ||
+                isSimpleKeyringType(internalAccount.metadata.keyring.type));
         }
         return internalAccount.metadata.keyring.type === keyringType;
     });
@@ -652,18 +625,40 @@ 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);
+}, _AccountsController_getInternalAccountFromAddressAndType = function _AccountsController_getInternalAccountFromAddressAndType(address, keyring) {
+    if (isSnapKeyringType(keyring.type)) {
+        const snapKeyring = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getSnapKeyring).call(this);
         // We need the Snap keyring to retrieve the account from its address.
-        if (!keyring) {
+        if (!snapKeyring) {
             return undefined;
         }
         // This might be undefined if the Snap deleted the account before
         // reaching that point.
-        return keyring.getAccountByAddress(address);
+        let account = snapKeyring.getAccountByAddress(address);
+        if (account) {
+            // We force the copy here, to avoid mutating the reference returned by the Snap keyring.
+            account = cloneDeep(account);
+            // MIGRATION: To avoid any existing Snap account migration, we are
+            // just "adding" the new typed options that we need for multichain
+            // accounts. Ultimately, we would need a real Snap account migrations
+            // (being handled by each Snaps).
+            if (isHdSnapKeyringAccount(account)) {
+                const options = {
+                    ...account.options,
+                    entropy: {
+                        type: KeyringAccountEntropyTypeOption.Mnemonic,
+                        id: account.options.entropySource,
+                        groupIndex: account.options.index,
+                        derivationPath: account.options.derivationPath,
+                    },
+                };
+                // Inject the new typed options to the internal account copy.
+                account.options = options;
+            }
+        }
+        return account;
     }
-    return __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_generateInternalAccountForNonSnapAccount).call(this, address, type);
+    return __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getInternalAccountForNonSnapAccount).call(this, address, keyring);
 }, _AccountsController_handleOnMultichainNetworkDidChange = function _AccountsController_handleOnMultichainNetworkDidChange(id) {
     let accountId;
     // We only support non-EVM Caip chain IDs at the moment. Ex Solana and Bitcoin
@@ -685,9 +680,6 @@ async function _AccountsController_listNormalAccounts() {
         currentState.internalAccounts.selectedAccount = accountId;
     });
     // DO NOT publish AccountsController:setSelectedAccount to prevent circular listener loops
-}, _AccountsController_populateExistingMetadata = function _AccountsController_populateExistingMetadata(accountId, metadataKey, account) {
-    const internalAccount = account ?? this.getAccount(accountId);
-    return internalAccount ? internalAccount.metadata[metadataKey] : undefined;
 }, _AccountsController_subscribeToMessageEvents = function _AccountsController_subscribeToMessageEvents() {
     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));