@metamask/assets-controllers 73.1.0 → 73.3.0

package/dist/TokenBalancesController.mjs

@@ -1,360 +1,320 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _TokenBalancesController_instances, _TokenBalancesController_queryMultipleAccounts, _TokenBalancesController_allTokens, _TokenBalancesController_allDetectedTokens, _TokenBalancesController_calculateQueryMultipleAccounts, _TokenBalancesController_onPreferencesStateChange, _TokenBalancesController_onTokensStateChange, _TokenBalancesController_onNetworkStateChange, _TokenBalancesController_handleOnAccountRemoved, _TokenBalancesController_getChainIds, _TokenBalancesController_handleTokensControllerStateChange, _TokenBalancesController_getProvider, _TokenBalancesController_ensureFreshBlockData, _TokenBalancesController_batchBalanceOf, _TokenBalancesController_getNetworkClient;
-import { Contract } from "@ethersproject/contracts";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TokenBalancesController_instances, _TokenBalancesController_queryAllAccounts, _TokenBalancesController_balanceFetchers, _TokenBalancesController_allTokens, _TokenBalancesController_detectedTokens, _TokenBalancesController_chainIdsWithTokens, _TokenBalancesController_getProvider, _TokenBalancesController_getNetworkClient, _TokenBalancesController_onTokensChanged, _TokenBalancesController_onNetworkChanged, _TokenBalancesController_onAccountRemoved;
 import { Web3Provider } from "@ethersproject/providers";
-import { isValidHexAddress, toChecksumHexAddress, toHex } from "@metamask/controller-utils";
-import { abiERC20 } from "@metamask/metamask-eth-abis";
+import { isValidHexAddress, safelyExecuteWithTimeout, toHex } from "@metamask/controller-utils";
 import { StaticIntervalPollingController } from "@metamask/polling-controller";
 import { isStrictHexString } from "@metamask/utils";
+import { produce } from "immer";
 import $lodash from "lodash";
 const { isEqual } = $lodash;
-import { multicallOrFallback } from "./multicall.mjs";
-const DEFAULT_INTERVAL = 180000;
-const controllerName = 'TokenBalancesController';
+import { STAKING_CONTRACT_ADDRESS_BY_CHAINID } from "./AssetsContractController.mjs";
+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 metadata = {
     tokenBalances: { persist: true, anonymous: false },
 };
-/**
- * Get the default TokenBalancesController state.
- *
- * @returns The default TokenBalancesController state.
- */
-export function getDefaultTokenBalancesState() {
-    return {
-        tokenBalances: {},
-    };
-}
-/**
- * Controller that passively polls on a set interval token balances
- * for tokens stored in the TokensController
- */
+// endregion
+// ────────────────────────────────────────────────────────────────────────────
+// region: Helper utilities
+const draft = (base, fn) => produce(base, fn);
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+// endregion
+// ────────────────────────────────────────────────────────────────────────────
+// region: Main controller
 export class TokenBalancesController extends StaticIntervalPollingController() {
-    /**
-     * Construct a Token Balances Controller.
-     *
-     * @param options - The controller options.
-     * @param options.interval - Polling interval used to fetch new token balances.
-     * @param options.state - Initial state to set on this controller.
-     * @param options.messenger - The controller restricted messenger.
-     */
-    constructor({ interval = DEFAULT_INTERVAL, messenger, state = {}, }) {
-        var _a, _b;
+    constructor({ messenger, interval = DEFAULT_INTERVAL_MS, state = {}, queryMultipleAccounts = true, useAccountsAPI = false, allowExternalServices = () => true, }) {
         super({
-            name: controllerName,
-            metadata,
+            name: CONTROLLER,
             messenger,
-            state: {
-                ...getDefaultTokenBalancesState(),
-                ...state,
-            },
+            metadata,
+            state: { tokenBalances: {}, ...state },
         });
         _TokenBalancesController_instances.add(this);
-        _TokenBalancesController_queryMultipleAccounts.set(this, void 0);
-        _TokenBalancesController_allTokens.set(this, void 0);
-        _TokenBalancesController_allDetectedTokens.set(this, void 0);
-        /**
-         * Determines whether to query all accounts, or just the selected account.
-         * @param preferences - The preferences state.
-         * @param preferences.isMultiAccountBalancesEnabled - whether to query all accounts (mobile).
-         * @param preferences.useMultiAccountBalanceChecker - whether to query all accounts (extension).
-         * @returns true if all accounts should be queried.
-         */
-        _TokenBalancesController_calculateQueryMultipleAccounts.set(this, ({ isMultiAccountBalancesEnabled, useMultiAccountBalanceChecker, }) => {
-            return Boolean(
-            // Note: These settings have different names on extension vs mobile
-            isMultiAccountBalancesEnabled || useMultiAccountBalanceChecker);
-        });
-        /**
-         * Handles the event for preferences state changes.
-         * @param preferences - The preferences state.
-         */
-        _TokenBalancesController_onPreferencesStateChange.set(this, (preferences) => {
-            // Update the user preference for whether to query multiple accounts.
-            const queryMultipleAccounts = __classPrivateFieldGet(this, _TokenBalancesController_calculateQueryMultipleAccounts, "f").call(this, preferences);
-            // Refresh when flipped off -> on
-            const refresh = queryMultipleAccounts && !__classPrivateFieldGet(this, _TokenBalancesController_queryMultipleAccounts, "f");
-            __classPrivateFieldSet(this, _TokenBalancesController_queryMultipleAccounts, queryMultipleAccounts, "f");
-            if (refresh) {
-                this.updateBalances().catch(console.error);
-            }
+        _TokenBalancesController_queryAllAccounts.set(this, void 0);
+        _TokenBalancesController_balanceFetchers.set(this, void 0);
+        _TokenBalancesController_allTokens.set(this, {});
+        _TokenBalancesController_detectedTokens.set(this, {});
+        _TokenBalancesController_getProvider.set(this, (chainId) => {
+            const { networkConfigurationsByChainId } = this.messagingSystem.call('NetworkController:getState');
+            const cfg = networkConfigurationsByChainId[chainId];
+            const { networkClientId } = cfg.rpcEndpoints[cfg.defaultRpcEndpointIndex];
+            const client = this.messagingSystem.call('NetworkController:getNetworkClientById', networkClientId);
+            return new Web3Provider(client.provider);
         });
-        /**
-         * Handles the event for tokens state changes.
-         * @param state - The token state.
-         * @param state.allTokens - The state for imported tokens across all chains.
-         * @param state.allDetectedTokens - The state for detected tokens across all chains.
-         */
-        _TokenBalancesController_onTokensStateChange.set(this, ({ allTokens, allDetectedTokens, }) => {
-            // Refresh token balances on chains whose tokens have changed.
-            const chainIds = __classPrivateFieldGet(this, _TokenBalancesController_getChainIds, "f").call(this, allTokens, allDetectedTokens);
-            const chainIdsToUpdate = chainIds.filter((chainId) => !isEqual(__classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")[chainId], allTokens[chainId]) ||
-                !isEqual(__classPrivateFieldGet(this, _TokenBalancesController_allDetectedTokens, "f")[chainId], allDetectedTokens[chainId]));
-            __classPrivateFieldSet(this, _TokenBalancesController_allTokens, allTokens, "f");
-            __classPrivateFieldSet(this, _TokenBalancesController_allDetectedTokens, allDetectedTokens, "f");
-            __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_handleTokensControllerStateChange).call(this, {
-                chainIds: chainIdsToUpdate,
-            }).catch(console.error);
+        _TokenBalancesController_getNetworkClient.set(this, (chainId) => {
+            const { networkConfigurationsByChainId } = this.messagingSystem.call('NetworkController:getState');
+            const cfg = networkConfigurationsByChainId[chainId];
+            const { networkClientId } = cfg.rpcEndpoints[cfg.defaultRpcEndpointIndex];
+            return this.messagingSystem.call('NetworkController:getNetworkClientById', networkClientId);
         });
-        /**
-         * Returns an array of chain ids that have tokens.
-         * @param allTokens - The state for imported tokens across all chains.
-         * @param allDetectedTokens - The state for detected tokens across all chains.
-         * @returns An array of chain ids that have tokens.
-         */
-        _TokenBalancesController_getChainIds.set(this, (allTokens, allDetectedTokens) => [
-            ...new Set([
-                ...Object.keys(allTokens),
-                ...Object.keys(allDetectedTokens),
-            ]),
-        ]);
-        this.setIntervalLength(interval);
-        // Set initial preference for querying multiple accounts, and subscribe to changes
-        __classPrivateFieldSet(this, _TokenBalancesController_queryMultipleAccounts, __classPrivateFieldGet(this, _TokenBalancesController_calculateQueryMultipleAccounts, "f").call(this, this.messagingSystem.call('PreferencesController:getState')), "f");
-        this.messagingSystem.subscribe('PreferencesController:stateChange', __classPrivateFieldGet(this, _TokenBalancesController_onPreferencesStateChange, "f").bind(this));
-        // Set initial tokens, and subscribe to changes
-        (_a = this, _b = this, {
-            allTokens: ({ set value(_c) { __classPrivateFieldSet(_a, _TokenBalancesController_allTokens, _c, "f"); } }).value,
-            allDetectedTokens: ({ set value(_c) { __classPrivateFieldSet(_b, _TokenBalancesController_allDetectedTokens, _c, "f"); } }).value,
-        } = this.messagingSystem.call('TokensController:getState'));
-        this.messagingSystem.subscribe('TokensController:stateChange', __classPrivateFieldGet(this, _TokenBalancesController_onTokensStateChange, "f").bind(this));
-        // Subscribe to network state changes
-        this.messagingSystem.subscribe('NetworkController:stateChange', __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_onNetworkStateChange).bind(this));
-        // subscribe to account removed event to cleanup stale balances
-        this.messagingSystem.subscribe('KeyringController:accountRemoved', (accountAddress) => __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_handleOnAccountRemoved).call(this, accountAddress));
-    }
-    /**
-     * Polls for erc20 token balances.
-     * @param input - The input for the poll.
-     * @param input.chainId - The chain id to poll token balances on.
-     */
-    async _executePoll({ chainId }) {
-        await this.updateBalancesByChainId({ chainId });
-    }
-    /**
-     * Updates the token balances for the given chain ids.
-     * @param input - The input for the update.
-     * @param input.chainIds - The chain ids to update token balances for.
-     * Or omitted to update all chains that contain tokens.
-     */
-    async updateBalances({ chainIds } = {}) {
-        chainIds ?? (chainIds = __classPrivateFieldGet(this, _TokenBalancesController_getChainIds, "f").call(this, __classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f"), __classPrivateFieldGet(this, _TokenBalancesController_allDetectedTokens, "f")));
-        await Promise.allSettled(chainIds.map((chainId) => this.updateBalancesByChainId({ chainId })));
-    }
-    /**
-     * Returns ERC-20 balances for a single account on a single chain.
-     *
-     * @param params - The parameters for the balance fetch.
-     * @param params.chainId - The chain id to fetch balances on.
-     * @param params.accountAddress - The account address to fetch balances for.
-     * @param params.tokenAddresses - The token addresses to fetch balances for.
-     * @returns A mapping from token address to balance (hex) | null.
-     */
-    async getErc20Balances({ chainId, accountAddress, tokenAddresses, }) {
-        // Return early if no token addresses provided
-        if (tokenAddresses.length === 0) {
-            return {};
-        }
-        const pairs = tokenAddresses.map((tokenAddress) => ({
-            accountAddress,
-            tokenAddress,
-        }));
-        const results = await __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_batchBalanceOf).call(this, { chainId, pairs });
-        const balances = {};
-        tokenAddresses.forEach((tokenAddress, i) => {
-            balances[tokenAddress] = results[i]?.success
-                ? toHex(results[i].value)
-                : null;
-        });
-        return balances;
-    }
-    /**
-     * Updates token balances for the given chain id.
-     * @param input - The input for the update.
-     * @param input.chainId - The chain id to update token balances on.
-     */
-    async updateBalancesByChainId({ chainId }) {
-        const { address: selectedAccountAddress } = this.messagingSystem.call('AccountsController:getSelectedAccount');
-        const isSelectedAccount = (accountAddress) => toChecksumHexAddress(accountAddress) ===
-            toChecksumHexAddress(selectedAccountAddress);
-        const accountTokenPairs = [];
-        const addTokens = ([accountAddress, tokens]) => __classPrivateFieldGet(this, _TokenBalancesController_queryMultipleAccounts, "f") || isSelectedAccount(accountAddress)
-            ? tokens.forEach((t) => accountTokenPairs.push({
-                accountAddress: accountAddress,
-                tokenAddress: t.address,
-            }))
-            : undefined;
-        // Balances will be updated for both imported and detected tokens
-        Object.entries(__classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")[chainId] ?? {}).forEach(addTokens);
-        Object.entries(__classPrivateFieldGet(this, _TokenBalancesController_allDetectedTokens, "f")[chainId] ?? {}).forEach(addTokens);
-        let results = [];
-        const currentTokenBalances = this.messagingSystem.call('TokenBalancesController:getState');
-        if (accountTokenPairs.length > 0) {
-            results = await __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_batchBalanceOf).call(this, {
-                chainId,
-                pairs: accountTokenPairs,
+        _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) ||
+                    (state.allDetectedTokens[id] &&
+                        Object.keys(state.allDetectedTokens[id]).length > 0);
+                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);
             });
-        }
-        const updatedResults = results.map((res, i) => {
-            const { value } = res;
-            const { accountAddress, tokenAddress } = accountTokenPairs[i];
-            const currentTokenBalanceValueForAccount = currentTokenBalances.tokenBalances?.[accountAddress]?.[chainId]?.[tokenAddress];
-            // `value` can be null or undefined if the multicall failed due to RPC issue.
-            // Please see packages/assets-controllers/src/multicall.ts#L365.
-            // Hence we should not update the balance in that case.
-            const isTokenBalanceValueChanged = res.success && value !== undefined && value !== null
-                ? currentTokenBalanceValueForAccount !== toHex(value)
-                : false;
-            return {
-                ...res,
-                isTokenBalanceValueChanged,
-            };
-        });
-        // if all values of isTokenBalanceValueChanged are false, return
-        if (updatedResults.every((result) => !result.isTokenBalanceValueChanged)) {
-            return;
-        }
-        this.update((state) => {
-            var _a, _b;
-            for (let i = 0; i < updatedResults.length; i++) {
-                const { success, value, isTokenBalanceValueChanged } = updatedResults[i];
-                const { accountAddress, tokenAddress } = accountTokenPairs[i];
-                if (success && isTokenBalanceValueChanged) {
-                    ((_b = ((_a = state.tokenBalances)[accountAddress] ?? (_a[accountAddress] = {})))[chainId] ?? (_b[chainId] = {}))[tokenAddress] = toHex(value);
+            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;
+            }
+            // 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] &&
+                        Object.keys(state.allTokens[id]).length > 0) ||
+                        (state.allDetectedTokens[id] &&
+                            Object.keys(state.allDetectedTokens[id]).length > 0);
+                    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);
+                    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;
+                                }
+                            }
+                        }
+                    }
                 }
+            });
+            __classPrivateFieldSet(this, _TokenBalancesController_allTokens, state.allTokens, "f");
+            __classPrivateFieldSet(this, _TokenBalancesController_detectedTokens, state.allDetectedTokens, "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);
+                });
             }
         });
-    }
-    /**
-     * Reset the controller state to the default state.
-     */
-    resetState() {
-        this.update(() => {
-            return getDefaultTokenBalancesState();
-        });
-    }
-}
-_TokenBalancesController_queryMultipleAccounts = new WeakMap(), _TokenBalancesController_allTokens = new WeakMap(), _TokenBalancesController_allDetectedTokens = new WeakMap(), _TokenBalancesController_calculateQueryMultipleAccounts = new WeakMap(), _TokenBalancesController_onPreferencesStateChange = new WeakMap(), _TokenBalancesController_onTokensStateChange = new WeakMap(), _TokenBalancesController_getChainIds = new WeakMap(), _TokenBalancesController_instances = new WeakSet(), _TokenBalancesController_onNetworkStateChange = function _TokenBalancesController_onNetworkStateChange(_, patches) {
-    // Remove state for deleted networks
-    for (const patch of patches) {
-        if (patch.op === 'remove' &&
-            patch.path[0] === 'networkConfigurationsByChainId') {
-            const removedChainId = patch.path[1];
-            this.update((state) => {
-                for (const accountAddress of Object.keys(state.tokenBalances)) {
-                    delete state.tokenBalances[accountAddress][removedChainId];
+        _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;
+                for (const network of Object.keys(this.state.tokenBalances[addressKey] || {})) {
+                    networksWithBalances.add(network);
                 }
+            }
+            // Find networks that were removed
+            const removedNetworks = Array.from(networksWithBalances).filter((network) => !currentNetworks.has(network));
+            if (removedNetworks.length > 0) {
+                this.update((s) => {
+                    // Remove balances for all accounts on the deleted networks
+                    for (const address of Object.keys(s.tokenBalances)) {
+                        const addressKey = address;
+                        for (const removedNetwork of removedNetworks) {
+                            const networkKey = removedNetwork;
+                            if (s.tokenBalances[addressKey]?.[networkKey]) {
+                                delete s.tokenBalances[addressKey][networkKey];
+                            }
+                        }
+                    }
+                });
+            }
+        });
+        _TokenBalancesController_onAccountRemoved.set(this, (addr) => {
+            if (!isStrictHexString(addr) || !isValidHexAddress(addr)) {
+                return;
+            }
+            this.update((s) => {
+                delete s.tokenBalances[addr];
             });
-        }
+        });
+        __classPrivateFieldSet(this, _TokenBalancesController_queryAllAccounts, queryMultipleAccounts, "f");
+        // Strategy order: API first, then RPC fallback
+        __classPrivateFieldSet(this, _TokenBalancesController_balanceFetchers, [
+            ...(useAccountsAPI && allowExternalServices()
+                ? [new AccountsApiBalanceFetcher('extension', __classPrivateFieldGet(this, _TokenBalancesController_getProvider, "f"))]
+                : []),
+            new RpcBalanceFetcher(__classPrivateFieldGet(this, _TokenBalancesController_getProvider, "f"), __classPrivateFieldGet(this, _TokenBalancesController_getNetworkClient, "f"), () => ({
+                allTokens: __classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f"),
+                allDetectedTokens: __classPrivateFieldGet(this, _TokenBalancesController_detectedTokens, "f"),
+            })),
+        ], "f");
+        this.setIntervalLength(interval);
+        // initial token state & subscriptions
+        const { allTokens, allDetectedTokens } = this.messagingSystem.call('TokensController:getState');
+        __classPrivateFieldSet(this, _TokenBalancesController_allTokens, allTokens, "f");
+        __classPrivateFieldSet(this, _TokenBalancesController_detectedTokens, allDetectedTokens, "f");
+        this.messagingSystem.subscribe('TokensController:stateChange', __classPrivateFieldGet(this, _TokenBalancesController_onTokensChanged, "f"));
+        this.messagingSystem.subscribe('NetworkController:stateChange', __classPrivateFieldGet(this, _TokenBalancesController_onNetworkChanged, "f"));
+        this.messagingSystem.subscribe('KeyringController:accountRemoved', __classPrivateFieldGet(this, _TokenBalancesController_onAccountRemoved, "f"));
     }
-}, _TokenBalancesController_handleOnAccountRemoved = function _TokenBalancesController_handleOnAccountRemoved(accountAddress) {
-    const isEthAddress = isStrictHexString(accountAddress.toLowerCase()) &&
-        isValidHexAddress(accountAddress);
-    if (!isEthAddress) {
-        return;
+    async _executePoll({ chainIds }) {
+        await this.updateBalances({ chainIds });
     }
-    this.update((state) => {
-        delete state.tokenBalances[accountAddress];
-    });
-}, _TokenBalancesController_handleTokensControllerStateChange = async function _TokenBalancesController_handleTokensControllerStateChange({ chainIds, } = {}) {
-    const currentTokenBalancesState = this.messagingSystem.call('TokenBalancesController:getState');
-    const currentTokenBalances = currentTokenBalancesState.tokenBalances;
-    const currentAllTokens = __classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f");
-    const chainIdsSet = new Set(chainIds);
-    // first we check if the state change was due to a token being removed
-    for (const currentAccount of Object.keys(currentTokenBalances)) {
-        const allChains = currentTokenBalances[currentAccount];
-        for (const currentChain of Object.keys(allChains)) {
-            if (chainIds?.length && !chainIdsSet.has(currentChain)) {
+    async updateBalances({ chainIds } = {}) {
+        const targetChains = chainIds ?? __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_chainIdsWithTokens).call(this);
+        if (!targetChains.length) {
+            return;
+        }
+        const { address: selected } = this.messagingSystem.call('AccountsController:getSelectedAccount');
+        const allAccounts = this.messagingSystem.call('AccountsController:listAccounts');
+        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;
             }
-            const tokensObject = allChains[currentChain];
-            const allCurrentTokens = Object.keys(tokensObject);
-            const existingTokensInState = currentAllTokens[currentChain]?.[currentAccount] || [];
-            const existingSet = new Set(existingTokensInState.map((elm) => elm.address));
-            for (const singleToken of allCurrentTokens) {
-                if (!existingSet.has(singleToken)) {
-                    this.update((state) => {
-                        delete state.tokenBalances[currentAccount][currentChain][singleToken];
+            try {
+                const balances = await safelyExecuteWithTimeout(async () => {
+                    return await fetcher.fetch({
+                        chainIds: supportedChains,
+                        queryAllAccounts: __classPrivateFieldGet(this, _TokenBalancesController_queryAllAccounts, "f"),
+                        selectedAccount: selected,
+                        allAccounts,
                     });
+                }, false, this.getIntervalLength());
+                if (balances && balances.length > 0) {
+                    aggregated.push(...balances);
+                    // Remove chains that were successfully processed
+                    const processedChains = new Set(balances.map((b) => b.chainId));
+                    remainingChains = remainingChains.filter((chain) => !processedChains.has(chain));
                 }
             }
+            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;
+            }
         }
-    }
-    // then we check if the state change was due to a token being added
-    let shouldUpdate = false;
-    for (const currentChain of Object.keys(currentAllTokens)) {
-        if (chainIds?.length && !chainIdsSet.has(currentChain)) {
-            continue;
-        }
-        const accountsPerChain = currentAllTokens[currentChain];
-        for (const currentAccount of Object.keys(accountsPerChain)) {
-            const tokensList = accountsPerChain[currentAccount];
-            const tokenBalancesObject = currentTokenBalances[currentAccount]?.[currentChain] || {};
-            for (const singleToken of tokensList) {
-                if (!tokenBalancesObject?.[singleToken.address]) {
-                    shouldUpdate = true;
-                    break;
+        // Determine which accounts to process
+        const accountsToProcess = __classPrivateFieldGet(this, _TokenBalancesController_queryAllAccounts, "f")
+            ? allAccounts.map((a) => a.address)
+            : [selected];
+        const prev = this.state;
+        const next = draft(prev, (d) => {
+            // First, initialize all tokens from allTokens state with balance 0
+            // for the accounts and chains we're processing
+            for (const chainId of targetChains) {
+                for (const account of accountsToProcess) {
+                    // Initialize tokens from allTokens
+                    const chainTokens = __classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")[chainId];
+                    if (chainTokens?.[account]) {
+                        Object.values(chainTokens[account]).forEach((token) => {
+                            var _a, _b;
+                            const tokenAddress = token.address;
+                            ((_b = ((_a = d.tokenBalances)[account] ?? (_a[account] = {})))[chainId] ?? (_b[chainId] = {}))[tokenAddress] = '0x0';
+                        });
+                    }
+                    // Initialize tokens from allDetectedTokens
+                    const detectedChainTokens = __classPrivateFieldGet(this, _TokenBalancesController_detectedTokens, "f")[chainId];
+                    if (detectedChainTokens?.[account]) {
+                        Object.values(detectedChainTokens[account]).forEach((token) => {
+                            var _a, _b;
+                            const tokenAddress = token.address;
+                            ((_b = ((_a = d.tokenBalances)[account] ?? (_a[account] = {})))[chainId] ?? (_b[chainId] = {}))[tokenAddress] = '0x0';
+                        });
+                    }
                 }
             }
+            // Then update with actual fetched balances where available
+            aggregated.forEach(({ success, value, account, token, chainId }) => {
+                var _a, _b;
+                if (success && value !== undefined) {
+                    ((_b = ((_a = d.tokenBalances)[account] ?? (_a[account] = {})))[chainId] ?? (_b[chainId] = {}))[token] =
+                        toHex(value);
+                }
+            });
+        });
+        if (!isEqual(prev, next)) {
+            this.update(() => next);
+            const nativeBalances = aggregated.filter((r) => r.success && r.token === ZERO_ADDRESS);
+            // Update native token balances in a single batch operation for better performance
+            if (nativeBalances.length > 0) {
+                const balanceUpdates = nativeBalances.map((balance) => ({
+                    address: balance.account,
+                    chainId: balance.chainId,
+                    balance: balance.value?.toString() ?? '0',
+                }));
+                this.messagingSystem.call('AccountTrackerController:updateNativeBalances', balanceUpdates);
+            }
+            // Get staking contract addresses for filtering
+            const stakingContractAddresses = Object.values(STAKING_CONTRACT_ADDRESS_BY_CHAINID).map((addr) => addr.toLowerCase());
+            // Filter and update staked balances in a single batch operation for better performance
+            const stakedBalances = aggregated.filter((r) => {
+                return (r.success &&
+                    r.token !== ZERO_ADDRESS &&
+                    stakingContractAddresses.includes(r.token.toLowerCase()));
+            });
+            if (stakedBalances.length > 0) {
+                const stakedBalanceUpdates = stakedBalances.map((balance) => ({
+                    address: balance.account,
+                    chainId: balance.chainId,
+                    stakedBalance: balance.value?.toString() ?? '0',
+                }));
+                this.messagingSystem.call('AccountTrackerController:updateStakedBalances', stakedBalanceUpdates);
+            }
         }
     }
-    if (shouldUpdate) {
-        await this.updateBalances({ chainIds }).catch(console.error);
-    }
-}, _TokenBalancesController_getProvider = function _TokenBalancesController_getProvider(chainId) {
-    return new Web3Provider(__classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_getNetworkClient).call(this, chainId).provider);
-}, _TokenBalancesController_ensureFreshBlockData = 
-/**
- * Ensures that the block tracker has the latest block data before performing multicall operations.
- * This is a temporary fix to ensure that the block number is up to date.
- *
- * @param chainId - The chain id to update block data for.
- */
-async function _TokenBalancesController_ensureFreshBlockData(chainId) {
-    // Force fresh block data before multicall
-    // TODO: This is a temporary fix to ensure that the block number is up to date.
-    // We should remove this once we have a better solution for this on the block tracker controller.
-    const networkClient = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_getNetworkClient).call(this, chainId);
-    await networkClient.blockTracker?.checkForLatestBlock?.();
-}, _TokenBalancesController_batchBalanceOf = 
-/**
- * Internal util: run `balanceOf` for an arbitrary set of account/token pairs.
- *
- * @param params - The parameters for the balance fetch.
- * @param params.chainId - The chain id to fetch balances on.
- * @param params.pairs - The account/token pairs to fetch balances for.
- * @returns The balances for the given token addresses.
- */
-async function _TokenBalancesController_batchBalanceOf({ chainId, pairs, }) {
-    if (!pairs.length) {
-        return [];
-    }
-    const provider = __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_getProvider).call(this, chainId);
-    const calls = pairs.map(({ accountAddress, tokenAddress }) => ({
-        contract: new Contract(tokenAddress, abiERC20, provider),
-        functionSignature: 'balanceOf(address)',
-        arguments: [accountAddress],
-    }));
-    await __classPrivateFieldGet(this, _TokenBalancesController_instances, "m", _TokenBalancesController_ensureFreshBlockData).call(this, chainId);
-    return multicallOrFallback(calls, chainId, provider);
-}, _TokenBalancesController_getNetworkClient = function _TokenBalancesController_getNetworkClient(chainId) {
-    const { networkConfigurationsByChainId } = this.messagingSystem.call('NetworkController:getState');
-    const networkConfiguration = networkConfigurationsByChainId[chainId];
-    if (!networkConfiguration) {
-        throw new Error(`TokenBalancesController: No network configuration found for chainId ${chainId}`);
+    resetState() {
+        this.update(() => ({ tokenBalances: {} }));
     }
-    const { networkClientId } = networkConfiguration.rpcEndpoints[networkConfiguration.defaultRpcEndpointIndex];
-    return this.messagingSystem.call(`NetworkController:getNetworkClientById`, networkClientId);
+}
+_TokenBalancesController_queryAllAccounts = new WeakMap(), _TokenBalancesController_balanceFetchers = new WeakMap(), _TokenBalancesController_allTokens = new WeakMap(), _TokenBalancesController_detectedTokens = new WeakMap(), _TokenBalancesController_getProvider = new WeakMap(), _TokenBalancesController_getNetworkClient = new WeakMap(), _TokenBalancesController_onTokensChanged = new WeakMap(), _TokenBalancesController_onNetworkChanged = new WeakMap(), _TokenBalancesController_onAccountRemoved = new WeakMap(), _TokenBalancesController_instances = new WeakSet(), _TokenBalancesController_chainIdsWithTokens = function _TokenBalancesController_chainIdsWithTokens() {
+    return [
+        ...new Set([
+            ...Object.keys(__classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")),
+            ...Object.keys(__classPrivateFieldGet(this, _TokenBalancesController_detectedTokens, "f")),
+        ]),
+    ];
 };
 export default TokenBalancesController;
 //# sourceMappingURL=TokenBalancesController.mjs.map