@metamask-previews/assets-controller 16.1.0-preview-b1e33e9f1 → 16.1.0-preview-d2ea3cc

package/dist/data-sources/RpcDataSource.js

@@ -1,13 +1,12 @@
 import { Web3Provider } from '@ethersproject/providers';
 import { toHex } from '@metamask/controller-utils';
-import { isStrictHexString, isCaipChainId, KnownCaipNamespace, parseCaipAssetType, parseCaipChainId, hexToNumber, toCaipChainId, } from '@metamask/utils';
+import { isStrictHexString, isCaipChainId, parseCaipAssetType, parseCaipChainId, hexToNumber, toCaipChainId, KnownCaipNamespace, } from '@metamask/utils';
 import { BigNumber as BigNumberJS } from 'bignumber.js';
 import { projectLogger, createModuleLogger } from '../logger.js';
 import { ZERO_ADDRESS } from '../utils/constants.js';
-import { filterFailedChainBalances } from '../utils/filterFailedChainBalances.js';
 import { normalizeAssetId } from '../utils/index.js';
 import { AbstractDataSource } from './AbstractDataSource.js';
-import { BalanceFetcher, isStakingContractAssetId, MulticallClient, TokenDetector, TokensApiClient, } from './evm-rpc-services/index.js';
+import { BalanceFetcher, MulticallClient, TokenDetector, TokensApiClient, } from './evm-rpc-services/index.js';
 import { shouldSkipNativeForCaipChainId } from './evm-rpc-services/utils/assets.js';
 const CONTROLLER_NAME = 'RpcDataSource';
 const DEFAULT_BALANCE_INTERVAL = 30_000; // 30 seconds
@@ -48,7 +47,6 @@ export const caipChainIdToHex = (chainId) => {
  */
 export class RpcDataSource extends AbstractDataSource {
     #messenger;
-    #getAssetsState;
     #onActiveChainsUpdated;
     #getNativeAssetForChain;
     #timeout;
@@ -69,12 +67,9 @@ export class RpcDataSource extends AbstractDataSource {
     #balanceFetcher;
     #tokenDetector;
     #getAssetType;
-    #isBalanceV6Enabled;
-    #getAssetVisibility;
     constructor(options) {
         super(CONTROLLER_NAME, { activeChains: [] });
         this.#messenger = options.messenger;
-        this.#getAssetsState = options.getAssetsState;
         this.#onActiveChainsUpdated = options.onActiveChainsUpdated;
         this.#getNativeAssetForChain = options.getNativeAssetForChain;
         this.#getAssetType = options.getAssetType;
@@ -84,9 +79,6 @@ export class RpcDataSource extends AbstractDataSource {
         this.#useExternalService =
             options.useExternalService ?? (() => true);
         this.#isOnboarded = options.isOnboarded ?? (() => true);
-        this.#isBalanceV6Enabled =
-            options.isBalanceV6Enabled ?? (() => false);
-        this.#getAssetVisibility = options.getAssetVisibility;
         const balanceInterval = options.balanceInterval ?? DEFAULT_BALANCE_INTERVAL;
         const detectionInterval = options.detectionInterval ?? DEFAULT_DETECTION_INTERVAL;
         log('Initializing RpcDataSource', {
@@ -126,8 +118,6 @@ export class RpcDataSource extends AbstractDataSource {
                 const nativeId = this.#getNativeAssetForChain(chainId);
                 return nativeId?.toLowerCase() === assetId.toLowerCase();
             },
-            isBalanceV6Enabled: () => this.#isBalanceV6Enabled(),
-            getAssetVisibility: this.#getAssetVisibility,
         });
         // Polling controller awaits this callback; rejections must not become unhandled.
         this.#balanceFetcher.setOnBalanceUpdate(async (result) => {
@@ -273,19 +263,6 @@ export class RpcDataSource extends AbstractDataSource {
      * @param result - The balance fetch result.
      */
     async #handleBalanceUpdate(result) {
-        if (this.#isBalanceV6Enabled()) {
-            await this.#handleBalanceUpdateV6(result);
-            return;
-        }
-        await this.#handleBalanceUpdateV5(result);
-    }
-    /**
-     * v5 poll path. Unchanged from the pre-v6 handler; delete the v6 sibling
-     * first if `assetsAccountsApiV6` is rolled back.
-     *
-     * @param result - The balance fetch result.
-     */
-    async #handleBalanceUpdateV5(result) {
         const newBalances = {};
         // Convert hex chain ID to CAIP-2 format
         const chainIdDecimal = parseInt(result.chainId, 16);
@@ -336,75 +313,6 @@ export class RpcDataSource extends AbstractDataSource {
             });
         }
     }
-    /**
-     * v6 poll path: a complete chain snapshot, or nothing. Delete with the rest
-     * of the v6 path if `assetsAccountsApiV6` is rolled back.
-     *
-     * @param result - The balance fetch result.
-     */
-    async #handleBalanceUpdateV6(result) {
-        if (result.failedAddresses.length > 0) {
-            log('Skipping incomplete v6 poll snapshot', {
-                accountId: result.accountId,
-                chainId: result.chainId,
-                failedAddresses: result.failedAddresses,
-            });
-            return;
-        }
-        const newBalances = {};
-        // Convert hex chain ID to CAIP-2 format
-        const chainIdDecimal = parseInt(result.chainId, 16);
-        const caipChainId = `eip155:${chainIdDecimal}`;
-        // Normalize asset IDs from BalanceFetcher (lowercase) to checksummed form
-        const normalizedBalances = result.balances.map((b) => ({
-            ...b,
-            assetId: normalizeAssetId(b.assetId),
-        }));
-        // Collect metadata for all balances
-        const assetsInfo = this.#collectMetadataForBalances(normalizedBalances, caipChainId);
-        // Convert balances to human-readable format.
-        // Unknown decimals mean the snapshot is incomplete: drop the chain
-        // instead of publishing a partial `full` result.
-        const existingMetadata = this.#getExistingAssetsMetadata();
-        for (const balance of normalizedBalances) {
-            const stateMetadata = existingMetadata[balance.assetId];
-            const pipelineMetadata = assetsInfo[balance.assetId];
-            const decimals = this.#pickValidDecimals(stateMetadata, pipelineMetadata);
-            if (decimals === undefined) {
-                log('Skipping incomplete v6 poll snapshot', {
-                    accountId: result.accountId,
-                    chainId: result.chainId,
-                    assetId: balance.assetId,
-                });
-                return;
-            }
-            const humanReadableAmount = this.#convertToHumanReadable(balance.balance, decimals);
-            newBalances[balance.assetId] = {
-                amount: humanReadableAmount,
-            };
-        }
-        const response = {
-            assetsBalance: {
-                [result.accountId]: newBalances,
-            },
-            assetsInfo,
-            updateMode: 'full',
-        };
-        const request = {
-            accountsWithSupportedChains: [],
-            chainIds: [caipChainId],
-            dataTypes: ['balance'],
-        };
-        log('Balance update response', {
-            accountId: result.accountId,
-            newBalanceCount: Object.keys(newBalances).length,
-        });
-        for (const subscription of this.#activeSubscriptions.values()) {
-            subscription.onAssetsUpdate(response, request)?.catch((error) => {
-                log('Failed to update assets', { error });
-            });
-        }
-    }
     /**
      * Handle detection update from TokenDetector.
      *
@@ -753,80 +661,21 @@ export class RpcDataSource extends AbstractDataSource {
             log('Skipping fetch - onboarding not complete');
             return {};
         }
-        if (this.#isBalanceV6Enabled()) {
-            return this.#fetchV6(request);
-        }
-        return this.#fetchV5(request);
-    }
-    /**
-     * v5 fetch. Overlays tokens that succeed, stamps `merge`. Delete with the
-     * rest of the v5 path if `assetsAccountsApiV6` is rolled back.
-     *
-     * @param request - The data request.
-     * @returns Balance and metadata for the requested chains.
-     */
-    async #fetchV5(request) {
-        const chainsToFetch = this.#getChainsToFetch(request);
-        if (chainsToFetch.length === 0) {
-            log('No active chains to fetch');
-            return {};
-        }
-        const assetsBalance = {};
-        const assetsInfo = {};
-        const failedChains = [];
-        for (const { account, supportedChains, } of request.accountsWithSupportedChains) {
-            const chainsForAccount = chainsToFetch.filter((chain) => supportedChains.includes(chain));
-            if (chainsForAccount.length === 0) {
-                continue;
-            }
-            const { address, id: accountId } = account;
-            for (const chainId of chainsForAccount) {
-                const hexChainId = caipChainIdToHex(chainId);
-                const nativeAssetId = this.#getNativeAssetForChain(chainId);
-                const shouldSkipNative = shouldSkipNativeForCaipChainId(chainId);
-                const assetsToFetch = this.#getAssetsToFetchV5(request, chainId, shouldSkipNative);
-                try {
-                    const result = await this.#balanceFetcher.fetchBalancesForAssets(hexChainId, accountId, address, assetsToFetch);
-                    await this.#ingestFetchedBalances(result, accountId, chainId, assetsBalance, assetsInfo);
-                }
-                catch (error) {
-                    this.#recordFetchChainFailure({
-                        address,
-                        chainId,
-                        error,
-                        accountId,
-                        nativeAssetId,
-                        shouldSkipNative,
-                        assetsBalance,
-                        assetsInfo,
-                        failedChains,
-                    });
-                }
-            }
-        }
-        return this.#completeFetchResponse({
-            assetsBalance,
-            assetsInfo,
-            failedChains,
+        const response = {};
+        const chainsToFetch = request.chainIds.filter((chainId) => this.#activeChains.includes(chainId));
+        log('Fetch requested', {
+            accounts: request.accountsWithSupportedChains.map((a) => a.account.id),
+            requestedChains: request.chainIds,
             chainsToFetch,
-            updateMode: 'merge',
         });
-    }
-    /**
-     * v6 fetch. Visibility-scoped snapshot, atomic per chain, stamps `full`.
-     *
-     * @param request - The data request.
-     * @returns Balance and metadata for successful chains only.
-     */
-    async #fetchV6(request) {
-        const chainsToFetch = this.#getChainsToFetch(request);
         if (chainsToFetch.length === 0) {
             log('No active chains to fetch');
-            return {};
+            return response;
         }
         const assetsBalance = {};
         const assetsInfo = {};
         const failedChains = [];
+        // Fetch balances for each account and its supported chains (pre-computed in request)
         for (const { account, supportedChains, } of request.accountsWithSupportedChains) {
             const chainsForAccount = chainsToFetch.filter((chain) => supportedChains.includes(chain));
             if (chainsForAccount.length === 0) {
@@ -837,133 +686,100 @@ export class RpcDataSource extends AbstractDataSource {
                 const hexChainId = caipChainIdToHex(chainId);
                 const nativeAssetId = this.#getNativeAssetForChain(chainId);
                 const shouldSkipNative = shouldSkipNativeForCaipChainId(chainId);
-                try {
-                    const result = await this.#balanceFetcher.fetchBalancesForAssets(hexChainId, accountId, address, this.#getAssetsToFetchV6(accountId, chainId));
-                    // A failed `balanceOf` or unresolved decimals means we do not have
-                    // the full list, so drop this chain instead of applying a partial
-                    // `full` snapshot (which would omit that token from state).
-                    if (result.failedAddresses.length > 0) {
-                        if (!failedChains.includes(chainId)) {
-                            failedChains.push(chainId);
+                const assetsToFetch = [];
+                if (!shouldSkipNative) {
+                    // Build a single AssetFetchEntry[] for native + custom ERC-20s
+                    assetsToFetch.push({ assetId: nativeAssetId, address: ZERO_ADDRESS });
+                }
+                if (request.customAssets) {
+                    const existingMetadata = this.#getExistingAssetsMetadata();
+                    for (const assetId of request.customAssets) {
+                        try {
+                            const parsed = parseCaipAssetType(assetId);
+                            const assetChainId = `${parsed.chain.namespace}:${parsed.chain.reference}`;
+                            if (assetChainId === chainId &&
+                                this.#getAssetType(assetId) === 'erc20') {
+                                const tokenAddress = parsed.assetReference.toLowerCase();
+                                const normalizedId = normalizeAssetId(assetId);
+                                const decimals = existingMetadata[normalizedId]?.decimals;
+                                assetsToFetch.push({
+                                    assetId,
+                                    address: tokenAddress,
+                                    decimals,
+                                });
+                            }
                         }
-                        continue;
+                        catch {
+                            // Skip unparseable asset IDs
+                        }
+                    }
+                }
+                try {
+                    const result = await this.#balanceFetcher.fetchBalancesForAssets(hexChainId, accountId, address, assetsToFetch);
+                    if (!assetsBalance[accountId]) {
+                        assetsBalance[accountId] = {};
                     }
-                    const ingested = await this.#ingestFetchedBalances(result, accountId, chainId, assetsBalance, assetsInfo, { failOnUnresolvedDecimals: true });
-                    if (!ingested) {
-                        if (!failedChains.includes(chainId)) {
-                            failedChains.push(chainId);
+                    // Normalize asset IDs from BalanceFetcher (which uses lowercase
+                    // addresses) to checksummed form so they match assetsInfo state keys.
+                    const normalizedBalances = result.balances.map((b) => ({
+                        ...b,
+                        assetId: normalizeAssetId(b.assetId),
+                    }));
+                    // Collect metadata for all balances
+                    const balanceMetadata = this.#collectMetadataForBalances(normalizedBalances, chainId);
+                    Object.assign(assetsInfo, balanceMetadata);
+                    // Convert balances to human-readable format using decimals from
+                    // assetsInfo state (which includes pendingMetadata from addCustomAsset).
+                    // Resolution: state → pipeline metadata → RPC `decimals()`; omit balance if still unknown.
+                    const existingMetadata = this.#getExistingAssetsMetadata();
+                    for (const balance of normalizedBalances) {
+                        const stateMetadata = existingMetadata[balance.assetId];
+                        const pipelineMetadata = assetsInfo[balance.assetId];
+                        let decimals = this.#pickValidDecimals(stateMetadata, pipelineMetadata);
+                        if (decimals === undefined) {
+                            const parsed = parseCaipAssetType(balance.assetId);
+                            if (this.#getAssetType(balance.assetId) === 'erc20') {
+                                decimals = await this.#fetchDecimalsViaRpc(chainId, parsed.assetReference);
+                            }
+                        }
+                        if (decimals === undefined) {
+                            continue;
                         }
+                        const humanReadableAmount = this.#convertToHumanReadable(balance.balance, decimals);
+                        assetsBalance[accountId][balance.assetId] = {
+                            amount: humanReadableAmount,
+                        };
                     }
                 }
                 catch (error) {
-                    this.#recordFetchChainFailure({
-                        address,
-                        chainId,
-                        error,
-                        accountId,
-                        nativeAssetId,
-                        shouldSkipNative,
-                        assetsBalance,
-                        assetsInfo,
-                        failedChains,
-                    });
+                    log('Failed to fetch balance', { address, chainId, error });
+                    if (!assetsBalance[accountId]) {
+                        assetsBalance[accountId] = {};
+                    }
+                    if (!shouldSkipNative) {
+                        assetsBalance[accountId][nativeAssetId] = { amount: '0' };
+                    }
+                    // On error, emit a stub only when no valid metadata exists in state
+                    // yet. Re-emitting existing metadata would overwrite richer entries
+                    // (e.g. image/description added by AccountsAPI) with a simpler stub.
+                    const existingNativeMeta = this.#getExistingAssetsMetadata()[nativeAssetId];
+                    if (!this.#hasValidDecimals(existingNativeMeta)) {
+                        const chainStatus = this.#chainStatuses[chainId];
+                        if (chainStatus) {
+                            assetsInfo[nativeAssetId] = {
+                                type: 'native',
+                                symbol: chainStatus.nativeCurrency,
+                                name: chainStatus.nativeCurrency,
+                                decimals: 18,
+                            };
+                        }
+                    }
+                    if (!failedChains.includes(chainId)) {
+                        failedChains.push(chainId);
+                    }
                 }
             }
         }
-        return this.#completeFetchResponse({
-            // A failed chain contributes nothing, so its balances stay as they are.
-            assetsBalance: filterFailedChainBalances(assetsBalance, new Set(failedChains)),
-            assetsInfo,
-            failedChains,
-            chainsToFetch,
-            updateMode: 'full',
-        });
-    }
-    #getChainsToFetch(request) {
-        const chainsToFetch = request.chainIds.filter((chainId) => this.#activeChains.includes(chainId));
-        log('Fetch requested', {
-            accounts: request.accountsWithSupportedChains.map((a) => a.account.id),
-            requestedChains: request.chainIds,
-            chainsToFetch,
-        });
-        return chainsToFetch;
-    }
-    /**
-     * Convert fetched raw balances into human-readable amounts.
-     *
-     * v5 overlays tokens that resolve and skips the rest (`merge`). v6 must not
-     * publish a partial `full` snapshot: when `failOnUnresolvedDecimals` is set,
-     * unresolved decimals abort ingest so the caller can fail the chain.
-     *
-     * @param result - The balance fetch result.
-     * @param accountId - The account the balances belong to.
-     * @param chainId - The CAIP-2 chain ID.
-     * @param assetsBalance - Accumulator for converted balances.
-     * @param assetsInfo - Accumulator for metadata collected from this fetch.
-     * @param options - Ingest options.
-     * @param options.failOnUnresolvedDecimals - When true, stop ingesting and
-     * return false if any token's decimals cannot be resolved.
-     * @returns `false` when ingest was aborted for unresolved decimals; otherwise `true`.
-     */
-    async #ingestFetchedBalances(result, accountId, chainId, assetsBalance, assetsInfo, { failOnUnresolvedDecimals = false, } = {}) {
-        assetsBalance[accountId] ??= {};
-        const normalizedBalances = result.balances.map((balance) => ({
-            ...balance,
-            assetId: normalizeAssetId(balance.assetId),
-        }));
-        Object.assign(assetsInfo, this.#collectMetadataForBalances(normalizedBalances, chainId));
-        const existingMetadata = this.#getExistingAssetsMetadata();
-        for (const balance of normalizedBalances) {
-            const stateMetadata = existingMetadata[balance.assetId];
-            const pipelineMetadata = assetsInfo[balance.assetId];
-            let decimals = this.#pickValidDecimals(stateMetadata, pipelineMetadata);
-            if (decimals === undefined) {
-                const parsed = parseCaipAssetType(balance.assetId);
-                if (this.#getAssetType(balance.assetId) === 'erc20') {
-                    decimals = await this.#fetchDecimalsViaRpc(chainId, parsed.assetReference);
-                }
-            }
-            if (decimals === undefined) {
-                if (failOnUnresolvedDecimals) {
-                    log('Skipping incomplete v6 fetch snapshot', {
-                        accountId,
-                        chainId,
-                        assetId: balance.assetId,
-                    });
-                    return false;
-                }
-                continue;
-            }
-            assetsBalance[accountId][balance.assetId] = {
-                amount: this.#convertToHumanReadable(balance.balance, decimals),
-            };
-        }
-        return true;
-    }
-    #recordFetchChainFailure({ address, chainId, error, accountId, nativeAssetId, shouldSkipNative, assetsBalance, assetsInfo, failedChains, }) {
-        log('Failed to fetch balance', { address, chainId, error });
-        assetsBalance[accountId] ??= {};
-        if (!shouldSkipNative) {
-            assetsBalance[accountId][nativeAssetId] = { amount: '0' };
-        }
-        const existingNativeMeta = this.#getExistingAssetsMetadata()[nativeAssetId];
-        if (!this.#hasValidDecimals(existingNativeMeta)) {
-            const chainStatus = this.#chainStatuses[chainId];
-            if (chainStatus) {
-                assetsInfo[nativeAssetId] = {
-                    type: 'native',
-                    symbol: chainStatus.nativeCurrency,
-                    name: chainStatus.nativeCurrency,
-                    decimals: 18,
-                };
-            }
-        }
-        if (!failedChains.includes(chainId)) {
-            failedChains.push(chainId);
-        }
-    }
-    #completeFetchResponse({ assetsBalance, assetsInfo, failedChains, chainsToFetch, updateMode, }) {
-        const response = { updateMode };
         if (failedChains.length > 0) {
             log('Fetch PARTIAL - some chains failed', {
                 successChains: chainsToFetch.filter((chain) => !failedChains.includes(chain)),
@@ -977,13 +793,15 @@ export class RpcDataSource extends AbstractDataSource {
         else {
             log('Fetch SUCCESS', {
                 chains: chainsToFetch,
-                accountCount: Object.keys(assetsBalance ?? {}).length,
+                accountCount: Object.keys(assetsBalance).length,
             });
         }
         response.assetsBalance = assetsBalance;
+        // Include metadata for native tokens if we have any
         if (Object.keys(assetsInfo).length > 0) {
             response.assetsInfo = assetsInfo;
         }
+        response.updateMode = 'merge';
         return response;
     }
     /**
@@ -1101,12 +919,6 @@ export class RpcDataSource extends AbstractDataSource {
                     ...response.errors,
                 };
             }
-            if (response.updateMode) {
-                context.response = {
-                    ...context.response,
-                    updateMode: response.updateMode,
-                };
-            }
             const failedChains = new Set(Object.keys(response.errors ?? {}));
             successfullyHandledChains = supportedChains.filter((chainId) => !failedChains.has(chainId));
             if (successfullyHandledChains.length > 0) {
@@ -1186,6 +998,8 @@ export class RpcDataSource extends AbstractDataSource {
                 };
                 const balanceToken = this.#balanceFetcher.startPolling(balanceInput);
                 balancePollingTokens.push(balanceToken);
+                // Token detection is only relevant for "regular" subscriptions —
+                // a customAssetsOnly subscription should never run detection.
                 if (request.customAssetsOnly !== true &&
                     this.#tokenDetectionEnabled() &&
                     this.#useExternalService()) {
@@ -1235,118 +1049,6 @@ export class RpcDataSource extends AbstractDataSource {
             log('Unsubscribed and stopped polling', { subscriptionId });
         }
     }
-    /**
-     * v5 entries for one account-chain fetch: native plus the ERC-20s the
-     * caller scoped via `request.customAssets`. Unchanged from the pre-v6
-     * behavior; delete with the rest of the v5 path.
-     *
-     * @param request - The data request being fetched.
-     * @param chainId - Chain being fetched.
-     * @param shouldSkipNative - When true, omit the native entry.
-     * @returns Entries to hand to the balance fetcher.
-     */
-    #getAssetsToFetchV5(request, chainId, shouldSkipNative) {
-        const assetsToFetch = [];
-        if (!shouldSkipNative) {
-            // Build a single AssetFetchEntry[] for native + custom ERC-20s
-            assetsToFetch.push({
-                assetId: this.#getNativeAssetForChain(chainId),
-                address: ZERO_ADDRESS,
-            });
-        }
-        if (request.customAssets) {
-            const existingMetadata = this.#getExistingAssetsMetadata();
-            for (const assetId of request.customAssets) {
-                try {
-                    const parsed = parseCaipAssetType(assetId);
-                    const assetChainId = `${parsed.chain.namespace}:${parsed.chain.reference}`;
-                    if (assetChainId === chainId &&
-                        this.#getAssetType(assetId) === 'erc20') {
-                        const tokenAddress = parsed.assetReference.toLowerCase();
-                        const normalizedId = normalizeAssetId(assetId);
-                        const decimals = existingMetadata[normalizedId]?.decimals;
-                        assetsToFetch.push({
-                            assetId,
-                            address: tokenAddress,
-                            decimals,
-                        });
-                    }
-                }
-                catch {
-                    // Skip unparseable asset IDs
-                }
-            }
-        }
-        return assetsToFetch;
-    }
-    /**
-     * v6 entries for one account-chain fetch: the shared visible set (native,
-     * pins, default tracked) plus already-tracked ERC-20s that are not hidden.
-     * Chains with no native token omit native from `visibleAssetIds`. Hide is
-     * only applied to `assetsBalance` rows. The request is never scoped via
-     * `customAssets` on v6.
-     *
-     * @param accountId - Account being fetched.
-     * @param chainId - Chain being fetched.
-     * @returns Entries to hand to the balance fetcher.
-     */
-    #getAssetsToFetchV6(accountId, chainId) {
-        const { assetsInfo = {}, assetsBalance = {} } = this.#getAssetsState();
-        const { visibleAssetIds, hiddenAssetIds } = this.#getAssetVisibility([accountId], [chainId]);
-        const hidden = new Set(hiddenAssetIds);
-        const assetsToFetch = [];
-        const seen = new Set();
-        // Fetch visible assets
-        for (const assetId of visibleAssetIds) {
-            try {
-                if (this.#getAssetType(assetId) === 'native') {
-                    assetsToFetch.push({ assetId, address: ZERO_ADDRESS });
-                    continue;
-                }
-                const parsed = parseCaipAssetType(assetId);
-                const assetChainId = `${parsed.chain.namespace}:${parsed.chain.reference}`;
-                if (assetChainId !== chainId ||
-                    this.#getAssetType(assetId) !== 'erc20' ||
-                    seen.has(assetId)) {
-                    continue;
-                }
-                seen.add(assetId);
-                assetsToFetch.push({
-                    assetId,
-                    address: parsed.assetReference.toLowerCase(),
-                    decimals: assetsInfo[assetId]?.decimals,
-                });
-            }
-            catch {
-                // Skip unparseable asset IDs
-            }
-        }
-        // Fetch already-tracked ERC-20s that are not hidden
-        for (const assetId of Object.keys(assetsBalance[accountId] ?? {})) {
-            try {
-                const parsed = parseCaipAssetType(assetId);
-                const assetChainId = `${parsed.chain.namespace}:${parsed.chain.reference}`;
-                const normalizedId = normalizeAssetId(assetId);
-                if (hidden.has(normalizedId) ||
-                    isStakingContractAssetId(assetId) ||
-                    assetChainId !== chainId ||
-                    this.#getAssetType(assetId) !== 'erc20' ||
-                    seen.has(normalizedId)) {
-                    continue;
-                }
-                seen.add(normalizedId);
-                assetsToFetch.push({
-                    assetId,
-                    address: parsed.assetReference.toLowerCase(),
-                    decimals: assetsInfo[normalizedId]?.decimals,
-                });
-            }
-            catch {
-                // Skip unparseable asset IDs
-            }
-        }
-        return assetsToFetch;
-    }
     /**
      * Get existing assets metadata from AssetsController state.
      * Used to include metadata for ERC20 tokens when returning balance updates.
@@ -1354,7 +1056,14 @@ export class RpcDataSource extends AbstractDataSource {
      * @returns Record of asset IDs to their metadata.
      */
     #getExistingAssetsMetadata() {
-        return this.#getAssetsState().assetsInfo ?? {};
+        try {
+            const state = this.#messenger.call('AssetsController:getState');
+            return state.assetsInfo ?? {};
+        }
+        catch (error) {
+            log('Failed to get existing assets metadata', { error });
+            return {};
+        }
     }
     /**
      * Destroy the data source and clean up resources.