@metamask-previews/account-tree-controller 2.0.0-preview-d74d2f9f → 2.0.0-preview-3d9bbf60

package/dist/AccountTreeController.mjs

@@ -9,8 +9,9 @@ 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_accountOrderCallbacks, _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;
-import { AccountWalletType, select } from "@metamask/account-api";
+var _AccountTreeController_instances, _AccountTreeController_accountIdToContext, _AccountTreeController_groupIdToWalletId, _AccountTreeController_backupAndSyncService, _AccountTreeController_rules, _AccountTreeController_trace, _AccountTreeController_backupAndSyncConfig, _AccountTreeController_accountOrderCallbacks, _AccountTreeController_initialized, _AccountTreeController_getSnapRule, _AccountTreeController_getKeyringRule, _AccountTreeController_getDefaultAccountWalletName, _AccountTreeController_applyAccountWalletMetadata, _AccountTreeController_getComputedAccountGroupName, _AccountTreeController_getDefaultAccountGroupPrefix, _AccountTreeController_getDefaultAccountGroupName, _AccountTreeController_applyAccountGroupMetadata, _AccountTreeController_handleAccountAdded, _AccountTreeController_handleAccountRemoved, _AccountTreeController_pruneEmptyGroupAndWallet, _AccountTreeController_sortAccountsOfGroup, _AccountTreeController_insertAccount, _AccountTreeController_insertOrUpdateMultichainAccountWalletAndGroup, _AccountTreeController_getMultichainAccountWallets, _AccountTreeController_listAccounts, _AccountTreeController_assertAccountGroupExists, _AccountTreeController_assertAccountWalletExists, _AccountTreeController_assertAccountGroupNameIsUnique, _AccountTreeController_getDefaultSelectedAccountGroup, _AccountTreeController_handleSelectedAccountChange, _AccountTreeController_handleMultichainAccountGroupCreatedOrUpdated, _AccountTreeController_handleMultichainAccountWalletStatusChange, _AccountTreeController_getAccountGroup, _AccountTreeController_getDefaultAccountFromAccountGroupId, _AccountTreeController_getDefaultAccountGroupId, _AccountTreeController_registerMessageHandlers, _AccountTreeController_createBackupAndSyncContext;
+import { AccountWalletType, isBip44Account, select } from "@metamask/account-api";
+import { AccountGroupType } from "@metamask/account-api";
 import { BaseController } from "@metamask/base-controller";
 import { isEvmAccountType } from "@metamask/keyring-api";
 import { assert } from "@metamask/utils";
@@ -18,7 +19,7 @@ import { formatAnalyticsEvent, traceFallback } from "./backup-and-sync/analytics
 import { BackupAndSyncService } from "./backup-and-sync/service/index.mjs";
 import { ACCOUNT_TYPE_TO_SORT_ORDER, isAccountGroupNameUnique, isAccountGroupNameUniqueFromWallet, MAX_SORT_ORDER } from "./group.mjs";
 import { projectLogger as log } from "./logger.mjs";
-import { EntropyRule } from "./rules/entropy.mjs";
+import { getEntropyDefaultAccountGroupPrefix, getEntropyDefaultAccountWalletName } from "./rules/entropy.mjs";
 import { KeyringRule } from "./rules/keyring.mjs";
 import { SnapRule } from "./rules/snap.mjs";
 export const controllerName = 'AccountTreeController';
@@ -114,7 +115,7 @@ export class AccountTreeController extends BaseController {
         // Rules to apply to construct the wallets tree.
         __classPrivateFieldSet(this, _AccountTreeController_rules, [
             // 1. We group by entropy-source
-            new EntropyRule(this.messenger),
+            // NOTE: This is now done by consuming the `MultichainAccountService` wallets and groups.
             // 2. We group by Snap ID
             new SnapRule(this.messenger),
             // 3. We group by wallet type (this rule cannot fail and will group all non-matching accounts)
@@ -145,6 +146,12 @@ export class AccountTreeController extends BaseController {
         this.messenger.subscribe('UserStorageController:stateChange', (userStorageControllerState) => {
             __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").handleUserStorageStateChange(userStorageControllerState);
         });
+        this.messenger.subscribe('MultichainAccountService:multichainAccountGroupCreated', (group) => {
+            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_handleMultichainAccountGroupCreatedOrUpdated).call(this, group);
+        });
+        this.messenger.subscribe('MultichainAccountService:multichainAccountGroupUpdated', (group) => {
+            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_handleMultichainAccountGroupCreatedOrUpdated).call(this, group);
+        });
         this.messenger.subscribe('MultichainAccountService:walletStatusChange', (walletId, status) => {
             __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_handleMultichainAccountWalletStatusChange).call(this, walletId, status);
         });
@@ -164,6 +171,7 @@ export class AccountTreeController extends BaseController {
             return;
         }
         log('Initializing...');
+        // For now, we always re-compute all wallets, we do not re-use the existing state.
         const wallets = {};
         // Clear mappings for fresh rebuild.
         __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").clear();
@@ -171,6 +179,12 @@ export class AccountTreeController extends 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;
+        // Insert all multichain account wallet/groups.
+        for (const wallet of __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getMultichainAccountWallets).call(this)) {
+            for (const group of wallet.getMultichainAccountGroups()) {
+                __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_insertOrUpdateMultichainAccountWalletAndGroup).call(this, wallets, wallet, group);
+            }
+        }
         // 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.
@@ -183,9 +197,14 @@ export class AccountTreeController extends BaseController {
         // 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.
+        // Insert all other kind of accounts (private keys, HW, other Snap accounts, etc.).
         for (const account of accounts) {
-            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_insert).call(this, wallets, account);
+            // BIP-44 accounts are owned byt the `MultichainAccountService`, so we have to skip them
+            // here, since we've already added wallets/groups for each of them.
+            if (isBip44Account(account)) {
+                continue;
+            }
+            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_insertAccount).call(this, wallets, account);
         }
         // Once we have the account tree, we can apply persisted metadata (names + UI states).
         let previousSelectedAccountGroupStillExists = false;
@@ -556,12 +575,19 @@ export class AccountTreeController extends BaseController {
         return __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").performFullSyncAtLeastOnce();
     }
 }
-_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_accountOrderCallbacks = new WeakMap(), _AccountTreeController_initialized = 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_accountOrderCallbacks = new WeakMap(), _AccountTreeController_initialized = new WeakMap(), _AccountTreeController_instances = new WeakSet(), _AccountTreeController_getSnapRule = function _AccountTreeController_getSnapRule() {
     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];
+    return __classPrivateFieldGet(this, _AccountTreeController_rules, "f")[1];
+}, _AccountTreeController_getDefaultAccountWalletName = function _AccountTreeController_getDefaultAccountWalletName(wallet) {
+    switch (wallet.type) {
+        case AccountWalletType.Entropy:
+            return getEntropyDefaultAccountWalletName(this.messenger, wallet);
+        case AccountWalletType.Snap:
+            return __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getSnapRule).call(this).getDefaultAccountWalletName(wallet);
+        default:
+            return __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getKeyringRule).call(this).getDefaultAccountWalletName(wallet);
+    }
 }, _AccountTreeController_applyAccountWalletMetadata = function _AccountTreeController_applyAccountWalletMetadata(state, walletId) {
     const wallet = state.accountTree.wallets[walletId];
     const persistedMetadata = state.accountWalletsMetadata[walletId];
@@ -571,29 +597,9 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
     }
     else if (!wallet.metadata.name) {
         // Generate default name if none exists
-        if (wallet.type === AccountWalletType.Entropy) {
-            wallet.metadata.name =
-                __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getEntropyRule).call(this).getDefaultAccountWalletName(wallet);
-        }
-        else if (wallet.type === AccountWalletType.Snap) {
-            wallet.metadata.name =
-                __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getSnapRule).call(this).getDefaultAccountWalletName(wallet);
-        }
-        else {
-            wallet.metadata.name =
-                __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getKeyringRule).call(this).getDefaultAccountWalletName(wallet);
-        }
+        wallet.metadata.name = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getDefaultAccountWalletName).call(this, wallet);
         log(`[${wallet.id}] Set default name to: "${wallet.metadata.name}"`);
     }
-}, _AccountTreeController_getRuleForWallet = function _AccountTreeController_getRuleForWallet(wallet) {
-    switch (wallet.type) {
-        case AccountWalletType.Entropy:
-            return __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getEntropyRule).call(this);
-        case AccountWalletType.Snap:
-            return __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getSnapRule).call(this);
-        default:
-            return __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getKeyringRule).call(this);
-    }
 }, _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) {
@@ -618,11 +624,18 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
         proposedName = this.resolveNameConflict(wallet, group.id, proposedName);
     }
     return proposedName;
+}, _AccountTreeController_getDefaultAccountGroupPrefix = function _AccountTreeController_getDefaultAccountGroupPrefix(wallet) {
+    switch (wallet.type) {
+        case AccountWalletType.Entropy:
+            return getEntropyDefaultAccountGroupPrefix();
+        case AccountWalletType.Snap:
+            return __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getSnapRule).call(this).getDefaultAccountGroupPrefix(wallet);
+        default:
+            return __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getKeyringRule).call(this).getDefaultAccountGroupPrefix(wallet);
+    }
 }, _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);
+    const namePrefix = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getDefaultAccountGroupPrefix).call(this, wallet);
     // Parse the highest account index being used (similar to accounts-controller)
     let highestNameIndex = 0;
     for (const { id: otherGroupId } of Object.values(wallet.groups)) {
@@ -748,10 +761,15 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
     if (!__classPrivateFieldGet(this, _AccountTreeController_initialized, "f")) {
         return;
     }
+    if (isBip44Account(account)) {
+        // We're skipping BIP-44 accounts since we rely on the `MultichainAccountService` to do
+        // the grouping of wallets/groups directly.
+        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);
+            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_insertAccount).call(this, state.accountTree.wallets, account);
             const context = __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").get(account.id);
             if (context) {
                 const { walletId, groupId } = context;
@@ -774,33 +792,40 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
     const context = __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").get(accountId);
     if (context) {
         const { walletId, groupId } = context;
-        const previousSelectedAccountGroup = this.state.accountTree.selectedAccountGroup;
-        let selectedAccountGroupChanged = false;
-        this.update((state) => {
-            const accounts = state.accountTree.wallets[walletId]?.groups[groupId]?.accounts;
-            if (accounts) {
-                const index = accounts.indexOf(accountId);
-                if (index !== -1) {
+        // If it's in the context, then `group` should be defined.
+        const group = this.state.accountTree.wallets[walletId]?.groups[groupId];
+        assert(group, 'Account group associated with a context cannot be undefined');
+        // We're only considering non-BIP-44 accounts for single account events.
+        if (group.type !== AccountGroupType.MultichainAccount) {
+            const index = group.accounts.indexOf(accountId);
+            if (index !== -1) {
+                let selectedAccountGroupChanged = false;
+                const previousSelectedAccountGroup = this.state.accountTree.selectedAccountGroup;
+                this.update((state) => {
+                    const accounts = state.accountTree.wallets[walletId]?.groups[groupId].accounts;
+                    // Effectively remove account from the group and state.
                     accounts.splice(index, 1);
-                    // Check if we need to update selectedAccountGroup after removal
-                    if (state.accountTree.selectedAccountGroup === groupId &&
-                        accounts.length === 0) {
-                        // The currently selected group is now empty, find a new group to select
-                        const newSelectedAccountGroup = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getDefaultAccountGroupId).call(this, state.accountTree.wallets);
-                        state.accountTree.selectedAccountGroup = newSelectedAccountGroup;
-                        selectedAccountGroupChanged =
-                            newSelectedAccountGroup !== previousSelectedAccountGroup;
+                    // If there's no more account, we have to prune the group and maybe select
+                    // a new account group too.
+                    if (accounts.length === 0) {
+                        // Check if we need to update selectedAccountGroup after removal
+                        if (state.accountTree.selectedAccountGroup === groupId) {
+                            // The currently selected group is now empty, find a new group to select
+                            const newSelectedAccountGroup = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getDefaultAccountGroupId).call(this, state.accountTree.wallets);
+                            state.accountTree.selectedAccountGroup =
+                                newSelectedAccountGroup;
+                            selectedAccountGroupChanged =
+                                newSelectedAccountGroup !== previousSelectedAccountGroup;
+                        }
+                        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_pruneEmptyGroupAndWallet).call(this, state, walletId, groupId);
                     }
-                }
-                if (accounts.length === 0) {
-                    __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_pruneEmptyGroupAndWallet).call(this, state, walletId, groupId);
+                });
+                this.messenger.publish(`${controllerName}:accountTreeChange`, this.state.accountTree);
+                // Emit selectedAccountGroupChange event if the selected group changed
+                if (selectedAccountGroupChanged) {
+                    this.messenger.publish(`${controllerName}:selectedAccountGroupChange`, this.state.accountTree.selectedAccountGroup, previousSelectedAccountGroup);
                 }
             }
-        });
-        this.messenger.publish(`${controllerName}:accountTreeChange`, this.state.accountTree);
-        // Emit selectedAccountGroupChange event if the selected group changed
-        if (selectedAccountGroupChanged) {
-            this.messenger.publish(`${controllerName}:selectedAccountGroupChange`, this.state.accountTree.selectedAccountGroup, previousSelectedAccountGroup);
         }
         // Clear reverse-mapping for that account.
         __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").delete(accountId);
@@ -817,9 +842,23 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
         delete state.accountWalletsMetadata[walletId];
     }
     return state;
-}, _AccountTreeController_insert = function _AccountTreeController_insert(wallets, account) {
-    const result = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getEntropyRule).call(this).match(account) ??
-        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getSnapRule).call(this).match(account) ??
+}, _AccountTreeController_sortAccountsOfGroup = function _AccountTreeController_sortAccountsOfGroup(group) {
+    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 = __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").get(a)?.sortOrder;
+        const bSortOrder = __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").get(b)?.sortOrder;
+        return (aSortOrder ?? MAX_SORT_ORDER) - (bSortOrder ?? MAX_SORT_ORDER);
+    });
+}, _AccountTreeController_insertAccount = function _AccountTreeController_insertAccount(wallets, account) {
+    // Those are owned by the `MultichainAccountService`, so they should be already handled
+    // by `#insertOrUpdateMultichainAccountWalletAndGroup` method.
+    assert(!isBip44Account(account), 'BIP-44 accounts cannot be inserted explicitly');
+    const result = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getSnapRule).call(this).match(account) ??
         __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getKeyringRule).call(this).match(account); // This one cannot fail.
     // Update controller's state.
     const walletId = result.wallet.id;
@@ -838,62 +877,119 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
             // the union tag `result.wallet.type`.
         };
         wallet = wallets[walletId];
-        // Trigger atomic sync for new wallet (only for entropy wallets)
-        if (wallet.type === AccountWalletType.Entropy) {
-            __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").enqueueSingleWalletSync(walletId);
-        }
     }
     const groupId = result.group.id;
-    let group = wallet.groups[groupId];
-    const { type, id } = account;
-    const sortOrder = ACCOUNT_TYPE_TO_SORT_ORDER[type];
+    assert(result.group.type === AccountGroupType.SingleAccount, `Account insertion should always result in a "${AccountGroupType.SingleAccount}" group type`);
+    assert(!wallet.groups[groupId], 'Single account insertion cannot re-use existing group');
+    log(`[${walletId}] Add new group: [${groupId}]`);
+    const group = {
+        ...result.group,
+        // Type-wise, we are guaranteed to always have at least 1 account.
+        accounts: [account.id],
+        metadata: {
+            name: '',
+            ...{ pinned: false, hidden: false },
+            ...result.group.metadata, // Allow rules to override defaults
+        },
+        // We do need to type-cast since we're not narrowing `result` with
+        // the union tag `result.group.type`.
+    };
+    wallet.groups[groupId] = group;
+    // Map group ID to its containing wallet ID for efficient direct access
+    __classPrivateFieldGet(this, _AccountTreeController_groupIdToWalletId, "f").set(groupId, walletId);
+    log(`[${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: ACCOUNT_TYPE_TO_SORT_ORDER[account.type],
+    });
+    // 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".
+    __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_sortAccountsOfGroup).call(this, group);
+}, _AccountTreeController_insertOrUpdateMultichainAccountWalletAndGroup = function _AccountTreeController_insertOrUpdateMultichainAccountWalletAndGroup(wallets, multichainAccountWallet, multichainAccountGroup) {
+    const walletId = multichainAccountWallet.id;
+    const groupId = multichainAccountGroup.id;
+    let wallet = null;
+    let group = null;
+    // Check type, mainly to infer proper wallet object type.
+    const walletObject = wallets[walletId];
+    if (walletObject && walletObject.type === AccountWalletType.Entropy) {
+        wallet = walletObject;
+        group = wallet.groups[groupId];
+    }
+    // We always re-use the account list from the group (if accounts get
+    // added/removed/re-ordered within the group).
+    const accounts = multichainAccountGroup.getAccounts();
+    const accountIds = accounts
+        // For now, we need this type-cast because `getAccounts` do not have the same
+        // type-constraint (uses string[] instead of [string; ...string])
+        .map((account) => account.id);
+    // Create the group object first, to inject it in the wallet in case this wallet is
+    // not part of the tree yet.
     if (!group) {
-        log(`[${walletId}] Add new group: [${groupId}]`);
-        wallet.groups[groupId] = {
-            ...result.group,
-            // Type-wise, we are guaranteed to always have at least 1 account.
-            accounts: [id],
+        group = {
+            id: multichainAccountGroup.id,
+            type: multichainAccountGroup.type,
+            accounts: accountIds,
             metadata: {
+                entropy: {
+                    groupIndex: multichainAccountGroup.groupIndex,
+                },
                 name: '',
-                ...{ pinned: false, hidden: false },
-                ...result.group.metadata, // Allow rules to override defaults
+                pinned: false,
+                hidden: false,
             },
-            // We do need to type-cast since we're not narrowing `result` with
-            // the union tag `result.group.type`.
         };
-        group = wallet.groups[groupId];
-        // Map group ID to its containing wallet ID for efficient direct access
-        __classPrivateFieldGet(this, _AccountTreeController_groupIdToWalletId, "f").set(groupId, walletId);
-        // Trigger atomic sync for new group (only for entropy wallets)
-        if (wallet.type === AccountWalletType.Entropy) {
-            __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").enqueueSingleGroupSync(groupId);
-        }
     }
     else {
-        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 ?? MAX_SORT_ORDER) - (bSortOrder ?? MAX_SORT_ORDER));
+        // We clear existing contexts for previous accounts of that group because:
+        // - Accounts might have been removed
+        // - Accounts context mapping will get updated below
+        group.accounts.forEach((accountId) => __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").delete(accountId));
+        group.accounts = accountIds;
+    }
+    if (!wallet) {
+        wallet = {
+            id: multichainAccountWallet.id,
+            type: multichainAccountWallet.type,
+            status: multichainAccountWallet.status,
+            groups: {
+                [group.id]: group,
+            },
+            metadata: {
+                entropy: {
+                    id: multichainAccountWallet.entropySource,
+                },
+                name: '', // Will get updated later.
+            },
+        };
+        wallets[walletId] = wallet;
+        // Trigger atomic sync for new wallet.
+        __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").enqueueSingleWalletSync(walletId);
+    }
+    else {
+        wallet.groups[group.id] = group;
+        // Trigger atomic sync for new group.
+        __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").enqueueSingleGroupSync(groupId);
+    }
+    // Map group ID to its containing wallet ID for efficient direct access
+    __classPrivateFieldGet(this, _AccountTreeController_groupIdToWalletId, "f").set(groupId, walletId);
+    // Update the reverse mapping for all accounts account.
+    for (const account of accounts) {
+        __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").set(account.id, {
+            walletId: wallet.id,
+            groupId: group.id,
+            sortOrder: ACCOUNT_TYPE_TO_SORT_ORDER[account.type],
         });
     }
-    log(`[${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,
-    });
+    // 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".
+    __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_sortAccountsOfGroup).call(this, group);
+}, _AccountTreeController_getMultichainAccountWallets = function _AccountTreeController_getMultichainAccountWallets() {
+    return this.messenger.call('MultichainAccountService:getMultichainAccountWallets');
 }, _AccountTreeController_listAccounts = function _AccountTreeController_listAccounts() {
     return this.messenger.call('AccountsController:listMultichainAccounts');
 }, _AccountTreeController_assertAccountGroupExists = function _AccountTreeController_assertAccountGroupExists(groupId) {
@@ -938,6 +1034,25 @@ _AccountTreeController_accountIdToContext = new WeakMap(), _AccountTreeControlle
         state.accountTree.selectedAccountGroup = groupId;
     });
     this.messenger.publish(`${controllerName}:selectedAccountGroupChange`, groupId, previousSelectedAccountGroup);
+}, _AccountTreeController_handleMultichainAccountGroupCreatedOrUpdated = function _AccountTreeController_handleMultichainAccountGroupCreatedOrUpdated(multichainAccountGroup) {
+    // 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;
+    }
+    this.update((state) => {
+        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_insertOrUpdateMultichainAccountWalletAndGroup).call(this, state.accountTree.wallets, multichainAccountGroup.wallet, multichainAccountGroup);
+        const wallet = state.accountTree.wallets[multichainAccountGroup.wallet.id];
+        if (wallet) {
+            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_applyAccountWalletMetadata).call(this, state, wallet.id);
+            const group = wallet.groups[multichainAccountGroup.id];
+            if (group) {
+                __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_applyAccountGroupMetadata).call(this, state, wallet.id, group.id);
+            }
+        }
+    });
+    this.messenger.publish(`${controllerName}:accountTreeChange`, this.state.accountTree);
 }, _AccountTreeController_handleMultichainAccountWalletStatusChange = function _AccountTreeController_handleMultichainAccountWalletStatusChange(walletId, walletStatus) {
     this.update((state) => {
         const wallet = state.accountTree.wallets[walletId];