@metamask-previews/accounts-controller 31.0.0-preview-97b5829f → 31.0.0-preview-feec3582

package/CHANGELOG.md

@@ -9,7 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- Use new typed `KeyringAccount.options` for BIP-44 compatible accounts ([#6122](https://github.com/MetaMask/core/pull/6122)), ([#6147](https://github.com/MetaMask/core/pull/6147))
+- Add `groupIndex` to EVM HD account options ([#6122](https://github.com/MetaMask/core/pull/6122))
 
 ### Changed
 

package/dist/AccountsController.cjs

@@ -4,7 +4,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_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;
+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;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AccountsController = exports.EMPTY_ACCOUNT = void 0;
 const base_controller_1 = require("@metamask/base-controller");
@@ -269,44 +269,38 @@ class AccountsController extends base_controller_1.BaseController {
      * @returns A Promise that resolves when the accounts have been updated.
      */
     async updateAccounts() {
-        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 = (0, utils_2.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;
-                }
-                const keyringAccountIndex = keyringAccountIndexes.get(keyringTypeName) ?? 0;
-                if (keyringAccountIndex) {
-                    keyringAccountIndexes.set(keyringTypeName, keyringAccountIndex + 1);
-                }
-                else {
-                    keyringAccountIndexes.set(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 + 1}`,
-                        importTime: existingAccount?.metadata.importTime ?? Date.now(),
-                        lastSelected: existingAccount?.metadata.lastSelected ?? 0,
-                    },
-                };
+        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 = (0, utils_2.keyringTypeToName)(internalAccount.metadata.keyring.type);
+            const keyringAccountIndex = keyringTypes.get(keyringTypeName) ?? 0;
+            if (keyringAccountIndex) {
+                keyringTypes.set(keyringTypeName, keyringAccountIndex + 1);
             }
-        }
+            else {
+                keyringTypes.set(keyringTypeName, 1);
+            }
+            const existingAccount = previousAccounts[internalAccount.id];
+            internalAccountMap[internalAccount.id] = {
+                ...internalAccount,
+                metadata: {
+                    ...internalAccount.metadata,
+                    name: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, existingAccount?.id, 'name') ??
+                        `${keyringTypeName} ${keyringAccountIndex + 1}`,
+                    importTime: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, existingAccount?.id, 'importTime') ?? Date.now(),
+                    lastSelected: __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, existingAccount?.id, 'lastSelected') ?? 0,
+                },
+            };
+            return internalAccountMap;
+        }, {});
         __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_update).call(this, (state) => {
-            state.internalAccounts.accounts = internalAccounts;
+            state.internalAccounts.accounts = accounts;
         });
     }
     /**
@@ -355,63 +349,11 @@ _AccountsController_instances = new WeakSet(), _AccountsController_assertAccount
         internalAccount.id !== account.id)) {
         throw new Error('Account name already exists');
     }
-}, _AccountsController_getInternalAccountForNonSnapAccount = function _AccountsController_getInternalAccountForNonSnapAccount(address, keyring) {
-    const id = (0, utils_2.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 ((0, utils_2.isHdKeyringType)(keyring.type)) {
-        // We need to find the account index from its HD keyring.
-        const groupIndex = (0, utils_2.getGroupIndexFromAddressIndex)(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 = (0, utils_2.getDerivationPathForIndex)(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: keyring_api_1.KeyringAccountEntropyTypeOption.Mnemonic,
-                    id: keyring.metadata.id,
-                    derivationPath,
-                    groupIndex,
-                },
-            };
-            options = {
-                ...legacyOptions,
-                ...entropyOptions,
-            };
-        }
-    }
+}, _AccountsController_generateInternalAccountForNonSnapAccount = function _AccountsController_generateInternalAccountForNonSnapAccount(address, type) {
     return {
-        id,
+        id: (0, utils_2.getUUIDFromAddressOfNormalAccount)(address),
         address,
-        options,
+        options: {},
         methods: [
             keyring_api_1.EthMethod.PersonalSign,
             keyring_api_1.EthMethod.Sign,
@@ -422,13 +364,90 @@ _AccountsController_instances = new WeakSet(), _AccountsController_assertAccount
         ],
         scopes: [keyring_api_1.EthScope.Eoa],
         type: keyring_api_1.EthAccountType.Eoa,
-        metadata,
+        metadata: {
+            name: '',
+            importTime: Date.now(),
+            keyring: {
+                type,
+            },
+        },
     };
 }, _AccountsController_getSnapKeyring = function _AccountsController_getSnapKeyring() {
     const [snapKeyring] = this.messagingSystem.call('KeyringController:getKeyringsByType', eth_snap_keyring_1.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 (!(0, utils_2.isNormalKeyringType)(keyringType)) {
+            // We only consider "normal accounts" here, so keep looping
+            continue;
+        }
+        for (const [accountIndex, address] of keyring.accounts.entries()) {
+            const id = (0, utils_2.getUUIDFromAddressOfNormalAccount)(address);
+            let options = {};
+            if ((0, utils_2.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: (0, utils_2.getDerivationPathForIndex)(accountIndex),
+                    // Required now for multichain accounts.
+                    groupIndex: accountIndex,
+                };
+            }
+            const nameLastUpdatedAt = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_populateExistingMetadata).call(this, id, 'nameLastUpdatedAt');
+            internalAccounts.push({
+                id,
+                address,
+                options,
+                methods: [
+                    keyring_api_1.EthMethod.PersonalSign,
+                    keyring_api_1.EthMethod.Sign,
+                    keyring_api_1.EthMethod.SignTransaction,
+                    keyring_api_1.EthMethod.SignTypedDataV1,
+                    keyring_api_1.EthMethod.SignTypedDataV3,
+                    keyring_api_1.EthMethod.SignTypedDataV4,
+                ],
+                scopes: [keyring_api_1.EthScope.Eoa],
+                type: keyring_api_1.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, }) {
@@ -455,7 +474,7 @@ _AccountsController_instances = new WeakSet(), _AccountsController_assertAccount
     // Gets the patch object based on the keyring type (since Snap accounts and other accounts
     // are handled differently).
     const patchOf = (type) => {
-        if ((0, utils_2.isSnapKeyringType)(type)) {
+        if (type === keyring_controller_1.KeyringTypes.snap) {
             return patches.snap;
         }
         return patches.normal;
@@ -482,7 +501,11 @@ _AccountsController_instances = new WeakSet(), _AccountsController_assertAccount
                 // Otherwise, that's a new account.
                 patch.added.push({
                     address,
-                    keyring,
+                    type: keyring.type,
+                    // Automatically injects `entropySource` for HD accounts only.
+                    options: keyring.type === keyring_controller_1.KeyringTypes.hd
+                        ? { entropySource: keyring.metadata.id }
+                        : {},
                 });
             }
             // Keep track of those address to check for removed accounts later.
@@ -512,7 +535,7 @@ _AccountsController_instances = new WeakSet(), _AccountsController_assertAccount
                 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.keyring);
+                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.
@@ -529,6 +552,10 @@ _AccountsController_instances = new WeakSet(), _AccountsController_assertAccount
                             importTime: Date.now(),
                             lastSelected,
                         },
+                        options: {
+                            ...account.options,
+                            ...added.options,
+                        },
                     };
                     diff.added.push(internalAccounts.accounts[account.id]);
                 }
@@ -613,9 +640,10 @@ _AccountsController_instances = new WeakSet(), _AccountsController_assertAccount
     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 ((0, utils_2.isHdKeyringType)(keyringType) || (0, utils_2.isSimpleKeyringType)(keyringType)) {
-            return ((0, utils_2.isHdKeyringType)(internalAccount.metadata.keyring.type) ||
-                (0, utils_2.isSimpleKeyringType)(internalAccount.metadata.keyring.type));
+        if (keyringType === keyring_controller_1.KeyringTypes.hd ||
+            keyringType === keyring_controller_1.KeyringTypes.simple) {
+            return (internalAccount.metadata.keyring.type === keyring_controller_1.KeyringTypes.hd ||
+                internalAccount.metadata.keyring.type === keyring_controller_1.KeyringTypes.simple);
         }
         return internalAccount.metadata.keyring.type === keyringType;
     });
@@ -630,40 +658,18 @@ _AccountsController_instances = new WeakSet(), _AccountsController_assertAccount
     // 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, keyring) {
-    if ((0, utils_2.isSnapKeyringType)(keyring.type)) {
-        const snapKeyring = __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getSnapKeyring).call(this);
+}, _AccountsController_getInternalAccountFromAddressAndType = function _AccountsController_getInternalAccountFromAddressAndType(address, type) {
+    if (type === keyring_controller_1.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 (!snapKeyring) {
+        if (!keyring) {
             return undefined;
         }
         // This might be undefined if the Snap deleted the account before
         // reaching that point.
-        const account = snapKeyring.getAccountByAddress(address);
-        if (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 ((0, utils_2.isHdSnapKeyringAccount)(account)) {
-                const options = {
-                    ...account.options,
-                    entropy: {
-                        type: keyring_api_1.KeyringAccountEntropyTypeOption.Mnemonic,
-                        id: account.options.entropySource,
-                        groupIndex: account.options.index,
-                        derivationPath: account.options.derivationPath,
-                    },
-                };
-                // We need to type cast the `account` cause it's now typed as
-                // a "HD Snap account" which as very specific options (which
-                // are not typed the same way on `KeyringAccountOptions`.
-                account.options = options;
-            }
-        }
-        return account;
+        return keyring.getAccountByAddress(address);
     }
-    return __classPrivateFieldGet(this, _AccountsController_instances, "m", _AccountsController_getInternalAccountForNonSnapAccount).call(this, address, keyring);
+    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
@@ -685,6 +691,9 @@ _AccountsController_instances = new WeakSet(), _AccountsController_assertAccount
         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));