@metamask-previews/assets-controller 0.0.0-preview-903db2da → 0.0.0-preview-3ec2a74

package/dist/AssetsController.cjs

@@ -1,89 +1,1056 @@
 "use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _AssetsController_instances, _AssetsController_defaultUpdateInterval, _AssetsController_controllerMutex, _AssetsController_activeSubscriptions, _AssetsController_enabledChains, _AssetsController_selectedAccounts_get, _AssetsController_assetsPrice, _AssetsController_dataSources, _AssetsController_initializeState, _AssetsController_extractEnabledChains, _AssetsController_normalizeChainReference, _AssetsController_subscribeToEvents, _AssetsController_registerActionHandlers, _AssetsController_executeMiddlewares, _AssetsController_assignChainsToDataSources, _AssetsController_updateState, _AssetsController_getAssetsFromState, _AssetsController_tokenStandardToAssetType, _AssetsController_start, _AssetsController_stop, _AssetsController_subscribeToDataSources, _AssetsController_subscribeAssetsBalance, _AssetsController_buildChainToAccountsMap, _AssetsController_getAccountsForChains, _AssetsController_subscribeToDataSource, _AssetsController_unsubscribeDataSource, _AssetsController_getEnabledChainsForAccount, _AssetsController_handleAccountGroupChanged, _AssetsController_handleEnabledNetworksChanged, _AssetsController_handleSubscriptionUpdate;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssetsController = exports.getDefaultAssetsControllerState = exports.controllerName = void 0;
+exports.AssetsController = exports.getDefaultAssetsControllerState = void 0;
 const base_controller_1 = require("@metamask/base-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 logger_1 = require("./logger.cjs");
+const utils_2 = require("./utils.cjs");
+// ============================================================================
+// CONTROLLER CONSTANTS
+// ============================================================================
+const CONTROLLER_NAME = 'AssetsController';
+/** Default polling interval hint for data sources (30 seconds) */
+const DEFAULT_POLLING_INTERVAL_MS = 30000;
+const log = (0, logger_1.createModuleLogger)(logger_1.projectLogger, CONTROLLER_NAME);
 /**
- * The name of the {@link AssetsController}, used to namespace the
- * controller's actions and events and to namespace the controller's state data
- * when composed with other controllers.
- */
-exports.controllerName = 'AssetsController';
-/**
- * The metadata for each property in {@link AssetsControllerState}.
- */
-const assetsControllerMetadata = {};
-/**
- * Constructs the default {@link AssetsController} state. This allows
- * consumers to provide a partial state object when initializing the controller
- * and also helps in constructing complete state objects for this controller in
- * tests.
+ * Returns the default state for AssetsController.
  *
- * @returns The default {@link AssetsController} state.
+ * @returns The default AssetsController state with empty metadata, balance, and customAssets maps.
  */
 function getDefaultAssetsControllerState() {
-    return {};
+    return {
+        assetsMetadata: {},
+        assetsBalance: {},
+        customAssets: {},
+    };
 }
 exports.getDefaultAssetsControllerState = getDefaultAssetsControllerState;
+// ============================================================================
+// STATE METADATA
+// ============================================================================
+const stateMetadata = {
+    assetsMetadata: {
+        persist: true,
+        includeInStateLogs: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    assetsBalance: {
+        persist: true,
+        includeInStateLogs: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    customAssets: {
+        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.assetsMetadata) {
+        normalized.assetsMetadata = {};
+        for (const [assetId, metadata] of Object.entries(response.assetsMetadata)) {
+            const normalizedId = (0, utils_2.normalizeAssetId)(assetId);
+            normalized.assetsMetadata[normalizedId] = metadata;
+        }
+    }
+    if (response.assetsPrice) {
+        normalized.assetsPrice = {};
+        for (const [assetId, price] of Object.entries(response.assetsPrice)) {
+            const normalizedId = (0, utils_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, utils_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, utils_2.normalizeAssetId)(assetId));
+        }
+    }
+    // Preserve errors (chain IDs don't need normalization)
+    if (response.errors) {
+        normalized.errors = { ...response.errors };
+    }
+    return normalized;
+}
+// ============================================================================
+// CONTROLLER IMPLEMENTATION
+// ============================================================================
 /**
- * `AssetsController` manages asset tracking for accounts.
+ * 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.
  *
- * This controller is a placeholder for future consolidation of asset tracking
- * functionality including account balances, token balances, and asset detection.
+ * 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.
  *
- * @example
+ * 4. **App Lifecycle Management**: Listens to app open/close events via messenger
+ *    to start/stop subscriptions automatically, conserving resources when app is closed.
  *
- * ``` ts
- * import { Messenger } from '@metamask/messenger';
- * import type {
- *   AssetsControllerActions,
- *   AssetsControllerEvents,
- * } from '@metamask/assets-controller';
- * import { AssetsController } from '@metamask/assets-controller';
+ * ## App Lifecycle
  *
- * const rootMessenger = new Messenger<
- *   'Root',
- *   AssetsControllerActions,
- *   AssetsControllerEvents
- * >({ namespace: 'Root' });
- * const assetsControllerMessenger = new Messenger<
- *   'AssetsController',
- *   AssetsControllerActions,
- *   AssetsControllerEvents,
- *   typeof rootMessenger,
- * >({
- *   namespace: 'AssetsController',
- *   parent: rootMessenger,
- * });
- * // Instantiate the controller to register its actions on the messenger
- * new AssetsController({
- *   messenger: assetsControllerMessenger,
- * });
+ * - **App Opened** (`AppStateController:appOpened`): Starts subscriptions, fetches initial data
+ * - **App Closed** (`AppStateController:appClosed`): Stops all subscriptions to conserve resources
  *
- * const assetsControllerState = await rootMessenger.call(
- *   'AssetsController:getState',
- * );
- * ```
+ * ## 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 {
-    /**
-     * Constructs a new {@link AssetsController}.
-     *
-     * @param args - The arguments to this controller.
-     * @param args.messenger - The messenger suited for this controller.
-     * @param args.state - The desired state with which to initialize this
-     * controller. Missing properties will be filled in with defaults.
-     */
-    constructor({ messenger, state, }) {
+    constructor({ messenger, state = {}, defaultUpdateInterval = DEFAULT_POLLING_INTERVAL_MS, }) {
         super({
+            name: CONTROLLER_NAME,
             messenger,
-            metadata: assetsControllerMetadata,
-            name: exports.controllerName,
+            metadata: stateMetadata,
             state: {
                 ...getDefaultAssetsControllerState(),
                 ...state,
             },
         });
+        _AssetsController_instances.add(this);
+        /** Default update interval hint passed to data sources */
+        _AssetsController_defaultUpdateInterval.set(this, void 0);
+        _AssetsController_controllerMutex.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());
+        /** Price data for assets (in-memory only, not persisted) */
+        _AssetsController_assetsPrice.set(this, {});
+        /**
+         * Registered data sources with their available chains.
+         * Updated continuously and independently from subscription flows.
+         * Key: sourceId, Value: Set of currently available chainIds
+         */
+        _AssetsController_dataSources.set(this, new Map());
+        __classPrivateFieldSet(this, _AssetsController_defaultUpdateInterval, defaultUpdateInterval, "f");
+        log('Initializing AssetsController', {
+            defaultUpdateInterval,
+        });
+        __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);
+        // Register data sources (order = subscription priority)
+        this.registerDataSources([
+            'BackendWebsocketDataSource', // Real-time push updates
+            'AccountsApiDataSource', // HTTP polling fallback
+            'SnapDataSource', // Solana/Bitcoin/Tron snaps
+            'RpcDataSource', // Direct blockchain queries
+        ]);
+    }
+    // ============================================================================
+    // DATA SOURCE MANAGEMENT
+    // ============================================================================
+    /**
+     * Register data sources with the controller.
+     * Order of the array determines subscription order.
+     *
+     * Data sources report chain changes by calling `AssetsController:activeChainsUpdate` action.
+     *
+     * @param dataSourceIds - Array of data source identifiers to register.
+     */
+    registerDataSources(dataSourceIds) {
+        for (const id of dataSourceIds) {
+            log('Registering data source', { id });
+            // Initialize available chains tracking for this source
+            __classPrivateFieldGet(this, _AssetsController_dataSources, "f").set(id, new Set());
+        }
+    }
+    // ============================================================================
+    // DATA SOURCE CHAIN MANAGEMENT
+    // ============================================================================
+    /**
+     * Handle when a data source's active chains change.
+     * Active chains are chains that are both supported AND available.
+     * Updates centralized chain tracking and triggers re-selection if needed.
+     *
+     * Data sources should call this via `AssetsController:activeChainsUpdate` action.
+     *
+     * @param dataSourceId - The identifier of the data source reporting the change.
+     * @param activeChains - Array of currently active chain IDs for this source.
+     */
+    handleActiveChainsUpdate(dataSourceId, activeChains) {
+        log('Data source active chains changed', {
+            dataSourceId,
+            chainCount: activeChains.length,
+            chains: activeChains,
+        });
+        const previousChains = __classPrivateFieldGet(this, _AssetsController_dataSources, "f").get(dataSourceId) ?? new Set();
+        const newChains = new Set(activeChains);
+        // Update centralized available chains tracking
+        __classPrivateFieldGet(this, _AssetsController_dataSources, "f").set(dataSourceId, newChains);
+        // Check for changes
+        const addedChains = activeChains.filter((chain) => !previousChains.has(chain));
+        const removedChains = Array.from(previousChains).filter((chain) => !newChains.has(chain));
+        if (addedChains.length > 0 || removedChains.length > 0) {
+            // Refresh subscriptions to use updated data source availability
+            __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeToDataSources).call(this);
+        }
+        // If chains were added and we have selected accounts, do one-time fetch
+        if (addedChains.length > 0 && __classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_selectedAccounts_get).length > 0) {
+            const addedEnabledChains = addedChains.filter((chain) => __classPrivateFieldGet(this, _AssetsController_enabledChains, "f").has(chain));
+            if (addedEnabledChains.length > 0) {
+                log('Fetching balances for newly added chains', { addedEnabledChains });
+                this.getAssets(__classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_selectedAccounts_get), {
+                    chainIds: addedEnabledChains,
+                    forceUpdate: true,
+                }).catch((error) => {
+                    log('Failed to fetch balance for added chains', { error });
+                });
+            }
+        }
+    }
+    // ============================================================================
+    // 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'];
+        // 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) {
+            const response = await __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_executeMiddlewares).call(this, [
+                this.messenger.call('AccountsApiDataSource:getAssetsMiddleware'),
+                this.messenger.call('SnapDataSource:getAssetsMiddleware'),
+                this.messenger.call('RpcDataSource:getAssetsMiddleware'),
+                this.messenger.call('DetectionMiddleware:getAssetsMiddleware'),
+                this.messenger.call('TokenDataSource:getAssetsMiddleware'),
+                this.messenger.call('PriceDataSource:getAssetsMiddleware'),
+            ], {
+                accounts,
+                chainIds,
+                assetTypes,
+                dataTypes,
+                customAssets: customAssets.length > 0 ? customAssets : undefined,
+                forceUpdate: true,
+            });
+            await __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_updateState).call(this, response);
+        }
+        return __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getAssetsFromState).call(this, accounts, chainIds, assetTypes);
+    }
+    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.assetsMetadata[assetId];
+    }
+    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;
+    }
+    // ============================================================================
+    // CUSTOM ASSETS MANAGEMENT
+    // ============================================================================
+    /**
+     * Add a custom asset for an account.
+     * Custom assets are included in subscription and fetch operations.
+     *
+     * @param accountId - The account ID to add the custom asset for.
+     * @param assetId - The CAIP-19 asset ID to add.
+     */
+    async addCustomAsset(accountId, assetId) {
+        const normalizedAssetId = (0, utils_2.normalizeAssetId)(assetId);
+        log('Adding custom asset', { accountId, assetId: normalizedAssetId });
+        this.update((state) => {
+            const customAssets = state.customAssets;
+            if (!customAssets[accountId]) {
+                customAssets[accountId] = [];
+            }
+            // Only add if not already present
+            if (!customAssets[accountId].includes(normalizedAssetId)) {
+                customAssets[accountId].push(normalizedAssetId);
+            }
+        });
+        // Fetch data for the newly added custom asset
+        const account = __classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_selectedAccounts_get).find((a) => a.id === accountId);
+        if (account) {
+            const chainId = extractChainId(normalizedAssetId);
+            await this.getAssets([account], {
+                chainIds: [chainId],
+                forceUpdate: true,
+            });
+        }
+    }
+    /**
+     * 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, utils_2.normalizeAssetId)(assetId);
+        log('Removing custom asset', { accountId, assetId: normalizedAssetId });
+        this.update((state) => {
+            const customAssets = state.customAssets;
+            if (customAssets[accountId]) {
+                customAssets[accountId] = customAssets[accountId].filter((id) => id !== normalizedAssetId);
+                // Clean up empty arrays
+                if (customAssets[accountId].length === 0) {
+                    delete customAssets[accountId];
+                }
+            }
+        });
+    }
+    /**
+     * 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] ?? []);
+    }
+    /**
+     * 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.
+     * @param options - Subscription options.
+     * @param options.updateInterval - Polling interval in ms.
+     */
+    subscribeAssetsPrice(accounts, chainIds, options = {}) {
+        const { updateInterval = __classPrivateFieldGet(this, _AssetsController_defaultUpdateInterval, "f") } = options;
+        const subscriptionKey = 'ds:PriceDataSource';
+        const existingSubscription = __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").get(subscriptionKey);
+        const isUpdate = existingSubscription !== undefined;
+        // Fire-and-forget - errors are handled internally by PriceDataSource
+        this.messenger
+            .call('PriceDataSource:subscribe', {
+            request: {
+                accounts,
+                chainIds,
+                dataTypes: ['price'],
+                updateInterval,
+            },
+            subscriptionId: subscriptionKey,
+            isUpdate,
+        })
+            .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;
+        }
+        // Fire-and-forget - errors are handled internally by PriceDataSource
+        this.messenger
+            .call('PriceDataSource:unsubscribe', subscriptionKey)
+            .catch(console.error);
+        existingSubscription.unsubscribe();
+    }
+    /**
+     * Handle assets updated from a data source.
+     * Called via `AssetsController:assetsUpdate` action by data sources.
+     *
+     * @param response - The data response with updated assets
+     * @param sourceId - The data source ID reporting the update
+     */
+    async handleAssetsUpdate(response, sourceId) {
+        log('Assets updated from data source', {
+            sourceId,
+            hasBalance: Boolean(response.assetsBalance),
+            hasPrice: Boolean(response.assetsPrice),
+        });
+        await __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_handleSubscriptionUpdate).call(this, response, sourceId);
+    }
+    // ============================================================================
+    // CLEANUP
+    // ============================================================================
+    destroy() {
+        log('Destroying AssetsController', {
+            dataSourceCount: __classPrivateFieldGet(this, _AssetsController_dataSources, "f").size,
+            subscriptionCount: __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").size,
+        });
+        // Clear data sources
+        __classPrivateFieldGet(this, _AssetsController_dataSources, "f").clear();
+        // Stop all active subscriptions
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_stop).call(this);
+        // Unregister action handlers
+        this.messenger.unregisterActionHandler('AssetsController:getAssets');
+        this.messenger.unregisterActionHandler('AssetsController:getAssetsBalance');
+        this.messenger.unregisterActionHandler('AssetsController:getAssetMetadata');
+        this.messenger.unregisterActionHandler('AssetsController:getAssetsPrice');
+        this.messenger.unregisterActionHandler('AssetsController:activeChainsUpdate');
+        this.messenger.unregisterActionHandler('AssetsController:assetsUpdate');
+        this.messenger.unregisterActionHandler('AssetsController:addCustomAsset');
+        this.messenger.unregisterActionHandler('AssetsController:removeCustomAsset');
+        this.messenger.unregisterActionHandler('AssetsController:getCustomAssets');
     }
 }
 exports.AssetsController = AssetsController;
+_AssetsController_defaultUpdateInterval = new WeakMap(), _AssetsController_controllerMutex = new WeakMap(), _AssetsController_activeSubscriptions = new WeakMap(), _AssetsController_enabledChains = new WeakMap(), _AssetsController_assetsPrice = new WeakMap(), _AssetsController_dataSources = new WeakMap(), _AssetsController_instances = new WeakSet(), _AssetsController_selectedAccounts_get = function _AssetsController_selectedAccounts_get() {
+    return this.messenger.call('AccountTreeController:getAccountsFromSelectedAccountGroup');
+}, _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' && reference.startsWith('0x')) {
+        // 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', () => {
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_handleAccountGroupChanged).call(this).catch(console.error);
+    });
+    // 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);
+    });
+    // App lifecycle: start when opened, stop when closed
+    this.messenger.subscribe('AppStateController:appOpened', () => __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_start).call(this));
+    this.messenger.subscribe('AppStateController:appClosed', () => __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_stop).call(this));
+    // Keyring lifecycle: start when unlocked, stop when locked
+    this.messenger.subscribe('KeyringController:unlock', () => __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_start).call(this));
+    this.messenger.subscribe('KeyringController:lock', () => __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_stop).call(this));
+}, _AssetsController_registerActionHandlers = function _AssetsController_registerActionHandlers() {
+    this.messenger.registerActionHandler('AssetsController:getAssets', this.getAssets.bind(this));
+    this.messenger.registerActionHandler('AssetsController:getAssetsBalance', this.getAssetsBalance.bind(this));
+    this.messenger.registerActionHandler('AssetsController:getAssetMetadata', this.getAssetMetadata.bind(this));
+    this.messenger.registerActionHandler('AssetsController:getAssetsPrice', this.getAssetsPrice.bind(this));
+    this.messenger.registerActionHandler('AssetsController:activeChainsUpdate', this.handleActiveChainsUpdate.bind(this));
+    this.messenger.registerActionHandler('AssetsController:assetsUpdate', this.handleAssetsUpdate.bind(this));
+    this.messenger.registerActionHandler('AssetsController:addCustomAsset', this.addCustomAsset.bind(this));
+    this.messenger.registerActionHandler('AssetsController:removeCustomAsset', this.removeCustomAsset.bind(this));
+    this.messenger.registerActionHandler('AssetsController:getCustomAssets', this.getCustomAssets.bind(this));
+}, _AssetsController_executeMiddlewares = 
+// ============================================================================
+// MIDDLEWARE EXECUTION
+// ============================================================================
+/**
+ * Execute middlewares with request/response context.
+ *
+ * @param middlewares - Middlewares to execute in order.
+ * @param request - The data request.
+ * @param initialResponse - Optional initial response (for enriching existing data).
+ * @returns The final DataResponse after all middlewares have processed.
+ */
+async function _AssetsController_executeMiddlewares(middlewares, request, initialResponse = {}) {
+    const chain = middlewares.reduceRight((next, middleware) => async (ctx) => {
+        try {
+            return await middleware(ctx, next);
+        }
+        catch (error) {
+            console.error('[AssetsController] Middleware failed:', error);
+            return next(ctx);
+        }
+    }, async (ctx) => ctx);
+    const result = await chain({
+        request,
+        response: initialResponse,
+        getAssetsState: () => this.state,
+    });
+    return result.response;
+}, _AssetsController_assignChainsToDataSources = function _AssetsController_assignChainsToDataSources(requestedChains) {
+    const assignment = new Map();
+    const remainingChains = new Set(requestedChains);
+    for (const sourceId of __classPrivateFieldGet(this, _AssetsController_dataSources, "f").keys()) {
+        // Get available chains for this data source
+        const availableChains = __classPrivateFieldGet(this, _AssetsController_dataSources, "f").get(sourceId);
+        if (!availableChains || availableChains.size === 0) {
+            continue;
+        }
+        const chainsForThisSource = [];
+        for (const chainId of remainingChains) {
+            // Check if this chain is available on this source
+            if (availableChains.has(chainId)) {
+                chainsForThisSource.push(chainId);
+                remainingChains.delete(chainId);
+            }
+        }
+        if (chainsForThisSource.length > 0) {
+            assignment.set(sourceId, chainsForThisSource);
+            log('Assigned chains to data source', {
+                sourceId,
+                chains: chainsForThisSource,
+            });
+        }
+    }
+    return assignment;
+}, _AssetsController_updateState = 
+// ============================================================================
+// STATE MANAGEMENT
+// ============================================================================
+async function _AssetsController_updateState(response) {
+    // Normalize asset IDs (checksum EVM addresses) before storing in state
+    const normalizedResponse = normalizeResponse(response);
+    const releaseLock = await __classPrivateFieldGet(this, _AssetsController_controllerMutex, "f").acquire();
+    try {
+        const previousState = this.state;
+        const previousPrices = { ...__classPrivateFieldGet(this, _AssetsController_assetsPrice, "f") };
+        // Use detectedAssets from response (assets without metadata)
+        const detectedAssets = normalizedResponse.detectedAssets ?? {};
+        // Update prices in memory (not persisted in state)
+        if (normalizedResponse.assetsPrice) {
+            for (const [key, value] of Object.entries(normalizedResponse.assetsPrice)) {
+                __classPrivateFieldGet(this, _AssetsController_assetsPrice, "f")[key] = value;
+            }
+        }
+        // Track actual changes for logging
+        const changedBalances = [];
+        const changedMetadata = [];
+        this.update((state) => {
+            // Use type assertions to avoid deep type instantiation issues with Draft<Json>
+            const metadata = state.assetsMetadata;
+            const balances = state.assetsBalance;
+            if (normalizedResponse.assetsMetadata) {
+                for (const [key, value] of Object.entries(normalizedResponse.assetsMetadata)) {
+                    if (!(0, lodash_1.isEqual)(previousState.assetsMetadata[key], value)) {
+                        changedMetadata.push(key);
+                    }
+                    metadata[key] = value;
+                }
+            }
+            if (normalizedResponse.assetsBalance) {
+                for (const [accountId, accountBalances] of Object.entries(normalizedResponse.assetsBalance)) {
+                    const previousBalances = previousState.assetsBalance[accountId] ?? {};
+                    if (!balances[accountId]) {
+                        balances[accountId] = {};
+                    }
+                    for (const [assetId, balance] of Object.entries(accountBalances)) {
+                        const previousBalance = previousBalances[assetId];
+                        const balanceData = balance;
+                        const newAmount = balanceData.amount;
+                        const oldAmount = previousBalance?.amount;
+                        // Track if balance actually changed
+                        if (oldAmount !== newAmount) {
+                            changedBalances.push({
+                                accountId,
+                                assetId,
+                                oldAmount,
+                                newAmount,
+                            });
+                        }
+                    }
+                    Object.assign(balances[accountId], accountBalances);
+                }
+            }
+        });
+        // 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 = {};
+    // 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] = {};
+        const accountBalances = this.state.assetsBalance[account.id] ?? {};
+        for (const [assetId, balance] of Object.entries(accountBalances)) {
+            const typedAssetId = assetId;
+            const assetChainId = extractChainId(typedAssetId);
+            if (!chainIdSet.has(assetChainId)) {
+                continue;
+            }
+            const metadataRaw = this.state.assetsMetadata[typedAssetId];
+            // Skip assets without metadata
+            if (!metadataRaw) {
+                continue;
+            }
+            const metadata = metadataRaw;
+            // Filter by asset type
+            const tokenAssetType = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_tokenStandardToAssetType).call(this, metadata.type);
+            if (!assetTypeSet.has(tokenAssetType)) {
+                continue;
+            }
+            const typedBalance = balance;
+            const priceRaw = __classPrivateFieldGet(this, _AssetsController_assetsPrice, "f")[typedAssetId];
+            const price = priceRaw ?? {
+                price: 0,
+                lastUpdated: 0,
+            };
+            // Compute fiat value using BigNumber for precision with large balances
+            const balanceAmount = new bignumber_js_1.default(typedBalance.amount || '0');
+            const divisor = new bignumber_js_1.default(10).pow(metadata.decimals);
+            const normalizedAmount = balanceAmount.dividedBy(divisor);
+            const fiatValue = normalizedAmount
+                .multipliedBy(price.price || 0)
+                .toNumber();
+            const asset = {
+                id: typedAssetId,
+                chainId: assetChainId,
+                balance: typedBalance,
+                metadata,
+                price,
+                fiatValue,
+            };
+            result[account.id][typedAssetId] = asset;
+        }
+    }
+    return result;
+}, _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() {
+    log('Starting asset tracking', {
+        selectedAccountCount: __classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_selectedAccounts_get).length,
+        enabledChainCount: __classPrivateFieldGet(this, _AssetsController_enabledChains, "f").size,
+    });
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeToDataSources).call(this);
+    if (__classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_selectedAccounts_get).length > 0) {
+        this.getAssets(__classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_selectedAccounts_get), {
+            chainIds: [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")],
+            forceUpdate: true,
+        }).catch((error) => {
+            log('Failed to fetch assets', 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'),
+    });
+    // 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
+    // Convert to array first to avoid modifying map during iteration
+    const subscriptionKeys = [...__classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").keys()];
+    for (const subscriptionKey of subscriptionKeys) {
+        // Extract sourceId from subscription key (format: "ds:${sourceId}")
+        if (subscriptionKey.startsWith('ds:')) {
+            const sourceId = subscriptionKey.slice(3);
+            __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_unsubscribeDataSource).call(this, sourceId);
+        }
+    }
+    __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").clear();
+}, _AssetsController_subscribeToDataSources = function _AssetsController_subscribeToDataSources() {
+    if (__classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_selectedAccounts_get).length === 0) {
+        return;
+    }
+    // Subscribe to balance updates (batched by data source)
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeAssetsBalance).call(this);
+    // Subscribe to price updates for all assets held by selected accounts
+    this.subscribeAssetsPrice(__classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_selectedAccounts_get), [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")]);
+}, _AssetsController_subscribeAssetsBalance = function _AssetsController_subscribeAssetsBalance() {
+    // Step 1: Build chain -> accounts mapping based on account scopes and enabled networks
+    const chainToAccounts = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_buildChainToAccountsMap).call(this, __classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_selectedAccounts_get), __classPrivateFieldGet(this, _AssetsController_enabledChains, "f"));
+    // Step 2: Split by data source active chains (ordered by priority)
+    // Get all chains that need to be subscribed
+    const remainingChains = new Set(chainToAccounts.keys());
+    // Assign chains to data sources based on availability (ordered by priority)
+    const chainAssignment = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_assignChainsToDataSources).call(this, Array.from(remainingChains));
+    log('Subscribe - chain assignment', {
+        totalChains: remainingChains.size,
+        dataSourceAssignments: Array.from(chainAssignment.entries()).map(([sourceId, chains]) => ({ sourceId, chainCount: chains.length })),
+    });
+    // Subscribe to each data source with its assigned chains and relevant accounts
+    for (const sourceId of __classPrivateFieldGet(this, _AssetsController_dataSources, "f").keys()) {
+        const assignedChains = chainAssignment.get(sourceId);
+        if (!assignedChains || assignedChains.length === 0) {
+            // Unsubscribe from data sources with no assigned chains
+            __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_unsubscribeDataSource).call(this, sourceId);
+            continue;
+        }
+        // Collect unique accounts that need any of the assigned chains
+        const accountsForSource = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getAccountsForChains).call(this, assignedChains, chainToAccounts);
+        if (accountsForSource.length === 0) {
+            continue;
+        }
+        // Subscribe with ONE call per data source
+        __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeToDataSource).call(this, sourceId, accountsForSource, assignedChains);
+    }
+}, _AssetsController_buildChainToAccountsMap = function _AssetsController_buildChainToAccountsMap(accounts, chainsToSubscribe) {
+    const chainToAccounts = new Map();
+    for (const account of accounts) {
+        const accountChains = __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_getEnabledChainsForAccount).call(this, account);
+        for (const chainId of accountChains) {
+            if (!chainsToSubscribe.has(chainId)) {
+                continue;
+            }
+            const existingAccounts = chainToAccounts.get(chainId) ?? [];
+            existingAccounts.push(account);
+            chainToAccounts.set(chainId, existingAccounts);
+        }
+    }
+    return chainToAccounts;
+}, _AssetsController_getAccountsForChains = function _AssetsController_getAccountsForChains(chains, chainToAccounts) {
+    const accountIds = new Set();
+    const accounts = [];
+    for (const chainId of chains) {
+        const chainAccounts = chainToAccounts.get(chainId) ?? [];
+        for (const account of chainAccounts) {
+            if (!accountIds.has(account.id)) {
+                accountIds.add(account.id);
+                accounts.push(account);
+            }
+        }
+    }
+    return accounts;
+}, _AssetsController_subscribeToDataSource = function _AssetsController_subscribeToDataSource(sourceId, accounts, chains) {
+    const 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,
+    });
+    // Call data source subscribe action via Messenger (fire-and-forget)
+    (async () => {
+        try {
+            await this.messenger.call(`${sourceId}:subscribe`, {
+                request: {
+                    accounts,
+                    chainIds: chains,
+                    assetTypes: ['fungible'],
+                    dataTypes: ['balance'],
+                    updateInterval: __classPrivateFieldGet(this, _AssetsController_defaultUpdateInterval, "f"),
+                },
+                subscriptionId: subscriptionKey,
+                isUpdate,
+            });
+        }
+        catch (error) {
+            console.error(`[AssetsController] Failed to subscribe to '${sourceId}':`, error);
+        }
+    })().catch(console.error);
+    // Track subscription
+    const subscription = {
+        chains,
+        accountId: subscriptionKey,
+        assetTypes: ['fungible'],
+        dataTypes: ['balance', 'price'],
+        unsubscribe: () => {
+            __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").delete(subscriptionKey);
+        },
+    };
+    __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").set(subscriptionKey, subscription);
+}, _AssetsController_unsubscribeDataSource = function _AssetsController_unsubscribeDataSource(sourceId) {
+    const subscriptionKey = `ds:${sourceId}`;
+    const existingSubscription = __classPrivateFieldGet(this, _AssetsController_activeSubscriptions, "f").get(subscriptionKey);
+    if (existingSubscription) {
+        // Fire-and-forget unsubscribe call
+        (async () => {
+            try {
+                await this.messenger.call(`${sourceId}:unsubscribe`, subscriptionKey);
+            }
+            catch {
+                // Ignore errors - source may not have been subscribed
+            }
+        })().catch(() => {
+            // Ignore errors - source may not have been subscribed
+        });
+        existingSubscription.unsubscribe();
+    }
+}, _AssetsController_getEnabledChainsForAccount = function _AssetsController_getEnabledChainsForAccount(account) {
+    // 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 [namespace, reference] = scope.split(':');
+        // Wildcard scope (e.g., "eip155:0" means all enabled chains in that namespace)
+        if (reference === '0') {
+            for (const chain of __classPrivateFieldGet(this, _AssetsController_enabledChains, "f")) {
+                if (chain.startsWith(`${namespace}:`)) {
+                    result.push(chain);
+                }
+            }
+        }
+        else if (namespace === 'eip155' && reference?.startsWith('0x')) {
+            // 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() {
+    const accounts = __classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_selectedAccounts_get);
+    log('Account group changed', {
+        accountCount: accounts.length,
+        accountIds: accounts.map((a) => a.id),
+    });
+    // Subscribe and fetch for the new account group
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeToDataSources).call(this);
+    if (accounts.length > 0) {
+        await this.getAssets(accounts, {
+            chainIds: [...__classPrivateFieldGet(this, _AssetsController_enabledChains, "f")],
+            forceUpdate: true,
+        });
+    }
+}, _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,
+    });
+    // Clean up state for disabled chains
+    if (removedChains.length > 0) {
+        const removedChainsSet = new Set(removedChains);
+        this.update((state) => {
+            const balances = state.assetsBalance;
+            for (const accountId of Object.keys(balances)) {
+                for (const assetId of Object.keys(balances[accountId])) {
+                    const assetChainId = extractChainId(assetId);
+                    if (removedChainsSet.has(assetChainId)) {
+                        delete balances[accountId][assetId];
+                    }
+                }
+            }
+        });
+    }
+    // Refresh subscriptions for new chain set
+    __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_subscribeToDataSources).call(this);
+    // Do one-time fetch for newly enabled chains
+    if (addedChains.length > 0 && __classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_selectedAccounts_get).length > 0) {
+        await this.getAssets(__classPrivateFieldGet(this, _AssetsController_instances, "a", _AssetsController_selectedAccounts_get), {
+            chainIds: addedChains,
+            forceUpdate: true,
+        });
+    }
+}, _AssetsController_handleSubscriptionUpdate = 
+/**
+ * Handle an async update from a data source subscription.
+ * Enriches response with token metadata before updating state.
+ *
+ * @param response - The data response from the data source.
+ * @param _sourceId - The source ID (unused but kept for logging context).
+ * @param request - Optional original request for context.
+ */
+async function _AssetsController_handleSubscriptionUpdate(response, _sourceId, request) {
+    // Run through enrichment middlewares (Event Stack: Detection → Token → Price)
+    // Include 'metadata' in dataTypes so TokenDataSource runs to enrich detected assets
+    const enrichedResponse = await __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_executeMiddlewares).call(this, [
+        this.messenger.call('DetectionMiddleware:getAssetsMiddleware'),
+        this.messenger.call('TokenDataSource:getAssetsMiddleware'),
+        this.messenger.call('PriceDataSource:getAssetsMiddleware'),
+    ], request ?? {
+        accounts: [],
+        chainIds: [],
+        dataTypes: ['balance', 'metadata', 'price'],
+    }, response);
+    // Update state
+    await __classPrivateFieldGet(this, _AssetsController_instances, "m", _AssetsController_updateState).call(this, enrichedResponse);
+};
 //# sourceMappingURL=AssetsController.cjs.map