@metamask-previews/account-tree-controller 1.0.0-preview-8ccfcb37 → 1.3.0-preview-a5441fae

package/CHANGELOG.md

@@ -9,11 +9,49 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-- Add new group naming for non-HD keyring accounts ([#6679](https://github.com/MetaMask/core/pull/6679))
+- Bump `@metamask/utils` from `^11.8.0` to `^11.8.1` ([#6708](https://github.com/MetaMask/core/pull/6708))
+
+## [1.3.0]
+
+### Changed
+
+- Add more internal logs ([#6730](https://github.com/MetaMask/core/pull/6730))
+
+### Fixed
+
+- Preverve import time for account groups ([#6727](https://github.com/MetaMask/core/pull/6727))
+  - We now wait sort accounts by their `importTime` before re-building the tree.
+- Prevent `:account{Added,Removed}` to be used if `init` has not been called yet ([#6717](https://github.com/MetaMask/core/pull/6717))
+  - We now wait for `init` to have been called at least once. Clients will need to ensure internal accounts are fully ready before calling `init`.
+  - 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))
+- 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
@@ -303,7 +341,10 @@ 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.3.0...HEAD
+[1.3.0]: https://github.com/MetaMask/core/compare/@metamask/account-tree-controller@1.2.0...@metamask/account-tree-controller@1.3.0
+[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_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");
@@ -20,6 +20,7 @@ const utils_1 = require("@metamask/utils");
 const analytics_1 = require("./backup-and-sync/analytics/index.cjs");
 const service_1 = require("./backup-and-sync/service/index.cjs");
 const group_1 = require("./group.cjs");
+const logger_1 = require("./logger.cjs");
 const entropy_1 = require("./rules/entropy.cjs");
 const keyring_1 = require("./rules/keyring.cjs");
 const snap_1 = require("./rules/snap.cjs");
@@ -103,6 +104,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.
@@ -133,9 +137,6 @@ 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);
         });
@@ -152,6 +153,12 @@ 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;
+        }
+        (0, logger_1.projectLogger)('Initializing...');
         const wallets = {};
         // Clear mappings for fresh rebuild.
         __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").clear();
@@ -159,8 +166,20 @@ class AccountTreeController extends base_controller_1.BaseController {
         // Keep the current selected group to check if it's still part of the tree
         // after rebuilding it.
         const previousSelectedAccountGroup = this.state.accountTree.selectedAccountGroup;
+        // There's no guarantee that accounts would be sorted by their import time
+        // with `listMultichainAccounts`. We have to sort them here before constructing
+        // the tree.
+        //
+        // Because of the alignment mecanism, some accounts from the same group might not
+        // have been imported at the same time, but at least of them should have been
+        // imported at the right time, thus, inserting the group at the proper place too.
+        //
+        // Lastly, if one day we allow to have "gaps" in between groups, then this `sort`
+        // won't be enough and we would have to use group properties instead (like group
+        // index or maybe introduce a `importTime` at group level).
+        const accounts = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_listAccounts).call(this).sort((a, b) => a.metadata.importTime - b.metadata.importTime);
         // For now, we always re-compute all wallets, we do not re-use the existing state.
-        for (const account of __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_listAccounts).call(this)) {
+        for (const account of accounts) {
             __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_insert).call(this, wallets, account);
         }
         // Once we have the account tree, we can apply persisted metadata (names + UI states).
@@ -203,8 +222,22 @@ class AccountTreeController extends base_controller_1.BaseController {
         // case, no need to fire any event.
         if (previousSelectedAccountGroup !==
             this.state.accountTree.selectedAccountGroup) {
+            (0, logger_1.projectLogger)(`Selected (initial) group is: [${this.state.accountTree.selectedAccountGroup}]`);
             this.messagingSystem.publish(`${exports.controllerName}:selectedAccountGroupChange`, this.state.accountTree.selectedAccountGroup, previousSelectedAccountGroup);
         }
+        (0, logger_1.projectLogger)('Initialized!');
+        __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() {
+        (0, logger_1.projectLogger)('Re-initializing...');
+        __classPrivateFieldSet(this, _AccountTreeController_initialized, false, "f");
+        this.init();
     }
     /**
      * Gets the account wallet object from its ID.
@@ -302,6 +335,7 @@ class AccountTreeController extends base_controller_1.BaseController {
         this.update((state) => {
             state.accountTree.selectedAccountGroup = groupId;
         });
+        (0, logger_1.projectLogger)(`Selected group is now: [${this.state.accountTree.selectedAccountGroup}]`);
         this.messagingSystem.publish(`${exports.controllerName}:selectedAccountGroupChange`, groupId, previousSelectedAccountGroup);
         // Update AccountsController - this will trigger selectedAccountChange event,
         // but our handler is idempotent so it won't cause infinite loop
@@ -351,6 +385,7 @@ class AccountTreeController extends base_controller_1.BaseController {
             // Validate that the name is unique
             __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_assertAccountGroupNameIsUnique).call(this, groupId, finalName);
         }
+        (0, logger_1.projectLogger)(`[${groupId}] Set new name to: "${finalName}" (auto handle conflict: ${autoHandleConflict})`);
         this.update((state) => {
             /* istanbul ignore next */
             if (!state.accountGroupsMetadata[groupId]) {
@@ -470,12 +505,15 @@ class AccountTreeController extends base_controller_1.BaseController {
      * Also clears the backup and sync service state.
      */
     clearState() {
+        (0, logger_1.projectLogger)('Clearing state');
         this.update(() => {
             return {
                 ...getDefaultAccountTreeControllerState(),
             };
         });
         __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.
@@ -508,7 +546,7 @@ 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];
@@ -535,6 +573,7 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
             wallet.metadata.name =
                 __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getKeyringRule).call(this).getDefaultAccountWalletName(wallet);
         }
+        (0, logger_1.projectLogger)(`[${wallet.id}] Set default name to: "${wallet.metadata.name}"`);
     }
 }, _AccountTreeController_getRuleForWallet = function _AccountTreeController_getRuleForWallet(wallet) {
     switch (wallet.type) {
@@ -546,7 +585,7 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
             return __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getKeyringRule).call(this);
     }
 }, _AccountTreeController_applyAccountGroupMetadata = function _AccountTreeController_applyAccountGroupMetadata(state, walletId, groupId, nextNaturalNameIndex) {
-    var _a, _b;
+    var _a;
     const wallet = state.accountTree.wallets[walletId];
     const group = wallet.groups[groupId];
     const persistedGroupMetadata = state.accountGroupsMetadata[group.id];
@@ -564,13 +603,17 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
         // TODO: Implement computed names in a future iteration
         // Parse the highest account index being used (similar to accounts-controller)
         let highestNameIndex = 0;
-        for (const existingGroup of Object.values(wallet.groups)) {
+        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
-            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 > highestNameIndex) {
@@ -610,9 +653,10 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
         } while (proposedNameExists);
         state.accountTree.wallets[walletId].groups[groupId].metadata.name =
             proposedName;
+        (0, logger_1.projectLogger)(`[${group.id}] Set default name to: "${group.metadata.name}"`);
         // 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
@@ -628,20 +672,35 @@ _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, state, walletId);
-                __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 is already known by the tree to avoid double-insertion.
+    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;
@@ -694,6 +753,7 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
     const walletId = result.wallet.id;
     let wallet = wallets[walletId];
     if (!wallet) {
+        (0, logger_1.projectLogger)(`[${walletId}] Added as new wallet`);
         wallets[walletId] = {
             ...result.wallet,
             status: 'ready',
@@ -713,11 +773,14 @@ _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) {
+        (0, logger_1.projectLogger)(`[${walletId}] Add new group: [${groupId}]`);
         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 },
@@ -735,12 +798,29 @@ _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));
+        });
     }
+    (0, logger_1.projectLogger)(`[${groupId}] Add new account: { id: "${account.id}", type: "${account.type}", address: "${account.address}"`);
     // 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');
@@ -769,23 +849,6 @@ _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];