@metamask/assets-controllers 79.0.0 → 80.0.0

package/dist/TokenBalancesController.mjs

@@ -9,11 +9,11 @@ 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;
 import { Web3Provider } from "@ethersproject/providers";
 import { BNToHex, isValidHexAddress, toChecksumHexAddress, toHex } from "@metamask/controller-utils";
 import { StaticIntervalPollingController } from "@metamask/polling-controller";
-import { isStrictHexString } from "@metamask/utils";
+import { isCaipAssetType, isCaipChainId, isStrictHexString, parseCaipAssetType, parseCaipChainId } from "@metamask/utils";
 import { produce } from "immer";
 import $lodash from "lodash";
 const { isEqual } = $lodash;
@@ -21,7 +21,8 @@ import { STAKING_CONTRACT_ADDRESS_BY_CHAINID } from "./AssetsContractController.
 import { AccountsApiBalanceFetcher } from "./multi-chain-accounts-service/api-balance-fetcher.mjs";
 import { RpcBalanceFetcher } from "./rpc-service/rpc-balance-fetcher.mjs";
 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,
@@ -36,11 +37,50 @@ const metadata = {
 const draft = (base, fn) => produce(base, fn);
 const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 const checksum = (addr) => toChecksumHexAddress(addr);
+/**
+ * Convert CAIP chain ID or hex chain ID to hex chain ID
+ * Handles both CAIP-2 format (e.g., "eip155:1") and hex format (e.g., "0x1")
+ *
+ * @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)) {
+        return chainId;
+    }
+    if (isCaipChainId(chainId)) {
+        return toHex(parseCaipChainId(chainId).reference);
+    }
+    throw new Error('caipChainIdToHex - Failed to provide CAIP-2 or Hex chainId');
+};
+/**
+ * Extract token address from asset type
+ * Returns tuple of [tokenAddress, isNativeToken] or null if invalid
+ *
+ * @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
 // ────────────────────────────────────────────────────────────────────────────
 // region: Main controller
 export class TokenBalancesController extends 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,
@@ -54,8 +94,11 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
         _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 */
@@ -64,6 +107,11 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
         _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];
@@ -165,6 +213,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) => {
@@ -208,10 +257,85 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
                 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 = 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, [
@@ -225,9 +349,10 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
         ], "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);
@@ -238,6 +363,10 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
         // 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
@@ -392,15 +521,14 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
             }
             // Update with actual fetched balances only if the value has changed
             aggregated.forEach(({ success, value, account, token, chainId }) => {
-                var _a, _b;
+                var _a, _b, _c;
                 if (success && value !== undefined) {
                     const newBalance = toHex(value);
                     const tokenAddress = checksum(token);
                     const currentBalance = d.tokenBalances[account]?.[chainId]?.[tokenAddress];
                     // Only update if the balance has actually changed
                     if (currentBalance !== newBalance) {
-                        ((_b = ((_a = d.tokenBalances)[account] ?? (_a[account] = {})))[chainId] ?? (_b[chainId] = {}))[tokenAddress] =
-                            newBalance;
+                        ((_c = ((_a = d.tokenBalances)[_b = account] ?? (_a[_b] = {})))[chainId] ?? (_c[chainId] = {}))[tokenAddress] = newBalance;
                     }
                 }
             });
@@ -465,13 +593,18 @@ export class TokenBalancesController extends StaticIntervalPollingController() {
         __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`);
         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_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")),
@@ -526,6 +659,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 = 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,
+                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 = 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);
 };
 export default TokenBalancesController;
 //# sourceMappingURL=TokenBalancesController.mjs.map