@metamask/assets-controllers 94.0.0 → 94.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_tokensChainsCache, _TokenDetectionController_disabled, _TokenDetectionController_isUnlocked, _TokenDetectionController_isDetectionEnabledFromPreferences, _TokenDetectionController_useTokenDetection, _TokenDetectionController_useExternalServices, _TokenDetectionController_getBalancesInSingleCall, _TokenDetectionController_trackMetaMetricsEvent, _TokenDetectionController_accountsAPI, _TokenDetectionController_registerEventListeners, _TokenDetectionController_stopPolling, _TokenDetectionController_startPolling, _TokenDetectionController_compareTokensChainsCache, _TokenDetectionController_getCorrectNetworkClientIdByChainId, _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;
+var _TokenDetectionController_instances, _TokenDetectionController_intervalId, _TokenDetectionController_selectedAccountId, _TokenDetectionController_tokensChainsCache, _TokenDetectionController_disabled, _TokenDetectionController_isUnlocked, _TokenDetectionController_isDetectionEnabledFromPreferences, _TokenDetectionController_useTokenDetection, _TokenDetectionController_useExternalServices, _TokenDetectionController_getBalancesInSingleCall, _TokenDetectionController_trackMetaMetricsEvent, _TokenDetectionController_registerEventListeners, _TokenDetectionController_stopPolling, _TokenDetectionController_startPolling, _TokenDetectionController_compareTokensChainsCache, _TokenDetectionController_getCorrectNetworkClientIdByChainId, _TokenDetectionController_restartTokenDetection, _TokenDetectionController_shouldDetectTokens, _TokenDetectionController_detectTokensUsingRpc, _TokenDetectionController_getSlicesOfTokensToDetect, _TokenDetectionController_getConvertedStaticMainnetTokenList, _TokenDetectionController_addDetectedTokens, _TokenDetectionController_getSelectedAccount, _TokenDetectionController_getSelectedAddress;
 function $importDefault(module) {
     if (module?.__esModule) {
         return module.default;
@@ -18,15 +18,13 @@ function $importDefault(module) {
 }
 import $contractMap from "@metamask/contract-metadata";
 const contractMap = $importDefault($contractMap);
-import { ASSET_TYPES, ChainId, ERC20, safelyExecute, safelyExecuteWithTimeout, isEqualCaseInsensitive, toChecksumHexAddress, toHex } from "@metamask/controller-utils";
+import { ASSET_TYPES, ChainId, ERC20, safelyExecute, isEqualCaseInsensitive, toChecksumHexAddress } from "@metamask/controller-utils";
 import { StaticIntervalPollingController } from "@metamask/polling-controller";
-import { hexToNumber } from "@metamask/utils";
 import $lodash from "lodash";
 const { isEqual, mapValues, isObject, get } = $lodash;
 import { isTokenDetectionSupportedForNetwork } from "./assetsUtil.mjs";
-import { fetchMultiChainBalances, fetchSupportedNetworks } from "./multi-chain-accounts-service/index.mjs";
+import { SUPPORTED_NETWORKS_ACCOUNTS_API_V4 } from "./constants.mjs";
 const DEFAULT_INTERVAL = 180000;
-const ACCOUNTS_API_TIMEOUT_MS = 10000;
 export const STATIC_MAINNET_TOKEN_LIST = Object.entries(contractMap).reduce((acc, [base, contract]) => {
     const { logo, erc20, erc721, ...tokenMetadata } = contract;
     return {
@@ -80,12 +78,10 @@ export class TokenDetectionController extends StaticIntervalPollingController()
      * @param options.interval - Polling interval used to fetch new token rates
      * @param options.getBalancesInSingleCall - Gets the balances of a list of tokens for the given address.
      * @param options.trackMetaMetricsEvent - Sets options for MetaMetrics event tracking.
-     * @param options.useAccountsAPI - Feature Switch for using the accounts API when detecting tokens (default: true)
      * @param options.useTokenDetection - Feature Switch for using token detection (default: true)
      * @param options.useExternalServices - Feature Switch for using external services (default: false)
-     * @param options.platform - Indicates whether the platform is extension or mobile
      */
-    constructor({ interval = DEFAULT_INTERVAL, disabled = true, getBalancesInSingleCall, trackMetaMetricsEvent, messenger, useAccountsAPI = true, useTokenDetection = () => true, useExternalServices = () => true, platform, }) {
+    constructor({ interval = DEFAULT_INTERVAL, disabled = true, getBalancesInSingleCall, trackMetaMetricsEvent, messenger, useTokenDetection = () => true, useExternalServices = () => true, }) {
         super({
             name: controllerName,
             messenger,
@@ -103,38 +99,9 @@ export class TokenDetectionController extends StaticIntervalPollingController()
         _TokenDetectionController_useExternalServices.set(this, void 0);
         _TokenDetectionController_getBalancesInSingleCall.set(this, void 0);
         _TokenDetectionController_trackMetaMetricsEvent.set(this, void 0);
-        _TokenDetectionController_accountsAPI.set(this, {
-            isAccountsAPIEnabled: true,
-            supportedNetworksCache: null,
-            platform: '',
-            async getSupportedNetworks() {
-                /* istanbul ignore next */
-                if (!this.isAccountsAPIEnabled) {
-                    throw new Error('Accounts API Feature Switch is disabled');
-                }
-                /* istanbul ignore next */
-                if (this.supportedNetworksCache) {
-                    return this.supportedNetworksCache;
-                }
-                const result = await fetchSupportedNetworks().catch(() => null);
-                this.supportedNetworksCache = result;
-                return result;
-            },
-            async getMultiNetworksBalances(address, chainIds, supportedNetworks, jwtToken) {
-                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}, requested networks: ${chainIdNumbers.toString()}`);
-                }
-                const result = await fetchMultiChainBalances(address, {
-                    networks: chainIdNumbers,
-                }, this.platform, jwtToken);
-                // Return the full response including unprocessedNetworks
-                return result;
-            },
-        });
         this.messenger.registerActionHandler(`${controllerName}:addDetectedTokensViaWs`, this.addDetectedTokensViaWs.bind(this));
+        this.messenger.registerActionHandler(`${controllerName}:addDetectedTokensViaPolling`, this.addDetectedTokensViaPolling.bind(this));
+        this.messenger.registerActionHandler(`${controllerName}:detectTokens`, this.detectTokens.bind(this));
         __classPrivateFieldSet(this, _TokenDetectionController_disabled, disabled, "f");
         this.setIntervalLength(interval);
         __classPrivateFieldSet(this, _TokenDetectionController_selectedAccountId, __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getSelectedAccount).call(this).id, "f");
@@ -146,10 +113,8 @@ export class TokenDetectionController extends StaticIntervalPollingController()
         __classPrivateFieldSet(this, _TokenDetectionController_trackMetaMetricsEvent, trackMetaMetricsEvent, "f");
         const { isUnlocked } = this.messenger.call('KeyringController:getState');
         __classPrivateFieldSet(this, _TokenDetectionController_isUnlocked, isUnlocked, "f");
-        __classPrivateFieldGet(this, _TokenDetectionController_accountsAPI, "f").isAccountsAPIEnabled = useAccountsAPI;
         __classPrivateFieldSet(this, _TokenDetectionController_useTokenDetection, useTokenDetection, "f");
         __classPrivateFieldSet(this, _TokenDetectionController_useExternalServices, useExternalServices, "f");
-        __classPrivateFieldGet(this, _TokenDetectionController_accountsAPI, "f").platform = platform;
         __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_registerEventListeners).call(this);
     }
     /**
@@ -202,48 +167,40 @@ export class TokenDetectionController extends StaticIntervalPollingController()
      * @param options - Options for token detection.
      * @param options.chainIds - The chain IDs of the network client to use.
      * @param options.selectedAddress - the selectedAddress against which to detect for token balances.
+     * @param options.forceRpc - Force RPC-based token detection for all specified chains,
+     * bypassing external services check and ensuring RPC is used even for chains
+     * that might otherwise be handled by the Accounts API.
      */
-    async detectTokens({ chainIds, selectedAddress, } = {}) {
+    async detectTokens({ chainIds, selectedAddress, forceRpc = false, } = {}) {
         if (!this.isActive) {
             return;
         }
-        if (!__classPrivateFieldGet(this, _TokenDetectionController_useTokenDetection, "f").call(this)) {
+        // When forceRpc is true, bypass the useTokenDetection check to ensure RPC detection runs
+        if (!forceRpc && !__classPrivateFieldGet(this, _TokenDetectionController_useTokenDetection, "f").call(this)) {
+            return;
+        }
+        // If external services are disabled and not forcing RPC, skip all detection
+        if (!forceRpc && !__classPrivateFieldGet(this, _TokenDetectionController_useExternalServices, "f").call(this)) {
             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);
-        const jwtToken = await safelyExecuteWithTimeout(() => {
-            return this.messenger.call('AuthenticationController:getBearerToken');
-        }, false, 5000);
-        let supportedNetworks;
-        if (__classPrivateFieldGet(this, _TokenDetectionController_accountsAPI, "f").isAccountsAPIEnabled && __classPrivateFieldGet(this, _TokenDetectionController_useExternalServices, "f").call(this)) {
-            supportedNetworks = await __classPrivateFieldGet(this, _TokenDetectionController_accountsAPI, "f").getSupportedNetworks();
-        }
-        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, jwtToken);
-            // If the account API call failed or returned undefined, have those chains fall back to RPC detection
-            if (!apiResult || apiResult.result === 'failed') {
-                __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_addChainsToRpcDetection).call(this, chainsToDetectUsingRpc, chainsToDetectUsingAccountAPI, clientNetworks);
-            }
-            else if (apiResult?.result === 'success' &&
-                apiResult.unprocessedNetworks &&
-                apiResult.unprocessedNetworks.length > 0) {
-                // Handle unprocessed networks by adding them to RPC detection
-                const unprocessedChainIds = apiResult.unprocessedNetworks.map((chainId) => toHex(chainId));
-                __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_addChainsToRpcDetection).call(this, chainsToDetectUsingRpc, unprocessedChainIds, clientNetworks);
-            }
-        }
-        // 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);
+        // If forceRpc is true, use RPC for all chains
+        // Otherwise, skip chains supported by Accounts API (they are handled by TokenBalancesController)
+        const chainsToDetectUsingRpc = forceRpc
+            ? clientNetworks
+            : clientNetworks.filter(({ chainId }) => !SUPPORTED_NETWORKS_ACCOUNTS_API_V4.includes(chainId));
+        if (chainsToDetectUsingRpc.length === 0) {
+            return;
         }
+        await __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_detectTokensUsingRpc).call(this, chainsToDetectUsingRpc, addressToDetect);
     }
     /**
      * Add tokens detected from websocket balance updates
-     * This method assumes:
-     * - Tokens are already in the tokensChainsCache with full metadata
+     * This method:
+     * - Checks if useTokenDetection preference is enabled (skips if disabled)
+     * - Checks if external services are enabled (skips if disabled)
+     * - Tokens are expected to be in the tokensChainsCache with full metadata
      * - Balance fetching is skipped since balances are provided by the websocket
      * - Ignored tokens have been filtered out by the caller
      *
@@ -253,6 +210,18 @@ export class TokenDetectionController extends StaticIntervalPollingController()
      * @returns Promise that resolves when tokens are added
      */
     async addDetectedTokensViaWs({ tokensSlice, chainId, }) {
+        // Check if token detection is enabled via preferences
+        if (!__classPrivateFieldGet(this, _TokenDetectionController_useTokenDetection, "f").call(this)) {
+            return;
+        }
+        // Check if external services are enabled (websocket requires external services)
+        if (!__classPrivateFieldGet(this, _TokenDetectionController_useExternalServices, "f").call(this)) {
+            return;
+        }
+        // Refresh the token cache to ensure we have the latest token metadata
+        // This fixes a bug where the cache from construction time could be stale/empty
+        const { tokensChainsCache } = this.messenger.call('TokenListController:getState');
+        __classPrivateFieldSet(this, _TokenDetectionController_tokensChainsCache, tokensChainsCache ?? {}, "f");
         const tokensWithBalance = [];
         const eventTokensDetails = [];
         for (const tokenAddress of tokensSlice) {
@@ -293,47 +262,135 @@ export class TokenDetectionController extends StaticIntervalPollingController()
             await this.messenger.call('TokensController:addTokens', tokensWithBalance, networkClientId);
         }
     }
+    /**
+     * Add tokens detected from polling balance updates
+     * This method:
+     * - Checks if useTokenDetection preference is enabled (skips if disabled)
+     * - Checks if external services are enabled (skips if disabled)
+     * - Filters out tokens already in allTokens or allIgnoredTokens
+     * - Tokens are expected to be in the tokensChainsCache with full metadata
+     * - Balance fetching is skipped since balances are provided by the caller
+     *
+     * @param options - The options object
+     * @param options.tokensSlice - Array of token addresses detected from polling
+     * @param options.chainId - Hex chain ID
+     * @returns Promise that resolves when tokens are added
+     */
+    async addDetectedTokensViaPolling({ tokensSlice, chainId, }) {
+        // Check if token detection is enabled via preferences
+        if (!__classPrivateFieldGet(this, _TokenDetectionController_useTokenDetection, "f").call(this)) {
+            return;
+        }
+        // Check if external services are enabled (polling via API requires external services)
+        if (!__classPrivateFieldGet(this, _TokenDetectionController_useExternalServices, "f").call(this)) {
+            return;
+        }
+        // Refresh the token cache to ensure we have the latest token metadata
+        // This fixes a bug where the cache from construction time could be stale/empty
+        const { tokensChainsCache } = this.messenger.call('TokenListController:getState');
+        __classPrivateFieldSet(this, _TokenDetectionController_tokensChainsCache, tokensChainsCache ?? {}, "f");
+        const selectedAddress = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getSelectedAddress).call(this);
+        // Get current token states to filter out already tracked/ignored tokens
+        const { allTokens, allIgnoredTokens } = this.messenger.call('TokensController:getState');
+        const existingTokenAddresses = (allTokens[chainId]?.[selectedAddress] ?? []).map((token) => token.address.toLowerCase());
+        const ignoredTokenAddresses = (allIgnoredTokens[chainId]?.[selectedAddress] ?? []).map((address) => address.toLowerCase());
+        const tokensWithBalance = [];
+        const eventTokensDetails = [];
+        for (const tokenAddress of tokensSlice) {
+            const lowercaseTokenAddress = tokenAddress.toLowerCase();
+            const checksummedTokenAddress = toChecksumHexAddress(tokenAddress);
+            // Skip tokens already in allTokens
+            if (existingTokenAddresses.includes(lowercaseTokenAddress)) {
+                continue;
+            }
+            // Skip tokens in allIgnoredTokens
+            if (ignoredTokenAddresses.includes(lowercaseTokenAddress)) {
+                continue;
+            }
+            // Check map of validated tokens (cache keys are lowercase)
+            const tokenData = __classPrivateFieldGet(this, _TokenDetectionController_tokensChainsCache, "f")[chainId]?.data?.[lowercaseTokenAddress];
+            if (!tokenData) {
+                console.warn(`Token metadata not found in cache for ${tokenAddress} on chain ${chainId}`);
+                continue;
+            }
+            const { decimals, symbol, aggregators, iconUrl, name } = tokenData;
+            eventTokensDetails.push(`${symbol} - ${checksummedTokenAddress}`);
+            tokensWithBalance.push({
+                address: checksummedTokenAddress,
+                decimals,
+                symbol,
+                aggregators,
+                image: iconUrl,
+                isERC721: false,
+                name,
+            });
+        }
+        // Perform addition
+        if (tokensWithBalance.length) {
+            __classPrivateFieldGet(this, _TokenDetectionController_trackMetaMetricsEvent, "f").call(this, {
+                event: 'Token Detected',
+                category: 'Wallet',
+                properties: {
+                    tokens: eventTokensDetails,
+                    token_standard: ERC20,
+                    asset_type: ASSET_TYPES.TOKEN,
+                },
+            });
+            const networkClientId = this.messenger.call('NetworkController:findNetworkClientIdByChainId', chainId);
+            await this.messenger.call('TokensController:addTokens', tokensWithBalance, networkClientId);
+        }
+    }
 }
-_TokenDetectionController_intervalId = new WeakMap(), _TokenDetectionController_selectedAccountId = new WeakMap(), _TokenDetectionController_tokensChainsCache = new WeakMap(), _TokenDetectionController_disabled = new WeakMap(), _TokenDetectionController_isUnlocked = new WeakMap(), _TokenDetectionController_isDetectionEnabledFromPreferences = new WeakMap(), _TokenDetectionController_useTokenDetection = new WeakMap(), _TokenDetectionController_useExternalServices = new WeakMap(), _TokenDetectionController_getBalancesInSingleCall = new WeakMap(), _TokenDetectionController_trackMetaMetricsEvent = new WeakMap(), _TokenDetectionController_accountsAPI = new WeakMap(), _TokenDetectionController_instances = new WeakSet(), _TokenDetectionController_registerEventListeners = function _TokenDetectionController_registerEventListeners() {
-    this.messenger.subscribe('KeyringController:unlock', async () => {
+_TokenDetectionController_intervalId = new WeakMap(), _TokenDetectionController_selectedAccountId = new WeakMap(), _TokenDetectionController_tokensChainsCache = new WeakMap(), _TokenDetectionController_disabled = new WeakMap(), _TokenDetectionController_isUnlocked = new WeakMap(), _TokenDetectionController_isDetectionEnabledFromPreferences = new WeakMap(), _TokenDetectionController_useTokenDetection = new WeakMap(), _TokenDetectionController_useExternalServices = new WeakMap(), _TokenDetectionController_getBalancesInSingleCall = new WeakMap(), _TokenDetectionController_trackMetaMetricsEvent = new WeakMap(), _TokenDetectionController_instances = new WeakSet(), _TokenDetectionController_registerEventListeners = function _TokenDetectionController_registerEventListeners() {
+    this.messenger.subscribe('KeyringController:unlock', () => {
         __classPrivateFieldSet(this, _TokenDetectionController_isUnlocked, true, "f");
-        await __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this);
+        __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this).catch(() => {
+            // Silently handle token detection errors
+        });
     });
     this.messenger.subscribe('KeyringController:lock', () => {
         __classPrivateFieldSet(this, _TokenDetectionController_isUnlocked, false, "f");
         __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_stopPolling).call(this);
     });
-    this.messenger.subscribe('TokenListController:stateChange', async ({ tokensChainsCache }) => {
+    this.messenger.subscribe('TokenListController:stateChange', ({ tokensChainsCache }) => {
         const isEqualValues = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_compareTokensChainsCache).call(this, tokensChainsCache, __classPrivateFieldGet(this, _TokenDetectionController_tokensChainsCache, "f"));
         if (!isEqualValues) {
-            await __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this);
+            __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this).catch(() => {
+                // Silently handle token detection errors
+            });
         }
     });
-    this.messenger.subscribe('PreferencesController:stateChange', async ({ useTokenDetection }) => {
+    this.messenger.subscribe('PreferencesController:stateChange', ({ useTokenDetection }) => {
         const selectedAccount = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getSelectedAccount).call(this);
         const isDetectionChangedFromPreferences = __classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f") !== useTokenDetection;
         __classPrivateFieldSet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, useTokenDetection, "f");
         if (isDetectionChangedFromPreferences) {
-            await __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this, {
+            __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this, {
                 selectedAddress: selectedAccount.address,
+            }).catch(() => {
+                // Silently handle token detection errors
             });
         }
     });
-    this.messenger.subscribe('AccountsController:selectedEvmAccountChange', async (selectedAccount) => {
+    this.messenger.subscribe('AccountsController:selectedEvmAccountChange', (selectedAccount) => {
         const { networkConfigurationsByChainId } = this.messenger.call('NetworkController:getState');
         const chainIds = Object.keys(networkConfigurationsByChainId);
         const isSelectedAccountIdChanged = __classPrivateFieldGet(this, _TokenDetectionController_selectedAccountId, "f") !== selectedAccount.id;
         if (isSelectedAccountIdChanged) {
             __classPrivateFieldSet(this, _TokenDetectionController_selectedAccountId, selectedAccount.id, "f");
-            await __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this, {
+            __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this, {
                 selectedAddress: selectedAccount.address,
                 chainIds,
+            }).catch(() => {
+                // Silently handle token detection errors
             });
         }
     });
-    this.messenger.subscribe('TransactionController:transactionConfirmed', async (transactionMeta) => {
-        await this.detectTokens({
+    this.messenger.subscribe('TransactionController:transactionConfirmed', (transactionMeta) => {
+        this.detectTokens({
             chainIds: [transactionMeta.chainId],
+        }).catch(() => {
+            // Silently handle token detection errors
         });
     });
 }, _TokenDetectionController_stopPolling = function _TokenDetectionController_stopPolling() {
@@ -394,41 +451,6 @@ async function _TokenDetectionController_restartTokenDetection({ selectedAddress
         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, jwtToken) {
-    const result = await safelyExecuteWithTimeout(async () => {
-        return __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_addDetectedTokensViaAPI).call(this, {
-            chainIds: chainsToDetectUsingAccountAPI,
-            selectedAddress: addressToDetect,
-            supportedNetworks,
-            jwtToken,
-        });
-    }, false, ACCOUNTS_API_TIMEOUT_MS);
-    if (!result) {
-        return { result: 'failed' };
-    }
-    return result;
-}, _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;
@@ -503,96 +525,6 @@ async function _TokenDetectionController_restartTokenDetection({ selectedAddress
             timestamp: 0,
         },
     };
-}, _TokenDetectionController_addDetectedTokensViaAPI = 
-/**
- * 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.chainIds - array of chainIds to check tokens for
- * @param options.supportedNetworks - array of chainIds to check tokens for
- * @param options.jwtToken - JWT token for authentication
- * @returns a success or failed object
- */
-async function _TokenDetectionController_addDetectedTokensViaAPI({ selectedAddress, chainIds, supportedNetworks, jwtToken, }) {
-    return await safelyExecute(async () => {
-        // Fetch balances for multiple chain IDs at once
-        const apiResponse = await __classPrivateFieldGet(this, _TokenDetectionController_accountsAPI, "f")
-            .getMultiNetworksBalances(selectedAddress, chainIds, supportedNetworks, jwtToken)
-            .catch(() => null);
-        if (apiResponse === null) {
-            return { result: 'failed' };
-        }
-        const tokenBalancesByChain = apiResponse.balances;
-        // Process each chain ID individually
-        for (const chainId of chainIds) {
-            const isTokenDetectionInactiveInMainnet = !__classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f") &&
-                chainId === ChainId.mainnet;
-            const { tokensChainsCache } = this.messenger.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,
-                        token_standard: ERC20,
-                        asset_type: ASSET_TYPES.TOKEN,
-                    },
-                });
-                const networkClientId = this.messenger.call('NetworkController:findNetworkClientIdByChainId', chainId);
-                await this.messenger.call('TokensController:addTokens', tokensWithBalance, networkClientId);
-            }
-        }
-        return {
-            result: 'success',
-            unprocessedNetworks: apiResponse.unprocessedNetworks,
-        };
-    });
-}, _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);
@@ -629,7 +561,7 @@ async function _TokenDetectionController_addDetectedTokensViaAPI({ selectedAddre
 }, _TokenDetectionController_getSelectedAddress = function _TokenDetectionController_getSelectedAddress() {
     // If the address is not defined (or empty), we fallback to the currently selected account's address
     const account = this.messenger.call('AccountsController:getAccount', __classPrivateFieldGet(this, _TokenDetectionController_selectedAccountId, "f"));
-    return account?.address || '';
+    return account?.address ?? '';
 };
 export default TokenDetectionController;
 //# sourceMappingURL=TokenDetectionController.mjs.map