@metamask-previews/assets-controllers 79.0.1-preview-e8868d87 → 79.0.1-preview-5f3688c1

package/CHANGELOG.md

@@ -7,9 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Fixed
+### Added
 
-- Fix address format compatibility between `TokenBalancesController` and `AccountTrackerController` in `AccountsApiBalanceFetcher` ([#6812](https://github.com/MetaMask/core/pull/6812))
+- Add real-time balance updates via WebSocket integration with `AccountActivityService` to `TokenBalancesController` ([#6784](https://github.com/MetaMask/core/pull/6784))
+  - Add `@metamask/core-backend` as a dependency and peer dependency ([#6784](https://github.com/MetaMask/core/pull/6784))
+  - Controller now subscribes to `AccountActivityService:balanceUpdated` events for instant balance updates
+    - Add support for real-time balance updates for both ERC20 tokens and native tokens
+    - Add `TokenDetectionController:addDetectedTokensViaWs` action handler for adding tokens detected via WebSocket
+  - Controller now subscribes to `AccountActivityService:statusChanged` events to dynamically adjust polling intervals
+    - When WebSocket service is "up", polling interval increases to backup interval (5 minutes)
+    - When WebSocket service is "down", polling interval restores to default interval (30 seconds)
+    - Status changes are debounced (5 seconds) and jittered to prevent thundering herd
+    - Add fallback to polling when balance updates contain errors or unsupported asset types
+
+### Changed
+
+- **BREAKING:** `TokenBalancesController` messenger must now allow `AccountActivityService:balanceUpdated` and `AccountActivityService:statusChanged` events ([#6784](https://github.com/MetaMask/core/pull/6784))
+- **BREAKING:** `TokenBalancesController` messenger must now allow `TokenDetectionController:addDetectedTokensViaWs` action ([#6784](https://github.com/MetaMask/core/pull/6784))
+- **BREAKING:** Change `TokenBalancesController` default polling interval to 30 seconds (was 180 seconds) ([#6784](https://github.com/MetaMask/core/pull/6784))
+  - With real-time WebSocket updates, the default interval only applies when WebSocket is disconnected
+  - When WebSocket is connected, polling automatically adjusts to 5 minutes as a backup
+- Update `TokenBalancesController` README documentation to mention real-time balance updates via WebSocket and intelligent polling management ([#6784](https://github.com/MetaMask/core/pull/6784))
+- `TokenDetectionController` code cleanup: remove unused private properties and ESLint disable comments ([#6784](https://github.com/MetaMask/core/pull/6784))
 
 ## [79.0.1]
 

package/README.md

@@ -21,7 +21,7 @@ This package features the following controllers:
 - [**CurrencyRateController**](src/CurrencyRateController.ts) keeps a periodically updated value of the exchange rate from the currently selected "native" currency to another (handling testnet tokens specially).
 - [**DeFiPositionsController**](src/DeFiPositionsController/DeFiPositionsController.ts.ts) keeps a periodically updated value of the DeFi positions for the owner EVM addresses.
 - [**RatesController**](src/RatesController/RatesController.ts) keeps a periodically updated value for the exchange rates for different cryptocurrencies. The difference between the `RatesController` and `CurrencyRateController` is that the second one is coupled to the `NetworksController` and is EVM specific, whilst the first one can handle different blockchain currencies like BTC and SOL.
-- [**TokenBalancesController**](src/TokenBalancesController.ts) keeps a periodically updated set of balances for the current set of ERC-20 tokens.
+- [**TokenBalancesController**](src/TokenBalancesController.ts) keeps a periodically updated set of balances for the current set of ERC-20 tokens. It supports real-time balance updates via WebSocket and intelligent polling management. See [Real-Time Balance Updates Flow](./REAL_TIME_BALANCE_UPDATES.md) for details.
 - [**TokenDetectionController**](src/TokenDetectionController.ts) keeps a periodically updated list of ERC-20 tokens assigned to the currently selected address.
 - [**TokenListController**](src/TokenListController.ts) uses the MetaSwap API to keep a periodically updated list of known ERC-20 tokens along with their metadata.
 - [**TokenRatesController**](src/TokenRatesController.ts) keeps a periodically updated list of exchange rates for known ERC-20 tokens relative to the currently selected native currency.

package/dist/TokenBalancesController.cjs

@@ -10,9 +10,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _TokenBalancesController_instances, _TokenBalancesController_platform, _TokenBalancesController_queryAllAccounts, _TokenBalancesController_accountsApiChainIds, _TokenBalancesController_balanceFetchers, _TokenBalancesController_allTokens, _TokenBalancesController_detectedTokens, _TokenBalancesController_defaultInterval, _TokenBalancesController_chainPollingConfig, _TokenBalancesController_intervalPollingTimers, _TokenBalancesController_isControllerPollingActive, _TokenBalancesController_requestedChainIds, _TokenBalancesController_chainIdsWithTokens, _TokenBalancesController_getProvider, _TokenBalancesController_getNetworkClient, _TokenBalancesController_createAccountsApiFetcher, _TokenBalancesController_startIntervalGroupPolling, _TokenBalancesController_startPollingForInterval, _TokenBalancesController_setPollingTimer, _TokenBalancesController_onTokensChanged, _TokenBalancesController_onNetworkChanged, _TokenBalancesController_onAccountRemoved;
+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_chainIdsWithTokens, _TokenBalancesController_getProvider, _TokenBalancesController_getNetworkClient, _TokenBalancesController_createAccountsApiFetcher, _TokenBalancesController_startIntervalGroupPolling, _TokenBalancesController_startPollingForInterval, _TokenBalancesController_setPollingTimer, _TokenBalancesController_isTokenTracked, _TokenBalancesController_onTokensChanged, _TokenBalancesController_onNetworkChanged, _TokenBalancesController_onAccountRemoved, _TokenBalancesController_prepareBalanceUpdates, _TokenBalancesController_onAccountActivityBalanceUpdate, _TokenBalancesController_onAccountActivityStatusChanged, _TokenBalancesController_processAccumulatedStatusChanges;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenBalancesController = void 0;
+exports.TokenBalancesController = exports.parseAssetType = exports.caipChainIdToHex = void 0;
 const providers_1 = require("@ethersproject/providers");
 const controller_utils_1 = require("@metamask/controller-utils");
 const polling_controller_1 = require("@metamask/polling-controller");
@@ -23,7 +23,8 @@ const AssetsContractController_1 = require("./AssetsContractController.cjs");
 const api_balance_fetcher_1 = require("./multi-chain-accounts-service/api-balance-fetcher.cjs");
 const rpc_balance_fetcher_1 = require("./rpc-service/rpc-balance-fetcher.cjs");
 const CONTROLLER = 'TokenBalancesController';
-const DEFAULT_INTERVAL_MS = 180000; // 3 minutes
+const DEFAULT_INTERVAL_MS = 30000; // 30 seconds
+const DEFAULT_WEBSOCKET_ACTIVE_POLLING_INTERVAL_MS = 300000; // 5 minutes
 const metadata = {
     tokenBalances: {
         includeInStateLogs: false,
@@ -38,11 +39,52 @@ const metadata = {
 const draft = (base, fn) => (0, immer_1.produce)(base, fn);
 const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 const checksum = (addr) => (0, controller_utils_1.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")
+ *
+ * @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
+ */
+const caipChainIdToHex = (chainId) => {
+    if ((0, utils_1.isStrictHexString)(chainId)) {
+        return chainId;
+    }
+    if ((0, utils_1.isCaipChainId)(chainId)) {
+        return (0, controller_utils_1.toHex)((0, utils_1.parseCaipChainId)(chainId).reference);
+    }
+    throw new Error('caipChainIdToHex - Failed to provide CAIP-2 or Hex chainId');
+};
+exports.caipChainIdToHex = caipChainIdToHex;
+/**
+ * Extract token address from asset type
+ * 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
+ */
+const parseAssetType = (assetType) => {
+    if (!(0, utils_1.isCaipAssetType)(assetType)) {
+        return null;
+    }
+    const parsed = (0, utils_1.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;
+};
+exports.parseAssetType = parseAssetType;
 // endregion
 // ────────────────────────────────────────────────────────────────────────────
 // region: Main controller
 class TokenBalancesController extends (0, polling_controller_1.StaticIntervalPollingController)() {
-    constructor({ messenger, interval = DEFAULT_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, }) {
         super({
             name: CONTROLLER,
             messenger,
@@ -56,8 +98,11 @@ class TokenBalancesController extends (0, polling_controller_1.StaticIntervalPol
         _TokenBalancesController_balanceFetchers.set(this, void 0);
         _TokenBalancesController_allTokens.set(this, {});
         _TokenBalancesController_detectedTokens.set(this, {});
+        _TokenBalancesController_allIgnoredTokens.set(this, {});
         /** Default polling interval for chains without specific configuration */
         _TokenBalancesController_defaultInterval.set(this, void 0);
+        /** Polling interval when WebSocket is active and providing real-time updates */
+        _TokenBalancesController_websocketActivePollingInterval.set(this, void 0);
         /** Per-chain polling configuration */
         _TokenBalancesController_chainPollingConfig.set(this, void 0);
         /** Active polling timers grouped by interval */
@@ -66,6 +111,11 @@ class TokenBalancesController extends (0, polling_controller_1.StaticIntervalPol
         _TokenBalancesController_isControllerPollingActive.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 */
+        _TokenBalancesController_statusChangeDebouncer.set(this, {
+            timer: null,
+            pendingChanges: new Map(),
+        });
         _TokenBalancesController_getProvider.set(this, (chainId) => {
             const { networkConfigurationsByChainId } = this.messagingSystem.call('NetworkController:getState');
             const cfg = networkConfigurationsByChainId[chainId];
@@ -167,6 +217,7 @@ class TokenBalancesController extends (0, polling_controller_1.StaticIntervalPol
             });
             __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) => {
@@ -210,10 +261,85 @@ class TokenBalancesController extends (0, polling_controller_1.StaticIntervalPol
                 delete s.tokenBalances[addr];
             });
         });
+        // ────────────────────────────────────────────────────────────────────────────
+        // 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 = (0, exports.caipChainIdToHex)(chain);
+            const account = checksum(address);
+            try {
+                // Process all balance updates at once
+                const { tokenBalances, newTokens, nativeBalanceUpdates } = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_prepareBalanceUpdates).call(this, updates, account, chainId);
+                // Update state once with all token balances
+                if (tokenBalances.length > 0) {
+                    this.update((state) => {
+                        var _a, _b;
+                        // Initialize account and chain structure
+                        (_a = state.tokenBalances)[account] ?? (_a[account] = {});
+                        (_b = state.tokenBalances[account])[chainId] ?? (_b[chainId] = {});
+                        // Apply all token balance updates
+                        for (const { tokenAddress, balance } of tokenBalances) {
+                            state.tokenBalances[account][chainId][tokenAddress] = balance;
+                        }
+                    });
+                }
+                // Update native balances in AccountTrackerController
+                if (nativeBalanceUpdates.length > 0) {
+                    this.messagingSystem.call('AccountTrackerController:updateNativeBalances', nativeBalanceUpdates);
+                }
+                // Import any new tokens that were discovered (balance already updated from websocket)
+                if (newTokens.length > 0) {
+                    await this.messagingSystem.call('TokenDetectionController:addDetectedTokensViaWs', {
+                        tokensSlice: newTokens,
+                        chainId: chainId,
+                    });
+                }
+            }
+            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
+        });
         __classPrivateFieldSet(this, _TokenBalancesController_platform, platform ?? 'extension', "f");
         __classPrivateFieldSet(this, _TokenBalancesController_queryAllAccounts, queryMultipleAccounts, "f");
         __classPrivateFieldSet(this, _TokenBalancesController_accountsApiChainIds, accountsApiChainIds, "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
         __classPrivateFieldSet(this, _TokenBalancesController_balanceFetchers, [
@@ -227,9 +353,10 @@ class TokenBalancesController extends (0, polling_controller_1.StaticIntervalPol
         ], "f");
         this.setIntervalLength(interval);
         // initial token state & subscriptions
-        const { allTokens, allDetectedTokens } = this.messagingSystem.call('TokensController:getState');
+        const { allTokens, allDetectedTokens, allIgnoredTokens } = this.messagingSystem.call('TokensController:getState');
         __classPrivateFieldSet(this, _TokenBalancesController_allTokens, allTokens, "f");
         __classPrivateFieldSet(this, _TokenBalancesController_detectedTokens, allDetectedTokens, "f");
+        __classPrivateFieldSet(this, _TokenBalancesController_allIgnoredTokens, allIgnoredTokens, "f");
         this.messagingSystem.subscribe('TokensController:stateChange', (tokensState) => {
             __classPrivateFieldGet(this, _TokenBalancesController_onTokensChanged, "f").call(this, tokensState).catch((error) => {
                 console.warn('Error handling token state change:', error);
@@ -240,6 +367,10 @@ class TokenBalancesController extends (0, polling_controller_1.StaticIntervalPol
         // Register action handlers for polling interval control
         this.messagingSystem.registerActionHandler(`TokenBalancesController:updateChainPollingConfigs`, this.updateChainPollingConfigs.bind(this));
         this.messagingSystem.registerActionHandler(`TokenBalancesController:getChainPollingConfig`, this.getChainPollingConfig.bind(this));
+        // Subscribe to AccountActivityService balance updates for real-time updates
+        this.messagingSystem.subscribe('AccountActivityService:balanceUpdated', __classPrivateFieldGet(this, _TokenBalancesController_onAccountActivityBalanceUpdate, "f").bind(this));
+        // Subscribe to AccountActivityService status changes for dynamic polling management
+        this.messagingSystem.subscribe('AccountActivityService:statusChanged', __classPrivateFieldGet(this, _TokenBalancesController_onAccountActivityStatusChanged, "f").bind(this));
     }
     /**
      * Override to support per-chain polling intervals by grouping chains by interval
@@ -394,14 +525,15 @@ class TokenBalancesController extends (0, polling_controller_1.StaticIntervalPol
             }
             // Update with actual fetched balances only if the value has changed
             aggregated.forEach(({ success, value, account, token, chainId }) => {
-                var _a, _b, _c;
+                var _a, _b;
                 if (success && value !== undefined) {
                     const newBalance = (0, controller_utils_1.toHex)(value);
                     const tokenAddress = checksum(token);
                     const currentBalance = d.tokenBalances[account]?.[chainId]?.[tokenAddress];
                     // Only update if the balance has actually changed
                     if (currentBalance !== newBalance) {
-                        ((_c = ((_a = d.tokenBalances)[_b = account] ?? (_a[_b] = {})))[chainId] ?? (_c[chainId] = {}))[tokenAddress] = newBalance;
+                        ((_b = ((_a = d.tokenBalances)[account] ?? (_a[account] = {})))[chainId] ?? (_b[chainId] = {}))[tokenAddress] =
+                            newBalance;
                     }
                 }
             });
@@ -466,6 +598,11 @@ class TokenBalancesController extends (0, polling_controller_1.StaticIntervalPol
         __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.messagingSystem.unregisterActionHandler(`TokenBalancesController:updateChainPollingConfigs`);
         this.messagingSystem.unregisterActionHandler(`TokenBalancesController:getChainPollingConfig`);
@@ -473,7 +610,7 @@ class TokenBalancesController extends (0, polling_controller_1.StaticIntervalPol
     }
 }
 exports.TokenBalancesController = TokenBalancesController;
-_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_defaultInterval = new WeakMap(), _TokenBalancesController_chainPollingConfig = new WeakMap(), _TokenBalancesController_intervalPollingTimers = new WeakMap(), _TokenBalancesController_isControllerPollingActive = new WeakMap(), _TokenBalancesController_requestedChainIds = 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_instances = new WeakSet(), _TokenBalancesController_chainIdsWithTokens = function _TokenBalancesController_chainIdsWithTokens() {
+_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_onAccountActivityBalanceUpdate = new WeakMap(), _TokenBalancesController_onAccountActivityStatusChanged = new WeakMap(), _TokenBalancesController_instances = new WeakSet(), _TokenBalancesController_chainIdsWithTokens = function _TokenBalancesController_chainIdsWithTokens() {
     return [
         ...new Set([
             ...Object.keys(__classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")),
@@ -528,6 +665,90 @@ _TokenBalancesController_platform = new WeakMap(), _TokenBalancesController_quer
         });
     }, interval);
     __classPrivateFieldGet(this, _TokenBalancesController_intervalPollingTimers, "f").set(interval, timer);
+}, _TokenBalancesController_isTokenTracked = function _TokenBalancesController_isTokenTracked(tokenAddress, account, chainId) {
+    const normalizedAddress = tokenAddress.toLowerCase();
+    // Check if token exists in allTokens
+    if (__classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")?.[chainId]?.[account.toLowerCase()]?.some((token) => token.address.toLowerCase() === normalizedAddress)) {
+        return true;
+    }
+    // Check if token exists in allIgnoredTokens
+    if (__classPrivateFieldGet(this, _TokenBalancesController_allIgnoredTokens, "f")?.[chainId]?.[account.toLowerCase()]?.some((addr) => addr.toLowerCase() === normalizedAddress)) {
+        return true;
+    }
+    return false;
+}, _TokenBalancesController_prepareBalanceUpdates = function _TokenBalancesController_prepareBalanceUpdates(updates, account, chainId) {
+    const tokenBalances = [];
+    const newTokens = [];
+    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 = (0, exports.parseAssetType)(asset.type);
+        if (!parsed) {
+            throw new Error('Failed to parse asset type');
+        }
+        const [tokenAddress, isNativeToken] = parsed;
+        // Validate token address
+        if (!(0, utils_1.isStrictHexString)(tokenAddress) ||
+            !(0, controller_utils_1.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,
+                chainId,
+                balance: balanceHex,
+            });
+        }
+        // Handle untracked ERC20 tokens - queue for import
+        if (!isNativeToken && !isTracked) {
+            newTokens.push(checksumTokenAddress);
+        }
+    }
+    return { tokenBalances, newTokens, nativeBalanceUpdates };
+}, _TokenBalancesController_processAccumulatedStatusChanges = function _TokenBalancesController_processAccumulatedStatusChanges() {
+    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) {
+        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 = (0, exports.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"),
+            };
+        }
+    }
+    // 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);
 };
 exports.default = TokenBalancesController;
 //# sourceMappingURL=TokenBalancesController.cjs.map