@metamask/assets-controllers 105.1.0 → 106.0.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_defaultTokensSeeded, _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_seedDefaultTokens, _TokenDetectionController_addDetectedTokens, _TokenDetectionController_getSelectedAccount, _TokenDetectionController_getSelectedAddress;
+var _TokenDetectionController_instances, _TokenDetectionController_intervalId, _TokenDetectionController_selectedAccountId, _TokenDetectionController_tokenListService, _TokenDetectionController_disabled, _TokenDetectionController_isUnlocked, _TokenDetectionController_isDetectionEnabledFromPreferences, _TokenDetectionController_useTokenDetection, _TokenDetectionController_useExternalServices, _TokenDetectionController_getBalancesInSingleCall, _TokenDetectionController_trackMetaMetricsEvent, _TokenDetectionController_registerEventListeners, _TokenDetectionController_stopPolling, _TokenDetectionController_startPolling, _TokenDetectionController_getCorrectNetworkClientIdByChainId, _TokenDetectionController_restartTokenDetection, _TokenDetectionController_getChainCacheForDetection, _TokenDetectionController_detectTokensUsingRpc, _TokenDetectionController_getSlicesOfTokensToDetect, _TokenDetectionController_getConvertedStaticMainnetTokenList, _TokenDetectionController_buildMusdTokenListToken, _TokenDetectionController_mergeMusdIntoTokenListMap, _TokenDetectionController_applyMusdDefaultToTokensChainsCache, _TokenDetectionController_includeMusdInTokenDetectionSlice, _TokenDetectionController_addDetectedTokens, _TokenDetectionController_getSelectedAccount, _TokenDetectionController_getSelectedAddress;
 function $importDefault(module) {
     if (module?.__esModule) {
         return module.default;
@@ -20,38 +20,9 @@ import $contractMap from "@metamask/contract-metadata";
 const contractMap = $importDefault($contractMap);
 import { ASSET_TYPES, ChainId, ERC20, safelyExecute, isEqualCaseInsensitive, toChecksumHexAddress } from "@metamask/controller-utils";
 import { StaticIntervalPollingController } from "@metamask/polling-controller";
-import $lodash from "lodash";
-const { isEqual, mapValues, isObject, get } = $lodash;
-import { isTokenDetectionSupportedForNetwork } from "./assetsUtil.mjs";
-import { SUPPORTED_NETWORKS_ACCOUNTS_API_V4 } from "./constants.mjs";
+import { formatIconUrlWithProxy, isTokenDetectionSupportedForNetwork } from "./assetsUtil.mjs";
+import { MUSD_ERC20_ADDRESS_LOWER, MUSD_TOKEN_DETECTION_CHAIN_IDS, MUSD_TOKEN_METADATA_BY_CHAIN, SUPPORTED_NETWORKS_ACCOUNTS_API_V4 } from "./constants.mjs";
 const DEFAULT_INTERVAL = 180000;
-/**
- * Canonical contract address for MetaMask USD (mUSD) — same across every
- * chain we deploy it to.
- */
-const MUSD_ADDRESS = '0xaca92e438df0b2401ff60da7e4337b687a2435da';
-/**
- * Pre-built Token entry for mUSD — used when seeding default state.
- */
-const MUSD_TOKEN = {
-    address: MUSD_ADDRESS,
-    decimals: 6,
-    symbol: 'mUSD',
-    name: 'MetaMask USD',
-};
-/**
- * Hex chain IDs on which mUSD is deployed and should be added by default.
- * - 0x1     — Ethereum mainnet (1)
- * - 0xe708  — Linea (59144)
- * - 0x8f    — Monad mainnet (143)
- * - 0x279f  — Monad testnet (10143)
- */
-const MUSD_SUPPORTED_CHAIN_IDS = new Set([
-    '0x1',
-    '0xe708',
-    '0x8f',
-    '0x279f',
-]);
 export const STATIC_MAINNET_TOKEN_LIST = Object.entries(contractMap).reduce((acc, [base, contract]) => {
     const { logo, erc20, erc721, ...tokenMetadata } = contract;
     return {
@@ -64,20 +35,7 @@ export const STATIC_MAINNET_TOKEN_LIST = Object.entries(contractMap).reduce((acc
         },
     };
 }, {});
-/**
- * Function that takes a TokensChainsCache object and maps chainId with TokenListMap.
- *
- * @param tokensChainsCache - TokensChainsCache input object
- * @returns returns the map of chainId with TokenListMap
- */
-export function mapChainIdWithTokenListMap(tokensChainsCache) {
-    return mapValues(tokensChainsCache, (value) => {
-        if (isObject(value) && 'data' in value) {
-            return get(value, ['data']);
-        }
-        return value;
-    });
-}
+const MUSD_TOKEN_DETECTION_CHAIN_ID_SET = new Set(MUSD_TOKEN_DETECTION_CHAIN_IDS);
 export const controllerName = 'TokenDetectionController';
 const MESSENGER_EXPOSED_METHODS = [
     'addDetectedTokensViaWs',
@@ -110,6 +68,7 @@ export class TokenDetectionController extends StaticIntervalPollingController()
      *
      * @param options - The controller options.
      * @param options.messenger - The controller messenger.
+     * @param options.tokenListService - Shared service for fetching the token list per chain.
      * @param options.disabled - If set to true, all network requests are blocked.
      * @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.
@@ -117,7 +76,7 @@ export class TokenDetectionController extends StaticIntervalPollingController()
      * @param options.useTokenDetection - Feature Switch for using token detection (default: true)
      * @param options.useExternalServices - Feature Switch for using external services (default: false)
      */
-    constructor({ interval = DEFAULT_INTERVAL, disabled = true, getBalancesInSingleCall, trackMetaMetricsEvent, messenger, useTokenDetection = () => true, useExternalServices = () => true, }) {
+    constructor({ interval = DEFAULT_INTERVAL, disabled = true, getBalancesInSingleCall, trackMetaMetricsEvent, messenger, tokenListService, useTokenDetection = () => true, useExternalServices = () => true, }) {
         super({
             name: controllerName,
             messenger,
@@ -127,22 +86,19 @@ export class TokenDetectionController extends StaticIntervalPollingController()
         _TokenDetectionController_instances.add(this);
         _TokenDetectionController_intervalId.set(this, void 0);
         _TokenDetectionController_selectedAccountId.set(this, void 0);
-        _TokenDetectionController_tokensChainsCache.set(this, {});
+        _TokenDetectionController_tokenListService.set(this, void 0);
         _TokenDetectionController_disabled.set(this, void 0);
         _TokenDetectionController_isUnlocked.set(this, void 0);
         _TokenDetectionController_isDetectionEnabledFromPreferences.set(this, void 0);
         _TokenDetectionController_useTokenDetection.set(this, void 0);
         _TokenDetectionController_useExternalServices.set(this, void 0);
-        /** Tracks whether default tokens (mUSD) have been seeded for the current session. */
-        _TokenDetectionController_defaultTokensSeeded.set(this, false);
         _TokenDetectionController_getBalancesInSingleCall.set(this, void 0);
         _TokenDetectionController_trackMetaMetricsEvent.set(this, void 0);
         messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
         __classPrivateFieldSet(this, _TokenDetectionController_disabled, disabled, "f");
         this.setIntervalLength(interval);
         __classPrivateFieldSet(this, _TokenDetectionController_selectedAccountId, __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getSelectedAccount).call(this).id, "f");
-        const { tokensChainsCache } = this.messenger.call('TokenListController:getState');
-        __classPrivateFieldSet(this, _TokenDetectionController_tokensChainsCache, tokensChainsCache, "f");
+        __classPrivateFieldSet(this, _TokenDetectionController_tokenListService, tokenListService, "f");
         const { useTokenDetection: defaultUseTokenDetection } = this.messenger.call('PreferencesController:getState');
         __classPrivateFieldSet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, defaultUseTokenDetection, "f");
         __classPrivateFieldSet(this, _TokenDetectionController_getBalancesInSingleCall, getBalancesInSingleCall, "f");
@@ -178,9 +134,6 @@ export class TokenDetectionController extends StaticIntervalPollingController()
      */
     async start() {
         this.enable();
-        // Seed mUSD as a default token via TokensController:addTokens. Runs
-        // once per session; idempotent because addTokens dedupes on address.
-        await __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_seedDefaultTokens).call(this);
         await __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_startPolling).call(this);
     }
     /**
@@ -200,7 +153,7 @@ export class TokenDetectionController extends StaticIntervalPollingController()
         });
     }
     /**
-     * For each token in the token list provided by the TokenListController, checks the token's balance for the selected account address on the active network.
+     * For each token in the token list provided by the TokenListService, checks the token's balance for the selected account address on the active network.
      * 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.
@@ -257,18 +210,28 @@ export class TokenDetectionController extends StaticIntervalPollingController()
         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");
+        let tokenListMap;
+        try {
+            tokenListMap = await __classPrivateFieldGet(this, _TokenDetectionController_tokenListService, "f").fetchTokensByChainId(chainId);
+        }
+        catch {
+            // These methods return void; there is no token array to return.
+            // Gracefully exit so the caller is unaffected — the next polling cycle
+            // will retry the fetch.
+            return;
+        }
+        const chainCache = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_applyMusdDefaultToTokensChainsCache).call(this, chainId, {
+            [chainId]: { data: tokenListMap, timestamp: Date.now() },
+        });
+        const effectiveSlice = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_includeMusdInTokenDetectionSlice).call(this, tokensSlice, chainId);
         const tokensWithBalance = [];
         const eventTokensDetails = [];
-        for (const tokenAddress of tokensSlice) {
+        for (const tokenAddress of effectiveSlice) {
             // Normalize addresses explicitly (don't assume input format)
             const lowercaseTokenAddress = tokenAddress.toLowerCase();
             const checksummedTokenAddress = toChecksumHexAddress(tokenAddress);
             // Check map of validated tokens (cache keys are lowercase)
-            const tokenData = __classPrivateFieldGet(this, _TokenDetectionController_tokensChainsCache, "f")[chainId]?.data?.[lowercaseTokenAddress];
+            const tokenData = chainCache[chainId]?.data?.[lowercaseTokenAddress];
             if (!tokenData) {
                 continue;
             }
@@ -324,18 +287,28 @@ export class TokenDetectionController extends StaticIntervalPollingController()
         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");
+        let tokenListMap;
+        try {
+            tokenListMap = await __classPrivateFieldGet(this, _TokenDetectionController_tokenListService, "f").fetchTokensByChainId(chainId);
+        }
+        catch {
+            // These methods return void; there is no token array to return.
+            // Gracefully exit so the caller is unaffected — the next polling cycle
+            // will retry the fetch.
+            return;
+        }
+        const chainCache = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_applyMusdDefaultToTokensChainsCache).call(this, chainId, {
+            [chainId]: { data: tokenListMap, timestamp: Date.now() },
+        });
         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 effectiveSlice = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_includeMusdInTokenDetectionSlice).call(this, tokensSlice, chainId);
         const tokensWithBalance = [];
         const eventTokensDetails = [];
-        for (const tokenAddress of tokensSlice) {
+        for (const tokenAddress of effectiveSlice) {
             const lowercaseTokenAddress = tokenAddress.toLowerCase();
             const checksummedTokenAddress = toChecksumHexAddress(tokenAddress);
             // Skip tokens already in allTokens
@@ -347,7 +320,7 @@ export class TokenDetectionController extends StaticIntervalPollingController()
                 continue;
             }
             // Check map of validated tokens (cache keys are lowercase)
-            const tokenData = __classPrivateFieldGet(this, _TokenDetectionController_tokensChainsCache, "f")[chainId]?.data?.[lowercaseTokenAddress];
+            const tokenData = chainCache[chainId]?.data?.[lowercaseTokenAddress];
             if (!tokenData) {
                 continue;
             }
@@ -380,7 +353,7 @@ export class TokenDetectionController extends StaticIntervalPollingController()
         }
     }
 }
-_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_defaultTokensSeeded = new WeakMap(), _TokenDetectionController_getBalancesInSingleCall = new WeakMap(), _TokenDetectionController_trackMetaMetricsEvent = new WeakMap(), _TokenDetectionController_instances = new WeakSet(), _TokenDetectionController_registerEventListeners = function _TokenDetectionController_registerEventListeners() {
+_TokenDetectionController_intervalId = new WeakMap(), _TokenDetectionController_selectedAccountId = new WeakMap(), _TokenDetectionController_tokenListService = 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");
         __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this).catch(() => {
@@ -391,14 +364,6 @@ _TokenDetectionController_intervalId = new WeakMap(), _TokenDetectionController_
         __classPrivateFieldSet(this, _TokenDetectionController_isUnlocked, false, "f");
         __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_stopPolling).call(this);
     });
-    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) {
-            __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this).catch(() => {
-                // Silently handle token detection errors
-            });
-        }
-    });
     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;
@@ -417,13 +382,6 @@ _TokenDetectionController_intervalId = new WeakMap(), _TokenDetectionController_
         const isSelectedAccountIdChanged = __classPrivateFieldGet(this, _TokenDetectionController_selectedAccountId, "f") !== selectedAccount.id;
         if (isSelectedAccountIdChanged) {
             __classPrivateFieldSet(this, _TokenDetectionController_selectedAccountId, selectedAccount.id, "f");
-            // Re-seed mUSD for the newly selected account. addTokens only adds
-            // tokens for the currently selected account, so we need to re-run
-            // it whenever the active account changes.
-            __classPrivateFieldSet(this, _TokenDetectionController_defaultTokensSeeded, false, "f");
-            __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_seedDefaultTokens).call(this).catch(() => {
-                // Silently handle default-token seeding errors
-            });
             __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this, {
                 selectedAddress: selectedAccount.address,
                 chainIds,
@@ -439,19 +397,6 @@ _TokenDetectionController_intervalId = new WeakMap(), _TokenDetectionController_
             // Silently handle token detection errors
         });
     });
-    // Re-seed mUSD whenever a network is added. Covers the case where the
-    // user adds a supported chain (e.g. Monad testnet) after the controller
-    // has already started — the chain wasn't configured at start() time so
-    // findNetworkClientIdByChainId would have skipped it.
-    this.messenger.subscribe('NetworkController:networkAdded', ({ chainId }) => {
-        if (!MUSD_SUPPORTED_CHAIN_IDS.has(chainId)) {
-            return;
-        }
-        __classPrivateFieldSet(this, _TokenDetectionController_defaultTokensSeeded, false, "f");
-        __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_seedDefaultTokens).call(this).catch(() => {
-            // Silently handle default-token seeding errors
-        });
-    });
 }, _TokenDetectionController_stopPolling = function _TokenDetectionController_stopPolling() {
     if (__classPrivateFieldGet(this, _TokenDetectionController_intervalId, "f")) {
         clearInterval(__classPrivateFieldGet(this, _TokenDetectionController_intervalId, "f"));
@@ -471,11 +416,6 @@ async function _TokenDetectionController_startPolling() {
     __classPrivateFieldSet(this, _TokenDetectionController_intervalId, setInterval(async () => {
         await this.detectTokens();
     }, this.getIntervalLength()), "f");
-}, _TokenDetectionController_compareTokensChainsCache = function _TokenDetectionController_compareTokensChainsCache(tokensChainsCache, previousTokensChainsCache) {
-    const cleanPreviousTokensChainsCache = mapChainIdWithTokenListMap(previousTokensChainsCache);
-    const cleanTokensChainsCache = mapChainIdWithTokenListMap(tokensChainsCache);
-    const isEqualValues = isEqual(cleanTokensChainsCache, cleanPreviousTokensChainsCache);
-    return isEqualValues;
 }, _TokenDetectionController_getCorrectNetworkClientIdByChainId = function _TokenDetectionController_getCorrectNetworkClientIdByChainId(chainIds) {
     const { networkConfigurationsByChainId, selectedNetworkClientId } = this.messenger.call('NetworkController:getState');
     if (!chainIds) {
@@ -510,30 +450,41 @@ async function _TokenDetectionController_restartTokenDetection({ selectedAddress
         selectedAddress,
     });
     this.setIntervalLength(DEFAULT_INTERVAL);
-}, _TokenDetectionController_shouldDetectTokens = function _TokenDetectionController_shouldDetectTokens(chainId) {
+}, _TokenDetectionController_getChainCacheForDetection = 
+/**
+ * Returns the token cache for `chainId` if detection should proceed, or `null` if it
+ * should be skipped.  Each call fetches a fresh snapshot from `TokenListService` (which
+ * may serve from its in-memory cache) so concurrent calls for different chains never
+ * overwrite each other's data.
+ *
+ * @param chainId - The chain ID to build a detection cache for.
+ * @returns A `TokensChainsCache` scoped to `chainId`, or `null` when detection should be skipped.
+ */
+async function _TokenDetectionController_getChainCacheForDetection(chainId) {
     if (!isTokenDetectionSupportedForNetwork(chainId)) {
-        return false;
+        return null;
     }
     if (!__classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f") &&
         chainId !== ChainId.mainnet) {
-        return false;
+        return null;
     }
     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.messenger.call('TokenListController:getState');
-        __classPrivateFieldSet(this, _TokenDetectionController_tokensChainsCache, tokensChainsCache ?? {}, "f");
+        return __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getConvertedStaticMainnetTokenList).call(this);
     }
-    return true;
+    const tokenListMap = await __classPrivateFieldGet(this, _TokenDetectionController_tokenListService, "f").fetchTokensByChainId(chainId);
+    return __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_applyMusdDefaultToTokensChainsCache).call(this, chainId, {
+        [chainId]: { data: tokenListMap, timestamp: Date.now() },
+    });
 }, _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)) {
+        const chainCache = await __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getChainCacheForDetection).call(this, chainId);
+        if (!chainCache) {
             continue;
         }
         const tokenCandidateSlices = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getSlicesOfTokensToDetect).call(this, {
             chainId,
+            chainCache,
             selectedAddress: addressToDetect,
         });
         const tokenDetectionPromises = tokenCandidateSlices.map((tokensSlice) => __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_addDetectedTokens).call(this, {
@@ -541,10 +492,11 @@ async function _TokenDetectionController_restartTokenDetection({ selectedAddress
             selectedAddress: addressToDetect,
             networkClientId,
             chainId,
+            chainCache,
         }));
         await Promise.all(tokenDetectionPromises);
     }
-}, _TokenDetectionController_getSlicesOfTokensToDetect = function _TokenDetectionController_getSlicesOfTokensToDetect({ chainId, selectedAddress, }) {
+}, _TokenDetectionController_getSlicesOfTokensToDetect = function _TokenDetectionController_getSlicesOfTokensToDetect({ chainId, chainCache, selectedAddress, }) {
     const { allTokens, allDetectedTokens, allIgnoredTokens } = this.messenger.call('TokensController:getState');
     const [tokensAddresses, detectedTokensAddresses, ignoredTokensAddresses] = [
         allTokens,
@@ -552,7 +504,7 @@ async function _TokenDetectionController_restartTokenDetection({ selectedAddress
         allIgnoredTokens,
     ].map((tokens) => (tokens[chainId]?.[selectedAddress] ?? []).map((value) => typeof value === 'string' ? value : value.address));
     const tokensToDetect = [];
-    for (const tokenAddress of Object.keys(__classPrivateFieldGet(this, _TokenDetectionController_tokensChainsCache, "f")?.[chainId]?.data || {})) {
+    for (const tokenAddress of Object.keys(chainCache[chainId]?.data ?? {})) {
         if ([
             tokensAddresses,
             detectedTokensAddresses,
@@ -578,50 +530,66 @@ async function _TokenDetectionController_restartTokenDetection({ selectedAddress
             iconUrl: value?.iconUrl,
         },
     }), {});
+    const dataWithMusd = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_mergeMusdIntoTokenListMap).call(this, ChainId.mainnet, data);
     return {
         '0x1': {
-            data,
+            data: dataWithMusd,
             timestamp: 0,
         },
     };
-}, _TokenDetectionController_seedDefaultTokens = 
-/**
- * Seed mUSD into `TokensController.allTokens` via the public `addTokens`
- * action for every supported chain that is currently configured in
- * `NetworkController`.
- *
- * Runs once per session (idempotent guard via `#defaultTokensSeeded`), but
- * `addTokens` itself dedupes by contract address so re-running is safe.
- *
- * @returns Promise that resolves once seeding has been attempted on every
- * supported chain.
- */
-async function _TokenDetectionController_seedDefaultTokens() {
-    if (__classPrivateFieldGet(this, _TokenDetectionController_defaultTokensSeeded, "f")) {
-        return;
+}, _TokenDetectionController_buildMusdTokenListToken = function _TokenDetectionController_buildMusdTokenListToken(chainId) {
+    const meta = MUSD_TOKEN_METADATA_BY_CHAIN[chainId];
+    return {
+        address: MUSD_ERC20_ADDRESS_LOWER,
+        name: meta.name,
+        symbol: meta.symbol,
+        decimals: meta.decimals,
+        aggregators: [...meta.aggregators],
+        iconUrl: formatIconUrlWithProxy({
+            chainId,
+            tokenAddress: MUSD_ERC20_ADDRESS_LOWER,
+        }),
+        occurrences: 999,
+    };
+}, _TokenDetectionController_mergeMusdIntoTokenListMap = function _TokenDetectionController_mergeMusdIntoTokenListMap(chainId, data) {
+    return {
+        ...data,
+        [MUSD_ERC20_ADDRESS_LOWER]: __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_buildMusdTokenListToken).call(this, chainId),
+    };
+}, _TokenDetectionController_applyMusdDefaultToTokensChainsCache = function _TokenDetectionController_applyMusdDefaultToTokensChainsCache(chainId, cache) {
+    if (!MUSD_TOKEN_DETECTION_CHAIN_ID_SET.has(chainId)) {
+        return cache;
     }
-    __classPrivateFieldSet(this, _TokenDetectionController_defaultTokensSeeded, true, "f");
-    const { networkConfigurationsByChainId } = this.messenger.call('NetworkController:getState');
-    for (const supportedChainId of MUSD_SUPPORTED_CHAIN_IDS) {
-        if (!networkConfigurationsByChainId[supportedChainId]) {
-            continue;
-        }
-        try {
-            const networkClientId = this.messenger.call('NetworkController:findNetworkClientIdByChainId', supportedChainId);
-            await this.messenger.call('TokensController:addTokens', [MUSD_TOKEN], networkClientId);
-        }
-        catch {
-            // Silently handle per-chain seeding errors so one failure does not
-            // block seeding on the remaining supported chains.
-        }
+    const existing = cache[chainId];
+    return {
+        ...cache,
+        [chainId]: {
+            data: __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_mergeMusdIntoTokenListMap).call(this, chainId, existing?.data ?? {}),
+            timestamp: existing?.timestamp ?? 0,
+        },
+    };
+}, _TokenDetectionController_includeMusdInTokenDetectionSlice = function _TokenDetectionController_includeMusdInTokenDetectionSlice(tokensSlice, chainId) {
+    if (!MUSD_TOKEN_DETECTION_CHAIN_ID_SET.has(chainId)) {
+        return tokensSlice;
     }
-}, _TokenDetectionController_addDetectedTokens = async function _TokenDetectionController_addDetectedTokens({ tokensSlice, selectedAddress, networkClientId, chainId, }) {
+    if (tokensSlice.some((a) => isEqualCaseInsensitive(a, MUSD_ERC20_ADDRESS_LOWER))) {
+        return tokensSlice;
+    }
+    return [...tokensSlice, MUSD_ERC20_ADDRESS_LOWER];
+}, _TokenDetectionController_addDetectedTokens = async function _TokenDetectionController_addDetectedTokens({ tokensSlice, selectedAddress, networkClientId, chainId, chainCache, }) {
     await safelyExecute(async () => {
         const balances = await __classPrivateFieldGet(this, _TokenDetectionController_getBalancesInSingleCall, "f").call(this, selectedAddress, tokensSlice, networkClientId);
+        const chainData = chainCache[chainId]?.data ?? {};
         const tokensWithBalance = [];
         const eventTokensDetails = [];
         for (const nonZeroTokenAddress of Object.keys(balances)) {
-            const { decimals, symbol, aggregators, iconUrl, name, rwaData } = __classPrivateFieldGet(this, _TokenDetectionController_tokensChainsCache, "f")[chainId].data[nonZeroTokenAddress];
+            // chainData keys are lowercase (normalised by buildTokenListMap);
+            // balance keys are checksummed, so normalise before lookup.
+            const tokenListEntry = chainData[nonZeroTokenAddress.toLowerCase()];
+            if (!tokenListEntry) {
+                continue;
+            }
+            const { decimals, symbol, aggregators, iconUrl, name, rwaData } = tokenListEntry;
             eventTokensDetails.push(`${symbol} - ${nonZeroTokenAddress}`);
             tokensWithBalance.push({
                 address: nonZeroTokenAddress,
@@ -634,6 +602,30 @@ async function _TokenDetectionController_seedDefaultTokens() {
                 ...(rwaData && { rwaData }),
             });
         }
+        // mUSD is always in the chain token cache on supported networks, but
+        // getBalancesInSingleCall omits zero balances; still add mUSD so the wallet
+        // shows the asset (balance updates via the usual balance pipeline).
+        if (MUSD_TOKEN_DETECTION_CHAIN_ID_SET.has(chainId)) {
+            const musdInSlice = tokensSlice.some((addr) => isEqualCaseInsensitive(addr, MUSD_ERC20_ADDRESS_LOWER));
+            const musdHasNonZeroFromRpc = Object.keys(balances).some((addr) => isEqualCaseInsensitive(addr, MUSD_ERC20_ADDRESS_LOWER));
+            if (musdInSlice && !musdHasNonZeroFromRpc) {
+                const musdListToken = Object.entries(chainData).find(([key]) => isEqualCaseInsensitive(key, MUSD_ERC20_ADDRESS_LOWER))?.[1];
+                if (musdListToken) {
+                    const { decimals, symbol, aggregators, iconUrl, name, rwaData } = musdListToken;
+                    eventTokensDetails.push(`${symbol} - ${MUSD_ERC20_ADDRESS_LOWER}`);
+                    tokensWithBalance.push({
+                        address: MUSD_ERC20_ADDRESS_LOWER,
+                        decimals,
+                        symbol,
+                        aggregators,
+                        image: iconUrl,
+                        isERC721: false,
+                        name,
+                        ...(rwaData && { rwaData }),
+                    });
+                }
+            }
+        }
         if (tokensWithBalance.length) {
             __classPrivateFieldGet(this, _TokenDetectionController_trackMetaMetricsEvent, "f").call(this, {
                 event: 'Token Detected',