@metamask-previews/assets-controller 0.0.0-preview-e09bf49f → 0.0.0-preview-52f4a2ca

package/dist/data-sources/RpcDataSource.cjs

@@ -10,13 +10,17 @@ 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_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;
+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';
@@ -94,24 +98,25 @@ class RpcDataSource extends base_controller_1.BaseController {
         __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');
+        // Create messenger adapters for BalanceFetcher and TokenDetector
+        const balanceFetcherMessenger = {
+            call: (_action) => {
+                const state = this.messenger.call('AssetsController:getState');
+                return {
+                    assetsBalance: (state.assetsBalance ?? {}),
+                };
+            },
         };
-        const getUserTokensState = () => {
-            return this.messenger.call('AssetsController:getState');
+        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"), {
-            pollingInterval: balanceInterval,
-        }), "f");
-        __classPrivateFieldGet(this, _RpcDataSource_balanceFetcher, "f").setUserTokensStateGetter(getUserTokensState);
+        __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"), {
-            pollingInterval: detectionInterval,
-        }), "f");
-        __classPrivateFieldGet(this, _RpcDataSource_tokenDetector, "f").setTokenListStateGetter(getTokenListState);
+        __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);
@@ -197,6 +202,7 @@ class RpcDataSource extends base_controller_1.BaseController {
             return response;
         }
         const assetsBalance = {};
+        const assetsMetadata = {};
         const failedChains = [];
         // Fetch balances for each chain using BalanceFetcher
         for (const chainId of chainsToFetch) {
@@ -213,10 +219,17 @@ class RpcDataSource extends base_controller_1.BaseController {
                     if (!assetsBalance[accountId]) {
                         assetsBalance[accountId] = {};
                     }
-                    // Convert balances to response format
+                    // 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: balance.balance,
+                            amount: humanReadableAmount,
                         };
                     }
                 }
@@ -227,6 +240,16 @@ class RpcDataSource extends base_controller_1.BaseController {
                     }
                     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);
                     }
@@ -250,6 +273,10 @@ class RpcDataSource extends base_controller_1.BaseController {
             });
         }
         response.assetsBalance = assetsBalance;
+        // Include metadata for native tokens if we have any
+        if (Object.keys(assetsMetadata).length > 0) {
+            response.assetsMetadata = assetsMetadata;
+        }
         return response;
     }
     /**
@@ -279,10 +306,27 @@ class RpcDataSource extends base_controller_1.BaseController {
             });
             // Convert detected assets to DataResponse format
             const balances = {};
-            // Add balances for detected tokens
+            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: balance.balance,
+                    amount: humanReadableAmount,
                 };
             }
             const response = {
@@ -293,6 +337,10 @@ class RpcDataSource extends base_controller_1.BaseController {
                     [accountId]: balances,
                 },
             };
+            // Include metadata if we have any
+            if (Object.keys(assetsMetadata).length > 0) {
+                response.assetsMetadata = assetsMetadata;
+            }
             return response;
         }
         catch (error) {
@@ -302,7 +350,7 @@ class RpcDataSource extends base_controller_1.BaseController {
     }
     get assetsMiddleware() {
         return async (context, next) => {
-            var _a, _b;
+            var _a, _b, _c;
             const { request } = context;
             const supportedChains = request.chainIds.filter((chainId) => __classPrivateFieldGet(this, _RpcDataSource_activeChains, "f").includes(chainId));
             if (supportedChains.length === 0) {
@@ -327,6 +375,13 @@ class RpcDataSource extends base_controller_1.BaseController {
                     };
                 }
             }
+            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) {
@@ -361,20 +416,19 @@ class RpcDataSource extends base_controller_1.BaseController {
             log('No active chains to subscribe');
             return;
         }
-        // Handle subscription update
+        // 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', {
+                log('Updating existing subscription - restarting polling', {
                     subscriptionId,
-                    chainsToSubscribe,
+                    existingChains: existing.chains,
+                    newChains: chainsToSubscribe,
                 });
-                existing.chains = chainsToSubscribe;
-                existing.accounts = request.accounts;
-                return;
+                // Don't return early - continue to unsubscribe and restart polling
             }
         }
-        // Clean up existing subscription
+        // Clean up existing subscription (stops old polling)
         await this.unsubscribe(subscriptionId);
         // Start polling through BalanceFetcher and TokenDetector
         const balancePollingTokens = [];
@@ -455,18 +509,82 @@ class RpcDataSource extends base_controller_1.BaseController {
     }
 }
 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_handleBalanceUpdate = function _RpcDataSource_handleBalanceUpdate(result) {
-    const accountBalances = {};
+_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) {
-        accountBalances[balance.assetId] = {
-            amount: balance.balance,
+        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]: accountBalances,
+            [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) => {
@@ -476,22 +594,47 @@ _RpcDataSource_timeout = new WeakMap(), _RpcDataSource_tokenDetectionEnabled = n
     log('Detected new tokens', {
         count: result.detectedAssets.length,
     });
-    const response = {
-        detectedAssets: {
-            [result.accountId]: result.detectedAssets.map((asset) => asset.assetId),
-        },
-    };
-    // Add balances for detected tokens
+    // 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) {
-        response.assetsBalance = {
-            [result.accountId]: {},
-        };
         for (const balance of result.detectedBalances) {
-            response.assetsBalance[result.accountId][balance.assetId] = {
-                amount: balance.balance,
+            // 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) => {
@@ -631,6 +774,53 @@ _RpcDataSource_timeout = new WeakMap(), _RpcDataSource_tokenDetectionEnabled = n
     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);