@metamask-previews/assets-controllers 111.1.3-preview-4f4c98e → 111.1.3-preview-eb263b0ee

package/dist/AccountTrackerController.cjs

@@ -0,0 +1,645 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _AccountTrackerController_instances, _AccountTrackerController_refreshMutex, _AccountTrackerController_includeStakedAssets, _AccountTrackerController_accountsApiChainIds, _AccountTrackerController_getStakedBalanceForChain, _AccountTrackerController_balanceFetchers, _AccountTrackerController_fetchingEnabled, _AccountTrackerController_isOnboarded, _AccountTrackerController_isHomepageSectionsV1Enabled, _AccountTrackerController_isDeprecated, _AccountTrackerController_isLocked, _AccountTrackerController_enforceDisabledState, _AccountTrackerController_syncAccounts, _AccountTrackerController_getProvider, _AccountTrackerController_getNetworkClient, _AccountTrackerController_createAccountsApiFetcher, _AccountTrackerController_getCorrectNetworkClient, _AccountTrackerController_getNetworkClientIds, _AccountTrackerController_refreshAccounts;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountTrackerController = void 0;
+const providers_1 = require("@ethersproject/providers");
+const controller_utils_1 = require("@metamask/controller-utils");
+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 lodash_1 = require("lodash");
+const AssetsContractController_js_1 = require("./AssetsContractController.cjs");
+const constants_js_1 = require("./constants.cjs");
+const api_balance_fetcher_js_1 = require("./multi-chain-accounts-service/api-balance-fetcher.cjs");
+const rpc_balance_fetcher_js_1 = require("./rpc-service/rpc-balance-fetcher.cjs");
+/**
+ * The name of the {@link AccountTrackerController}.
+ */
+const controllerName = 'AccountTrackerController';
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+/**
+ * Creates an RPC balance fetcher configured for AccountTracker use case.
+ * Returns only native balances and staked balances (no token balances).
+ *
+ * @param getProvider - Function to get Web3Provider for a given chain ID
+ * @param getNetworkClient - Function to get NetworkClient for a given chain ID
+ * @param includeStakedAssets - Whether to include staked assets in the fetch
+ * @returns BalanceFetcher configured to fetch only native and optionally staked balances
+ */
+function createAccountTrackerRpcBalanceFetcher(getProvider, getNetworkClient, includeStakedAssets) {
+    // Provide empty tokens state to ensure only native and staked balances are fetched
+    const getEmptyTokensState = () => ({
+        allTokens: {},
+        allDetectedTokens: {},
+    });
+    const rpcBalanceFetcher = new rpc_balance_fetcher_js_1.RpcBalanceFetcher(getProvider, getNetworkClient, getEmptyTokensState);
+    // Wrap the RpcBalanceFetcher to filter staked balances when not needed
+    return {
+        supports(_chainId) {
+            return rpcBalanceFetcher.supports();
+        },
+        async fetch(params) {
+            const result = await rpcBalanceFetcher.fetch(params);
+            if (!includeStakedAssets) {
+                // Filter out staked balances from the results
+                return {
+                    balances: result.balances.filter((balance) => balance.token === ZERO_ADDRESS),
+                    unprocessedChainIds: result.unprocessedChainIds,
+                };
+            }
+            return result;
+        },
+    };
+}
+const accountTrackerMetadata = {
+    accountsByChainId: {
+        includeInStateLogs: false,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+};
+const MESSENGER_EXPOSED_METHODS = [
+    'updateNativeBalances',
+    'updateStakedBalances',
+    'refresh',
+    'syncBalanceWithAddresses',
+];
+/**
+ * Controller that tracks the network balances for all user accounts.
+ */
+class AccountTrackerController extends (0, polling_controller_1.StaticIntervalPollingController)() {
+    /**
+     * Creates an AccountTracker instance.
+     *
+     * @param options - The controller options.
+     * @param options.interval - Polling interval used to fetch new account balances.
+     * @param options.state - Initial state to set on this controller.
+     * @param options.messenger - The controller messenger.
+     * @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.accountsApiChainIds - Function that returns array of chainIds that should use Accounts-API strategy (if supported by API).
+     * @param options.allowExternalServices - Disable external HTTP calls (privacy / offline mode).
+     * @param options.fetchingEnabled - Function that returns whether the controller is fetching enabled.
+     * @param options.isOnboarded - Whether the user has completed onboarding. If false, balance updates are skipped.
+     * @param options.isHomepageSectionsV1Enabled - Whether the homepage sections v1 is enabled.
+     * @param options.isDeprecated - Optional function that returns true to completely
+     * disable this controller (no requests, no state updates). When it returns
+     * `true`, `accountsByChainId` is reset to `{}` at construction and at every
+     * entry point, so no stale balances remain in state. The function is evaluated
+     * dynamically on each entry point so it can be toggled at runtime. Intended for
+     * use when a higher-level controller (e.g. AssetsController) supersedes this one.
+     */
+    constructor({ interval = 10000, state, messenger, getStakedBalanceForChain, includeStakedAssets = false, accountsApiChainIds = () => [], allowExternalServices = () => true, fetchingEnabled = () => true, isOnboarded = () => true, isHomepageSectionsV1Enabled = () => false, isDeprecated = () => false, }) {
+        const { selectedNetworkClientId } = messenger.call('NetworkController:getState');
+        const { configuration: { chainId }, } = messenger.call('NetworkController:getNetworkClientById', selectedNetworkClientId);
+        super({
+            name: controllerName,
+            messenger,
+            state: {
+                accountsByChainId: {
+                    [chainId]: {},
+                },
+                ...state,
+            },
+            metadata: accountTrackerMetadata,
+        });
+        _AccountTrackerController_instances.add(this);
+        _AccountTrackerController_refreshMutex.set(this, new async_mutex_1.Mutex());
+        _AccountTrackerController_includeStakedAssets.set(this, void 0);
+        _AccountTrackerController_accountsApiChainIds.set(this, void 0);
+        _AccountTrackerController_getStakedBalanceForChain.set(this, void 0);
+        _AccountTrackerController_balanceFetchers.set(this, void 0);
+        _AccountTrackerController_fetchingEnabled.set(this, void 0);
+        _AccountTrackerController_isOnboarded.set(this, void 0);
+        _AccountTrackerController_isHomepageSectionsV1Enabled.set(this, void 0);
+        _AccountTrackerController_isDeprecated.set(this, void 0);
+        /** Track if the keyring is locked */
+        _AccountTrackerController_isLocked.set(this, true);
+        _AccountTrackerController_getProvider.set(this, (chainId) => {
+            const { networkConfigurationsByChainId } = this.messenger.call('NetworkController:getState');
+            const networkConfig = networkConfigurationsByChainId[chainId];
+            const { networkClientId } = networkConfig.rpcEndpoints[networkConfig.defaultRpcEndpointIndex];
+            const client = this.messenger.call('NetworkController:getNetworkClientById', networkClientId);
+            return new providers_1.Web3Provider(client.provider);
+        });
+        _AccountTrackerController_getNetworkClient.set(this, (chainId) => {
+            const { networkConfigurationsByChainId } = this.messenger.call('NetworkController:getState');
+            const networkConfig = networkConfigurationsByChainId[chainId];
+            const { networkClientId } = networkConfig.rpcEndpoints[networkConfig.defaultRpcEndpointIndex];
+            return this.messenger.call('NetworkController:getNetworkClientById', networkClientId);
+        });
+        /**
+         * Creates an AccountsApiBalanceFetcher that only supports chains in the accountsApiChainIds array
+         *
+         * @returns A BalanceFetcher that wraps AccountsApiBalanceFetcher with chainId filtering
+         */
+        _AccountTrackerController_createAccountsApiFetcher.set(this, () => {
+            const originalFetcher = new api_balance_fetcher_js_1.AccountsApiBalanceFetcher('extension', __classPrivateFieldGet(this, _AccountTrackerController_getProvider, "f"));
+            return {
+                supports: (chainId) => {
+                    // Only support chains that are both:
+                    // 1. In our specified accountsApiChainIds array
+                    // 2. Actually supported by the AccountsApi
+                    return (__classPrivateFieldGet(this, _AccountTrackerController_accountsApiChainIds, "f").call(this).includes(chainId) &&
+                        originalFetcher.supports(chainId));
+                },
+                fetch: originalFetcher.fetch.bind(originalFetcher),
+            };
+        });
+        __classPrivateFieldSet(this, _AccountTrackerController_getStakedBalanceForChain, getStakedBalanceForChain, "f");
+        __classPrivateFieldSet(this, _AccountTrackerController_includeStakedAssets, includeStakedAssets, "f");
+        __classPrivateFieldSet(this, _AccountTrackerController_accountsApiChainIds, accountsApiChainIds, "f");
+        __classPrivateFieldSet(this, _AccountTrackerController_isHomepageSectionsV1Enabled, isHomepageSectionsV1Enabled, "f");
+        // Initialize balance fetchers - Strategy order: API first, then RPC fallback
+        __classPrivateFieldSet(this, _AccountTrackerController_balanceFetchers, [
+            ...(accountsApiChainIds().length > 0 && allowExternalServices()
+                ? [__classPrivateFieldGet(this, _AccountTrackerController_createAccountsApiFetcher, "f").call(this)]
+                : []),
+            createAccountTrackerRpcBalanceFetcher(__classPrivateFieldGet(this, _AccountTrackerController_getProvider, "f"), __classPrivateFieldGet(this, _AccountTrackerController_getNetworkClient, "f"), __classPrivateFieldGet(this, _AccountTrackerController_includeStakedAssets, "f")),
+        ], "f");
+        __classPrivateFieldSet(this, _AccountTrackerController_fetchingEnabled, fetchingEnabled, "f");
+        __classPrivateFieldSet(this, _AccountTrackerController_isOnboarded, isOnboarded, "f");
+        __classPrivateFieldSet(this, _AccountTrackerController_isDeprecated, isDeprecated, "f");
+        if (__classPrivateFieldGet(this, _AccountTrackerController_isDeprecated, "f").call(this)) {
+            __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_enforceDisabledState).call(this);
+        }
+        const { isUnlocked } = this.messenger.call('KeyringController:getState');
+        __classPrivateFieldSet(this, _AccountTrackerController_isLocked, !isUnlocked, "f");
+        this.setIntervalLength(interval);
+        this.messenger.subscribe('AccountsController:selectedEvmAccountChange', (newAddress, prevAddress) => {
+            if (newAddress !== prevAddress) {
+                // Making an async call for this new event
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                this.refresh(__classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_getNetworkClientIds).call(this));
+            }
+        }, (event) => event.address);
+        this.messenger.subscribe('NetworkController:networkAdded', (networkConfiguration) => {
+            const { networkClientId } = networkConfiguration.rpcEndpoints[networkConfiguration.defaultRpcEndpointIndex];
+            this.refresh([networkClientId]).catch(() => {
+                // Silently handle refresh errors
+            });
+        });
+        this.messenger.subscribe('KeyringController:unlock', () => {
+            __classPrivateFieldSet(this, _AccountTrackerController_isLocked, false, "f");
+            const networkClientIds = __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_getNetworkClientIds).call(this);
+            this.refresh(networkClientIds).catch((error) => {
+                console.error('Error refreshing balances after keyring unlock:', error);
+            });
+        });
+        this.messenger.subscribe('KeyringController:lock', () => {
+            __classPrivateFieldSet(this, _AccountTrackerController_isLocked, true, "f");
+        });
+        this.messenger.subscribe('TransactionController:unapprovedTransactionAdded', (transactionMeta) => {
+            const addresses = [transactionMeta.txParams.from];
+            if (transactionMeta.txParams.to) {
+                addresses.push(transactionMeta.txParams.to);
+            }
+            this.refreshAddresses({
+                networkClientIds: [transactionMeta.networkClientId],
+                addresses,
+            }).catch(() => {
+                // Silently handle refresh errors
+            });
+        });
+        this.messenger.subscribe('TransactionController:transactionConfirmed', (transactionMeta) => {
+            const addresses = [transactionMeta.txParams.from];
+            if (transactionMeta.txParams.to) {
+                addresses.push(transactionMeta.txParams.to);
+            }
+            this.refreshAddresses({
+                networkClientIds: [transactionMeta.networkClientId],
+                addresses,
+            }).catch(() => {
+                // Silently handle refresh errors
+            });
+        });
+        messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+    }
+    /**
+     * Whether the controller is active (keyring is unlocked and user is onboarded).
+     * When locked or not onboarded, balance updates should be skipped.
+     *
+     * @returns Whether the controller should perform balance updates.
+     */
+    get isActive() {
+        return !__classPrivateFieldGet(this, _AccountTrackerController_isLocked, "f") && __classPrivateFieldGet(this, _AccountTrackerController_isOnboarded, "f").call(this);
+    }
+    /**
+     * Refreshes the balances of the accounts using the networkClientId
+     *
+     * @param input - The input for the poll.
+     * @param input.networkClientIds - The network client IDs used to get balances.
+     * @param input.queryAllAccounts - Whether to query all accounts or just the selected account
+     */
+    async _executePoll({ networkClientIds, queryAllAccounts = false, }) {
+        if (__classPrivateFieldGet(this, _AccountTrackerController_isDeprecated, "f").call(this)) {
+            __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_enforceDisabledState).call(this);
+            return;
+        }
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        this.refresh(networkClientIds, queryAllAccounts);
+    }
+    /**
+     * Refreshes the balances of the accounts depending on the multi-account setting.
+     * If multi-account is disabled, only updates the selected account balance.
+     * If multi-account is enabled, updates balances for all accounts.
+     *
+     * @param networkClientIds - Optional network client IDs to fetch a network client with
+     * @param queryAllAccounts - Whether to query all accounts or just the selected account
+     */
+    async refresh(networkClientIds, queryAllAccounts = false) {
+        if (__classPrivateFieldGet(this, _AccountTrackerController_isDeprecated, "f").call(this)) {
+            __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_enforceDisabledState).call(this);
+            return;
+        }
+        const selectedAccount = this.messenger.call('AccountsController:getSelectedAccount');
+        const allAccounts = this.messenger.call('AccountsController:listAccounts');
+        const { isMultiAccountBalancesEnabled } = this.messenger.call('PreferencesController:getState');
+        await __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_refreshAccounts).call(this, {
+            networkClientIds,
+            queryAllAccounts: queryAllAccounts ?? isMultiAccountBalancesEnabled,
+            selectedAccount: (0, controller_utils_1.toChecksumHexAddress)(selectedAccount.address),
+            allAccounts,
+        });
+    }
+    async refreshAddresses({ networkClientIds, addresses, }) {
+        if (__classPrivateFieldGet(this, _AccountTrackerController_isDeprecated, "f").call(this)) {
+            __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_enforceDisabledState).call(this);
+            return;
+        }
+        const checksummedAddresses = addresses.map((address) => (0, controller_utils_1.toChecksumHexAddress)(address));
+        const accounts = this.messenger
+            .call('AccountsController:listAccounts')
+            .filter((account) => checksummedAddresses.includes((0, controller_utils_1.toChecksumHexAddress)(account.address)));
+        await __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_refreshAccounts).call(this, {
+            networkClientIds,
+            queryAllAccounts: true,
+            selectedAccount: '0x0',
+            allAccounts: accounts,
+        });
+    }
+    /**
+     * Sync accounts balances with some additional addresses.
+     *
+     * @param addresses - the additional addresses, may be hardware wallet addresses.
+     * @param networkClientId - Optional networkClientId to fetch a network client with.
+     * @returns accounts - addresses with synced balance
+     */
+    async syncBalanceWithAddresses(addresses, networkClientId) {
+        if (__classPrivateFieldGet(this, _AccountTrackerController_isDeprecated, "f").call(this)) {
+            __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_enforceDisabledState).call(this);
+            return {};
+        }
+        // Skip balance fetching if locked or not onboarded to avoid unnecessary RPC calls
+        if (!this.isActive) {
+            return {};
+        }
+        const { ethQuery, chainId } = __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_getCorrectNetworkClient).call(this, networkClientId);
+        // Skip native token fetching for chains that return arbitrary large numbers
+        if (!(0, constants_js_1.shouldIncludeNativeToken)(chainId)) {
+            // Return empty balances for chains that skip native token fetching
+            return addresses.reduce((acc, address) => {
+                acc[address] = { balance: '0x0' };
+                return acc;
+            }, {});
+        }
+        // TODO: This should use multicall when enabled by the user.
+        return await Promise.all(addresses.map((address) => {
+            return (0, controller_utils_1.safelyExecuteWithTimeout)(async () => {
+                (0, utils_1.assert)(ethQuery, 'Provider not set.');
+                const balance = await (0, controller_utils_1.query)(ethQuery, 'getBalance', [address]);
+                let stakedBalance;
+                if (__classPrivateFieldGet(this, _AccountTrackerController_includeStakedAssets, "f")) {
+                    stakedBalance = (await __classPrivateFieldGet(this, _AccountTrackerController_getStakedBalanceForChain, "f").call(this, [address], networkClientId))[address];
+                }
+                return [address, balance, stakedBalance];
+            });
+        })).then((value) => {
+            return value.reduce((obj, item) => {
+                if (!item) {
+                    return obj;
+                }
+                const [address, balance, stakedBalance] = item;
+                return {
+                    ...obj,
+                    [address]: {
+                        balance,
+                        stakedBalance,
+                    },
+                };
+            }, {});
+        });
+    }
+    /**
+     * Updates the balances of multiple native tokens in a single batch operation.
+     * This is more efficient than calling updateNativeToken multiple times as it
+     * triggers only one state update.
+     *
+     * @param balances - Array of balance updates, each containing address, chainId, and balance.
+     */
+    updateNativeBalances(balances) {
+        if (__classPrivateFieldGet(this, _AccountTrackerController_isDeprecated, "f").call(this)) {
+            __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_enforceDisabledState).call(this);
+            return;
+        }
+        const nextAccountsByChainId = (0, lodash_1.cloneDeep)(this.state.accountsByChainId);
+        let hasChanges = false;
+        balances.forEach(({ address, chainId, balance }) => {
+            const checksumAddress = (0, controller_utils_1.toChecksumHexAddress)(address);
+            // Ensure the chainId exists in the state
+            if (!nextAccountsByChainId[chainId]) {
+                nextAccountsByChainId[chainId] = {};
+                hasChanges = true;
+            }
+            // Check if the address exists for this chain
+            const accountExists = Boolean(nextAccountsByChainId[chainId][checksumAddress]);
+            // Ensure the address exists for this chain
+            if (!accountExists) {
+                nextAccountsByChainId[chainId][checksumAddress] = {
+                    balance: '0x0',
+                };
+                hasChanges = true;
+            }
+            // Only update the balance if it has changed, or if this is a new account
+            const currentBalance = nextAccountsByChainId[chainId][checksumAddress].balance;
+            if (!accountExists || currentBalance !== balance) {
+                nextAccountsByChainId[chainId][checksumAddress].balance = balance;
+                hasChanges = true;
+            }
+        });
+        // Only call update if there are actual changes
+        if (hasChanges) {
+            this.update((state) => {
+                state.accountsByChainId = nextAccountsByChainId;
+            });
+        }
+    }
+    /**
+     * Updates the staked balances of multiple accounts in a single batch operation.
+     * This is more efficient than updating staked balances individually as it
+     * triggers only one state update.
+     *
+     * @param stakedBalances - Array of staked balance updates, each containing address, chainId, and stakedBalance.
+     */
+    updateStakedBalances(stakedBalances) {
+        if (__classPrivateFieldGet(this, _AccountTrackerController_isDeprecated, "f").call(this)) {
+            __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_enforceDisabledState).call(this);
+            return;
+        }
+        const nextAccountsByChainId = (0, lodash_1.cloneDeep)(this.state.accountsByChainId);
+        let hasChanges = false;
+        stakedBalances.forEach(({ address, chainId, stakedBalance }) => {
+            const checksumAddress = (0, controller_utils_1.toChecksumHexAddress)(address);
+            // Ensure the chainId exists in the state
+            if (!nextAccountsByChainId[chainId]) {
+                nextAccountsByChainId[chainId] = {};
+                hasChanges = true;
+            }
+            // Check if the address exists for this chain
+            const accountExists = Boolean(nextAccountsByChainId[chainId][checksumAddress]);
+            // Ensure the address exists for this chain
+            if (!accountExists) {
+                nextAccountsByChainId[chainId][checksumAddress] = {
+                    balance: '0x0',
+                };
+                hasChanges = true;
+            }
+            // Only update the staked balance if it has changed, or if this is a new account
+            const currentStakedBalance = nextAccountsByChainId[chainId][checksumAddress].stakedBalance;
+            if (!accountExists || !(0, lodash_1.isEqual)(currentStakedBalance, stakedBalance)) {
+                nextAccountsByChainId[chainId][checksumAddress].stakedBalance =
+                    stakedBalance;
+                hasChanges = true;
+            }
+        });
+        // Only call update if there are actual changes
+        if (hasChanges) {
+            this.update((state) => {
+                state.accountsByChainId = nextAccountsByChainId;
+            });
+        }
+    }
+}
+exports.AccountTrackerController = AccountTrackerController;
+_AccountTrackerController_refreshMutex = new WeakMap(), _AccountTrackerController_includeStakedAssets = new WeakMap(), _AccountTrackerController_accountsApiChainIds = new WeakMap(), _AccountTrackerController_getStakedBalanceForChain = new WeakMap(), _AccountTrackerController_balanceFetchers = new WeakMap(), _AccountTrackerController_fetchingEnabled = new WeakMap(), _AccountTrackerController_isOnboarded = new WeakMap(), _AccountTrackerController_isHomepageSectionsV1Enabled = new WeakMap(), _AccountTrackerController_isDeprecated = new WeakMap(), _AccountTrackerController_isLocked = new WeakMap(), _AccountTrackerController_getProvider = new WeakMap(), _AccountTrackerController_getNetworkClient = new WeakMap(), _AccountTrackerController_createAccountsApiFetcher = new WeakMap(), _AccountTrackerController_instances = new WeakSet(), _AccountTrackerController_enforceDisabledState = function _AccountTrackerController_enforceDisabledState() {
+    if (Object.keys(this.state.accountsByChainId).length === 0) {
+        return;
+    }
+    this.update((state) => {
+        state.accountsByChainId = {};
+    });
+}, _AccountTrackerController_syncAccounts = function _AccountTrackerController_syncAccounts(newChainIds) {
+    const accountsByChainId = (0, lodash_1.cloneDeep)(this.state.accountsByChainId);
+    const { selectedNetworkClientId } = this.messenger.call('NetworkController:getState');
+    const { configuration: { chainId: currentChainId }, } = this.messenger.call('NetworkController:getNetworkClientById', selectedNetworkClientId);
+    const existing = Object.keys(accountsByChainId?.[currentChainId] ?? {});
+    // Initialize new chain IDs if they don't exist
+    newChainIds.forEach((newChainId) => {
+        if (!accountsByChainId[newChainId]) {
+            accountsByChainId[newChainId] = {};
+            existing.forEach((address) => {
+                accountsByChainId[newChainId][address] = { balance: '0x0' };
+            });
+        }
+    });
+    // Note: The address from the preferences controller are checksummed
+    // The addresses from the accounts controller are lowercased
+    const addresses = Object.values(this.messenger
+        .call('AccountsController:listAccounts')
+        .map((internalAccount) => (0, controller_utils_1.toChecksumHexAddress)(internalAccount.address)));
+    const newAddresses = addresses.filter((address) => !existing.includes(address));
+    const oldAddresses = existing.filter((address) => !addresses.includes(address));
+    Object.keys(accountsByChainId).forEach((chainId) => {
+        newAddresses.forEach((address) => {
+            if (!accountsByChainId[chainId][address]) {
+                accountsByChainId[chainId][address] = {
+                    balance: '0x0',
+                };
+            }
+        });
+    });
+    Object.keys(accountsByChainId).forEach((chainId) => {
+        oldAddresses.forEach((address) => {
+            delete accountsByChainId[chainId][address];
+        });
+    });
+    if (!(0, lodash_1.isEqual)(this.state.accountsByChainId, accountsByChainId)) {
+        this.update((state) => {
+            state.accountsByChainId = accountsByChainId;
+        });
+    }
+}, _AccountTrackerController_getCorrectNetworkClient = function _AccountTrackerController_getCorrectNetworkClient(networkClientId) {
+    const selectedNetworkClientId = networkClientId ??
+        this.messenger.call('NetworkController:getState').selectedNetworkClientId;
+    const { configuration: { chainId }, provider, blockTracker, } = this.messenger.call('NetworkController:getNetworkClientById', selectedNetworkClientId);
+    return {
+        chainId,
+        provider,
+        ethQuery: new eth_query_1.default(provider),
+        blockTracker,
+    };
+}, _AccountTrackerController_getNetworkClientIds = function _AccountTrackerController_getNetworkClientIds() {
+    const { networkConfigurationsByChainId } = this.messenger.call('NetworkController:getState');
+    if (__classPrivateFieldGet(this, _AccountTrackerController_isHomepageSectionsV1Enabled, "f").call(this)) {
+        const popularEvmChainIds = this.messenger.call('NetworkEnablementController:listPopularEvmNetworks');
+        return popularEvmChainIds
+            .map((hexChainId) => {
+            const networkConfig = networkConfigurationsByChainId[hexChainId];
+            return networkConfig?.rpcEndpoints[networkConfig.defaultRpcEndpointIndex]?.networkClientId;
+        })
+            .filter((id) => id !== undefined);
+    }
+    const { enabledNetworkMap } = this.messenger.call('NetworkEnablementController:getState');
+    const evmEnabledStorageKeys = enabledNetworkMap[utils_1.KnownCaipNamespace.Eip155]
+        ? Object.keys(enabledNetworkMap[utils_1.KnownCaipNamespace.Eip155])
+        : [];
+    return evmEnabledStorageKeys
+        .map((hexChainId) => {
+        const networkConfig = networkConfigurationsByChainId[hexChainId];
+        return networkConfig?.rpcEndpoints[networkConfig.defaultRpcEndpointIndex]?.networkClientId;
+    })
+        .filter((id) => id !== undefined);
+}, _AccountTrackerController_refreshAccounts = async function _AccountTrackerController_refreshAccounts({ networkClientIds, queryAllAccounts, selectedAccount, allAccounts, }) {
+    const releaseLock = await __classPrivateFieldGet(this, _AccountTrackerController_refreshMutex, "f").acquire();
+    try {
+        const chainIds = networkClientIds.map((networkClientId) => {
+            const { chainId } = __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_getCorrectNetworkClient).call(this, networkClientId);
+            return chainId;
+        });
+        __classPrivateFieldGet(this, _AccountTrackerController_instances, "m", _AccountTrackerController_syncAccounts).call(this, chainIds);
+        if (!__classPrivateFieldGet(this, _AccountTrackerController_fetchingEnabled, "f").call(this) || !this.isActive) {
+            return;
+        }
+        // Use balance fetchers with fallback strategy
+        const aggregated = [];
+        let remainingChains = [...chainIds];
+        // Temporary normalization to lowercase for balance fetching to match TokenBalancesController and enable HTTP caching
+        const lowerCaseSelectedAccount = selectedAccount.toLowerCase();
+        const lowerCaseAllAccounts = allAccounts.map((account) => ({
+            ...account,
+            address: account.address.toLowerCase(),
+        }));
+        // Try each fetcher in order, removing successfully processed chains
+        for (const fetcher of __classPrivateFieldGet(this, _AccountTrackerController_balanceFetchers, "f")) {
+            const supportedChains = remainingChains.filter((chainId) => fetcher.supports(chainId));
+            if (!supportedChains.length) {
+                continue;
+            }
+            try {
+                const result = await fetcher.fetch({
+                    chainIds: supportedChains,
+                    queryAllAccounts,
+                    selectedAccount: lowerCaseSelectedAccount,
+                    allAccounts: lowerCaseAllAccounts,
+                });
+                if (result.balances && result.balances.length > 0) {
+                    aggregated.push(...result.balances);
+                    // Remove chains that were successfully processed
+                    const processedChains = new Set(result.balances.map((b) => b.chainId));
+                    remainingChains = remainingChains.filter((chain) => !processedChains.has(chain));
+                }
+                // Add unprocessed chains back to remainingChains for next fetcher
+                if (result.unprocessedChainIds &&
+                    result.unprocessedChainIds.length > 0) {
+                    // Only add chains that were originally requested and aren't already in remainingChains
+                    const currentRemainingChains = remainingChains;
+                    const chainsToAdd = result.unprocessedChainIds.filter((chainId) => supportedChains.includes(chainId) &&
+                        !currentRemainingChains.includes(chainId));
+                    remainingChains.push(...chainsToAdd);
+                }
+            }
+            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;
+        // Process the aggregated balance results
+        const stakedBalancesByChainAndAddress = {};
+        aggregated.forEach(({ success, value, account, token, chainId }) => {
+            if (success && value !== undefined) {
+                const checksumAddress = (0, controller_utils_1.toChecksumHexAddress)(account);
+                const hexValue = `0x${value.toString(16)}`;
+                if (token === ZERO_ADDRESS) {
+                    // Native balance
+                    // Ensure the account entry exists before accessing it
+                    if (!nextAccountsByChainId[chainId]) {
+                        nextAccountsByChainId[chainId] = {};
+                    }
+                    if (!nextAccountsByChainId[chainId][checksumAddress]) {
+                        nextAccountsByChainId[chainId][checksumAddress] = {
+                            balance: '0x0',
+                        };
+                    }
+                    if (nextAccountsByChainId[chainId][checksumAddress].balance !==
+                        hexValue) {
+                        nextAccountsByChainId[chainId][checksumAddress].balance =
+                            hexValue;
+                        hasChanges = true;
+                    }
+                }
+                else if (AssetsContractController_js_1.STAKING_CONTRACT_ADDRESS_BY_CHAINID[chainId]?.toLowerCase() ===
+                    token.toLowerCase()) {
+                    // Staked balance (from staking contract address)
+                    if (!stakedBalancesByChainAndAddress[chainId]) {
+                        stakedBalancesByChainAndAddress[chainId] = {};
+                    }
+                    stakedBalancesByChainAndAddress[chainId][checksumAddress] =
+                        hexValue;
+                }
+            }
+        });
+        // Apply staked balances
+        Object.entries(stakedBalancesByChainAndAddress).forEach(([chainId, balancesByAddress]) => {
+            Object.entries(balancesByAddress).forEach(([address, stakedBalance]) => {
+                // Ensure account structure exists
+                if (!nextAccountsByChainId[chainId]) {
+                    nextAccountsByChainId[chainId] = {};
+                }
+                if (!nextAccountsByChainId[chainId][address]) {
+                    nextAccountsByChainId[chainId][address] = { balance: '0x0' };
+                }
+                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;
+            });
+        }
+    }
+    finally {
+        releaseLock();
+    }
+};
+exports.default = AccountTrackerController;
+//# sourceMappingURL=AccountTrackerController.cjs.map