@metamask-previews/assets-controller 0.0.0-preview-3ec2a74 → 0.0.0-preview-6ae8a59c

package/dist/data-sources/RpcDataSource.cjs

@@ -10,35 +10,40 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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_timeout, _RpcDataSource_pollInterval, _RpcDataSource_providerCache, _RpcDataSource_registerActionHandlers, _RpcDataSource_subscribeToNetworkController, _RpcDataSource_initializeFromNetworkController, _RpcDataSource_updateFromNetworkState, _RpcDataSource_getProvider, _RpcDataSource_clearProviderCache, _RpcDataSource_accountSupportsChain;
+var _RpcDataSource_instances, _RpcDataSource_timeout, _RpcDataSource_tokenDetectionEnabled, _RpcDataSource_activeChains, _RpcDataSource_chainStatuses, _RpcDataSource_providerCache, _RpcDataSource_activeSubscriptions, _RpcDataSource_multicallClient, _RpcDataSource_balanceFetcher, _RpcDataSource_tokenDetector, _RpcDataSource_handleBalanceUpdate, _RpcDataSource_handleDetectionUpdate, _RpcDataSource_registerActionHandlers, _RpcDataSource_subscribeToNetworkController, _RpcDataSource_initializeFromNetworkController, _RpcDataSource_updateFromNetworkState, _RpcDataSource_getProvider, _RpcDataSource_getMulticallProvider, _RpcDataSource_clearProviderCache, _RpcDataSource_accountSupportsChain, _RpcDataSource_buildNativeAssetId;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRpcDataSource = exports.RpcDataSource = void 0;
+exports.createRpcDataSource = exports.RpcDataSource = exports.caipChainIdToHex = void 0;
 const providers_1 = require("@ethersproject/providers");
-const AbstractDataSource_1 = require("./AbstractDataSource.cjs");
+const base_controller_1 = require("@metamask/base-controller");
+const controller_utils_1 = require("@metamask/controller-utils");
+const utils_1 = require("@metamask/utils");
+const evm_rpc_services_1 = require("./evm-rpc-services/index.cjs");
 const logger_1 = require("../logger.cjs");
-// ============================================================================
-// CONSTANTS
-// ============================================================================
 const CONTROLLER_NAME = 'RpcDataSource';
-const DEFAULT_POLL_INTERVAL = 30000;
+const DEFAULT_BALANCE_INTERVAL = 30000; // 30 seconds
+const DEFAULT_DETECTION_INTERVAL = 180000; // 3 minutes
 const log = (0, logger_1.createModuleLogger)(logger_1.projectLogger, CONTROLLER_NAME);
-const defaultState = {
-    activeChains: [],
-    chainStatuses: {},
+/**
+ * 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.
+ */
+const caipChainIdToHex = (chainId) => {
+    if ((0, utils_1.isStrictHexString)(chainId)) {
+        return chainId;
+    }
+    if ((0, utils_1.isCaipChainId)(chainId)) {
+        return (0, controller_utils_1.toHex)((0, utils_1.parseCaipChainId)(chainId).reference);
+    }
+    throw new Error('caipChainIdToHex - Failed to provide CAIP-2 or Hex chainId');
 };
-// ============================================================================
-// HELPER FUNCTIONS
-// ============================================================================
-function buildNativeAssetId(chainId) {
-    return `${chainId}/slip44:60`;
-}
-// ============================================================================
-// RPC DATA SOURCE
-// ============================================================================
+exports.caipChainIdToHex = caipChainIdToHex;
 /**
  * Data source for fetching balances via RPC calls.
  *
- * Used as a fallback when the Accounts API doesn't support a chain.
+ * Orchestrates polling through BalanceFetcher and TokenDetector,
+ * each of which handle their own polling intervals.
  *
  * Communicates with AssetsController via Messenger:
  *
@@ -52,88 +57,176 @@ function buildNativeAssetId(chainId) {
  * - RpcDataSource:activeChainsUpdated
  * - RpcDataSource:assetsUpdated
  */
-class RpcDataSource extends AbstractDataSource_1.AbstractDataSource {
+class RpcDataSource extends base_controller_1.BaseController {
     constructor(options) {
-        super(CONTROLLER_NAME, {
-            ...defaultState,
-            ...options.state,
+        super({
+            name: CONTROLLER_NAME,
+            metadata: {},
+            state: {},
+            messenger: options.messenger,
         });
         _RpcDataSource_instances.add(this);
-        _RpcDataSource_messenger.set(this, void 0);
         _RpcDataSource_timeout.set(this, void 0);
-        _RpcDataSource_pollInterval.set(this, void 0);
+        _RpcDataSource_tokenDetectionEnabled.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());
-        __classPrivateFieldSet(this, _RpcDataSource_messenger, options.messenger, "f");
+        /** Active subscriptions by ID */
+        _RpcDataSource_activeSubscriptions.set(this, new Map());
+        // Rpc-datasource components
+        _RpcDataSource_multicallClient.set(this, void 0);
+        _RpcDataSource_balanceFetcher.set(this, void 0);
+        _RpcDataSource_tokenDetector.set(this, void 0);
         __classPrivateFieldSet(this, _RpcDataSource_timeout, options.timeout ?? 10000, "f");
-        __classPrivateFieldSet(this, _RpcDataSource_pollInterval, options.pollInterval ?? DEFAULT_POLL_INTERVAL, "f");
+        __classPrivateFieldSet(this, _RpcDataSource_tokenDetectionEnabled, options.tokenDetectionEnabled ?? false, "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"),
+        });
+        // Initialize MulticallClient with a provider getter
+        __classPrivateFieldSet(this, _RpcDataSource_multicallClient, new evm_rpc_services_1.MulticallClient((hexChainId) => {
+            return __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_getMulticallProvider).call(this, hexChainId);
+        }), "f");
+        // Create state getters using messenger
+        const getTokenListState = () => {
+            return this.messenger.call('TokenListController:getState');
+        };
+        const getUserTokensState = () => {
+            return this.messenger.call('AssetsController:getState');
+        };
+        // Initialize BalanceFetcher with polling interval
+        __classPrivateFieldSet(this, _RpcDataSource_balanceFetcher, new evm_rpc_services_1.BalanceFetcher(__classPrivateFieldGet(this, _RpcDataSource_multicallClient, "f"), {
+            pollingInterval: balanceInterval,
+        }), "f");
+        __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").setUserTokensStateGetter(getUserTokensState);
+        __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").setOnBalanceUpdate(__classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_handleBalanceUpdate).bind(this));
+        // Initialize TokenDetector with polling interval
+        __classPrivateFieldSet(this, _RpcDataSource_tokenDetector, new evm_rpc_services_1.TokenDetector(__classPrivateFieldGet(this, _RpcDataSource_multicallClient, "f"), {
+            pollingInterval: detectionInterval,
+        }), "f");
+        __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").setTokenListStateGetter(getTokenListState);
+        __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").setOnDetectionUpdate(__classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_handleDetectionUpdate).bind(this));
         __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_registerActionHandlers).call(this);
         __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_subscribeToNetworkController).call(this);
         __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_initializeFromNetworkController).call(this);
     }
-    // ============================================================================
-    // CHAIN STATUS
-    // ============================================================================
+    /**
+     * Get the data source name.
+     *
+     * @returns The name of this data source.
+     */
+    getName() {
+        return this.name;
+    }
+    /**
+     * Get currently active chains.
+     *
+     * @returns Promise resolving to array of active chain IDs.
+     */
+    async getActiveChains() {
+        return __classPrivateFieldGet(this, _RpcDataSource_activeChains, "f");
+    }
     /**
      * Get the status of all configured chains.
      *
      * @returns Record of chain statuses keyed by chain ID.
      */
     getChainStatuses() {
-        return { ...this.state.chainStatuses };
+        return { ...__classPrivateFieldGet(this, _RpcDataSource_chainStatuses, "f") };
     }
     /**
      * Get the status of a specific chain.
      *
-     * @param chainId - The CAIP-2 chain ID to check.
-     * @returns The chain status, or undefined if not configured.
+     * @param chainId - The chain ID to get status for.
+     * @returns The chain status or undefined if not found.
      */
     getChainStatus(chainId) {
-        return this.state.chainStatuses[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();
     }
-    // ============================================================================
-    // FETCH
-    // ============================================================================
     async fetch(request) {
         const response = {};
-        // Filter to active chains
-        const chainsToFetch = request.chainIds.filter((chainId) => this.state.activeChains.includes(chainId));
+        const chainsToFetch = request.chainIds.filter((chainId) => __classPrivateFieldGet(this, _RpcDataSource_activeChains, "f").includes(chainId));
+        log('Fetch requested', {
+            accounts: request.accounts.map((a) => a.id),
+            requestedChains: request.chainIds,
+            chainsToFetch,
+        });
         if (chainsToFetch.length === 0) {
+            log('No active chains to fetch');
             return response;
         }
         const assetsBalance = {};
         const failedChains = [];
-        // Fetch native balance for each chain
+        // Fetch balances for each chain using BalanceFetcher
         for (const chainId of chainsToFetch) {
-            const provider = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_getProvider).call(this, chainId);
-            if (!provider) {
-                continue;
-            }
-            const assetId = buildNativeAssetId(chainId);
-            // Fetch balance for each account that supports this chain
+            const hexChainId = (0, exports.caipChainIdToHex)(chainId);
             for (const account of request.accounts) {
-                // Check if account supports this chain based on its scopes
                 if (!__classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_accountSupportsChain).call(this, account, chainId)) {
                     continue;
                 }
                 const { address, id: accountId } = account;
                 try {
-                    const balancePromise = provider.getBalance(address);
-                    const timeoutPromise = new Promise((_resolve, reject) => setTimeout(() => reject(new Error('RPC timeout')), __classPrivateFieldGet(this, _RpcDataSource_timeout, "f")));
-                    const balance = await Promise.race([balancePromise, timeoutPromise]);
+                    // Use BalanceFetcher for batched balance fetching
+                    const result = await __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").fetchBalancesForTokens(hexChainId, accountId, address, [], // Empty array means just native token
+                    { includeNative: true });
                     if (!assetsBalance[accountId]) {
                         assetsBalance[accountId] = {};
                     }
-                    assetsBalance[accountId][assetId] = {
-                        amount: balance.toString(),
-                    };
+                    // Convert balances to response format
+                    for (const balance of result.balances) {
+                        assetsBalance[accountId][balance.assetId] = {
+                            amount: balance.balance,
+                        };
+                    }
                 }
                 catch (error) {
                     log('Failed to fetch balance', { address, chainId, error });
                     if (!assetsBalance[accountId]) {
                         assetsBalance[accountId] = {};
                     }
-                    assetsBalance[accountId][assetId] = { amount: '0' };
+                    const nativeAssetId = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_buildNativeAssetId).call(this, chainId);
+                    assetsBalance[accountId][nativeAssetId] = { amount: '0' };
                     if (!failedChains.includes(chainId)) {
                         failedChains.push(chainId);
                     }
@@ -141,68 +234,101 @@ class RpcDataSource extends AbstractDataSource_1.AbstractDataSource {
             }
         }
         if (failedChains.length > 0) {
-            // Add failed chains to errors so they can fallback to other data sources
+            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;
         return response;
     }
-    // ============================================================================
-    // MIDDLEWARE
-    // ============================================================================
     /**
-     * Get the middleware for fetching balances via RPC.
-     * This middleware:
-     * - Supports multiple accounts in a single request
-     * - Filters request to only chains this data source supports
-     * - Fetches balances for those chains for all accounts
-     * - Merges response into context
-     * - Removes handled chains from request for next middleware
+     * Run token detection for an account on a chain.
      *
-     * @returns The middleware function for the assets pipeline.
+     * @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")) {
+            return {};
+        }
+        const hexChainId = (0, exports.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);
+            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 = {};
+            // Add balances for detected tokens
+            for (const balance of result.detectedBalances) {
+                balances[balance.assetId] = {
+                    amount: balance.balance,
+                };
+            }
+            const response = {
+                detectedAssets: {
+                    [accountId]: result.detectedAssets.map((asset) => asset.assetId),
+                },
+                assetsBalance: {
+                    [accountId]: balances,
+                },
+            };
+            return response;
+        }
+        catch (error) {
+            log('Token detection failed', { chainId, accountId, error });
+            return {};
+        }
+    }
     get assetsMiddleware() {
         return async (context, next) => {
-            var _a;
+            var _a, _b;
             const { request } = context;
-            // Filter to chains this data source supports
-            const supportedChains = request.chainIds.filter((chainId) => this.state.activeChains.includes(chainId));
-            // If no supported chains, skip and pass to next middleware
+            const supportedChains = request.chainIds.filter((chainId) => __classPrivateFieldGet(this, _RpcDataSource_activeChains, "f").includes(chainId));
             if (supportedChains.length === 0) {
                 return next(context);
             }
             let successfullyHandledChains = [];
-            try {
-                // Fetch for supported chains
-                const response = await this.fetch({
-                    ...request,
-                    chainIds: supportedChains,
-                });
-                // Merge response into context
-                if (response.assetsBalance) {
-                    (_a = context.response).assetsBalance ?? (_a.assetsBalance = {});
-                    for (const [accountId, accountBalances] of Object.entries(response.assetsBalance)) {
-                        if (!context.response.assetsBalance[accountId]) {
-                            context.response.assetsBalance[accountId] = {};
-                        }
-                        context.response.assetsBalance[accountId] = {
-                            ...context.response.assetsBalance[accountId],
-                            ...accountBalances,
-                        };
-                    }
+            log('Middleware fetching', {
+                chains: supportedChains,
+                accounts: request.accounts.map((a) => a.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,
+                    };
                 }
-                // Determine successfully handled chains (exclude errors)
-                const failedChains = new Set(Object.keys(response.errors ?? {}));
-                successfullyHandledChains = supportedChains.filter((chainId) => !failedChains.has(chainId));
             }
-            catch (error) {
-                log('Middleware fetch failed', { error });
-                successfullyHandledChains = [];
-            }
-            // Remove successfully handled chains from request for next middleware
+            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({
@@ -213,88 +339,185 @@ class RpcDataSource extends AbstractDataSource_1.AbstractDataSource {
                     },
                 });
             }
-            // No chains handled - pass context unchanged
             return next(context);
         };
     }
-    // ============================================================================
-    // SUBSCRIBE
-    // ============================================================================
+    /**
+     * Subscribe to updates for the given request.
+     * Starts polling through BalanceFetcher and TokenDetector.
+     *
+     * @param subscriptionRequest - The subscription request details.
+     */
     async subscribe(subscriptionRequest) {
         const { request, subscriptionId, isUpdate } = subscriptionRequest;
-        // Filter to active chains
-        const chainsToSubscribe = request.chainIds.filter((chainId) => this.state.activeChains.includes(chainId));
+        const chainsToSubscribe = request.chainIds.filter((chainId) => __classPrivateFieldGet(this, _RpcDataSource_activeChains, "f").includes(chainId));
+        log('Subscribe requested', {
+            subscriptionId,
+            isUpdate,
+            accounts: request.accounts.map((a) => a.id),
+            chainsToSubscribe,
+        });
         if (chainsToSubscribe.length === 0) {
+            log('No active chains to subscribe');
             return;
         }
-        // Handle subscription update - update both chains AND request (for accounts)
+        // Handle subscription update
         if (isUpdate) {
-            const existing = this.activeSubscriptions.get(subscriptionId);
+            const existing = __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").get(subscriptionId);
             if (existing) {
+                log('Updating existing subscription', {
+                    subscriptionId,
+                    chainsToSubscribe,
+                });
                 existing.chains = chainsToSubscribe;
-                existing.request = request;
+                existing.accounts = request.accounts;
                 return;
             }
         }
         // Clean up existing subscription
         await this.unsubscribe(subscriptionId);
-        const pollInterval = request.updateInterval ?? __classPrivateFieldGet(this, _RpcDataSource_pollInterval, "f");
-        // Create poll function
-        const pollFn = async () => {
-            try {
-                const subscription = this.activeSubscriptions.get(subscriptionId);
-                if (!subscription?.request) {
-                    return;
+        // Start polling through BalanceFetcher and TokenDetector
+        const balancePollingTokens = [];
+        const detectionPollingTokens = [];
+        for (const chainId of chainsToSubscribe) {
+            const hexChainId = (0, exports.caipChainIdToHex)(chainId);
+            for (const account of request.accounts) {
+                if (!__classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_accountSupportsChain).call(this, account, chainId)) {
+                    continue;
+                }
+                const { address, id: accountId } = account;
+                // Start balance polling
+                const balanceInput = {
+                    chainId: hexChainId,
+                    accountId,
+                    accountAddress: address,
+                };
+                const balanceToken = __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").startPolling(balanceInput);
+                balancePollingTokens.push(balanceToken);
+                // Start detection polling if enabled
+                if (__classPrivateFieldGet(this, _RpcDataSource_tokenDetectionEnabled, "f")) {
+                    const detectionInput = {
+                        chainId: hexChainId,
+                        accountId,
+                        accountAddress: address,
+                    };
+                    const detectionToken = __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").startPolling(detectionInput);
+                    detectionPollingTokens.push(detectionToken);
                 }
-                // Use stored request (which gets updated on account changes)
-                const fetchResponse = await this.fetch({
-                    ...subscription.request,
-                    chainIds: subscription.chains,
-                });
-                // Report update to AssetsController
-                await __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('AssetsController:assetsUpdate', fetchResponse, CONTROLLER_NAME);
-            }
-            catch (error) {
-                log('Subscription poll failed', { subscriptionId, error });
             }
-        };
-        // Set up polling
-        const timer = setInterval(() => {
-            pollFn().catch(console.error);
-        }, pollInterval);
-        // Store subscription with request for account updates
-        this.activeSubscriptions.set(subscriptionId, {
-            cleanup: () => {
-                clearInterval(timer);
-            },
+        }
+        // Store subscription data
+        __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").set(subscriptionId, {
+            balancePollingTokens,
+            detectionPollingTokens,
+            chains: chainsToSubscribe,
+            accounts: request.accounts,
+        });
+        log('Subscription SUCCESS', {
+            subscriptionId,
             chains: chainsToSubscribe,
-            request,
+            balancePollingCount: balancePollingTokens.length,
+            detectionPollingCount: detectionPollingTokens.length,
         });
-        // Initial fetch
-        await pollFn();
+    }
+    /**
+     * 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');
+        // 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();
     }
 }
 exports.RpcDataSource = RpcDataSource;
-_RpcDataSource_messenger = new WeakMap(), _RpcDataSource_timeout = new WeakMap(), _RpcDataSource_pollInterval = new WeakMap(), _RpcDataSource_providerCache = new WeakMap(), _RpcDataSource_instances = new WeakSet(), _RpcDataSource_registerActionHandlers = function _RpcDataSource_registerActionHandlers() {
+_RpcDataSource_timeout = new WeakMap(), _RpcDataSource_tokenDetectionEnabled = new WeakMap(), _RpcDataSource_activeChains = new WeakMap(), _RpcDataSource_chainStatuses = new WeakMap(), _RpcDataSource_providerCache = new WeakMap(), _RpcDataSource_activeSubscriptions = new WeakMap(), _RpcDataSource_multicallClient = new WeakMap(), _RpcDataSource_balanceFetcher = new WeakMap(), _RpcDataSource_tokenDetector = new WeakMap(), _RpcDataSource_instances = new WeakSet(), _RpcDataSource_handleBalanceUpdate = function _RpcDataSource_handleBalanceUpdate(result) {
+    const accountBalances = {};
+    for (const balance of result.balances) {
+        accountBalances[balance.assetId] = {
+            amount: balance.balance,
+        };
+    }
+    const response = {
+        assetsBalance: {
+            [result.accountId]: accountBalances,
+        },
+    };
+    this.messenger
+        .call('AssetsController:assetsUpdate', response, CONTROLLER_NAME)
+        .catch((error) => {
+        log('Failed to update assets', { error });
+    });
+}, _RpcDataSource_handleDetectionUpdate = function _RpcDataSource_handleDetectionUpdate(result) {
+    log('Detected new tokens', {
+        count: result.detectedAssets.length,
+    });
+    const response = {
+        detectedAssets: {
+            [result.accountId]: result.detectedAssets.map((asset) => asset.assetId),
+        },
+    };
+    // Add balances for detected tokens
+    if (result.detectedBalances.length > 0) {
+        response.assetsBalance = {
+            [result.accountId]: {},
+        };
+        for (const balance of result.detectedBalances) {
+            response.assetsBalance[result.accountId][balance.assetId] = {
+                amount: balance.balance,
+            };
+        }
+    }
+    this.messenger
+        .call('AssetsController:assetsUpdate', response, CONTROLLER_NAME)
+        .catch((error) => {
+        log('Failed to update detected assets', { error });
+    });
+}, _RpcDataSource_registerActionHandlers = function _RpcDataSource_registerActionHandlers() {
     const getAssetsMiddlewareHandler = () => this.assetsMiddleware;
     const getActiveChainsHandler = async () => this.getActiveChains();
     const fetchHandler = async (request) => this.fetch(request);
     const subscribeHandler = async (request) => this.subscribe(request);
     const unsubscribeHandler = async (subscriptionId) => this.unsubscribe(subscriptionId);
-    __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").registerActionHandler('RpcDataSource:getAssetsMiddleware', getAssetsMiddlewareHandler);
-    __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").registerActionHandler('RpcDataSource:getActiveChains', getActiveChainsHandler);
-    __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").registerActionHandler('RpcDataSource:fetch', fetchHandler);
-    __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").registerActionHandler('RpcDataSource:subscribe', subscribeHandler);
-    __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").registerActionHandler('RpcDataSource:unsubscribe', unsubscribeHandler);
+    this.messenger.registerActionHandler('RpcDataSource:getAssetsMiddleware', getAssetsMiddlewareHandler);
+    this.messenger.registerActionHandler('RpcDataSource:getActiveChains', getActiveChainsHandler);
+    this.messenger.registerActionHandler('RpcDataSource:fetch', fetchHandler);
+    this.messenger.registerActionHandler('RpcDataSource:subscribe', subscribeHandler);
+    this.messenger.registerActionHandler('RpcDataSource:unsubscribe', unsubscribeHandler);
 }, _RpcDataSource_subscribeToNetworkController = function _RpcDataSource_subscribeToNetworkController() {
-    __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").subscribe('NetworkController:stateChange', (networkState) => {
-        // Clear provider cache since network configurations may have changed
+    this.messenger.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_initializeFromNetworkController = function _RpcDataSource_initializeFromNetworkController() {
+    log('Initializing from NetworkController');
     try {
-        const networkState = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('NetworkController:getState');
+        const networkState = this.messenger.call('NetworkController:getState');
         __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_updateFromNetworkState).call(this, networkState);
     }
     catch (error) {
@@ -304,19 +527,15 @@ _RpcDataSource_messenger = new WeakMap(), _RpcDataSource_timeout = new WeakMap()
     const { networkConfigurationsByChainId, networksMetadata } = networkState;
     const chainStatuses = {};
     const activeChains = [];
-    // Iterate through all configured networks
     for (const [hexChainId, config] of Object.entries(networkConfigurationsByChainId)) {
-        // Convert hex chainId to CAIP-2 format (eip155:decimal)
         const decimalChainId = parseInt(hexChainId, 16);
         const caip2ChainId = `eip155:${decimalChainId}`;
-        // Get the default RPC endpoint's network client ID
         const defaultRpcEndpoint = config.rpcEndpoints[config.defaultRpcEndpointIndex];
         if (!defaultRpcEndpoint) {
             continue;
         }
         const { networkClientId } = defaultRpcEndpoint;
         const metadata = networksMetadata[networkClientId];
-        // Determine status - default to 'unknown' if not in metadata
         const status = metadata?.status ?? 'unknown';
         chainStatuses[caip2ChainId] = {
             chainId: caip2ChainId,
@@ -325,84 +544,94 @@ _RpcDataSource_messenger = new WeakMap(), _RpcDataSource_timeout = new WeakMap()
             nativeCurrency: config.nativeCurrency,
             networkClientId,
         };
-        // Only include chains that have an available status
-        // (not degraded/unavailable/blocked)
         if (status === 'available' || status === 'unknown') {
             activeChains.push(caip2ChainId);
         }
     }
-    // Update state
-    this.state.chainStatuses = chainStatuses;
-    // Update active chains and report to AssetsController
-    this.updateActiveChains(activeChains, (chains) => __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('AssetsController:activeChainsUpdate', CONTROLLER_NAME, chains));
+    log('Network state updated', {
+        configuredChains: Object.keys(chainStatuses),
+        activeChains,
+    });
+    // Check if chains changed
+    const previousChains = new Set(__classPrivateFieldGet(this, _RpcDataSource_activeChains, "f"));
+    const hasChanges = previousChains.size !== activeChains.length ||
+        activeChains.some((chain) => !previousChains.has(chain));
+    // Update internal state
+    __classPrivateFieldSet(this, _RpcDataSource_chainStatuses, chainStatuses, "f");
+    __classPrivateFieldSet(this, _RpcDataSource_activeChains, activeChains, "f");
+    if (hasChanges) {
+        this.messenger.call('AssetsController:activeChainsUpdate', CONTROLLER_NAME, activeChains);
+    }
 }, _RpcDataSource_getProvider = function _RpcDataSource_getProvider(chainId) {
-    // Check cache first
     const cached = __classPrivateFieldGet(this, _RpcDataSource_providerCache, "f").get(chainId);
     if (cached) {
         return cached;
     }
-    // Get chain status to find networkClientId
-    const chainStatus = this.state.chainStatuses[chainId];
+    const chainStatus = __classPrivateFieldGet(this, _RpcDataSource_chainStatuses, "f")[chainId];
     if (!chainStatus) {
         return undefined;
     }
     try {
-        // Get network client from NetworkController (like TokenBalancesController)
-        const networkClient = __classPrivateFieldGet(this, _RpcDataSource_messenger, "f").call('NetworkController:getNetworkClientById', chainStatus.networkClientId);
-        // Create Web3Provider directly
+        const networkClient = this.messenger.call('NetworkController:getNetworkClientById', chainStatus.networkClientId);
         const web3Provider = new providers_1.Web3Provider(networkClient.provider);
-        // Cache for reuse
         __classPrivateFieldGet(this, _RpcDataSource_providerCache, "f").set(chainId, web3Provider);
         return web3Provider;
     }
     catch (error) {
-        console.error(`[RpcDataSource] Failed to get provider for chain ${chainId}:`, 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_accountSupportsChain = function _RpcDataSource_accountSupportsChain(account, chainId) {
     const scopes = account.scopes ?? [];
-    // If no scopes defined, assume it supports the chain (backward compatibility)
     if (scopes.length === 0) {
         return true;
     }
-    // Extract namespace and reference from chainId (e.g., "eip155:1" -> ["eip155", "1"])
     const [chainNamespace, chainReference] = chainId.split(':');
     for (const scope of scopes) {
         const [scopeNamespace, scopeReference] = scope.split(':');
-        // Check if namespaces match
         if (scopeNamespace !== chainNamespace) {
             continue;
         }
-        // Wildcard scope (e.g., "eip155:0" means all chains in that namespace)
+        // Wildcard scope (e.g., eip155:0) matches all chains in the namespace
         if (scopeReference === '0') {
             return true;
         }
-        // Exact match check - normalize hex to decimal for EIP155
-        if (chainNamespace === 'eip155') {
-            const normalizedScopeRef = scopeReference?.startsWith('0x')
-                ? parseInt(scopeReference, 16).toString()
-                : scopeReference;
-            if (normalizedScopeRef === chainReference) {
-                return true;
-            }
-        }
-        else if (scopeReference === chainReference) {
+        // RpcDataSource only handles eip155 (EVM) chains
+        // Normalize hex chain references (e.g., 0x1 -> 1) for comparison
+        const normalizedScopeRef = scopeReference?.startsWith('0x')
+            ? parseInt(scopeReference, 16).toString()
+            : scopeReference;
+        if (normalizedScopeRef === chainReference) {
             return true;
         }
     }
     return false;
+}, _RpcDataSource_buildNativeAssetId = function _RpcDataSource_buildNativeAssetId(chainId) {
+    const { nativeAssetIdentifiers } = this.messenger.call('NetworkEnablementController:getState');
+    return (nativeAssetIdentifiers[chainId] ??
+        `${chainId}/slip44:60`);
 };
-// ============================================================================
-// FACTORY FUNCTION
-// ============================================================================
-/**
- * Creates an RpcDataSource instance.
- *
- * @param options - Configuration options for the data source.
- * @returns A new RpcDataSource instance.
- */
 function createRpcDataSource(options) {
     return new RpcDataSource(options);
 }