@metamask-previews/assets-controller 14.0.2-preview-4f4c98e → 14.0.2-preview-eb263b0ee

package/dist/AssetsController.cjs

@@ -0,0 +1,2559 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _AssetsController_instances, _AssetsController_isEnabled, _AssetsController_isBasicFunctionality, _AssetsController_defaultUpdateInterval, _AssetsController_trace, _AssetsController_captureException, _AssetsController_firstInitFetchReported, _AssetsController_stateSizeReported, _AssetsController_emitStateSizeTrace, _AssetsController_uiOpen, _AssetsController_keyringUnlocked, _AssetsController_accountTreeInitialized, _AssetsController_controllerMutex, _AssetsController_accountRefreshMutex, _AssetsController_activeSubscriptions, _AssetsController_enabledChains, _AssetsController_lastKnownAccountIds, _AssetsController_getSelectedAccounts, _AssetsController_accountActivityDataSource, _AssetsController_accountsApiDataSource, _AssetsController_snapDataSource, _AssetsController_rpcDataSource, _AssetsController_stakedBalanceDataSource, _AssetsController_allBalanceDataSources_get, _AssetsController_priceDataSource, _AssetsController_detectionMiddleware, _AssetsController_customAssetGraduationMiddleware, _AssetsController_rpcFallbackMiddleware, _AssetsController_tokenDataSource, _AssetsController_unsubscribeBasicFunctionality, _AssetsController_queryApiClient, _AssetsController_onActiveChainsUpdated, _AssetsController_initializeNativeAssetsMap, _AssetsController_initializeState, _AssetsController_extractEnabledChains, _AssetsController_normalizeChainReference, _AssetsController_subscribeToEvents, _AssetsController_onUnapprovedTransactionAdded, _AssetsController_onTransactionConfirmed, _AssetsController_updateActive, _AssetsController_handleAccountTreeStateChange, _AssetsController_runAccountTreeRefresh, _AssetsController_runStartupRefresh, _AssetsController_registerActionHandlers, _AssetsController_handleActiveChainsUpdate, _AssetsController_executeMiddlewares, _AssetsController_assertNonEmptyAccountId, _AssetsController_normalizeAssetIdOrThrow, _AssetsController_fetchMissingPricesWithoutCache, _AssetsController_getNativeAssetMap, _AssetsController_isNativeAsset, _AssetsController_getAssetType, _AssetsController_resolveNativeAssetIds, _AssetsController_getNativeAssetIdsForEnabledChains, _AssetsController_getNativeAssetIdsForAccount, _AssetsController_getSlowPipelineChainIds, _AssetsController_ensureNativeBalancesDefaultZero, _AssetsController_ensureDefaultTrackedAssetsSeeded, _AssetsController_updateState, _AssetsController_getAssetsFromState, _AssetsController_getAssetFromState, _AssetsController_shouldHideNativeToken, _AssetsController_tokenStandardToAssetType, _AssetsController_start, _AssetsController_stop, _AssetsController_subscribeAssets, _AssetsController_subscribeAssetsBalance, _AssetsController_subscribeRpcCustomAssetsSupplement, _AssetsController_unsubscribeBySubscriptionKey, _AssetsController_subscribeStakedBalance, _AssetsController_buildChainToAccountsMap, _AssetsController_subscribeDataSource, _AssetsController_unsubscribeDataSource, _AssetsController_buildDataRequest, _AssetsController_getEnabledChainsForAccount, _AssetsController_handleAccountGroupChanged, _AssetsController_handleEnabledNetworksChanged, _AssetsController_handleNetworkAdded, _AssetsController_refreshActiveChainsOnNetworkSwitch, _AssetsController_getSelectedEvmChainIdFromNetworkState, _AssetsController_handleNetworkDidChange, _AssetsController_refreshAssetsAfterNetworkChange, _AssetsController_refreshAssetsAfterNetworkAdded;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetsController = exports.getDefaultAssetsControllerState = void 0;
+const base_controller_1 = require("@metamask/base-controller");
+const client_controller_1 = require("@metamask/client-controller");
+const utils_1 = require("@metamask/utils");
+const async_mutex_1 = require("async-mutex");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const lodash_1 = require("lodash");
+const AccountActivityDataSource_js_1 = require("./data-sources/AccountActivityDataSource.cjs");
+const AccountsApiDataSource_js_1 = require("./data-sources/AccountsApiDataSource.cjs");
+const index_js_1 = require("./data-sources/evm-rpc-services/index.cjs");
+const assets_js_1 = require("./data-sources/evm-rpc-services/utils/assets.cjs");
+const PriceDataSource_js_1 = require("./data-sources/PriceDataSource.cjs");
+const RpcDataSource_js_1 = require("./data-sources/RpcDataSource.cjs");
+const SnapDataSource_js_1 = require("./data-sources/SnapDataSource.cjs");
+const StakedBalanceDataSource_js_1 = require("./data-sources/StakedBalanceDataSource.cjs");
+const TokenDataSource_js_1 = require("./data-sources/TokenDataSource.cjs");
+const defaults_js_1 = require("./defaults.cjs");
+const errors_js_1 = require("./errors.cjs");
+const logger_js_1 = require("./logger.cjs");
+const CustomAssetGraduationMiddleware_js_1 = require("./middlewares/CustomAssetGraduationMiddleware.cjs");
+const DetectionMiddleware_js_1 = require("./middlewares/DetectionMiddleware.cjs");
+const ParallelMiddleware_js_1 = require("./middlewares/ParallelMiddleware.cjs");
+const RpcFallbackMiddleware_js_1 = require("./middlewares/RpcFallbackMiddleware.cjs");
+const healAssetsInfoMetadata_js_1 = require("./migrations/healAssetsInfoMetadata.cjs");
+const constants_js_1 = require("./utils/constants.cjs");
+const customAssetsRpcSupplement_js_1 = require("./utils/customAssetsRpcSupplement.cjs");
+const index_js_2 = require("./utils/index.cjs");
+const trace_js_1 = require("./utils/trace.cjs");
+const NATIVE_ASSETS_QUERY_KEY = ['nativeAssets'];
+/** Stable empty map so memoized formatters are not busted by `?? {}` identity churn. */
+const EMPTY_NATIVE_ASSET_MAP = {};
+// ============================================================================
+// CONTROLLER CONSTANTS
+// ============================================================================
+const CONTROLLER_NAME = 'AssetsController';
+/** Method names exposed as messenger actions (AssetsController:getAssets, etc.) */
+const MESSENGER_EXPOSED_METHODS = [
+    'getAssets',
+    'getAssetsBalance',
+    'getAssetMetadata',
+    'getAccountAssetByID',
+    'getAccountAssetsByIDs',
+    'getAccountAssetsByScope',
+    'getAssetsPrice',
+    'getExchangeRatesForBridge',
+    'getStateForTransactionPay',
+    'addCustomAsset',
+    'removeCustomAsset',
+    'getCustomAssets',
+    'hideAsset',
+    'unhideAsset',
+    'setSelectedCurrency',
+];
+/** Default polling interval hint for data sources (30 seconds) */
+const DEFAULT_POLLING_INTERVAL_MS = 30000;
+// ============================================================================
+// TRACE NAMES — used in Sentry spans (search these strings in Discover)
+// ============================================================================
+const TRACE_FIRST_INIT_FETCH = 'AssetsControllerFirstInitFetch';
+const TRACE_FULL_FETCH = 'AssetsFullFetch';
+/** Parent span that nests per-source timings; dashboard charts {@link TRACE_FULL_FETCH}. */
+const TRACE_FETCH_PIPELINE = 'AssetsFetchPipeline';
+const TRACE_BACKGROUND_FETCH = 'AssetsBackgroundFetch';
+const TRACE_DATA_SOURCE_TIMING = 'AssetsDataSourceTiming';
+const TRACE_DATA_SOURCE_ERROR = 'AssetsDataSourceError';
+const TRACE_UPDATE_PIPELINE = 'AssetsUpdatePipeline';
+/** Parent span that nests update enrichment; dashboard charts {@link TRACE_UPDATE_PIPELINE}. */
+const TRACE_UPDATE_PARENT = 'AssetsUpdateEnrichment';
+const TRACE_SUBSCRIPTION_ERROR = 'AssetsSubscriptionError';
+const TRACE_STATE_SIZE = 'AssetsStateSize';
+const log = (0, logger_js_1.createModuleLogger)(logger_js_1.projectLogger, CONTROLLER_NAME);
+/**
+ * Returns the default state for AssetsController.
+ *
+ * @returns The default AssetsController state. Balance, price, and custom
+ * asset maps start empty; `assetsInfo` is pre-seeded for default tracked
+ * assets (see {@link buildDefaultAssetsInfo}).
+ */
+function getDefaultAssetsControllerState() {
+    return {
+        // Pre-populate metadata for controller-managed default tracked assets
+        // (e.g. mUSD on Ethereum mainnet, Linea, Monad) so they are
+        // immediately renderable in the UI before any RPC poll completes.
+        // Per-account zero-balance entries are filled into `assetsBalance`
+        // by `#ensureDefaultTrackedAssetsSeeded` once accounts are known.
+        assetsInfo: (0, defaults_js_1.buildDefaultAssetsInfo)(),
+        assetsBalance: {},
+        assetsPrice: {},
+        customAssets: {},
+        assetPreferences: {},
+        selectedCurrency: 'usd',
+    };
+}
+exports.getDefaultAssetsControllerState = getDefaultAssetsControllerState;
+// ============================================================================
+// STATE METADATA
+// ============================================================================
+const stateMetadata = {
+    assetsInfo: {
+        persist: true,
+        includeInStateLogs: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    assetsBalance: {
+        persist: true,
+        includeInStateLogs: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    assetsPrice: {
+        persist: true,
+        includeInStateLogs: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    customAssets: {
+        persist: true,
+        includeInStateLogs: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    assetPreferences: {
+        persist: true,
+        includeInStateLogs: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    selectedCurrency: {
+        persist: true,
+        includeInStateLogs: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+function extractChainId(assetId) {
+    const parsed = (0, utils_1.parseCaipAssetType)(assetId);
+    return parsed.chainId;
+}
+/**
+ * Normalizes all asset IDs in a DataResponse.
+ * This is applied at the controller level to ensure consistent state
+ * regardless of how data sources format their asset IDs.
+ *
+ * @param response - The DataResponse to normalize.
+ * @returns The normalized DataResponse with checksummed EVM addresses.
+ */
+function normalizeResponse(response) {
+    const normalized = {};
+    if (response.assetsInfo) {
+        normalized.assetsInfo = {};
+        for (const [assetId, metadata] of Object.entries(response.assetsInfo)) {
+            const normalizedId = (0, index_js_2.normalizeAssetId)(assetId);
+            normalized.assetsInfo[normalizedId] = metadata;
+        }
+    }
+    if (response.assetsPrice) {
+        normalized.assetsPrice = {};
+        for (const [assetId, price] of Object.entries(response.assetsPrice)) {
+            const normalizedId = (0, index_js_2.normalizeAssetId)(assetId);
+            normalized.assetsPrice[normalizedId] = price;
+        }
+    }
+    if (response.assetsBalance) {
+        normalized.assetsBalance = {};
+        for (const [accountId, balances] of Object.entries(response.assetsBalance)) {
+            normalized.assetsBalance[accountId] = {};
+            for (const [assetId, balance] of Object.entries(balances)) {
+                const normalizedId = (0, index_js_2.normalizeAssetId)(assetId);
+                normalized.assetsBalance[accountId][normalizedId] = balance;
+            }
+        }
+    }
+    // Preserve detectedAssets with normalized asset IDs
+    if (response.detectedAssets) {
+        normalized.detectedAssets = {};
+        for (const [accountId, assetIds] of Object.entries(response.detectedAssets)) {
+            normalized.detectedAssets[accountId] = assetIds.map((assetId) => (0, index_js_2.normalizeAssetId)(assetId));
+        }
+    }
+    // Preserve errors (chain IDs don't need normalization)
+    if (response.errors) {
+        normalized.errors = { ...response.errors };
+    }
+    if (response.updateMode) {
+        normalized.updateMode = response.updateMode;
+    }
+    if (response.replaceCoveredChainBalances) {
+        normalized.replaceCoveredChainBalances = true;
+    }
+    return normalized;
+}
+/**
+ * Merge account balances from a data-source response into prior state.
+ *
+ * @param previousBalances - Balances already in state for this account.
+ * @param accountBalances - Balances from the incoming response.
+ * @param customAssetIds - Custom assets to preserve when replacing covered chains.
+ * @param replaceCoveredChains - When true, drop prior balances on chains present
+ *   in the response before applying it (authoritative chain slice).
+ * @returns The merged balance map for the account.
+ */
+function mergeAccountBalances(previousBalances, accountBalances, customAssetIds, replaceCoveredChains) {
+    if (!replaceCoveredChains) {
+        return { ...previousBalances, ...accountBalances };
+    }
+    const coveredChains = new Set(Object.keys(accountBalances).map((assetId) => assetId.split('/')[0]));
+    const next = {};
+    for (const [assetId, balance] of Object.entries(previousBalances)) {
+        if (!coveredChains.has(assetId.split('/')[0])) {
+            next[assetId] = balance;
+        }
+    }
+    Object.assign(next, accountBalances);
+    for (const customId of customAssetIds) {
+        if (!Object.prototype.hasOwnProperty.call(next, customId)) {
+            const prev = previousBalances[customId];
+            next[customId] = prev ?? { amount: '0' };
+        }
+    }
+    // Staked vault balances are owned by StakedBalanceDataSource. When an
+    // Accounts API (or other) chain-slice replace omits them, keep the prior
+    // on-chain staked amount instead of clearing it to missing/0.
+    for (const [assetId, balance] of Object.entries(previousBalances)) {
+        if ((0, index_js_1.isStakingContractAssetId)(assetId) &&
+            !Object.prototype.hasOwnProperty.call(next, assetId)) {
+            next[assetId] = balance;
+        }
+    }
+    return next;
+}
+// ============================================================================
+// CONTROLLER IMPLEMENTATION
+// ============================================================================
+/**
+ * AssetsController provides a unified interface for managing asset balances
+ * across all blockchain networks (EVM and non-EVM) and all asset types.
+ *
+ * ## Core Responsibilities
+ *
+ * 1. **One-Time Fetch (Sync)**: For initial load, force refresh, or on-demand queries.
+ *    Uses `getAssets()`, `getAssetsBalance()`, etc. with `forceUpdate: true`.
+ *
+ * 2. **Async Subscriptions**: Subscribes to data sources for ongoing updates.
+ *    Data sources push updates via callbacks; the controller updates state.
+ *
+ * 3. **Dynamic Source Selection**: Routes requests to appropriate data sources
+ *    based on which chains they support. When active chains change, the controller
+ *    dynamically adjusts subscriptions.
+ *
+ * 4. **Client + Keyring Lifecycle**: Starts subscriptions only when both the UI is
+ *    open (ClientController) and the wallet is unlocked (KeyringController).
+ *    Stops when either the UI closes or the keyring locks. See client-controller
+ *    README for the combined pattern.
+ *
+ * ## Architecture
+ *
+ * - Data sources declare their supported chains (async, can change over time)
+ * - Data sources are responsible for their own update mechanisms (WebSocket, polling, events)
+ * - The controller does NOT manage polling - it simply receives pushed updates
+ */
+class AssetsController extends base_controller_1.BaseController {
+    constructor({ messenger, state = {}, defaultUpdateInterval = DEFAULT_POLLING_INTERVAL_MS, isEnabled = () => true, isBasicFunctionality, subscribeToBasicFunctionalityChange, queryApiClient, rpcDataSourceConfig, trace, captureException, accountsApiDataSourceConfig, priceDataSourceConfig, stakedBalanceDataSourceConfig, isOnboarded, tempMigrateAssetsInfoMetadataAssets3346, }) {
+        super({
+            name: CONTROLLER_NAME,
+            messenger,
+            metadata: stateMetadata,
+            state: {
+                ...getDefaultAssetsControllerState(),
+                ...state,
+            },
+        });
+        _AssetsController_instances.add(this);
+        /** Whether the controller is enabled */
+        _AssetsController_isEnabled.set(this, void 0);
+        /** Getter for basic functionality (only balance fetch/subscribe use RPC; token/price API not used). No attribute stored. */
+        _AssetsController_isBasicFunctionality.set(this, void 0);
+        /** Default update interval hint passed to data sources */
+        _AssetsController_defaultUpdateInterval.set(this, void 0);
+        /** Optional trace callback for first init/fetch measurement (duration). */
+        _AssetsController_trace.set(this, void 0);
+        /** Optional reporter for Issue-style errors (e.g. Sentry.captureException). */
+        _AssetsController_captureException.set(this, void 0);
+        /** Whether we have already reported first init fetch for this session (reset on #stop). */
+        _AssetsController_firstInitFetchReported.set(this, false);
+        /** Whether we have already reported state size for this session (reset on #stop). */
+        _AssetsController_stateSizeReported.set(this, false);
+        /** Whether the client (UI) is open. Combined with #keyringUnlocked for #updateActive. */
+        _AssetsController_uiOpen.set(this, false);
+        /** Whether the keyring is unlocked. Combined with #uiOpen for #updateActive. */
+        _AssetsController_keyringUnlocked.set(this, false);
+        /**
+         * Whether `AccountTreeController` has finished `init()`. Unlock / UI-open
+         * alone must not start fetches — the tree can still be mid-build.
+         */
+        _AssetsController_accountTreeInitialized.set(this, false);
+        _AssetsController_controllerMutex.set(this, new async_mutex_1.Mutex());
+        /** Serializes account-switch fetch + subscribe to prevent overlapping races. */
+        _AssetsController_accountRefreshMutex.set(this, new async_mutex_1.Mutex());
+        /**
+         * Active balance subscriptions keyed by account ID.
+         * Each account has one logical subscription that may span multiple data sources.
+         * For example, if WebSocket covers chains A,B and RPC covers chain C,
+         * the account subscribes to both data sources for its chains.
+         */
+        _AssetsController_activeSubscriptions.set(this, new Map());
+        /** Currently enabled chains from NetworkEnablementController */
+        _AssetsController_enabledChains.set(this, new Set());
+        /**
+         * Snapshot of account IDs that were active when the last subscription/fetch
+         * cycle ran. Used by #handleAccountTreeStateChange to skip redundant
+         * re-subscriptions when the account set hasn't actually changed.
+         */
+        _AssetsController_lastKnownAccountIds.set(this, new Set());
+        _AssetsController_accountActivityDataSource.set(this, void 0);
+        _AssetsController_accountsApiDataSource.set(this, void 0);
+        _AssetsController_snapDataSource.set(this, void 0);
+        _AssetsController_rpcDataSource.set(this, void 0);
+        _AssetsController_stakedBalanceDataSource.set(this, void 0);
+        _AssetsController_priceDataSource.set(this, void 0);
+        _AssetsController_detectionMiddleware.set(this, void 0);
+        _AssetsController_customAssetGraduationMiddleware.set(this, void 0);
+        _AssetsController_rpcFallbackMiddleware.set(this, void 0);
+        _AssetsController_tokenDataSource.set(this, void 0);
+        _AssetsController_unsubscribeBasicFunctionality.set(this, null);
+        _AssetsController_queryApiClient.set(this, void 0);
+        _AssetsController_onActiveChainsUpdated.set(this, void 0);
+        __classPrivateFieldSet(this, _AssetsController_isEnabled, isEnabled, "f");
+        __classPrivateFieldSet(this, _AssetsController_isBasicFunctionality, isBasicFunctionality ?? (() => true), "f");
+        __classPrivateFieldSet(this, _AssetsController_defaultUpdateInterval, defaultUpdateInterval, "f");
+        __classPrivateFieldSet(this, _AssetsController_trace, trace, "f");
+        __classPrivateFieldSet(this, _AssetsController_captureException, captureException, "f");
+        __classPrivateFieldSet(this, _AssetsController_queryApiClient, queryApiClient, "f");
+        const rpcConfig = rpcDataSourceConfig ?? {};
+        // TEMPORARY: heal assetsInfo metadata wiped by a prior defect
+        // (see extension migration #215 / ASSETS-3346). Remove in a future release.
+        if (tempMigrateAssetsInfoMetadataAssets3346) {
+            this.update(() => (0, healAssetsInfoMetadata_js_1.tempHealAssetsInfoMetadata)({
+                state: this.state,
+                getMigrationState: tempMigrateAssetsInfoMetadataAssets3346,
+                captureException,
+            }));
+        }
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_initializeNativeAssetsMap).call(this, queryApiClient);
+        __classPrivateFieldSet(this, _AssetsController_onActiveChainsUpdated, (dataSourceName, chains, previousChains) => {
+            try {
+                __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_handleActiveChainsUpdate).call(this, dataSourceName, chains, previousChains);
+            }
+            catch (error) {
+                log('Failed to handle active chains update', {
+                    dataSourceName,
+                    error,
+                });
+            }
+        }, "f");
+        __classPrivateFieldSet(this, _AssetsController_accountActivityDataSource, new AccountActivityDataSource_js_1.AccountActivityDataSource({
+            messenger: this.messenger,
+            onActiveChainsUpdated: __classPrivateFieldGet(this, _AssetsController_onActiveChainsUpdated, "f"),
+            getAssetType: (assetId) => __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getAssetType).call(this, assetId),
+            onAssetsUpdate: (response, request) => this.handleAssetsUpdate(response, __classPrivateFieldGet(this, _AssetsController_accountActivityDataSource, "f").getName(), request),
+        }), "f");
+        __classPrivateFieldSet(this, _AssetsController_accountsApiDataSource, new AccountsApiDataSource_js_1.AccountsApiDataSource({
+            messenger: this.messenger,
+            queryApiClient,
+            onActiveChainsUpdated: __classPrivateFieldGet(this, _AssetsController_onActiveChainsUpdated, "f"),
+            ...accountsApiDataSourceConfig,
+        }), "f");
+        __classPrivateFieldSet(this, _AssetsController_snapDataSource, new SnapDataSource_js_1.SnapDataSource({
+            messenger: this.messenger,
+            onActiveChainsUpdated: __classPrivateFieldGet(this, _AssetsController_onActiveChainsUpdated, "f"),
+            onAssetsUpdate: (response) => this.handleAssetsUpdate(response, 'SnapDataSource'),
+        }), "f");
+        __classPrivateFieldSet(this, _AssetsController_rpcDataSource, new RpcDataSource_js_1.RpcDataSource({
+            messenger: this.messenger,
+            onActiveChainsUpdated: __classPrivateFieldGet(this, _AssetsController_onActiveChainsUpdated, "f"),
+            getNativeAssetForChain: (chainId) => __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getNativeAssetMap).call(this)[chainId] ??
+                `${chainId}/erc20:${constants_js_1.ZERO_ADDRESS}`,
+            // Share the API platform's TanStack Query client so the RPC token
+            // detector caches/dedupes its top-token-list fetches alongside the rest
+            // of the package's API calls. Caller-provided rpcConfig.queryClient
+            // wins via the spread below.
+            queryClient: queryApiClient.queryClient,
+            ...rpcConfig,
+            isOnboarded: rpcConfig.isOnboarded ?? isOnboarded,
+            getAssetType: (assetId) => __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getAssetType).call(this, assetId),
+        }), "f");
+        __classPrivateFieldSet(this, _AssetsController_stakedBalanceDataSource, new StakedBalanceDataSource_js_1.StakedBalanceDataSource({
+            messenger: this.messenger,
+            onActiveChainsUpdated: __classPrivateFieldGet(this, _AssetsController_onActiveChainsUpdated, "f"),
+            ...stakedBalanceDataSourceConfig,
+        }), "f");
+        __classPrivateFieldSet(this, _AssetsController_tokenDataSource, new TokenDataSource_js_1.TokenDataSource(this.messenger, {
+            queryApiClient,
+            getNativeAssetIds: () => {
+                return __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getNativeAssetIdsForEnabledChains).call(this);
+            },
+            getAssetType: (assetId) => __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getAssetType).call(this, assetId),
+        }), "f");
+        __classPrivateFieldSet(this, _AssetsController_priceDataSource, new PriceDataSource_js_1.PriceDataSource({
+            queryApiClient,
+            getSelectedCurrency: () => this.state.selectedCurrency,
+            ...priceDataSourceConfig,
+        }), "f");
+        __classPrivateFieldSet(this, _AssetsController_detectionMiddleware, new DetectionMiddleware_js_1.DetectionMiddleware(), "f");
+        __classPrivateFieldSet(this, _AssetsController_customAssetGraduationMiddleware, new CustomAssetGraduationMiddleware_js_1.CustomAssetGraduationMiddleware({
+            getSelectedAccountId: () => {
+                try {
+                    return __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this)[0]?.id;
+                }
+                catch {
+                    return undefined;
+                }
+            },
+            removeCustomAsset: (accountId, assetId) => this.removeCustomAsset(accountId, assetId),
+        }), "f");
+        __classPrivateFieldSet(this, _AssetsController_rpcFallbackMiddleware, new RpcFallbackMiddleware_js_1.RpcFallbackMiddleware({
+            rpcDataSource: __classPrivateFieldGet(this, _AssetsController_rpcDataSource, "f"),
+        }), "f");
+        log('Initializing AssetsController', {
+            defaultUpdateInterval: __classPrivateFieldGet(this, _AssetsController_defaultUpdateInterval, "f"),
+        });
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_initializeState).call(this);
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeToEvents).call(this);
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_registerActionHandlers).call(this);
+        // Subscriptions start only when both UI is open and keyring unlocked -> #updateActive().
+        // Subscribe to basic-functionality changes after construction so a synchronous
+        // onChange during subscribe cannot run before data sources are initialized.
+        if (subscribeToBasicFunctionalityChange) {
+            const unsubscribe = subscribeToBasicFunctionalityChange((isBasic) => this.handleBasicFunctionalityChange(isBasic));
+            if (typeof unsubscribe === 'function') {
+                __classPrivateFieldSet(this, _AssetsController_unsubscribeBasicFunctionality, unsubscribe, "f");
+            }
+        }
+    }
+    /**
+     * Returns the callback passed to data sources for reporting active chain updates.
+     * Used by tests to simulate a data source reporting chain changes.
+     *
+     * @returns The onActiveChainsUpdated callback.
+     */
+    getOnActiveChainsUpdated() {
+        return __classPrivateFieldGet(this, _AssetsController_onActiveChainsUpdated, "f");
+    }
+    // ============================================================================
+    // PUBLIC API: QUERY METHODS
+    // ============================================================================
+    async getAssets(accounts, options) {
+        const chainIds = options?.chainIds ?? [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")];
+        const assetTypes = options?.assetTypes ?? ['fungible'];
+        const dataTypes = options?.dataTypes ?? ['balance', 'metadata', 'price'];
+        if (accounts.length === 0 || chainIds.length === 0) {
+            return __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getAssetsFromState).call(this, accounts, chainIds, assetTypes);
+        }
+        // Collect custom assets for all requested accounts
+        const customAssets = [];
+        for (const account of accounts) {
+            const accountCustomAssets = this.getCustomAssets(account.id);
+            customAssets.push(...accountCustomAssets);
+        }
+        if (options?.forceUpdate) {
+            // Pipeline spans only on unlock/first-init fetch; later forceUpdates pass
+            // `undefined` so `emitTrace` / `withTrace` no-op without call-site if/else.
+            const pipelineTrace = __classPrivateFieldGet(this, _AssetsController_firstInitFetchReported, "f")
+                ? undefined
+                : __classPrivateFieldGet(this, _AssetsController_trace, "f");
+            const request = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_buildDataRequest).call(this, accounts, chainIds, {
+                assetTypes,
+                dataTypes,
+                customAssets: customAssets.length > 0 ? customAssets : undefined,
+                forceUpdate: true,
+                assetsForPriceUpdate: options?.assetsForPriceUpdate,
+            });
+            // Fast pipeline: accountsApi + stakedBalance → detection → token + price.
+            // Snap and RPC are excluded here due to their latency (snap triggers account
+            // creation, RPC is slow on many chains). Results are committed to state
+            // immediately so the UI can display balances without waiting for them.
+            //
+            // Fast/slow pipelines use merge so partial API snapshots cannot wipe
+            // tokens missing from the response (e.g. USDC when only native balance
+            // is returned). Balances present in the response are still refreshed.
+            const fastSources = __classPrivateFieldGet(this, _AssetsController_isBasicFunctionality, "f").call(this)
+                ? [
+                    (0, ParallelMiddleware_js_1.createParallelBalanceMiddleware)([
+                        __classPrivateFieldGet(this, _AssetsController_accountsApiDataSource, "f"),
+                        __classPrivateFieldGet(this, _AssetsController_stakedBalanceDataSource, "f"),
+                    ]),
+                    // Graduation must run BEFORE the RPC fallback so it only sees
+                    // AccountsApi/Websocket balances. RPC intentionally carries
+                    // custom assets and must never trigger graduation.
+                    __classPrivateFieldGet(this, _AssetsController_customAssetGraduationMiddleware, "f"),
+                    __classPrivateFieldGet(this, _AssetsController_rpcFallbackMiddleware, "f"),
+                    __classPrivateFieldGet(this, _AssetsController_detectionMiddleware, "f"),
+                    (0, ParallelMiddleware_js_1.createParallelMiddleware)([
+                        __classPrivateFieldGet(this, _AssetsController_tokenDataSource, "f"),
+                        __classPrivateFieldGet(this, _AssetsController_priceDataSource, "f"),
+                    ]),
+                ]
+                : [__classPrivateFieldGet(this, _AssetsController_stakedBalanceDataSource, "f"), __classPrivateFieldGet(this, _AssetsController_detectionMiddleware, "f")];
+            const { response } = await (0, trace_js_1.withTrace)({
+                name: TRACE_FETCH_PIPELINE,
+                trace: pipelineTrace,
+                data: {
+                    chain_count: chainIds.length,
+                    account_count: accounts.length,
+                    basic_functionality: __classPrivateFieldGet(this, _AssetsController_isBasicFunctionality, "f").call(this),
+                },
+                fn: async (parentContext) => {
+                    const startTime = performance.now();
+                    const result = await __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_executeMiddlewares).call(this, {
+                        sources: fastSources,
+                        request,
+                        parentContext,
+                        trace: pipelineTrace,
+                    });
+                    await __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_updateState).call(this, {
+                        ...result.response,
+                        updateMode: 'merge',
+                        replaceCoveredChainBalances: true,
+                    });
+                    const durationMs = performance.now() - startTime;
+                    // Summary fields for Assets Health (nested under the parent span).
+                    (0, trace_js_1.emitTrace)({
+                        name: TRACE_FULL_FETCH,
+                        trace: pipelineTrace,
+                        data: {
+                            duration_ms: durationMs,
+                            chain_count: chainIds.length,
+                            account_count: accounts.length,
+                            basic_functionality: __classPrivateFieldGet(this, _AssetsController_isBasicFunctionality, "f").call(this),
+                            asset_count: result.response.assetsBalance
+                                ? Object.values(result.response.assetsBalance).reduce((sum, acct) => sum + Object.keys(acct).length, 0)
+                                : 0,
+                            price_count: result.response.assetsPrice
+                                ? Object.keys(result.response.assetsPrice).length
+                                : 0,
+                            ...result.durationByDataSource,
+                        },
+                        parentContext,
+                    });
+                    (0, trace_js_1.emitTrace)({
+                        name: TRACE_FIRST_INIT_FETCH,
+                        trace: pipelineTrace,
+                        data: {
+                            duration_ms: durationMs,
+                            chain_ids: JSON.stringify(chainIds),
+                            ...result.durationByDataSource,
+                        },
+                        parentContext,
+                    });
+                    return result;
+                },
+            });
+            // Mark after the unlock/first forceUpdate so later polls skip pipeline spans.
+            __classPrivateFieldSet(this, _AssetsController_firstInitFetchReported, true, "f");
+            // Background (slow) lane — flattened sibling of the fast lane (not nested
+            // inside its withTrace callback). Still fire-and-forget so UI is not blocked.
+            const slowPipelineChainIds = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSlowPipelineChainIds).call(this, chainIds, response);
+            if (slowPipelineChainIds.length > 0) {
+                const slowSources = __classPrivateFieldGet(this, _AssetsController_isBasicFunctionality, "f").call(this)
+                    ? [__classPrivateFieldGet(this, _AssetsController_snapDataSource, "f"), __classPrivateFieldGet(this, _AssetsController_rpcDataSource, "f")]
+                    : [__classPrivateFieldGet(this, _AssetsController_rpcDataSource, "f")];
+                const slowRequest = { ...request, chainIds: slowPipelineChainIds };
+                (0, trace_js_1.withTrace)({
+                    name: TRACE_BACKGROUND_FETCH,
+                    trace: pipelineTrace,
+                    data: {
+                        chain_count: slowPipelineChainIds.length,
+                        account_count: accounts.length,
+                    },
+                    fn: async (slowParentContext) => {
+                        const { response: slowResponse } = await __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_executeMiddlewares).call(this, {
+                            sources: [
+                                (0, ParallelMiddleware_js_1.createParallelBalanceMiddleware)(slowSources),
+                                __classPrivateFieldGet(this, _AssetsController_detectionMiddleware, "f"),
+                                ...(__classPrivateFieldGet(this, _AssetsController_isBasicFunctionality, "f").call(this)
+                                    ? [
+                                        (0, ParallelMiddleware_js_1.createParallelMiddleware)([
+                                            __classPrivateFieldGet(this, _AssetsController_tokenDataSource, "f"),
+                                            __classPrivateFieldGet(this, _AssetsController_priceDataSource, "f"),
+                                        ]),
+                                    ]
+                                    : []),
+                            ],
+                            request: slowRequest,
+                            parentContext: slowParentContext,
+                            trace: pipelineTrace,
+                        });
+                        await __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_updateState).call(this, {
+                            ...slowResponse,
+                            updateMode: 'merge',
+                        });
+                    },
+                }).catch((error) => log('Background pipeline failed', { error }));
+            }
+        }
+        const result = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getAssetsFromState).call(this, accounts, chainIds, assetTypes);
+        return result;
+    }
+    async getAssetsBalance(accounts, options) {
+        // Reuse getAssets with dataTypes: ['balance'] only
+        const assets = await this.getAssets(accounts, {
+            chainIds: options?.chainIds,
+            assetTypes: options?.assetTypes,
+            forceUpdate: options?.forceUpdate,
+            dataTypes: ['balance', 'metadata'],
+        });
+        // Extract just the balance from each asset
+        const result = {};
+        for (const [accountId, accountAssets] of Object.entries(assets)) {
+            result[accountId] = {};
+            for (const [assetId, asset] of Object.entries(accountAssets)) {
+                if (asset.balance) {
+                    result[accountId][assetId] = asset.balance;
+                }
+            }
+        }
+        return result;
+    }
+    getAssetMetadata(assetId) {
+        return this.state.assetsInfo[assetId];
+    }
+    /**
+     * Get a single combined asset (balance + metadata + price + computed
+     * `fiatValue`) for an account directly from controller state.
+     *
+     * Reuses the same state-composition and filtering logic as `getAssets`
+     * (balance and metadata are required, a missing price falls back to
+     * `{ price: 0, lastUpdated: 0 }` with `fiatValue: 0`, and hidden or
+     * otherwise filtered assets are excluded) so the returned shape never
+     * drifts from `getAssets`. Reads from current state only and does not
+     * trigger a data-source refresh.
+     *
+     * @param accountId - The account ID (`InternalAccount.id`, not an address).
+     * @param assetId - The CAIP-19 asset ID including chain scope
+     * (e.g. `eip155:1/erc20:0x...`).
+     * @returns The combined `Asset`, or `undefined` when no complete
+     * renderable asset (balance + metadata) exists for the account/asset pair.
+     * @throws If `accountId` is empty or `assetId` is not a valid CAIP-19 asset ID.
+     */
+    getAccountAssetByID(accountId, assetId) {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_assertNonEmptyAccountId).call(this, accountId, 'getAccountAssetByID');
+        const normalizedAssetId = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_normalizeAssetIdOrThrow).call(this, assetId, 'getAccountAssetByID');
+        return __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getAssetFromState).call(this, accountId, normalizedAssetId, {
+            assetTypeSet: new Set(['fungible']),
+        });
+    }
+    /**
+     * Get multiple combined assets (balance + metadata + price + computed
+     * `fiatValue`) for an account directly from controller state.
+     *
+     * Applies the same state-composition and filtering rules as
+     * `getAccountAssetByID` to each requested asset ID. Asset IDs that do not
+     * resolve to a complete renderable asset (missing balance/metadata, hidden,
+     * or otherwise filtered out) are omitted from the result. Reads from
+     * current state only and does not trigger a data-source refresh.
+     *
+     * @param accountId - The account ID (`InternalAccount.id`, not an address).
+     * @param assetIds - The CAIP-19 asset IDs including chain scope
+     * (e.g. `eip155:1/erc20:0x...`).
+     * @returns A record of combined `Asset`s keyed by normalized CAIP-19 asset
+     * ID, containing only the requested assets that resolved.
+     * @throws If `accountId` is empty or any `assetIds` entry is not a valid
+     * CAIP-19 asset ID.
+     */
+    getAccountAssetsByIDs(accountId, assetIds) {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_assertNonEmptyAccountId).call(this, accountId, 'getAccountAssetsByIDs');
+        const result = Object.create(null);
+        for (const assetId of assetIds) {
+            const normalizedAssetId = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_normalizeAssetIdOrThrow).call(this, assetId, 'getAccountAssetsByIDs');
+            const asset = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getAssetFromState).call(this, accountId, normalizedAssetId, {
+                assetTypeSet: new Set(['fungible']),
+            });
+            if (asset) {
+                result[normalizedAssetId] = asset;
+            }
+        }
+        return result;
+    }
+    /**
+     * Get all combined assets (balance + metadata + price + computed
+     * `fiatValue`) an account holds on a given chain scope, directly from
+     * controller state.
+     *
+     * Applies the same state-composition and filtering rules as
+     * `getAccountAssetByID` (hidden or otherwise filtered assets are excluded).
+     * Reads from current state only and does not trigger a data-source refresh.
+     *
+     * @param accountId - The account ID (`InternalAccount.id`, not an address).
+     * @param scope - The CAIP-2 chain ID to filter by (e.g. `eip155:1`).
+     * @returns A record of combined `Asset`s keyed by CAIP-19 asset ID,
+     * containing only the account's assets on the given scope.
+     * @throws If `accountId` is empty or `scope` is not a valid CAIP-2 chain ID.
+     */
+    getAccountAssetsByScope(accountId, scope) {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_assertNonEmptyAccountId).call(this, accountId, 'getAccountAssetsByScope');
+        if (!(0, utils_1.isCaipChainId)(scope)) {
+            throw new Error(`AssetsController.getAccountAssetsByScope: invalid CAIP-2 scope "${String(scope)}"`);
+        }
+        const result = Object.create(null);
+        const chainIdSet = new Set([scope]);
+        const assetTypeSet = new Set(['fungible']);
+        const accountBalances = this.state.assetsBalance[accountId] ?? {};
+        for (const assetId of Object.keys(accountBalances)) {
+            const typedAssetId = assetId;
+            const asset = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getAssetFromState).call(this, accountId, typedAssetId, {
+                chainIdSet,
+                assetTypeSet,
+            });
+            if (asset) {
+                result[typedAssetId] = asset;
+            }
+        }
+        return result;
+    }
+    async getAssetsPrice(accounts, options) {
+        const assets = await this.getAssets(accounts, {
+            chainIds: options?.chainIds,
+            assetTypes: options?.assetTypes,
+            forceUpdate: options?.forceUpdate,
+            dataTypes: ['price'],
+        });
+        // Extract just the price from each asset (flattened across accounts)
+        const result = {};
+        for (const accountAssets of Object.values(assets)) {
+            for (const [assetId, asset] of Object.entries(accountAssets)) {
+                if (asset.price) {
+                    result[assetId] = asset.price;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Returns exchange rates in the format expected by the bridge controller
+     * (conversionRates, currencyRates, marketData, currentCurrency) so that
+     * when useAssetsControllerForRates is true the bridge can use a single
+     * action instead of MultichainAssetsRatesController, TokenRatesController,
+     * and CurrencyRateController.
+     *
+     * @returns Bridge-compatible exchange rate state derived from assetsPrice and selectedCurrency.
+     */
+    getExchangeRatesForBridge() {
+        const { networkConfigurationsByChainId } = this.messenger.call('NetworkController:getState');
+        return (0, index_js_2.formatExchangeRatesForBridge)({
+            assetsInfo: this.state.assetsInfo,
+            assetsPrice: this.state.assetsPrice,
+            selectedCurrency: this.state.selectedCurrency,
+            nativeAssetIdentifiers: __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getNativeAssetMap).call(this),
+            networkConfigurationsByChainId,
+        });
+    }
+    /**
+     * Returns state in the legacy format expected by transaction-pay-controller
+     * (TokenBalancesController, AccountTrackerController, TokensController,
+     * TokenRatesController, CurrencyRateController shapes) so that when
+     * useAssetsController is true the transaction-pay-controller can use a
+     * single action instead of five separate getState calls.
+     *
+     * @returns Legacy-compatible state for transaction-pay-controller.
+     */
+    getStateForTransactionPay() {
+        const accounts = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this);
+        const { networkConfigurationsByChainId } = this.messenger.call('NetworkController:getState');
+        return (0, index_js_2.formatStateForTransactionPay)({
+            assetsBalance: this.state.assetsBalance,
+            assetsInfo: this.state.assetsInfo,
+            assetsPrice: this.state.assetsPrice,
+            selectedCurrency: this.state.selectedCurrency,
+            accounts: accounts.map((a) => ({ id: a.id, address: a.address })),
+            nativeAssetIdentifiers: __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getNativeAssetMap).call(this),
+            networkConfigurationsByChainId,
+        });
+    }
+    // ============================================================================
+    // CUSTOM ASSETS MANAGEMENT
+    // ============================================================================
+    /**
+     * Add a custom asset for an account.
+     * Custom assets are included in subscription and fetch operations.
+     * Adding a custom asset also unhides it if it was previously hidden.
+     *
+     * When `pendingMetadata` is provided (e.g. from the extension's pending-tokens
+     * flow), the token metadata is persisted immediately into `assetsInfo` so the
+     * UI can render it without waiting for the next pipeline fetch.
+     *
+     * @param accountId - The account ID to add the custom asset for.
+     * @param assetId - The CAIP-19 asset ID to add.
+     * @param pendingMetadata - Optional token metadata from the UI (pendingTokens format).
+     */
+    async addCustomAsset(accountId, assetId, pendingMetadata) {
+        const normalizedAssetId = (0, index_js_2.normalizeAssetId)(assetId);
+        log('Adding custom asset', { accountId, assetId: normalizedAssetId });
+        this.update((state) => {
+            var _a;
+            const customAssets = state.customAssets;
+            if (!customAssets[accountId]) {
+                customAssets[accountId] = [];
+            }
+            // Only add if not already present
+            if (!customAssets[accountId].includes(normalizedAssetId)) {
+                customAssets[accountId].push(normalizedAssetId);
+            }
+            // Unhide the asset if it was hidden (via assetPreferences)
+            const prefs = state.assetPreferences[normalizedAssetId];
+            if (prefs?.hidden) {
+                delete prefs.hidden;
+                if (Object.keys(prefs).length === 0) {
+                    delete state.assetPreferences[normalizedAssetId];
+                }
+            }
+            // Persist metadata from the UI so the token is immediately renderable
+            if (pendingMetadata) {
+                const parsed = (0, utils_1.parseCaipAssetType)(normalizedAssetId);
+                let tokenType = 'erc20';
+                if (__classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_isNativeAsset).call(this, normalizedAssetId)) {
+                    tokenType = 'native';
+                }
+                else if (parsed.chain.namespace === utils_1.KnownCaipNamespace.Solana &&
+                    parsed.assetNamespace === TokenDataSource_js_1.CaipAssetNamespace.Token) {
+                    tokenType = 'spl';
+                }
+                const assetMetadata = {
+                    type: tokenType,
+                    symbol: pendingMetadata.symbol,
+                    name: pendingMetadata.name,
+                    decimals: pendingMetadata.decimals,
+                    image: pendingMetadata.iconUrl,
+                    aggregators: pendingMetadata.aggregators,
+                    occurrences: pendingMetadata.occurrences,
+                };
+                state.assetsInfo[normalizedAssetId] =
+                    assetMetadata;
+            }
+            // Seed a zero balance so the UI can render the asset immediately,
+            // before the next pipeline fetch returns the real amount.
+            const balances = state.assetsBalance;
+            balances[accountId] ?? (balances[accountId] = {});
+            (_a = balances[accountId])[normalizedAssetId] ?? (_a[normalizedAssetId] = { amount: '0' });
+        });
+        // Fetch data for the newly added custom asset (merge to preserve other chains)
+        const account = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this).find((a) => a.id === accountId);
+        if (account) {
+            const chainId = extractChainId(normalizedAssetId);
+            await this.getAssets([account], {
+                chainIds: [chainId],
+                dataTypes: ['balance', 'metadata', 'price'],
+                assetTypes: ['fungible'],
+                forceUpdate: true,
+                updateMode: 'merge',
+            });
+        }
+        // Re-evaluate subscriptions so the supplemental RPC poll picks up the
+        // new customAsset on chains another data source already owns.
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeAssets).call(this);
+    }
+    /**
+     * Remove a custom asset from an account.
+     *
+     * @param accountId - The account ID to remove the custom asset from.
+     * @param assetId - The CAIP-19 asset ID to remove.
+     */
+    removeCustomAsset(accountId, assetId) {
+        const normalizedAssetId = (0, index_js_2.normalizeAssetId)(assetId);
+        log('Removing custom asset', { accountId, assetId: normalizedAssetId });
+        this.update((state) => {
+            if (state.customAssets[accountId]) {
+                state.customAssets[accountId] = state.customAssets[accountId].filter((id) => id !== normalizedAssetId);
+                // Clean up empty arrays
+                if (state.customAssets[accountId].length === 0) {
+                    delete state.customAssets[accountId];
+                }
+            }
+        });
+        // Re-evaluate subscriptions so the supplemental RPC poll for that chain
+        // is torn down when no more customAssets remain there.
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeAssets).call(this);
+    }
+    /**
+     * Get all custom assets for an account.
+     *
+     * @param accountId - The account ID to get custom assets for.
+     * @returns Array of CAIP-19 asset IDs for the account's custom assets.
+     */
+    getCustomAssets(accountId) {
+        return this.state.customAssets[accountId] ?? [];
+    }
+    // ============================================================================
+    // HIDDEN ASSETS MANAGEMENT
+    // ============================================================================
+    /**
+     * Hide an asset globally.
+     * Hidden assets are excluded from the asset list returned by getAssets.
+     * The hidden state is stored in assetPreferences.
+     *
+     * @param assetId - The CAIP-19 asset ID to hide.
+     */
+    hideAsset(assetId) {
+        const normalizedAssetId = (0, index_js_2.normalizeAssetId)(assetId);
+        log('Hiding asset', { assetId: normalizedAssetId });
+        this.update((state) => {
+            if (!state.assetPreferences[normalizedAssetId]) {
+                state.assetPreferences[normalizedAssetId] = {};
+            }
+            state.assetPreferences[normalizedAssetId].hidden = true;
+        });
+    }
+    /**
+     * Unhide an asset globally.
+     *
+     * @param assetId - The CAIP-19 asset ID to unhide.
+     */
+    unhideAsset(assetId) {
+        const normalizedAssetId = (0, index_js_2.normalizeAssetId)(assetId);
+        log('Unhiding asset', { assetId: normalizedAssetId });
+        this.update((state) => {
+            const prefs = state.assetPreferences[normalizedAssetId];
+            if (prefs) {
+                delete prefs.hidden;
+                if (Object.keys(prefs).length === 0) {
+                    delete state.assetPreferences[normalizedAssetId];
+                }
+            }
+        });
+    }
+    // ============================================================================
+    // CURRENT CURRENCY MANAGEMENT
+    // ============================================================================
+    /**
+     * Set the current currency.
+     *
+     * @param selectedCurrency - The ISO 4217 currency code to set.
+     */
+    setSelectedCurrency(selectedCurrency) {
+        const previousCurrency = this.state.selectedCurrency;
+        if (previousCurrency === selectedCurrency) {
+            return;
+        }
+        this.update((state) => {
+            state.selectedCurrency = selectedCurrency;
+        });
+        log('Current currency changed', {
+            previousCurrency,
+            selectedCurrency,
+        });
+        if (!__classPrivateFieldGet(this, _AssetsController_isBasicFunctionality, "f").call(this)) {
+            return;
+        }
+        // Currency changed — old cached prices are in the wrong currency.
+        __classPrivateFieldGet(this, _AssetsController_priceDataSource, "f").invalidatePriceCache();
+        this.getAssets(__classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this), {
+            forceUpdate: true,
+            dataTypes: ['price'],
+            assetsForPriceUpdate: Object.values(this.state.assetsBalance).flatMap((balances) => Object.keys(balances)),
+        }).catch((error) => {
+            log('Failed to fetch asset prices after current currency change', error);
+        });
+    }
+    // ============================================================================
+    // SUBSCRIPTIONS
+    // ============================================================================
+    /**
+     * Subscribe to price updates for all assets held by the given accounts.
+     * Polls PriceDataSource which fetches prices from balance state.
+     *
+     * @param accounts - Accounts to subscribe price updates for.
+     * @param chainIds - Chain IDs to filter prices for.
+     */
+    subscribeAssetsPrice(accounts, chainIds) {
+        if (!__classPrivateFieldGet(this, _AssetsController_isBasicFunctionality, "f").call(this)) {
+            return;
+        }
+        const subscriptionKey = 'ds:PriceDataSource';
+        const existingSubscription = __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").get(subscriptionKey);
+        const isUpdate = existingSubscription !== undefined;
+        const request = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_buildDataRequest).call(this, accounts, chainIds, {
+            dataTypes: ['price'],
+        });
+        const subscribeReq = {
+            request,
+            subscriptionId: subscriptionKey,
+            isUpdate,
+            onAssetsUpdate: (response) => this.handleAssetsUpdate(response, 'PriceDataSource'),
+            getAssetsState: () => this.state,
+        };
+        __classPrivateFieldGet(this, _AssetsController_priceDataSource, "f").subscribe(subscribeReq).catch(console.error);
+        // Track subscription
+        const subscription = {
+            chains: chainIds,
+            accountId: subscriptionKey,
+            assetTypes: ['fungible'],
+            dataTypes: ['price'],
+            unsubscribe: () => {
+                __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").delete(subscriptionKey);
+            },
+        };
+        __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").set(subscriptionKey, subscription);
+    }
+    /**
+     * Unsubscribe from price updates.
+     */
+    unsubscribeAssetsPrice() {
+        const subscriptionKey = 'ds:PriceDataSource';
+        const existingSubscription = __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").get(subscriptionKey);
+        if (!existingSubscription) {
+            return;
+        }
+        __classPrivateFieldGet(this, _AssetsController_priceDataSource, "f").unsubscribe(subscriptionKey).catch(console.error);
+        existingSubscription.unsubscribe();
+    }
+    /**
+     * Handle basic functionality toggle change. Call this from the consumer (extension or mobile)
+     * when the user changes the "Basic functionality" setting. Refreshes subscriptions so the
+     * current {@link AssetsControllerOptions.isBasicFunctionality} getter is used (true = APIs on,
+     * false = RPC only).
+     *
+     * @param _isBasic - The new value (for call-site clarity; the getter is the source of truth).
+     */
+    handleBasicFunctionalityChange(_isBasic) {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_stop).call(this);
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeAssets).call(this);
+    }
+    /**
+     * Handle assets updated from a data source.
+     * Called via the onAssetsUpdate callback passed in SubscriptionRequest when the controller subscribes to a data source.
+     * Runs detection, then (when basic functionality is enabled) token metadata and price enrichment before updating state.
+     * When basic functionality is disabled (RPC-only mode), only detection runs; token and price APIs are not used.
+     *
+     * @param response - The data response with updated assets
+     * @param sourceId - The data source ID reporting the update
+     * @param request - Optional original request for context when enriching
+     */
+    async handleAssetsUpdate(response, sourceId, request) {
+        log('Assets updated from data source', {
+            sourceId,
+            hasBalance: Boolean(response.assetsBalance),
+            hasPrice: Boolean(response.assetsPrice),
+        });
+        // Enrichment spans only before unlock/first-init fetch completes.
+        const pipelineTrace = __classPrivateFieldGet(this, _AssetsController_firstInitFetchReported, "f")
+            ? undefined
+            : __classPrivateFieldGet(this, _AssetsController_trace, "f");
+        await (0, trace_js_1.withTrace)({
+            name: TRACE_UPDATE_PARENT,
+            trace: pipelineTrace,
+            data: {
+                source: sourceId,
+                has_balance: Boolean(response.assetsBalance),
+                has_price: Boolean(response.assetsPrice),
+                balance_account_count: response.assetsBalance
+                    ? Object.keys(response.assetsBalance).length
+                    : 0,
+            },
+            fn: async (parentContext) => {
+                const updateStart = performance.now();
+                const resolvedRequest = request ?? {
+                    accountsWithSupportedChains: [],
+                    chainIds: [],
+                    dataTypes: ['balance', 'metadata', 'price'],
+                };
+                // RPC-only mode (basic functionality off): never run token/price APIs. Strip
+                // those data types so downstream middleware cannot treat them as requested.
+                const pipelineRequest = __classPrivateFieldGet(this, _AssetsController_isBasicFunctionality, "f").call(this)
+                    ? resolvedRequest
+                    : {
+                        ...resolvedRequest,
+                        dataTypes: resolvedRequest.dataTypes.filter((dt) => dt !== 'metadata' && dt !== 'price'),
+                    };
+                // Graduate custom assets only when AccountsAPI / AccountActivity reports
+                // them. RPC already fetches custom assets on purpose, and Snap handles
+                // non-EVM chains the rule does not apply to, so skip the middleware for
+                // those.
+                const shouldGraduateCustomAssets = sourceId === 'AccountsApiDataSource' ||
+                    sourceId === 'AccountActivityDataSource';
+                // Websocket updates can carry brand-new spam airdrops: enrich them
+                // with Token API occurrences and drop below-floor tokens BEFORE
+                // detection, so spam is never detected, enriched, priced or persisted.
+                const shouldFilterOccurrences = sourceId === 'AccountActivityDataSource' &&
+                    __classPrivateFieldGet(this, _AssetsController_isBasicFunctionality, "f").call(this);
+                const enrichmentSources = [
+                    ...(shouldGraduateCustomAssets
+                        ? [__classPrivateFieldGet(this, _AssetsController_customAssetGraduationMiddleware, "f")]
+                        : []),
+                    ...(shouldFilterOccurrences
+                        ? [
+                            {
+                                getName: () => 'OccurrenceFloorFilter',
+                                assetsMiddleware: __classPrivateFieldGet(this, _AssetsController_tokenDataSource, "f").occurrenceFilterMiddleware,
+                            },
+                        ]
+                        : []),
+                    __classPrivateFieldGet(this, _AssetsController_detectionMiddleware, "f"),
+                ];
+                if (__classPrivateFieldGet(this, _AssetsController_isBasicFunctionality, "f").call(this)) {
+                    enrichmentSources.push((0, ParallelMiddleware_js_1.createParallelMiddleware)([
+                        __classPrivateFieldGet(this, _AssetsController_tokenDataSource, "f"),
+                        __classPrivateFieldGet(this, _AssetsController_priceDataSource, "f"),
+                    ]));
+                }
+                const { response: enrichedResponse } = await __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_executeMiddlewares).call(this, {
+                    sources: enrichmentSources,
+                    request: pipelineRequest,
+                    initialResponse: response,
+                    parentContext,
+                    trace: pipelineTrace,
+                });
+                await __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_updateState).call(this, {
+                    ...enrichedResponse,
+                    replaceCoveredChainBalances: response.replaceCoveredChainBalances,
+                });
+                // Summary fields for Assets Health (nested under the parent span).
+                (0, trace_js_1.emitTrace)({
+                    name: TRACE_UPDATE_PIPELINE,
+                    trace: pipelineTrace,
+                    data: {
+                        source: sourceId,
+                        duration_ms: performance.now() - updateStart,
+                        has_balance: Boolean(response.assetsBalance),
+                        has_price: Boolean(response.assetsPrice),
+                        has_metadata: Boolean(enrichedResponse.assetsInfo),
+                        balance_account_count: response.assetsBalance
+                            ? Object.keys(response.assetsBalance).length
+                            : 0,
+                    },
+                    parentContext,
+                });
+            },
+        });
+    }
+    // ============================================================================
+    // CLEANUP
+    // ============================================================================
+    destroy() {
+        log('Destroying AssetsController', {
+            dataSourceCount: __classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_allBalanceDataSources_get).length,
+            subscriptionCount: __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").size,
+        });
+        // Destroy instantiated data sources
+        __classPrivateFieldGet(this, _AssetsController_accountActivityDataSource, "f")?.destroy?.();
+        __classPrivateFieldGet(this, _AssetsController_accountsApiDataSource, "f")?.destroy?.();
+        __classPrivateFieldGet(this, _AssetsController_snapDataSource, "f")?.destroy?.();
+        __classPrivateFieldGet(this, _AssetsController_rpcDataSource, "f")?.destroy?.();
+        __classPrivateFieldGet(this, _AssetsController_stakedBalanceDataSource, "f")?.destroy?.();
+        // Stop all active subscriptions
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_stop).call(this);
+        if (__classPrivateFieldGet(this, _AssetsController_unsubscribeBasicFunctionality, "f")) {
+            __classPrivateFieldGet(this, _AssetsController_unsubscribeBasicFunctionality, "f").call(this);
+            __classPrivateFieldSet(this, _AssetsController_unsubscribeBasicFunctionality, null, "f");
+        }
+        // Unregister action handlers
+        this.messenger.unregisterActionHandler('AssetsController:getAssets');
+        this.messenger.unregisterActionHandler('AssetsController:getAssetsBalance');
+        this.messenger.unregisterActionHandler('AssetsController:getAssetMetadata');
+        this.messenger.unregisterActionHandler('AssetsController:getAccountAssetByID');
+        this.messenger.unregisterActionHandler('AssetsController:getAccountAssetsByIDs');
+        this.messenger.unregisterActionHandler('AssetsController:getAccountAssetsByScope');
+        this.messenger.unregisterActionHandler('AssetsController:getAssetsPrice');
+        this.messenger.unregisterActionHandler('AssetsController:getExchangeRatesForBridge');
+        this.messenger.unregisterActionHandler('AssetsController:getStateForTransactionPay');
+        this.messenger.unregisterActionHandler('AssetsController:addCustomAsset');
+        this.messenger.unregisterActionHandler('AssetsController:removeCustomAsset');
+        this.messenger.unregisterActionHandler('AssetsController:getCustomAssets');
+        this.messenger.unregisterActionHandler('AssetsController:hideAsset');
+        this.messenger.unregisterActionHandler('AssetsController:unhideAsset');
+        this.messenger.unregisterActionHandler('AssetsController:setSelectedCurrency');
+    }
+}
+exports.AssetsController = AssetsController;
+_AssetsController_isEnabled = new WeakMap(), _AssetsController_isBasicFunctionality = new WeakMap(), _AssetsController_defaultUpdateInterval = new WeakMap(), _AssetsController_trace = new WeakMap(), _AssetsController_captureException = new WeakMap(), _AssetsController_firstInitFetchReported = new WeakMap(), _AssetsController_stateSizeReported = new WeakMap(), _AssetsController_uiOpen = new WeakMap(), _AssetsController_keyringUnlocked = new WeakMap(), _AssetsController_accountTreeInitialized = new WeakMap(), _AssetsController_controllerMutex = new WeakMap(), _AssetsController_accountRefreshMutex = new WeakMap(), _AssetsController_activeSubscriptions = new WeakMap(), _AssetsController_enabledChains = new WeakMap(), _AssetsController_lastKnownAccountIds = new WeakMap(), _AssetsController_accountActivityDataSource = new WeakMap(), _AssetsController_accountsApiDataSource = new WeakMap(), _AssetsController_snapDataSource = new WeakMap(), _AssetsController_rpcDataSource = new WeakMap(), _AssetsController_stakedBalanceDataSource = new WeakMap(), _AssetsController_priceDataSource = new WeakMap(), _AssetsController_detectionMiddleware = new WeakMap(), _AssetsController_customAssetGraduationMiddleware = new WeakMap(), _AssetsController_rpcFallbackMiddleware = new WeakMap(), _AssetsController_tokenDataSource = new WeakMap(), _AssetsController_unsubscribeBasicFunctionality = new WeakMap(), _AssetsController_queryApiClient = new WeakMap(), _AssetsController_onActiveChainsUpdated = new WeakMap(), _AssetsController_instances = new WeakSet(), _AssetsController_emitStateSizeTrace = function _AssetsController_emitStateSizeTrace() {
+    if (!__classPrivateFieldGet(this, _AssetsController_trace, "f") || __classPrivateFieldGet(this, _AssetsController_stateSizeReported, "f")) {
+        return;
+    }
+    __classPrivateFieldSet(this, _AssetsController_stateSizeReported, true, "f");
+    const { assetsBalance: balances, customAssets, assetsInfo, assetsPrice, } = this.state;
+    // Count balance entries and collect unique asset IDs / chain IDs in one pass.
+    let balanceEntries = 0;
+    const uniqueAssets = new Set();
+    const uniqueNetworks = new Set();
+    for (const acct of Object.values(balances)) {
+        const assetIds = Object.keys(acct);
+        balanceEntries += assetIds.length;
+        for (const assetId of assetIds) {
+            uniqueAssets.add(assetId);
+            // CAIP-19 format: "eip155:1/slip44:60" — chainId is everything before "/"
+            const slash = assetId.indexOf('/');
+            if (slash > 0) {
+                uniqueNetworks.add(assetId.slice(0, slash));
+            }
+        }
+    }
+    let customAssetEntries = 0;
+    for (const ids of Object.values(customAssets)) {
+        if (Array.isArray(ids)) {
+            customAssetEntries += ids.length;
+        }
+    }
+    (0, trace_js_1.emitTrace)({
+        name: TRACE_STATE_SIZE,
+        trace: __classPrivateFieldGet(this, _AssetsController_trace, "f"),
+        data: {
+            balance_entries: balanceEntries,
+            balance_accounts: Object.keys(balances).length,
+            // `asset_count` matches the Assets Health dashboard widget field name.
+            asset_count: uniqueAssets.size,
+            unique_asset_count: uniqueAssets.size,
+            network_count: uniqueNetworks.size,
+            metadata_entries: Object.keys(assetsInfo).length,
+            price_entries: Object.keys(assetsPrice).length,
+            custom_asset_entries: customAssetEntries,
+        },
+    });
+}, _AssetsController_getSelectedAccounts = function _AssetsController_getSelectedAccounts() {
+    const accounts = this.messenger.call('AccountTreeController:getAccountsFromSelectedAccountGroup');
+    if (accounts.length > 0) {
+        return accounts;
+    }
+    const selectedAccount = this.messenger.call('AccountsController:getSelectedAccount');
+    if (selectedAccount) {
+        return [selectedAccount];
+    }
+    return [];
+}, _AssetsController_allBalanceDataSources_get = function _AssetsController_allBalanceDataSources_get() {
+    return [
+        __classPrivateFieldGet(this, _AssetsController_accountActivityDataSource, "f"),
+        __classPrivateFieldGet(this, _AssetsController_accountsApiDataSource, "f"),
+        __classPrivateFieldGet(this, _AssetsController_snapDataSource, "f"),
+        __classPrivateFieldGet(this, _AssetsController_rpcDataSource, "f"),
+    ];
+}, _AssetsController_initializeNativeAssetsMap = function _AssetsController_initializeNativeAssetsMap(queryApiClient) {
+    queryApiClient.queryClient
+        .fetchQuery({
+        queryKey: NATIVE_ASSETS_QUERY_KEY,
+        queryFn: index_js_2.buildNativeAssetsFromApi,
+        staleTime: Infinity,
+        gcTime: Infinity,
+    })
+        .catch((error) => {
+        // Failure to populate native asset cache is non-fatal;
+        // #isNativeAsset falls back to the seed data from buildNativeAssetsFromConstant.
+        log('Failed to populate native asset cache, falling back to seed data', error);
+    });
+    // Seed the cache synchronously so that synchronous consumers (e.g.
+    // #isNativeAsset, #resolveNativeAssetIds) have data available immediately.
+    // When fetchQuery resolves (currently instant, future: API), it overwrites
+    // this with potentially fresher data.
+    const initialNativeAssetMap = (0, index_js_2.buildNativeAssetsFromConstant)();
+    queryApiClient.setCachedData(NATIVE_ASSETS_QUERY_KEY, initialNativeAssetMap);
+}, _AssetsController_initializeState = function _AssetsController_initializeState() {
+    const { enabledNetworkMap } = this.messenger.call('NetworkEnablementController:getState');
+    __classPrivateFieldSet(this, _AssetsController_enabledChains, __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_extractEnabledChains).call(this, enabledNetworkMap), "f");
+    log('Initialized state', {
+        enabledNetworkMap,
+        enabledChains: __classPrivateFieldGet(this, _AssetsController_enabledChains, "f"),
+    });
+}, _AssetsController_extractEnabledChains = function _AssetsController_extractEnabledChains(enabledNetworkMap) {
+    const chains = new Set();
+    for (const [namespace, networks] of Object.entries(enabledNetworkMap)) {
+        for (const [reference, isEnabled] of Object.entries(networks)) {
+            if (isEnabled) {
+                // Check if reference is already a full CAIP-2 chain ID (contains colon)
+                if (reference.includes(':')) {
+                    // Already a full chain ID, use as-is
+                    chains.add(reference);
+                }
+                else {
+                    // Normalize EIP155 chain references from hex to decimal (CAIP-2 standard)
+                    const normalizedReference = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_normalizeChainReference).call(this, namespace, reference);
+                    chains.add(`${namespace}:${normalizedReference}`);
+                }
+            }
+        }
+    }
+    return chains;
+}, _AssetsController_normalizeChainReference = function _AssetsController_normalizeChainReference(namespace, reference) {
+    if (namespace === 'eip155' && (0, utils_1.isStrictHexString)(reference)) {
+        // Convert hex to decimal for EIP155 chains
+        return parseInt(reference, 16).toString();
+    }
+    return reference;
+}, _AssetsController_subscribeToEvents = function _AssetsController_subscribeToEvents() {
+    // Subscribe to account group changes (when user switches between account groups like Account 1 -> Account 2)
+    this.messenger.subscribe('AccountTreeController:selectedAccountGroupChange', (groupId, previousGroupId) => {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_handleAccountGroupChanged).call(this, groupId, previousGroupId).catch(console.error);
+    });
+    // Catch post-init tree mutations that change the selected account set
+    // (e.g. a snap account added to the current group) without changing
+    // the selected group id. Intermediate `:stateChange` events during
+    // `AccountTreeController.init()` are ignored until `:initialized`.
+    this.messenger.subscribe('AccountTreeController:stateChange', () => {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_handleAccountTreeStateChange).call(this);
+    });
+    // Subscribe to network enablement changes (only enabledNetworkMap)
+    this.messenger.subscribe('NetworkEnablementController:stateChange', ({ enabledNetworkMap }) => {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_handleEnabledNetworksChanged).call(this, enabledNetworkMap).catch(console.error);
+    });
+    // When a network is added or removed from NetworkController, refresh
+    // assets across every data source so balances, prices, and metadata
+    // stay consistent. On add we also seed default tracked assets (e.g.
+    // mUSD on Monad) when the chain is in our defaults registry, so the
+    // entries appear immediately without waiting for it to also be
+    // enabled in NetworkEnablementController.
+    this.messenger.subscribe('NetworkController:networkAdded', (networkConfiguration) => {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_handleNetworkAdded).call(this, networkConfiguration.chainId);
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_refreshAssetsAfterNetworkAdded).call(this, networkConfiguration.chainId).catch((error) => {
+            log('Failed to refresh assets after network added', { error });
+        });
+    });
+    this.messenger.subscribe('NetworkController:networkRemoved', () => {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_refreshAssetsAfterNetworkChange).call(this);
+    });
+    // Selected EVM network switch (network picker). Enablement changes are
+    // handled separately via NetworkEnablementController:stateChange.
+    this.messenger.subscribe('NetworkController:networkDidChange', (networkState) => {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_handleNetworkDidChange).call(this, networkState).catch(console.error);
+    });
+    // Client + Keyring lifecycle: only run when UI is open AND keyring is unlocked
+    this.messenger.subscribe('ClientController:stateChange', (isUiOpen) => {
+        __classPrivateFieldSet(this, _AssetsController_uiOpen, isUiOpen, "f");
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_updateActive).call(this);
+    }, client_controller_1.clientControllerSelectors.selectIsUiOpen);
+    this.messenger.subscribe('KeyringController:unlock', () => {
+        __classPrivateFieldSet(this, _AssetsController_keyringUnlocked, true, "f");
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_updateActive).call(this);
+    });
+    this.messenger.subscribe('KeyringController:lock', () => {
+        __classPrivateFieldSet(this, _AssetsController_keyringUnlocked, false, "f");
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_updateActive).call(this);
+    });
+    // Subscribe to unapproved transactions - TXs that need confirmation
+    // Ensures that balances for the account making transaction are updated (e.g. for gas estimations)
+    this.messenger.subscribe('TransactionController:unapprovedTransactionAdded', (transactionMeta) => {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_onUnapprovedTransactionAdded).call(this, transactionMeta);
+    });
+    // Post-tx refresh via the full fetch pipeline (Accounts API + RPC fallback).
+    // RpcDataSource also listens for transactionConfirmed, but only refreshes
+    // chains it owns via an active subscription.
+    this.messenger.subscribe('TransactionController:transactionConfirmed', (transactionMeta) => {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_onTransactionConfirmed).call(this, transactionMeta);
+    });
+    // Start tracking only after the account tree is fully built. Unlock can
+    // happen before `AccountTreeController.init()`, and `:stateChange` fires
+    // for intermediate mutations during that build.
+    this.messenger.subscribe('AccountTreeController:initialized', () => {
+        __classPrivateFieldSet(this, _AssetsController_accountTreeInitialized, true, "f");
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_updateActive).call(this);
+    });
+    this.messenger.subscribe('AccountTreeController:uninitialized', () => {
+        __classPrivateFieldSet(this, _AssetsController_accountTreeInitialized, false, "f");
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_updateActive).call(this);
+    });
+}, _AssetsController_onUnapprovedTransactionAdded = function _AssetsController_onUnapprovedTransactionAdded(transactionMeta) {
+    const hexChainId = transactionMeta.chainId;
+    if (!hexChainId) {
+        return;
+    }
+    const caipChainId = `eip155:${parseInt(hexChainId, 16)}`;
+    const fromAddress = transactionMeta.txParams.from?.toLowerCase();
+    if (!fromAddress) {
+        return;
+    }
+    const matchedAccount = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this).find((account) => account.address.toLowerCase() === fromAddress);
+    if (!matchedAccount) {
+        return;
+    }
+    this.getAssets([matchedAccount], {
+        chainIds: [caipChainId],
+        forceUpdate: true,
+    }).catch((error) => {
+        log('Failed to refresh assets after unapproved transaction added', {
+            error,
+        });
+    });
+}, _AssetsController_onTransactionConfirmed = function _AssetsController_onTransactionConfirmed(transactionMeta) {
+    const hexChainId = transactionMeta.chainId;
+    if (!hexChainId) {
+        return;
+    }
+    const caipChainId = `eip155:${parseInt(hexChainId, 16)}`;
+    const fromAddress = transactionMeta.txParams.from?.toLowerCase();
+    if (!fromAddress) {
+        return;
+    }
+    const matchedAccount = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this).find((account) => account.address.toLowerCase() === fromAddress);
+    if (!matchedAccount) {
+        return;
+    }
+    this.getAssets([matchedAccount], {
+        chainIds: [caipChainId],
+        forceUpdate: true,
+    }).catch((error) => {
+        log('Failed to refresh assets after transaction confirmed', { error });
+    });
+}, _AssetsController_updateActive = function _AssetsController_updateActive() {
+    const shouldRun = __classPrivateFieldGet(this, _AssetsController_uiOpen, "f") && __classPrivateFieldGet(this, _AssetsController_keyringUnlocked, "f") && __classPrivateFieldGet(this, _AssetsController_accountTreeInitialized, "f");
+    if (shouldRun) {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_start).call(this);
+    }
+    else {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_stop).call(this);
+    }
+}, _AssetsController_handleAccountTreeStateChange = function _AssetsController_handleAccountTreeStateChange() {
+    const shouldRun = __classPrivateFieldGet(this, _AssetsController_uiOpen, "f") &&
+        __classPrivateFieldGet(this, _AssetsController_keyringUnlocked, "f") &&
+        __classPrivateFieldGet(this, _AssetsController_accountTreeInitialized, "f") &&
+        __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").size > 0;
+    if (!shouldRun) {
+        return;
+    }
+    const accounts = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this);
+    const currentIds = new Set(accounts.map((a) => a.id));
+    const accountsChanged = currentIds.size !== __classPrivateFieldGet(this, _AssetsController_lastKnownAccountIds, "f").size ||
+        [...currentIds].some((id) => !__classPrivateFieldGet(this, _AssetsController_lastKnownAccountIds, "f").has(id));
+    if (!accountsChanged) {
+        return;
+    }
+    const hasOverlap = [...currentIds].some((id) => __classPrivateFieldGet(this, _AssetsController_lastKnownAccountIds, "f").has(id));
+    if (!hasOverlap && __classPrivateFieldGet(this, _AssetsController_lastKnownAccountIds, "f").size > 0) {
+        return;
+    }
+    log('Account tree changed with new accounts, re-subscribing', {
+        previousCount: __classPrivateFieldGet(this, _AssetsController_lastKnownAccountIds, "f").size,
+        currentCount: currentIds.size,
+    });
+    const newAccounts = accounts.filter((account) => !__classPrivateFieldGet(this, _AssetsController_lastKnownAccountIds, "f").has(account.id));
+    __classPrivateFieldSet(this, _AssetsController_lastKnownAccountIds, currentIds, "f");
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_ensureNativeBalancesDefaultZero).call(this);
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_ensureDefaultTrackedAssetsSeeded).call(this);
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_runAccountTreeRefresh).call(this, accounts, newAccounts).catch((error) => {
+        log('Failed to refresh assets after tree change', error);
+    });
+}, _AssetsController_runAccountTreeRefresh = async function _AssetsController_runAccountTreeRefresh(accounts, newAccounts = []) {
+    const releaseLock = await __classPrivateFieldGet(this, _AssetsController_accountRefreshMutex, "f").acquire();
+    try {
+        await this.getAssets(accounts, {
+            chainIds: [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")],
+            forceUpdate: true,
+        });
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeAssets).call(this, { skipInitialFetch: true });
+        if (newAccounts.length > 0) {
+            await this.getAssets(newAccounts, {
+                chainIds: [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")],
+                forceUpdate: true,
+            });
+        }
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_fetchMissingPricesWithoutCache).call(this, accounts, [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")]);
+    }
+    catch (error) {
+        log('Failed to fetch assets after tree change', error);
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeAssets).call(this, { skipInitialFetch: true });
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_fetchMissingPricesWithoutCache).call(this, accounts, [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")]);
+    }
+    finally {
+        releaseLock();
+    }
+}, _AssetsController_runStartupRefresh = 
+/**
+ * Force-fetch balances then subscribe. Used on unlock / first startup.
+ *
+ * @param accounts - Selected accounts to refresh.
+ */
+async function _AssetsController_runStartupRefresh(accounts) {
+    const releaseLock = await __classPrivateFieldGet(this, _AssetsController_accountRefreshMutex, "f").acquire();
+    try {
+        await this.getAssets(accounts, {
+            chainIds: [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")],
+            forceUpdate: true,
+        });
+        // Seed before subscribe so the price poll / update fetch sees natives
+        // and default tracked assets that were never returned by balance APIs.
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_ensureNativeBalancesDefaultZero).call(this);
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_ensureDefaultTrackedAssetsSeeded).call(this);
+        // Balances were just force-fetched — skip AccountsApi's subscribe-time poll.
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeAssets).call(this, { skipInitialFetch: true });
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_fetchMissingPricesWithoutCache).call(this, accounts, [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")]);
+    }
+    catch (error) {
+        log('Failed to fetch assets on startup', error);
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_ensureNativeBalancesDefaultZero).call(this);
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_ensureDefaultTrackedAssetsSeeded).call(this);
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeAssets).call(this, { skipInitialFetch: true });
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_fetchMissingPricesWithoutCache).call(this, accounts, [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")]);
+    }
+    finally {
+        releaseLock();
+    }
+}, _AssetsController_registerActionHandlers = function _AssetsController_registerActionHandlers() {
+    this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+}, _AssetsController_handleActiveChainsUpdate = function _AssetsController_handleActiveChainsUpdate(dataSourceId, activeChains, previousChains) {
+    if (!__classPrivateFieldGet(this, _AssetsController_uiOpen, "f") || !__classPrivateFieldGet(this, _AssetsController_keyringUnlocked, "f") || !__classPrivateFieldGet(this, _AssetsController_isEnabled, "f").call(this)) {
+        return;
+    }
+    log('Data source active chains changed', {
+        dataSourceId,
+        chainCount: activeChains.length,
+        chains: activeChains,
+    });
+    const previous = previousChains;
+    const previousSet = new Set(previous);
+    const addedChains = activeChains.filter((ch) => !previousSet.has(ch));
+    const removedChains = previous.filter((ch) => !activeChains.includes(ch));
+    // Refresh subscriptions to use updated data source availability.
+    if (addedChains.length > 0 || removedChains.length > 0) {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeAssets).call(this);
+    }
+}, _AssetsController_executeMiddlewares = 
+// ============================================================================
+// MIDDLEWARE EXECUTION
+// ============================================================================
+/**
+ * Execute middlewares with request/response context.
+ * Returns response and exclusive duration per source (sum ≈ wall time).
+ *
+ * @param params - Middleware execution options.
+ * @param params.sources - Data sources or middlewares with getName() and assetsMiddleware.
+ * @param params.request - The data request.
+ * @param params.initialResponse - Optional initial response (for enriching existing data).
+ * @param params.parentContext - Optional parent Sentry span; per-source timings nest under it.
+ * @param params.trace - Optional trace callback; omit after unlock/first-init to skip spans.
+ * @returns Response and durationByDataSource (exclusive ms per source name).
+ */
+async function _AssetsController_executeMiddlewares(params) {
+    const { sources, request, initialResponse = {}, parentContext, trace, } = params;
+    const names = sources.map((source) => source.getName());
+    const middlewares = sources.map((source) => source.assetsMiddleware);
+    const inclusive = [];
+    const wrapped = middlewares.map((middleware, i) => (async (ctx, next) => {
+        const start = performance.now();
+        try {
+            return await middleware(ctx, next);
+        }
+        finally {
+            inclusive[i] = performance.now() - start;
+        }
+    }));
+    const middlewareErrors = [];
+    const chain = wrapped.reduceRight((next, middleware, index) => async (ctx) => {
+        try {
+            return await middleware(ctx, next);
+        }
+        catch (error) {
+            const sourceName = names[index] ?? `middleware_${index}`;
+            middlewareErrors.push(sourceName);
+            console.error('[AssetsController] Middleware failed:', error);
+            return next(ctx);
+        }
+    }, async (ctx) => ctx);
+    const result = await chain({
+        request,
+        response: initialResponse,
+        getAssetsState: () => this.state,
+    });
+    const durationByDataSource = {};
+    for (let i = 0; i < inclusive.length; i++) {
+        const nextInc = i + 1 < inclusive.length ? (inclusive[i + 1] ?? 0) : 0;
+        const exclusive = Math.max(0, (inclusive[i] ?? 0) - nextInc);
+        const name = names[i];
+        if (name !== undefined) {
+            durationByDataSource[name] = exclusive;
+        }
+    }
+    if (result.durationByDataSource) {
+        for (const [key, ms] of Object.entries(result.durationByDataSource)) {
+            durationByDataSource[key] = ms;
+        }
+    }
+    // Emit per-source timing as subspans under the parent fetch/update span
+    // (no-op when `trace` is omitted — unlock/first-init only).
+    for (const [sourceName, durationMs] of Object.entries(durationByDataSource)) {
+        (0, trace_js_1.emitTrace)({
+            name: TRACE_DATA_SOURCE_TIMING,
+            trace,
+            data: {
+                source: sourceName,
+                duration_ms: durationMs,
+                chain_count: request.chainIds.length,
+                account_count: request.accountsWithSupportedChains.length,
+            },
+            tags: {
+                controller: 'AssetsController',
+                // String tag so Spans widgets can group by `source`.
+                source: sourceName,
+            },
+            parentContext,
+        });
+    }
+    // Failed middlewares: Issues (optional) + perf/Dashboard spans
+    if (middlewareErrors.length > 0) {
+        const failedSources = middlewareErrors.join(',');
+        const assetsError = new errors_js_1.AssetsDataSourceError({
+            failedSources,
+            errorCount: middlewareErrors.length,
+            chainCount: request.chainIds.length,
+        });
+        try {
+            __classPrivateFieldGet(this, _AssetsController_captureException, "f")?.call(this, assetsError);
+        }
+        catch {
+            // Never let telemetry throw.
+        }
+        (0, trace_js_1.emitTrace)({
+            name: TRACE_DATA_SOURCE_ERROR,
+            trace,
+            data: {
+                failed_sources: failedSources,
+                error_count: middlewareErrors.length,
+                chain_count: request.chainIds.length,
+            },
+            tags: {
+                controller: 'AssetsController',
+                severity: 'error',
+                error_type: assetsError.name,
+            },
+            parentContext,
+        });
+    }
+    return { response: result.response, durationByDataSource };
+}, _AssetsController_assertNonEmptyAccountId = function _AssetsController_assertNonEmptyAccountId(accountId, methodName) {
+    if (typeof accountId !== 'string' || accountId.length === 0) {
+        throw new Error(`AssetsController.${methodName}: accountId must be a non-empty string`);
+    }
+}, _AssetsController_normalizeAssetIdOrThrow = function _AssetsController_normalizeAssetIdOrThrow(assetId, methodName) {
+    try {
+        return (0, index_js_2.normalizeAssetId)(assetId);
+    }
+    catch {
+        throw new Error(`AssetsController.${methodName}: invalid CAIP-19 assetId "${assetId}"`);
+    }
+}, _AssetsController_fetchMissingPricesWithoutCache = function _AssetsController_fetchMissingPricesWithoutCache(accounts, chainIds) {
+    if (!__classPrivateFieldGet(this, _AssetsController_isBasicFunctionality, "f").call(this) || accounts.length === 0) {
+        return;
+    }
+    const accountIds = new Set(accounts.map((account) => account.id));
+    const chainFilter = new Set(chainIds);
+    const assetsForPriceUpdate = [];
+    const prices = this.state.assetsPrice;
+    for (const [accountId, accountBalances] of Object.entries(this.state.assetsBalance)) {
+        if (!accountIds.has(accountId)) {
+            continue;
+        }
+        for (const assetId of Object.keys(accountBalances)) {
+            if (!chainFilter.has(assetId.split('/')[0])) {
+                continue;
+            }
+            const normalizedAssetId = (0, index_js_2.normalizeAssetId)(assetId);
+            if (prices[normalizedAssetId] ?? prices[assetId]) {
+                continue;
+            }
+            if (!(0, PriceDataSource_js_1.isPriceableAsset)(normalizedAssetId)) {
+                continue;
+            }
+            assetsForPriceUpdate.push(normalizedAssetId);
+        }
+    }
+    if (assetsForPriceUpdate.length === 0) {
+        return;
+    }
+    __classPrivateFieldGet(this, _AssetsController_priceDataSource, "f").invalidatePriceCache();
+    this.getAssets(accounts, {
+        forceUpdate: true,
+        dataTypes: ['price'],
+        chainIds,
+        assetsForPriceUpdate,
+    }).catch((error) => {
+        log('Failed to fetch missing prices', { error });
+    });
+}, _AssetsController_getNativeAssetMap = function _AssetsController_getNativeAssetMap() {
+    return (__classPrivateFieldGet(this, _AssetsController_queryApiClient, "f").getCachedData(NATIVE_ASSETS_QUERY_KEY) ?? EMPTY_NATIVE_ASSET_MAP);
+}, _AssetsController_isNativeAsset = function _AssetsController_isNativeAsset(assetId) {
+    const parsed = (0, utils_1.parseCaipAssetType)(assetId);
+    if (parsed.assetNamespace === 'slip44') {
+        return true;
+    }
+    const lower = assetId.toLowerCase();
+    const isInNativeAssetMap = Object.values(__classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getNativeAssetMap).call(this)).some((id) => id.toLowerCase() === lower);
+    if (isInNativeAssetMap) {
+        return true;
+    }
+    if (parsed.assetNamespace === 'erc20' &&
+        parsed.assetReference === constants_js_1.ZERO_ADDRESS) {
+        return true;
+    }
+    return false;
+}, _AssetsController_getAssetType = function _AssetsController_getAssetType(assetId) {
+    const parsed = (0, utils_1.parseCaipAssetType)(assetId);
+    if (__classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_isNativeAsset).call(this, assetId)) {
+        return 'native';
+    }
+    if (parsed.chain.namespace === utils_1.KnownCaipNamespace.Solana &&
+        parsed.assetNamespace === TokenDataSource_js_1.CaipAssetNamespace.Token) {
+        return 'spl';
+    }
+    return 'erc20';
+}, _AssetsController_resolveNativeAssetIds = function _AssetsController_resolveNativeAssetIds(chains) {
+    const nativeAssetMap = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getNativeAssetMap).call(this);
+    const ids = [];
+    for (const chainId of chains) {
+        const nativeId = nativeAssetMap[chainId];
+        if (nativeId) {
+            ids.push(nativeId);
+        }
+    }
+    return ids;
+}, _AssetsController_getNativeAssetIdsForEnabledChains = function _AssetsController_getNativeAssetIdsForEnabledChains() {
+    return __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_resolveNativeAssetIds).call(this, __classPrivateFieldGet(this, _AssetsController_enabledChains, "f"));
+}, _AssetsController_getNativeAssetIdsForAccount = function _AssetsController_getNativeAssetIdsForAccount(account) {
+    return __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_resolveNativeAssetIds).call(this, __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getEnabledChainsForAccount).call(this, account));
+}, _AssetsController_getSlowPipelineChainIds = function _AssetsController_getSlowPipelineChainIds(chainIds, fastResponse) {
+    const accountsApiChains = new Set(__classPrivateFieldGet(this, _AssetsController_accountsApiDataSource, "f").getActiveChainsSync());
+    return chainIds.filter((chainId) => {
+        if (fastResponse.errors?.[chainId]) {
+            return true;
+        }
+        if (!accountsApiChains.has(chainId)) {
+            return true;
+        }
+        return false;
+    });
+}, _AssetsController_ensureNativeBalancesDefaultZero = function _AssetsController_ensureNativeBalancesDefaultZero() {
+    const accounts = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this);
+    if (accounts.length === 0) {
+        return;
+    }
+    this.update((state) => {
+        const balances = state.assetsBalance;
+        for (const account of accounts) {
+            const accountId = account.id;
+            const nativeAssetIds = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getNativeAssetIdsForAccount).call(this, account);
+            if (nativeAssetIds.length === 0) {
+                continue;
+            }
+            if (!balances[accountId]) {
+                balances[accountId] = {};
+            }
+            for (const nativeAssetId of nativeAssetIds) {
+                if (!Object.prototype.hasOwnProperty.call(balances[accountId], nativeAssetId)) {
+                    balances[accountId][nativeAssetId] = { amount: '0' };
+                }
+            }
+        }
+    });
+}, _AssetsController_ensureDefaultTrackedAssetsSeeded = function _AssetsController_ensureDefaultTrackedAssetsSeeded(chainsToSeed) {
+    const accounts = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this);
+    if (accounts.length === 0) {
+        return;
+    }
+    // Default tracked assets are ERC-20s on EVM chains today. Restrict
+    // seeding to accounts that have at least one EVM scope so we don't
+    // pollute non-EVM accounts. The wildcard `eip155:0` scope counts.
+    const evmAccounts = accounts.filter((account) => (account.scopes ?? []).some((scope) => scope.startsWith('eip155:')));
+    if (evmAccounts.length === 0) {
+        return;
+    }
+    // Gate seeding on whether the chain is currently enabled. This is
+    // why mUSD appears on mainnet/Linea immediately (those are normally
+    // enabled at startup) but only appears on Monad once the user
+    // turns the Monad network on.
+    const candidateChains = chainsToSeed ?? [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")];
+    const targetChains = candidateChains.filter((chainId) => defaults_js_1.CHAINS_WITH_DEFAULT_TRACKED_ASSETS.has(chainId));
+    if (targetChains.length === 0) {
+        return;
+    }
+    this.update((state) => {
+        var _a;
+        const balances = state.assetsBalance;
+        const metadata = state.assetsInfo;
+        for (const chainId of targetChains) {
+            const defaultAssetIds = defaults_js_1.DEFAULT_TRACKED_ASSETS_BY_CHAIN.get(chainId) ?? [];
+            for (const assetId of defaultAssetIds) {
+                // Re-seed metadata if state was hydrated from a prior version
+                // that didn't include defaults.
+                if (!metadata[assetId]) {
+                    const seed = (0, defaults_js_1.getDefaultAssetMetadata)(assetId);
+                    if (seed) {
+                        metadata[assetId] = seed;
+                    }
+                }
+                for (const account of evmAccounts) {
+                    balances[_a = account.id] ?? (balances[_a] = {});
+                    const accountBalances = balances[account.id];
+                    accountBalances[assetId] ?? (accountBalances[assetId] = { amount: '0' });
+                }
+            }
+        }
+    });
+}, _AssetsController_updateState = async function _AssetsController_updateState(response) {
+    const normalizedResponse = normalizeResponse(response);
+    const mode = normalizedResponse.updateMode ?? 'merge';
+    const releaseLock = await __classPrivateFieldGet(this, _AssetsController_controllerMutex, "f").acquire();
+    try {
+        const previousState = this.state;
+        const previousPrices = { ...this.state.assetsPrice };
+        // Use detectedAssets from response (assets without metadata)
+        const detectedAssets = normalizedResponse.detectedAssets ?? {};
+        // Track actual changes for logging
+        const changedBalances = [];
+        const changedMetadata = [];
+        this.update((state) => {
+            // Use type assertions to avoid deep type instantiation issues with Immer Draft types
+            const metadata = state.assetsInfo;
+            const balances = state.assetsBalance;
+            const prices = state.assetsPrice;
+            if (normalizedResponse.assetsInfo) {
+                for (const [key, value] of Object.entries(normalizedResponse.assetsInfo)) {
+                    if (!(0, lodash_1.isEqual)(previousState.assetsInfo[key], value)) {
+                        changedMetadata.push(key);
+                    }
+                    const existing = metadata[key];
+                    const incoming = value;
+                    // When the API returns no symbol or name for this token, it has no
+                    // real knowledge of it (e.g. a user-deployed token not indexed by
+                    // the API). Preserve richer metadata already in state (e.g. from
+                    // pendingMetadata set by addCustomAsset) so that the correct
+                    // decimals/symbol/name/image are not overwritten with empty values.
+                    if (existing && !incoming.symbol && !incoming.name) {
+                        metadata[key] = {
+                            ...existing,
+                            ...incoming,
+                            symbol: existing.symbol,
+                            name: existing.name,
+                            decimals: existing.decimals ?? incoming.decimals,
+                            image: existing.image ?? incoming.image,
+                        };
+                    }
+                    else {
+                        metadata[key] = value;
+                    }
+                }
+            }
+            // Reconcile & self-heal stale asset "types" (e.g. erc20 -> native)
+            // using IDs from new response assetInfo and assetBalance
+            const assetsInfoAssetIdsSet = new Set([
+                ...Object.keys(normalizedResponse.assetsInfo ?? {}),
+                ...Object.values(normalizedResponse.assetsBalance ?? {}).flatMap((accountBalances) => Object.keys(accountBalances)),
+            ]);
+            for (const assetId of assetsInfoAssetIdsSet) {
+                const entry = metadata[assetId];
+                if (!entry) {
+                    continue;
+                }
+                const correctType = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getAssetType).call(this, assetId);
+                if (entry.type !== correctType) {
+                    metadata[assetId] = { ...entry, type: correctType };
+                    if (!changedMetadata.includes(assetId)) {
+                        changedMetadata.push(assetId);
+                    }
+                }
+            }
+            if (normalizedResponse.assetsBalance) {
+                for (const [accountId, accountBalances] of Object.entries(normalizedResponse.assetsBalance)) {
+                    const previousBalances = previousState.assetsBalance[accountId] ?? {};
+                    const customAssetIds = state.customAssets[accountId] ?? [];
+                    const replaceCoveredChains = mode === 'full' ||
+                        normalizedResponse.replaceCoveredChainBalances === true;
+                    const effective = mergeAccountBalances(previousBalances, accountBalances, customAssetIds, replaceCoveredChains);
+                    // Ensure native tokens have an entry (0 if missing) for chains this account supports
+                    const account = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this).find((a) => a.id === accountId);
+                    const nativeAssetIdsForAccount = account
+                        ? __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getNativeAssetIdsForAccount).call(this, account)
+                        : __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getNativeAssetIdsForEnabledChains).call(this);
+                    for (const nativeAssetId of nativeAssetIdsForAccount) {
+                        if (!Object.prototype.hasOwnProperty.call(effective, nativeAssetId)) {
+                            effective[nativeAssetId] = { amount: '0' };
+                        }
+                    }
+                    for (const [assetId, balance] of Object.entries(effective)) {
+                        const previousBalance = previousBalances[assetId];
+                        // Coerce amounts (e.g. "1e-18" from a data source stringifying
+                        // a JS Number) into a plain decimal so downstream BigInt()
+                        // consumers don't crash. Decimals are read from the freshest
+                        // merged metadata when available; when metadata is not yet
+                        // known, the amount is left at its natural precision (only
+                        // exponent form is rewritten) so balances arriving before
+                        // their metadata aren't lossily truncated.
+                        const assetDecimals = metadata[assetId]?.decimals;
+                        const newAmount = (0, index_js_2.normalizeAmountString)(balance.amount, assetDecimals);
+                        effective[assetId] = { ...balance, amount: newAmount };
+                        const oldAmount = previousBalance?.amount;
+                        const isNewDefaultNativeZero = oldAmount === undefined &&
+                            newAmount === '0' &&
+                            nativeAssetIdsForAccount.includes(assetId);
+                        if (oldAmount !== newAmount && !isNewDefaultNativeZero) {
+                            changedBalances.push({
+                                accountId,
+                                assetId,
+                                oldAmount,
+                                newAmount,
+                            });
+                        }
+                    }
+                    balances[accountId] = effective;
+                }
+            }
+            if (normalizedResponse.assetsPrice) {
+                for (const [key, value] of Object.entries(normalizedResponse.assetsPrice)) {
+                    prices[key] = value;
+                }
+            }
+        });
+        // Emit state size trace (throttled to avoid JSON.stringify on every update)
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_emitStateSizeTrace).call(this);
+        // Calculate changed prices
+        const changedPriceAssets = normalizedResponse.assetsPrice
+            ? Object.keys(normalizedResponse.assetsPrice).filter((assetId) => !(0, lodash_1.isEqual)(previousPrices[assetId], normalizedResponse.assetsPrice?.[assetId]))
+            : [];
+        // Log only actual changes
+        if (changedBalances.length > 0 ||
+            changedMetadata.length > 0 ||
+            changedPriceAssets.length > 0) {
+            log('State updated', {
+                changedBalances: changedBalances.length > 0 ? changedBalances : undefined,
+                changedMetadataCount: changedMetadata.length > 0 ? changedMetadata.length : undefined,
+                changedPricesCount: changedPriceAssets.length > 0
+                    ? changedPriceAssets.length
+                    : undefined,
+                newAssets: Object.keys(detectedAssets).length > 0
+                    ? Object.entries(detectedAssets).map(([accountId, assets]) => ({
+                        accountId,
+                        assets,
+                    }))
+                    : undefined,
+            });
+        }
+        // Publish balance changed events
+        for (const change of changedBalances) {
+            this.messenger.publish('AssetsController:balanceChanged', {
+                accountId: change.accountId,
+                assetId: change.assetId,
+                previousAmount: change.oldAmount ?? '0',
+                newAmount: change.newAmount,
+            });
+        }
+        // Publish price changed event with full price data
+        if (changedPriceAssets.length > 0 && normalizedResponse.assetsPrice) {
+            // Build prices object with only changed prices
+            const changedPrices = {};
+            for (const assetId of changedPriceAssets) {
+                const price = normalizedResponse.assetsPrice[assetId];
+                if (price) {
+                    changedPrices[assetId] = price;
+                }
+            }
+            this.messenger.publish('AssetsController:priceChanged', {
+                prices: changedPrices,
+            });
+        }
+        // Publish assets detected events
+        for (const [accountId, assetIds] of Object.entries(detectedAssets)) {
+            if (assetIds.length > 0) {
+                this.messenger.publish('AssetsController:assetsDetected', {
+                    accountId,
+                    assetIds,
+                });
+            }
+        }
+    }
+    finally {
+        releaseLock();
+    }
+}, _AssetsController_getAssetsFromState = function _AssetsController_getAssetsFromState(accounts, chainIds, assetTypes) {
+    const result = Object.create(null);
+    // Convert to Sets for O(1) lookups
+    const chainIdSet = new Set(chainIds);
+    const assetTypeSet = new Set(assetTypes);
+    for (const account of accounts) {
+        result[account.id] = Object.create(null);
+        const accountBalances = this.state.assetsBalance[account.id] ?? {};
+        for (const assetId of Object.keys(accountBalances)) {
+            const typedAssetId = assetId;
+            const asset = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getAssetFromState).call(this, account.id, typedAssetId, {
+                chainIdSet,
+                assetTypeSet,
+            });
+            if (asset) {
+                result[account.id][typedAssetId] = asset;
+            }
+        }
+    }
+    return result;
+}, _AssetsController_getAssetFromState = function _AssetsController_getAssetFromState(accountId, assetId, filters) {
+    const balance = this.state.assetsBalance[accountId]?.[assetId];
+    // Skip assets without a balance entry
+    if (!balance) {
+        return undefined;
+    }
+    const metadata = this.state.assetsInfo[assetId];
+    // Skip assets without metadata
+    if (!metadata) {
+        return undefined;
+    }
+    // Skip hidden assets (assetPreferences)
+    const prefs = this.state.assetPreferences[assetId];
+    if (prefs?.hidden) {
+        return undefined;
+    }
+    const assetChainId = extractChainId(assetId);
+    // Skip native tokens on Tempo networks
+    if (__classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_shouldHideNativeToken).call(this, assetChainId, metadata)) {
+        return undefined;
+    }
+    if (filters?.chainIdSet && !filters.chainIdSet.has(assetChainId)) {
+        return undefined;
+    }
+    // Filter by asset type
+    if (filters?.assetTypeSet) {
+        const tokenAssetType = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_tokenStandardToAssetType).call(this, metadata.type);
+        if (!filters.assetTypeSet.has(tokenAssetType)) {
+            return undefined;
+        }
+    }
+    const priceRaw = this.state.assetsPrice[assetId];
+    const price = priceRaw ?? {
+        price: 0,
+        lastUpdated: 0,
+    };
+    // Compute fiat value using BigNumber for precision
+    // Note: balance.amount is already in human-readable format (e.g., "1" for 1 ETH)
+    // so we do NOT divide by 10^decimals here
+    const balanceAmount = new bignumber_js_1.default(balance.amount || '0');
+    const fiatValue = balanceAmount.multipliedBy(price.price || 0).toNumber();
+    return {
+        id: assetId,
+        chainId: assetChainId,
+        balance,
+        metadata,
+        price,
+        fiatValue,
+    };
+}, _AssetsController_shouldHideNativeToken = function _AssetsController_shouldHideNativeToken(chainId, metadata) {
+    // Check if it's a chain that should skip native tokens
+    if (!(0, assets_js_1.shouldSkipNativeForCaipChainId)(chainId)) {
+        return false;
+    }
+    return metadata.type === 'native';
+}, _AssetsController_tokenStandardToAssetType = function _AssetsController_tokenStandardToAssetType(tokenStandard) {
+    switch (tokenStandard) {
+        case 'native':
+        case 'erc20':
+        case 'spl':
+            return 'fungible';
+        case 'erc721':
+            return 'nft';
+        case 'erc1155':
+            // ERC1155 can be either fungible or non-fungible, treat as collectible
+            return 'collectible';
+        default:
+            // Unknown standards default to fungible
+            return 'fungible';
+    }
+}, _AssetsController_start = function _AssetsController_start() {
+    const accounts = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this);
+    const chainIds = [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")];
+    if (accounts.length === 0 || chainIds.length === 0) {
+        return;
+    }
+    if (__classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").size > 0) {
+        return;
+    }
+    log('Starting asset tracking', {
+        selectedAccountCount: accounts.length,
+        enabledChainCount: chainIds.length,
+    });
+    __classPrivateFieldSet(this, _AssetsController_lastKnownAccountIds, new Set(accounts.map((a) => a.id)), "f");
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_runStartupRefresh).call(this, accounts).catch((error) => {
+        log('Failed to start asset tracking', error);
+    });
+}, _AssetsController_stop = function _AssetsController_stop() {
+    log('Stopping asset tracking', {
+        activeSubscriptionCount: __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").size,
+        hasPriceSubscription: __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").has('ds:PriceDataSource'),
+    });
+    __classPrivateFieldSet(this, _AssetsController_firstInitFetchReported, false, "f");
+    __classPrivateFieldSet(this, _AssetsController_stateSizeReported, false, "f");
+    __classPrivateFieldSet(this, _AssetsController_lastKnownAccountIds, new Set(), "f");
+    // Stop price subscription first (uses direct messenger call)
+    this.unsubscribeAssetsPrice();
+    // Stop balance subscriptions by properly notifying data sources via messenger
+    // This ensures data sources stop their polling timers.
+    // Use #allBalanceDataSources + staked balance source so we unsubscribe from
+    // every source that may have been subscribed.
+    const allSources = [
+        ...__classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_allBalanceDataSources_get),
+        __classPrivateFieldGet(this, _AssetsController_stakedBalanceDataSource, "f"),
+    ];
+    const subscriptionKeys = [...__classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").keys()];
+    for (const subscriptionKey of subscriptionKeys) {
+        if (!subscriptionKey.startsWith('ds:')) {
+            continue;
+        }
+        // Subscription keys take the form `ds:<SourceName>` for the regular
+        // subscription or `ds:<SourceName>:<suffix>` for supplemental
+        // subscriptions (e.g. `ds:RpcDataSource:custom`). Split on `:` and
+        // pick the source-name segment so both shapes resolve correctly.
+        const [, sourceId] = subscriptionKey.split(':');
+        const source = allSources.find((ds) => ds.getName() === sourceId);
+        if (source) {
+            // Unsubscribe by the actual key — `#unsubscribeDataSource` only
+            // knows the regular `ds:<SourceName>` shape and would miss
+            // supplemental subscriptions, leaking their polling timers.
+            __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_unsubscribeBySubscriptionKey).call(this, source, subscriptionKey);
+        }
+    }
+    __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").clear();
+}, _AssetsController_subscribeAssets = function _AssetsController_subscribeAssets(options) {
+    const accounts = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this);
+    const enabledChains = [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")];
+    if (accounts.length === 0 || enabledChains.length === 0) {
+        return;
+    }
+    // Subscribe to balance updates (batched by data source)
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeAssetsBalance).call(this, accounts, enabledChains, options);
+    // Subscribe to staked balance updates (separate from regular balance chain-claiming)
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeStakedBalance).call(this, accounts, enabledChains);
+    // Subscribe to price updates for all assets held by selected accounts
+    this.subscribeAssetsPrice(accounts, enabledChains);
+}, _AssetsController_subscribeAssetsBalance = function _AssetsController_subscribeAssetsBalance(accounts, chainIds, options) {
+    const chainToAccounts = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_buildChainToAccountsMap).call(this, accounts, new Set(chainIds));
+    const remainingChains = new Set(chainToAccounts.keys());
+    // When basic functionality is on, use all balance data sources; when off,
+    // RPC only.
+    const isBasicFunctionality = __classPrivateFieldGet(this, _AssetsController_isBasicFunctionality, "f").call(this);
+    const balanceDataSources = isBasicFunctionality
+        ? __classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_allBalanceDataSources_get)
+        : [__classPrivateFieldGet(this, _AssetsController_rpcDataSource, "f")];
+    let rpcAssignedChains = new Set();
+    for (const source of balanceDataSources) {
+        const availableChains = new Set(source.getActiveChainsSync());
+        const assignedChains = [];
+        for (const chainId of remainingChains) {
+            if (availableChains.has(chainId)) {
+                assignedChains.push(chainId);
+                remainingChains.delete(chainId);
+            }
+        }
+        if (assignedChains.length === 0) {
+            __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_unsubscribeDataSource).call(this, source);
+            continue;
+        }
+        if (source === __classPrivateFieldGet(this, _AssetsController_rpcDataSource, "f")) {
+            rpcAssignedChains = new Set(assignedChains);
+        }
+        const seenIds = new Set();
+        const accountsForSource = assignedChains
+            .flatMap((chainId) => chainToAccounts.get(chainId) ?? [])
+            .filter((account) => {
+            if (seenIds.has(account.id)) {
+                return false;
+            }
+            seenIds.add(account.id);
+            return true;
+        });
+        if (accountsForSource.length > 0) {
+            __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeDataSource).call(this, source, accountsForSource, assignedChains, {
+                ...(options?.skipInitialFetch &&
+                    source === __classPrivateFieldGet(this, _AssetsController_accountsApiDataSource, "f")
+                    ? { skipInitialFetch: true }
+                    : {}),
+            });
+        }
+    }
+    // Supplemental RPC subscription for customAssets on chains another data
+    // source claimed during regular handoff. RPC is the sole balance fetcher
+    // for customAssets, so we must always poll them — even when (e.g.)
+    // AccountsApi is already covering the chain for normal balances. The
+    // supplemental subscription runs in `customAssetsOnly` mode so it does
+    // NOT double-poll the regular tracked balances.
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeRpcCustomAssetsSupplement).call(this, accounts, chainToAccounts, rpcAssignedChains);
+}, _AssetsController_subscribeRpcCustomAssetsSupplement = function _AssetsController_subscribeRpcCustomAssetsSupplement(accounts, chainToAccounts, rpcAssignedChains) {
+    const rpc = __classPrivateFieldGet(this, _AssetsController_rpcDataSource, "f");
+    const supplementalKey = `ds:${rpc.getName()}:custom`;
+    const decision = (0, customAssetsRpcSupplement_js_1.pickRpcCustomAssetsSupplement)({
+        accountIds: accounts.map((account) => account.id),
+        customAssetsByAccount: this.state.customAssets,
+        rpcAssignedChains,
+        rpcAvailableChains: new Set(rpc.getActiveChainsSync()),
+        enabledChains: new Set(chainToAccounts.keys()),
+    });
+    if (decision.chains.length === 0) {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_unsubscribeBySubscriptionKey).call(this, rpc, supplementalKey);
+        return;
+    }
+    const supplementalAccounts = accounts.filter((account) => decision.accountIds.has(account.id));
+    if (supplementalAccounts.length === 0) {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_unsubscribeBySubscriptionKey).call(this, rpc, supplementalKey);
+        return;
+    }
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeDataSource).call(this, rpc, supplementalAccounts, decision.chains, {
+        subscriptionKey: supplementalKey,
+        customAssetsOnly: true,
+    });
+}, _AssetsController_unsubscribeBySubscriptionKey = function _AssetsController_unsubscribeBySubscriptionKey(source, subscriptionKey) {
+    const existingSubscription = __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").get(subscriptionKey);
+    if (existingSubscription) {
+        source.unsubscribe(subscriptionKey).catch(() => undefined);
+        existingSubscription.unsubscribe();
+    }
+}, _AssetsController_subscribeStakedBalance = function _AssetsController_subscribeStakedBalance(accounts, chainIds) {
+    const source = __classPrivateFieldGet(this, _AssetsController_stakedBalanceDataSource, "f");
+    if (!source) {
+        return;
+    }
+    const availableChains = new Set(source.getActiveChainsSync());
+    const assignedChains = chainIds.filter((chainId) => availableChains.has(chainId));
+    if (assignedChains.length === 0) {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_unsubscribeDataSource).call(this, source);
+        return;
+    }
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeDataSource).call(this, source, accounts, assignedChains);
+}, _AssetsController_buildChainToAccountsMap = function _AssetsController_buildChainToAccountsMap(accounts, chainsToSubscribe) {
+    const chainToAccounts = new Map();
+    for (const account of accounts) {
+        for (const chainId of __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getEnabledChainsForAccount).call(this, account)) {
+            if (!chainsToSubscribe.has(chainId)) {
+                continue;
+            }
+            let list = chainToAccounts.get(chainId);
+            if (!list) {
+                list = [];
+                chainToAccounts.set(chainId, list);
+            }
+            list.push(account);
+        }
+    }
+    return chainToAccounts;
+}, _AssetsController_subscribeDataSource = function _AssetsController_subscribeDataSource(source, accounts, chains, options = {}) {
+    const sourceId = source.getName();
+    const subscriptionKey = options.subscriptionKey ?? `ds:${sourceId}`;
+    const existingSubscription = __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").get(subscriptionKey);
+    const isUpdate = existingSubscription !== undefined;
+    log('Subscribe to data source', {
+        sourceId,
+        subscriptionKey,
+        isUpdate,
+        accountCount: accounts.length,
+        chainCount: chains.length,
+        customAssetsOnly: options.customAssetsOnly === true,
+        skipInitialFetch: options.skipInitialFetch === true,
+    });
+    const subscribeReq = {
+        request: __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_buildDataRequest).call(this, accounts, chains, {
+            assetTypes: ['fungible'],
+            dataTypes: ['balance'],
+            updateInterval: __classPrivateFieldGet(this, _AssetsController_defaultUpdateInterval, "f"),
+            ...(options.customAssetsOnly === true
+                ? { customAssetsOnly: true }
+                : {}),
+        }),
+        subscriptionId: subscriptionKey,
+        isUpdate,
+        onAssetsUpdate: (response, request) => this.handleAssetsUpdate(response, sourceId, request),
+        getAssetsState: () => this.state,
+        ...(options.skipInitialFetch === true ? { skipInitialFetch: true } : {}),
+    };
+    source.subscribe(subscribeReq).catch((error) => {
+        console.error(`[AssetsController] Failed to subscribe to '${sourceId}':`, error);
+        (0, trace_js_1.emitTrace)({
+            name: TRACE_SUBSCRIPTION_ERROR,
+            trace: __classPrivateFieldGet(this, _AssetsController_trace, "f"),
+            data: {
+                source: sourceId,
+                error_message: String(error),
+            },
+        });
+    });
+    // Track subscription
+    const subscription = {
+        chains,
+        accountId: subscriptionKey,
+        assetTypes: ['fungible'],
+        dataTypes: ['balance'],
+        unsubscribe: () => {
+            __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").delete(subscriptionKey);
+        },
+    };
+    __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").set(subscriptionKey, subscription);
+}, _AssetsController_unsubscribeDataSource = function _AssetsController_unsubscribeDataSource(source) {
+    const subscriptionKey = `ds:${source.getName()}`;
+    const existingSubscription = __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").get(subscriptionKey);
+    if (existingSubscription) {
+        source.unsubscribe(subscriptionKey).catch(() => undefined);
+        existingSubscription.unsubscribe();
+    }
+}, _AssetsController_buildDataRequest = function _AssetsController_buildDataRequest(accounts, chainIds, partial = {}) {
+    const chainIdSet = new Set(chainIds);
+    // Force update will pass in additional chains for wildcard account scope
+    // Enables updates for chains that are not selected (e.g. for unapproved transactions)
+    const forceUpdateChains = partial.forceUpdate ? chainIds : undefined;
+    const accountsWithSupportedChains = accounts.map((account) => ({
+        account,
+        supportedChains: __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getEnabledChainsForAccount).call(this, account, forceUpdateChains).filter((chain) => chainIdSet.has(chain)),
+    }));
+    return {
+        accountsWithSupportedChains,
+        chainIds,
+        ...partial,
+    };
+}, _AssetsController_getEnabledChainsForAccount = function _AssetsController_getEnabledChainsForAccount(account, additionalChains) {
+    // Account scopes are CAIP-2 chain IDs like "eip155:1", "solana:mainnet", "bip122:..."
+    const scopes = account.scopes ?? [];
+    const result = [];
+    for (const scope of scopes) {
+        const scopeStr = scope;
+        if (!(0, utils_1.isCaipChainId)(scopeStr)) {
+            result.push(scope);
+            continue;
+        }
+        const { namespace, reference } = (0, utils_1.parseCaipChainId)(scopeStr);
+        // Wildcard scope (e.g., "eip155:0" means all enabled chains in that namespace)
+        if (reference === '0') {
+            // Add enabled chains
+            for (const chain of __classPrivateFieldGet(this, _AssetsController_enabledChains, "f")) {
+                if ((0, utils_1.isCaipChainId)(chain)) {
+                    const chainParsed = (0, utils_1.parseCaipChainId)(chain);
+                    if (chainParsed.namespace === namespace) {
+                        result.push(chain);
+                    }
+                }
+            }
+            // Add additional chains
+            for (const chain of additionalChains ?? []) {
+                if ((0, utils_1.isCaipChainId)(chain)) {
+                    const chainParsed = (0, utils_1.parseCaipChainId)(chain);
+                    if (chainParsed.namespace === namespace) {
+                        result.push(chain);
+                    }
+                }
+            }
+        }
+        else if (namespace === 'eip155' && (0, utils_1.isStrictHexString)(reference)) {
+            // Normalize hex to decimal for EIP155
+            result.push(`eip155:${parseInt(reference, 16)}`);
+        }
+        else {
+            result.push(scope);
+        }
+    }
+    return result;
+}, _AssetsController_handleAccountGroupChanged = 
+// ============================================================================
+// EVENT HANDLERS
+// ============================================================================
+async function _AssetsController_handleAccountGroupChanged(groupId, previousGroupId = '') {
+    // The selected account group can be empty during onboarding or wallet reset.
+    if (!groupId) {
+        return;
+    }
+    // First start is owned by `AccountTreeController:initialized` / `#start`.
+    // ATC also re-publishes `selectedAccountGroupChange` on every `init()`
+    // (including when the group did not change) so late subscribers can catch
+    // up — ignore those until we are already tracking.
+    if (__classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").size === 0) {
+        return;
+    }
+    if (groupId === previousGroupId) {
+        return;
+    }
+    const accounts = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this);
+    log('Account group changed', {
+        accountCount: accounts.length,
+        accountIds: accounts.map((a) => a.id),
+        groupId,
+        previousGroupId,
+    });
+    __classPrivateFieldSet(this, _AssetsController_lastKnownAccountIds, new Set(accounts.map((a) => a.id)), "f");
+    const releaseLock = await __classPrivateFieldGet(this, _AssetsController_accountRefreshMutex, "f").acquire();
+    try {
+        if (accounts.length > 0) {
+            await this.getAssets(accounts, {
+                chainIds: [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")],
+                forceUpdate: true,
+            });
+        }
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_ensureNativeBalancesDefaultZero).call(this);
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_ensureDefaultTrackedAssetsSeeded).call(this);
+        // Subscribe after seed so the price poll sees natives / defaults.
+        // Balances were just force-fetched — skip AccountsApi's subscribe-time poll.
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeAssets).call(this, { skipInitialFetch: true });
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_fetchMissingPricesWithoutCache).call(this, accounts, [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")]);
+    }
+    finally {
+        releaseLock();
+    }
+}, _AssetsController_handleEnabledNetworksChanged = async function _AssetsController_handleEnabledNetworksChanged(enabledNetworkMap) {
+    const previousChains = __classPrivateFieldGet(this, _AssetsController_enabledChains, "f");
+    __classPrivateFieldSet(this, _AssetsController_enabledChains, __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_extractEnabledChains).call(this, enabledNetworkMap), "f");
+    // Find newly enabled chains (in new set but not in previous)
+    const addedChains = [];
+    for (const chain of __classPrivateFieldGet(this, _AssetsController_enabledChains, "f")) {
+        if (!previousChains.has(chain)) {
+            addedChains.push(chain);
+        }
+    }
+    // Find disabled chains to clean up (in previous but not in new)
+    const removedChains = [];
+    for (const chain of previousChains) {
+        if (!__classPrivateFieldGet(this, _AssetsController_enabledChains, "f").has(chain)) {
+            removedChains.push(chain);
+        }
+    }
+    log('Enabled networks changed', {
+        previousCount: previousChains.size,
+        newCount: __classPrivateFieldGet(this, _AssetsController_enabledChains, "f").size,
+        addedChains,
+        removedChains,
+    });
+    // Note: We intentionally do NOT delete balance data for disabled chains.
+    // Users may want to see historical balances even if the network is currently disabled.
+    // The data will simply not be updated until the network is re-enabled.
+    // Refresh subscriptions for new chain set
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeAssets).call(this);
+    // Do one-time fetch for newly enabled chains; merge so we keep existing chain balances
+    const accounts = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this);
+    if (addedChains.length > 0 && accounts.length > 0) {
+        await this.getAssets(accounts, {
+            chainIds: addedChains,
+            forceUpdate: true,
+            updateMode: 'merge',
+        });
+    }
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_ensureNativeBalancesDefaultZero).call(this);
+    // Seed default tracked assets (mUSD) for any chain the user has
+    // *just* enabled. This is what makes mUSD appear on Monad after
+    // the user finally adds it to NetworkEnablementController.
+    if (addedChains.length > 0) {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_ensureDefaultTrackedAssetsSeeded).call(this, addedChains);
+    }
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_fetchMissingPricesWithoutCache).call(this, accounts, [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")]);
+}, _AssetsController_handleNetworkAdded = function _AssetsController_handleNetworkAdded(hexChainId) {
+    let caipChainId;
+    try {
+        caipChainId = `eip155:${parseInt(hexChainId, 16)}`;
+    }
+    catch {
+        return;
+    }
+    if (!defaults_js_1.CHAINS_WITH_DEFAULT_TRACKED_ASSETS.has(caipChainId)) {
+        return;
+    }
+    log('Network added — seeding default tracked assets', {
+        hexChainId,
+        caipChainId,
+    });
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_ensureDefaultTrackedAssetsSeeded).call(this, [caipChainId]);
+    const accounts = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this);
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_fetchMissingPricesWithoutCache).call(this, accounts, [caipChainId]);
+}, _AssetsController_refreshActiveChainsOnNetworkSwitch = 
+/**
+ * Refresh data-source `activeChains` after an EVM network switch so API/Rpc
+ * chain claiming is not stuck on an empty or stale init-time list.
+ */
+async function _AssetsController_refreshActiveChainsOnNetworkSwitch() {
+    await __classPrivateFieldGet(this, _AssetsController_accountsApiDataSource, "f").refreshActiveChains();
+    __classPrivateFieldGet(this, _AssetsController_rpcDataSource, "f").refreshActiveChainsFromNetworkState();
+}, _AssetsController_getSelectedEvmChainIdFromNetworkState = function _AssetsController_getSelectedEvmChainIdFromNetworkState(networkState) {
+    try {
+        const networkClient = this.messenger.call('NetworkController:getNetworkClientById', networkState.selectedNetworkClientId);
+        const hexChainId = networkClient.configuration?.chainId;
+        if (!hexChainId) {
+            return undefined;
+        }
+        return `eip155:${parseInt(hexChainId, 16)}`;
+    }
+    catch {
+        return undefined;
+    }
+}, _AssetsController_handleNetworkDidChange = 
+/**
+ * Refresh subscriptions and fetch balances when the user switches the
+ * selected EVM network in the UI (`NetworkController:networkDidChange`).
+ *
+ * @param networkState - NetworkController state after the switch.
+ */
+async function _AssetsController_handleNetworkDidChange(networkState) {
+    if (!__classPrivateFieldGet(this, _AssetsController_uiOpen, "f") || !__classPrivateFieldGet(this, _AssetsController_keyringUnlocked, "f") || !__classPrivateFieldGet(this, _AssetsController_isEnabled, "f").call(this)) {
+        return;
+    }
+    const accounts = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this);
+    if (accounts.length === 0) {
+        return;
+    }
+    const selectedChainId = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedEvmChainIdFromNetworkState).call(this, networkState);
+    if (!selectedChainId) {
+        return;
+    }
+    log('Selected EVM network switched', {
+        selectedNetworkClientId: networkState.selectedNetworkClientId,
+        selectedChainId,
+    });
+    const releaseLock = await __classPrivateFieldGet(this, _AssetsController_accountRefreshMutex, "f").acquire();
+    try {
+        await __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_refreshActiveChainsOnNetworkSwitch).call(this);
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeAssets).call(this);
+        await this.getAssets(accounts, {
+            chainIds: [selectedChainId],
+            forceUpdate: true,
+            dataTypes: ['balance', 'metadata', 'price'],
+        });
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_ensureNativeBalancesDefaultZero).call(this);
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_fetchMissingPricesWithoutCache).call(this, accounts, [selectedChainId]);
+    }
+    finally {
+        releaseLock();
+    }
+}, _AssetsController_refreshAssetsAfterNetworkChange = function _AssetsController_refreshAssetsAfterNetworkChange() {
+    const accounts = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this);
+    if (accounts.length === 0) {
+        return;
+    }
+    this.getAssets(accounts, {
+        forceUpdate: true,
+        dataTypes: ['balance', 'metadata'],
+    }).catch((error) => {
+        log('Failed to refresh assets after network change', { error });
+    });
+}, _AssetsController_refreshAssetsAfterNetworkAdded = 
+/**
+ * Refresh balances and fetch missing prices after a network is added.
+ *
+ * @param hexChainId - Hex chain id of the newly-added network.
+ */
+async function _AssetsController_refreshAssetsAfterNetworkAdded(hexChainId) {
+    const accounts = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getSelectedAccounts).call(this);
+    if (accounts.length === 0) {
+        return;
+    }
+    let caipChainId;
+    try {
+        caipChainId = `eip155:${parseInt(hexChainId, 16)}`;
+    }
+    catch {
+        return;
+    }
+    await this.getAssets(accounts, {
+        chainIds: [caipChainId],
+        forceUpdate: true,
+        dataTypes: ['balance', 'metadata', 'price'],
+    });
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_ensureNativeBalancesDefaultZero).call(this);
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_fetchMissingPricesWithoutCache).call(this, accounts, [caipChainId]);
+};
+//# sourceMappingURL=AssetsController.cjs.map