@metamask-previews/assets-controllers 73.0.1-preview-bf50b46b → 73.0.1-preview-e4e5ca5c

package/dist/TokenBalancesController.mjs

@@ -1,310 +1,360 @@
+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 __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_log, _TokenBalancesController_queryAllAccounts, _TokenBalancesController_balanceFetchers, _TokenBalancesController_allTokens, _TokenBalancesController_detectedTokens, _TokenBalancesController_chainIdsWithTokens_get, _TokenBalancesController_getProvider, _TokenBalancesController_getNetworkClient, _TokenBalancesController_onTokensChanged, _TokenBalancesController_onNetworkChanged, _TokenBalancesController_onAccountRemoved;
-function $importDefault(module) {
-    if (module?.__esModule) {
-        return module.default;
-    }
-    return module;
-}
+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";
 import { Web3Provider } from "@ethersproject/providers";
-import { isValidHexAddress, toHex } from "@metamask/controller-utils";
+import { isValidHexAddress, toChecksumHexAddress, toHex } from "@metamask/controller-utils";
+import { abiERC20 } from "@metamask/metamask-eth-abis";
 import { StaticIntervalPollingController } from "@metamask/polling-controller";
 import { isStrictHexString } from "@metamask/utils";
-import { produce } from "immer";
-import $isEqual from "lodash/isEqual.js";
-const isEqual = $importDefault($isEqual);
-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
+import $lodash from "lodash";
+const { isEqual } = $lodash;
+import { multicallOrFallback } from "./multicall.mjs";
+const DEFAULT_INTERVAL = 180000;
+const controllerName = 'TokenBalancesController';
 const metadata = {
     tokenBalances: { persist: true, anonymous: false },
 };
-// endregion
-// ────────────────────────────────────────────────────────────────────────────
-// region: Helper utilities
-const draft = (base, fn) => produce(base, fn);
-const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
-// endregion
-// ────────────────────────────────────────────────────────────────────────────
-// region: Main controller
+/**
+ * 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
+ */
 export class TokenBalancesController extends StaticIntervalPollingController() {
-    constructor({ messenger, interval = DEFAULT_INTERVAL_MS, state = {}, queryMultipleAccounts = true, useAccountsAPI = true, allowExternalServices = () => true, log = (...args) => console.warn(`[${CONTROLLER}]`, ...args), }) {
+    /**
+     * 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;
         super({
-            name: CONTROLLER,
-            messenger,
+            name: controllerName,
             metadata,
-            state: { tokenBalances: {}, ...state },
+            messenger,
+            state: {
+                ...getDefaultTokenBalancesState(),
+                ...state,
+            },
         });
         _TokenBalancesController_instances.add(this);
-        _TokenBalancesController_log.set(this, void 0);
-        _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);
-        });
-        _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);
+        _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);
         });
-        // ───────── event handlers ─────────
-        _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);
-            });
-            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) => {
-                    __classPrivateFieldGet(this, _TokenBalancesController_log, "f").call(this, 'Error updating balances after token change:', error);
-                });
+        /**
+         * 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_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];
-            });
+        /**
+         * 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);
         });
-        __classPrivateFieldSet(this, _TokenBalancesController_log, log, "f");
-        __classPrivateFieldSet(this, _TokenBalancesController_queryAllAccounts, queryMultipleAccounts, "f");
-        // Strategy order: API first, then RPC fallback
-        __classPrivateFieldSet(this, _TokenBalancesController_balanceFetchers, [
-            ...(useAccountsAPI && allowExternalServices()
-                ? [new AccountsApiBalanceFetcher()]
-                : []),
-            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");
+        /**
+         * 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);
-        // 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"));
+        // 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));
     }
-    // ───────── polling ─────────
-    async _executePoll({ chainIds }) {
-        await this.updateBalances({ chainIds });
+    /**
+     * 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 });
     }
-    // ───────── public API ─────────
+    /**
+     * 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 } = {}) {
-        const targetChains = chainIds ?? __classPrivateFieldGet(this, _TokenBalancesController_instances, "a", _TokenBalancesController_chainIdsWithTokens_get);
-        if (!targetChains.length) {
+        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,
+            });
+        }
+        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;
         }
-        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;
-            }
-            try {
-                const balances = await fetcher.fetch({
-                    chainIds: supportedChains,
-                    queryAllAccounts: __classPrivateFieldGet(this, _TokenBalancesController_queryAllAccounts, "f"),
-                    selectedAccount: selected,
-                    allAccounts,
-                });
-                if (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));
+        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);
                 }
             }
-            catch (error) {
-                __classPrivateFieldGet(this, _TokenBalancesController_log, "f").call(this, `Balance fetcher failed for chains ${supportedChains.join(', ')}: ${String(error)}`);
-                // Continue to next fetcher (fallback)
+        });
+    }
+    /**
+     * 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_handleOnAccountRemoved = function _TokenBalancesController_handleOnAccountRemoved(accountAddress) {
+    const isEthAddress = isStrictHexString(accountAddress.toLowerCase()) &&
+        isValidHexAddress(accountAddress);
+    if (!isEthAddress) {
+        return;
+    }
+    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)) {
+                continue;
             }
-            // If all chains have been processed, break early
-            if (remainingChains.length === 0) {
-                break;
+            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];
+                    });
+                }
             }
         }
-        // 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 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;
                 }
             }
-            // 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);
-            aggregated.forEach((r) => {
-                if (r.success && r.token === ZERO_ADDRESS) {
-                    this.messagingSystem.call('AccountTrackerController:updateNativeToken', r.account, r.chainId, r.value?.toString() ?? '0');
-                }
-            });
-        }
-        else {
-            __classPrivateFieldGet(this, _TokenBalancesController_log, "f").call(this, 'No balance changes detected');
         }
     }
-    resetState() {
-        this.update(() => ({ tokenBalances: {} }));
+    if (shouldUpdate) {
+        await this.updateBalances({ chainIds }).catch(console.error);
     }
-}
-_TokenBalancesController_log = new WeakMap(), _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_get = function _TokenBalancesController_chainIdsWithTokens_get() {
-    return [
-        ...new Set([
-            ...Object.keys(__classPrivateFieldGet(this, _TokenBalancesController_allTokens, "f")),
-            ...Object.keys(__classPrivateFieldGet(this, _TokenBalancesController_detectedTokens, "f")),
-        ]),
-    ];
+}, _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}`);
+    }
+    const { networkClientId } = networkConfiguration.rpcEndpoints[networkConfiguration.defaultRpcEndpointIndex];
+    return this.messagingSystem.call(`NetworkController:getNetworkClientById`, networkClientId);
 };
 export default TokenBalancesController;
 //# sourceMappingURL=TokenBalancesController.mjs.map