@metamask-previews/assets-controller 14.0.2-preview-3866c0ff1 → 14.0.2-preview-e3275932a

package/dist/data-sources/RpcDataSource.mjs

@@ -0,0 +1,1012 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RpcDataSource_instances, _RpcDataSource_messenger, _RpcDataSource_onActiveChainsUpdated, _RpcDataSource_getNativeAssetForChain, _RpcDataSource_timeout, _RpcDataSource_tokenDetectionEnabled, _RpcDataSource_useExternalService, _RpcDataSource_isOnboarded, _RpcDataSource_activeChains, _RpcDataSource_chainStatuses, _RpcDataSource_providerCache, _RpcDataSource_activeSubscriptions, _RpcDataSource_unsubscribeTransactionConfirmed, _RpcDataSource_multicallClient, _RpcDataSource_balanceFetcher, _RpcDataSource_tokenDetector, _RpcDataSource_getAssetType, _RpcDataSource_convertToHumanReadable, _RpcDataSource_collectMetadataForBalances, _RpcDataSource_hasValidDecimals, _RpcDataSource_pickValidDecimals, _RpcDataSource_handleBalanceUpdate, _RpcDataSource_handleDetectionUpdate, _RpcDataSource_subscribeToNetworkController, _RpcDataSource_subscribeToTransactionEvents, _RpcDataSource_onTransactionConfirmed, _RpcDataSource_refreshBalanceForChains, _RpcDataSource_initializeFromNetworkController, _RpcDataSource_updateFromNetworkState, _RpcDataSource_getProvider, _RpcDataSource_getMulticallProvider, _RpcDataSource_clearProviderCache, _RpcDataSource_fetchDecimalsViaRpc, _RpcDataSource_getExistingAssetsMetadata;
+import { Web3Provider } from "@ethersproject/providers";
+import { toHex } from "@metamask/controller-utils";
+import { isStrictHexString, isCaipChainId, parseCaipAssetType, parseCaipChainId, hexToNumber, toCaipChainId, KnownCaipNamespace } from "@metamask/utils";
+import BigNumberJS from "bignumber.js";
+import { projectLogger, createModuleLogger } from "../logger.mjs";
+import { ZERO_ADDRESS } from "../utils/constants.mjs";
+import { normalizeAssetId } from "../utils/index.mjs";
+import { AbstractDataSource } from "./AbstractDataSource.mjs";
+import { BalanceFetcher, MulticallClient, TokenDetector, TokensApiClient } from "./evm-rpc-services/index.mjs";
+import { shouldSkipNativeForCaipChainId } from "./evm-rpc-services/utils/assets.mjs";
+const CONTROLLER_NAME = 'RpcDataSource';
+const DEFAULT_BALANCE_INTERVAL = 30000; // 30 seconds
+const DEFAULT_DETECTION_INTERVAL = 180000; // 3 minutes
+const log = createModuleLogger(projectLogger, CONTROLLER_NAME);
+/**
+ * Convert CAIP chain ID or hex chain ID to hex chain ID.
+ *
+ * @param chainId - CAIP chain ID or hex chain ID.
+ * @returns Hex chain ID.
+ */
+export const caipChainIdToHex = (chainId) => {
+    if (isStrictHexString(chainId)) {
+        return chainId;
+    }
+    if (isCaipChainId(chainId)) {
+        return toHex(parseCaipChainId(chainId).reference);
+    }
+    throw new Error('caipChainIdToHex - Failed to provide CAIP-2 or Hex chainId');
+};
+/**
+ * Data source for fetching balances via RPC calls.
+ *
+ * Orchestrates polling through BalanceFetcher and TokenDetector,
+ * each of which handle their own polling intervals.
+ *
+ * Communicates with AssetsController via Messenger:
+ *
+ * Actions:
+ * - RpcDataSource:getActiveChains
+ * - RpcDataSource:fetch
+ * - RpcDataSource:subscribe
+ * - RpcDataSource:unsubscribe
+ *
+ * Events:
+ * - RpcDataSource:activeChainsUpdated
+ * - RpcDataSource:assetsUpdated
+ */
+export class RpcDataSource extends AbstractDataSource {
+    constructor(options) {
+        super(CONTROLLER_NAME, { activeChains: [] });
+        _RpcDataSource_instances.add(this);
+        _RpcDataSource_messenger.set(this, void 0);
+        _RpcDataSource_onActiveChainsUpdated.set(this, void 0);
+        _RpcDataSource_getNativeAssetForChain.set(this, void 0);
+        _RpcDataSource_timeout.set(this, void 0);
+        _RpcDataSource_tokenDetectionEnabled.set(this, void 0);
+        _RpcDataSource_useExternalService.set(this, void 0);
+        _RpcDataSource_isOnboarded.set(this, void 0);
+        /** Currently active chains */
+        _RpcDataSource_activeChains.set(this, []);
+        /** Network status for each active chain */
+        _RpcDataSource_chainStatuses.set(this, {});
+        /** Cache of Web3Provider instances by chainId */
+        _RpcDataSource_providerCache.set(this, new Map());
+        /** Active subscriptions by ID */
+        _RpcDataSource_activeSubscriptions.set(this, new Map());
+        _RpcDataSource_unsubscribeTransactionConfirmed.set(this, undefined);
+        // Rpc-datasource components
+        _RpcDataSource_multicallClient.set(this, void 0);
+        _RpcDataSource_balanceFetcher.set(this, void 0);
+        _RpcDataSource_tokenDetector.set(this, void 0);
+        _RpcDataSource_getAssetType.set(this, void 0);
+        __classPrivateFieldSet(this, _RpcDataSource_messenger, options.messenger, "f");
+        __classPrivateFieldSet(this, _RpcDataSource_onActiveChainsUpdated, options.onActiveChainsUpdated, "f");
+        __classPrivateFieldSet(this, _RpcDataSource_getNativeAssetForChain, options.getNativeAssetForChain, "f");
+        __classPrivateFieldSet(this, _RpcDataSource_getAssetType, options.getAssetType, "f");
+        __classPrivateFieldSet(this, _RpcDataSource_timeout, options.timeout ?? 10000, "f");
+        __classPrivateFieldSet(this, _RpcDataSource_tokenDetectionEnabled, options.tokenDetectionEnabled ?? (() => true), "f");
+        __classPrivateFieldSet(this, _RpcDataSource_useExternalService, options.useExternalService ?? (() => true), "f");
+        __classPrivateFieldSet(this, _RpcDataSource_isOnboarded, options.isOnboarded ?? (() => true), "f");
+        const balanceInterval = options.balanceInterval ?? DEFAULT_BALANCE_INTERVAL;
+        const detectionInterval = options.detectionInterval ?? DEFAULT_DETECTION_INTERVAL;
+        log('Initializing RpcDataSource', {
+            timeout: __classPrivateFieldGet(this, _RpcDataSource_timeout, "f"),
+            balanceInterval,
+            detectionInterval,
+            tokenDetectionEnabled: __classPrivateFieldGet(this, _RpcDataSource_tokenDetectionEnabled, "f").call(this),
+            useExternalService: __classPrivateFieldGet(this, _RpcDataSource_useExternalService, "f").call(this),
+        });
+        // Initialize MulticallClient with a provider getter
+        __classPrivateFieldSet(this, _RpcDataSource_multicallClient, new MulticallClient({
+            getProvider: (hexChainId) => {
+                return __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_getMulticallProvider).call(this, hexChainId);
+            },
+            getMulticall3AddressForChain: (hexChainId) => 
+            // The messenger is not being called from a constructor, so this is safe.
+            // eslint-disable-next-line no-restricted-syntax
+            __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('ConfigRegistryController:getNetworkConfigByCaip2ChainId', toCaipChainId(KnownCaipNamespace.Eip155, hexToNumber(hexChainId).toString()))?.contracts?.multicall3,
+        }), "f");
+        // Create messenger adapters for BalanceFetcher and TokenDetector
+        const balanceFetcherMessenger = {
+            call: (_action) => {
+                // The messenger is not being called from a constructor, so this is safe.
+                // eslint-disable-next-line no-restricted-syntax
+                const state = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('AssetsController:getState');
+                return {
+                    assetsBalance: (state.assetsBalance ?? {}),
+                    customAssets: (state.customAssets ?? {}),
+                };
+            },
+        };
+        // Initialize BalanceFetcher with polling interval
+        __classPrivateFieldSet(this, _RpcDataSource_balanceFetcher, new BalanceFetcher(__classPrivateFieldGet(this, _RpcDataSource_multicallClient, "f"), balanceFetcherMessenger, {
+            pollingInterval: balanceInterval,
+            isNativeAsset: (assetId) => {
+                const { chainId } = parseCaipAssetType(assetId);
+                const nativeId = __classPrivateFieldGet(this, _RpcDataSource_getNativeAssetForChain, "f").call(this, chainId);
+                return nativeId?.toLowerCase() === assetId.toLowerCase();
+            },
+        }), "f");
+        // Polling controller awaits this callback; rejections must not become unhandled.
+        __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").setOnBalanceUpdate(async (result) => {
+            try {
+                await __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_handleBalanceUpdate).call(this, result);
+            }
+            catch (error) {
+                log('Balance update handler failed', { error });
+            }
+        });
+        // Initialize TokenDetector with polling interval. The TokensApiClient is
+        // configured with the shared TanStack Query client (when the controller
+        // provides one) so concurrent detector polls/accounts/instances share a
+        // single in-flight request and cached result per chain.
+        const tokensApiClient = new TokensApiClient({
+            queryClient: options.queryClient,
+        });
+        __classPrivateFieldSet(this, _RpcDataSource_tokenDetector, new TokenDetector(__classPrivateFieldGet(this, _RpcDataSource_multicallClient, "f"), tokensApiClient, {
+            pollingInterval: detectionInterval,
+            tokenDetectionEnabled: __classPrivateFieldGet(this, _RpcDataSource_tokenDetectionEnabled, "f"),
+            useExternalService: __classPrivateFieldGet(this, _RpcDataSource_useExternalService, "f"),
+        }), "f");
+        // Sync throw in the detector would reject the poll tick if uncaught.
+        __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").setOnDetectionUpdate((result) => {
+            try {
+                __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_handleDetectionUpdate).call(this, result);
+            }
+            catch (error) {
+                log('Detection update handler failed', { error });
+            }
+        });
+        __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_subscribeToNetworkController).call(this);
+        __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_subscribeToTransactionEvents).call(this);
+        __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_initializeFromNetworkController).call(this);
+    }
+    /**
+     * Re-read NetworkController state and refresh Rpc `activeChains` (e.g. when
+     * network availability metadata changes after an EVM network switch).
+     */
+    refreshActiveChainsFromNetworkState() {
+        __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_initializeFromNetworkController).call(this);
+    }
+    /**
+     * Get the data source name.
+     *
+     * @returns The name of this data source.
+     */
+    /**
+     * Get the status of all configured chains.
+     *
+     * @returns Record of chain statuses keyed by chain ID.
+     */
+    getChainStatuses() {
+        return { ...__classPrivateFieldGet(this, _RpcDataSource_chainStatuses, "f") };
+    }
+    /**
+     * Get the status of a specific chain.
+     *
+     * @param chainId - The chain ID to get status for.
+     * @returns The chain status or undefined if not found.
+     */
+    getChainStatus(chainId) {
+        return __classPrivateFieldGet(this, _RpcDataSource_chainStatuses, "f")[chainId];
+    }
+    /**
+     * Set the balance polling interval.
+     *
+     * @param interval - The polling interval in milliseconds.
+     */
+    setBalancePollingInterval(interval) {
+        log('Setting balance polling interval', { interval });
+        __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").setIntervalLength(interval);
+    }
+    /**
+     * Get the current balance polling interval.
+     *
+     * @returns The polling interval in milliseconds, or undefined if not set.
+     */
+    getBalancePollingInterval() {
+        return __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").getIntervalLength();
+    }
+    /**
+     * Set the token detection polling interval.
+     *
+     * @param interval - The polling interval in milliseconds.
+     */
+    setDetectionPollingInterval(interval) {
+        log('Setting detection polling interval', { interval });
+        __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").setIntervalLength(interval);
+    }
+    /**
+     * Get the current token detection polling interval.
+     *
+     * @returns The polling interval in milliseconds, or undefined if not set.
+     */
+    getDetectionPollingInterval() {
+        return __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").getIntervalLength();
+    }
+    async fetch(request) {
+        if (!__classPrivateFieldGet(this, _RpcDataSource_isOnboarded, "f").call(this)) {
+            log('Skipping fetch - onboarding not complete');
+            return {};
+        }
+        const response = {};
+        const chainsToFetch = request.chainIds.filter((chainId) => __classPrivateFieldGet(this, _RpcDataSource_activeChains, "f").includes(chainId));
+        log('Fetch requested', {
+            accounts: request.accountsWithSupportedChains.map((a) => a.account.id),
+            requestedChains: request.chainIds,
+            chainsToFetch,
+        });
+        if (chainsToFetch.length === 0) {
+            log('No active chains to fetch');
+            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) {
+                continue;
+            }
+            const { address, id: accountId } = account;
+            for (const chainId of chainsForAccount) {
+                const hexChainId = caipChainIdToHex(chainId);
+                const nativeAssetId = __classPrivateFieldGet(this, _RpcDataSource_getNativeAssetForChain, "f").call(this, chainId);
+                const shouldSkipNative = shouldSkipNativeForCaipChainId(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 = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_getExistingAssetsMetadata).call(this);
+                    for (const assetId of request.customAssets) {
+                        try {
+                            const parsed = parseCaipAssetType(assetId);
+                            const assetChainId = `${parsed.chain.namespace}:${parsed.chain.reference}`;
+                            if (assetChainId === chainId &&
+                                __classPrivateFieldGet(this, _RpcDataSource_getAssetType, "f").call(this, 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
+                        }
+                    }
+                }
+                try {
+                    const result = await __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").fetchBalancesForAssets(hexChainId, accountId, address, assetsToFetch);
+                    if (!assetsBalance[accountId]) {
+                        assetsBalance[accountId] = {};
+                    }
+                    // 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 = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_collectMetadataForBalances).call(this, 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 = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_getExistingAssetsMetadata).call(this);
+                    for (const balance of normalizedBalances) {
+                        const stateMetadata = existingMetadata[balance.assetId];
+                        const pipelineMetadata = assetsInfo[balance.assetId];
+                        let decimals = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_pickValidDecimals).call(this, stateMetadata, pipelineMetadata);
+                        if (decimals === undefined) {
+                            const parsed = parseCaipAssetType(balance.assetId);
+                            if (__classPrivateFieldGet(this, _RpcDataSource_getAssetType, "f").call(this, balance.assetId) === 'erc20') {
+                                decimals = await __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_fetchDecimalsViaRpc).call(this, chainId, parsed.assetReference);
+                            }
+                        }
+                        if (decimals === undefined) {
+                            continue;
+                        }
+                        const humanReadableAmount = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_convertToHumanReadable).call(this, balance.balance, decimals);
+                        assetsBalance[accountId][balance.assetId] = {
+                            amount: humanReadableAmount,
+                        };
+                    }
+                }
+                catch (error) {
+                    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 = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_getExistingAssetsMetadata).call(this)[nativeAssetId];
+                    if (!__classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_hasValidDecimals).call(this, existingNativeMeta)) {
+                        const chainStatus = __classPrivateFieldGet(this, _RpcDataSource_chainStatuses, "f")[chainId];
+                        if (chainStatus) {
+                            assetsInfo[nativeAssetId] = {
+                                type: 'native',
+                                symbol: chainStatus.nativeCurrency,
+                                name: chainStatus.nativeCurrency,
+                                decimals: 18,
+                            };
+                        }
+                    }
+                    if (!failedChains.includes(chainId)) {
+                        failedChains.push(chainId);
+                    }
+                }
+            }
+        }
+        if (failedChains.length > 0) {
+            log('Fetch PARTIAL - some chains failed', {
+                successChains: chainsToFetch.filter((chain) => !failedChains.includes(chain)),
+                failedChains,
+            });
+            response.errors = {};
+            for (const chainId of failedChains) {
+                response.errors[chainId] = 'RPC fetch failed';
+            }
+        }
+        else {
+            log('Fetch SUCCESS', {
+                chains: chainsToFetch,
+                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;
+    }
+    /**
+     * Run token detection for an account on a chain.
+     *
+     * @param chainId - The chain ID to detect tokens on.
+     * @param account - The account to detect tokens for.
+     * @returns Promise resolving to a DataResponse with detected assets.
+     */
+    async detectTokens(chainId, account) {
+        if (!__classPrivateFieldGet(this, _RpcDataSource_tokenDetectionEnabled, "f").call(this) || !__classPrivateFieldGet(this, _RpcDataSource_useExternalService, "f").call(this)) {
+            return {};
+        }
+        const hexChainId = caipChainIdToHex(chainId);
+        const { address, id: accountId } = account;
+        log('Running token detection', { chainId, accountId });
+        try {
+            const result = await __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").detectTokens(hexChainId, accountId, address, {
+                tokenDetectionEnabled: __classPrivateFieldGet(this, _RpcDataSource_tokenDetectionEnabled, "f").call(this),
+                useExternalService: __classPrivateFieldGet(this, _RpcDataSource_useExternalService, "f").call(this),
+            });
+            if (result.detectedAssets.length === 0) {
+                log('No new tokens detected');
+                return {};
+            }
+            log('Detected new tokens', {
+                count: result.detectedAssets.length,
+                chainId,
+                accountId,
+            });
+            // Convert detected assets to DataResponse format
+            const balances = {};
+            const assetsInfo = {};
+            // Build metadata from detected assets
+            for (const asset of result.detectedAssets) {
+                if (asset.symbol && asset.decimals !== undefined) {
+                    assetsInfo[asset.assetId] = {
+                        type: __classPrivateFieldGet(this, _RpcDataSource_getAssetType, "f").call(this, asset.assetId),
+                        symbol: asset.symbol,
+                        name: asset.name ?? asset.symbol,
+                        decimals: asset.decimals,
+                        image: asset.image,
+                    };
+                }
+            }
+            // Add balances for detected tokens (converted to human-readable format)
+            for (const balance of result.detectedBalances) {
+                const detectedAsset = result.detectedAssets.find((asset) => asset.assetId === balance.assetId);
+                if (detectedAsset?.decimals === undefined) {
+                    continue;
+                }
+                const humanReadableAmount = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_convertToHumanReadable).call(this, balance.balance, detectedAsset.decimals);
+                balances[balance.assetId] = {
+                    amount: humanReadableAmount,
+                };
+            }
+            const response = {
+                detectedAssets: {
+                    [accountId]: result.detectedAssets.map((asset) => asset.assetId),
+                },
+                assetsBalance: {
+                    [accountId]: balances,
+                },
+            };
+            // Include metadata if we have any
+            if (Object.keys(assetsInfo).length > 0) {
+                response.assetsInfo = assetsInfo;
+            }
+            return response;
+        }
+        catch (error) {
+            log('Token detection failed', { chainId, accountId, error });
+            return {};
+        }
+    }
+    get assetsMiddleware() {
+        return async (context, next) => {
+            var _a, _b, _c;
+            const { request } = context;
+            const supportedChains = request.chainIds.filter((chainId) => __classPrivateFieldGet(this, _RpcDataSource_activeChains, "f").includes(chainId));
+            if (supportedChains.length === 0) {
+                return next(context);
+            }
+            let successfullyHandledChains = [];
+            log('Middleware fetching', {
+                chains: supportedChains,
+                accounts: request.accountsWithSupportedChains.map((a) => a.account.id),
+            });
+            const response = await this.fetch({
+                ...request,
+                chainIds: supportedChains,
+            });
+            if (response.assetsBalance) {
+                (_a = context.response).assetsBalance ?? (_a.assetsBalance = {});
+                for (const [accountId, accountBalances] of Object.entries(response.assetsBalance)) {
+                    (_b = context.response.assetsBalance)[accountId] ?? (_b[accountId] = {});
+                    context.response.assetsBalance[accountId] = {
+                        ...context.response.assetsBalance[accountId],
+                        ...accountBalances,
+                    };
+                }
+            }
+            if (response.assetsInfo) {
+                (_c = context.response).assetsInfo ?? (_c.assetsInfo = {});
+                context.response.assetsInfo = {
+                    ...context.response.assetsInfo,
+                    ...response.assetsInfo,
+                };
+            }
+            const failedChains = new Set(Object.keys(response.errors ?? {}));
+            successfullyHandledChains = supportedChains.filter((chainId) => !failedChains.has(chainId));
+            if (successfullyHandledChains.length > 0) {
+                const remainingChains = request.chainIds.filter((chainId) => !successfullyHandledChains.includes(chainId));
+                return next({
+                    ...context,
+                    request: {
+                        ...request,
+                        chainIds: remainingChains,
+                    },
+                });
+            }
+            return next(context);
+        };
+    }
+    /**
+     * Subscribe to updates for the given request.
+     * Starts polling through BalanceFetcher and TokenDetector.
+     *
+     * @param subscriptionRequest - The subscription request details.
+     */
+    async subscribe(subscriptionRequest) {
+        if (!__classPrivateFieldGet(this, _RpcDataSource_isOnboarded, "f").call(this)) {
+            log('Skipping subscribe - onboarding not complete');
+            return;
+        }
+        const { request, subscriptionId, isUpdate } = subscriptionRequest;
+        // Use request.chainIds when activeChains is not yet populated (e.g. before
+        // NetworkController state has been applied) so polling can start.
+        const chainsToSubscribe = __classPrivateFieldGet(this, _RpcDataSource_activeChains, "f").length > 0
+            ? request.chainIds.filter((chainId) => __classPrivateFieldGet(this, _RpcDataSource_activeChains, "f").includes(chainId))
+            : request.chainIds;
+        log('Subscribe requested', {
+            subscriptionId,
+            isUpdate,
+            accounts: request.accountsWithSupportedChains.map((a) => a.account.id),
+            chainsToSubscribe,
+            activeChainsFallback: __classPrivateFieldGet(this, _RpcDataSource_activeChains, "f").length === 0,
+        });
+        if (chainsToSubscribe.length === 0) {
+            log('No active chains to subscribe');
+            return;
+        }
+        // Handle subscription update - restart polling for new chains
+        if (isUpdate) {
+            const existing = __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").get(subscriptionId);
+            if (existing) {
+                log('Updating existing subscription - restarting polling', {
+                    subscriptionId,
+                    existingChains: existing.chains,
+                    newChains: chainsToSubscribe,
+                });
+                // Don't return early - continue to unsubscribe and restart polling
+            }
+        }
+        // Clean up existing subscription (stops old polling)
+        await this.unsubscribe(subscriptionId);
+        // Start polling through BalanceFetcher and TokenDetector
+        const balancePollingTokens = [];
+        const detectionPollingTokens = [];
+        for (const { account, supportedChains, } of request.accountsWithSupportedChains) {
+            const chainsForAccount = chainsToSubscribe.filter((chain) => supportedChains.includes(chain));
+            if (chainsForAccount.length === 0) {
+                continue;
+            }
+            const { address, id: accountId } = account;
+            for (const chainId of chainsForAccount) {
+                const hexChainId = caipChainIdToHex(chainId);
+                // Start balance polling
+                const balanceInput = {
+                    chainId: hexChainId,
+                    accountId,
+                    accountAddress: address,
+                    ...(request.customAssetsOnly === true
+                        ? { customAssetsOnly: true }
+                        : {}),
+                };
+                const balanceToken = __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").startPolling(balanceInput);
+                balancePollingTokens.push(balanceToken);
+                // Token detection is only relevant for "regular" subscriptions —
+                // a customAssetsOnly subscription should never run detection.
+                if (request.customAssetsOnly !== true &&
+                    __classPrivateFieldGet(this, _RpcDataSource_tokenDetectionEnabled, "f").call(this) &&
+                    __classPrivateFieldGet(this, _RpcDataSource_useExternalService, "f").call(this)) {
+                    const detectionInput = {
+                        chainId: hexChainId,
+                        accountId,
+                        accountAddress: address,
+                    };
+                    const detectionToken = __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").startPolling(detectionInput);
+                    detectionPollingTokens.push(detectionToken);
+                }
+            }
+        }
+        // Store subscription data
+        const accounts = request.accountsWithSupportedChains.map((entry) => entry.account);
+        __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").set(subscriptionId, {
+            balancePollingTokens,
+            detectionPollingTokens,
+            chains: chainsToSubscribe,
+            accounts,
+            onAssetsUpdate: subscriptionRequest.onAssetsUpdate,
+        });
+        log('Subscription SUCCESS', {
+            subscriptionId,
+            chains: chainsToSubscribe,
+            balancePollingCount: balancePollingTokens.length,
+            detectionPollingCount: detectionPollingTokens.length,
+        });
+    }
+    /**
+     * Unsubscribe from updates and stop polling.
+     *
+     * @param subscriptionId - The subscription ID to unsubscribe.
+     */
+    async unsubscribe(subscriptionId) {
+        const subscription = __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").get(subscriptionId);
+        if (subscription) {
+            // Stop balance polling
+            for (const token of subscription.balancePollingTokens) {
+                __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").stopPollingByPollingToken(token);
+            }
+            // Stop detection polling
+            for (const token of subscription.detectionPollingTokens) {
+                __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").stopPollingByPollingToken(token);
+            }
+            __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").delete(subscriptionId);
+            log('Unsubscribed and stopped polling', { subscriptionId });
+        }
+    }
+    /**
+     * Destroy the data source and clean up resources.
+     */
+    destroy() {
+        log('Destroying RpcDataSource');
+        __classPrivateFieldGet(this, _RpcDataSource_unsubscribeTransactionConfirmed, "f")?.call(this);
+        // Stop all polling
+        __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").stopAllPolling();
+        __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").stopAllPolling();
+        // Clear subscriptions
+        __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").clear();
+        // Clear caches
+        __classPrivateFieldGet(this, _RpcDataSource_providerCache, "f").clear();
+    }
+}
+_RpcDataSource_messenger = new WeakMap(), _RpcDataSource_onActiveChainsUpdated = new WeakMap(), _RpcDataSource_getNativeAssetForChain = new WeakMap(), _RpcDataSource_timeout = new WeakMap(), _RpcDataSource_tokenDetectionEnabled = new WeakMap(), _RpcDataSource_useExternalService = new WeakMap(), _RpcDataSource_isOnboarded = new WeakMap(), _RpcDataSource_activeChains = new WeakMap(), _RpcDataSource_chainStatuses = new WeakMap(), _RpcDataSource_providerCache = new WeakMap(), _RpcDataSource_activeSubscriptions = new WeakMap(), _RpcDataSource_unsubscribeTransactionConfirmed = new WeakMap(), _RpcDataSource_multicallClient = new WeakMap(), _RpcDataSource_balanceFetcher = new WeakMap(), _RpcDataSource_tokenDetector = new WeakMap(), _RpcDataSource_getAssetType = new WeakMap(), _RpcDataSource_instances = new WeakSet(), _RpcDataSource_convertToHumanReadable = function _RpcDataSource_convertToHumanReadable(rawBalance, decimals) {
+    if (!Number.isFinite(decimals) || decimals < 0) {
+        log('Invalid decimals — defaulting balance to "0"', {
+            rawBalance,
+            decimals,
+        });
+        return '0';
+    }
+    const rawAmount = new BigNumberJS(rawBalance);
+    if (!rawAmount.isFinite()) {
+        log('Invalid raw balance — defaulting to "0"', { rawBalance, decimals });
+        return '0';
+    }
+    const divisor = new BigNumberJS(10).pow(decimals);
+    return rawAmount.dividedBy(divisor).toFixed();
+}, _RpcDataSource_collectMetadataForBalances = function _RpcDataSource_collectMetadataForBalances(balances, chainId) {
+    const assetsInfo = {};
+    const existingMetadata = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_getExistingAssetsMetadata).call(this);
+    const nativeAssetId = __classPrivateFieldGet(this, _RpcDataSource_getNativeAssetForChain, "f").call(this, chainId);
+    for (const balance of balances) {
+        const existingMeta = existingMetadata[balance.assetId];
+        const isNative = existingMeta?.type === 'native' ||
+            balance.assetId.toLowerCase() === nativeAssetId?.toLowerCase() ||
+            __classPrivateFieldGet(this, _RpcDataSource_getAssetType, "f").call(this, balance.assetId) === 'native';
+        if (isNative && !__classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_hasValidDecimals).call(this, existingMeta)) {
+            // Only emit a stub when no valid metadata exists in state yet.
+            // Re-emitting existing metadata into the response would overwrite
+            // richer entries (e.g. image/description added by AccountsAPI) with
+            // a simpler stub on every balance poll cycle.
+            const chainStatus = __classPrivateFieldGet(this, _RpcDataSource_chainStatuses, "f")[chainId];
+            if (chainStatus) {
+                assetsInfo[balance.assetId] = {
+                    type: 'native',
+                    symbol: chainStatus.nativeCurrency,
+                    name: chainStatus.nativeCurrency,
+                    decimals: 18,
+                };
+            }
+        }
+        // For ERC-20 tokens and native tokens with existing valid metadata:
+        // do not re-emit — the existing state entry is already correct.
+        // Decimals for balance conversion are resolved via stateMetadata in
+        // the callers (pickValidDecimals(stateMetadata, pipelineMetadata)).
+    }
+    return assetsInfo;
+}, _RpcDataSource_hasValidDecimals = function _RpcDataSource_hasValidDecimals(metadata) {
+    return Boolean(metadata && Number.isFinite(metadata.decimals) && metadata.decimals >= 0);
+}, _RpcDataSource_pickValidDecimals = function _RpcDataSource_pickValidDecimals(...metadatas) {
+    for (const metadata of metadatas) {
+        if (__classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_hasValidDecimals).call(this, metadata)) {
+            return metadata.decimals;
+        }
+    }
+    return undefined;
+}, _RpcDataSource_handleBalanceUpdate = 
+/**
+ * Handle balance update from BalanceFetcher.
+ *
+ * @param result - The balance fetch result.
+ */
+async function _RpcDataSource_handleBalanceUpdate(result) {
+    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 = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_collectMetadataForBalances).call(this, normalizedBalances, caipChainId);
+    // Convert balances to human-readable format.
+    // Resolution: state metadata → pipeline metadata; skip if decimals unknown.
+    const existingMetadata = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_getExistingAssetsMetadata).call(this);
+    for (const balance of normalizedBalances) {
+        const stateMetadata = existingMetadata[balance.assetId];
+        const pipelineMetadata = assetsInfo[balance.assetId];
+        const decimals = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_pickValidDecimals).call(this, stateMetadata, pipelineMetadata);
+        if (decimals === undefined) {
+            continue;
+        }
+        const humanReadableAmount = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_convertToHumanReadable).call(this, balance.balance, decimals);
+        newBalances[balance.assetId] = {
+            amount: humanReadableAmount,
+        };
+    }
+    // Only send new data to AssetsController - it handles merging atomically
+    // to avoid race conditions when concurrent updates occur for the same account
+    const response = {
+        assetsBalance: {
+            [result.accountId]: newBalances,
+        },
+        assetsInfo,
+        updateMode: 'merge',
+    };
+    const request = {
+        accountsWithSupportedChains: [],
+        chainIds: [caipChainId],
+        dataTypes: ['balance'],
+    };
+    log('Balance update response', {
+        accountId: result.accountId,
+        newBalanceCount: Object.keys(newBalances).length,
+    });
+    for (const subscription of __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").values()) {
+        subscription.onAssetsUpdate(response, request)?.catch((error) => {
+            log('Failed to update assets', { error });
+        });
+    }
+}, _RpcDataSource_handleDetectionUpdate = function _RpcDataSource_handleDetectionUpdate(result) {
+    log('Detected new tokens', {
+        count: result.detectedAssets.length,
+    });
+    // Build new metadata from detected assets
+    const newMetadata = {};
+    if (result.detectedAssets.length > 0) {
+        for (const asset of result.detectedAssets) {
+            // Only include if we have metadata (symbol and decimals at minimum)
+            if (asset.symbol && asset.decimals !== undefined) {
+                newMetadata[asset.assetId] = {
+                    type: __classPrivateFieldGet(this, _RpcDataSource_getAssetType, "f").call(this, asset.assetId),
+                    symbol: asset.symbol,
+                    name: asset.name ?? asset.symbol,
+                    decimals: asset.decimals,
+                    image: asset.image,
+                };
+            }
+        }
+    }
+    // Build new balances from detected tokens
+    const newBalances = {};
+    if (result.detectedBalances.length > 0) {
+        for (const balance of result.detectedBalances) {
+            // Get decimals from the detected asset metadata
+            const detectedAsset = result.detectedAssets.find((asset) => asset.assetId === balance.assetId);
+            if (detectedAsset?.decimals === undefined) {
+                continue;
+            }
+            const humanReadableAmount = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_convertToHumanReadable).call(this, balance.balance, detectedAsset.decimals);
+            newBalances[balance.assetId] = {
+                amount: humanReadableAmount,
+            };
+        }
+    }
+    // Only send new data to AssetsController - it handles merging atomically
+    // to avoid race conditions when concurrent updates occur for the same account
+    const response = {
+        detectedAssets: {
+            [result.accountId]: result.detectedAssets.map((asset) => asset.assetId),
+        },
+        assetsInfo: newMetadata,
+        assetsBalance: {
+            [result.accountId]: newBalances,
+        },
+        updateMode: 'merge',
+    };
+    const chainIdDecimal = parseInt(result.chainId, 16);
+    const caipChainId = `eip155:${chainIdDecimal}`;
+    const request = {
+        accountsWithSupportedChains: [],
+        chainIds: [caipChainId],
+        dataTypes: ['balance', 'metadata', 'price'],
+    };
+    for (const subscription of __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").values()) {
+        subscription.onAssetsUpdate(response, request)?.catch((error) => {
+            log('Failed to update detected assets', { error });
+        });
+    }
+}, _RpcDataSource_subscribeToNetworkController = function _RpcDataSource_subscribeToNetworkController() {
+    __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").subscribe('NetworkController:stateChange', (networkState) => {
+        log('NetworkController state changed');
+        __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_clearProviderCache).call(this);
+        __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_updateFromNetworkState).call(this, networkState);
+    });
+}, _RpcDataSource_subscribeToTransactionEvents = function _RpcDataSource_subscribeToTransactionEvents() {
+    const unsubConfirmed = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").subscribe('TransactionController:transactionConfirmed', __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_onTransactionConfirmed).bind(this));
+    __classPrivateFieldSet(this, _RpcDataSource_unsubscribeTransactionConfirmed, typeof unsubConfirmed === 'function' ? unsubConfirmed : undefined, "f");
+}, _RpcDataSource_onTransactionConfirmed = function _RpcDataSource_onTransactionConfirmed(payload) {
+    const hexChainId = payload?.chainId;
+    if (!hexChainId) {
+        return;
+    }
+    const caipChainId = `eip155:${parseInt(hexChainId, 16)}`;
+    __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_refreshBalanceForChains).call(this, [caipChainId], 'transactionConfirmed').catch((error) => {
+        log('Failed to refresh balance after transaction confirmed', { error });
+    });
+}, _RpcDataSource_refreshBalanceForChains = 
+/**
+ * Fetch balances for the given chains across all active subscriptions and
+ * push updates to the controller.
+ *
+ * @param chainIds - CAIP-2 chain IDs to refresh.
+ * @param context - Why the refresh was triggered (for logging).
+ */
+async function _RpcDataSource_refreshBalanceForChains(chainIds, context = 'polling') {
+    const chainIdsSet = new Set(chainIds);
+    const chainsToFetch = chainIds.filter((chainId) => __classPrivateFieldGet(this, _RpcDataSource_activeChains, "f").includes(chainId));
+    if (chainsToFetch.length === 0) {
+        return;
+    }
+    let appliedCount = 0;
+    for (const subscription of __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").values()) {
+        const subscriptionChains = subscription.chains.filter((chainId) => chainIdsSet.has(chainId));
+        if (subscriptionChains.length === 0) {
+            continue;
+        }
+        const request = {
+            accountsWithSupportedChains: subscription.accounts.map((account) => ({
+                account,
+                supportedChains: subscriptionChains,
+            })),
+            chainIds: subscriptionChains,
+            dataTypes: ['balance'],
+        };
+        try {
+            const response = await this.fetch(request);
+            const balanceCount = response.assetsBalance
+                ? Object.values(response.assetsBalance).reduce((sum, accountBalances) => sum + Object.keys(accountBalances).length, 0)
+                : 0;
+            if (balanceCount === 0) {
+                continue;
+            }
+            const responseWithMode = {
+                ...response,
+                updateMode: response.updateMode ?? 'merge',
+            };
+            await subscription.onAssetsUpdate(responseWithMode, request);
+            appliedCount += 1;
+        }
+        catch (error) {
+            log('Failed to fetch balance after transaction', {
+                context,
+                chains: subscriptionChains,
+                error,
+            });
+        }
+    }
+    if (appliedCount === 0 && context === 'transactionConfirmed') {
+        log('No RpcDataSource subscription covers chain after transaction', {
+            chainsToFetch,
+        });
+    }
+}, _RpcDataSource_initializeFromNetworkController = function _RpcDataSource_initializeFromNetworkController() {
+    log('Initializing from NetworkController');
+    try {
+        const networkState = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('NetworkController:getState');
+        __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_updateFromNetworkState).call(this, networkState);
+    }
+    catch (error) {
+        log('Failed to initialize from NetworkController', error);
+    }
+}, _RpcDataSource_updateFromNetworkState = function _RpcDataSource_updateFromNetworkState(networkState) {
+    const { networkConfigurationsByChainId, networksMetadata } = networkState;
+    const chainStatuses = {};
+    const activeChains = [];
+    for (const [hexChainId, config] of Object.entries(networkConfigurationsByChainId)) {
+        const decimalChainId = parseInt(hexChainId, 16);
+        const caip2ChainId = `eip155:${decimalChainId}`;
+        const defaultRpcEndpoint = config.rpcEndpoints[config.defaultRpcEndpointIndex];
+        if (!defaultRpcEndpoint) {
+            continue;
+        }
+        const { networkClientId } = defaultRpcEndpoint;
+        const metadata = networksMetadata[networkClientId];
+        const status = metadata?.status ?? 'unknown';
+        chainStatuses[caip2ChainId] = {
+            chainId: caip2ChainId,
+            status,
+            name: config.name,
+            nativeCurrency: config.nativeCurrency,
+            networkClientId,
+        };
+        if (status === 'available' || status === 'unknown') {
+            activeChains.push(caip2ChainId);
+        }
+    }
+    log('Network state updated', {
+        configuredChains: Object.keys(chainStatuses),
+        activeChains,
+    });
+    // Check if chains changed
+    const previousChains = [...__classPrivateFieldGet(this, _RpcDataSource_activeChains, "f")];
+    const previousSet = new Set(previousChains);
+    const hasChanges = previousChains.length !== activeChains.length ||
+        activeChains.some((chain) => !previousSet.has(chain));
+    // Update internal state and data source state before notifying, so that
+    // when the controller handles the callback and calls getActiveChainsSync(),
+    // it receives the updated chains (same order as AbstractDataSource.updateActiveChains).
+    __classPrivateFieldSet(this, _RpcDataSource_chainStatuses, chainStatuses, "f");
+    __classPrivateFieldSet(this, _RpcDataSource_activeChains, activeChains, "f");
+    this.state.activeChains = activeChains;
+    if (hasChanges) {
+        __classPrivateFieldGet(this, _RpcDataSource_onActiveChainsUpdated, "f").call(this, this.getName(), activeChains, previousChains);
+    }
+}, _RpcDataSource_getProvider = function _RpcDataSource_getProvider(chainId) {
+    const cached = __classPrivateFieldGet(this, _RpcDataSource_providerCache, "f").get(chainId);
+    if (cached) {
+        return cached;
+    }
+    const chainStatus = __classPrivateFieldGet(this, _RpcDataSource_chainStatuses, "f")[chainId];
+    if (!chainStatus) {
+        return undefined;
+    }
+    try {
+        const networkClient = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('NetworkController:getNetworkClientById', chainStatus.networkClientId);
+        if (!networkClient?.provider) {
+            return undefined;
+        }
+        const web3Provider = new Web3Provider(networkClient.provider);
+        __classPrivateFieldGet(this, _RpcDataSource_providerCache, "f").set(chainId, web3Provider);
+        return web3Provider;
+    }
+    catch (error) {
+        log('Failed to get provider for chain', { chainId, error });
+        return undefined;
+    }
+}, _RpcDataSource_getMulticallProvider = function _RpcDataSource_getMulticallProvider(hexChainId) {
+    const decimalChainId = parseInt(hexChainId, 16);
+    const caip2ChainId = `eip155:${decimalChainId}`;
+    const web3Provider = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_getProvider).call(this, caip2ChainId);
+    if (!web3Provider) {
+        throw new Error(`No provider available for chain ${hexChainId}`);
+    }
+    return {
+        call: async (params) => {
+            return web3Provider.call({
+                to: params.to,
+                data: params.data,
+            });
+        },
+        getBalance: async (address) => {
+            const balance = await web3Provider.getBalance(address);
+            return balance;
+        },
+    };
+}, _RpcDataSource_clearProviderCache = function _RpcDataSource_clearProviderCache() {
+    __classPrivateFieldGet(this, _RpcDataSource_providerCache, "f").clear();
+}, _RpcDataSource_fetchDecimalsViaRpc = 
+/**
+ * Fetch the `decimals()` value from an ERC20 contract via RPC.
+ *
+ * @param chainId - CAIP-2 chain ID.
+ * @param tokenAddress - The token contract address.
+ * @returns The decimals value, or undefined if the call fails.
+ */
+async function _RpcDataSource_fetchDecimalsViaRpc(chainId, tokenAddress) {
+    try {
+        const provider = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_getProvider).call(this, chainId);
+        if (!provider) {
+            return undefined;
+        }
+        // ERC20 decimals() selector: keccak256("decimals()") = 0x313ce567
+        const result = await provider.call({
+            to: tokenAddress,
+            data: '0x313ce567',
+        });
+        if (!result || result === '0x') {
+            return undefined;
+        }
+        const parsed = parseInt(result, 16);
+        if (Number.isNaN(parsed) || parsed < 0 || parsed > 255) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}, _RpcDataSource_getExistingAssetsMetadata = function _RpcDataSource_getExistingAssetsMetadata() {
+    try {
+        const state = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('AssetsController:getState');
+        return state.assetsInfo ?? {};
+    }
+    catch (error) {
+        log('Failed to get existing assets metadata', { error });
+        return {};
+    }
+};
+export function createRpcDataSource(options) {
+    return new RpcDataSource(options);
+}
+//# sourceMappingURL=RpcDataSource.mjs.map