@metamask-previews/assets-controller 16.0.0-preview-ff6e6f34a → 16.0.0-preview-95104ffdb

package/dist/AssetsController.js

@@ -13,7 +13,7 @@ import { RpcDataSource } from './data-sources/RpcDataSource.js';
 import { SnapDataSource } from './data-sources/SnapDataSource.js';
 import { StakedBalanceDataSource } from './data-sources/StakedBalanceDataSource.js';
 import { CaipAssetNamespace, TokenDataSource, } from './data-sources/TokenDataSource.js';
-import { CHAINS_WITH_DEFAULT_TRACKED_ASSETS, DEFAULT_TRACKED_ASSETS_BY_CHAIN, buildDefaultAssetsInfo, getDefaultAssetMetadata, getDefaultTrackedAssetsForChain, } from './defaults.js';
+import { CHAINS_WITH_DEFAULT_TRACKED_ASSETS, DEFAULT_TRACKED_ASSETS_BY_CHAIN, buildDefaultAssetsInfo, getDefaultAssetMetadata, } from './defaults.js';
 import { AssetsDataSourceError } from './errors.js';
 import { projectLogger, createModuleLogger } from './logger.js';
 import { CustomAssetGraduationMiddleware } from './middlewares/CustomAssetGraduationMiddleware.js';
@@ -189,10 +189,6 @@ function normalizeResponse(response) {
     if (response.replaceCoveredChainBalances) {
         normalized.replaceCoveredChainBalances = true;
     }
-    if (response.unprocessedCustomAssets &&
-        response.unprocessedCustomAssets.length > 0) {
-        normalized.unprocessedCustomAssets = response.unprocessedCustomAssets.map((assetId) => normalizeAssetId(assetId));
-    }
     return normalized;
 }
 /**
@@ -200,13 +196,12 @@ function normalizeResponse(response) {
  *
  * @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
- *   on the Accounts API v5 path (`replaceCoveredChainBalances`).
- * @param replaceCoveredChains - When true (v5 force refresh), drop prior balances
- *   on chains present in the response before applying it, then restore custom assets.
+ * @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 mergeAccountBalancesV5(previousBalances, accountBalances, customAssetIds = [], replaceCoveredChains = false) {
+function mergeAccountBalances(previousBalances, accountBalances, customAssetIds, replaceCoveredChains) {
     if (!replaceCoveredChains) {
         return { ...previousBalances, ...accountBalances };
     }
@@ -220,8 +215,8 @@ function mergeAccountBalancesV5(previousBalances, accountBalances, customAssetId
     Object.assign(next, accountBalances);
     for (const customId of customAssetIds) {
         if (!Object.prototype.hasOwnProperty.call(next, customId)) {
-            const previous = previousBalances[customId];
-            next[customId] = previous ?? { amount: '0' };
+            const prev = previousBalances[customId];
+            next[customId] = prev ?? { amount: '0' };
         }
     }
     // Staked vault balances are owned by StakedBalanceDataSource. When an
@@ -235,38 +230,6 @@ function mergeAccountBalancesV5(previousBalances, accountBalances, customAssetId
     }
     return next;
 }
-/**
- * Apply an Accounts API v6 authoritative chain snapshot.
- *
- * @param previousBalances - Balances already in state for this account.
- * @param accountBalances - Balances from the incoming response.
- * @param unprocessedCustomAssets - Pins that v6 and RPC could not resolve.
- * @returns The merged balance map for the account.
- */
-function mergeAccountBalancesV6(previousBalances, accountBalances, unprocessedCustomAssets = []) {
-    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);
-    const unprocessedSet = new Set(unprocessedCustomAssets.map((assetId) => normalizeAssetId(assetId)));
-    for (const [assetId, balance] of Object.entries(previousBalances)) {
-        if (unprocessedSet.has(normalizeAssetId(assetId)) &&
-            !Object.prototype.hasOwnProperty.call(next, assetId)) {
-            next[assetId] = balance;
-        }
-    }
-    for (const [assetId, balance] of Object.entries(previousBalances)) {
-        if (isStakingContractAssetId(assetId) &&
-            !Object.prototype.hasOwnProperty.call(next, assetId)) {
-            next[assetId] = balance;
-        }
-    }
-    return next;
-}
 // ============================================================================
 // CONTROLLER IMPLEMENTATION
 // ============================================================================
@@ -502,7 +465,6 @@ export class AssetsController extends BaseController {
             queryApiClient,
             onActiveChainsUpdated: this.#onActiveChainsUpdated,
             ...accountsApiDataSourceConfig,
-            isBalanceV6Enabled: () => this.#isBalanceV6Enabled(),
         });
         this.#snapDataSource = new SnapDataSource({
             messenger: this.messenger,
@@ -522,7 +484,6 @@ export class AssetsController extends BaseController {
             ...rpcConfig,
             isOnboarded: rpcConfig.isOnboarded ?? isOnboarded,
             getAssetType: (assetId) => this.#getAssetType(assetId),
-            isBalanceV6Enabled: () => this.#isBalanceV6Enabled(),
         });
         this.#stakedBalanceDataSource = new StakedBalanceDataSource({
             messenger: this.messenger,
@@ -555,7 +516,6 @@ export class AssetsController extends BaseController {
         });
         this.#rpcFallbackMiddleware = new RpcFallbackMiddleware({
             rpcDataSource: this.#rpcDataSource,
-            isBalanceV6Enabled: () => this.#isBalanceV6Enabled(),
         });
         log('Initializing AssetsController', {
             defaultUpdateInterval: this.#defaultUpdateInterval,
@@ -997,310 +957,152 @@ export class AssetsController extends BaseController {
         if (accounts.length === 0 || chainIds.length === 0) {
             return this.#getAssetsFromState(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 = this.#firstInitFetchReported
                 ? undefined
                 : this.#trace;
-            const requestOptions = {
+            const request = this.#buildDataRequest(accounts, chainIds, {
                 assetTypes,
                 dataTypes,
+                customAssets: customAssets.length > 0 ? customAssets : undefined,
                 forceUpdate: true,
                 bypassServerCache: options?.bypassServerCache,
                 assetsForPriceUpdate: options?.assetsForPriceUpdate,
-            };
-            if (this.#isBalanceV6Enabled()) {
-                await this.#forceUpdateAssetsV6({
-                    accounts,
-                    chainIds,
-                    request: this.#buildForceUpdateRequestV6(accounts, chainIds, {
-                        ...requestOptions,
-                        customAssetsOverride: options?.customAssets,
-                    }),
-                    pipelineTrace,
-                });
-            }
-            else {
-                await this.#forceUpdateAssetsV5({
-                    accounts,
-                    chainIds,
-                    request: this.#buildForceUpdateRequestV5(accounts, chainIds, requestOptions),
-                    pipelineTrace,
-                });
+            });
+            // 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 = this.#isBasicFunctionality()
+                ? [
+                    createParallelBalanceMiddleware([
+                        this.#accountsApiDataSource,
+                        this.#stakedBalanceDataSource,
+                    ]),
+                    // Graduation must run BEFORE the RPC fallback so it only sees
+                    // AccountsApi/Websocket balances. RPC intentionally carries
+                    // custom assets and must never trigger graduation.
+                    this.#customAssetGraduationMiddleware,
+                    this.#rpcFallbackMiddleware,
+                    this.#detectionMiddleware,
+                    createParallelMiddleware([
+                        this.#tokenDataSource,
+                        this.#priceDataSource,
+                    ]),
+                ]
+                : [this.#stakedBalanceDataSource, this.#detectionMiddleware];
+            const { response } = await withTrace({
+                name: TRACE_FETCH_PIPELINE,
+                trace: pipelineTrace,
+                data: {
+                    chain_count: chainIds.length,
+                    account_count: accounts.length,
+                    basic_functionality: this.#isBasicFunctionality(),
+                },
+                fn: async (parentContext) => {
+                    const startTime = performance.now();
+                    const result = await this.#executeMiddlewares({
+                        sources: fastSources,
+                        request,
+                        parentContext,
+                        trace: pipelineTrace,
+                    });
+                    await this.#updateState({
+                        ...result.response,
+                        updateMode: 'merge',
+                        replaceCoveredChainBalances: true,
+                    });
+                    const durationMs = performance.now() - startTime;
+                    // Summary fields for Assets Health (nested under the parent span).
+                    emitTrace({
+                        name: TRACE_FULL_FETCH,
+                        trace: pipelineTrace,
+                        data: {
+                            duration_ms: durationMs,
+                            chain_count: chainIds.length,
+                            account_count: accounts.length,
+                            basic_functionality: this.#isBasicFunctionality(),
+                            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,
+                    });
+                    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.
+            this.#firstInitFetchReported = true;
+            // 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 = this.#getSlowPipelineChainIds(chainIds, response);
+            if (slowPipelineChainIds.length > 0) {
+                const slowSources = this.#isBasicFunctionality()
+                    ? [this.#snapDataSource, this.#rpcDataSource]
+                    : [this.#rpcDataSource];
+                const slowRequest = { ...request, chainIds: slowPipelineChainIds };
+                withTrace({
+                    name: TRACE_BACKGROUND_FETCH,
+                    trace: pipelineTrace,
+                    data: {
+                        chain_count: slowPipelineChainIds.length,
+                        account_count: accounts.length,
+                    },
+                    fn: async (slowParentContext) => {
+                        const { response: slowResponse } = await this.#executeMiddlewares({
+                            sources: [
+                                createParallelBalanceMiddleware(slowSources),
+                                this.#detectionMiddleware,
+                                ...(this.#isBasicFunctionality()
+                                    ? [
+                                        createParallelMiddleware([
+                                            this.#tokenDataSource,
+                                            this.#priceDataSource,
+                                        ]),
+                                    ]
+                                    : []),
+                            ],
+                            request: slowRequest,
+                            parentContext: slowParentContext,
+                            trace: pipelineTrace,
+                        });
+                        await this.#updateState({
+                            ...slowResponse,
+                            updateMode: 'merge',
+                        });
+                    },
+                }).catch((error) => log('Background pipeline failed', { error }));
             }
         }
         const result = this.#getAssetsFromState(accounts, chainIds, assetTypes);
         return result;
     }
-    /**
-     * v5 force-update request: every pin of the requested accounts, unscoped.
-     * Delete with the rest of the v5 path when `assetsAccountsApiV6` is the default.
-     *
-     * @param accounts - Accounts in this fetch.
-     * @param chainIds - Chains in this fetch.
-     * @param requestOptions - Shared force-update request fields.
-     * @param requestOptions.assetTypes - Asset types to fetch.
-     * @param requestOptions.dataTypes - Data types to fetch.
-     * @param requestOptions.forceUpdate - Always `true` to bypass caches.
-     * @param requestOptions.bypassServerCache - Also bypass server-side HTTP caches.
-     * @param requestOptions.assetsForPriceUpdate - Assets to refresh prices for.
-     * @returns The v5 data request.
-     */
-    #buildForceUpdateRequestV5(accounts, chainIds, requestOptions) {
-        const customAssets = [];
-        for (const account of accounts) {
-            customAssets.push(...this.#getVisibleCustomAssets(account.id));
-        }
-        return this.#buildDataRequest(accounts, chainIds, {
-            ...requestOptions,
-            customAssets: customAssets.length > 0 ? customAssets : undefined,
-        });
-    }
-    /**
-     * v6 force-update request: chain-scoped pins (or `customAssets` override)
-     * plus hidden assets as `excludeAssetIds`.
-     *
-     * @param accounts - Accounts in this fetch.
-     * @param chainIds - Chains in this fetch.
-     * @param requestOptions - Shared force-update request fields and optional pin override.
-     * @param requestOptions.assetTypes - Asset types to fetch.
-     * @param requestOptions.dataTypes - Data types to fetch.
-     * @param requestOptions.forceUpdate - Always `true` to bypass caches.
-     * @param requestOptions.bypassServerCache - Also bypass server-side HTTP caches.
-     * @param requestOptions.assetsForPriceUpdate - Assets to refresh prices for.
-     * @param requestOptions.customAssetsOverride - Pinned assets to use instead of the stored custom assets.
-     * @returns The v6 data request.
-     */
-    #buildForceUpdateRequestV6(accounts, chainIds, requestOptions) {
-        const requestedChains = new Set(chainIds);
-        const candidateCustomAssets = requestOptions.customAssetsOverride ??
-            accounts.flatMap((account) => this.getCustomAssets(account.id));
-        const customAssetsSet = new Set();
-        for (const assetId of candidateCustomAssets) {
-            try {
-                const normalizedAssetId = normalizeAssetId(assetId);
-                if (requestedChains.has(parseCaipAssetType(normalizedAssetId).chainId) &&
-                    !this.state.assetPreferences[normalizedAssetId]?.hidden) {
-                    customAssetsSet.add(normalizedAssetId);
-                }
-            }
-            catch {
-                // Skip unparseable asset IDs
-            }
-        }
-        const customAssets = [...customAssetsSet];
-        const hiddenAssets = this.#getHiddenAssetIds();
-        return this.#buildDataRequest(accounts, chainIds, {
-            assetTypes: requestOptions.assetTypes,
-            dataTypes: requestOptions.dataTypes,
-            forceUpdate: requestOptions.forceUpdate,
-            bypassServerCache: requestOptions.bypassServerCache,
-            assetsForPriceUpdate: requestOptions.assetsForPriceUpdate,
-            customAssets: customAssets.length > 0 ? customAssets : undefined,
-            excludeAssetIds: hiddenAssets.length > 0 ? hiddenAssets : undefined,
-        });
-    }
-    async #forceUpdateAssetsV5({ accounts, chainIds, request, pipelineTrace, }) {
-        const isBasicFunctionality = this.#isBasicFunctionality();
-        const fastSources = isBasicFunctionality
-            ? [
-                createParallelBalanceMiddleware([
-                    this.#accountsApiDataSource,
-                    this.#stakedBalanceDataSource,
-                ]),
-                this.#customAssetGraduationMiddleware,
-                this.#rpcFallbackMiddleware,
-                this.#detectionMiddleware,
-                createParallelMiddleware([
-                    this.#tokenDataSource,
-                    this.#priceDataSource,
-                ]),
-            ]
-            : [this.#stakedBalanceDataSource, this.#detectionMiddleware];
-        const fastResponse = await this.#runFastFetchV5({
-            accounts,
-            chainIds,
-            request,
-            pipelineTrace,
-            fastSources,
-            isBasicFunctionality,
-        });
-        this.#firstInitFetchReported = true;
-        this.#runBackgroundFetch({
-            accounts,
-            request,
-            pipelineTrace,
-            chainIds: this.#getSlowPipelineChainIds(chainIds, fastResponse),
-            isBasicFunctionality,
-        });
-    }
-    async #forceUpdateAssetsV6({ accounts, chainIds, request, pipelineTrace, }) {
-        const isBasicFunctionality = this.#isBasicFunctionality();
-        const fastSources = isBasicFunctionality
-            ? [
-                createParallelBalanceMiddleware([
-                    this.#accountsApiDataSource,
-                    this.#stakedBalanceDataSource,
-                ]),
-                this.#rpcFallbackMiddleware,
-                this.#detectionMiddleware,
-                createParallelMiddleware([
-                    this.#tokenDataSource,
-                    this.#priceDataSource,
-                ]),
-            ]
-            : [this.#stakedBalanceDataSource, this.#detectionMiddleware];
-        const fastResponse = await this.#runFastFetchV6({
-            accounts,
-            chainIds,
-            request,
-            pipelineTrace,
-            fastSources,
-            isBasicFunctionality,
-        });
-        this.#firstInitFetchReported = true;
-        this.#runBackgroundFetch({
-            accounts,
-            request,
-            pipelineTrace,
-            chainIds: this.#getSlowPipelineChainIds(chainIds, fastResponse),
-            isBasicFunctionality,
-        });
-    }
-    async #runFastFetchV5({ accounts, chainIds, request, pipelineTrace, fastSources, isBasicFunctionality, }) {
-        const { response } = await withTrace({
-            name: TRACE_FETCH_PIPELINE,
-            trace: pipelineTrace,
-            data: {
-                chain_count: chainIds.length,
-                account_count: accounts.length,
-                basic_functionality: isBasicFunctionality,
-            },
-            fn: async (parentContext) => {
-                const startTime = performance.now();
-                const result = await this.#executeMiddlewares({
-                    sources: fastSources,
-                    request,
-                    parentContext,
-                    trace: pipelineTrace,
-                });
-                await this.#updateState({
-                    ...result.response,
-                    updateMode: 'merge',
-                    replaceCoveredChainBalances: true,
-                });
-                this.#emitFastFetchTraces({
-                    accounts,
-                    chainIds,
-                    result,
-                    durationMs: performance.now() - startTime,
-                    isBasicFunctionality,
-                    parentContext,
-                    pipelineTrace,
-                });
-                return result;
-            },
-        });
-        return response;
-    }
-    async #runFastFetchV6({ accounts, chainIds, request, pipelineTrace, fastSources, isBasicFunctionality, }) {
-        const { response } = await withTrace({
-            name: TRACE_FETCH_PIPELINE,
-            trace: pipelineTrace,
-            data: {
-                chain_count: chainIds.length,
-                account_count: accounts.length,
-                basic_functionality: isBasicFunctionality,
-            },
-            fn: async (parentContext) => {
-                const startTime = performance.now();
-                const result = await this.#executeMiddlewares({
-                    sources: fastSources,
-                    request,
-                    parentContext,
-                    trace: pipelineTrace,
-                });
-                await this.#updateState(result.response);
-                this.#emitFastFetchTraces({
-                    accounts,
-                    chainIds,
-                    result,
-                    durationMs: performance.now() - startTime,
-                    isBasicFunctionality,
-                    parentContext,
-                    pipelineTrace,
-                });
-                return result;
-            },
-        });
-        return response;
-    }
-    #runBackgroundFetch({ accounts, chainIds, request, pipelineTrace, isBasicFunctionality, }) {
-        if (chainIds.length === 0) {
-            return;
-        }
-        const slowSources = isBasicFunctionality
-            ? [this.#snapDataSource, this.#rpcDataSource]
-            : [this.#rpcDataSource];
-        const slowRequest = { ...request, chainIds };
-        withTrace({
-            name: TRACE_BACKGROUND_FETCH,
-            trace: pipelineTrace,
-            data: {
-                chain_count: chainIds.length,
-                account_count: accounts.length,
-            },
-            fn: async (parentContext) => {
-                const { response } = await this.#executeMiddlewares({
-                    sources: [
-                        createParallelBalanceMiddleware(slowSources),
-                        this.#detectionMiddleware,
-                        ...(isBasicFunctionality
-                            ? [
-                                createParallelMiddleware([
-                                    this.#tokenDataSource,
-                                    this.#priceDataSource,
-                                ]),
-                            ]
-                            : []),
-                    ],
-                    request: slowRequest,
-                    parentContext,
-                    trace: pipelineTrace,
-                });
-                await this.#updateState({ ...response, updateMode: 'merge' });
-            },
-        }).catch((error) => log('Background pipeline failed', { error }));
-    }
-    #emitFastFetchTraces({ accounts, chainIds, result, durationMs, isBasicFunctionality, parentContext, pipelineTrace, }) {
-        emitTrace({
-            name: TRACE_FULL_FETCH,
-            trace: pipelineTrace,
-            data: {
-                duration_ms: durationMs,
-                chain_count: chainIds.length,
-                account_count: accounts.length,
-                basic_functionality: isBasicFunctionality,
-                asset_count: result.response.assetsBalance
-                    ? Object.values(result.response.assetsBalance).reduce((sum, account) => sum + Object.keys(account).length, 0)
-                    : 0,
-                price_count: result.response.assetsPrice
-                    ? Object.keys(result.response.assetsPrice).length
-                    : 0,
-                ...result.durationByDataSource,
-            },
-            parentContext,
-        });
-        emitTrace({
-            name: TRACE_FIRST_INIT_FETCH,
-            trace: pipelineTrace,
-            data: {
-                duration_ms: durationMs,
-                chain_ids: JSON.stringify(chainIds),
-                ...result.durationByDataSource,
-            },
-            parentContext,
-        });
-    }
     async getAssetsBalance(accounts, options) {
         // Reuse getAssets with dataTypes: ['balance'] only
         const assets = await this.getAssets(accounts, {
@@ -1568,28 +1370,20 @@ export class AssetsController extends BaseController {
             balances[accountId] ??= {};
             balances[accountId][normalizedAssetId] ??= { amount: '0' };
         });
+        // Fetch data for the newly added custom asset (merge to preserve other chains)
         const account = this.#getSelectedAccounts().find((a) => a.id === accountId);
         if (account) {
             const chainId = extractChainId(normalizedAssetId);
-            if (this.#isBalanceV6Enabled()) {
-                await this.getAssets([account], {
-                    chainIds: [chainId],
-                    dataTypes: ['balance', 'metadata', 'price'],
-                    assetTypes: ['fungible'],
-                    forceUpdate: true,
-                    customAssets: [normalizedAssetId],
-                });
-            }
-            else {
-                await this.getAssets([account], {
-                    chainIds: [chainId],
-                    dataTypes: ['balance', 'metadata', 'price'],
-                    assetTypes: ['fungible'],
-                    forceUpdate: true,
-                });
-            }
+            await this.getAssets([account], {
+                chainIds: [chainId],
+                dataTypes: ['balance', 'metadata', 'price'],
+                assetTypes: ['fungible'],
+                forceUpdate: true,
+                updateMode: 'merge',
+            });
         }
-        // Re-evaluate subscriptions so polls pick up the new pin.
+        // Re-evaluate subscriptions so the supplemental RPC poll picks up the
+        // new customAsset on chains another data source already owns.
         this.#subscribeAssets();
     }
     /**
@@ -1610,7 +1404,8 @@ export class AssetsController extends BaseController {
                 }
             }
         });
-        // Re-evaluate subscriptions so polls drop the removed pin.
+        // Re-evaluate subscriptions so the supplemental RPC poll for that chain
+        // is torn down when no more customAssets remain there.
         this.#subscribeAssets();
     }
     /**
@@ -1641,8 +1436,6 @@ export class AssetsController extends BaseController {
             }
             state.assetPreferences[normalizedAssetId].hidden = true;
         });
-        // Re-evaluate subscriptions so polls exclude the newly hidden asset.
-        this.#subscribeAssets();
     }
     /**
      * Unhide an asset globally.
@@ -1661,53 +1454,6 @@ export class AssetsController extends BaseController {
                 }
             }
         });
-        // Re-evaluate subscriptions so polls stop excluding the asset.
-        this.#subscribeAssets();
-    }
-    /**
-     * Collect globally hidden asset IDs (from `assetPreferences`), forwarded on
-     * data requests as `excludeAssetIds`.
-     *
-     * @returns The CAIP-19 asset IDs the user has hidden.
-     */
-    #getHiddenAssetIds() {
-        const hidden = [];
-        for (const [assetId, prefs] of Object.entries(this.state.assetPreferences)) {
-            if (prefs.hidden) {
-                hidden.push(assetId);
-            }
-        }
-        return hidden;
-    }
-    /**
-     * An account's pins minus the ones the user has hidden. A hide wins over a
-     * pin on requests, so a hidden asset is never fetched; the pin stays in
-     * `customAssets` to record that the token was imported, and unhiding it
-     * restores the pin on the next subscription.
-     *
-     * @param accountId - The account whose pins should be collected.
-     * @returns The account's pinned asset IDs that are not hidden.
-     */
-    #getVisibleCustomAssets(accountId) {
-        return this.getCustomAssets(accountId).filter((assetId) => !this.state.assetPreferences[assetId]?.hidden);
-    }
-    /**
-     * Whether Accounts API v6 (and the v6 custom-asset path) is enabled.
-     * Injected into AccountsApiDataSource and RpcFallbackMiddleware.
-     *
-     * `RemoteFeatureFlagController` resolves a threshold-scoped flag to the
-     * selected group's `value`, so processed state is a boolean.
-     *
-     * @returns `true` when the v6 remote flag is on.
-     */
-    #isBalanceV6Enabled() {
-        try {
-            const { remoteFeatureFlags } = this.messenger.call('RemoteFeatureFlagController:getState');
-            return remoteFeatureFlags?.assetsAccountsApiV6 === true;
-        }
-        catch {
-            return false;
-        }
     }
     // ============================================================================
     // CURRENT CURRENCY MANAGEMENT
@@ -1930,22 +1676,6 @@ export class AssetsController extends BaseController {
     #getNativeAssetIdsForAccount(account) {
         return this.#resolveNativeAssetIds(this.#getEnabledChainsForAccount(account));
     }
-    /**
-     * Returns the controller-managed default tracked asset IDs (e.g. mUSD) for
-     * the chains this account supports (account scopes ∩ enabled chains).
-     * Non-EVM accounts resolve to an empty list because every chain in the
-     * defaults registry is EVM today.
-     *
-     * @param account - The account (scopes determine which chains apply).
-     * @returns Array of default tracked asset IDs across the supported chains.
-     */
-    #getDefaultTrackedAssetIdsForAccount(account) {
-        const ids = [];
-        for (const chainId of this.#getEnabledChainsForAccount(account)) {
-            ids.push(...getDefaultTrackedAssetsForChain(chainId));
-        }
-        return ids;
-    }
     /**
      * Chains for the post-commit slow pipeline (Snap + RPC). Excludes chains the
      * fast Accounts API path already handled without error so stale RPC data cannot
@@ -1957,16 +1687,10 @@ export class AssetsController extends BaseController {
      */
     #getSlowPipelineChainIds(chainIds, fastResponse) {
         const accountsApiChains = new Set(this.#accountsApiDataSource.getActiveChainsSync());
-        // Chains whose pins went unresolved (`unprocessedCustomAssets`): route
-        // them to the slow pipeline so RPC fetches the pins.
-        const unprocessedCustomAssetChains = new Set((fastResponse.unprocessedCustomAssets ?? []).map((assetId) => assetId.split('/')[0]));
         return chainIds.filter((chainId) => {
             if (fastResponse.errors?.[chainId]) {
                 return true;
             }
-            if (unprocessedCustomAssetChains.has(chainId)) {
-                return true;
-            }
             if (!accountsApiChains.has(chainId)) {
                 return true;
             }
@@ -2130,9 +1854,9 @@ export class AssetsController extends BaseController {
                     for (const [accountId, accountBalances] of Object.entries(normalizedResponse.assetsBalance)) {
                         const previousBalances = previousState.assetsBalance[accountId] ?? {};
                         const customAssetIds = state.customAssets[accountId] ?? [];
-                        const effective = mode === 'full'
-                            ? mergeAccountBalancesV6(previousBalances, accountBalances, normalizedResponse.unprocessedCustomAssets ?? [])
-                            : mergeAccountBalancesV5(previousBalances, accountBalances, customAssetIds, normalizedResponse.replaceCoveredChainBalances === true);
+                        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 = this.#getSelectedAccounts().find((a) => a.id === accountId);
                         const nativeAssetIdsForAccount = account
@@ -2143,19 +1867,6 @@ export class AssetsController extends BaseController {
                                 effective[nativeAssetId] = { amount: '0' };
                             }
                         }
-                        // Default tracked assets (mUSD) are controller-managed and, like
-                        // natives, must render at zero balance. An authoritative
-                        // chain-slice replace omits them whenever the account holds none,
-                        // so re-assert them here — otherwise a force refresh (e.g. the
-                        // "Refresh list" action) would drop mUSD from the token list.
-                        const defaultTrackedAssetIdsForAccount = account
-                            ? this.#getDefaultTrackedAssetIdsForAccount(account)
-                            : [];
-                        for (const defaultAssetId of defaultTrackedAssetIdsForAccount) {
-                            if (!Object.prototype.hasOwnProperty.call(effective, defaultAssetId)) {
-                                effective[defaultAssetId] = { 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
@@ -2167,13 +1878,19 @@ export class AssetsController extends BaseController {
                             // their metadata aren't lossily truncated.
                             const assetDecimals = metadata[assetId]?.decimals;
                             const newAmount = normalizeAmountString(balance.amount, assetDecimals);
-                            effective[assetId] = { ...balance, amount: newAmount };
+                            // Keep existing metadata when the incoming update is
+                            // amount-only (e.g. Account Activity websocket). Incoming
+                            // metadata still wins when present.
+                            effective[assetId] = {
+                                ...previousBalance,
+                                ...balance,
+                                amount: newAmount,
+                            };
                             const oldAmount = previousBalance?.amount;
-                            const isNewSeededZero = oldAmount === undefined &&
+                            const isNewDefaultNativeZero = oldAmount === undefined &&
                                 newAmount === '0' &&
-                                (nativeAssetIdsForAccount.includes(assetId) ||
-                                    defaultTrackedAssetIdsForAccount.includes(assetId));
-                            if (oldAmount !== newAmount && !isNewSeededZero) {
+                                nativeAssetIdsForAccount.includes(assetId);
+                            if (oldAmount !== newAmount && !isNewDefaultNativeZero) {
                                 changedBalances.push({
                                     accountId,
                                     assetId,
@@ -2203,8 +1920,10 @@ export class AssetsController extends BaseController {
                 changedPriceAssets.length > 0) {
                 log('State updated', {
                     changedBalances: changedBalances.length > 0 ? changedBalances : undefined,
-                    changedMetadata: changedMetadata.length > 0 ? changedMetadata : undefined,
-                    changedPrices: changedPriceAssets.length > 0 ? changedPriceAssets : 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,
@@ -2426,10 +2145,16 @@ export class AssetsController extends BaseController {
             if (!subscriptionKey.startsWith('ds:')) {
                 continue;
             }
-            // Subscription keys take the form `ds:<SourceName>`.
+            // 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.
                 this.#unsubscribeBySubscriptionKey(source, subscriptionKey);
             }
         }
@@ -2473,12 +2198,10 @@ export class AssetsController extends BaseController {
      * Strategy to minimize data source calls:
      * 1. Collect all chains to subscribe based on enabled networks
      * 2. Map chains to accounts based on their scopes
-     * 3. Split by data source (priority order) - each source gets ONE
-     *    subscription, claiming chains AND pinned assets (`claimCustomAssets`);
-     *    unclaimed assets fall through to lower-priority sources.
+     * 3. Split by data source (ordered by priority) - each data source gets ONE subscription
      *
      * This ensures we make minimal subscriptions to each data source while covering
-     * all accounts, chains, and pinned assets.
+     * all accounts and chains.
      *
      * @param accounts - Accounts to subscribe balance updates for.
      * @param chainIds - Chain IDs to subscribe for.
@@ -2486,16 +2209,12 @@ export class AssetsController extends BaseController {
      * @param options.skipInitialFetch - Forwarded to AccountsApi subscribe.
      */
     #subscribeAssetsBalance(accounts, chainIds, options) {
-        if (this.#isBalanceV6Enabled()) {
-            this.#subscribeAssetsBalanceV6(accounts, chainIds, options);
-            return;
-        }
-        this.#subscribeAssetsBalanceV5(accounts, chainIds, options);
-    }
-    #subscribeAssetsBalanceV5(accounts, chainIds, options) {
         const chainToAccounts = this.#buildChainToAccountsMap(accounts, new Set(chainIds));
         const remainingChains = new Set(chainToAccounts.keys());
-        const balanceDataSources = this.#isBasicFunctionality()
+        // When basic functionality is on, use all balance data sources; when off,
+        // RPC only.
+        const isBasicFunctionality = this.#isBasicFunctionality();
+        const balanceDataSources = isBasicFunctionality
             ? this.#allBalanceDataSources
             : [this.#rpcDataSource];
         let rpcAssignedChains = new Set();
@@ -2534,88 +2253,22 @@ export class AssetsController extends BaseController {
                 });
             }
         }
+        // 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.
         this.#subscribeRpcCustomAssetsSupplement(accounts, chainToAccounts, rpcAssignedChains);
     }
-    #subscribeAssetsBalanceV6(accounts, chainIds, options) {
-        const chainToAccounts = this.#buildChainToAccountsMap(accounts, new Set(chainIds));
-        const remainingChains = new Set(chainToAccounts.keys());
-        const remainingCustomAssets = new Set();
-        for (const account of accounts) {
-            for (const assetId of this.#getVisibleCustomAssets(account.id)) {
-                try {
-                    if (remainingChains.has(parseCaipAssetType(assetId).chainId)) {
-                        remainingCustomAssets.add(assetId);
-                    }
-                }
-                catch {
-                    // Skip unparseable asset IDs
-                }
-            }
-        }
-        const balanceDataSources = this.#isBasicFunctionality()
-            ? this.#allBalanceDataSources
-            : [this.#rpcDataSource];
-        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);
-                }
-            }
-            const claimedAssets = source.claimCustomAssets([...remainingCustomAssets], assignedChains);
-            for (const assetId of claimedAssets) {
-                remainingCustomAssets.delete(assetId);
-            }
-            if (assignedChains.length === 0 && claimedAssets.length === 0) {
-                this.#unsubscribeDataSource(source);
-                continue;
-            }
-            const claimedAssetsSet = new Set(claimedAssets);
-            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;
-            });
-            for (const account of accounts) {
-                if (!seenIds.has(account.id) &&
-                    this.getCustomAssets(account.id).some((assetId) => claimedAssetsSet.has(assetId))) {
-                    seenIds.add(account.id);
-                    accountsForSource.push(account);
-                }
-            }
-            if (accountsForSource.length > 0) {
-                const hiddenAssets = this.#getHiddenAssetIds();
-                this.#subscribeDataSource(source, accountsForSource, assignedChains, {
-                    customAssets: claimedAssets,
-                    excludeAssetIds: hiddenAssets.length > 0 ? hiddenAssets : undefined,
-                    ...(options?.skipInitialFetch &&
-                        source === this.#accountsApiDataSource
-                        ? { skipInitialFetch: true }
-                        : {}),
-                });
-            }
-            else {
-                this.#unsubscribeDataSource(source);
-            }
-        }
-        if (remainingCustomAssets.size > 0) {
-            log('Custom assets unclaimed by any data source', {
-                assetIds: [...remainingCustomAssets],
-            });
-        }
-    }
     /**
      * Guarantee that customAssets are **always** polled by RPC, even when
      * AccountsApi or another data source has claimed the chain in the
      * regular handoff. RPC is the sole balance fetcher for user-imported
-     * tokens on the Accounts API v5 path (see `pickRpcCustomAssetsSupplement`).
+     * tokens (see `pickRpcCustomAssetsSupplement` for the full rationale),
+     * so we run a dedicated subscription in `customAssetsOnly` mode under a
+     * distinct subscription key (`ds:RpcDataSource:custom`) that does not
+     * interfere with the regular RPC subscription.
      *
      * @param accounts - Accounts to consider for customAssets.
      * @param chainToAccounts - Map of chain → accounts (built by caller).
@@ -2624,16 +2277,9 @@ export class AssetsController extends BaseController {
     #subscribeRpcCustomAssetsSupplement(accounts, chainToAccounts, rpcAssignedChains) {
         const rpc = this.#rpcDataSource;
         const supplementalKey = `ds:${rpc.getName()}:custom`;
-        const visibleCustomAssetsByAccount = {};
-        for (const account of accounts) {
-            const visibleCustomAssets = this.#getVisibleCustomAssets(account.id);
-            if (visibleCustomAssets.length > 0) {
-                visibleCustomAssetsByAccount[account.id] = visibleCustomAssets;
-            }
-        }
         const decision = pickRpcCustomAssetsSupplement({
             accountIds: accounts.map((account) => account.id),
-            customAssetsByAccount: visibleCustomAssetsByAccount,
+            customAssetsByAccount: this.state.customAssets,
             rpcAssignedChains,
             rpcAvailableChains: new Set(rpc.getActiveChainsSync()),
             enabledChains: new Set(chainToAccounts.keys()),
@@ -2720,12 +2366,7 @@ export class AssetsController extends BaseController {
      * @param chains - Array of chain IDs to subscribe for.
      * @param options - Optional subscription overrides.
      * @param options.subscriptionKey - Custom subscription key (default: `ds:<sourceId>`).
-     * @param options.customAssets - Pinned assets this source claimed
-     * (`claimCustomAssets`), forwarded on the poll request (Accounts API v6).
-     * @param options.customAssetsOnly - When true, only poll customAssets for these
-     * chains (Accounts API v5 supplemental RPC subscription).
-     * @param options.excludeAssetIds - Hidden assets forwarded on the poll request
-     * (Accounts API v6).
+     * @param options.customAssetsOnly - When true, only poll customAssets for these chains.
      * @param options.skipInitialFetch - When true, skip the data source's subscribe-time fetch.
      */
     #subscribeDataSource(source, accounts, chains, options = {}) {
@@ -2733,14 +2374,12 @@ export class AssetsController extends BaseController {
         const subscriptionKey = options.subscriptionKey ?? `ds:${sourceId}`;
         const existingSubscription = this.#activeSubscriptions.get(subscriptionKey);
         const isUpdate = existingSubscription !== undefined;
-        const customAssets = options.customAssets ?? [];
         log('Subscribe to data source', {
             sourceId,
             subscriptionKey,
             isUpdate,
             accountCount: accounts.length,
             chainCount: chains.length,
-            customAssetCount: customAssets.length,
             customAssetsOnly: options.customAssetsOnly === true,
             skipInitialFetch: options.skipInitialFetch === true,
         });
@@ -2749,10 +2388,6 @@ export class AssetsController extends BaseController {
                 assetTypes: ['fungible'],
                 dataTypes: ['balance'],
                 updateInterval: this.#defaultUpdateInterval,
-                customAssets: customAssets.length > 0 ? customAssets : undefined,
-                excludeAssetIds: options.excludeAssetIds && options.excludeAssetIds.length > 0
-                    ? options.excludeAssetIds
-                    : undefined,
                 ...(options.customAssetsOnly === true
                     ? { customAssetsOnly: true }
                     : {}),
@@ -2944,13 +2579,13 @@ export class AssetsController extends BaseController {
         // The data will simply not be updated until the network is re-enabled.
         // Refresh subscriptions for new chain set
         this.#subscribeAssets();
-        // One-time fetch for newly enabled chains. v6 `full` replace is scoped to
-        // those chains; existing balances on other chains are left untouched.
+        // Do one-time fetch for newly enabled chains; merge so we keep existing chain balances
         const accounts = this.#getSelectedAccounts();
         if (addedChains.length > 0 && accounts.length > 0) {
             await this.getAssets(accounts, {
                 chainIds: addedChains,
                 forceUpdate: true,
+                updateMode: 'merge',
             });
         }
         this.#ensureNativeBalancesDefaultZero();
@@ -3110,28 +2745,48 @@ export class AssetsController extends BaseController {
     async handleAssetsUpdate(response, sourceId, request) {
         log('Assets updated from data source', {
             sourceId,
-            assetsBalance: response.assetsBalance,
-            assetsPrice: response.assetsPrice,
+            hasBalance: Boolean(response.assetsBalance),
+            hasPrice: Boolean(response.assetsPrice),
         });
-        if (this.#isBalanceV6Enabled()) {
-            await this.#handleAssetsUpdateV6(response, sourceId, request);
-            return;
-        }
-        await this.#handleAssetsUpdateV5(response, sourceId, request);
-    }
-    async #handleAssetsUpdateV5(response, sourceId, request) {
+        // Enrichment spans only before unlock/first-init fetch completes.
         const pipelineTrace = this.#firstInitFetchReported
             ? undefined
             : this.#trace;
         await withTrace({
             name: TRACE_UPDATE_PARENT,
             trace: pipelineTrace,
-            data: this.#getUpdateTraceData(response, sourceId),
+            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 pipelineRequest = this.#getUpdatePipelineRequest(request);
+                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 = this.#isBasicFunctionality()
+                    ? 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' &&
                     this.#isBasicFunctionality();
                 const shouldRunRpcFallback = sourceId === 'AccountsApiDataSource';
@@ -3150,7 +2805,6 @@ export class AssetsController extends BaseController {
                     ...(shouldRunRpcFallback ? [this.#rpcFallbackMiddleware] : []),
                     this.#detectionMiddleware,
                 ];
-                enrichmentSources.push(this.#detectionMiddleware);
                 if (this.#isBasicFunctionality()) {
                     enrichmentSources.push(createParallelMiddleware([
                         this.#tokenDataSource,
@@ -3168,110 +2822,25 @@ export class AssetsController extends BaseController {
                     ...enrichedResponse,
                     replaceCoveredChainBalances: response.replaceCoveredChainBalances,
                 });
-                this.#emitUpdateTrace({
-                    response,
-                    sourceId,
-                    enrichedResponse,
-                    updateStart,
-                    pipelineTrace,
-                    parentContext,
-                });
-            },
-        });
-    }
-    async #handleAssetsUpdateV6(response, sourceId, request) {
-        const pipelineTrace = this.#firstInitFetchReported
-            ? undefined
-            : this.#trace;
-        await withTrace({
-            name: TRACE_UPDATE_PARENT,
-            trace: pipelineTrace,
-            data: this.#getUpdateTraceData(response, sourceId),
-            fn: async (parentContext) => {
-                const updateStart = performance.now();
-                const pipelineRequest = this.#getUpdatePipelineRequest(request);
-                const shouldFilterOccurrences = sourceId === 'AccountActivityDataSource' &&
-                    this.#isBasicFunctionality();
-                const enrichmentSources = [
-                    ...(shouldFilterOccurrences
-                        ? [
-                            {
-                                getName: () => 'OccurrenceFloorFilter',
-                                assetsMiddleware: this.#tokenDataSource.occurrenceFilterMiddleware,
-                            },
-                        ]
-                        : []),
-                ];
-                if (this.#isBasicFunctionality()) {
-                    enrichmentSources.push(this.#rpcFallbackMiddleware);
-                }
-                enrichmentSources.push(this.#detectionMiddleware);
-                if (this.#isBasicFunctionality()) {
-                    enrichmentSources.push(createParallelMiddleware([
-                        this.#tokenDataSource,
-                        this.#priceDataSource,
-                    ]));
-                }
-                const { response: enrichedResponse } = await this.#executeMiddlewares({
-                    sources: enrichmentSources,
-                    request: pipelineRequest,
-                    initialResponse: response,
-                    parentContext,
+                // Summary fields for Assets Health (nested under the parent span).
+                emitTrace({
+                    name: TRACE_UPDATE_PIPELINE,
                     trace: pipelineTrace,
-                });
-                await this.#updateState(enrichedResponse);
-                this.#emitUpdateTrace({
-                    response,
-                    sourceId,
-                    enrichedResponse,
-                    updateStart,
-                    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,
                 });
             },
         });
     }
-    #getUpdatePipelineRequest(request) {
-        const resolvedRequest = request ?? {
-            accountsWithSupportedChains: [],
-            chainIds: [],
-            dataTypes: ['balance', 'metadata', 'price'],
-        };
-        if (this.#isBasicFunctionality()) {
-            return resolvedRequest;
-        }
-        return {
-            ...resolvedRequest,
-            dataTypes: resolvedRequest.dataTypes.filter((dataType) => dataType !== 'metadata' && dataType !== 'price'),
-        };
-    }
-    #getUpdateTraceData(response, sourceId) {
-        return {
-            source: sourceId,
-            has_balance: Boolean(response.assetsBalance),
-            has_price: Boolean(response.assetsPrice),
-            balance_account_count: response.assetsBalance
-                ? Object.keys(response.assetsBalance).length
-                : 0,
-        };
-    }
-    #emitUpdateTrace({ response, sourceId, enrichedResponse, updateStart, pipelineTrace, parentContext, }) {
-        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
     // ============================================================================