@metamask/assets-controllers 42.0.0 → 43.1.0

package/dist/TokenDetectionController.mjs

@@ -9,7 +9,7 @@ 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 _TokenDetectionController_instances, _TokenDetectionController_intervalId, _TokenDetectionController_selectedAccountId, _TokenDetectionController_networkClientId, _TokenDetectionController_tokensChainsCache, _TokenDetectionController_disabled, _TokenDetectionController_isUnlocked, _TokenDetectionController_isDetectionEnabledFromPreferences, _TokenDetectionController_isDetectionEnabledForNetwork, _TokenDetectionController_getBalancesInSingleCall, _TokenDetectionController_trackMetaMetricsEvent, _TokenDetectionController_accountsAPI, _TokenDetectionController_registerEventListeners, _TokenDetectionController_stopPolling, _TokenDetectionController_startPolling, _TokenDetectionController_compareTokensChainsCache, _TokenDetectionController_getCorrectChainIdAndNetworkClientId, _TokenDetectionController_restartTokenDetection, _TokenDetectionController_getSlicesOfTokensToDetect, _TokenDetectionController_getConvertedStaticMainnetTokenList, _TokenDetectionController_addDetectedTokensViaAPI, _TokenDetectionController_addDetectedTokens, _TokenDetectionController_getSelectedAccount, _TokenDetectionController_getSelectedAddress;
+var _TokenDetectionController_instances, _TokenDetectionController_intervalId, _TokenDetectionController_selectedAccountId, _TokenDetectionController_networkClientId, _TokenDetectionController_tokensChainsCache, _TokenDetectionController_disabled, _TokenDetectionController_isUnlocked, _TokenDetectionController_isDetectionEnabledFromPreferences, _TokenDetectionController_isDetectionEnabledForNetwork, _TokenDetectionController_getBalancesInSingleCall, _TokenDetectionController_trackMetaMetricsEvent, _TokenDetectionController_accountsAPI, _TokenDetectionController_registerEventListeners, _TokenDetectionController_stopPolling, _TokenDetectionController_startPolling, _TokenDetectionController_compareTokensChainsCache, _TokenDetectionController_getCorrectNetworkClientIdByChainId, _TokenDetectionController_getCorrectChainIdAndNetworkClientId, _TokenDetectionController_restartTokenDetection, _TokenDetectionController_getChainsToDetect, _TokenDetectionController_attemptAccountAPIDetection, _TokenDetectionController_addChainsToRpcDetection, _TokenDetectionController_shouldDetectTokens, _TokenDetectionController_detectTokensUsingRpc, _TokenDetectionController_getSlicesOfTokensToDetect, _TokenDetectionController_getConvertedStaticMainnetTokenList, _TokenDetectionController_addDetectedTokensViaAPI, _TokenDetectionController_filterAndBuildTokensWithBalance, _TokenDetectionController_addDetectedTokens, _TokenDetectionController_getSelectedAccount, _TokenDetectionController_getSelectedAddress;
 function $importDefault(module) {
     if (module?.__esModule) {
         return module.default;
@@ -43,7 +43,7 @@ export const STATIC_MAINNET_TOKEN_LIST = Object.entries(contractMap).reduce((acc
  * @param tokensChainsCache - TokensChainsCache input object
  * @returns returns the map of chainId with TokenListMap
  */
-function mapChainIdWithTokenListMap(tokensChainsCache) {
+export function mapChainIdWithTokenListMap(tokensChainsCache) {
     return mapValues(tokensChainsCache, (value) => {
         if (isObject(value) && 'data' in value) {
             return get(value, ['data']);
@@ -110,18 +110,15 @@ export class TokenDetectionController extends StaticIntervalPollingController()
                 this.supportedNetworksCache = result;
                 return result;
             },
-            async getMultiChainBalances(address, chainId) {
-                if (!this.isAccountsAPIEnabled) {
-                    throw new Error('Accounts API Feature Switch is disabled');
-                }
-                const chainIdNumber = hexToNumber(chainId);
-                const supportedNetworks = await this.getSupportedNetworks();
-                if (!supportedNetworks || !supportedNetworks.includes(chainIdNumber)) {
+            async getMultiNetworksBalances(address, chainIds, supportedNetworks) {
+                const chainIdNumbers = chainIds.map((chainId) => hexToNumber(chainId));
+                if (!supportedNetworks ||
+                    !chainIdNumbers.every((id) => supportedNetworks.includes(id))) {
                     const supportedNetworksErrStr = (supportedNetworks ?? []).toString();
-                    throw new Error(`Unsupported Network: supported networks ${supportedNetworksErrStr}, network: ${chainIdNumber}`);
+                    throw new Error(`Unsupported Network: supported networks ${supportedNetworksErrStr}, requested networks: ${chainIdNumbers.toString()}`);
                 }
                 const result = await fetchMultiChainBalances(address, {
-                    networks: [chainIdNumber],
+                    networks: chainIdNumbers,
                 }, this.platform);
                 return result.balances;
             },
@@ -177,12 +174,12 @@ export class TokenDetectionController extends StaticIntervalPollingController()
         this.disable();
         __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_stopPolling).call(this);
     }
-    async _executePoll({ networkClientId, address, }) {
+    async _executePoll({ chainIds, address, }) {
         if (!this.isActive) {
             return;
         }
         await this.detectTokens({
-            networkClientId,
+            chainIds,
             selectedAddress: address,
         });
     }
@@ -191,51 +188,35 @@ export class TokenDetectionController extends StaticIntervalPollingController()
      * On mainnet, if token detection is disabled in preferences, ERC20 token auto detection will be triggered for each contract address in the legacy token list from the @metamask/contract-metadata repo.
      *
      * @param options - Options for token detection.
-     * @param options.networkClientId - The ID of the network client to use.
+     * @param options.chainIds - The chain IDs of the network client to use.
      * @param options.selectedAddress - the selectedAddress against which to detect for token balances.
      */
-    async detectTokens({ networkClientId, selectedAddress, } = {}) {
+    async detectTokens({ chainIds, selectedAddress, } = {}) {
         if (!this.isActive) {
             return;
         }
-        const addressAgainstWhichToDetect = selectedAddress ?? __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getSelectedAddress).call(this);
-        const { chainId, networkClientId: selectedNetworkClientId } = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getCorrectChainIdAndNetworkClientId).call(this, networkClientId);
-        const chainIdAgainstWhichToDetect = chainId;
-        const networkClientIdAgainstWhichToDetect = selectedNetworkClientId;
-        if (!isTokenDetectionSupportedForNetwork(chainIdAgainstWhichToDetect)) {
-            return;
+        const addressToDetect = selectedAddress ?? __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getSelectedAddress).call(this);
+        const clientNetworks = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getCorrectNetworkClientIdByChainId).call(this, chainIds);
+        let supportedNetworks;
+        if (__classPrivateFieldGet(this, _TokenDetectionController_accountsAPI, "f").isAccountsAPIEnabled) {
+            supportedNetworks = await __classPrivateFieldGet(this, _TokenDetectionController_accountsAPI, "f").getSupportedNetworks();
         }
-        if (!__classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f") &&
-            chainIdAgainstWhichToDetect !== ChainId.mainnet) {
-            return;
+        const { chainsToDetectUsingRpc, chainsToDetectUsingAccountAPI } = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getChainsToDetect).call(this, clientNetworks, supportedNetworks);
+        // Try detecting tokens via Account API first if conditions allow
+        if (supportedNetworks && chainsToDetectUsingAccountAPI.length > 0) {
+            const apiResult = await __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_attemptAccountAPIDetection).call(this, chainsToDetectUsingAccountAPI, addressToDetect, supportedNetworks);
+            // If API succeeds and no chains are left for RPC detection, we can return early
+            if (apiResult?.result === 'success' &&
+                chainsToDetectUsingRpc.length === 0) {
+                return;
+            }
+            // If API fails or chainsToDetectUsingRpc still has items, add chains to RPC detection
+            __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_addChainsToRpcDetection).call(this, chainsToDetectUsingRpc, chainsToDetectUsingAccountAPI, clientNetworks);
         }
-        const isTokenDetectionInactiveInMainnet = !__classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f") &&
-            chainIdAgainstWhichToDetect === ChainId.mainnet;
-        const { tokensChainsCache } = this.messagingSystem.call('TokenListController:getState');
-        __classPrivateFieldSet(this, _TokenDetectionController_tokensChainsCache, isTokenDetectionInactiveInMainnet
-            ? __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getConvertedStaticMainnetTokenList).call(this)
-            : tokensChainsCache ?? {}, "f");
-        const tokenCandidateSlices = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getSlicesOfTokensToDetect).call(this, {
-            chainId: chainIdAgainstWhichToDetect,
-            selectedAddress: addressAgainstWhichToDetect,
-        });
-        // Attempt Accounts API Detection
-        const accountAPIResult = await __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_addDetectedTokensViaAPI).call(this, {
-            chainId: chainIdAgainstWhichToDetect,
-            selectedAddress: addressAgainstWhichToDetect,
-            tokenCandidateSlices,
-        });
-        if (accountAPIResult?.result === 'success') {
-            return;
+        // Proceed with RPC detection if there are chains remaining in chainsToDetectUsingRpc
+        if (chainsToDetectUsingRpc.length > 0) {
+            await __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_detectTokensUsingRpc).call(this, chainsToDetectUsingRpc, addressToDetect);
         }
-        // Attempt RPC Detection
-        const tokenDetectionPromises = tokenCandidateSlices.map((tokensSlice) => __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_addDetectedTokens).call(this, {
-            tokensSlice,
-            selectedAddress: addressAgainstWhichToDetect,
-            networkClientId: networkClientIdAgainstWhichToDetect,
-            chainId: chainIdAgainstWhichToDetect,
-        }));
-        await Promise.all(tokenDetectionPromises);
     }
 }
 _TokenDetectionController_intervalId = new WeakMap(), _TokenDetectionController_selectedAccountId = new WeakMap(), _TokenDetectionController_networkClientId = new WeakMap(), _TokenDetectionController_tokensChainsCache = new WeakMap(), _TokenDetectionController_disabled = new WeakMap(), _TokenDetectionController_isUnlocked = new WeakMap(), _TokenDetectionController_isDetectionEnabledFromPreferences = new WeakMap(), _TokenDetectionController_isDetectionEnabledForNetwork = new WeakMap(), _TokenDetectionController_getBalancesInSingleCall = new WeakMap(), _TokenDetectionController_trackMetaMetricsEvent = new WeakMap(), _TokenDetectionController_accountsAPI = new WeakMap(), _TokenDetectionController_instances = new WeakSet(), _TokenDetectionController_registerEventListeners = function _TokenDetectionController_registerEventListeners() {
@@ -283,20 +264,6 @@ _TokenDetectionController_intervalId = new WeakMap(), _TokenDetectionController_
             });
         }
     });
-    this.messagingSystem.subscribe('NetworkController:networkDidChange', 
-    // TODO: Either fix this lint violation or explain why it's necessary to ignore.
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    async ({ selectedNetworkClientId }) => {
-        const isNetworkClientIdChanged = __classPrivateFieldGet(this, _TokenDetectionController_networkClientId, "f") !== selectedNetworkClientId;
-        const { chainId: newChainId } = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getCorrectChainIdAndNetworkClientId).call(this, selectedNetworkClientId);
-        __classPrivateFieldSet(this, _TokenDetectionController_isDetectionEnabledForNetwork, isTokenDetectionSupportedForNetwork(newChainId), "f");
-        if (isNetworkClientIdChanged && __classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledForNetwork, "f")) {
-            __classPrivateFieldSet(this, _TokenDetectionController_networkClientId, selectedNetworkClientId, "f");
-            await __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this, {
-                networkClientId: __classPrivateFieldGet(this, _TokenDetectionController_networkClientId, "f"),
-            });
-        }
-    });
 }, _TokenDetectionController_stopPolling = function _TokenDetectionController_stopPolling() {
     if (__classPrivateFieldGet(this, _TokenDetectionController_intervalId, "f")) {
         clearInterval(__classPrivateFieldGet(this, _TokenDetectionController_intervalId, "f"));
@@ -321,16 +288,26 @@ async function _TokenDetectionController_startPolling() {
     const cleanTokensChainsCache = mapChainIdWithTokenListMap(tokensChainsCache);
     const isEqualValues = isEqual(cleanTokensChainsCache, cleanPreviousTokensChainsCache);
     return isEqualValues;
-}, _TokenDetectionController_getCorrectChainIdAndNetworkClientId = function _TokenDetectionController_getCorrectChainIdAndNetworkClientId(networkClientId) {
-    if (networkClientId) {
-        const networkConfiguration = this.messagingSystem.call('NetworkController:getNetworkConfigurationByNetworkClientId', networkClientId);
-        if (networkConfiguration) {
-            return {
-                chainId: networkConfiguration.chainId,
-                networkClientId,
-            };
-        }
+}, _TokenDetectionController_getCorrectNetworkClientIdByChainId = function _TokenDetectionController_getCorrectNetworkClientIdByChainId(chainIds) {
+    const { networkConfigurationsByChainId, selectedNetworkClientId } = this.messagingSystem.call('NetworkController:getState');
+    if (!chainIds) {
+        const networkConfiguration = this.messagingSystem.call('NetworkController:getNetworkConfigurationByNetworkClientId', selectedNetworkClientId);
+        return [
+            {
+                chainId: networkConfiguration?.chainId ?? ChainId.mainnet,
+                networkClientId: selectedNetworkClientId,
+            },
+        ];
     }
+    return chainIds.map((chainId) => {
+        const configuration = networkConfigurationsByChainId[chainId];
+        return {
+            chainId,
+            networkClientId: configuration.rpcEndpoints[configuration.defaultRpcEndpointIndex]
+                .networkClientId,
+        };
+    });
+}, _TokenDetectionController_getCorrectChainIdAndNetworkClientId = function _TokenDetectionController_getCorrectChainIdAndNetworkClientId() {
     const { selectedNetworkClientId } = this.messagingSystem.call('NetworkController:getState');
     const { configuration: { chainId }, } = this.messagingSystem.call('NetworkController:getNetworkClientById', selectedNetworkClientId);
     return {
@@ -344,14 +321,76 @@ async function _TokenDetectionController_startPolling() {
  *
  * @param options - Options for restart token detection.
  * @param options.selectedAddress - the selectedAddress against which to detect for token balances
- * @param options.networkClientId - The ID of the network client to use.
+ * @param options.chainIds - The chain IDs of the network client to use.
  */
-async function _TokenDetectionController_restartTokenDetection({ selectedAddress, networkClientId, } = {}) {
+async function _TokenDetectionController_restartTokenDetection({ selectedAddress, chainIds, } = {}) {
     await this.detectTokens({
-        networkClientId,
+        chainIds,
         selectedAddress,
     });
     this.setIntervalLength(DEFAULT_INTERVAL);
+}, _TokenDetectionController_getChainsToDetect = function _TokenDetectionController_getChainsToDetect(clientNetworks, supportedNetworks) {
+    const chainsToDetectUsingAccountAPI = [];
+    const chainsToDetectUsingRpc = [];
+    clientNetworks.forEach(({ chainId, networkClientId }) => {
+        if (supportedNetworks?.includes(hexToNumber(chainId))) {
+            chainsToDetectUsingAccountAPI.push(chainId);
+        }
+        else {
+            chainsToDetectUsingRpc.push({ chainId, networkClientId });
+        }
+    });
+    return { chainsToDetectUsingRpc, chainsToDetectUsingAccountAPI };
+}, _TokenDetectionController_attemptAccountAPIDetection = async function _TokenDetectionController_attemptAccountAPIDetection(chainsToDetectUsingAccountAPI, addressToDetect, supportedNetworks) {
+    return await __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_addDetectedTokensViaAPI).call(this, {
+        chainIds: chainsToDetectUsingAccountAPI,
+        selectedAddress: addressToDetect,
+        supportedNetworks,
+    });
+}, _TokenDetectionController_addChainsToRpcDetection = function _TokenDetectionController_addChainsToRpcDetection(chainsToDetectUsingRpc, chainsToDetectUsingAccountAPI, clientNetworks) {
+    chainsToDetectUsingAccountAPI.forEach((chainId) => {
+        const networkEntry = clientNetworks.find((network) => network.chainId === chainId);
+        if (networkEntry) {
+            chainsToDetectUsingRpc.push({
+                chainId: networkEntry.chainId,
+                networkClientId: networkEntry.networkClientId,
+            });
+        }
+    });
+}, _TokenDetectionController_shouldDetectTokens = function _TokenDetectionController_shouldDetectTokens(chainId) {
+    if (!isTokenDetectionSupportedForNetwork(chainId)) {
+        return false;
+    }
+    if (!__classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f") &&
+        chainId !== ChainId.mainnet) {
+        return false;
+    }
+    const isMainnetDetectionInactive = !__classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f") && chainId === ChainId.mainnet;
+    if (isMainnetDetectionInactive) {
+        __classPrivateFieldSet(this, _TokenDetectionController_tokensChainsCache, __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getConvertedStaticMainnetTokenList).call(this), "f");
+    }
+    else {
+        const { tokensChainsCache } = this.messagingSystem.call('TokenListController:getState');
+        __classPrivateFieldSet(this, _TokenDetectionController_tokensChainsCache, tokensChainsCache ?? {}, "f");
+    }
+    return true;
+}, _TokenDetectionController_detectTokensUsingRpc = async function _TokenDetectionController_detectTokensUsingRpc(chainsToDetectUsingRpc, addressToDetect) {
+    for (const { chainId, networkClientId } of chainsToDetectUsingRpc) {
+        if (!__classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_shouldDetectTokens).call(this, chainId)) {
+            continue;
+        }
+        const tokenCandidateSlices = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getSlicesOfTokensToDetect).call(this, {
+            chainId,
+            selectedAddress: addressToDetect,
+        });
+        const tokenDetectionPromises = tokenCandidateSlices.map((tokensSlice) => __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_addDetectedTokens).call(this, {
+            tokensSlice,
+            selectedAddress: addressToDetect,
+            networkClientId,
+            chainId,
+        }));
+        await Promise.all(tokenDetectionPromises);
+    }
 }, _TokenDetectionController_getSlicesOfTokensToDetect = function _TokenDetectionController_getSlicesOfTokensToDetect({ chainId, selectedAddress, }) {
     const { allTokens, allDetectedTokens, allIgnoredTokens } = this.messagingSystem.call('TokensController:getState');
     const [tokensAddresses, detectedTokensAddresses, ignoredTokensAddresses] = [
@@ -397,68 +436,92 @@ async function _TokenDetectionController_restartTokenDetection({ selectedAddress
  * This adds detected tokens from the Accounts API, avoiding the multi-call RPC calls for balances
  * @param options - method arguments
  * @param options.selectedAddress - address to check against
- * @param options.chainId - chainId to check tokens for
- * @param options.tokenCandidateSlices - these are tokens we know a user does not have (by checking the tokens controller).
- * We will use these these token candidates to determine if a token found from the API is valid to be added on the users wallet.
- * It will also prevent us to adding tokens a user already has
+ * @param options.chainIds - array of chainIds to check tokens for
+ * @param options.supportedNetworks - array of chainIds to check tokens for
  * @returns a success or failed object
  */
-async function _TokenDetectionController_addDetectedTokensViaAPI({ selectedAddress, chainId, tokenCandidateSlices, }) {
+async function _TokenDetectionController_addDetectedTokensViaAPI({ selectedAddress, chainIds, supportedNetworks, }) {
     return await safelyExecute(async () => {
-        const tokenBalances = await __classPrivateFieldGet(this, _TokenDetectionController_accountsAPI, "f")
-            .getMultiChainBalances(selectedAddress, chainId)
+        // Fetch balances for multiple chain IDs at once
+        const tokenBalancesByChain = await __classPrivateFieldGet(this, _TokenDetectionController_accountsAPI, "f")
+            .getMultiNetworksBalances(selectedAddress, chainIds, supportedNetworks)
             .catch(() => null);
-        if (!tokenBalances || tokenBalances.length === 0) {
+        if (!tokenBalancesByChain ||
+            Object.keys(tokenBalancesByChain).length === 0) {
             return { result: 'failed' };
         }
-        const tokensWithBalance = [];
-        const eventTokensDetails = [];
-        const tokenCandidateSet = new Set(tokenCandidateSlices.flat());
-        tokenBalances.forEach((token) => {
-            const tokenAddress = token.address;
-            // Make sure that the token to add is in our candidate list
-            // Ensures we don't add tokens we already own
-            if (!tokenCandidateSet.has(token.address)) {
-                return;
-            }
-            // We need specific data from tokensChainsCache to correctly create a token
-            // So even if we have a token that was detected correctly by the API, if its missing data we cannot safely add it.
-            if (!__classPrivateFieldGet(this, _TokenDetectionController_tokensChainsCache, "f")[chainId].data[token.address]) {
-                return;
-            }
-            const { decimals, symbol, aggregators, iconUrl, name } = __classPrivateFieldGet(this, _TokenDetectionController_tokensChainsCache, "f")[chainId].data[token.address];
-            eventTokensDetails.push(`${symbol} - ${tokenAddress}`);
-            tokensWithBalance.push({
-                address: tokenAddress,
-                decimals,
-                symbol,
-                aggregators,
-                image: iconUrl,
-                isERC721: false,
-                name,
-            });
-        });
-        if (tokensWithBalance.length) {
-            __classPrivateFieldGet(this, _TokenDetectionController_trackMetaMetricsEvent, "f").call(this, {
-                event: 'Token Detected',
-                category: 'Wallet',
-                properties: {
-                    tokens: eventTokensDetails,
-                    // TODO: Either fix this lint violation or explain why it's necessary to ignore.
-                    // eslint-disable-next-line @typescript-eslint/naming-convention
-                    token_standard: ERC20,
-                    // TODO: Either fix this lint violation or explain why it's necessary to ignore.
-                    // eslint-disable-next-line @typescript-eslint/naming-convention
-                    asset_type: ASSET_TYPES.TOKEN,
-                },
-            });
-            await this.messagingSystem.call('TokensController:addDetectedTokens', tokensWithBalance, {
-                selectedAddress,
+        // Process each chain ID individually
+        for (const chainId of chainIds) {
+            const isTokenDetectionInactiveInMainnet = !__classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f") &&
+                chainId === ChainId.mainnet;
+            const { tokensChainsCache } = this.messagingSystem.call('TokenListController:getState');
+            __classPrivateFieldSet(this, _TokenDetectionController_tokensChainsCache, isTokenDetectionInactiveInMainnet
+                ? __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getConvertedStaticMainnetTokenList).call(this)
+                : tokensChainsCache ?? {}, "f");
+            // Generate token candidates based on chainId and selectedAddress
+            const tokenCandidateSlices = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getSlicesOfTokensToDetect).call(this, {
                 chainId,
+                selectedAddress,
             });
+            // Filter balances for the current chainId
+            const tokenBalances = tokenBalancesByChain.filter((balance) => balance.chainId === hexToNumber(chainId));
+            if (!tokenBalances || tokenBalances.length === 0) {
+                continue;
+            }
+            // Use helper function to filter tokens with balance for this chainId
+            const { tokensWithBalance, eventTokensDetails } = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_filterAndBuildTokensWithBalance).call(this, tokenCandidateSlices, tokenBalances, chainId);
+            if (tokensWithBalance.length) {
+                __classPrivateFieldGet(this, _TokenDetectionController_trackMetaMetricsEvent, "f").call(this, {
+                    event: 'Token Detected',
+                    category: 'Wallet',
+                    properties: {
+                        tokens: eventTokensDetails,
+                        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+                        // eslint-disable-next-line @typescript-eslint/naming-convention
+                        token_standard: ERC20,
+                        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+                        // eslint-disable-next-line @typescript-eslint/naming-convention
+                        asset_type: ASSET_TYPES.TOKEN,
+                    },
+                });
+                await this.messagingSystem.call('TokensController:addDetectedTokens', tokensWithBalance, {
+                    selectedAddress,
+                    chainId,
+                });
+            }
         }
         return { result: 'success' };
     });
+}, _TokenDetectionController_filterAndBuildTokensWithBalance = function _TokenDetectionController_filterAndBuildTokensWithBalance(tokenCandidateSlices, tokenBalances, chainId) {
+    const tokensWithBalance = [];
+    const eventTokensDetails = [];
+    const tokenCandidateSet = new Set(tokenCandidateSlices.flat());
+    tokenBalances?.forEach((token) => {
+        const tokenAddress = token.address;
+        // Make sure the token to add is in our candidate list
+        if (!tokenCandidateSet.has(tokenAddress)) {
+            return;
+        }
+        // Retrieve token data from cache to safely add it
+        const tokenData = __classPrivateFieldGet(this, _TokenDetectionController_tokensChainsCache, "f")[chainId]?.data[tokenAddress];
+        // We need specific data from tokensChainsCache to correctly create a token
+        // So even if we have a token that was detected correctly by the API, if its missing data we cannot safely add it.
+        if (!tokenData) {
+            return;
+        }
+        const { decimals, symbol, aggregators, iconUrl, name } = tokenData;
+        eventTokensDetails.push(`${symbol} - ${tokenAddress}`);
+        tokensWithBalance.push({
+            address: tokenAddress,
+            decimals,
+            symbol,
+            aggregators,
+            image: iconUrl,
+            isERC721: false,
+            name,
+        });
+    });
+    return { tokensWithBalance, eventTokensDetails };
 }, _TokenDetectionController_addDetectedTokens = async function _TokenDetectionController_addDetectedTokens({ tokensSlice, selectedAddress, networkClientId, chainId, }) {
     await safelyExecute(async () => {
         const balances = await __classPrivateFieldGet(this, _TokenDetectionController_getBalancesInSingleCall, "f").call(this, selectedAddress, tokensSlice, networkClientId);