@metamask-previews/account-tree-controller 8.0.0-preview-4f4c98e → 8.0.0-preview-eb263b0ee

package/dist/AccountTreeController.cjs

@@ -0,0 +1,1247 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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_initTreeContext, _AccountTreeController_getEntropyRule, _AccountTreeController_getSnapRule, _AccountTreeController_getKeyringRule, _AccountTreeController_applyAccountWalletMetadata, _AccountTreeController_getRuleForWallet, _AccountTreeController_getComputedAccountGroupName, _AccountTreeController_getDefaultAccountGroupName, _AccountTreeController_applyAccountGroupMetadata, _AccountTreeController_handleAccountsAdded, _AccountTreeController_handleAccountsRemoved, _AccountTreeController_pruneEmptyGroupAndWallet, _AccountTreeController_publishAccountGroupCreated, _AccountTreeController_publishAccountGroupUpdated, _AccountTreeController_publishAccountGroupRemoved, _AccountTreeController_insert, _AccountTreeController_listAccounts, _AccountTreeController_assertAccountGroupExists, _AccountTreeController_assertAccountWalletExists, _AccountTreeController_assertAccountGroupNameIsUnique, _AccountTreeController_setSelectedAccountGroup, _AccountTreeController_getDefaultSelectedAccountGroup, _AccountTreeController_handleSelectedAccountChange, _AccountTreeController_handleMultichainAccountWalletStatusChange, _AccountTreeController_getAccountGroup, _AccountTreeController_getAccountFromAccountGroupId, _AccountTreeController_getDefaultAccountGroupId, _AccountTreeController_hasEvmAccount, _AccountTreeController_resolveNameConflict, _AccountTreeController_createBackupAndSyncContext;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountTreeController = exports.getDefaultAccountTreeControllerState = exports.controllerName = void 0;
+const account_api_1 = require("@metamask/account-api");
+const base_controller_1 = require("@metamask/base-controller");
+const keyring_api_1 = require("@metamask/keyring-api");
+const utils_1 = require("@metamask/utils");
+const index_js_1 = require("./backup-and-sync/analytics/index.cjs");
+const index_js_2 = require("./backup-and-sync/service/index.cjs");
+const index_js_3 = require("./backup-and-sync/utils/index.cjs");
+const group_js_1 = require("./group.cjs");
+const logger_js_1 = require("./logger.cjs");
+const entropy_js_1 = require("./rules/entropy.cjs");
+const keyring_js_1 = require("./rules/keyring.cjs");
+const snap_js_1 = require("./rules/snap.cjs");
+const export_js_1 = require("./state/export.cjs");
+const import_js_1 = require("./state/import.cjs");
+exports.controllerName = 'AccountTreeController';
+const MESSENGER_EXPOSED_METHODS = [
+    'getSelectedAccountGroup',
+    'setSelectedAccountGroup',
+    'setSelectedAccountGroupByAccountId',
+    'getAccountsFromSelectedAccountGroup',
+    'getAccountFromSelectedAccountGroup',
+    'getAccountContext',
+    'setAccountWalletName',
+    'setAccountGroupName',
+    'setAccountGroupPinned',
+    'setAccountGroupHidden',
+    'getAccountWalletObject',
+    'getAccountWalletObjects',
+    'getAccountGroupObject',
+    'clearState',
+    'syncWithUserStorage',
+    'syncWithUserStorageAtLeastOnce',
+    'init',
+    'reinit',
+    'exportState',
+    'importState',
+];
+const accountTreeControllerMetadata = {
+    accountTree: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    selectedAccountGroup: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    isAccountTreeSyncingInProgress: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    hasAccountTreeSyncingSyncedAtLeastOnce: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    accountGroupsMetadata: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    accountWalletsMetadata: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+};
+/**
+ * Gets default state of the `AccountTreeController`.
+ *
+ * @returns The default state of the `AccountTreeController`.
+ */
+function getDefaultAccountTreeControllerState() {
+    return {
+        accountTree: {
+            wallets: {},
+        },
+        selectedAccountGroup: '',
+        isAccountTreeSyncingInProgress: false,
+        hasAccountTreeSyncingSyncedAtLeastOnce: false,
+        accountGroupsMetadata: {},
+        accountWalletsMetadata: {},
+    };
+}
+exports.getDefaultAccountTreeControllerState = getDefaultAccountTreeControllerState;
+class AccountTreeController extends base_controller_1.BaseController {
+    /**
+     * Constructor for AccountTreeController.
+     *
+     * @param options - The controller options.
+     * @param options.messenger - The messenger object.
+     * @param options.state - Initial state to set on this controller
+     * @param options.config - Optional configuration for the controller.
+     */
+    constructor({ messenger, state, config, }) {
+        super({
+            messenger,
+            name: exports.controllerName,
+            metadata: accountTreeControllerMetadata,
+            state: {
+                ...getDefaultAccountTreeControllerState(),
+                ...state,
+            },
+        });
+        _AccountTreeController_instances.add(this);
+        _AccountTreeController_accountIdToContext.set(this, void 0);
+        _AccountTreeController_groupIdToWalletId.set(this, void 0);
+        /**
+         * Service responsible for all backup and sync operations.
+         */
+        _AccountTreeController_backupAndSyncService.set(this, void 0);
+        _AccountTreeController_rules.set(this, void 0);
+        _AccountTreeController_trace.set(this, void 0);
+        _AccountTreeController_backupAndSyncConfig.set(this, void 0);
+        /**
+         * Callbacks to migrate hidden and pinned account information from the account order controller
+         */
+        _AccountTreeController_accountOrderCallbacks.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.
+        __classPrivateFieldSet(this, _AccountTreeController_groupIdToWalletId, new Map(), "f");
+        // Rules to apply to construct the wallets tree.
+        __classPrivateFieldSet(this, _AccountTreeController_rules, [
+            // 1. We group by entropy-source
+            new entropy_js_1.EntropyRule(this.messenger),
+            // 2. We group by Snap ID
+            new snap_js_1.SnapRule(this.messenger),
+            // 3. We group by wallet type (this rule cannot fail and will group all non-matching accounts)
+            new keyring_js_1.KeyringRule(this.messenger),
+        ], "f");
+        // Initialize trace function
+        __classPrivateFieldSet(this, _AccountTreeController_trace, config?.trace ?? index_js_1.traceFallback, "f");
+        // Initialize backup and sync config
+        __classPrivateFieldSet(this, _AccountTreeController_backupAndSyncConfig, {
+            emitAnalyticsEventFn: (event) => {
+                return config?.backupAndSync?.onBackupAndSyncEvent?.((0, index_js_1.formatAnalyticsEvent)(event));
+            },
+        }, "f");
+        // Used when migrating initial hidden/pinned state for groups (if available).
+        __classPrivateFieldSet(this, _AccountTreeController_accountOrderCallbacks, config?.accountOrderCallbacks, "f");
+        // Initialize the backup and sync service
+        __classPrivateFieldSet(this, _AccountTreeController_backupAndSyncService, new index_js_2.BackupAndSyncService(__classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_createBackupAndSyncContext).call(this)), "f");
+        // We build the initial tree (from the state), but this might get updated
+        // after `init` got called. Having it available now, allow our consumers to
+        // re-use the state that was already available before we restart/lock the
+        // wallet.
+        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_initTreeContext).call(this, this.state.accountTree);
+        this.messenger.subscribe('AccountsController:accountsAdded', (accounts) => {
+            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_handleAccountsAdded).call(this, accounts);
+        });
+        this.messenger.subscribe('AccountsController:accountsRemoved', (accountIds) => {
+            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_handleAccountsRemoved).call(this, accountIds);
+        });
+        this.messenger.subscribe('AccountsController:selectedAccountChange', (account) => {
+            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_handleSelectedAccountChange).call(this, account);
+        });
+        this.messenger.subscribe('UserStorageController:stateChange', (userStorageControllerState) => {
+            __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").handleUserStorageStateChange(userStorageControllerState);
+        });
+        this.messenger.subscribe('MultichainAccountService:walletStatusChange', (walletId, status) => {
+            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_handleMultichainAccountWalletStatusChange).call(this, walletId, status);
+        });
+        this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+    }
+    /**
+     * Initialize the controller's state.
+     *
+     * It constructs the initial state of the account tree (tree nodes, nodes
+     * names, metadata, etc..) and will automatically update the controller's
+     * 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_js_1.projectLogger)('Initializing...');
+        const wallets = {};
+        // Clear mappings for fresh rebuild.
+        __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").clear();
+        __classPrivateFieldGet(this, _AccountTreeController_groupIdToWalletId, "f").clear();
+        // Keep the current selected group to check if it's still part of the tree
+        // after rebuilding it.
+        const previousSelectedAccountGroup = this.state.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 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).
+        let previousSelectedAccountGroupStillExists = false;
+        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, {
+                        // 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;
+                    }
+                    nextNaturalNameIndex += 1;
+                }
+            }
+            if (!previousSelectedAccountGroupStillExists ||
+                previousSelectedAccountGroup === '') {
+                // No group is selected yet OR group no longer exists, re-sync with the
+                // AccountsController.
+                state.selectedAccountGroup = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getDefaultSelectedAccountGroup).call(this, state.accountTree.wallets);
+            }
+        });
+        // We always fire the current selected group after init, even if it did not change, to ensure that
+        // all subscribers are aware of it and can react accordingly (e.g. by fetching accounts from
+        // the selected group on startup).
+        (0, logger_js_1.projectLogger)(`Selected (initial) group is: [${this.state.selectedAccountGroup}]`);
+        this.messenger.publish(`${exports.controllerName}:selectedAccountGroupChange`, this.state.selectedAccountGroup, previousSelectedAccountGroup);
+        __classPrivateFieldSet(this, _AccountTreeController_initialized, true, "f");
+        (0, logger_js_1.projectLogger)('Initialized!');
+        this.messenger.publish(`${exports.controllerName}:initialized`, this.state);
+    }
+    /**
+     * 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_js_1.projectLogger)('Re-initializing...');
+        __classPrivateFieldSet(this, _AccountTreeController_initialized, false, "f");
+        this.init();
+    }
+    /**
+     * Gets the account wallet object from its ID.
+     *
+     * @param walletId - Account wallet ID.
+     * @returns The account wallet object if found, undefined otherwise.
+     */
+    getAccountWalletObject(walletId) {
+        const wallet = this.state.accountTree.wallets[walletId];
+        if (!wallet) {
+            return undefined;
+        }
+        return wallet;
+    }
+    /**
+     * Gets all account wallet objects.
+     *
+     * @returns All account wallet objects.
+     */
+    getAccountWalletObjects() {
+        return Object.values(this.state.accountTree.wallets);
+    }
+    /**
+     * Gets all underlying accounts from the currently selected account
+     * group.
+     *
+     * It also support account selector, which allows to filter specific
+     * accounts given some criterias (account type, address, scopes, etc...).
+     *
+     * @param selector - Optional account selector.
+     * @returns Underlying accounts for the currently selected account (filtered
+     * by the selector if provided).
+     */
+    getAccountsFromSelectedAccountGroup(selector) {
+        const groupId = this.getSelectedAccountGroup();
+        if (!groupId) {
+            return [];
+        }
+        const group = this.getAccountGroupObject(groupId);
+        // We should never reach this part, so we cannot cover it either.
+        /* istanbul ignore next */
+        if (!group) {
+            return [];
+        }
+        const accounts = [];
+        for (const id of group.accounts) {
+            const account = this.messenger.call('AccountsController:getAccount', id);
+            // For now, we're filtering undefined account, but I believe
+            // throwing would be more appropriate here.
+            if (account) {
+                accounts.push(account);
+            }
+        }
+        return selector ? (0, account_api_1.select)(accounts, selector) : accounts;
+    }
+    /**
+     * Gets an account from the currently selected account group, optionally
+     * filtered by a CAIP-2 chain ID.
+     *
+     * This is the group-based replacement for both
+     * `AccountsController:getSelectedAccount` and
+     * `AccountsController:getSelectedMultichainAccount`.
+     *
+     * When no chain ID is provided, an account of the selected group is returned
+     * using an EVM-priority rule: the first EVM account found in the group, or the
+     * first account in the group if no EVM account is found. When a chain ID is
+     * provided, the first account in the selected group whose scopes match the
+     * given chain is returned.
+     *
+     * @param chainId - Optional CAIP-2 chain ID used to filter accounts by scope.
+     * @returns The matching internal account from the selected group, or
+     * undefined if no group is selected or no account matches.
+     * @throws If `chainId` is provided but is not a valid CAIP-2 chain ID.
+     */
+    getAccountFromSelectedAccountGroup(chainId) {
+        const groupId = this.getSelectedAccountGroup();
+        if (!groupId) {
+            return undefined;
+        }
+        if (!chainId) {
+            return __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getAccountFromAccountGroupId).call(this, groupId);
+        }
+        if (!(0, utils_1.isCaipChainId)(chainId)) {
+            throw new Error(`Invalid CAIP-2 chain ID: ${String(chainId)}`);
+        }
+        const accounts = this.getAccountsFromSelectedAccountGroup({
+            scopes: [chainId],
+        });
+        return accounts[0];
+    }
+    /**
+     * Gets the account group object from its ID.
+     *
+     * @param groupId - Account group ID.
+     * @returns The account group object if found, undefined otherwise.
+     */
+    getAccountGroupObject(groupId) {
+        const walletId = __classPrivateFieldGet(this, _AccountTreeController_groupIdToWalletId, "f").get(groupId);
+        if (!walletId) {
+            return undefined;
+        }
+        const wallet = this.getAccountWalletObject(walletId);
+        return wallet?.groups[groupId];
+    }
+    /**
+     * Gets the account's context which contains its wallet ID, group ID, and sort order.
+     *
+     * @param accountId - Account ID.
+     * @returns The account context if found, undefined otherwise.
+     */
+    getAccountContext(accountId) {
+        return __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").get(accountId);
+    }
+    /**
+     * Gets the currently selected account group ID.
+     *
+     * @returns The selected account group ID or empty string if none selected.
+     */
+    getSelectedAccountGroup() {
+        return this.state.selectedAccountGroup;
+    }
+    /**
+     * Sets the selected account group and updates the AccountsController selectedAccount accordingly.
+     *
+     * @param groupId - The account group ID to select.
+     */
+    setSelectedAccountGroup(groupId) {
+        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_setSelectedAccountGroup).call(this, groupId);
+    }
+    /**
+     * Sets the selected account group and updates the AccountsController selectedAccount accordingly.
+     *
+     * @param accountId - The account ID to select the group for.
+     */
+    setSelectedAccountGroupByAccountId(accountId) {
+        const context = __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").get(accountId);
+        if (!context) {
+            throw new Error('Account not found in the account tree');
+        }
+        this.setSelectedAccountGroup(context.groupId);
+    }
+    /**
+     * Sets a custom name for an account group.
+     *
+     * @param groupId - The account group ID.
+     * @param name - The custom name to set.
+     * @param autoHandleConflict - If true, automatically resolves name conflicts by adding a suffix. If false, throws on conflicts.
+     * @throws If the account group ID is not found in the current tree.
+     * @throws If the account group name already exists and autoHandleConflict is false.
+     */
+    setAccountGroupName(groupId, name, autoHandleConflict = false) {
+        // Validate that the group exists in the current tree
+        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_assertAccountGroupExists).call(this, groupId);
+        const walletId = __classPrivateFieldGet(this, _AccountTreeController_groupIdToWalletId, "f").get(groupId);
+        (0, utils_1.assert)(walletId, 'Account group not found in tree');
+        const wallet = this.state.accountTree.wallets[walletId];
+        let finalName = name;
+        // Handle name conflicts based on the autoHandleConflict flag
+        if (autoHandleConflict &&
+            !(0, group_js_1.isAccountGroupNameUniqueFromWallet)(wallet, groupId, name)) {
+            finalName = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_resolveNameConflict).call(this, wallet, groupId, name);
+        }
+        else {
+            // Validate that the name is unique
+            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_assertAccountGroupNameIsUnique).call(this, groupId, finalName);
+        }
+        (0, logger_js_1.projectLogger)(`[${groupId}] Set new name to: "${finalName}" (auto handle conflict: ${autoHandleConflict})`);
+        this.update((state) => {
+            /* istanbul ignore next */
+            if (!state.accountGroupsMetadata[groupId]) {
+                state.accountGroupsMetadata[groupId] = {};
+            }
+            // Update persistent metadata
+            state.accountGroupsMetadata[groupId].name = {
+                value: finalName,
+                lastUpdatedAt: Date.now(),
+            };
+            // Update tree node directly using efficient mapping
+            state.accountTree.wallets[walletId].groups[groupId].metadata.name =
+                finalName;
+        });
+        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_publishAccountGroupUpdated).call(this, walletId, groupId);
+        // Trigger atomic sync for group rename (only for groups from entropy wallets)
+        if (wallet.type === account_api_1.AccountWalletType.Entropy) {
+            __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").enqueueSingleGroupSync(groupId);
+        }
+    }
+    /**
+     * Sets a custom name for an account wallet.
+     *
+     * @param walletId - The account wallet ID.
+     * @param name - The custom name to set.
+     * @throws If the account wallet ID is not found in the current tree.
+     */
+    setAccountWalletName(walletId, name) {
+        // Validate that the wallet exists in the current tree
+        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_assertAccountWalletExists).call(this, walletId);
+        this.update((state) => {
+            var _a;
+            // Update persistent metadata
+            (_a = state.accountWalletsMetadata)[walletId] ?? (_a[walletId] = {});
+            state.accountWalletsMetadata[walletId].name = {
+                value: name,
+                lastUpdatedAt: Date.now(),
+            };
+            // Update tree node directly
+            state.accountTree.wallets[walletId].metadata.name = name;
+        });
+        // Trigger atomic sync for wallet rename (only for groups from entropy wallets)
+        if (this.state.accountTree.wallets[walletId].type ===
+            account_api_1.AccountWalletType.Entropy) {
+            __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").enqueueSingleWalletSync(walletId);
+        }
+    }
+    /**
+     * Toggles the pinned state of an account group.
+     *
+     * @param groupId - The account group ID.
+     * @param pinned - Whether the group should be pinned.
+     * @throws If the account group ID is not found in the current tree.
+     */
+    setAccountGroupPinned(groupId, pinned) {
+        // Validate that the group exists in the current tree
+        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_assertAccountGroupExists).call(this, groupId);
+        const walletId = __classPrivateFieldGet(this, _AccountTreeController_groupIdToWalletId, "f").get(groupId);
+        this.update((state) => {
+            /* istanbul ignore next */
+            if (!state.accountGroupsMetadata[groupId]) {
+                state.accountGroupsMetadata[groupId] = {};
+            }
+            // Update persistent metadata
+            state.accountGroupsMetadata[groupId].pinned = {
+                value: pinned,
+                lastUpdatedAt: Date.now(),
+            };
+            // Update tree node directly using efficient mapping
+            if (walletId) {
+                state.accountTree.wallets[walletId].groups[groupId].metadata.pinned =
+                    pinned;
+            }
+        });
+        if (walletId) {
+            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_publishAccountGroupUpdated).call(this, walletId, groupId);
+        }
+        // Trigger atomic sync for group pinning (only for groups from entropy wallets)
+        if (walletId &&
+            this.state.accountTree.wallets[walletId].type ===
+                account_api_1.AccountWalletType.Entropy) {
+            __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").enqueueSingleGroupSync(groupId);
+        }
+    }
+    /**
+     * Toggles the hidden state of an account group.
+     *
+     * @param groupId - The account group ID.
+     * @param hidden - Whether the group should be hidden.
+     * @throws If the account group ID is not found in the current tree.
+     */
+    setAccountGroupHidden(groupId, hidden) {
+        // Validate that the group exists in the current tree
+        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_assertAccountGroupExists).call(this, groupId);
+        const walletId = __classPrivateFieldGet(this, _AccountTreeController_groupIdToWalletId, "f").get(groupId);
+        this.update((state) => {
+            /* istanbul ignore next */
+            if (!state.accountGroupsMetadata[groupId]) {
+                state.accountGroupsMetadata[groupId] = {};
+            }
+            // Update persistent metadata
+            state.accountGroupsMetadata[groupId].hidden = {
+                value: hidden,
+                lastUpdatedAt: Date.now(),
+            };
+            // Update tree node directly using efficient mapping
+            if (walletId) {
+                state.accountTree.wallets[walletId].groups[groupId].metadata.hidden =
+                    hidden;
+            }
+        });
+        if (walletId) {
+            __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_publishAccountGroupUpdated).call(this, walletId, groupId);
+        }
+        // Trigger atomic sync for group hiding (only for groups from entropy wallets)
+        if (walletId &&
+            this.state.accountTree.wallets[walletId].type ===
+                account_api_1.AccountWalletType.Entropy) {
+            __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").enqueueSingleGroupSync(groupId);
+        }
+    }
+    /**
+     * Clears the controller state and resets to default values.
+     * Also clears the backup and sync service state.
+     */
+    clearState() {
+        (0, logger_js_1.projectLogger)('Clearing state');
+        const previousSelectedAccountGroup = this.state.selectedAccountGroup;
+        this.update(() => {
+            return {
+                ...getDefaultAccountTreeControllerState(),
+            };
+        });
+        __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").clearState();
+        // Clear in-memory reverse-lookup Maps so stale data is not accessible
+        // between this call and the next init().
+        __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").clear();
+        __classPrivateFieldGet(this, _AccountTreeController_groupIdToWalletId, "f").clear();
+        // Notify subscribers that the selected group has been cleared,
+        // mirroring what #setSelectedAccountGroup does on normal transitions.
+        this.messenger.publish(`${exports.controllerName}:selectedAccountGroupChange`, '', previousSelectedAccountGroup);
+        // So we know we have to call `init` again.
+        __classPrivateFieldSet(this, _AccountTreeController_initialized, false, "f");
+        this.messenger.publish(`${exports.controllerName}:uninitialized`);
+    }
+    /**
+     * Bi-directionally syncs the account tree with user storage.
+     * This will perform a full sync, including both pulling updates
+     * from user storage and pushing local changes to user storage.
+     * This also performs legacy account syncing if needed.
+     *
+     * IMPORTANT:
+     * If a full sync is already in progress, it will return the ongoing promise.
+     *
+     * @returns A promise that resolves when the sync is complete.
+     */
+    async syncWithUserStorage() {
+        return __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").performFullSync();
+    }
+    /**
+     * Bi-directionally syncs the account tree with user storage.
+     * This will ensure at least one full sync is ran, including both pulling updates
+     * from user storage and pushing local changes to user storage.
+     * This also performs legacy account syncing if needed.
+     *
+     * IMPORTANT:
+     * If the first ever full sync is already in progress, it will return the ongoing promise.
+     * If the first ever full sync was previously completed, it will NOT start a new sync, and will resolve immediately.
+     *
+     * @returns A promise that resolves when the first ever full sync is complete.
+     */
+    async syncWithUserStorageAtLeastOnce() {
+        return __classPrivateFieldGet(this, _AccountTreeController_backupAndSyncService, "f").performFullSyncAtLeastOnce();
+    }
+    /**
+     * Produces a versioned snapshot of the current wallet and group state.
+     *
+     * When `options.includeSecrets` is `true`, `options.password` is required
+     * and verified against the vault before any secret is read. Without
+     * `includeSecrets`, only metadata (names, pinned, hidden) is exported and
+     * no password is needed.
+     *
+     * @param options - Export options.
+     * @returns A promise resolving to an `AccountTreeSnapshot`.
+     * @throws If the vault is locked or the password is incorrect.
+     */
+    async exportState(options) {
+        return (0, export_js_1.exportState)({ getState: () => this.state, messenger: this.messenger }, options);
+    }
+    /**
+     * Applies a validated snapshot to the current state.
+     *
+     * Accepts an {@link AccountTreeSnapshot} only — untrusted wire data must be
+     * parsed with {@link AccountTreeSnapshot.deserialize} first. Callers may
+     * filter the snapshot with {@link AccountTreeSnapshot.filterWallets},
+     * {@link AccountTreeSnapshot.filterGroups}, or
+     * {@link AccountTreeSnapshot.filterAllGroups} before importing.
+     *
+     * New mnemonic wallets are imported via `MultichainAccountService` and new
+     * private-key accounts via `KeyringController`. Metadata (name, pinned,
+     * hidden) is applied to all existing and newly created wallets / groups.
+     *
+     * @param snapshot - The validated snapshot to import.
+     * @returns A promise that resolves when the import is complete.
+     */
+    async importState(snapshot) {
+        return (0, import_js_1.importState)({
+            getState: () => this.state,
+            messenger: this.messenger,
+            setWalletName: (id, name) => this.setAccountWalletName(id, name),
+            setAccountGroupName: (id, name) => this.setAccountGroupName(id, name, true),
+            setAccountGroupPinned: (id, pinned) => this.setAccountGroupPinned(id, pinned),
+            setAccountGroupHidden: (id, hidden) => this.setAccountGroupHidden(id, hidden),
+        }, snapshot);
+    }
+}
+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_accountOrderCallbacks = new WeakMap(), _AccountTreeController_initialized = new WeakMap(), _AccountTreeController_instances = new WeakSet(), _AccountTreeController_initTreeContext = function _AccountTreeController_initTreeContext(tree) {
+    // Fetch persisted accounts from the `AccountsController`.
+    const accounts = new Map(__classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_listAccounts).call(this).map((account) => [account.id, account]));
+    for (const [walletId, wallet] of Object.entries(tree.wallets)) {
+        for (const [groupId, group] of Object.entries(wallet.groups)) {
+            __classPrivateFieldGet(this, _AccountTreeController_groupIdToWalletId, "f").set(groupId, walletId);
+            // We still need to go through accounts for the sort order.
+            for (const accountId of group.accounts) {
+                const account = accounts.get(accountId);
+                // NOTE: The account should always be available, but if it is not, we
+                // still let it inside the tree with a max sort order to avoid blocking
+                // the entire tree construction.
+                let sortOrder = group_js_1.MAX_SORT_ORDER;
+                if (account) {
+                    sortOrder = group_js_1.ACCOUNT_TYPE_TO_SORT_ORDER[account.type];
+                }
+                __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").set(accountId, {
+                    walletId,
+                    groupId,
+                    sortOrder,
+                });
+            }
+        }
+    }
+}, _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(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;
+    }
+    else if (!wallet.metadata.name) {
+        // Generate default name if none exists
+        if (wallet.type === account_api_1.AccountWalletType.Entropy) {
+            wallet.metadata.name =
+                __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getEntropyRule).call(this).getDefaultAccountWalletName(wallet);
+        }
+        else if (wallet.type === account_api_1.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);
+        }
+        (0, logger_js_1.projectLogger)(`[${wallet.id}] Set default name to: "${wallet.metadata.name}"`);
+    }
+}, _AccountTreeController_getRuleForWallet = function _AccountTreeController_getRuleForWallet(wallet) {
+    switch (wallet.type) {
+        case account_api_1.AccountWalletType.Entropy:
+            return __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getEntropyRule).call(this);
+        case account_api_1.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) {
+        const account = this.messenger.call('AccountsController:getAccount', id);
+        if (!account?.metadata.name.length) {
+            continue;
+        }
+        // We only pick a new proposed name if we don't have one yet.
+        if (!proposedName) {
+            proposedName = account.metadata.name;
+        }
+        // But EVM accounts take precedence over any other computed names.
+        if ((0, keyring_api_1.isEvmAccountType)(account.type)) {
+            // So we just overwrite the proposed name and stop looping right away.
+            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_js_1.isAccountGroupNameUniqueFromWallet)(wallet, group.id, proposedName)) {
+        proposedName = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_resolveNameConflict).call(this, 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_js_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];
+    const persistedGroupMetadata = state.accountGroupsMetadata[groupId];
+    // Ensure metadata object exists once at the beginning
+    (_a = state.accountGroupsMetadata)[groupId] ?? (_a[groupId] = {});
+    // Apply persisted name if available (including empty strings)
+    if (persistedGroupMetadata?.name !== undefined) {
+        state.accountTree.wallets[walletId].groups[groupId].metadata.name =
+            persistedGroupMetadata.name.value;
+    }
+    else if (!group.metadata.name) {
+        let proposedName = '';
+        // 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_js_1.projectLogger)(`[${group.id}] Set default name to: "${group.metadata.name}"`);
+        // Persist the generated name to ensure consistency
+        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
+            // over a user-defined name, so we set `lastUpdatedAt` to 0.
+            lastUpdatedAt: 0,
+        };
+    }
+    // Apply persisted UI states
+    if (persistedGroupMetadata?.pinned?.value !== undefined) {
+        group.metadata.pinned = persistedGroupMetadata.pinned.value;
+    }
+    else {
+        let isPinned = false;
+        if (__classPrivateFieldGet(this, _AccountTreeController_accountOrderCallbacks, "f")?.isPinnedAccount) {
+            isPinned = group.accounts.some((account) => __classPrivateFieldGet(this, _AccountTreeController_accountOrderCallbacks, "f")?.isPinnedAccount?.(account));
+        }
+        state.accountGroupsMetadata[groupId].pinned = {
+            value: isPinned,
+            lastUpdatedAt: 0,
+        };
+        // If any accounts was previously pinned, then we consider the group to be pinned as well.
+        group.metadata.pinned = isPinned;
+    }
+    if (persistedGroupMetadata?.hidden?.value !== undefined) {
+        group.metadata.hidden = persistedGroupMetadata.hidden.value;
+    }
+    else {
+        let isHidden = false;
+        if (__classPrivateFieldGet(this, _AccountTreeController_accountOrderCallbacks, "f")?.isHiddenAccount) {
+            isHidden = group.accounts.some((account) => __classPrivateFieldGet(this, _AccountTreeController_accountOrderCallbacks, "f")?.isHiddenAccount?.(account));
+        }
+        state.accountGroupsMetadata[groupId].hidden = {
+            value: isHidden,
+            lastUpdatedAt: 0,
+        };
+        // If any accounts was previously hidden, then we consider the group to be hidden as well.
+        group.metadata.hidden = isHidden;
+    }
+    // Apply persisted lastSelected (plain number, not synced).
+    if (persistedGroupMetadata?.lastSelected !== undefined &&
+        persistedGroupMetadata.lastSelected >= 0) {
+        group.metadata.lastSelected = persistedGroupMetadata.lastSelected;
+    }
+    else {
+        // Automatiacally inject default value.
+        state.accountGroupsMetadata[groupId].lastSelected = 0;
+        group.metadata.lastSelected = 0;
+    }
+}, _AccountTreeController_handleAccountsAdded = function _AccountTreeController_handleAccountsAdded(accounts) {
+    // 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;
+    }
+    // Filter out accounts already known by the tree to avoid double-insertion.
+    const newAccounts = accounts.filter((account) => !__classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").has(account.id));
+    if (newAccounts.length === 0) {
+        return;
+    }
+    const createdGroups = new Map();
+    const updatedGroups = new Map();
+    this.update((state) => {
+        for (const account of newAccounts) {
+            const { walletId, groupId, created } = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_insert).call(this, state.accountTree.wallets, account);
+            if (created) {
+                createdGroups.set(groupId, walletId);
+            }
+            else if (!createdGroups.has(groupId)) {
+                // ^ We check that the group has not been created in this same batch before adding it to the `updatedGroups`
+                // map, to avoid sending both created and updated events for the same group:
+                // - Account 1 + Account 2 + Account 3
+                // - Account 1 and 3 belong to the same group
+                // - Account 1 will create the group
+                // - Account 3 will update the group (but we only want to send a created event, not an updated one)
+                updatedGroups.set(groupId, walletId);
+            }
+            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.messenger.publish(`${exports.controllerName}:accountTreeChange`, this.state.accountTree);
+    for (const [groupId, walletId] of createdGroups) {
+        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_publishAccountGroupCreated).call(this, walletId, groupId);
+    }
+    for (const [groupId, walletId] of updatedGroups) {
+        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_publishAccountGroupUpdated).call(this, walletId, groupId);
+    }
+}, _AccountTreeController_handleAccountsRemoved = function _AccountTreeController_handleAccountsRemoved(accountIds) {
+    // 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 knownAccounts = [];
+    for (const id of accountIds) {
+        const context = __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").get(id);
+        if (context) {
+            knownAccounts.push({ id, context });
+        }
+    }
+    if (knownAccounts.length === 0) {
+        return;
+    }
+    const previousSelectedAccountGroup = this.state.selectedAccountGroup;
+    const updatedGroups = new Map();
+    const removedGroups = new Set();
+    this.update((state) => {
+        for (const { id: accountId, context } of knownAccounts) {
+            const { walletId, groupId } = context;
+            const accounts = state.accountTree.wallets[walletId]?.groups[groupId]?.accounts;
+            if (accounts) {
+                const index = accounts.indexOf(accountId);
+                if (index !== -1) {
+                    accounts.splice(index, 1);
+                    if (state.selectedAccountGroup === groupId &&
+                        accounts.length === 0) {
+                        state.selectedAccountGroup = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getDefaultAccountGroupId).call(this, state.accountTree.wallets);
+                    }
+                }
+                if (accounts.length === 0) {
+                    __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_pruneEmptyGroupAndWallet).call(this, state, walletId, groupId);
+                    // If the group gets pruned, we should not consider it as updated.
+                    updatedGroups.delete(groupId);
+                    removedGroups.add(groupId);
+                }
+                else {
+                    updatedGroups.set(groupId, walletId);
+                }
+            }
+        }
+    });
+    // Clear reverse-mappings after the state update
+    for (const { id } of knownAccounts) {
+        __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").delete(id);
+    }
+    this.messenger.publish(`${exports.controllerName}:accountTreeChange`, this.state.accountTree);
+    for (const [groupId, walletId] of updatedGroups) {
+        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_publishAccountGroupUpdated).call(this, walletId, groupId);
+    }
+    for (const groupId of removedGroups) {
+        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_publishAccountGroupRemoved).call(this, groupId);
+    }
+    const newSelectedAccountGroup = this.state.selectedAccountGroup;
+    if (newSelectedAccountGroup !== previousSelectedAccountGroup) {
+        this.messenger.publish(`${exports.controllerName}:selectedAccountGroupChange`, newSelectedAccountGroup, previousSelectedAccountGroup);
+    }
+}, _AccountTreeController_pruneEmptyGroupAndWallet = function _AccountTreeController_pruneEmptyGroupAndWallet(state, walletId, groupId) {
+    const { wallets } = state.accountTree;
+    delete wallets[walletId].groups[groupId];
+    __classPrivateFieldGet(this, _AccountTreeController_groupIdToWalletId, "f").delete(groupId);
+    // Clean up metadata for the pruned group
+    delete state.accountGroupsMetadata[groupId];
+    if (Object.keys(wallets[walletId].groups).length === 0) {
+        delete wallets[walletId];
+        // Clean up metadata for the pruned wallet
+        delete state.accountWalletsMetadata[walletId];
+    }
+    return state;
+}, _AccountTreeController_publishAccountGroupCreated = function _AccountTreeController_publishAccountGroupCreated(walletId, groupId) {
+    const group = this.state.accountTree.wallets[walletId]?.groups[groupId];
+    if (group) {
+        this.messenger.publish(`${exports.controllerName}:accountGroupCreated`, group);
+    }
+}, _AccountTreeController_publishAccountGroupUpdated = function _AccountTreeController_publishAccountGroupUpdated(walletId, groupId) {
+    const group = this.state.accountTree.wallets[walletId]?.groups[groupId];
+    if (group) {
+        this.messenger.publish(`${exports.controllerName}:accountGroupUpdated`, group);
+    }
+}, _AccountTreeController_publishAccountGroupRemoved = function _AccountTreeController_publishAccountGroupRemoved(groupId) {
+    this.messenger.publish(`${exports.controllerName}:accountGroupRemoved`, groupId);
+}, _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) ??
+        __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getKeyringRule).call(this).match(account); // This one cannot fail.
+    // Update controller's state.
+    const walletId = result.wallet.id;
+    let wallet = wallets[walletId];
+    if (!wallet) {
+        (0, logger_js_1.projectLogger)(`[${walletId}] Added as new wallet`);
+        wallets[walletId] = {
+            ...result.wallet,
+            status: 'ready',
+            groups: {},
+            metadata: {
+                name: '', // Will get updated later.
+                ...result.wallet.metadata,
+            },
+            // We do need to type-cast since we're not narrowing `result` with
+            // the union tag `result.wallet.type`.
+        };
+        wallet = wallets[walletId];
+        // Trigger atomic sync for new wallet (only for entropy wallets)
+        if (wallet.type === account_api_1.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 = group_js_1.ACCOUNT_TYPE_TO_SORT_ORDER[type];
+    const created = !group;
+    if (!group) {
+        (0, logger_js_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: [id],
+            metadata: {
+                name: '',
+                ...{ pinned: false, hidden: false, lastSelected: 0 }, // Default UI states
+                ...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`.
+        };
+        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 === account_api_1.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 ?? group_js_1.MAX_SORT_ORDER) - (bSortOrder ?? group_js_1.MAX_SORT_ORDER));
+        });
+    }
+    (0, logger_js_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,
+    });
+    return { walletId: wallet.id, groupId: group.id, created };
+}, _AccountTreeController_listAccounts = function _AccountTreeController_listAccounts() {
+    return this.messenger.call('AccountsController:listMultichainAccounts');
+}, _AccountTreeController_assertAccountGroupExists = function _AccountTreeController_assertAccountGroupExists(groupId) {
+    const exists = __classPrivateFieldGet(this, _AccountTreeController_groupIdToWalletId, "f").has(groupId);
+    if (!exists) {
+        throw new Error('Account group not found in tree');
+    }
+}, _AccountTreeController_assertAccountWalletExists = function _AccountTreeController_assertAccountWalletExists(walletId) {
+    const exists = Boolean(this.state.accountTree.wallets[walletId]);
+    if (!exists) {
+        throw new Error('Account wallet not found in tree');
+    }
+}, _AccountTreeController_assertAccountGroupNameIsUnique = function _AccountTreeController_assertAccountGroupNameIsUnique(groupId, name) {
+    if (!(0, group_js_1.isAccountGroupNameUnique)(this.state, groupId, name)) {
+        throw new Error('Account group name already exists');
+    }
+}, _AccountTreeController_setSelectedAccountGroup = function _AccountTreeController_setSelectedAccountGroup(groupId, forwardSelectedAccount = true) {
+    const previousSelectedAccountGroup = this.state.selectedAccountGroup;
+    // Idempotent check - if the same group is already selected, do nothing
+    if (previousSelectedAccountGroup === groupId) {
+        return;
+    }
+    // Find the first account in this group to select
+    const accountToSelect = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getAccountFromAccountGroupId).call(this, groupId);
+    if (!accountToSelect) {
+        throw new Error('No accounts found in group');
+    }
+    this.update((state) => {
+        // Update our selected account group first.
+        state.selectedAccountGroup = groupId;
+        // Then update its associated metadata (lastSelected timestamp) to keep
+        // track of the most recently selected groups.
+        const now = Date.now();
+        /* istanbul ignore next */
+        if (!state.accountGroupsMetadata[groupId]) {
+            state.accountGroupsMetadata[groupId] = {};
+        }
+        state.accountGroupsMetadata[groupId].lastSelected = now;
+        const walletId = __classPrivateFieldGet(this, _AccountTreeController_groupIdToWalletId, "f").get(groupId);
+        if (walletId) {
+            state.accountTree.wallets[walletId].groups[groupId].metadata.lastSelected = now;
+        }
+    });
+    (0, logger_js_1.projectLogger)(`Selected group is now: [${this.state.selectedAccountGroup}]`);
+    this.messenger.publish(`${exports.controllerName}:selectedAccountGroupChange`, groupId, previousSelectedAccountGroup);
+    if (forwardSelectedAccount) {
+        // Update AccountsController - this will trigger selectedAccountChange event,
+        // but our handler is idempotent so it won't cause infinite loop
+        this.messenger.call('AccountsController:setSelectedAccount', accountToSelect.id);
+        (0, logger_js_1.projectLogger)(`Selected account is now: ${accountToSelect.id}`);
+    }
+}, _AccountTreeController_getDefaultSelectedAccountGroup = function _AccountTreeController_getDefaultSelectedAccountGroup(wallets) {
+    const selectedAccount = this.messenger.call('AccountsController:getSelectedMultichainAccount');
+    if (selectedAccount?.id) {
+        const accountMapping = __classPrivateFieldGet(this, _AccountTreeController_accountIdToContext, "f").get(selectedAccount.id);
+        if (accountMapping) {
+            const { groupId } = accountMapping;
+            return groupId;
+        }
+    }
+    // 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;
+    // Avoid infinite loop since this method is triggered by selected account change.
+    const forwardSelectedAccount = false;
+    __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_setSelectedAccountGroup).call(this, groupId, forwardSelectedAccount);
+}, _AccountTreeController_handleMultichainAccountWalletStatusChange = function _AccountTreeController_handleMultichainAccountWalletStatusChange(walletId, walletStatus) {
+    this.update((state) => {
+        const wallet = state.accountTree.wallets[walletId];
+        if (wallet) {
+            wallet.status = walletStatus;
+        }
+    });
+}, _AccountTreeController_getAccountGroup = function _AccountTreeController_getAccountGroup(groupId) {
+    const found = Object.values(this.state.accountTree.wallets).find((wallet) => wallet.groups[groupId] !== undefined);
+    return found?.groups[groupId];
+}, _AccountTreeController_getAccountFromAccountGroupId = function _AccountTreeController_getAccountFromAccountGroupId(groupId) {
+    const group = __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_getAccountGroup).call(this, groupId);
+    if (group) {
+        let candidateId;
+        for (const id of group.accounts) {
+            const account = this.messenger.call('AccountsController:getAccount', id);
+            if (account) {
+                candidateId ?? (candidateId = id);
+                if ((0, keyring_api_1.isEvmAccountType)(account.type)) {
+                    // EVM accounts have a higher priority, so if we find any, we just
+                    // use that account!
+                    return account;
+                }
+            }
+        }
+        return candidateId
+            ? this.messenger.call('AccountsController:getAccount', candidateId)
+            : undefined;
+    }
+    return undefined;
+}, _AccountTreeController_getDefaultAccountGroupId = function _AccountTreeController_getDefaultAccountGroupId(wallets) {
+    let candidate;
+    for (const wallet of Object.values(wallets)) {
+        for (const group of Object.values(wallet.groups)) {
+            if (group.accounts.length === 0) {
+                continue;
+            }
+            if (!candidate) {
+                candidate = group;
+                continue;
+            }
+            if (group.metadata.lastSelected > candidate.metadata.lastSelected) {
+                candidate = group;
+            }
+            else if (group.metadata.lastSelected === candidate.metadata.lastSelected &&
+                __classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_hasEvmAccount).call(this, group) &&
+                !__classPrivateFieldGet(this, _AccountTreeController_instances, "m", _AccountTreeController_hasEvmAccount).call(this, candidate)) {
+                candidate = group;
+            }
+        }
+    }
+    return candidate?.id ?? '';
+}, _AccountTreeController_hasEvmAccount = function _AccountTreeController_hasEvmAccount(group) {
+    for (const id of group.accounts) {
+        const account = this.messenger.call('AccountsController:getAccount', id);
+        if (account && (0, keyring_api_1.isEvmAccountType)(account.type)) {
+            return true;
+        }
+    }
+    return false;
+}, _AccountTreeController_resolveNameConflict = function _AccountTreeController_resolveNameConflict(wallet, groupId, name) {
+    let suffix = 2;
+    let candidateName = `${name} (${suffix})`;
+    // Keep incrementing suffix until we find a unique name
+    while (!(0, group_js_1.isAccountGroupNameUniqueFromWallet)(wallet, groupId, candidateName)) {
+        suffix += 1;
+        candidateName = `${name} (${suffix})`;
+    }
+    return candidateName;
+}, _AccountTreeController_createBackupAndSyncContext = function _AccountTreeController_createBackupAndSyncContext() {
+    return {
+        ...__classPrivateFieldGet(this, _AccountTreeController_backupAndSyncConfig, "f"),
+        controller: this,
+        messenger: this.messenger,
+        controllerStateUpdateFn: this.update.bind(this),
+        traceFn: __classPrivateFieldGet(this, _AccountTreeController_trace, "f").bind(this),
+        groupIdToWalletId: __classPrivateFieldGet(this, _AccountTreeController_groupIdToWalletId, "f"),
+        mutationTracker: (0, index_js_3.createSyncMutationTracker)(),
+    };
+};
+//# sourceMappingURL=AccountTreeController.cjs.map