@metamask/assets-controllers 74.0.0 → 74.1.1

package/CHANGELOG.md

@@ -7,6 +7,53 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [74.1.1]
+
+### Changed
+
+- Improve balance fetching performance and resilience by parallelizing multi-chain operations and moving timeout handling to fetchers ([#6390](https://github.com/MetaMask/core/pull/6390))
+
+  - Replace sequential `for` loops with `Promise.allSettled` in `RpcBalanceFetcher` and `AccountTrackerController` for parallel chain processing
+  - Move timeout handling from controller-level `Promise.race` to fetcher-level `safelyExecuteWithTimeout` for better error isolation
+  - Add `safelyExecuteWithTimeout` to both `RpcBalanceFetcher` and `AccountsApiBalanceFetcher` to prevent individual chain timeouts from blocking other chains
+  - Remove redundant timeout wrappers from `TokenBalancesController` and `AccountTrackerController`
+  - Improve test coverage for timeout and error handling scenarios in all balance fetchers
+
+## [74.1.0]
+
+### Added
+
+- Enable `AccountTrackerController` to fetch native balances using AccountsAPI when `allowExternalServices` is enabled ([#6369](https://github.com/MetaMask/core/pull/6369))
+
+  - Implement native balance fetching via AccountsAPI when `useAccountsAPI` and `allowExternalServices` are both true
+  - Add fallback to RPC balance fetching when external services are disabled
+  - Add comprehensive test coverage for both AccountsAPI and RPC balance fetching scenarios
+
+### Changed
+
+- Bump `@metamask/base-controller` from `^8.1.0` to `^8.2.0` ([#6355](https://github.com/MetaMask/core/pull/6355))
+
+- Add new `accountId` field to the `Asset` type ([#6358](https://github.com/MetaMask/core/pull/6358))
+
+### Fixed
+
+- Uses `InternalAccount['type']` for the `Asset['type']` property ([#6358](https://github.com/MetaMask/core/pull/6358))
+
+- Ensure that the evm addresses used to fetch balances from AccountTrackerController state is lowercase, in order to account for discrepancies between clients ([#6358](https://github.com/MetaMask/core/pull/6358))
+
+- Prevents mutation of memoized fields used inside selectors ([#6358](https://github.com/MetaMask/core/pull/6358))
+
+- Fix duplicate token balance entries caused by case-sensitive address comparison in `TokenBalancesController.updateBalances` ([#6354](https://github.com/MetaMask/core/pull/6354))
+
+  - Normalize token addresses to proper EIP-55 checksum format before using as object keys to prevent the same token from appearing multiple times with different cases
+  - Add comprehensive unit tests for token address normalization scenarios
+
+- Fix TokenBalancesController timeout handling by replacing `safelyExecuteWithTimeout` with proper `Promise.race` implementation ([#6365](https://github.com/MetaMask/core/pull/6365))
+
+  - Replace `safelyExecuteWithTimeout` which was silently swallowing timeout errors with direct `Promise.race` that properly throws
+  - Reduce RPC timeout from 3 minutes to 15 seconds for better responsiveness and batch size
+  - Enable proper fallback between API and RPC balance fetchers when timeouts occur
+
 ## [74.0.0]
 
 ### Added
@@ -1879,7 +1926,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Use Ethers for AssetsContractController ([#845](https://github.com/MetaMask/core/pull/845))
 
-[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/assets-controllers@74.0.0...HEAD
+[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/assets-controllers@74.1.1...HEAD
+[74.1.1]: https://github.com/MetaMask/core/compare/@metamask/assets-controllers@74.1.0...@metamask/assets-controllers@74.1.1
+[74.1.0]: https://github.com/MetaMask/core/compare/@metamask/assets-controllers@74.0.0...@metamask/assets-controllers@74.1.0
 [74.0.0]: https://github.com/MetaMask/core/compare/@metamask/assets-controllers@73.3.0...@metamask/assets-controllers@74.0.0
 [73.3.0]: https://github.com/MetaMask/core/compare/@metamask/assets-controllers@73.2.0...@metamask/assets-controllers@73.3.0
 [73.2.0]: https://github.com/MetaMask/core/compare/@metamask/assets-controllers@73.1.0...@metamask/assets-controllers@73.2.0

package/dist/AccountTrackerController.cjs

@@ -13,7 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _AccountTrackerController_instances, _AccountTrackerController_refreshMutex, _AccountTrackerController_includeStakedAssets, _AccountTrackerController_getStakedBalanceForChain, _AccountTrackerController_getCorrectNetworkClient, _AccountTrackerController_getNetworkClientIds, _AccountTrackerController_getBalanceFromChain, _AccountTrackerController_registerMessageHandlers;
+var _AccountTrackerRpcBalanceFetcher_instances, _AccountTrackerRpcBalanceFetcher_getProvider, _AccountTrackerRpcBalanceFetcher_getNetworkClient, _AccountTrackerRpcBalanceFetcher_includeStakedAssets, _AccountTrackerRpcBalanceFetcher_getStakedBalanceForChain, _AccountTrackerRpcBalanceFetcher_getBalanceFromChain, _AccountTrackerController_instances, _AccountTrackerController_refreshMutex, _AccountTrackerController_includeStakedAssets, _AccountTrackerController_getStakedBalanceForChain, _AccountTrackerController_balanceFetchers, _AccountTrackerController_getProvider, _AccountTrackerController_getNetworkClient, _AccountTrackerController_getCorrectNetworkClient, _AccountTrackerController_getNetworkClientIds, _AccountTrackerController_registerMessageHandlers;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AccountTrackerController = void 0;
 const contracts_1 = require("@ethersproject/contracts");
@@ -23,14 +23,149 @@ const eth_query_1 = __importDefault(require("@metamask/eth-query"));
 const polling_controller_1 = require("@metamask/polling-controller");
 const utils_1 = require("@metamask/utils");
 const async_mutex_1 = require("async-mutex");
+const bn_js_1 = __importDefault(require("bn.js"));
 const lodash_1 = require("lodash");
 const single_call_balance_checker_abi_1 = __importDefault(require("single-call-balance-checker-abi"));
 const AssetsContractController_1 = require("./AssetsContractController.cjs");
 const assetsUtil_1 = require("./assetsUtil.cjs");
+const api_balance_fetcher_1 = require("./multi-chain-accounts-service/api-balance-fetcher.cjs");
 /**
  * The name of the {@link AccountTrackerController}.
  */
 const controllerName = 'AccountTrackerController';
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+/**
+ * RPC-based balance fetcher for AccountTrackerController.
+ * Fetches only native balances and staked balances (no token balances).
+ */
+class AccountTrackerRpcBalanceFetcher {
+    constructor(getProvider, getNetworkClient, includeStakedAssets, getStakedBalanceForChain) {
+        _AccountTrackerRpcBalanceFetcher_instances.add(this);
+        _AccountTrackerRpcBalanceFetcher_getProvider.set(this, void 0);
+        _AccountTrackerRpcBalanceFetcher_getNetworkClient.set(this, void 0);
+        _AccountTrackerRpcBalanceFetcher_includeStakedAssets.set(this, void 0);
+        _AccountTrackerRpcBalanceFetcher_getStakedBalanceForChain.set(this, void 0);
+        __classPrivateFieldSet(this, _AccountTrackerRpcBalanceFetcher_getProvider, getProvider, "f");
+        __classPrivateFieldSet(this, _AccountTrackerRpcBalanceFetcher_getNetworkClient, getNetworkClient, "f");
+        __classPrivateFieldSet(this, _AccountTrackerRpcBalanceFetcher_includeStakedAssets, includeStakedAssets, "f");
+        __classPrivateFieldSet(this, _AccountTrackerRpcBalanceFetcher_getStakedBalanceForChain, getStakedBalanceForChain, "f");
+    }
+    supports() {
+        return true; // fallback – supports every chain
+    }
+    async fetch({ chainIds, queryAllAccounts, selectedAccount, allAccounts, }) {
+        // Process all chains in parallel for better performance
+        const chainProcessingPromises = chainIds.map(async (chainId) => {
+            const accountsToUpdate = queryAllAccounts
+                ? Object.values(allAccounts).map((account) => (0, controller_utils_1.toChecksumHexAddress)(account.address))
+                : [selectedAccount];
+            const { provider, blockTracker } = __classPrivateFieldGet(this, _AccountTrackerRpcBalanceFetcher_getNetworkClient, "f").call(this, chainId);
+            const ethQuery = new eth_query_1.default(provider);
+            const chainResults = [];
+            // Force fresh block data before multicall
+            await (0, controller_utils_1.safelyExecuteWithTimeout)(() => blockTracker?.checkForLatestBlock?.());
+            // Fetch native balances
+            if ((0, utils_1.hasProperty)(AssetsContractController_1.SINGLE_CALL_BALANCES_ADDRESS_BY_CHAINID, chainId)) {
+                const contractAddress = AssetsContractController_1.SINGLE_CALL_BALANCES_ADDRESS_BY_CHAINID[chainId];
+                const contract = new contracts_1.Contract(contractAddress, single_call_balance_checker_abi_1.default, __classPrivateFieldGet(this, _AccountTrackerRpcBalanceFetcher_getProvider, "f").call(this, chainId));
+                const nativeBalances = await (0, controller_utils_1.safelyExecuteWithTimeout)(() => contract.balances(accountsToUpdate, [ZERO_ADDRESS]), false, 3000);
+                if (nativeBalances) {
+                    accountsToUpdate.forEach((address, index) => {
+                        chainResults.push({
+                            success: true,
+                            value: new bn_js_1.default(nativeBalances[index].toString()),
+                            account: address,
+                            token: ZERO_ADDRESS,
+                            chainId,
+                        });
+                    });
+                }
+            }
+            else {
+                // Process accounts in batches using reduceInBatchesSerially
+                await (0, assetsUtil_1.reduceInBatchesSerially)({
+                    values: accountsToUpdate,
+                    batchSize: assetsUtil_1.TOKEN_PRICES_BATCH_SIZE,
+                    initialResult: undefined,
+                    eachBatch: async (workingResult, batch) => {
+                        const balancePromises = batch.map(async (address) => {
+                            const balanceResult = await __classPrivateFieldGet(this, _AccountTrackerRpcBalanceFetcher_instances, "m", _AccountTrackerRpcBalanceFetcher_getBalanceFromChain).call(this, address, ethQuery).catch(() => null);
+                            if (balanceResult) {
+                                chainResults.push({
+                                    success: true,
+                                    value: new bn_js_1.default(balanceResult.replace('0x', ''), 16),
+                                    account: address,
+                                    token: ZERO_ADDRESS,
+                                    chainId,
+                                });
+                            }
+                            else {
+                                chainResults.push({
+                                    success: false,
+                                    account: address,
+                                    token: ZERO_ADDRESS,
+                                    chainId,
+                                });
+                            }
+                        });
+                        await Promise.allSettled(balancePromises);
+                        return workingResult;
+                    },
+                });
+            }
+            // Fetch staked balances if enabled
+            if (__classPrivateFieldGet(this, _AccountTrackerRpcBalanceFetcher_includeStakedAssets, "f")) {
+                const stakedBalancesPromise = __classPrivateFieldGet(this, _AccountTrackerRpcBalanceFetcher_getStakedBalanceForChain, "f").call(this, accountsToUpdate, chainId);
+                const stakedBalanceResult = await (0, controller_utils_1.safelyExecuteWithTimeout)(async () => (await stakedBalancesPromise));
+                if (stakedBalanceResult) {
+                    // Find the staking contract address for this chain
+                    const stakingContractAddress = AssetsContractController_1.STAKING_CONTRACT_ADDRESS_BY_CHAINID[chainId];
+                    if (stakingContractAddress) {
+                        Object.entries(stakedBalanceResult).forEach(([address, balance]) => {
+                            chainResults.push({
+                                success: true,
+                                value: balance
+                                    ? new bn_js_1.default(balance.replace('0x', ''), 16)
+                                    : new bn_js_1.default('0'),
+                                account: address,
+                                token: (0, controller_utils_1.toChecksumHexAddress)(stakingContractAddress),
+                                chainId,
+                            });
+                        });
+                    }
+                }
+            }
+            return chainResults;
+        });
+        // Wait for all chains to complete (or fail) and collect results
+        const chainResultsArray = await Promise.allSettled(chainProcessingPromises);
+        const results = [];
+        chainResultsArray.forEach((chainResult) => {
+            if (chainResult.status === 'fulfilled') {
+                results.push(...chainResult.value);
+            }
+            else {
+                // Log error but continue with other chains
+                console.warn('Chain processing failed:', chainResult.reason);
+            }
+        });
+        return results;
+    }
+}
+_AccountTrackerRpcBalanceFetcher_getProvider = new WeakMap(), _AccountTrackerRpcBalanceFetcher_getNetworkClient = new WeakMap(), _AccountTrackerRpcBalanceFetcher_includeStakedAssets = new WeakMap(), _AccountTrackerRpcBalanceFetcher_getStakedBalanceForChain = new WeakMap(), _AccountTrackerRpcBalanceFetcher_instances = new WeakSet(), _AccountTrackerRpcBalanceFetcher_getBalanceFromChain = 
+/**
+ * Fetches the balance of a given address from the blockchain.
+ *
+ * @param address - The account address to fetch the balance for.
+ * @param ethQuery - The EthQuery instance to query getBalance with.
+ * @returns A promise that resolves to the balance in a hex string format.
+ */
+async function _AccountTrackerRpcBalanceFetcher_getBalanceFromChain(address, ethQuery) {
+    return await (0, controller_utils_1.safelyExecuteWithTimeout)(async () => {
+        (0, utils_1.assert)(ethQuery, 'Provider not set.');
+        return await (0, controller_utils_1.query)(ethQuery, 'getBalance', [address]);
+    });
+};
 const accountTrackerMetadata = {
     accountsByChainId: {
         persist: true,
@@ -50,8 +185,10 @@ class AccountTrackerController extends (0, polling_controller_1.StaticIntervalPo
      * @param options.messenger - The controller messaging system.
      * @param options.getStakedBalanceForChain - The function to get the staked native asset balance for a chain.
      * @param options.includeStakedAssets - Whether to include staked assets in the account balances.
+     * @param options.useAccountsAPI - Enable Accounts‑API strategy (if supported chain).
+     * @param options.allowExternalServices - Disable external HTTP calls (privacy / offline mode).
      */
-    constructor({ interval = 10000, state, messenger, getStakedBalanceForChain, includeStakedAssets = false, }) {
+    constructor({ interval = 10000, state, messenger, getStakedBalanceForChain, includeStakedAssets = false, useAccountsAPI = false, allowExternalServices = () => true, }) {
         const { selectedNetworkClientId } = messenger.call('NetworkController:getState');
         const { configuration: { chainId }, } = messenger.call('NetworkController:getNetworkClientById', selectedNetworkClientId);
         super({
@@ -69,8 +206,29 @@ class AccountTrackerController extends (0, polling_controller_1.StaticIntervalPo
         _AccountTrackerController_refreshMutex.set(this, new async_mutex_1.Mutex());
         _AccountTrackerController_includeStakedAssets.set(this, void 0);
         _AccountTrackerController_getStakedBalanceForChain.set(this, void 0);
+        _AccountTrackerController_balanceFetchers.set(this, void 0);
+        _AccountTrackerController_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 providers_1.Web3Provider(client.provider);
+        });
+        _AccountTrackerController_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);
+        });
         __classPrivateFieldSet(this, _AccountTrackerController_getStakedBalanceForChain, getStakedBalanceForChain, "f");
         __classPrivateFieldSet(this, _AccountTrackerController_includeStakedAssets, includeStakedAssets, "f");
+        // Initialize balance fetchers - Strategy order: API first, then RPC fallback
+        __classPrivateFieldSet(this, _AccountTrackerController_balanceFetchers, [
+            ...(useAccountsAPI && allowExternalServices()
+                ? [new api_balance_fetcher_1.AccountsApiBalanceFetcher('extension', __classPrivateFieldGet(this, _AccountTrackerController_getProvider, "f"))]
+                : []),
+            new AccountTrackerRpcBalanceFetcher(__classPrivateFieldGet(this, _AccountTrackerController_getProvider, "f"), __classPrivateFieldGet(this, _AccountTrackerController_getNetworkClient, "f"), includeStakedAssets, getStakedBalanceForChain),
+        ], "f");
         this.setIntervalLength(interval);
         this.messagingSystem.subscribe('AccountsController:selectedEvmAccountChange', (newAddress, prevAddress) => {
             if (newAddress !== prevAddress) {
@@ -140,6 +298,8 @@ class AccountTrackerController extends (0, polling_controller_1.StaticIntervalPo
      */
     async refresh(networkClientIds) {
         const selectedAccount = this.messagingSystem.call('AccountsController:getSelectedAccount');
+        const allAccounts = this.messagingSystem.call('AccountsController:listAccounts');
+        const { isMultiAccountBalancesEnabled } = this.messagingSystem.call('PreferencesController:getState');
         const releaseLock = await __classPrivateFieldGet(this, _AccountTrackerController_refreshMutex, "f").acquire();
         try {
             const chainIds = networkClientIds.map((networkClientId) => {
@@ -147,83 +307,74 @@ class AccountTrackerController extends (0, polling_controller_1.StaticIntervalPo
                 return chainId;
             });
             this.syncAccounts(chainIds);
-            // Create an array of promises for each networkClientId
-            const updatePromises = networkClientIds.map(async (networkClientId) => {
-                const { chainId, ethQuery, provider, blockTracker } = __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_getCorrectNetworkClient).call(this, networkClientId);
-                const { accountsByChainId } = this.state;
-                const { isMultiAccountBalancesEnabled } = this.messagingSystem.call('PreferencesController:getState');
-                const accountsToUpdate = isMultiAccountBalancesEnabled
-                    ? Object.keys(accountsByChainId[chainId])
-                    : [(0, controller_utils_1.toChecksumHexAddress)(selectedAccount.address)];
-                const accountsForChain = { ...accountsByChainId[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.
-                await (0, controller_utils_1.safelyExecuteWithTimeout)(() => blockTracker?.checkForLatestBlock?.());
-                const stakedBalancesPromise = __classPrivateFieldGet(this, _AccountTrackerController_includeStakedAssets, "f")
-                    ? __classPrivateFieldGet(this, _AccountTrackerController_getStakedBalanceForChain, "f").call(this, accountsToUpdate, networkClientId)
-                    : Promise.resolve({});
-                if ((0, utils_1.hasProperty)(AssetsContractController_1.SINGLE_CALL_BALANCES_ADDRESS_BY_CHAINID, chainId)) {
-                    const contractAddress = AssetsContractController_1.SINGLE_CALL_BALANCES_ADDRESS_BY_CHAINID[chainId];
-                    const contract = new contracts_1.Contract(contractAddress, single_call_balance_checker_abi_1.default, new providers_1.Web3Provider(provider));
-                    const nativeBalances = await (0, controller_utils_1.safelyExecuteWithTimeout)(() => contract.balances(accountsToUpdate, [
-                        '0x0000000000000000000000000000000000000000',
-                    ]), false, 3000);
-                    if (nativeBalances) {
-                        accountsToUpdate.forEach((address, index) => {
-                            accountsForChain[address] = {
-                                balance: nativeBalances[index].toHexString(),
-                            };
-                        });
-                    }
+            // Use balance fetchers with fallback strategy
+            const aggregated = [];
+            let remainingChains = [...chainIds];
+            // Try each fetcher in order, removing successfully processed chains
+            for (const fetcher of __classPrivateFieldGet(this, _AccountTrackerController_balanceFetchers, "f")) {
+                const supportedChains = remainingChains.filter((c) => fetcher.supports(c));
+                if (!supportedChains.length) {
+                    continue;
                 }
-                else {
-                    // Process accounts in batches using reduceInBatchesSerially
-                    await (0, assetsUtil_1.reduceInBatchesSerially)({
-                        values: accountsToUpdate,
-                        batchSize: assetsUtil_1.TOKEN_PRICES_BATCH_SIZE,
-                        initialResult: undefined,
-                        eachBatch: async (workingResult, batch) => {
-                            const balancePromises = batch.map(async (address) => {
-                                const balanceResult = await __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_getBalanceFromChain).call(this, address, ethQuery).catch(() => null);
-                                // Update account balances
-                                if (balanceResult) {
-                                    accountsForChain[address] = {
-                                        balance: balanceResult,
-                                    };
-                                }
-                            });
-                            await Promise.allSettled(balancePromises);
-                            return workingResult;
-                        },
+                try {
+                    const balances = await fetcher.fetch({
+                        chainIds: supportedChains,
+                        queryAllAccounts: isMultiAccountBalancesEnabled,
+                        selectedAccount: (0, controller_utils_1.toChecksumHexAddress)(selectedAccount.address),
+                        allAccounts,
                     });
+                    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));
+                    }
                 }
-                const stakedBalanceResult = await (0, controller_utils_1.safelyExecuteWithTimeout)(async () => (await stakedBalancesPromise));
-                Object.entries(stakedBalanceResult ?? {}).forEach(([address, balance]) => {
-                    accountsForChain[address] = {
-                        ...accountsForChain[address],
-                        stakedBalance: balance,
-                    };
-                });
-                // After all batches are processed, return the updated data
-                return { chainId, accountsForChain };
-            });
-            // Wait for all networkClientId updates to settle in parallel
-            const allResults = await Promise.allSettled(updatePromises);
+                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;
+                }
+            }
             // Build a _copy_ of the current state and track whether anything changed
             const nextAccountsByChainId = (0, lodash_1.cloneDeep)(this.state.accountsByChainId);
             let hasChanges = false;
-            allResults.forEach((result) => {
-                if (result.status === 'fulfilled') {
-                    const { chainId, accountsForChain } = result.value;
-                    // Only mark as changed if the incoming data differs
-                    if (!(0, lodash_1.isEqual)(nextAccountsByChainId[chainId], accountsForChain)) {
-                        nextAccountsByChainId[chainId] = accountsForChain;
-                        hasChanges = true;
+            // Process the aggregated balance results
+            const stakedBalancesByChainAndAddress = {};
+            aggregated.forEach(({ success, value, account, token, chainId }) => {
+                if (success && value !== undefined) {
+                    const hexValue = `0x${value.toString(16)}`;
+                    if (token === ZERO_ADDRESS) {
+                        // Native balance
+                        if (nextAccountsByChainId[chainId][account].balance !== hexValue) {
+                            nextAccountsByChainId[chainId][account].balance = hexValue;
+                            hasChanges = true;
+                        }
+                    }
+                    else {
+                        // Staked balance (from staking contract address)
+                        if (!stakedBalancesByChainAndAddress[chainId]) {
+                            stakedBalancesByChainAndAddress[chainId] = {};
+                        }
+                        stakedBalancesByChainAndAddress[chainId][account] = hexValue;
                     }
                 }
             });
-            // 👇🏻 call `update` only when something is new / different
+            // Apply staked balances
+            Object.entries(stakedBalancesByChainAndAddress).forEach(([chainId, balancesByAddress]) => {
+                Object.entries(balancesByAddress).forEach(([address, stakedBalance]) => {
+                    if (nextAccountsByChainId[chainId][address].stakedBalance !==
+                        stakedBalance) {
+                        nextAccountsByChainId[chainId][address].stakedBalance =
+                            stakedBalance;
+                        hasChanges = true;
+                    }
+                });
+            });
+            // Only update state if something changed
             if (hasChanges) {
                 this.update((state) => {
                     state.accountsByChainId = nextAccountsByChainId;
@@ -318,7 +469,7 @@ class AccountTrackerController extends (0, polling_controller_1.StaticIntervalPo
     }
 }
 exports.AccountTrackerController = AccountTrackerController;
-_AccountTrackerController_refreshMutex = new WeakMap(), _AccountTrackerController_includeStakedAssets = new WeakMap(), _AccountTrackerController_getStakedBalanceForChain = new WeakMap(), _AccountTrackerController_instances = new WeakSet(), _AccountTrackerController_getCorrectNetworkClient = function _AccountTrackerController_getCorrectNetworkClient(networkClientId) {
+_AccountTrackerController_refreshMutex = new WeakMap(), _AccountTrackerController_includeStakedAssets = new WeakMap(), _AccountTrackerController_getStakedBalanceForChain = new WeakMap(), _AccountTrackerController_balanceFetchers = new WeakMap(), _AccountTrackerController_getProvider = new WeakMap(), _AccountTrackerController_getNetworkClient = new WeakMap(), _AccountTrackerController_instances = new WeakSet(), _AccountTrackerController_getCorrectNetworkClient = function _AccountTrackerController_getCorrectNetworkClient(networkClientId) {
     const selectedNetworkClientId = networkClientId ??
         this.messagingSystem.call('NetworkController:getState')
             .selectedNetworkClientId;
@@ -332,19 +483,6 @@ _AccountTrackerController_refreshMutex = new WeakMap(), _AccountTrackerControlle
 }, _AccountTrackerController_getNetworkClientIds = function _AccountTrackerController_getNetworkClientIds() {
     const { networkConfigurationsByChainId } = this.messagingSystem.call('NetworkController:getState');
     return Object.values(networkConfigurationsByChainId).flatMap((networkConfiguration) => networkConfiguration.rpcEndpoints.map((rpcEndpoint) => rpcEndpoint.networkClientId));
-}, _AccountTrackerController_getBalanceFromChain = 
-/**
- * Fetches the balance of a given address from the blockchain.
- *
- * @param address - The account address to fetch the balance for.
- * @param ethQuery - The EthQuery instance to query getBalnce with.
- * @returns A promise that resolves to the balance in a hex string format.
- */
-async function _AccountTrackerController_getBalanceFromChain(address, ethQuery) {
-    return await (0, controller_utils_1.safelyExecuteWithTimeout)(async () => {
-        (0, utils_1.assert)(ethQuery, 'Provider not set.');
-        return await (0, controller_utils_1.query)(ethQuery, 'getBalance', [address]);
-    });
 }, _AccountTrackerController_registerMessageHandlers = function _AccountTrackerController_registerMessageHandlers() {
     this.messagingSystem.registerActionHandler(`${controllerName}:updateNativeBalances`, this.updateNativeBalances.bind(this));
     this.messagingSystem.registerActionHandler(`${controllerName}:updateStakedBalances`, this.updateStakedBalances.bind(this));