@metamask/assets-controllers 94.0.0 → 94.1.0

package/dist/TokenBalancesController.mjs

@@ -9,7 +9,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     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 _TokenBalancesController_instances, _TokenBalancesController_platform, _TokenBalancesController_queryAllAccounts, _TokenBalancesController_accountsApiChainIds, _TokenBalancesController_balanceFetchers, _TokenBalancesController_allTokens, _TokenBalancesController_detectedTokens, _TokenBalancesController_allIgnoredTokens, _TokenBalancesController_defaultInterval, _TokenBalancesController_websocketActivePollingInterval, _TokenBalancesController_chainPollingConfig, _TokenBalancesController_intervalPollingTimers, _TokenBalancesController_isControllerPollingActive, _TokenBalancesController_requestedChainIds, _TokenBalancesController_statusChangeDebouncer, _TokenBalancesController_normalizeAccountAddresses, _TokenBalancesController_chainIdsWithTokens, _TokenBalancesController_getProvider, _TokenBalancesController_getNetworkClient, _TokenBalancesController_createAccountsApiFetcher, _TokenBalancesController_startIntervalGroupPolling, _TokenBalancesController_startPollingForInterval, _TokenBalancesController_setPollingTimer, _TokenBalancesController_isTokenTracked, _TokenBalancesController_onTokensChanged, _TokenBalancesController_onNetworkChanged, _TokenBalancesController_onAccountRemoved, _TokenBalancesController_onAccountChanged, _TokenBalancesController_prepareBalanceUpdates, _TokenBalancesController_onAccountActivityBalanceUpdate, _TokenBalancesController_onAccountActivityStatusChanged, _TokenBalancesController_processAccumulatedStatusChanges;
+var _TokenBalancesController_instances, _TokenBalancesController_platform, _TokenBalancesController_queryAllAccounts, _TokenBalancesController_accountsApiChainIds, _TokenBalancesController_allowExternalServices, _TokenBalancesController_isOnboarded, _TokenBalancesController_balanceFetchers, _TokenBalancesController_allTokens, _TokenBalancesController_detectedTokens, _TokenBalancesController_allIgnoredTokens, _TokenBalancesController_defaultInterval, _TokenBalancesController_websocketActivePollingInterval, _TokenBalancesController_chainPollingConfig, _TokenBalancesController_intervalPollingTimers, _TokenBalancesController_isControllerPollingActive, _TokenBalancesController_isUnlocked, _TokenBalancesController_requestedChainIds, _TokenBalancesController_statusChangeDebouncer, _TokenBalancesController_subscribeToControllers, _TokenBalancesController_registerActions, _TokenBalancesController_normalizeAccountAddresses, _TokenBalancesController_chainIdsWithTokens, _TokenBalancesController_getProvider, _TokenBalancesController_getNetworkClient, _TokenBalancesController_createAccountsApiFetcher, _TokenBalancesController_startIntervalGroupPolling, _TokenBalancesController_startPollingForInterval, _TokenBalancesController_setPollingTimer, _TokenBalancesController_stopAllPolling, _TokenBalancesController_getTargetChains, _TokenBalancesController_getAccountsAndJwt, _TokenBalancesController_fetchAllBalances, _TokenBalancesController_filterByTokenAddresses, _TokenBalancesController_getAccountsToProcess, _TokenBalancesController_applyTokenBalancesToState, _TokenBalancesController_buildNativeBalanceUpdates, _TokenBalancesController_buildStakedBalanceUpdates, _TokenBalancesController_importUntrackedTokens, _TokenBalancesController_isTokenTracked, _TokenBalancesController_onTokensChanged, _TokenBalancesController_onNetworkChanged, _TokenBalancesController_onAccountRemoved, _TokenBalancesController_onAccountChanged, _TokenBalancesController_prepareBalanceUpdates, _TokenBalancesController_onAccountActivityBalanceUpdate, _TokenBalancesController_onAccountActivityStatusChanged, _TokenBalancesController_processAccumulatedStatusChanges;
 import { Web3Provider } from "@ethersproject/providers";
 import { BNToHex, isValidHexAddress, safelyExecuteWithTimeout, toChecksumHexAddress, toHex } from "@metamask/controller-utils";
 import { StaticIntervalPollingController } from "@metamask/polling-controller";
@@ -31,19 +31,14 @@ const metadata = {
         usedInUi: true,
     },
 };
-// endregion
-// ────────────────────────────────────────────────────────────────────────────
-// region: Helper utilities
 const draft = (base, fn) => produce(base, fn);
 const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 const checksum = (addr) => toChecksumHexAddress(addr);
 /**
- * Convert CAIP chain ID or hex chain ID to hex chain ID
- * Handles both CAIP-2 format (e.g., "eip155:1") and hex format (e.g., "0x1")
+ * Convert CAIP chain ID or hex chain ID to hex chain ID.
  *
- * @param chainId - CAIP chain ID (e.g., "eip155:1") or hex chain ID (e.g., "0x1")
- * @returns Hex chain ID (e.g., "0x1")
- * @throws {Error} If chainId is neither a valid CAIP-2 chain ID nor a hex string
+ * @param chainId - CAIP chain ID or hex chain ID.
+ * @returns Hex chain ID.
  */
 export const caipChainIdToHex = (chainId) => {
     if (isStrictHexString(chainId)) {
@@ -55,32 +50,26 @@ export const caipChainIdToHex = (chainId) => {
     throw new Error('caipChainIdToHex - Failed to provide CAIP-2 or Hex chainId');
 };
 /**
- * Extract token address from asset type
- * Returns tuple of [tokenAddress, isNativeToken] or null if invalid
+ * Extract token address from asset type.
  *
- * @param assetType - Asset type string (e.g., 'eip155:1/erc20:0x...' or 'eip155:1/slip44:60')
- * @returns Tuple of [tokenAddress, isNativeToken] or null if invalid
+ * @param assetType - Asset type string.
+ * @returns Tuple of [tokenAddress, isNativeToken] or null if invalid.
  */
 export const parseAssetType = (assetType) => {
     if (!isCaipAssetType(assetType)) {
         return null;
     }
     const parsed = parseCaipAssetType(assetType);
-    // ERC20 token (e.g., "eip155:1/erc20:0x...")
     if (parsed.assetNamespace === 'erc20') {
         return [parsed.assetReference, false];
     }
-    // Native token (e.g., "eip155:1/slip44:60")
     if (parsed.assetNamespace === 'slip44') {
         return [ZERO_ADDRESS, true];
     }
     return null;
 };
-// endregion
-// ────────────────────────────────────────────────────────────────────────────
-// region: Main controller
 export class TokenBalancesController extends StaticIntervalPollingController() {
-    constructor({ messenger, interval = DEFAULT_INTERVAL_MS, websocketActivePollingInterval = DEFAULT_WEBSOCKET_ACTIVE_POLLING_INTERVAL_MS, chainPollingIntervals = {}, state = {}, queryMultipleAccounts = true, accountsApiChainIds = () => [], allowExternalServices = () => true, platform, }) {
+    constructor({ messenger, interval = DEFAULT_INTERVAL_MS, websocketActivePollingInterval = DEFAULT_WEBSOCKET_ACTIVE_POLLING_INTERVAL_MS, chainPollingIntervals = {}, state = {}, queryMultipleAccounts = true, accountsApiChainIds = () => [], allowExternalServices = () => true, platform, isOnboarded = () => true, }) {
         super({
             name: CONTROLLER,
             messenger,
@@ -91,6 +80,8 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
         _TokenBalancesController_platform.set(this, void 0);
         _TokenBalancesController_queryAllAccounts.set(this, void 0);
         _TokenBalancesController_accountsApiChainIds.set(this, void 0);
+        _TokenBalancesController_allowExternalServices.set(this, void 0);
+        _TokenBalancesController_isOnboarded.set(this, void 0);
         _TokenBalancesController_balanceFetchers.set(this, void 0);
         _TokenBalancesController_allTokens.set(this, {});
         _TokenBalancesController_detectedTokens.set(this, {});
@@ -105,6 +96,8 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
         _TokenBalancesController_intervalPollingTimers.set(this, new Map());
         /** Track if controller-level polling is active */
         _TokenBalancesController_isControllerPollingActive.set(this, false);
+        /** Track if the keyring is unlocked */
+        _TokenBalancesController_isUnlocked.set(this, false);
         /** Store original chainIds from startPolling to preserve intent */
         _TokenBalancesController_requestedChainIds.set(this, []);
         /** Debouncing for rapid status changes to prevent excessive HTTP calls */
@@ -114,52 +107,34 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
         });
         _TokenBalancesController_getProvider.set(this, (chainId) => {
             const { networkConfigurationsByChainId } = this.messenger.call('NetworkController:getState');
-            const cfg = networkConfigurationsByChainId[chainId];
-            const { networkClientId } = cfg.rpcEndpoints[cfg.defaultRpcEndpointIndex];
+            const networkConfig = networkConfigurationsByChainId[chainId];
+            const { networkClientId } = networkConfig.rpcEndpoints[networkConfig.defaultRpcEndpointIndex];
             const client = this.messenger.call('NetworkController:getNetworkClientById', networkClientId);
             return new Web3Provider(client.provider);
         });
         _TokenBalancesController_getNetworkClient.set(this, (chainId) => {
             const { networkConfigurationsByChainId } = this.messenger.call('NetworkController:getState');
-            const cfg = networkConfigurationsByChainId[chainId];
-            const { networkClientId } = cfg.rpcEndpoints[cfg.defaultRpcEndpointIndex];
+            const networkConfig = networkConfigurationsByChainId[chainId];
+            const { networkClientId } = networkConfig.rpcEndpoints[networkConfig.defaultRpcEndpointIndex];
             return this.messenger.call('NetworkController:getNetworkClientById', networkClientId);
         });
-        /**
-         * Creates an AccountsApiBalanceFetcher that only supports chains in the accountsApiChainIds array
-         *
-         * @returns A BalanceFetcher that wraps AccountsApiBalanceFetcher with chainId filtering
-         */
         _TokenBalancesController_createAccountsApiFetcher.set(this, () => {
             const originalFetcher = new AccountsApiBalanceFetcher(__classPrivateFieldGet(this, _TokenBalancesController_platform, "f"), __classPrivateFieldGet(this, _TokenBalancesController_getProvider, "f"));
             return {
-                supports: (chainId) => {
-                    // Only support chains that are both:
-                    // 1. In our specified accountsApiChainIds array
-                    // 2. Actually supported by the AccountsApi
-                    return (__classPrivateFieldGet(this, _TokenBalancesController_accountsApiChainIds, "f").call(this).includes(chainId) &&
-                        originalFetcher.supports(chainId));
-                },
+                // Dynamically check allowExternalServices() at call time, not just at construction time
+                supports: (chainId) => __classPrivateFieldGet(this, _TokenBalancesController_allowExternalServices, "f").call(this) &&
+                    __classPrivateFieldGet(this, _TokenBalancesController_accountsApiChainIds, "f").call(this).includes(chainId) &&
+                    originalFetcher.supports(chainId),
                 fetch: originalFetcher.fetch.bind(originalFetcher),
             };
         });
         _TokenBalancesController_onTokensChanged.set(this, async (state) => {
             const changed = [];
             let hasChanges = false;
-            // Get chains that have existing balances
-            const chainsWithBalances = new Set();
-            for (const address of Object.keys(this.state.tokenBalances)) {
-                const addressKey = address;
-                for (const chainId of Object.keys(this.state.tokenBalances[addressKey] || {})) {
-                    chainsWithBalances.add(chainId);
-                }
-            }
-            // Only process chains that are explicitly mentioned in the incoming state change
             const incomingChainIds = new Set([
                 ...Object.keys(state.allTokens),
                 ...Object.keys(state.allDetectedTokens),
             ]);
-            // Only proceed if there are actual changes to chains that have balances or are being added
             const relevantChainIds = Array.from(incomingChainIds).filter((chainId) => {
                 const id = chainId;
                 const hasTokensNow = (state.allTokens[id] && Object.keys(state.allTokens[id]).length > 0) ||
@@ -168,20 +143,16 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
                 const hadTokensBefore = (__classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")[id] && Object.keys(__classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")[id]).length > 0) ||
                     (__classPrivateFieldGet(this, _TokenBalancesController_detectedTokens, "f")[id] &&
                         Object.keys(__classPrivateFieldGet(this, _TokenBalancesController_detectedTokens, "f")[id]).length > 0);
-                // Check if there's an actual change in token state
                 const hasTokenChange = !isEqual(state.allTokens[id], __classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")[id]) ||
                     !isEqual(state.allDetectedTokens[id], __classPrivateFieldGet(this, _TokenBalancesController_detectedTokens, "f")[id]);
-                // Process chains that have actual changes OR are new chains getting tokens
                 return hasTokenChange || (!hadTokensBefore && hasTokensNow);
             });
-            if (relevantChainIds.length === 0) {
-                // No relevant changes, just update internal state
+            if (!relevantChainIds.length) {
                 __classPrivateFieldSet(this, _TokenBalancesController_allTokens, state.allTokens, "f");
                 __classPrivateFieldSet(this, _TokenBalancesController_detectedTokens, state.allDetectedTokens, "f");
                 return;
             }
-            // Handle both cleanup and updates in a single state update
-            this.update((s) => {
+            this.update((currentState) => {
                 for (const chainId of relevantChainIds) {
                     const id = chainId;
                     const hasTokensNow = (state.allTokens[id] &&
@@ -192,20 +163,20 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
                         Object.keys(__classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")[id]).length > 0) ||
                         (__classPrivateFieldGet(this, _TokenBalancesController_detectedTokens, "f")[id] &&
                             Object.keys(__classPrivateFieldGet(this, _TokenBalancesController_detectedTokens, "f")[id]).length > 0);
-                    if (!isEqual(state.allTokens[id], __classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")[id]) ||
-                        !isEqual(state.allDetectedTokens[id], __classPrivateFieldGet(this, _TokenBalancesController_detectedTokens, "f")[id])) {
-                        if (hasTokensNow) {
-                            // Chain still has tokens - mark for async balance update
-                            changed.push(id);
-                        }
-                        else if (hadTokensBefore) {
-                            // Chain had tokens before but doesn't now - clean up balances immediately
-                            for (const address of Object.keys(s.tokenBalances)) {
-                                const addressKey = address;
-                                if (s.tokenBalances[addressKey]?.[id]) {
-                                    s.tokenBalances[addressKey][id] = {};
-                                    hasChanges = true;
-                                }
+                    const tokensChanged = !isEqual(state.allTokens[id], __classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")[id]) ||
+                        !isEqual(state.allDetectedTokens[id], __classPrivateFieldGet(this, _TokenBalancesController_detectedTokens, "f")[id]);
+                    if (!tokensChanged) {
+                        continue;
+                    }
+                    if (hasTokensNow) {
+                        changed.push(id);
+                    }
+                    else if (hadTokensBefore) {
+                        for (const address of Object.keys(currentState.tokenBalances)) {
+                            const addressKey = address;
+                            if (currentState.tokenBalances[addressKey]?.[id]) {
+                                currentState.tokenBalances[addressKey][id] = {};
+                                hasChanges = true;
                             }
                         }
                     }
@@ -214,7 +185,6 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
             __classPrivateFieldSet(this, _TokenBalancesController_allTokens, state.allTokens, "f");
             __classPrivateFieldSet(this, _TokenBalancesController_detectedTokens, state.allDetectedTokens, "f");
             __classPrivateFieldSet(this, _TokenBalancesController_allIgnoredTokens, state.allIgnoredTokens, "f");
-            // Only update balances for chains that still have tokens (and only if we haven't already updated state)
             if (changed.length && !hasChanges) {
                 this.updateBalances({ chainIds: changed }).catch((error) => {
                     console.warn('Error updating balances after token change:', error);
@@ -222,9 +192,7 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
             }
         });
         _TokenBalancesController_onNetworkChanged.set(this, (state) => {
-            // Check if any networks were removed by comparing with previous state
             const currentNetworks = new Set(Object.keys(state.networkConfigurationsByChainId));
-            // Get all networks that currently have balances
             const networksWithBalances = new Set();
             for (const address of Object.keys(this.state.tokenBalances)) {
                 const addressKey = address;
@@ -232,83 +200,59 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
                     networksWithBalances.add(network);
                 }
             }
-            // Find networks that were removed
             const removedNetworks = Array.from(networksWithBalances).filter((network) => !currentNetworks.has(network));
-            if (removedNetworks.length > 0) {
-                this.update((s) => {
-                    // Remove balances for all accounts on the deleted networks
-                    for (const address of Object.keys(s.tokenBalances)) {
-                        const addressKey = address;
-                        for (const removedNetwork of removedNetworks) {
-                            const networkKey = removedNetwork;
-                            if (s.tokenBalances[addressKey]?.[networkKey]) {
-                                delete s.tokenBalances[addressKey][networkKey];
-                            }
+            if (!removedNetworks.length) {
+                return;
+            }
+            this.update((currentState) => {
+                for (const address of Object.keys(currentState.tokenBalances)) {
+                    const addressKey = address;
+                    for (const removedNetwork of removedNetworks) {
+                        const networkKey = removedNetwork;
+                        if (currentState.tokenBalances[addressKey]?.[networkKey]) {
+                            delete currentState.tokenBalances[addressKey][networkKey];
                         }
                     }
-                });
-            }
+                }
+            });
         });
         _TokenBalancesController_onAccountRemoved.set(this, (addr) => {
             if (!isStrictHexString(addr) || !isValidHexAddress(addr)) {
                 return;
             }
-            this.update((s) => {
-                delete s.tokenBalances[addr];
+            this.update((currentState) => {
+                delete currentState.tokenBalances[addr];
             });
         });
-        /**
-         * Handle account selection changes
-         * Triggers immediate balance fetch to ensure we have the latest balances
-         * since WebSocket only provides updates for changes going forward
-         */
         _TokenBalancesController_onAccountChanged.set(this, () => {
-            // Fetch balances for all chains with tokens when account changes
             const chainIds = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_chainIdsWithTokens).call(this);
-            if (chainIds.length > 0) {
-                this.updateBalances({ chainIds }).catch(() => {
-                    // Silently handle polling errors
-                });
+            if (!chainIds.length) {
+                return;
             }
+            this.updateBalances({ chainIds }).catch(() => {
+                // Silently handle polling errors
+            });
         });
-        // ────────────────────────────────────────────────────────────────────────────
-        // AccountActivityService event handlers
-        /**
-         * Handle real-time balance updates from AccountActivityService
-         * Processes balance updates and updates the token balance state
-         * If any balance update has an error, triggers fallback polling for the chain
-         *
-         * @param options0 - Balance update parameters
-         * @param options0.address - Account address
-         * @param options0.chain - CAIP chain identifier
-         * @param options0.updates - Array of balance updates for the account
-         */
         _TokenBalancesController_onAccountActivityBalanceUpdate.set(this, async ({ address, chain, updates, }) => {
             const chainId = caipChainIdToHex(chain);
             const checksummedAccount = checksum(address);
             try {
-                // Process all balance updates at once
                 const { tokenBalances, newTokens, nativeBalanceUpdates } = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_prepareBalanceUpdates).call(this, updates, checksummedAccount, chainId);
-                // Update state once with all token balances
                 if (tokenBalances.length > 0) {
                     this.update((state) => {
                         var _a, _b;
-                        // Temporary until ADR to normalize all keys - tokenBalances state requires: account in lowercase, token in checksum
                         const lowercaseAccount = checksummedAccount.toLowerCase();
                         (_a = state.tokenBalances)[lowercaseAccount] ?? (_a[lowercaseAccount] = {});
                         (_b = state.tokenBalances[lowercaseAccount])[chainId] ?? (_b[chainId] = {});
-                        // Apply all token balance updates
                         for (const { tokenAddress, balance } of tokenBalances) {
                             state.tokenBalances[lowercaseAccount][chainId][tokenAddress] =
                                 balance;
                         }
                     });
                 }
-                // Update native balances in AccountTrackerController
                 if (nativeBalanceUpdates.length > 0) {
                     this.messenger.call('AccountTrackerController:updateNativeBalances', nativeBalanceUpdates);
                 }
-                // Import any new tokens that were discovered (balance already updated from websocket)
                 if (newTokens.length > 0) {
                     await this.messenger.call('TokenDetectionController:addDetectedTokensViaWs', {
                         tokensSlice: newTokens,
@@ -319,349 +263,206 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
             catch (error) {
                 console.warn(`Error updating balances from AccountActivityService for chain ${chain}, account ${address}:`, error);
                 console.warn('Balance update data:', JSON.stringify(updates, null, 2));
-                // On error, trigger fallback polling
                 await this.updateBalances({ chainIds: [chainId] }).catch(() => {
                     // Silently handle polling errors
                 });
             }
         });
-        /**
-         * Handle status changes from AccountActivityService
-         * Uses aggressive debouncing to prevent excessive HTTP calls from rapid up/down changes
-         *
-         * @param options0 - Status change event data
-         * @param options0.chainIds - Array of chain identifiers
-         * @param options0.status - Connection status ('up' for connected, 'down' for disconnected)
-         */
         _TokenBalancesController_onAccountActivityStatusChanged.set(this, ({ chainIds, status, }) => {
-            // Update pending changes (latest status wins for each chain)
             for (const chainId of chainIds) {
                 __classPrivateFieldGet(this, _TokenBalancesController_statusChangeDebouncer, "f").pendingChanges.set(chainId, status);
             }
-            // Clear existing timer to extend debounce window
             if (__classPrivateFieldGet(this, _TokenBalancesController_statusChangeDebouncer, "f").timer) {
                 clearTimeout(__classPrivateFieldGet(this, _TokenBalancesController_statusChangeDebouncer, "f").timer);
             }
-            // Set new timer - only process changes after activity settles
             __classPrivateFieldGet(this, _TokenBalancesController_statusChangeDebouncer, "f").timer = setTimeout(() => {
                 __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_processAccumulatedStatusChanges).call(this);
-            }, 5000); // 5-second debounce window
+            }, 5000);
         });
-        // Normalize all account addresses to lowercase in existing state
         __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_normalizeAccountAddresses).call(this);
         __classPrivateFieldSet(this, _TokenBalancesController_platform, platform ?? 'extension', "f");
         __classPrivateFieldSet(this, _TokenBalancesController_queryAllAccounts, queryMultipleAccounts, "f");
         __classPrivateFieldSet(this, _TokenBalancesController_accountsApiChainIds, accountsApiChainIds, "f");
+        __classPrivateFieldSet(this, _TokenBalancesController_allowExternalServices, allowExternalServices, "f");
+        __classPrivateFieldSet(this, _TokenBalancesController_isOnboarded, isOnboarded, "f");
         __classPrivateFieldSet(this, _TokenBalancesController_defaultInterval, interval, "f");
         __classPrivateFieldSet(this, _TokenBalancesController_websocketActivePollingInterval, websocketActivePollingInterval, "f");
         __classPrivateFieldSet(this, _TokenBalancesController_chainPollingConfig, { ...chainPollingIntervals }, "f");
-        // Strategy order: API first, then RPC fallback
+        // Always include AccountsApiFetcher - it dynamically checks allowExternalServices() in supports()
         __classPrivateFieldSet(this, _TokenBalancesController_balanceFetchers, [
-            ...(accountsApiChainIds().length > 0 && allowExternalServices()
-                ? [__classPrivateFieldGet(this, _TokenBalancesController_createAccountsApiFetcher, "f").call(this)]
-                : []),
+            __classPrivateFieldGet(this, _TokenBalancesController_createAccountsApiFetcher, "f").call(this),
             new RpcBalanceFetcher(__classPrivateFieldGet(this, _TokenBalancesController_getProvider, "f"), __classPrivateFieldGet(this, _TokenBalancesController_getNetworkClient, "f"), () => ({
                 allTokens: __classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f"),
                 allDetectedTokens: __classPrivateFieldGet(this, _TokenBalancesController_detectedTokens, "f"),
             })),
         ], "f");
         this.setIntervalLength(interval);
-        // initial token state & subscriptions
         const { allTokens, allDetectedTokens, allIgnoredTokens } = this.messenger.call('TokensController:getState');
         __classPrivateFieldSet(this, _TokenBalancesController_allTokens, allTokens, "f");
         __classPrivateFieldSet(this, _TokenBalancesController_detectedTokens, allDetectedTokens, "f");
         __classPrivateFieldSet(this, _TokenBalancesController_allIgnoredTokens, allIgnoredTokens, "f");
-        this.messenger.subscribe('TokensController:stateChange', (tokensState) => {
-            __classPrivateFieldGet(this, _TokenBalancesController_onTokensChanged, "f").call(this, tokensState).catch((error) => {
-                console.warn('Error handling token state change:', error);
-            });
-        });
-        this.messenger.subscribe('NetworkController:stateChange', __classPrivateFieldGet(this, _TokenBalancesController_onNetworkChanged, "f"));
-        this.messenger.subscribe('KeyringController:accountRemoved', __classPrivateFieldGet(this, _TokenBalancesController_onAccountRemoved, "f"));
-        this.messenger.subscribe('AccountsController:selectedEvmAccountChange', __classPrivateFieldGet(this, _TokenBalancesController_onAccountChanged, "f"));
-        // Register action handlers for polling interval control
-        this.messenger.registerActionHandler(`TokenBalancesController:updateChainPollingConfigs`, this.updateChainPollingConfigs.bind(this));
-        this.messenger.registerActionHandler(`TokenBalancesController:getChainPollingConfig`, this.getChainPollingConfig.bind(this));
-        // Subscribe to AccountActivityService balance updates for real-time updates
-        this.messenger.subscribe('AccountActivityService:balanceUpdated', __classPrivateFieldGet(this, _TokenBalancesController_onAccountActivityBalanceUpdate, "f").bind(this));
-        // Subscribe to AccountActivityService status changes for dynamic polling management
-        this.messenger.subscribe('AccountActivityService:statusChanged', __classPrivateFieldGet(this, _TokenBalancesController_onAccountActivityStatusChanged, "f").bind(this));
+        const { isUnlocked } = this.messenger.call('KeyringController:getState');
+        __classPrivateFieldSet(this, _TokenBalancesController_isUnlocked, isUnlocked, "f");
+        __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_subscribeToControllers).call(this);
+        __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_registerActions).call(this);
     }
     /**
-     * Override to support per-chain polling intervals by grouping chains by interval
+     * Whether the controller is active (keyring is unlocked and user is onboarded).
+     * When locked or not onboarded, balance updates should be skipped.
      *
-     * @param options0 - The polling options
-     * @param options0.chainIds - Chain IDs to start polling for
+     * @returns Whether the controller should perform balance updates.
      */
+    get isActive() {
+        return __classPrivateFieldGet(this, _TokenBalancesController_isUnlocked, "f") && __classPrivateFieldGet(this, _TokenBalancesController_isOnboarded, "f").call(this);
+    }
     _startPolling({ chainIds }) {
-        // Store the original chainIds to preserve intent across config updates
         __classPrivateFieldSet(this, _TokenBalancesController_requestedChainIds, [...chainIds], "f");
         __classPrivateFieldSet(this, _TokenBalancesController_isControllerPollingActive, true, "f");
         __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_startIntervalGroupPolling).call(this, chainIds, true);
     }
-    /**
-     * Override to handle our custom polling approach
-     *
-     * @param tokenSetId - The token set ID to stop polling for
-     */
     _stopPollingByPollingTokenSetId(tokenSetId) {
-        let parsedTokenSetId;
         let chainsToStop = [];
         try {
-            parsedTokenSetId = JSON.parse(tokenSetId);
-            chainsToStop = parsedTokenSetId.chainIds || [];
+            const parsedTokenSetId = JSON.parse(tokenSetId);
+            chainsToStop = parsedTokenSetId.chainIds ?? [];
         }
         catch (error) {
             console.warn('Failed to parse tokenSetId, stopping all polling:', error);
-            // Fallback: stop all polling if we can't parse the tokenSetId
-            __classPrivateFieldSet(this, _TokenBalancesController_isControllerPollingActive, false, "f");
-            __classPrivateFieldSet(this, _TokenBalancesController_requestedChainIds, [], "f");
-            __classPrivateFieldGet(this, _TokenBalancesController_intervalPollingTimers, "f").forEach((timer) => clearInterval(timer));
-            __classPrivateFieldGet(this, _TokenBalancesController_intervalPollingTimers, "f").clear();
+            __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_stopAllPolling).call(this);
             return;
         }
-        // Compare with current chains - only stop if it matches our current session
         const currentChainsSet = new Set(__classPrivateFieldGet(this, _TokenBalancesController_requestedChainIds, "f"));
         const stopChainsSet = new Set(chainsToStop);
-        // Check if this stop request is for our current session
         const isCurrentSession = currentChainsSet.size === stopChainsSet.size &&
             [...currentChainsSet].every((chain) => stopChainsSet.has(chain));
         if (isCurrentSession) {
-            __classPrivateFieldSet(this, _TokenBalancesController_isControllerPollingActive, false, "f");
-            __classPrivateFieldSet(this, _TokenBalancesController_requestedChainIds, [], "f");
-            __classPrivateFieldGet(this, _TokenBalancesController_intervalPollingTimers, "f").forEach((timer) => clearInterval(timer));
-            __classPrivateFieldGet(this, _TokenBalancesController_intervalPollingTimers, "f").clear();
+            __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_stopAllPolling).call(this);
         }
     }
-    /**
-     * Get polling configuration for a chain (includes default fallback)
-     *
-     * @param chainId - The chain ID to get config for
-     * @returns The polling configuration for the chain
-     */
     getChainPollingConfig(chainId) {
         return (__classPrivateFieldGet(this, _TokenBalancesController_chainPollingConfig, "f")[chainId] ?? {
             interval: __classPrivateFieldGet(this, _TokenBalancesController_defaultInterval, "f"),
         });
     }
     async _executePoll({ chainIds, queryAllAccounts = false, }) {
-        // This won't be called with our custom implementation, but keep for compatibility
         await this.updateBalances({ chainIds, queryAllAccounts });
     }
-    /**
-     * Update multiple chain polling configurations at once
-     *
-     * @param configs - Object mapping chain IDs to polling configurations
-     * @param options - Optional configuration for the update behavior
-     * @param options.immediateUpdate - Whether to immediately fetch balances after updating configs (default: true)
-     */
     updateChainPollingConfigs(configs, options = { immediateUpdate: true }) {
         Object.assign(__classPrivateFieldGet(this, _TokenBalancesController_chainPollingConfig, "f"), configs);
-        // If polling is currently active, restart with new interval groupings
         if (__classPrivateFieldGet(this, _TokenBalancesController_isControllerPollingActive, "f")) {
-            // Restart polling with immediate fetch by default, unless explicitly disabled
             __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_startIntervalGroupPolling).call(this, __classPrivateFieldGet(this, _TokenBalancesController_requestedChainIds, "f"), options.immediateUpdate);
         }
     }
-    async updateBalances({ chainIds, queryAllAccounts = false, } = {}) {
-        const targetChains = chainIds ?? __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_chainIdsWithTokens).call(this);
-        if (!targetChains.length) {
+    async updateBalances({ chainIds, tokenAddresses, queryAllAccounts = false, } = {}) {
+        if (!this.isActive) {
             return;
         }
-        const { address: selected } = this.messenger.call('AccountsController:getSelectedAccount');
-        const allAccounts = this.messenger.call('AccountsController:listAccounts');
-        const jwtToken = await safelyExecuteWithTimeout(() => {
-            return this.messenger.call('AuthenticationController:getBearerToken');
-        }, false, 5000);
-        const aggregated = [];
-        let remainingChains = [...targetChains];
-        // Try each fetcher in order, removing successfully processed chains
-        for (const fetcher of __classPrivateFieldGet(this, _TokenBalancesController_balanceFetchers, "f")) {
-            const supportedChains = remainingChains.filter((c) => fetcher.supports(c));
-            if (!supportedChains.length) {
-                continue;
-            }
-            try {
-                const result = await fetcher.fetch({
-                    chainIds: supportedChains,
-                    queryAllAccounts: queryAllAccounts ?? __classPrivateFieldGet(this, _TokenBalancesController_queryAllAccounts, "f"),
-                    selectedAccount: selected,
-                    allAccounts,
-                    jwtToken,
-                });
-                if (result.balances && result.balances.length > 0) {
-                    aggregated.push(...result.balances);
-                    // Remove chains that were successfully processed
-                    const processedChains = new Set(result.balances.map((b) => b.chainId));
-                    remainingChains = remainingChains.filter((chain) => !processedChains.has(chain));
-                }
-                // Add unprocessed chains back to remainingChains for next fetcher
-                if (result.unprocessedChainIds &&
-                    result.unprocessedChainIds.length > 0) {
-                    const currentRemainingChains = remainingChains;
-                    const chainsToAdd = result.unprocessedChainIds.filter((chainId) => supportedChains.includes(chainId) &&
-                        !currentRemainingChains.includes(chainId));
-                    remainingChains.push(...chainsToAdd);
-                }
-            }
-            catch (error) {
-                console.warn(`Balance fetcher failed for chains ${supportedChains.join(', ')}: ${String(error)}`);
-                // Continue to next fetcher (fallback)
-            }
-            // If all chains have been processed, break early
-            if (remainingChains.length === 0) {
-                break;
-            }
+        const targetChains = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_getTargetChains).call(this, chainIds);
+        if (!targetChains.length) {
+            return;
         }
-        // Determine which accounts to process based on queryAllAccounts parameter
-        const accountsToProcess = (queryAllAccounts ?? __classPrivateFieldGet(this, _TokenBalancesController_queryAllAccounts, "f"))
-            ? allAccounts.map((a) => a.address)
-            : [selected];
+        const { selectedAccount, allAccounts, jwtToken } = await __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_getAccountsAndJwt).call(this);
+        const aggregatedBalances = await __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_fetchAllBalances).call(this, {
+            targetChains,
+            selectedAccount,
+            allAccounts,
+            jwtToken,
+            queryAllAccounts: queryAllAccounts ?? __classPrivateFieldGet(this, _TokenBalancesController_queryAllAccounts, "f"),
+        });
+        const filteredAggregated = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_filterByTokenAddresses).call(this, aggregatedBalances, tokenAddresses);
+        const accountsToProcess = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_getAccountsToProcess).call(this, queryAllAccounts, allAccounts, selectedAccount);
         const prev = this.state;
-        const next = draft(prev, (d) => {
-            var _a, _b;
-            // Initialize account and chain structures if they don't exist, but preserve existing balances
-            for (const chainId of targetChains) {
-                for (const account of accountsToProcess) {
-                    // Ensure the nested structure exists without overwriting existing balances
-                    (_a = d.tokenBalances)[account] ?? (_a[account] = {});
-                    (_b = d.tokenBalances[account])[chainId] ?? (_b[chainId] = {});
-                    // Initialize tokens from allTokens only if they don't exist yet
-                    const chainTokens = __classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")[chainId];
-                    if (chainTokens?.[account]) {
-                        Object.values(chainTokens[account]).forEach((token) => {
-                            const tokenAddress = checksum(token.address);
-                            // Only initialize if the token balance doesn't exist yet
-                            if (!(tokenAddress in d.tokenBalances[account][chainId])) {
-                                d.tokenBalances[account][chainId][tokenAddress] = '0x0';
-                            }
-                        });
-                    }
-                    // Initialize tokens from allDetectedTokens only if they don't exist yet
-                    const detectedChainTokens = __classPrivateFieldGet(this, _TokenBalancesController_detectedTokens, "f")[chainId];
-                    if (detectedChainTokens?.[account]) {
-                        Object.values(detectedChainTokens[account]).forEach((token) => {
-                            const tokenAddress = checksum(token.address);
-                            // Only initialize if the token balance doesn't exist yet
-                            if (!(tokenAddress in d.tokenBalances[account][chainId])) {
-                                d.tokenBalances[account][chainId][tokenAddress] = '0x0';
-                            }
-                        });
-                    }
-                }
-            }
-            // Update with actual fetched balances only if the value has changed
-            aggregated.forEach(({ success, value, account, token, chainId }) => {
-                var _a, _b;
-                if (success && value !== undefined) {
-                    // Ensure all accounts we add/update are in lower-case
-                    const lowerCaseAccount = account.toLowerCase();
-                    const newBalance = toHex(value);
-                    const tokenAddress = checksum(token);
-                    const currentBalance = d.tokenBalances[lowerCaseAccount]?.[chainId]?.[tokenAddress];
-                    // Only update if the balance has actually changed
-                    if (currentBalance !== newBalance) {
-                        ((_b = ((_a = d.tokenBalances)[lowerCaseAccount] ?? (_a[lowerCaseAccount] = {})))[chainId] ?? (_b[chainId] = {}))[tokenAddress] = newBalance;
-                    }
-                }
-            });
+        const next = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_applyTokenBalancesToState).call(this, {
+            prev,
+            targetChains,
+            accountsToProcess,
+            balances: filteredAggregated,
         });
         if (!isEqual(prev, next)) {
             this.update(() => next);
-            const nativeBalances = aggregated.filter((r) => r.success && r.token === ZERO_ADDRESS);
-            // Get current AccountTracker state to compare existing balances
             const accountTrackerState = this.messenger.call('AccountTrackerController:getState');
-            // Update native token balances only if they have changed
-            if (nativeBalances.length > 0) {
-                const balanceUpdates = nativeBalances
-                    .map((balance) => ({
-                    address: balance.account,
-                    chainId: balance.chainId,
-                    balance: balance.value ? BNToHex(balance.value) : '0x0',
-                }))
-                    .filter((update) => {
-                    const currentBalance = accountTrackerState.accountsByChainId[update.chainId]?.[checksum(update.address)]?.balance;
-                    // Only include if the balance has actually changed
-                    return currentBalance !== update.balance;
-                });
-                if (balanceUpdates.length > 0) {
-                    this.messenger.call('AccountTrackerController:updateNativeBalances', balanceUpdates);
-                }
+            const nativeUpdates = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_buildNativeBalanceUpdates).call(this, filteredAggregated, accountTrackerState);
+            if (nativeUpdates.length > 0) {
+                this.messenger.call('AccountTrackerController:updateNativeBalances', nativeUpdates);
             }
-            // Filter and update staked balances in a single batch operation for better performance
-            const stakedBalances = aggregated.filter((r) => {
-                if (!r.success || r.token === ZERO_ADDRESS) {
-                    return false;
-                }
-                // Check if the chainId and token address match any staking contract
-                const stakingContractAddress = STAKING_CONTRACT_ADDRESS_BY_CHAINID[r.chainId];
-                return (stakingContractAddress &&
-                    stakingContractAddress.toLowerCase() === r.token.toLowerCase());
-            });
-            if (stakedBalances.length > 0) {
-                const stakedBalanceUpdates = stakedBalances
-                    .map((balance) => ({
-                    address: balance.account,
-                    chainId: balance.chainId,
-                    stakedBalance: balance.value ? toHex(balance.value) : '0x0',
-                }))
-                    .filter((update) => {
-                    const currentStakedBalance = accountTrackerState.accountsByChainId[update.chainId]?.[checksum(update.address)]?.stakedBalance;
-                    // Only include if the staked balance has actually changed
-                    return currentStakedBalance !== update.stakedBalance;
-                });
-                if (stakedBalanceUpdates.length > 0) {
-                    this.messenger.call('AccountTrackerController:updateStakedBalances', stakedBalanceUpdates);
-                }
+            const stakedUpdates = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_buildStakedBalanceUpdates).call(this, filteredAggregated, accountTrackerState);
+            if (stakedUpdates.length > 0) {
+                this.messenger.call('AccountTrackerController:updateStakedBalances', stakedUpdates);
             }
         }
+        await __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_importUntrackedTokens).call(this, filteredAggregated);
     }
     resetState() {
         this.update(() => ({ tokenBalances: {} }));
     }
-    /**
-     * Clean up all timers and resources when controller is destroyed
-     */
     destroy() {
         __classPrivateFieldSet(this, _TokenBalancesController_isControllerPollingActive, false, "f");
         __classPrivateFieldGet(this, _TokenBalancesController_intervalPollingTimers, "f").forEach((timer) => clearInterval(timer));
         __classPrivateFieldGet(this, _TokenBalancesController_intervalPollingTimers, "f").clear();
-        // Clean up debouncing timer
         if (__classPrivateFieldGet(this, _TokenBalancesController_statusChangeDebouncer, "f").timer) {
             clearTimeout(__classPrivateFieldGet(this, _TokenBalancesController_statusChangeDebouncer, "f").timer);
             __classPrivateFieldGet(this, _TokenBalancesController_statusChangeDebouncer, "f").timer = null;
         }
-        // Unregister action handlers
         this.messenger.unregisterActionHandler(`TokenBalancesController:updateChainPollingConfigs`);
         this.messenger.unregisterActionHandler(`TokenBalancesController:getChainPollingConfig`);
         super.destroy();
     }
 }
-_TokenBalancesController_platform = new WeakMap(), _TokenBalancesController_queryAllAccounts = new WeakMap(), _TokenBalancesController_accountsApiChainIds = new WeakMap(), _TokenBalancesController_balanceFetchers = new WeakMap(), _TokenBalancesController_allTokens = new WeakMap(), _TokenBalancesController_detectedTokens = new WeakMap(), _TokenBalancesController_allIgnoredTokens = new WeakMap(), _TokenBalancesController_defaultInterval = new WeakMap(), _TokenBalancesController_websocketActivePollingInterval = new WeakMap(), _TokenBalancesController_chainPollingConfig = new WeakMap(), _TokenBalancesController_intervalPollingTimers = new WeakMap(), _TokenBalancesController_isControllerPollingActive = new WeakMap(), _TokenBalancesController_requestedChainIds = new WeakMap(), _TokenBalancesController_statusChangeDebouncer = new WeakMap(), _TokenBalancesController_getProvider = new WeakMap(), _TokenBalancesController_getNetworkClient = new WeakMap(), _TokenBalancesController_createAccountsApiFetcher = new WeakMap(), _TokenBalancesController_onTokensChanged = new WeakMap(), _TokenBalancesController_onNetworkChanged = new WeakMap(), _TokenBalancesController_onAccountRemoved = new WeakMap(), _TokenBalancesController_onAccountChanged = new WeakMap(), _TokenBalancesController_onAccountActivityBalanceUpdate = new WeakMap(), _TokenBalancesController_onAccountActivityStatusChanged = new WeakMap(), _TokenBalancesController_instances = new WeakSet(), _TokenBalancesController_normalizeAccountAddresses = function _TokenBalancesController_normalizeAccountAddresses() {
+_TokenBalancesController_platform = new WeakMap(), _TokenBalancesController_queryAllAccounts = new WeakMap(), _TokenBalancesController_accountsApiChainIds = new WeakMap(), _TokenBalancesController_allowExternalServices = new WeakMap(), _TokenBalancesController_isOnboarded = new WeakMap(), _TokenBalancesController_balanceFetchers = new WeakMap(), _TokenBalancesController_allTokens = new WeakMap(), _TokenBalancesController_detectedTokens = new WeakMap(), _TokenBalancesController_allIgnoredTokens = new WeakMap(), _TokenBalancesController_defaultInterval = new WeakMap(), _TokenBalancesController_websocketActivePollingInterval = new WeakMap(), _TokenBalancesController_chainPollingConfig = new WeakMap(), _TokenBalancesController_intervalPollingTimers = new WeakMap(), _TokenBalancesController_isControllerPollingActive = new WeakMap(), _TokenBalancesController_isUnlocked = new WeakMap(), _TokenBalancesController_requestedChainIds = new WeakMap(), _TokenBalancesController_statusChangeDebouncer = new WeakMap(), _TokenBalancesController_getProvider = new WeakMap(), _TokenBalancesController_getNetworkClient = new WeakMap(), _TokenBalancesController_createAccountsApiFetcher = new WeakMap(), _TokenBalancesController_onTokensChanged = new WeakMap(), _TokenBalancesController_onNetworkChanged = new WeakMap(), _TokenBalancesController_onAccountRemoved = new WeakMap(), _TokenBalancesController_onAccountChanged = new WeakMap(), _TokenBalancesController_onAccountActivityBalanceUpdate = new WeakMap(), _TokenBalancesController_onAccountActivityStatusChanged = new WeakMap(), _TokenBalancesController_instances = new WeakSet(), _TokenBalancesController_subscribeToControllers = function _TokenBalancesController_subscribeToControllers() {
+    this.messenger.subscribe('TokensController:stateChange', (tokensState) => {
+        __classPrivateFieldGet(this, _TokenBalancesController_onTokensChanged, "f").call(this, tokensState).catch((error) => {
+            console.warn('Error handling token state change:', error);
+        });
+    });
+    this.messenger.subscribe('NetworkController:stateChange', __classPrivateFieldGet(this, _TokenBalancesController_onNetworkChanged, "f"));
+    this.messenger.subscribe('KeyringController:unlock', () => {
+        __classPrivateFieldSet(this, _TokenBalancesController_isUnlocked, true, "f");
+    });
+    this.messenger.subscribe('KeyringController:lock', () => {
+        __classPrivateFieldSet(this, _TokenBalancesController_isUnlocked, false, "f");
+    });
+    this.messenger.subscribe('KeyringController:accountRemoved', __classPrivateFieldGet(this, _TokenBalancesController_onAccountRemoved, "f"));
+    this.messenger.subscribe('AccountsController:selectedEvmAccountChange', __classPrivateFieldGet(this, _TokenBalancesController_onAccountChanged, "f"));
+    this.messenger.subscribe('AccountActivityService:balanceUpdated', (event) => {
+        __classPrivateFieldGet(this, _TokenBalancesController_onAccountActivityBalanceUpdate, "f").call(this, event).catch((error) => {
+            console.warn('Error handling balance update:', error);
+        });
+    });
+    this.messenger.subscribe('AccountActivityService:statusChanged', __classPrivateFieldGet(this, _TokenBalancesController_onAccountActivityStatusChanged, "f").bind(this));
+    this.messenger.subscribe('TransactionController:transactionConfirmed', (transactionMeta) => {
+        this.updateBalances({
+            chainIds: [transactionMeta.chainId],
+        }).catch(() => {
+            // Silently handle balance update errors
+        });
+    });
+    this.messenger.subscribe('TransactionController:incomingTransactionsReceived', (incomingTransactions) => {
+        this.updateBalances({
+            chainIds: incomingTransactions.map((tx) => tx.chainId),
+        }).catch(() => {
+            // Silently handle balance update errors
+        });
+    });
+}, _TokenBalancesController_registerActions = function _TokenBalancesController_registerActions() {
+    this.messenger.registerActionHandler(`TokenBalancesController:updateChainPollingConfigs`, this.updateChainPollingConfigs.bind(this));
+    this.messenger.registerActionHandler(`TokenBalancesController:getChainPollingConfig`, this.getChainPollingConfig.bind(this));
+}, _TokenBalancesController_normalizeAccountAddresses = function _TokenBalancesController_normalizeAccountAddresses() {
+    var _a;
     const currentState = this.state.tokenBalances;
     const normalizedBalances = {};
-    // Iterate through all accounts and normalize to lowercase
     for (const address of Object.keys(currentState)) {
         const lowercaseAddress = address.toLowerCase();
         const accountBalances = currentState[address];
         if (!accountBalances) {
             continue;
         }
-        // If this lowercase address doesn't exist yet, create it
-        if (!normalizedBalances[lowercaseAddress]) {
-            normalizedBalances[lowercaseAddress] = {};
-        }
-        // Merge chain data
+        normalizedBalances[lowercaseAddress] ?? (normalizedBalances[lowercaseAddress] = {});
         for (const chainId of Object.keys(accountBalances)) {
             const chainIdKey = chainId;
-            if (!normalizedBalances[lowercaseAddress][chainIdKey]) {
-                normalizedBalances[lowercaseAddress][chainIdKey] = {};
-            }
-            // Merge token balances (later values override earlier ones if duplicates exist)
+            (_a = normalizedBalances[lowercaseAddress])[chainIdKey] ?? (_a[chainIdKey] = {});
             Object.assign(normalizedBalances[lowercaseAddress][chainIdKey], accountBalances[chainIdKey]);
         }
     }
-    // Only update if there were changes
     if (Object.keys(currentState).length !==
         Object.keys(normalizedBalances).length ||
         Object.keys(currentState).some((addr) => addr !== addr.toLowerCase())) {
@@ -675,18 +476,15 @@ _TokenBalancesController_platform = new WeakMap(), _TokenBalancesController_quer
         ]),
     ];
 }, _TokenBalancesController_startIntervalGroupPolling = function _TokenBalancesController_startIntervalGroupPolling(chainIds, immediate = true) {
-    // Stop any existing interval timers
     __classPrivateFieldGet(this, _TokenBalancesController_intervalPollingTimers, "f").forEach((timer) => clearInterval(timer));
     __classPrivateFieldGet(this, _TokenBalancesController_intervalPollingTimers, "f").clear();
-    // Group chains by their polling intervals
     const intervalGroups = new Map();
     for (const chainId of chainIds) {
         const config = this.getChainPollingConfig(chainId);
-        const existing = intervalGroups.get(config.interval) || [];
-        existing.push(chainId);
-        intervalGroups.set(config.interval, existing);
+        const group = intervalGroups.get(config.interval) ?? [];
+        group.push(chainId);
+        intervalGroups.set(config.interval, group);
     }
-    // Start separate polling loop for each interval group
     for (const [interval, chainIdsGroup] of intervalGroups) {
         __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_startPollingForInterval).call(this, interval, chainIdsGroup, immediate);
     }
@@ -702,33 +500,221 @@ _TokenBalancesController_platform = new WeakMap(), _TokenBalancesController_quer
             console.warn(`Polling failed for chains ${chainIds.join(', ')} with interval ${interval}:`, error);
         }
     };
-    // Poll immediately first if requested
     if (immediate) {
         pollFunction().catch((error) => {
             console.warn(`Immediate polling failed for chains ${chainIds.join(', ')}:`, error);
         });
     }
-    // Then start regular interval polling
     __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_setPollingTimer).call(this, interval, chainIds, pollFunction);
 }, _TokenBalancesController_setPollingTimer = function _TokenBalancesController_setPollingTimer(interval, chainIds, pollFunction) {
-    // Clear any existing timer for this interval first
-    const existingTimer = __classPrivateFieldGet(this, _TokenBalancesController_intervalPollingTimers, "f").get(interval);
-    if (existingTimer) {
-        clearInterval(existingTimer);
-    }
     const timer = setInterval(() => {
         pollFunction().catch((error) => {
             console.warn(`Interval polling failed for chains ${chainIds.join(', ')}:`, error);
         });
     }, interval);
     __classPrivateFieldGet(this, _TokenBalancesController_intervalPollingTimers, "f").set(interval, timer);
+}, _TokenBalancesController_stopAllPolling = function _TokenBalancesController_stopAllPolling() {
+    __classPrivateFieldSet(this, _TokenBalancesController_isControllerPollingActive, false, "f");
+    __classPrivateFieldSet(this, _TokenBalancesController_requestedChainIds, [], "f");
+    __classPrivateFieldGet(this, _TokenBalancesController_intervalPollingTimers, "f").forEach((timer) => clearInterval(timer));
+    __classPrivateFieldGet(this, _TokenBalancesController_intervalPollingTimers, "f").clear();
+}, _TokenBalancesController_getTargetChains = function _TokenBalancesController_getTargetChains(chainIds) {
+    return chainIds?.length ? chainIds : __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_chainIdsWithTokens).call(this);
+}, _TokenBalancesController_getAccountsAndJwt = async function _TokenBalancesController_getAccountsAndJwt() {
+    const { address: selected } = this.messenger.call('AccountsController:getSelectedAccount');
+    const allAccounts = this.messenger.call('AccountsController:listAccounts');
+    const jwtToken = await safelyExecuteWithTimeout(() => {
+        return this.messenger.call('AuthenticationController:getBearerToken');
+    }, false, 5000);
+    return {
+        selectedAccount: selected,
+        allAccounts,
+        jwtToken,
+    };
+}, _TokenBalancesController_fetchAllBalances = async function _TokenBalancesController_fetchAllBalances({ targetChains, selectedAccount, allAccounts, jwtToken, queryAllAccounts, }) {
+    const aggregated = [];
+    let remainingChains = [...targetChains];
+    for (const fetcher of __classPrivateFieldGet(this, _TokenBalancesController_balanceFetchers, "f")) {
+        const supportedChains = remainingChains.filter((chain) => fetcher.supports(chain));
+        if (!supportedChains.length) {
+            continue;
+        }
+        try {
+            const result = await fetcher.fetch({
+                chainIds: supportedChains,
+                queryAllAccounts,
+                selectedAccount,
+                allAccounts,
+                jwtToken,
+            });
+            if (result.balances?.length) {
+                aggregated.push(...result.balances);
+                const processed = new Set(result.balances.map((b) => b.chainId));
+                remainingChains = remainingChains.filter((chain) => !processed.has(chain));
+            }
+            if (result.unprocessedChainIds?.length) {
+                const currentRemaining = [...remainingChains];
+                const chainsToAdd = result.unprocessedChainIds.filter((chainId) => supportedChains.includes(chainId) &&
+                    !currentRemaining.includes(chainId));
+                remainingChains.push(...chainsToAdd);
+                this.messenger
+                    .call('TokenDetectionController:detectTokens', {
+                    chainIds: result.unprocessedChainIds,
+                    forceRpc: true,
+                })
+                    .catch(() => {
+                    // Silently handle token detection errors
+                });
+            }
+        }
+        catch (error) {
+            console.warn(`Balance fetcher failed for chains ${supportedChains.join(', ')}: ${String(error)}`);
+            this.messenger
+                .call('TokenDetectionController:detectTokens', {
+                chainIds: supportedChains,
+                forceRpc: true,
+            })
+                .catch(() => {
+                // Silently handle token detection errors
+            });
+        }
+        if (!remainingChains.length) {
+            break;
+        }
+    }
+    return aggregated;
+}, _TokenBalancesController_filterByTokenAddresses = function _TokenBalancesController_filterByTokenAddresses(balances, tokenAddresses) {
+    if (!tokenAddresses?.length) {
+        return balances;
+    }
+    const lowered = tokenAddresses.map((a) => a.toLowerCase());
+    return balances.filter((balance) => lowered.includes(balance.token.toLowerCase()));
+}, _TokenBalancesController_getAccountsToProcess = function _TokenBalancesController_getAccountsToProcess(queryAllAccountsParam, allAccounts, selectedAccount) {
+    const effectiveQueryAll = queryAllAccountsParam ?? __classPrivateFieldGet(this, _TokenBalancesController_queryAllAccounts, "f") ?? false;
+    if (!effectiveQueryAll) {
+        return [selectedAccount];
+    }
+    return allAccounts.map((account) => account.address);
+}, _TokenBalancesController_applyTokenBalancesToState = function _TokenBalancesController_applyTokenBalancesToState({ prev, targetChains, accountsToProcess, balances, }) {
+    return draft(prev, (draftState) => {
+        var _a, _b;
+        for (const chainId of targetChains) {
+            for (const account of accountsToProcess) {
+                (_a = draftState.tokenBalances)[account] ?? (_a[account] = {});
+                (_b = draftState.tokenBalances[account])[chainId] ?? (_b[chainId] = {});
+                const chainTokens = __classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")[chainId];
+                if (chainTokens?.[account]) {
+                    Object.values(chainTokens[account]).forEach((token) => {
+                        var _a;
+                        const tokenAddress = checksum(token.address);
+                        (_a = draftState.tokenBalances[account][chainId])[tokenAddress] ?? (_a[tokenAddress] = '0x0');
+                    });
+                }
+                const detectedChainTokens = __classPrivateFieldGet(this, _TokenBalancesController_detectedTokens, "f")[chainId];
+                if (detectedChainTokens?.[account]) {
+                    Object.values(detectedChainTokens[account]).forEach((token) => {
+                        var _a;
+                        const tokenAddress = checksum(token.address);
+                        (_a = draftState.tokenBalances[account][chainId])[tokenAddress] ?? (_a[tokenAddress] = '0x0');
+                    });
+                }
+            }
+        }
+        balances.forEach(({ success, value, account, token, chainId }) => {
+            var _a, _b;
+            if (!success || value === undefined) {
+                return;
+            }
+            const lowerCaseAccount = account.toLowerCase();
+            const newBalance = toHex(value);
+            const tokenAddress = checksum(token);
+            const currentBalance = draftState.tokenBalances[lowerCaseAccount]?.[chainId]?.[tokenAddress];
+            if (currentBalance !== newBalance) {
+                ((_b = ((_a = draftState.tokenBalances)[lowerCaseAccount] ?? (_a[lowerCaseAccount] = {})))[chainId] ?? (_b[chainId] = {}))[tokenAddress] = newBalance;
+            }
+        });
+    });
+}, _TokenBalancesController_buildNativeBalanceUpdates = function _TokenBalancesController_buildNativeBalanceUpdates(balances, accountTrackerState) {
+    const nativeBalances = balances.filter((balance) => balance.success && balance.token === ZERO_ADDRESS);
+    if (!nativeBalances.length) {
+        return [];
+    }
+    return nativeBalances
+        .map((balance) => ({
+        address: balance.account,
+        chainId: balance.chainId,
+        balance: balance.value ? BNToHex(balance.value) : '0x0',
+    }))
+        .filter((update) => {
+        const currentBalance = accountTrackerState.accountsByChainId[update.chainId]?.[checksum(update.address)]?.balance;
+        return currentBalance !== update.balance;
+    });
+}, _TokenBalancesController_buildStakedBalanceUpdates = function _TokenBalancesController_buildStakedBalanceUpdates(balances, accountTrackerState) {
+    const stakedBalances = balances.filter((balance) => {
+        if (!balance.success || balance.token === ZERO_ADDRESS) {
+            return false;
+        }
+        const stakingContractAddress = STAKING_CONTRACT_ADDRESS_BY_CHAINID[balance.chainId];
+        return (stakingContractAddress &&
+            stakingContractAddress.toLowerCase() === balance.token.toLowerCase());
+    });
+    if (!stakedBalances.length) {
+        return [];
+    }
+    return stakedBalances
+        .map((balance) => ({
+        address: balance.account,
+        chainId: balance.chainId,
+        stakedBalance: balance.value ? toHex(balance.value) : '0x0',
+    }))
+        .filter((update) => {
+        const currentStakedBalance = accountTrackerState.accountsByChainId[update.chainId]?.[checksum(update.address)]?.stakedBalance;
+        return currentStakedBalance !== update.stakedBalance;
+    });
+}, _TokenBalancesController_importUntrackedTokens = 
+/**
+ * Import untracked tokens that have non-zero balances.
+ * This mirrors the v2 behavior where only tokens with actual balances are added.
+ * Delegates to TokenDetectionController:addDetectedTokensViaPolling which handles:
+ * - Checking if useTokenDetection preference is enabled
+ * - Filtering tokens already in allTokens or allIgnoredTokens
+ * - Token metadata lookup and addition via TokensController
+ *
+ * @param balances - Array of processed balance results from fetchers
+ */
+async function _TokenBalancesController_importUntrackedTokens(balances) {
+    const tokensByChain = new Map();
+    for (const balance of balances) {
+        // Skip failed fetches, native tokens, and zero balances (like v2 did)
+        if (!balance.success ||
+            balance.token === ZERO_ADDRESS ||
+            !balance.value ||
+            balance.value.isZero()) {
+            continue;
+        }
+        const tokenAddress = checksum(balance.token);
+        const existing = tokensByChain.get(balance.chainId) ?? [];
+        if (!existing.includes(tokenAddress)) {
+            existing.push(tokenAddress);
+            tokensByChain.set(balance.chainId, existing);
+        }
+    }
+    // Add detected tokens via TokenDetectionController (handles preference check,
+    // filtering of allTokens/allIgnoredTokens, and metadata lookup)
+    for (const [chainId, tokenAddresses] of tokensByChain) {
+        if (tokenAddresses.length) {
+            await this.messenger.call('TokenDetectionController:addDetectedTokensViaPolling', {
+                tokensSlice: tokenAddresses,
+                chainId,
+            });
+        }
+    }
 }, _TokenBalancesController_isTokenTracked = function _TokenBalancesController_isTokenTracked(tokenAddress, account, chainId) {
-    // Check if token exists in allTokens
-    if (__classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")?.[chainId]?.[account.toLowerCase()]?.some((token) => token.address === tokenAddress)) {
+    const normalizedAccount = account.toLowerCase();
+    if (__classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")?.[chainId]?.[normalizedAccount]?.some((token) => token.address === tokenAddress)) {
         return true;
     }
-    // Check if token exists in allIgnoredTokens
-    if (__classPrivateFieldGet(this, _TokenBalancesController_allIgnoredTokens, "f")?.[chainId]?.[account.toLowerCase()]?.some((token) => token === tokenAddress)) {
+    if (__classPrivateFieldGet(this, _TokenBalancesController_allIgnoredTokens, "f")?.[chainId]?.[normalizedAccount]?.some((token) => token === tokenAddress)) {
         return true;
     }
     return false;
@@ -738,31 +724,25 @@ _TokenBalancesController_platform = new WeakMap(), _TokenBalancesController_quer
     const nativeBalanceUpdates = [];
     for (const update of updates) {
         const { asset, postBalance } = update;
-        // Throw if balance update has an error
         if (postBalance.error) {
             throw new Error('Balance update has error');
         }
-        // Parse token address from asset type
         const parsed = parseAssetType(asset.type);
         if (!parsed) {
             throw new Error('Failed to parse asset type');
         }
         const [tokenAddress, isNativeToken] = parsed;
-        // Validate token address
         if (!isStrictHexString(tokenAddress) ||
             !isValidHexAddress(tokenAddress)) {
             throw new Error('Invalid token address');
         }
         const checksumTokenAddress = checksum(tokenAddress);
         const isTracked = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_isTokenTracked).call(this, checksumTokenAddress, account, chainId);
-        // postBalance.amount is in hex format (raw units)
         const balanceHex = postBalance.amount;
-        // Add token balance (tracked tokens, ignored tokens, and native tokens all get balance updates)
         tokenBalances.push({
             tokenAddress: checksumTokenAddress,
             balance: balanceHex,
         });
-        // Add native balance update if this is a native token
         if (isNativeToken) {
             nativeBalanceUpdates.push({
                 address: account,
@@ -770,7 +750,6 @@ _TokenBalancesController_platform = new WeakMap(), _TokenBalancesController_quer
                 balance: balanceHex,
             });
         }
-        // Handle untracked ERC20 tokens - queue for import
         if (!isNativeToken && !isTracked) {
             newTokens.push(checksumTokenAddress);
         }
@@ -780,28 +759,18 @@ _TokenBalancesController_platform = new WeakMap(), _TokenBalancesController_quer
     const changes = Array.from(__classPrivateFieldGet(this, _TokenBalancesController_statusChangeDebouncer, "f").pendingChanges.entries());
     __classPrivateFieldGet(this, _TokenBalancesController_statusChangeDebouncer, "f").pendingChanges.clear();
     __classPrivateFieldGet(this, _TokenBalancesController_statusChangeDebouncer, "f").timer = null;
-    if (changes.length === 0) {
+    if (!changes.length) {
         return;
     }
-    // Calculate final polling configurations
     const chainConfigs = {};
     for (const [chainId, status] of changes) {
-        // Convert CAIP format (eip155:1) to hex format (0x1)
-        // chainId is always in CAIP format from AccountActivityService
         const hexChainId = caipChainIdToHex(chainId);
-        if (status === 'down') {
-            // Chain is down - use default polling since no real-time updates available
-            chainConfigs[hexChainId] = { interval: __classPrivateFieldGet(this, _TokenBalancesController_defaultInterval, "f") };
-        }
-        else {
-            // Chain is up - use longer intervals since WebSocket provides real-time updates
-            chainConfigs[hexChainId] = {
-                interval: __classPrivateFieldGet(this, _TokenBalancesController_websocketActivePollingInterval, "f"),
-            };
-        }
+        chainConfigs[hexChainId] =
+            status === 'down'
+                ? { interval: __classPrivateFieldGet(this, _TokenBalancesController_defaultInterval, "f") }
+                : { interval: __classPrivateFieldGet(this, _TokenBalancesController_websocketActivePollingInterval, "f") };
     }
-    // Add jitter to prevent synchronized requests across instances
-    const jitterDelay = Math.random() * __classPrivateFieldGet(this, _TokenBalancesController_defaultInterval, "f"); // 0 to default interval
+    const jitterDelay = Math.random() * __classPrivateFieldGet(this, _TokenBalancesController_defaultInterval, "f");
     setTimeout(() => {
         this.updateChainPollingConfigs(chainConfigs, { immediateUpdate: true });
     }, jitterDelay);