@metamask-previews/account-tree-controller 1.3.0-preview-a5441fae → 1.3.0-preview-683bbcb0

package/CHANGELOG.md

@@ -9,6 +9,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- Re-introduce computed names for account groups ([#6758](https://github.com/MetaMask/core/pull/6758))
+  - Those names are computed using the old internal account names, allowing to automatically migrate them.
+  - We only consider EVM account names.
+  - This automatically handles conflicting names, similarly to backup & sync (adding a suffix ` (n)` in case of conflicts.
 - Bump `@metamask/utils` from `^11.8.0` to `^11.8.1` ([#6708](https://github.com/MetaMask/core/pull/6708))
 
 ## [1.3.0]

package/dist/AccountTreeController.cjs

@@ -10,7 +10,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 _AccountTreeController_instances, _AccountTreeController_accountIdToContext, _AccountTreeController_groupIdToWalletId, _AccountTreeController_backupAndSyncService, _AccountTreeController_rules, _AccountTreeController_trace, _AccountTreeController_backupAndSyncConfig, _AccountTreeController_initialized, _AccountTreeController_getEntropyRule, _AccountTreeController_getSnapRule, _AccountTreeController_getKeyringRule, _AccountTreeController_applyAccountWalletMetadata, _AccountTreeController_getRuleForWallet, _AccountTreeController_applyAccountGroupMetadata, _AccountTreeController_handleAccountAdded, _AccountTreeController_handleAccountRemoved, _AccountTreeController_pruneEmptyGroupAndWallet, _AccountTreeController_insert, _AccountTreeController_listAccounts, _AccountTreeController_assertAccountGroupExists, _AccountTreeController_assertAccountWalletExists, _AccountTreeController_assertAccountGroupNameIsUnique, _AccountTreeController_getDefaultSelectedAccountGroup, _AccountTreeController_handleMultichainAccountWalletStatusChange, _AccountTreeController_getAccountGroup, _AccountTreeController_getDefaultAccountFromAccountGroupId, _AccountTreeController_getDefaultAccountGroupId, _AccountTreeController_registerMessageHandlers, _AccountTreeController_createBackupAndSyncContext;
+var _AccountTreeController_instances, _AccountTreeController_accountIdToContext, _AccountTreeController_groupIdToWalletId, _AccountTreeController_backupAndSyncService, _AccountTreeController_rules, _AccountTreeController_trace, _AccountTreeController_backupAndSyncConfig, _AccountTreeController_initialized, _AccountTreeController_getEntropyRule, _AccountTreeController_getSnapRule, _AccountTreeController_getKeyringRule, _AccountTreeController_applyAccountWalletMetadata, _AccountTreeController_getRuleForWallet, _AccountTreeController_getComputedAccountGroupName, _AccountTreeController_getDefaultAccountGroupName, _AccountTreeController_applyAccountGroupMetadata, _AccountTreeController_handleAccountAdded, _AccountTreeController_handleAccountRemoved, _AccountTreeController_pruneEmptyGroupAndWallet, _AccountTreeController_insert, _AccountTreeController_listAccounts, _AccountTreeController_assertAccountGroupExists, _AccountTreeController_assertAccountWalletExists, _AccountTreeController_assertAccountGroupNameIsUnique, _AccountTreeController_getDefaultSelectedAccountGroup, _AccountTreeController_handleSelectedAccountChange, _AccountTreeController_handleMultichainAccountWalletStatusChange, _AccountTreeController_getAccountGroup, _AccountTreeController_getDefaultAccountFromAccountGroupId, _AccountTreeController_getDefaultAccountGroupId, _AccountTreeController_registerMessageHandlers, _AccountTreeController_createBackupAndSyncContext;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AccountTreeController = exports.getDefaultAccountTreeControllerState = exports.controllerName = void 0;
 const account_api_1 = require("@metamask/account-api");
@@ -137,6 +137,9 @@ class AccountTreeController extends base_controller_1.BaseController {
         this.messagingSystem.subscribe('AccountsController:accountRemoved', (accountId) => {
             __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_handleAccountRemoved).call(this, accountId);
         });
+        this.messagingSystem.subscribe('AccountsController:selectedAccountChange', (account) => {
+            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_handleSelectedAccountChange).call(this, account);
+        });
         this.messagingSystem.subscribe('UserStorageController:stateChange', (userStorageControllerState) => {
             __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").handleUserStorageStateChange(userStorageControllerState);
         });
@@ -192,16 +195,22 @@ class AccountTreeController extends base_controller_1.BaseController {
                 // Used for default group default names (so we use human-indexing here).
                 let nextNaturalNameIndex = 1;
                 for (const group of Object.values(wallet.groups)) {
-                    __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_applyAccountGroupMetadata).call(this, state, wallet.id, group.id, 
-                    // FIXME: We should not need this kind of logic if we were not inserting accounts
-                    // 1 by 1. Instead, we should be inserting wallets and groups directly. This would
-                    // allow us to naturally insert a group in the tree AND update its metadata right
-                    // away...
-                    // But here, we have to wait for the entire group to be ready before updating
-                    // its metadata (mainly because we're dealing with single accounts rather than entire
-                    // groups).
-                    // That is why we need this kind of extra parameter.
-                    nextNaturalNameIndex);
+                    __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_applyAccountGroupMetadata).call(this, state, wallet.id, group.id, {
+                        // We allow computed name when initializing the tree.
+                        // This will automatically handle account name migration for the very first init of the
+                        // tree. Once groups are created, their name will be persisted, thus, taking precedence
+                        // over the computed names (even if we re-init).
+                        allowComputedName: true,
+                        // FIXME: We should not need this kind of logic if we were not inserting accounts
+                        // 1 by 1. Instead, we should be inserting wallets and groups directly. This would
+                        // allow us to naturally insert a group in the tree AND update its metadata right
+                        // away...
+                        // But here, we have to wait for the entire group to be ready before updating
+                        // its metadata (mainly because we're dealing with single accounts rather than entire
+                        // groups).
+                        // That is why we need this kind of extra parameter.
+                        nextNaturalNameIndex,
+                    });
                     if (group.id === previousSelectedAccountGroup) {
                         previousSelectedAccountGroupStillExists = true;
                     }
@@ -584,7 +593,82 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
         default:
             return __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getKeyringRule).call(this);
     }
-}, _AccountTreeController_applyAccountGroupMetadata = function _AccountTreeController_applyAccountGroupMetadata(state, walletId, groupId, nextNaturalNameIndex) {
+}, _AccountTreeController_getComputedAccountGroupName = function _AccountTreeController_getComputedAccountGroupName(wallet, group) {
+    let proposedName = ''; // Empty means there's no computed name for this group.
+    for (const id of group.accounts) {
+        const account = this.messagingSystem.call('AccountsController:getAccount', id);
+        if (!account) {
+            continue;
+        }
+        // We only consider EVM account types for computed names.
+        if ((0, keyring_api_1.isEvmAccountType)(account.type) && account.metadata.name.length) {
+            proposedName = account.metadata.name;
+            break;
+        }
+    }
+    // If this name already exists for whatever reason, we rename it to resolve this conflict.
+    if (proposedName.length &&
+        !(0, group_1.isAccountGroupNameUniqueFromWallet)(wallet, group.id, proposedName)) {
+        proposedName = this.resolveNameConflict(wallet, group.id, proposedName);
+    }
+    return proposedName;
+}, _AccountTreeController_getDefaultAccountGroupName = function _AccountTreeController_getDefaultAccountGroupName(state, wallet, group, nextNaturalNameIndex) {
+    // Get the appropriate rule for this wallet type
+    const rule = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getRuleForWallet).call(this, wallet);
+    // Get the prefix for groups of this wallet
+    const namePrefix = rule.getDefaultAccountGroupPrefix(wallet);
+    // Parse the highest account index being used (similar to accounts-controller)
+    let highestNameIndex = 0;
+    for (const { id: otherGroupId } of Object.values(wallet.groups)) {
+        // Skip the current group being processed
+        if (otherGroupId === group.id) {
+            continue;
+        }
+        // We always get the name from the persisted map, since `init` will clear the
+        // `state.accountTree.wallets`, thus, given empty `group.metadata.name`.
+        // NOTE: If the other group has not been named yet, we just use an empty name.
+        const otherGroupName = state.accountGroupsMetadata[otherGroupId]?.name?.value ?? '';
+        // Parse the existing group name to extract the numeric index
+        const nameMatch = otherGroupName.match(/account\s+(\d+)$/iu);
+        if (nameMatch) {
+            const nameIndex = parseInt(nameMatch[1], 10);
+            if (nameIndex > highestNameIndex) {
+                highestNameIndex = nameIndex;
+            }
+        }
+    }
+    // We just use the highest known index no matter the wallet type.
+    //
+    // For entropy-based wallets (bip44), if a multichain account group with group index 1
+    // is inserted before another one with group index 0, then the naming will be:
+    // - "Account 1" (group index 1)
+    // - "Account 2" (group index 0)
+    // This naming makes more sense for the end-user.
+    //
+    // For other type of wallets, since those wallets can create arbitrary gaps, we still
+    // rely on the highest know index to avoid back-filling account with "old names".
+    let proposedNameIndex = Math.max(
+    // Use + 1 to use the next available index.
+    highestNameIndex + 1, 
+    // In case all accounts have been renamed differently than the usual "Account <index>"
+    // pattern, we want to use the next "natural" index, which is just the number of groups
+    // in that wallet (e.g. ["Account A", "Another Account"], next natural index would be
+    // "Account 3" in this case).
+    nextNaturalNameIndex ?? Object.keys(wallet.groups).length);
+    // Find a unique name by checking for conflicts and incrementing if needed
+    let proposedNameExists;
+    let proposedName = '';
+    do {
+        proposedName = `${namePrefix} ${proposedNameIndex}`;
+        // Check if this name already exists in the wallet (excluding current group)
+        proposedNameExists = !(0, group_1.isAccountGroupNameUniqueFromWallet)(wallet, group.id, proposedName);
+        /* istanbul ignore next */
+        if (proposedNameExists) {
+            proposedNameIndex += 1; // Try next number
+        }
+    } while (proposedNameExists);
+    return proposedName;
+}, _AccountTreeController_applyAccountGroupMetadata = function _AccountTreeController_applyAccountGroupMetadata(state, walletId, groupId, { allowComputedName, nextNaturalNameIndex, } = {}) {
     var _a;
     const wallet = state.accountTree.wallets[walletId];
     const group = wallet.groups[groupId];
@@ -595,62 +679,16 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
             persistedGroupMetadata.name.value;
     }
     else if (!group.metadata.name) {
-        // Get the appropriate rule for this wallet type
-        const rule = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getRuleForWallet).call(this, wallet);
-        // Get the prefix for groups of this wallet
-        const namePrefix = rule.getDefaultAccountGroupPrefix(wallet);
-        // Skip computed names for now - use default naming with per-wallet logic
-        // TODO: Implement computed names in a future iteration
-        // Parse the highest account index being used (similar to accounts-controller)
-        let highestNameIndex = 0;
-        for (const { id: otherGroupId } of Object.values(wallet.groups)) {
-            // Skip the current group being processed
-            if (otherGroupId === groupId) {
-                continue;
-            }
-            // We always get the name from the persisted map, since `init` will clear the
-            // `state.accountTree.wallets`, thus, given empty `group.metadata.name`.
-            // NOTE: If the other group has not been named yet, we just use an empty name.
-            const otherGroupName = state.accountGroupsMetadata[otherGroupId]?.name?.value ?? '';
-            // Parse the existing group name to extract the numeric index
-            const nameMatch = otherGroupName.match(/account\s+(\d+)$/iu);
-            if (nameMatch) {
-                const nameIndex = parseInt(nameMatch[1], 10);
-                if (nameIndex > highestNameIndex) {
-                    highestNameIndex = nameIndex;
-                }
-            }
-        }
-        // We just use the highest known index no matter the wallet type.
-        //
-        // For entropy-based wallets (bip44), if a multichain account group with group index 1
-        // is inserted before another one with group index 0, then the naming will be:
-        // - "Account 1" (group index 1)
-        // - "Account 2" (group index 0)
-        // This naming makes more sense for the end-user.
-        //
-        // For other type of wallets, since those wallets can create arbitrary gaps, we still
-        // rely on the highest know index to avoid back-filling account with "old names".
-        let proposedNameIndex = Math.max(
-        // Use + 1 to use the next available index.
-        highestNameIndex + 1, 
-        // In case all accounts have been renamed differently than the usual "Account <index>"
-        // pattern, we want to use the next "natural" index, which is just the number of groups
-        // in that wallet (e.g. ["Account A", "Another Account"], next natural index would be
-        // "Account 3" in this case).
-        nextNaturalNameIndex ?? Object.keys(wallet.groups).length);
-        // Find a unique name by checking for conflicts and incrementing if needed
-        let proposedNameExists;
         let proposedName = '';
-        do {
-            proposedName = `${namePrefix} ${proposedNameIndex}`;
-            // Check if this name already exists in the wallet (excluding current group)
-            proposedNameExists = !(0, group_1.isAccountGroupNameUniqueFromWallet)(wallet, group.id, proposedName);
-            /* istanbul ignore next */
-            if (proposedNameExists) {
-                proposedNameIndex += 1; // Try next number
-            }
-        } while (proposedNameExists);
+        // Computed names are usually only used for existing/old accounts. So this option
+        // should be used only when we first initialize the tree.
+        if (allowComputedName) {
+            proposedName = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getComputedAccountGroupName).call(this, wallet, group);
+        }
+        // If we still don't have a valid name candidate, we fallback to a default name.
+        if (!proposedName.length) {
+            proposedName = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getDefaultAccountGroupName).call(this, state, wallet, group, nextNaturalNameIndex);
+        }
         state.accountTree.wallets[walletId].groups[groupId].metadata.name =
             proposedName;
         (0, logger_1.projectLogger)(`[${group.id}] Set default name to: "${group.metadata.name}"`);
@@ -849,6 +887,23 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
     }
     // Default to the default group in case of errors.
     return __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getDefaultAccountGroupId).call(this, wallets);
+}, _AccountTreeController_handleSelectedAccountChange = function _AccountTreeController_handleSelectedAccountChange(account) {
+    const accountMapping = __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").get(account.id);
+    if (!accountMapping) {
+        // Account not in tree yet, might be during initialization
+        return;
+    }
+    const { groupId } = accountMapping;
+    const previousSelectedAccountGroup = this.state.accountTree.selectedAccountGroup;
+    // Idempotent check - if the same group is already selected, do nothing
+    if (previousSelectedAccountGroup === groupId) {
+        return;
+    }
+    // Update selectedAccountGroup to match the selected account
+    this.update((state) => {
+        state.accountTree.selectedAccountGroup = groupId;
+    });
+    this.messagingSystem.publish(`${exports.controllerName}:selectedAccountGroupChange`, groupId, previousSelectedAccountGroup);
 }, _AccountTreeController_handleMultichainAccountWalletStatusChange = function _AccountTreeController_handleMultichainAccountWalletStatusChange(walletId, walletStatus) {
     this.update((state) => {
         const wallet = state.accountTree.wallets[walletId];