@metamask/assets-controller 0.1.0

package/dist/data-sources/RpcDataSource.cjs

@@ -0,0 +1,829 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _RpcDataSource_instances, _RpcDataSource_timeout, _RpcDataSource_tokenDetectionEnabled, _RpcDataSource_activeChains, _RpcDataSource_chainStatuses, _RpcDataSource_providerCache, _RpcDataSource_activeSubscriptions, _RpcDataSource_multicallClient, _RpcDataSource_balanceFetcher, _RpcDataSource_tokenDetector, _RpcDataSource_convertToHumanReadable, _RpcDataSource_collectMetadataForBalances, _RpcDataSource_handleBalanceUpdate, _RpcDataSource_handleDetectionUpdate, _RpcDataSource_registerActionHandlers, _RpcDataSource_subscribeToNetworkController, _RpcDataSource_initializeFromNetworkController, _RpcDataSource_updateFromNetworkState, _RpcDataSource_getProvider, _RpcDataSource_getMulticallProvider, _RpcDataSource_clearProviderCache, _RpcDataSource_accountSupportsChain, _RpcDataSource_buildNativeAssetId, _RpcDataSource_getExistingAssetsMetadata, _RpcDataSource_getTokenMetadataFromTokenList;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcDataSource = exports.RpcDataSource = exports.caipChainIdToHex = void 0;
+const providers_1 = require("@ethersproject/providers");
+const base_controller_1 = require("@metamask/base-controller");
+const controller_utils_1 = require("@metamask/controller-utils");
+const utils_1 = require("@metamask/utils");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const evm_rpc_services_1 = require("./evm-rpc-services/index.cjs");
+const logger_1 = require("../logger.cjs");
+const CONTROLLER_NAME = 'RpcDataSource';
+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);
+/**
+ * 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');
+};
+exports.caipChainIdToHex = caipChainIdToHex;
+/**
+ * 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
+ */
+class RpcDataSource extends base_controller_1.BaseController {
+    constructor(options) {
+        super({
+            name: CONTROLLER_NAME,
+            metadata: {},
+            state: {},
+            messenger: options.messenger,
+        });
+        _RpcDataSource_instances.add(this);
+        _RpcDataSource_timeout.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());
+        /** 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_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 messenger adapters for BalanceFetcher and TokenDetector
+        const balanceFetcherMessenger = {
+            call: (_action) => {
+                const state = this.messenger.call('AssetsController:getState');
+                return {
+                    assetsBalance: (state.assetsBalance ?? {}),
+                };
+            },
+        };
+        const tokenDetectorMessenger = {
+            call: (_action) => {
+                return this.messenger.call('TokenListController:getState');
+            },
+        };
+        // Initialize BalanceFetcher with polling interval
+        __classPrivateFieldSet(this, _RpcDataSource_balanceFetcher, new evm_rpc_services_1.BalanceFetcher(__classPrivateFieldGet(this, _RpcDataSource_multicallClient, "f"), balanceFetcherMessenger, { pollingInterval: balanceInterval }), "f");
+        __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"), tokenDetectorMessenger, { pollingInterval: detectionInterval }), "f");
+        __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);
+    }
+    /**
+     * 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 { ...__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) {
+        const response = {};
+        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 assetsMetadata = {};
+        const failedChains = [];
+        // Fetch balances for each chain using BalanceFetcher
+        for (const chainId of chainsToFetch) {
+            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;
+                try {
+                    // 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] = {};
+                    }
+                    // Collect metadata for all balances
+                    const balanceMetadata = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_collectMetadataForBalances).call(this, result.balances, chainId);
+                    Object.assign(assetsMetadata, balanceMetadata);
+                    // Convert balances to human-readable format
+                    for (const balance of result.balances) {
+                        const metadata = assetsMetadata[balance.assetId];
+                        // Default to 18 decimals (ERC20 standard) for consistent human-readable format
+                        const decimals = metadata?.decimals ?? 18;
+                        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] = {};
+                    }
+                    const nativeAssetId = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_buildNativeAssetId).call(this, chainId);
+                    assetsBalance[accountId][nativeAssetId] = { amount: '0' };
+                    // Even on error, include native token metadata
+                    const chainStatus = __classPrivateFieldGet(this, _RpcDataSource_chainStatuses, "f")[chainId];
+                    if (chainStatus) {
+                        assetsMetadata[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(assetsMetadata).length > 0) {
+            response.assetsMetadata = assetsMetadata;
+        }
+        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")) {
+            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 = {};
+            const assetsMetadata = {};
+            // Build metadata from detected assets
+            for (const asset of result.detectedAssets) {
+                if (asset.symbol && asset.decimals !== undefined) {
+                    assetsMetadata[asset.assetId] = {
+                        type: 'erc20',
+                        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);
+                // Default to 18 decimals (ERC20 standard) for consistent human-readable format
+                const decimals = detectedAsset?.decimals ?? 18;
+                const humanReadableAmount = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_convertToHumanReadable).call(this, balance.balance, 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(assetsMetadata).length > 0) {
+                response.assetsMetadata = assetsMetadata;
+            }
+            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.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,
+                    };
+                }
+            }
+            if (response.assetsMetadata) {
+                (_c = context.response).assetsMetadata ?? (_c.assetsMetadata = {});
+                context.response.assetsMetadata = {
+                    ...context.response.assetsMetadata,
+                    ...response.assetsMetadata,
+                };
+            }
+            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) {
+        const { request, subscriptionId, isUpdate } = subscriptionRequest;
+        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 - 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 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);
+                }
+            }
+        }
+        // Store subscription data
+        __classPrivateFieldGet(this, _RpcDataSource_activeSubscriptions, "f").set(subscriptionId, {
+            balancePollingTokens,
+            detectionPollingTokens,
+            chains: chainsToSubscribe,
+            accounts: request.accounts,
+        });
+        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');
+        // 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_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_convertToHumanReadable = function _RpcDataSource_convertToHumanReadable(rawBalance, decimals) {
+    const rawAmount = new bignumber_js_1.default(rawBalance);
+    const divisor = new bignumber_js_1.default(10).pow(decimals);
+    return rawAmount.dividedBy(divisor).toString();
+}, _RpcDataSource_collectMetadataForBalances = function _RpcDataSource_collectMetadataForBalances(balances, chainId) {
+    const assetsMetadata = {};
+    const existingMetadata = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_getExistingAssetsMetadata).call(this);
+    for (const balance of balances) {
+        const isNative = balance.assetId.includes('/slip44:');
+        if (isNative) {
+            const chainStatus = __classPrivateFieldGet(this, _RpcDataSource_chainStatuses, "f")[chainId];
+            if (chainStatus) {
+                assetsMetadata[balance.assetId] = {
+                    type: 'native',
+                    symbol: chainStatus.nativeCurrency,
+                    name: chainStatus.nativeCurrency,
+                    decimals: 18,
+                };
+            }
+        }
+        else {
+            // For ERC20 tokens, try existing metadata from state first
+            const existingMeta = existingMetadata[balance.assetId];
+            if (existingMeta) {
+                assetsMetadata[balance.assetId] = existingMeta;
+            }
+            else {
+                // Fallback to token list if not in state
+                const tokenListMeta = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_getTokenMetadataFromTokenList).call(this, balance.assetId);
+                if (tokenListMeta) {
+                    assetsMetadata[balance.assetId] = tokenListMeta;
+                }
+                else {
+                    // Default metadata for unknown ERC20 tokens.
+                    // Use 18 decimals (the standard for most ERC20 tokens)
+                    // to ensure consistent human-readable balance format.
+                    assetsMetadata[balance.assetId] = {
+                        type: 'erc20',
+                        symbol: '',
+                        name: '',
+                        decimals: 18,
+                    };
+                }
+            }
+        }
+    }
+    return assetsMetadata;
+}, _RpcDataSource_handleBalanceUpdate = function _RpcDataSource_handleBalanceUpdate(result) {
+    const newBalances = {};
+    // Convert hex chain ID to CAIP-2 format
+    const chainIdDecimal = parseInt(result.chainId, 16);
+    const caipChainId = `eip155:${chainIdDecimal}`;
+    // Collect metadata for all balances
+    const assetsMetadata = __classPrivateFieldGet(this, _RpcDataSource_instances, "m", _RpcDataSource_collectMetadataForBalances).call(this, result.balances, caipChainId);
+    // Convert balances to human-readable format using metadata
+    for (const balance of result.balances) {
+        const metadata = assetsMetadata[balance.assetId];
+        // Default to 18 decimals (ERC20 standard) for consistent human-readable format
+        const decimals = metadata?.decimals ?? 18;
+        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,
+        },
+        assetsMetadata,
+    };
+    log('Balance update response', {
+        accountId: result.accountId,
+        newBalanceCount: Object.keys(newBalances).length,
+    });
+    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,
+    });
+    // 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: 'erc20',
+                    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);
+            // Default to 18 decimals (ERC20 standard) for consistent human-readable format
+            const decimals = detectedAsset?.decimals ?? 18;
+            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 = {
+        detectedAssets: {
+            [result.accountId]: result.detectedAssets.map((asset) => asset.assetId),
+        },
+        assetsMetadata: newMetadata,
+        assetsBalance: {
+            [result.accountId]: newBalances,
+        },
+    };
+    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);
+    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() {
+    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 = this.messenger.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 = 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) {
+    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 = this.messenger.call('NetworkController:getNetworkClientById', chainStatus.networkClientId);
+        const web3Provider = new providers_1.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_accountSupportsChain = function _RpcDataSource_accountSupportsChain(account, chainId) {
+    const scopes = account.scopes ?? [];
+    if (scopes.length === 0) {
+        return true;
+    }
+    const [chainNamespace, chainReference] = chainId.split(':');
+    for (const scope of scopes) {
+        const [scopeNamespace, scopeReference] = scope.split(':');
+        if (scopeNamespace !== chainNamespace) {
+            continue;
+        }
+        // Wildcard scope (e.g., eip155:0) matches all chains in the namespace
+        if (scopeReference === '0') {
+            return true;
+        }
+        // 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`);
+}, _RpcDataSource_getExistingAssetsMetadata = function _RpcDataSource_getExistingAssetsMetadata() {
+    try {
+        const state = this.messenger.call('AssetsController:getState');
+        return (state.assetsMetadata ?? {});
+    }
+    catch {
+        // If AssetsController:getState fails, return empty metadata
+        return {};
+    }
+}, _RpcDataSource_getTokenMetadataFromTokenList = function _RpcDataSource_getTokenMetadataFromTokenList(assetId) {
+    try {
+        // Parse asset ID to get chain and token address
+        // Format: eip155:{chainId}/erc20:{address}
+        const [chainPart, assetPart] = assetId.split('/');
+        if (!assetPart?.startsWith('erc20:')) {
+            return undefined;
+        }
+        const tokenAddress = assetPart.slice(6); // Remove 'erc20:' prefix
+        const chainIdDecimal = chainPart.split(':')[1];
+        const hexChainId = `0x${parseInt(chainIdDecimal, 10).toString(16)}`;
+        const tokenListState = this.messenger.call('TokenListController:getState');
+        const chainCacheEntry = tokenListState.tokensChainsCache[hexChainId];
+        const chainTokenList = chainCacheEntry?.data;
+        if (!chainTokenList) {
+            return undefined;
+        }
+        // Look up token by address (case-insensitive)
+        const lowerAddress = tokenAddress.toLowerCase();
+        for (const [address, tokenData] of Object.entries(chainTokenList)) {
+            if (address.toLowerCase() === lowerAddress) {
+                const token = tokenData;
+                if (token.symbol && token.decimals !== undefined) {
+                    return {
+                        type: 'erc20',
+                        symbol: token.symbol,
+                        name: token.name ?? token.symbol,
+                        decimals: token.decimals,
+                        image: token.iconUrl,
+                    };
+                }
+            }
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+function createRpcDataSource(options) {
+    return new RpcDataSource(options);
+}
+exports.createRpcDataSource = createRpcDataSource;
+//# sourceMappingURL=RpcDataSource.cjs.map