@metamask-previews/assets-controllers 93.1.0-preview-c92c27f1 → 93.1.0-preview-d717276a

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_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;
+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;
 import { Web3Provider } from "@ethersproject/providers";
 import { BNToHex, isValidHexAddress, safelyExecuteWithTimeout, toChecksumHexAddress, toHex } from "@metamask/controller-utils";
 import { StaticIntervalPollingController } from "@metamask/polling-controller";
@@ -31,14 +31,19 @@ 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.
+ * 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")
  *
- * @param chainId - CAIP chain ID or hex chain ID.
- * @returns 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
  */
 export const caipChainIdToHex = (chainId) => {
     if (isStrictHexString(chainId)) {
@@ -50,26 +55,30 @@ export const caipChainIdToHex = (chainId) => {
     throw new Error('caipChainIdToHex - Failed to provide CAIP-2 or Hex chainId');
 };
 /**
- * Extract token address from asset type.
+ * Extract token address from asset type
+ * Returns tuple of [tokenAddress, isNativeToken] or null if invalid
  *
- * @param assetType - Asset type string.
- * @returns Tuple of [tokenAddress, isNativeToken] or null if invalid.
+ * @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
  */
 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
 // ────────────────────────────────────────────────────────────────────────────
-// Main controller
+// 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, }) {
         super({
@@ -96,8 +105,6 @@ 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 */
@@ -107,34 +114,52 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
         });
         _TokenBalancesController_getProvider.set(this, (chainId) => {
             const { networkConfigurationsByChainId } = this.messenger.call('NetworkController:getState');
-            const networkConfig = networkConfigurationsByChainId[chainId];
-            const { networkClientId } = networkConfig.rpcEndpoints[networkConfig.defaultRpcEndpointIndex];
+            const cfg = networkConfigurationsByChainId[chainId];
+            const { networkClientId } = cfg.rpcEndpoints[cfg.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 networkConfig = networkConfigurationsByChainId[chainId];
-            const { networkClientId } = networkConfig.rpcEndpoints[networkConfig.defaultRpcEndpointIndex];
+            const cfg = networkConfigurationsByChainId[chainId];
+            const { networkClientId } = cfg.rpcEndpoints[cfg.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) => __classPrivateFieldGet(this, _TokenBalancesController_accountsApiChainIds, "f").call(this).includes(chainId) &&
-                    originalFetcher.supports(chainId),
+                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));
+                },
                 fetch: originalFetcher.fetch.bind(originalFetcher),
             };
         });
-        // ────────────────────────────────────────────────────────────────────────
-        // TokensController / Network / Accounts events
         _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) ||
@@ -143,16 +168,20 @@ 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) {
+            if (relevantChainIds.length === 0) {
+                // No relevant changes, just update internal state
                 __classPrivateFieldSet(this, _TokenBalancesController_allTokens, state.allTokens, "f");
                 __classPrivateFieldSet(this, _TokenBalancesController_detectedTokens, state.allDetectedTokens, "f");
                 return;
             }
-            this.update((currentState) => {
+            // Handle both cleanup and updates in a single state update
+            this.update((s) => {
                 for (const chainId of relevantChainIds) {
                     const id = chainId;
                     const hasTokensNow = (state.allTokens[id] &&
@@ -163,20 +192,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);
-                    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;
+                    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;
+                                }
                             }
                         }
                     }
@@ -185,6 +214,7 @@ 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);
@@ -192,7 +222,9 @@ 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;
@@ -200,59 +232,83 @@ 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) {
-                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];
+            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];
+                            }
                         }
                     }
-                }
-            });
+                });
+            }
         });
         _TokenBalancesController_onAccountRemoved.set(this, (addr) => {
             if (!isStrictHexString(addr) || !isValidHexAddress(addr)) {
                 return;
             }
-            this.update((currentState) => {
-                delete currentState.tokenBalances[addr];
+            this.update((s) => {
+                delete s.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) {
-                return;
+            if (chainIds.length > 0) {
+                this.updateBalances({ chainIds }).catch(() => {
+                    // Silently handle polling errors
+                });
             }
-            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,
@@ -263,22 +319,35 @@ 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);
+            }, 5000); // 5-second debounce window
         });
+        // 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");
@@ -286,6 +355,7 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
         __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
         __classPrivateFieldSet(this, _TokenBalancesController_balanceFetchers, [
             ...(accountsApiChainIds().length > 0 && allowExternalServices()
                 ? [__classPrivateFieldGet(this, _TokenBalancesController_createAccountsApiFetcher, "f").call(this)]
@@ -296,180 +366,302 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
             })),
         ], "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");
-        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);
+        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));
     }
-    // ────────────────────────────────────────────────────────────────────────
-    // Address + network helpers
     /**
-     * Whether the controller is active (keyring is unlocked).
-     * When locked, balance updates should be skipped.
+     * Override to support per-chain polling intervals by grouping chains by interval
      *
-     * @returns Whether the keyring is unlocked.
+     * @param options0 - The polling options
+     * @param options0.chainIds - Chain IDs to start polling for
      */
-    get isActive() {
-        return __classPrivateFieldGet(this, _TokenBalancesController_isUnlocked, "f");
-    }
-    // ────────────────────────────────────────────────────────────────────────
-    // Polling overrides
     _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 {
-            const parsedTokenSetId = JSON.parse(tokenSetId);
-            chainsToStop = parsedTokenSetId.chainIds ?? [];
+            parsedTokenSetId = JSON.parse(tokenSetId);
+            chainsToStop = parsedTokenSetId.chainIds || [];
         }
         catch (error) {
             console.warn('Failed to parse tokenSetId, stopping all polling:', error);
-            __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_stopAllPolling).call(this);
+            // 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();
             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) {
-            __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_stopAllPolling).call(this);
+            __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();
         }
     }
+    /**
+     * 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);
         }
     }
-    // ────────────────────────────────────────────────────────────────────────
-    // Balances update (main flow, refactored)
-    async updateBalances({ chainIds, tokenAddresses, queryAllAccounts = false, } = {}) {
-        if (!this.isActive) {
-            return;
-        }
-        const targetChains = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_getTargetChains).call(this, chainIds);
+    async updateBalances({ chainIds, queryAllAccounts = false, } = {}) {
+        const targetChains = chainIds ?? __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_chainIdsWithTokens).call(this);
         if (!targetChains.length) {
             return;
         }
-        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 { 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;
+            }
+        }
+        // Determine which accounts to process based on queryAllAccounts parameter
+        const accountsToProcess = (queryAllAccounts ?? __classPrivateFieldGet(this, _TokenBalancesController_queryAllAccounts, "f"))
+            ? allAccounts.map((a) => a.address)
+            : [selected];
         const prev = this.state;
-        const next = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_applyTokenBalancesToState).call(this, {
-            prev,
-            targetChains,
-            accountsToProcess,
-            balances: filteredAggregated,
+        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;
+                    }
+                }
+            });
         });
         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');
-            const nativeUpdates = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_buildNativeBalanceUpdates).call(this, filteredAggregated, accountTrackerState);
-            if (nativeUpdates.length > 0) {
-                this.messenger.call('AccountTrackerController:updateNativeBalances', nativeUpdates);
+            // 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 stakedUpdates = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_buildStakedBalanceUpdates).call(this, filteredAggregated, accountTrackerState);
-            if (stakedUpdates.length > 0) {
-                this.messenger.call('AccountTrackerController:updateStakedBalances', stakedUpdates);
+            // 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);
+                }
             }
         }
-        await __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_importUntrackedTokens).call(this, filteredAggregated);
     }
     resetState() {
         this.update(() => ({ tokenBalances: {} }));
     }
-    // ────────────────────────────────────────────────────────────────────────
-    // Destroy
+    /**
+     * 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_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;
+_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() {
     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;
         }
-        normalizedBalances[lowercaseAddress] ?? (normalizedBalances[lowercaseAddress] = {});
+        // If this lowercase address doesn't exist yet, create it
+        if (!normalizedBalances[lowercaseAddress]) {
+            normalizedBalances[lowercaseAddress] = {};
+        }
+        // Merge chain data
         for (const chainId of Object.keys(accountBalances)) {
             const chainIdKey = chainId;
-            (_a = normalizedBalances[lowercaseAddress])[chainIdKey] ?? (_a[chainIdKey] = {});
+            if (!normalizedBalances[lowercaseAddress][chainIdKey]) {
+                normalizedBalances[lowercaseAddress][chainIdKey] = {};
+            }
+            // Merge token balances (later values override earlier ones if duplicates exist)
             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())) {
@@ -483,15 +675,18 @@ _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 group = intervalGroups.get(config.interval) ?? [];
-        group.push(chainId);
-        intervalGroups.set(config.interval, group);
+        const existing = intervalGroups.get(config.interval) || [];
+        existing.push(chainId);
+        intervalGroups.set(config.interval, existing);
     }
+    // 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);
     }
@@ -507,205 +702,33 @@ _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 = async function _TokenBalancesController_importUntrackedTokens(balances) {
-    const untrackedTokensByChain = new Map();
-    for (const balance of balances) {
-        if (!balance.success || balance.token === ZERO_ADDRESS) {
-            continue;
-        }
-        const tokenAddress = checksum(balance.token);
-        const account = balance.account.toLowerCase();
-        if (!__classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_isTokenTracked).call(this, tokenAddress, account, balance.chainId)) {
-            const existing = untrackedTokensByChain.get(balance.chainId) ?? [];
-            if (!existing.includes(tokenAddress)) {
-                existing.push(tokenAddress);
-                untrackedTokensByChain.set(balance.chainId, existing);
-            }
-        }
-    }
-    for (const [chainId, tokens] of untrackedTokensByChain) {
-        await this.messenger.call('TokenDetectionController:addDetectedTokensViaWs', {
-            tokensSlice: tokens,
-            chainId,
-        });
-    }
 }, _TokenBalancesController_isTokenTracked = function _TokenBalancesController_isTokenTracked(tokenAddress, account, chainId) {
-    const normalizedAccount = account.toLowerCase();
-    if (__classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")?.[chainId]?.[normalizedAccount]?.some((token) => token.address === tokenAddress)) {
+    // Check if token exists in allTokens
+    if (__classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")?.[chainId]?.[account.toLowerCase()]?.some((token) => token.address === tokenAddress)) {
         return true;
     }
-    if (__classPrivateFieldGet(this, _TokenBalancesController_allIgnoredTokens, "f")?.[chainId]?.[normalizedAccount]?.some((token) => token === tokenAddress)) {
+    // Check if token exists in allIgnoredTokens
+    if (__classPrivateFieldGet(this, _TokenBalancesController_allIgnoredTokens, "f")?.[chainId]?.[account.toLowerCase()]?.some((token) => token === tokenAddress)) {
         return true;
     }
     return false;
@@ -715,25 +738,31 @@ _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,
@@ -741,6 +770,7 @@ _TokenBalancesController_platform = new WeakMap(), _TokenBalancesController_quer
                 balance: balanceHex,
             });
         }
+        // Handle untracked ERC20 tokens - queue for import
         if (!isNativeToken && !isTracked) {
             newTokens.push(checksumTokenAddress);
         }
@@ -750,18 +780,28 @@ _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) {
+    if (changes.length === 0) {
         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);
-        chainConfigs[hexChainId] =
-            status === 'down'
-                ? { interval: __classPrivateFieldGet(this, _TokenBalancesController_defaultInterval, "f") }
-                : { interval: __classPrivateFieldGet(this, _TokenBalancesController_websocketActivePollingInterval, "f") };
+        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"),
+            };
+        }
     }
-    const jitterDelay = Math.random() * __classPrivateFieldGet(this, _TokenBalancesController_defaultInterval, "f");
+    // Add jitter to prevent synchronized requests across instances
+    const jitterDelay = Math.random() * __classPrivateFieldGet(this, _TokenBalancesController_defaultInterval, "f"); // 0 to default interval
     setTimeout(() => {
         this.updateChainPollingConfigs(chainConfigs, { immediateUpdate: true });
     }, jitterDelay);