@metamask-previews/assets-controller 16.1.2-preview-ff2ab0583 → 17.0.0-preview-c4789fdf4

package/dist/AssetsController.js

@@ -21,9 +21,10 @@ import { createParallelBalanceMiddleware, createParallelMiddleware, } from './mi
 import { RpcFallbackMiddleware } from './middlewares/RpcFallbackMiddleware.js';
 import { cleanSpamAssets, isUnlockCleanupEnabled, tempHealAssetsInfoMetadata, } from './migrations/healAssetsInfoMetadata.js';
 import { buildFastFetchSources, executeAssetsPipeline, } from './pipeline/index.js';
-import { ZERO_ADDRESS } from './utils/constants.js';
+import { getAssetVisibility } from './utils/assetVisibility.js';
+import { UNKNOWN_EVM_NATIVE_ASSET_REFERENCE, ZERO_ADDRESS, } from './utils/constants.js';
 import { pickRpcCustomAssetsSupplement } from './utils/customAssetsRpcSupplement.js';
-import { normalizeAmountString, normalizeAssetId, formatExchangeRatesForBridge, formatStateForTransactionPay, buildNativeAssetsFromConstant, buildNativeAssetsFromApi, getDefaultNativeAssetBalance, } from './utils/index.js';
+import { normalizeAmountString, normalizeAssetId, formatExchangeRatesForBridge, formatStateForTransactionPay, buildNativeAssetsFromConstant, buildNativeAssetsFromApi, getDefaultNativeAssetBalance, getZeroAssetBalance, } from './utils/index.js';
 import { emitTrace, withTrace } from './utils/trace.js';
 const NATIVE_ASSETS_QUERY_KEY = ['nativeAssets'];
 /** Stable empty map so memoized formatters are not busted by `?? {}` identity churn. */
@@ -190,16 +191,17 @@ function normalizeResponse(response) {
     return normalized;
 }
 /**
- * Merge account balances from a data-source response into prior state.
+ * Compute the effective account balances from a data-source response and prior state.
  *
  * @param previousBalances - Balances already in state for this account.
  * @param accountBalances - Balances from the incoming response.
- * @param customAssetIds - Custom assets to preserve when replacing covered chains.
- * @param replaceCoveredChains - When true, drop prior balances on chains present
- *   in the response before applying it (authoritative chain slice).
- * @returns The merged balance map for the account.
+ * @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.
+ * @returns The effective balance map for the account.
  */
-function mergeAccountBalances(previousBalances, accountBalances, customAssetIds, replaceCoveredChains) {
+function effectiveAccountBalancesV5(previousBalances, accountBalances, customAssetIds, replaceCoveredChains) {
     if (!replaceCoveredChains) {
         return { ...previousBalances, ...accountBalances };
     }
@@ -214,7 +216,7 @@ function mergeAccountBalances(previousBalances, accountBalances, customAssetIds,
     for (const customId of customAssetIds) {
         if (!Object.prototype.hasOwnProperty.call(next, customId)) {
             const prev = previousBalances[customId];
-            next[customId] = prev ?? { amount: '0' };
+            next[customId] = prev ?? getZeroAssetBalance(customId);
         }
     }
     // Staked vault balances are owned by StakedBalanceDataSource. When an
@@ -228,6 +230,43 @@ function mergeAccountBalances(previousBalances, accountBalances, customAssetIds,
     }
     return next;
 }
+/**
+ * Compute the effective account balances for an Accounts API v6 update.
+ *
+ * `merge` overlays the incoming balances on prior state (Account Activity,
+ * Snap events, staking). `full` replaces each covered chain slice. v6 asks
+ * for natives, pins, and default tracked assets through `includeAssetIds`
+ * and either returns them (at zero when the account holds none) or names
+ * them in `unprocessedIncludeAssetIds`. Assets the client tracks on purpose
+ * survive a `full` replace even when the response omits them, so an upstream
+ * gap cannot wipe them — see `shouldKeepAsset`.
+ *
+ * @param previousBalances - Balances already in state for this account.
+ * @param updatedBalances - Balances from the incoming response.
+ * @param undeletableAssetIds - Visible assets the client asked for (native,
+ *   pin, or default tracked). They survive a `full` replace if the response
+ *   omits them. Hidden assets are excluded from snapshots and dropped here;
+ *   unhide is expected to fetch a new snapshot.
+ * @param updateMode - `'merge'` overlays incoming balances; `'full'` replaces
+ *   each updated chain slice except undeletable and staking assets.
+ * @returns The effective balance map for the account.
+ */
+function effectiveAccountBalancesV6(previousBalances, updatedBalances, undeletableAssetIds, updateMode) {
+    if (updateMode === 'merge') {
+        return { ...previousBalances, ...updatedBalances };
+    }
+    const updatedChains = new Set(Object.keys(updatedBalances).map((assetId) => extractChainId(assetId)));
+    const shouldKeepAsset = (assetId) => !updatedChains.has(extractChainId(assetId)) ||
+        undeletableAssetIds.has(assetId.toLowerCase()) ||
+        isStakingContractAssetId(assetId);
+    const keptBalances = {};
+    for (const [assetId, balance] of Object.entries(previousBalances)) {
+        if (shouldKeepAsset(assetId)) {
+            keptBalances[assetId] = balance;
+        }
+    }
+    return { ...keptBalances, ...updatedBalances };
+}
 // ============================================================================
 // CONTROLLER IMPLEMENTATION
 // ============================================================================
@@ -462,17 +501,25 @@ export class AssetsController extends BaseController {
             queryApiClient,
             onActiveChainsUpdated: this.#onActiveChainsUpdated,
             ...accountsApiDataSourceConfig,
+            isBalanceV6Enabled: () => this.#isBalanceV6Enabled(),
+            getAssetsState: () => this.state,
+            getAssetVisibility: this.#getAssetVisibility.bind(this),
         });
         this.#snapDataSource = new SnapDataSource({
             messenger: this.messenger,
             onActiveChainsUpdated: this.#onActiveChainsUpdated,
             onAssetsUpdate: (response) => this.handleAssetsUpdate(response, 'SnapDataSource'),
+            isBalanceV6Enabled: () => this.#isBalanceV6Enabled(),
+            getAssetVisibility: this.#getAssetVisibility.bind(this),
+            getAssetsState: () => this.state,
         });
         this.#rpcDataSource = new RpcDataSource({
             messenger: this.messenger,
+            getAssetsState: () => this.state,
+            isBalanceV6Enabled: () => this.#isBalanceV6Enabled(),
+            getAssetVisibility: this.#getAssetVisibility.bind(this),
             onActiveChainsUpdated: this.#onActiveChainsUpdated,
-            getNativeAssetForChain: (chainId) => this.#getNativeAssetMap()[chainId] ??
-                `${chainId}/erc20:${ZERO_ADDRESS}`,
+            getNativeAssetForChain: (chainId) => this.#getNativeAssetForChain(chainId),
             // Share the API platform's TanStack Query client so the RPC token
             // detector caches/dedupes its top-token-list fetches alongside the rest
             // of the package's API calls. Caller-provided rpcConfig.queryClient
@@ -493,13 +540,17 @@ export class AssetsController extends BaseController {
                 return this.#getNativeAssetIdsForEnabledChains();
             },
             getAssetType: (assetId) => this.#getAssetType(assetId),
+            getAssetsState: () => this.state,
         });
         this.#priceDataSource = new PriceDataSource({
             queryApiClient,
             getSelectedCurrency: () => this.state.selectedCurrency,
+            getAssetsState: () => this.state,
             ...priceDataSourceConfig,
         });
-        this.#detectionMiddleware = new DetectionMiddleware();
+        this.#detectionMiddleware = new DetectionMiddleware({
+            getAssetsState: () => this.state,
+        });
         this.#customAssetGraduationMiddleware = new CustomAssetGraduationMiddleware({
             getSelectedAccountId: () => {
                 try {
@@ -510,9 +561,12 @@ export class AssetsController extends BaseController {
                 }
             },
             removeCustomAsset: (accountId, assetId) => this.removeCustomAsset(accountId, assetId),
+            getAssetsState: () => this.state,
         });
         this.#rpcFallbackMiddleware = new RpcFallbackMiddleware({
             rpcDataSource: this.#rpcDataSource,
+            isBalanceV6Enabled: () => this.#isBalanceV6Enabled(),
+            getAssetsState: () => this.state,
         });
         log('Initializing AssetsController', {
             defaultUpdateInterval: this.#defaultUpdateInterval,
@@ -844,7 +898,7 @@ export class AssetsController extends BaseController {
      * Returns response and exclusive duration per source (sum ≈ wall time).
      *
      * Thin wrapper over {@link executeAssetsPipeline} that supplies the
-     * controller-owned state accessor and exception reporter.
+     * controller-owned exception reporter.
      *
      * @param params - Middleware execution options.
      * @param params.sources - Data sources or middlewares with getName() and assetsMiddleware.
@@ -857,7 +911,6 @@ export class AssetsController extends BaseController {
     async #executeMiddlewares(params) {
         return executeAssetsPipeline({
             ...params,
-            getAssetsState: () => this.state,
             captureException: this.#captureException,
         });
     }
@@ -871,143 +924,255 @@ 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 request = this.#buildDataRequest(accounts, chainIds, {
+            const requestOptions = {
                 assetTypes,
                 dataTypes,
-                customAssets: customAssets.length > 0 ? customAssets : undefined,
                 forceUpdate: true,
                 bypassServerCache: options?.bypassServerCache,
                 assetsForPriceUpdate: options?.assetsForPriceUpdate,
-            });
-            // Fast pipeline: accountsApi + stakedBalance → detection → token + price.
-            // Snap and RPC are excluded here due to their latency (snap triggers account
-            // creation, RPC is slow on many chains). Results are committed to state
-            // immediately so the UI can display balances without waiting for them.
-            //
-            // Fast/slow pipelines use merge so partial API snapshots cannot wipe
-            // tokens missing from the response (e.g. USDC when only native balance
-            // is returned). Balances present in the response are still refreshed.
-            const fastSources = buildFastFetchSources({
-                accountsApiDataSource: this.#accountsApiDataSource,
-                stakedBalanceDataSource: this.#stakedBalanceDataSource,
-                customAssetGraduationMiddleware: this.#customAssetGraduationMiddleware,
-                rpcFallbackMiddleware: this.#rpcFallbackMiddleware,
-                detectionMiddleware: this.#detectionMiddleware,
-                tokenDataSource: this.#tokenDataSource,
-                priceDataSource: this.#priceDataSource,
-            }, { isBasicFunctionality: this.#isBasicFunctionality() });
-            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 }));
+            };
+            if (this.#isBalanceV6Enabled()) {
+                await this.#forceUpdateAssetsV6({
+                    accounts,
+                    chainIds,
+                    request: this.#buildDataRequest(accounts, chainIds, requestOptions),
+                    pipelineTrace,
+                });
+            }
+            else {
+                await this.#forceUpdateAssetsV5({
+                    accounts,
+                    chainIds,
+                    request: this.#buildForceUpdateRequestV5(accounts, chainIds, requestOptions),
+                    pipelineTrace,
+                });
             }
         }
         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.getCustomAssets(account.id));
+        }
+        return this.#buildDataRequest(accounts, chainIds, {
+            ...requestOptions,
+            customAssets: customAssets.length > 0 ? customAssets : undefined,
+        });
+    }
+    async #forceUpdateAssetsV5({ accounts, chainIds, request, pipelineTrace, }) {
+        const isBasicFunctionality = this.#isBasicFunctionality();
+        const fastSources = buildFastFetchSources({
+            accountsApiDataSource: this.#accountsApiDataSource,
+            stakedBalanceDataSource: this.#stakedBalanceDataSource,
+            customAssetGraduationMiddleware: this.#customAssetGraduationMiddleware,
+            rpcFallbackMiddleware: this.#rpcFallbackMiddleware,
+            detectionMiddleware: this.#detectionMiddleware,
+            tokenDataSource: this.#tokenDataSource,
+            priceDataSource: this.#priceDataSource,
+        }, { isBasicFunctionality, includeCustomAssetGraduation: true });
+        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 = buildFastFetchSources({
+            accountsApiDataSource: this.#accountsApiDataSource,
+            stakedBalanceDataSource: this.#stakedBalanceDataSource,
+            customAssetGraduationMiddleware: this.#customAssetGraduationMiddleware,
+            rpcFallbackMiddleware: this.#rpcFallbackMiddleware,
+            detectionMiddleware: this.#detectionMiddleware,
+            tokenDataSource: this.#tokenDataSource,
+            priceDataSource: this.#priceDataSource,
+        }, {
+            isBasicFunctionality,
+            includeCustomAssetGraduation: false,
+        });
+        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);
+            },
+        }).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, {
@@ -1216,7 +1381,8 @@ export class AssetsController extends BaseController {
     /**
      * Add a custom asset for an account.
      * Custom assets are included in subscription and fetch operations.
-     * Adding a custom asset also unhides it if it was previously hidden.
+     * Adding a custom asset also unhides it if it was previously hidden,
+     * and force-fetches that asset's chain (including every visible pin).
      *
      * When `pendingMetadata` is provided (e.g. from the extension's pending-tokens
      * flow), the token metadata is persisted immediately into `assetsInfo` so the
@@ -1273,22 +1439,19 @@ export class AssetsController extends BaseController {
             // before the next pipeline fetch returns the real amount.
             const balances = state.assetsBalance;
             balances[accountId] ??= {};
-            balances[accountId][normalizedAssetId] ??= { amount: '0' };
+            balances[accountId][normalizedAssetId] ??=
+                getZeroAssetBalance(normalizedAssetId);
         });
-        // 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);
             await this.getAssets([account], {
-                chainIds: [chainId],
+                chainIds: [extractChainId(normalizedAssetId)],
                 dataTypes: ['balance', 'metadata', 'price'],
                 assetTypes: ['fungible'],
                 forceUpdate: true,
-                updateMode: 'merge',
             });
         }
-        // Re-evaluate subscriptions so the supplemental RPC poll picks up the
-        // new customAsset on chains another data source already owns.
+        // Re-evaluate subscriptions so polls pick up the new pin.
         this.#subscribeAssets();
     }
     /**
@@ -1309,8 +1472,7 @@ export class AssetsController extends BaseController {
                 }
             }
         });
-        // Re-evaluate subscriptions so the supplemental RPC poll for that chain
-        // is torn down when no more customAssets remain there.
+        // Re-evaluate subscriptions so polls drop the removed pin.
         this.#subscribeAssets();
     }
     /**
@@ -1341,13 +1503,18 @@ 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.
+     * Force-fetches that asset's chain (including every visible pin) so a
+     * `full` snapshot can restore the balance immediately, then re-evaluates
+     * subscriptions so later polls stop excluding it.
      *
      * @param assetId - The CAIP-19 asset ID to unhide.
      */
-    unhideAsset(assetId) {
+    async unhideAsset(assetId) {
         const normalizedAssetId = normalizeAssetId(assetId);
         log('Unhiding asset', { assetId: normalizedAssetId });
         this.update((state) => {
@@ -1359,6 +1526,35 @@ export class AssetsController extends BaseController {
                 }
             }
         });
+        const chainId = extractChainId(normalizedAssetId);
+        const account = this.#getSelectedAccounts().find((selectedAccount) => this.#getEnabledChainsForAccount(selectedAccount).includes(chainId));
+        if (account) {
+            await this.getAssets([account], {
+                chainIds: [chainId],
+                dataTypes: ['balance', 'metadata', 'price'],
+                assetTypes: ['fungible'],
+                forceUpdate: true,
+            });
+        }
+        this.#subscribeAssets();
+    }
+    /**
+     * 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
@@ -1464,7 +1660,6 @@ export class AssetsController extends BaseController {
             subscriptionId: subscriptionKey,
             isUpdate,
             onAssetsUpdate: (response) => this.handleAssetsUpdate(response, 'PriceDataSource'),
-            getAssetsState: () => this.state,
         };
         this.#priceDataSource.subscribe(subscribeReq).catch(console.error);
         // Track subscription
@@ -1504,6 +1699,63 @@ export class AssetsController extends BaseController {
     #getNativeAssetMap() {
         return (this.#queryApiClient.getCachedData(NATIVE_ASSETS_QUERY_KEY) ?? EMPTY_NATIVE_ASSET_MAP);
     }
+    /**
+     * Canonical native CAIP-19 ID for a chain. Uses the native asset map when
+     * the chain is registered. An unregistered EVM chain falls back to the
+     * zero-address ERC-20 encoding used for EVM natives without a SLIP-44 id;
+     * an unregistered non-EVM chain resolves no native at all — fabricating an
+     * `erc20:` asset on a non-EVM namespace would produce an ID no data source
+     * ever writes.
+     *
+     * @param chainId - CAIP-2 chain ID.
+     * @returns The native asset ID for the chain, or `undefined` when the
+     * chain is unregistered and non-EVM.
+     */
+    #getNativeAssetForChain(chainId) {
+        const registered = this.#getNativeAssetMap()[chainId];
+        if (registered) {
+            return registered;
+        }
+        if (parseCaipChainId(chainId).namespace === KnownCaipNamespace.Eip155) {
+            return `${chainId}/${UNKNOWN_EVM_NATIVE_ASSET_REFERENCE}`;
+        }
+        return undefined;
+    }
+    #getAssetVisibility(accountIds, chainIds) {
+        return getAssetVisibility({
+            state: this.state,
+            accountIds,
+            chainIds,
+            getNativeAssetForChain: (chainId) => this.#getNativeAssetForChain(chainId),
+        });
+    }
+    /**
+     * Lowercased asset IDs a v6 `full` snapshot must keep for an account, even
+     * when the response omits them: natives, pins, and default tracked assets
+     * the client asked for. Hidden assets are sent as `excludeAssetIds` and are
+     * dropped here; unhide is expected to fetch a new snapshot. Everything else
+     * on a covered chain was discovered by the source, so its absence means the
+     * balance is gone.
+     *
+     * @param state - State being updated (the in-flight draft, not `this.state`).
+     * @param accountId - Account whose pins apply.
+     * @param accountBalances - Incoming balances, which define the covered chains.
+     * @returns Lowercased CAIP-19 IDs that must survive the replace.
+     */
+    #getUndeletableAssetIds(state, accountId, accountBalances) {
+        const coveredChainIds = [
+            ...new Set(Object.keys(accountBalances).map((assetId) => assetId.split('/')[0])),
+        ];
+        const { visibleAssetIds } = getAssetVisibility({
+            state,
+            accountIds: [accountId],
+            chainIds: coveredChainIds,
+            // Registered natives only: the unknown-native fallback is a fabricated
+            // ID, so it must never shield a row from a `full` replace.
+            getNativeAssetForChain: (chainId) => this.#getNativeAssetMap()[chainId],
+        });
+        return new Set(visibleAssetIds.map((assetId) => assetId.toLowerCase()));
+    }
     /**
      * Checks whether the given CAIP-19 asset ID represents a native asset
      * according to the cached native asset map, the asset namespace, and the asset reference.
@@ -1696,6 +1948,7 @@ export class AssetsController extends BaseController {
     async #updateState(response) {
         const normalizedResponse = normalizeResponse(response);
         const mode = normalizedResponse.updateMode ?? 'merge';
+        const isBalanceV6Enabled = this.#isBalanceV6Enabled();
         const releaseLock = await this.#controllerMutex.acquire();
         try {
             const previousState = this.state;
@@ -1755,24 +2008,23 @@ export class AssetsController extends BaseController {
                     }
                 }
                 if (normalizedResponse.assetsBalance) {
-                    for (const [accountId, accountBalances] of Object.entries(normalizedResponse.assetsBalance)) {
-                        const previousBalances = previousState.assetsBalance[accountId] ?? {};
+                    const applyV5AccountBalanceUpdate = (accountId, accountBalances, previousBalances) => {
                         const customAssetIds = state.customAssets[accountId] ?? [];
                         const replaceCoveredChains = mode === 'full' ||
                             normalizedResponse.replaceCoveredChainBalances === true;
-                        const effective = mergeAccountBalances(previousBalances, accountBalances, customAssetIds, replaceCoveredChains);
+                        const effectiveAccountBalances = effectiveAccountBalancesV5(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
                             ? this.#getNativeAssetIdsForAccount(account)
                             : this.#getNativeAssetIdsForEnabledChains();
                         for (const nativeAssetId of nativeAssetIdsForAccount) {
-                            if (!Object.prototype.hasOwnProperty.call(effective, nativeAssetId)) {
-                                effective[nativeAssetId] =
+                            if (!Object.prototype.hasOwnProperty.call(effectiveAccountBalances, nativeAssetId)) {
+                                effectiveAccountBalances[nativeAssetId] =
                                     getDefaultNativeAssetBalance(nativeAssetId);
                             }
                         }
-                        for (const [assetId, balance] of Object.entries(effective)) {
+                        for (const [assetId, balance] of Object.entries(effectiveAccountBalances)) {
                             const previousBalance = previousBalances[assetId];
                             // Coerce amounts (e.g. "1e-18" from a data source stringifying
                             // a JS Number) into a plain decimal so downstream BigInt()
@@ -1785,15 +2037,17 @@ export class AssetsController extends BaseController {
                             const newAmount = normalizeAmountString(balance.amount, assetDecimals);
                             const newMetadata = balance.metadata ??
                                 previousBalance?.metadata;
-                            effective[assetId] = {
+                            effectiveAccountBalances[assetId] = {
                                 amount: newAmount,
                                 ...(newMetadata === undefined ? {} : { metadata: newMetadata }),
                             };
                             const oldAmount = previousBalance?.amount;
-                            const isNewDefaultNativeZero = oldAmount === undefined &&
+                            const isNewSeededZero = oldAmount === undefined &&
                                 newAmount === '0' &&
-                                nativeAssetIdsForAccount.includes(assetId);
-                            if (oldAmount !== newAmount && !isNewDefaultNativeZero) {
+                                (nativeAssetIdsForAccount.includes(assetId) ||
+                                    getDefaultAssetMetadata(assetId) !==
+                                        undefined);
+                            if (oldAmount !== newAmount && !isNewSeededZero) {
                                 changedBalances.push({
                                     accountId,
                                     assetId,
@@ -1802,8 +2056,49 @@ export class AssetsController extends BaseController {
                                 });
                             }
                         }
-                        if (!isEqual(previousBalances, effective)) {
-                            balances[accountId] = effective;
+                        if (!isEqual(previousBalances, effectiveAccountBalances)) {
+                            balances[accountId] = effectiveAccountBalances;
+                        }
+                    };
+                    // Delete with the rest of the v6 path if `assetsAccountsApiV6` is
+                    // rolled back; v5 keeps using `applyV5AccountBalanceUpdate`.
+                    const applyV6AccountBalanceUpdate = (accountId, accountBalances, previousBalances) => {
+                        const effectiveAccountBalances = effectiveAccountBalancesV6(previousBalances, accountBalances, this.#getUndeletableAssetIds(state, accountId, accountBalances), mode);
+                        for (const [assetId, balance] of Object.entries(effectiveAccountBalances)) {
+                            const previousBalance = previousBalances[assetId];
+                            const assetDecimals = metadata[assetId]?.decimals;
+                            const newAmount = normalizeAmountString(balance.amount, assetDecimals);
+                            const newMetadata = balance.metadata ??
+                                previousBalance?.metadata;
+                            effectiveAccountBalances[assetId] = {
+                                amount: newAmount,
+                                ...(newMetadata === undefined ? {} : { metadata: newMetadata }),
+                            };
+                            const oldAmount = previousBalance?.amount;
+                            // A v6 snapshot reports assets the account holds none of (its
+                            // `includeAssetIds`) at zero. Publishing those as a change would
+                            // emit `0 -> 0`, since a missing previous amount reads as '0'.
+                            const isNewZero = oldAmount === undefined && newAmount === '0';
+                            if (oldAmount !== newAmount && !isNewZero) {
+                                changedBalances.push({
+                                    accountId,
+                                    assetId,
+                                    oldAmount,
+                                    newAmount,
+                                });
+                            }
+                        }
+                        if (!isEqual(previousBalances, effectiveAccountBalances)) {
+                            balances[accountId] = effectiveAccountBalances;
+                        }
+                    };
+                    for (const [accountId, accountBalances] of Object.entries(normalizedResponse.assetsBalance)) {
+                        const previousBalances = previousState.assetsBalance[accountId] ?? {};
+                        if (isBalanceV6Enabled) {
+                            applyV6AccountBalanceUpdate(accountId, accountBalances, previousBalances);
+                        }
+                        else {
+                            applyV5AccountBalanceUpdate(accountId, accountBalances, previousBalances);
                         }
                     }
                 }
@@ -1827,10 +2122,8 @@ export class AssetsController extends BaseController {
                 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,
+                    changedMetadata: changedMetadata.length > 0 ? changedMetadata : undefined,
+                    changedPrices: changedPriceAssets.length > 0 ? changedPriceAssets : undefined,
                     newAssets: Object.keys(detectedAssets).length > 0
                         ? Object.entries(detectedAssets).map(([accountId, assets]) => ({
                             accountId,
@@ -2052,16 +2345,10 @@ export class AssetsController extends BaseController {
             if (!subscriptionKey.startsWith('ds:')) {
                 continue;
             }
-            // Subscription keys take the form `ds:<SourceName>` for the regular
-            // subscription or `ds:<SourceName>:<suffix>` for supplemental
-            // subscriptions (e.g. `ds:RpcDataSource:custom`). Split on `:` and
-            // pick the source-name segment so both shapes resolve correctly.
+            // Subscription keys take the form `ds:<SourceName>`.
             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);
             }
         }
@@ -2105,10 +2392,12 @@ 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 (ordered by priority) - each data source gets ONE subscription
-     *
-     * This ensures we make minimal subscriptions to each data source while covering
-     * all accounts and chains.
+     * 3. Split by data source (priority order) — each source gets one
+     *    subscription for the chains it was assigned (accounts + chains only).
+     *    v6 sources read pins/hides/defaults from state themselves (Accounts API
+     *    sends `includeAssetIds` / `excludeAssetIds`; RPC polls native, balances,
+     *    pins, and default tracked assets). v5 uses a separate RPC
+     *    `customAssetsOnly` supplement for pins on chains another source owns.
      *
      * @param accounts - Accounts to subscribe balance updates for.
      * @param chainIds - Chain IDs to subscribe for.
@@ -2118,10 +2407,7 @@ export class AssetsController extends BaseController {
     #subscribeAssetsBalance(accounts, chainIds, options) {
         const chainToAccounts = this.#buildChainToAccountsMap(accounts, new Set(chainIds));
         const remainingChains = new Set(chainToAccounts.keys());
-        // When basic functionality is on, use all balance data sources; when off,
-        // RPC only.
-        const isBasicFunctionality = this.#isBasicFunctionality();
-        const balanceDataSources = isBasicFunctionality
+        const balanceDataSources = this.#isBasicFunctionality()
             ? this.#allBalanceDataSources
             : [this.#rpcDataSource];
         let rpcAssignedChains = new Set();
@@ -2160,22 +2446,15 @@ 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);
+        if (!this.#isBalanceV6Enabled()) {
+            this.#subscribeRpcCustomAssetsSupplement(accounts, chainToAccounts, rpcAssignedChains);
+        }
     }
     /**
      * 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 (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.
+     * tokens on the Accounts API v5 path (see `pickRpcCustomAssetsSupplement`).
      *
      * @param accounts - Accounts to consider for customAssets.
      * @param chainToAccounts - Map of chain → accounts (built by caller).
@@ -2273,7 +2552,8 @@ 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.customAssetsOnly - When true, only poll customAssets for these chains.
+     * @param options.customAssetsOnly - When true, only poll customAssets for these
+     * chains (Accounts API v5 supplemental RPC subscription).
      * @param options.skipInitialFetch - When true, skip the data source's subscribe-time fetch.
      */
     #subscribeDataSource(source, accounts, chains, options = {}) {
@@ -2302,7 +2582,6 @@ export class AssetsController extends BaseController {
             subscriptionId: subscriptionKey,
             isUpdate,
             onAssetsUpdate: (response, request) => this.handleAssetsUpdate(response, sourceId, request),
-            getAssetsState: () => this.state,
             ...(options.skipInitialFetch === true ? { skipInitialFetch: true } : {}),
         };
         source.subscribe(subscribeReq).catch((error) => {
@@ -2486,13 +2765,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();
-        // Do one-time fetch for newly enabled chains; merge so we keep existing chain balances
+        // One-time fetch for newly enabled chains. v6 `full` replace is scoped to
+        // those chains; existing balances on other chains are left untouched.
         const accounts = this.#getSelectedAccounts();
         if (addedChains.length > 0 && accounts.length > 0) {
             await this.getAssets(accounts, {
                 chainIds: addedChains,
                 forceUpdate: true,
-                updateMode: 'merge',
             });
         }
         this.#ensureNativeBalancesDefaultZero();
@@ -2652,48 +2931,28 @@ export class AssetsController extends BaseController {
     async handleAssetsUpdate(response, sourceId, request) {
         log('Assets updated from data source', {
             sourceId,
-            hasBalance: Boolean(response.assetsBalance),
-            hasPrice: Boolean(response.assetsPrice),
+            assetsBalance: response.assetsBalance,
+            assetsPrice: response.assetsPrice,
         });
-        // Enrichment spans only before unlock/first-init fetch completes.
+        if (this.#isBalanceV6Enabled()) {
+            await this.#handleAssetsUpdateV6(response, sourceId, request);
+            return;
+        }
+        await this.#handleAssetsUpdateV5(response, sourceId, request);
+    }
+    async #handleAssetsUpdateV5(response, sourceId, request) {
         const pipelineTrace = this.#firstInitFetchReported
             ? undefined
             : this.#trace;
         await withTrace({
             name: TRACE_UPDATE_PARENT,
             trace: pipelineTrace,
-            data: {
-                source: sourceId,
-                has_balance: Boolean(response.assetsBalance),
-                has_price: Boolean(response.assetsPrice),
-                balance_account_count: response.assetsBalance
-                    ? Object.keys(response.assetsBalance).length
-                    : 0,
-            },
+            data: this.#getUpdateTraceData(response, sourceId),
             fn: async (parentContext) => {
                 const updateStart = performance.now();
-                const resolvedRequest = request ?? {
-                    accountsWithSupportedChains: [],
-                    chainIds: [],
-                    dataTypes: ['balance', 'metadata', 'price'],
-                };
-                // RPC-only mode (basic functionality off): never run token/price APIs. Strip
-                // those data types so downstream middleware cannot treat them as requested.
-                const pipelineRequest = 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 pipelineRequest = this.#getUpdatePipelineRequest(request);
                 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';
@@ -2729,25 +2988,110 @@ export class AssetsController extends BaseController {
                     ...enrichedResponse,
                     replaceCoveredChainBalances: response.replaceCoveredChainBalances,
                 });
-                // Summary fields for Assets Health (nested under the parent span).
-                emitTrace({
-                    name: TRACE_UPDATE_PIPELINE,
+                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,
                     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,
-                    },
+                });
+                await this.#updateState(enrichedResponse);
+                this.#emitUpdateTrace({
+                    response,
+                    sourceId,
+                    enrichedResponse,
+                    updateStart,
+                    pipelineTrace,
                     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
     // ============================================================================