@metamask-previews/account-tree-controller 1.0.0-preview-5a701133 → 1.2.0-preview-c20b7569

package/CHANGELOG.md

@@ -9,8 +9,43 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
-- Fix group naming for PK/Hardware accounts ([#6677](https://github.com/MetaMask/core/pull/6677))
-  - Previously, the first PK/Hardware account would start as `Account 2` as opposed to `Account 1` and thus subsequent group names were off as well.
+- Prevent `:account{Added,Removed}` to used if `init` has not been called yet ([#6717](https://github.com/MetaMask/core/pull/6717))
+  - We now wait for internal accounts to be fully ready (before `init` gets called).
+  - This should also enforce account group ordering, since all accounts will be ready to consume right away.
+
+## [1.2.0]
+
+### Added
+
+- Add `reinit` method ([#6709](https://github.com/MetaMask/core/pull/6709))
+  - This method can be used if we change the entire list of accounts of the `AccountsController` and want to re-initilize the tree with it.
+
+### Changed
+
+- Implicitly call `init` before mutating the tree ([#6709](https://github.com/MetaMask/core/pull/6709))
+  - This ensure the tree is always using existing accounts before inserting/removing any new accounts if `init` has not been called yet.
+
+### Fixed
+
+- Fix use of unknown `group.metadata.name` when checking for group name uniqueness ([#6706](https://github.com/MetaMask/core/pull/6706))
+- Added logic that prevents an account within a group from being out of order ([#6683](https://github.com/MetaMask/core/pull/6683))
+
+## [1.1.0]
+
+### Changed
+
+- Set the `setAccountGroupName`'s option `autoHandleConflict` to `true` for all backup & sync operations ([#6697](https://github.com/MetaMask/core/pull/6697))
+- Add new group naming for non-HD keyring accounts ([#6679](https://github.com/MetaMask/core/pull/6679)), ([#6696](https://github.com/MetaMask/core/pull/6696))
+  - Hardware-wallet account groups are now named: "Ledger|Trezor|QR|Lattice|OneKey Account N".
+  - Private key account groups are now named: "Imported Account N".
+  - Snap account groups are now named: "Snap Account N".
+- Account group names now use natural indexing as a fallback ([#6677](https://github.com/MetaMask/core/pull/6677)), ([#6679](https://github.com/MetaMask/core/pull/6679)), ([#6696](https://github.com/MetaMask/core/pull/6696))
+  - If a user names his accounts without any indexes, we would just use the number of accounts to compute the next available index.
+
+### Fixed
+
+- Fix group naming for non-HD keyring accounts ([#6677](https://github.com/MetaMask/core/pull/6677)), ([#6679](https://github.com/MetaMask/core/pull/6679))
+  - Previously, the first non-HD keyring account would start as `Account 2` as opposed to `Account 1` and thus subsequent group names were off as well.
 
 ## [1.0.0]
 
@@ -294,7 +329,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Initial release ([#5847](https://github.com/MetaMask/core/pull/5847))
   - Grouping accounts into 3 main categories: Entropy source, Snap ID, keyring types.
 
-[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/account-tree-controller@1.0.0...HEAD
+[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/account-tree-controller@1.2.0...HEAD
+[1.2.0]: https://github.com/MetaMask/core/compare/@metamask/account-tree-controller@1.1.0...@metamask/account-tree-controller@1.2.0
+[1.1.0]: https://github.com/MetaMask/core/compare/@metamask/account-tree-controller@1.0.0...@metamask/account-tree-controller@1.1.0
 [1.0.0]: https://github.com/MetaMask/core/compare/@metamask/account-tree-controller@0.18.1...@metamask/account-tree-controller@1.0.0
 [0.18.1]: https://github.com/MetaMask/core/compare/@metamask/account-tree-controller@0.18.0...@metamask/account-tree-controller@0.18.1
 [0.18.0]: https://github.com/MetaMask/core/compare/@metamask/account-tree-controller@0.17.0...@metamask/account-tree-controller@0.18.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_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_handleSelectedAccountChange, _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_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");
@@ -103,6 +103,9 @@ class AccountTreeController extends base_controller_1.BaseController {
         _AccountTreeController_rules.set(this, void 0);
         _AccountTreeController_trace.set(this, void 0);
         _AccountTreeController_backupAndSyncConfig.set(this, void 0);
+        _AccountTreeController_initialized.set(this, void 0);
+        // This will be set to true upon the first `init` call.
+        __classPrivateFieldSet(this, _AccountTreeController_initialized, false, "f");
         // Reverse map to allow fast node access from an account ID.
         __classPrivateFieldSet(this, _AccountTreeController_accountIdToContext, new Map(), "f");
         // Reverse map to allow fast wallet node access from a group ID.
@@ -152,6 +155,11 @@ class AccountTreeController extends base_controller_1.BaseController {
      * state with it.
      */
     init() {
+        if (__classPrivateFieldGet(this, _AccountTreeController_initialized, "f")) {
+            // We prevent re-initilializing the state multiple times. Though, we can use
+            // `reinit` to re-init everything from scratch.
+            return;
+        }
         const wallets = {};
         // Clear mappings for fresh rebuild.
         __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").clear();
@@ -165,20 +173,28 @@ class AccountTreeController extends base_controller_1.BaseController {
         }
         // Once we have the account tree, we can apply persisted metadata (names + UI states).
         let previousSelectedAccountGroupStillExists = false;
-        for (const wallet of Object.values(wallets)) {
-            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_applyAccountWalletMetadata).call(this, wallet);
-            for (const group of Object.values(wallet.groups)) {
-                if (group.id === previousSelectedAccountGroup) {
-                    previousSelectedAccountGroupStillExists = true;
-                }
-            }
-        }
         this.update((state) => {
             state.accountTree.wallets = wallets;
             // Apply group metadata within the state update
             for (const wallet of Object.values(state.accountTree.wallets)) {
+                __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_applyAccountWalletMetadata).call(this, state, wallet.id);
+                // 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);
+                    __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);
+                    if (group.id === previousSelectedAccountGroup) {
+                        previousSelectedAccountGroupStillExists = true;
+                    }
+                    nextNaturalNameIndex += 1;
                 }
             }
             if (!previousSelectedAccountGroupStillExists ||
@@ -197,6 +213,17 @@ class AccountTreeController extends base_controller_1.BaseController {
             this.state.accountTree.selectedAccountGroup) {
             this.messagingSystem.publish(`${exports.controllerName}:selectedAccountGroupChange`, this.state.accountTree.selectedAccountGroup, previousSelectedAccountGroup);
         }
+        __classPrivateFieldSet(this, _AccountTreeController_initialized, true, "f");
+    }
+    /**
+     * Re-initialize the controller's state.
+     *
+     * This is done in one single (atomic) `update` block to avoid having a temporary
+     * cleared state. Use this when you need to force a full re-init even if already initialized.
+     */
+    reinit() {
+        __classPrivateFieldSet(this, _AccountTreeController_initialized, false, "f");
+        this.init();
     }
     /**
      * Gets the account wallet object from its ID.
@@ -468,6 +495,8 @@ class AccountTreeController extends base_controller_1.BaseController {
             };
         });
         __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").clearState();
+        // So we know we have to call `init` again.
+        __classPrivateFieldSet(this, _AccountTreeController_initialized, false, "f");
     }
     /**
      * Bi-directionally syncs the account tree with user storage.
@@ -500,14 +529,15 @@ class AccountTreeController extends base_controller_1.BaseController {
     }
 }
 exports.AccountTreeController = AccountTreeController;
-_AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeController_groupIdToWalletId = new WeakMap(), _AccountTreeController_backupAndSyncService = new WeakMap(), _AccountTreeController_rules = new WeakMap(), _AccountTreeController_trace = new WeakMap(), _AccountTreeController_backupAndSyncConfig = new WeakMap(), _AccountTreeController_instances = new WeakSet(), _AccountTreeController_getEntropyRule = function _AccountTreeController_getEntropyRule() {
+_AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeController_groupIdToWalletId = new WeakMap(), _AccountTreeController_backupAndSyncService = new WeakMap(), _AccountTreeController_rules = new WeakMap(), _AccountTreeController_trace = new WeakMap(), _AccountTreeController_backupAndSyncConfig = new WeakMap(), _AccountTreeController_initialized = new WeakMap(), _AccountTreeController_instances = new WeakSet(), _AccountTreeController_getEntropyRule = function _AccountTreeController_getEntropyRule() {
     return __classPrivateFieldGet(this, _AccountTreeController_rules, "f")[0];
 }, _AccountTreeController_getSnapRule = function _AccountTreeController_getSnapRule() {
     return __classPrivateFieldGet(this, _AccountTreeController_rules, "f")[1];
 }, _AccountTreeController_getKeyringRule = function _AccountTreeController_getKeyringRule() {
     return __classPrivateFieldGet(this, _AccountTreeController_rules, "f")[2];
-}, _AccountTreeController_applyAccountWalletMetadata = function _AccountTreeController_applyAccountWalletMetadata(wallet) {
-    const persistedMetadata = this.state.accountWalletsMetadata[wallet.id];
+}, _AccountTreeController_applyAccountWalletMetadata = function _AccountTreeController_applyAccountWalletMetadata(state, walletId) {
+    const wallet = state.accountTree.wallets[walletId];
+    const persistedMetadata = state.accountWalletsMetadata[walletId];
     // Apply persisted name if available (including empty strings)
     if (persistedMetadata?.name !== undefined) {
         wallet.metadata.name = persistedMetadata.name.value;
@@ -536,8 +566,8 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
         default:
             return __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getKeyringRule).call(this);
     }
-}, _AccountTreeController_applyAccountGroupMetadata = function _AccountTreeController_applyAccountGroupMetadata(state, walletId, groupId) {
-    var _a, _b;
+}, _AccountTreeController_applyAccountGroupMetadata = function _AccountTreeController_applyAccountGroupMetadata(state, walletId, groupId, nextNaturalNameIndex) {
+    var _a;
     const wallet = state.accountTree.wallets[walletId];
     const group = wallet.groups[groupId];
     const persistedGroupMetadata = state.accountGroupsMetadata[group.id];
@@ -549,58 +579,65 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
     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
-        // Generate default name and ensure it's unique within the wallet
-        let proposedName = '';
-        let proposedNameIndex;
         // Parse the highest account index being used (similar to accounts-controller)
-        let highestAccountNameIndex = 0;
-        for (const existingGroup of Object.values(wallet.groups)) {
+        let highestNameIndex = 0;
+        for (const { id: otherGroupId } of Object.values(wallet.groups)) {
             // Skip the current group being processed
-            if (existingGroup.id === group.id) {
+            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
-            // TODO: This regex only matches "Account N" pattern. Hardware wallets (Trezor, Ledger, etc.)
-            // use different patterns like "Trezor N", "Ledger N" per keyringTypeToName().
-            // We'll enhance this to handle all keyring types in a future iteration.
-            const nameMatch = existingGroup.metadata.name.match(/Account (\d+)$/u);
+            const nameMatch = otherGroupName.match(/account\s+(\d+)$/iu);
             if (nameMatch) {
                 const nameIndex = parseInt(nameMatch[1], 10);
-                if (nameIndex > highestAccountNameIndex) {
-                    highestAccountNameIndex = nameIndex;
+                if (nameIndex > highestNameIndex) {
+                    highestNameIndex = nameIndex;
                 }
             }
         }
-        // For entropy-based multichain groups, start with the actual groupIndex
-        if (group.type === account_api_1.AccountGroupType.MultichainAccount &&
-            group.metadata.entropy) {
-            proposedNameIndex = group.metadata.entropy.groupIndex;
-        }
-        else {
-            // For other wallet types, start with the number of existing groups
-            // This gives us the next logical sequential number
-            proposedNameIndex = Object.keys(wallet.groups).length - 1;
-        }
-        // Use the higher of the two: highest parsed index or computed index
-        proposedNameIndex = Math.min(highestAccountNameIndex, proposedNameIndex);
+        // 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 nameExists;
+        let proposedNameExists;
+        let proposedName = '';
         do {
-            proposedName = rule.getDefaultAccountGroupName(proposedNameIndex);
+            proposedName = `${namePrefix} ${proposedNameIndex}`;
             // Check if this name already exists in the wallet (excluding current group)
-            nameExists = !(0, group_1.isAccountGroupNameUniqueFromWallet)(wallet, group.id, proposedName);
+            proposedNameExists = !(0, group_1.isAccountGroupNameUniqueFromWallet)(wallet, group.id, proposedName);
             /* istanbul ignore next */
-            if (nameExists) {
+            if (proposedNameExists) {
                 proposedNameIndex += 1; // Try next number
             }
-        } while (nameExists);
+        } while (proposedNameExists);
         state.accountTree.wallets[walletId].groups[groupId].metadata.name =
             proposedName;
         // Persist the generated name to ensure consistency
-        (_a = state.accountGroupsMetadata)[_b = group.id] ?? (_a[_b] = {});
-        state.accountGroupsMetadata[group.id].name = {
+        (_a = state.accountGroupsMetadata)[groupId] ?? (_a[groupId] = {});
+        state.accountGroupsMetadata[groupId].name = {
             value: proposedName,
             // The `lastUpdatedAt` field is used for backup and sync, when comparing local names
             // with backed up names. In this case, the generated name should never take precedence
@@ -616,20 +653,36 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
         group.metadata.hidden = persistedGroupMetadata.hidden.value;
     }
 }, _AccountTreeController_handleAccountAdded = function _AccountTreeController_handleAccountAdded(account) {
-    this.update((state) => {
-        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_insert).call(this, state.accountTree.wallets, account);
-        const context = __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").get(account.id);
-        if (context) {
-            const { walletId, groupId } = context;
-            const wallet = state.accountTree.wallets[walletId];
-            if (wallet) {
-                __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_applyAccountWalletMetadata).call(this, wallet);
-                __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_applyAccountGroupMetadata).call(this, state, walletId, groupId);
+    // We wait for the first `init` to be called to actually build up the tree and
+    // mutate it. We expect the caller to first update the `AccountsController` state
+    // to force the migration of accounts, and then call `init`.
+    if (!__classPrivateFieldGet(this, _AccountTreeController_initialized, "f")) {
+        return;
+    }
+    // Check if this account got already added by `#initAtLeastOnce`, if not, then we
+    // can proceed.
+    if (!__classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").has(account.id)) {
+        this.update((state) => {
+            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_insert).call(this, state.accountTree.wallets, account);
+            const context = __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").get(account.id);
+            if (context) {
+                const { walletId, groupId } = context;
+                const wallet = state.accountTree.wallets[walletId];
+                if (wallet) {
+                    __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_applyAccountWalletMetadata).call(this, state, walletId);
+                    __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_applyAccountGroupMetadata).call(this, state, walletId, groupId);
+                }
             }
-        }
-    });
-    this.messagingSystem.publish(`${exports.controllerName}:accountTreeChange`, this.state.accountTree);
+        });
+        this.messagingSystem.publish(`${exports.controllerName}:accountTreeChange`, this.state.accountTree);
+    }
 }, _AccountTreeController_handleAccountRemoved = function _AccountTreeController_handleAccountRemoved(accountId) {
+    // We wait for the first `init` to be called to actually build up the tree and
+    // mutate it. We expect the caller to first update the `AccountsController` state
+    // to force the migration of accounts, and then call `init`.
+    if (!__classPrivateFieldGet(this, _AccountTreeController_initialized, "f")) {
+        return;
+    }
     const context = __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").get(accountId);
     if (context) {
         const { walletId, groupId } = context;
@@ -701,11 +754,13 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
     }
     const groupId = result.group.id;
     let group = wallet.groups[groupId];
+    const { type, id } = account;
+    const sortOrder = group_1.ACCOUNT_TYPE_TO_SORT_ORDER[type];
     if (!group) {
         wallet.groups[groupId] = {
             ...result.group,
             // Type-wise, we are guaranteed to always have at least 1 account.
-            accounts: [account.id],
+            accounts: [id],
             metadata: {
                 name: '',
                 ...{ pinned: false, hidden: false },
@@ -723,12 +778,28 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
         }
     }
     else {
-        group.accounts.push(account.id);
+        group.accounts.push(id);
+        // We need to do this at every insertion because race conditions can happen
+        // during the account creation process where one provider completes before the other.
+        // The discovery process in the service can also lead to some accounts being created "out of order".
+        const { accounts } = group;
+        accounts.sort(
+        /* istanbul ignore next: Comparator branch execution (a===id vs b===id)
+         * and return attribution vary across engines; final ordering is covered
+         * by behavior tests. Ignoring the entire comparator avoids flaky line
+         * coverage without reducing scenario coverage.
+         */
+        (a, b) => {
+            const aSortOrder = a === id ? sortOrder : __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").get(a)?.sortOrder;
+            const bSortOrder = b === id ? sortOrder : __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").get(b)?.sortOrder;
+            return ((aSortOrder ?? group_1.MAX_SORT_ORDER) - (bSortOrder ?? group_1.MAX_SORT_ORDER));
+        });
     }
     // Update the reverse mapping for this account.
     __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").set(account.id, {
         walletId: wallet.id,
         groupId: group.id,
+        sortOrder,
     });
 }, _AccountTreeController_listAccounts = function _AccountTreeController_listAccounts() {
     return this.messagingSystem.call('AccountsController:listMultichainAccounts');