@metamask-previews/assets-controllers 105.1.0-preview-938a7fe → 106.0.0-preview-d3f1b8bd9

package/CHANGELOG.md

@@ -7,8 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- Bump `@metamask/account-tree-controller` from `^7.2.0` to `^7.3.0` ([#8722](https://github.com/MetaMask/core/pull/8722))
+- Bump `@metamask/keyring-controller` from `^25.4.0` to `^25.5.0` ([#8722](https://github.com/MetaMask/core/pull/8722))
+- Bump `@metamask/multichain-account-service` from `^8.0.1` to `^9.0.0` ([#8722](https://github.com/MetaMask/core/pull/8722))
+- Bump `@metamask/permission-controller` from `^13.0.0` to `^13.1.0` ([#8722](https://github.com/MetaMask/core/pull/8722))
+- Bump `@metamask/transaction-controller` from `^65.1.0` to `^65.2.0` ([#8722](https://github.com/MetaMask/core/pull/8722))
+
+## [106.0.0]
+
 ### Added
 
+- Add `TokenListService`, a shared service for fetching and caching the token list per chain ([#8700](https://github.com/MetaMask/core/pull/8700))
+  - Wraps `@tanstack/query-core` to cache results in-memory for 4 hours per chain ID, matching `TokenListController`'s existing threshold.
+  - Multiple controllers sharing the same `TokenListService` instance share the same cache: only one HTTP request is made per chain per 4-hour window regardless of how many callers invoke `fetchTokensByChainId`.
+  - Exported from the package as `TokenListService` and `buildTokenListMap`.
+- Add `@tanstack/query-core` `^5.62.16` as a direct dependency ([#8700](https://github.com/MetaMask/core/pull/8700))
 - Expose missing public `AccountTrackerController` methods through its messenger ([#8693](https://github.com/MetaMask/core/pull/8693))
   - The following actions are now available:
     - `AccountTrackerController:refresh`
@@ -22,6 +37,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- **BREAKING:** `TokenDetectionController` now requires a `tokenListService: TokenListService` constructor option ([#8700](https://github.com/MetaMask/core/pull/8700))
+  - Token list data is fetched directly from `TokenListService` instead of reading `TokenListController` state on each detection pass.
+  - `GetTokenListState` has been removed from `AllowedActions` and `TokenListStateChange` has been removed from `AllowedEvents` on `TokenDetectionControllerMessenger`.
+- **BREAKING:** `TokensController` now requires a `tokenListService: TokenListService` constructor option ([#8700](https://github.com/MetaMask/core/pull/8700))
+  - `TokenListStateChange` has been removed from `AllowedEvents` on `TokensControllerMessenger`.
+  - Token `name` and `rwaData` enrichment now happens once at controller initialization instead of reactively on every `TokenListController:stateChange` event.
 - Bump `@metamask/transaction-controller` from `^65.0.0` to `^65.1.0` ([#8691](https://github.com/MetaMask/core/pull/8691))
 - Switch the default mUSD asset from upfront `allTokens` state seeding to detection-based discovery on Ethereum mainnet (`0x1`), Linea (`0xe708`), and Monad mainnet (`0x8f`) ([#8688](https://github.com/MetaMask/core/pull/8688))
   - `TokenDetectionController` now merges mUSD into the in-memory token list cache for these chains so it is treated as a regular detection candidate, replacing the previous `start()`-time `TokensController:addTokens` call and the per-event re-seed runs.
@@ -34,6 +55,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Removed
 
+- `TokenDetectionController` no longer restarts token detection when `TokenListController` publishes a `stateChange` event ([#8700](https://github.com/MetaMask/core/pull/8700))
+  - Detection is still triggered on wallet unlock, account change, network change, and preference changes; the extra restart that occurred whenever `TokenListController` refreshed its cache is gone.
 - Stop seeding mUSD directly into `TokensController` state and remove the related event subscriptions ([#8688](https://github.com/MetaMask/core/pull/8688))
   - `TokensController` no longer subscribes to `KeyringController:unlock`, `AccountsController:accountAdded`, `AccountsController:selectedEvmAccountChange`, `NetworkController:networkAdded`, or `NetworkController:stateChange` for mUSD seeding purposes.
   - `TokensControllerMessenger` no longer requires `NetworkControllerNetworkAddedEvent`, `AccountsControllerAccountAddedEvent`, or `KeyringControllerUnlockEvent` as allowed events.
@@ -3028,7 +3051,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Use Ethers for AssetsContractController ([#845](https://github.com/MetaMask/core/pull/845))
 
-[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/assets-controllers@105.1.0...HEAD
+[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/assets-controllers@106.0.0...HEAD
+[106.0.0]: https://github.com/MetaMask/core/compare/@metamask/assets-controllers@105.1.0...@metamask/assets-controllers@106.0.0
 [105.1.0]: https://github.com/MetaMask/core/compare/@metamask/assets-controllers@105.0.0...@metamask/assets-controllers@105.1.0
 [105.0.0]: https://github.com/MetaMask/core/compare/@metamask/assets-controllers@104.3.0...@metamask/assets-controllers@105.0.0
 [104.3.0]: https://github.com/MetaMask/core/compare/@metamask/assets-controllers@104.2.0...@metamask/assets-controllers@104.3.0

package/dist/TokenDetectionController-method-action-types.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"TokenDetectionController-method-action-types.cjs","sourceRoot":"","sources":["../src/TokenDetectionController-method-action-types.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/**\n * This file is auto generated.\n * Do not edit manually.\n */\n\nimport type { TokenDetectionController } from './TokenDetectionController';\n\n/**\n * Allows controller to make active and passive polling requests\n */\nexport type TokenDetectionControllerEnableAction = {\n  type: `TokenDetectionController:enable`;\n  handler: TokenDetectionController['enable'];\n};\n\n/**\n * Blocks controller from making network calls\n */\nexport type TokenDetectionControllerDisableAction = {\n  type: `TokenDetectionController:disable`;\n  handler: TokenDetectionController['disable'];\n};\n\n/**\n * Start polling for detected tokens.\n */\nexport type TokenDetectionControllerStartAction = {\n  type: `TokenDetectionController:start`;\n  handler: TokenDetectionController['start'];\n};\n\n/**\n * Stop polling for detected tokens.\n */\nexport type TokenDetectionControllerStopAction = {\n  type: `TokenDetectionController:stop`;\n  handler: TokenDetectionController['stop'];\n};\n\n/**\n * 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.\n * 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.\n *\n * @param options - Options for token detection.\n * @param options.chainIds - The chain IDs of the network client to use.\n * @param options.selectedAddress - the selectedAddress against which to detect for token balances.\n * @param options.forceRpc - Force RPC-based token detection for all specified chains,\n * bypassing external services check and ensuring RPC is used even for chains\n * that might otherwise be handled by the Accounts API.\n */\nexport type TokenDetectionControllerDetectTokensAction = {\n  type: `TokenDetectionController:detectTokens`;\n  handler: TokenDetectionController['detectTokens'];\n};\n\n/**\n * Add tokens detected from websocket balance updates\n * This method:\n * - Checks if useTokenDetection preference is enabled (skips if disabled)\n * - Checks if external services are enabled (skips if disabled)\n * - Tokens are expected to be in the tokensChainsCache with full metadata\n * - Balance fetching is skipped since balances are provided by the websocket\n * - Ignored tokens have been filtered out by the caller\n *\n * @param options - The options object\n * @param options.tokensSlice - Array of token addresses detected from websocket (already filtered to exclude ignored tokens)\n * @param options.chainId - Hex chain ID\n * @returns Promise that resolves when tokens are added\n */\nexport type TokenDetectionControllerAddDetectedTokensViaWsAction = {\n  type: `TokenDetectionController:addDetectedTokensViaWs`;\n  handler: TokenDetectionController['addDetectedTokensViaWs'];\n};\n\n/**\n * Add tokens detected from polling balance updates\n * This method:\n * - Checks if useTokenDetection preference is enabled (skips if disabled)\n * - Checks if external services are enabled (skips if disabled)\n * - Filters out tokens already in allTokens or allIgnoredTokens\n * - Tokens are expected to be in the tokensChainsCache with full metadata\n * - Balance fetching is skipped since balances are provided by the caller\n *\n * @param options - The options object\n * @param options.tokensSlice - Array of token addresses detected from polling\n * @param options.chainId - Hex chain ID\n * @returns Promise that resolves when tokens are added\n */\nexport type TokenDetectionControllerAddDetectedTokensViaPollingAction = {\n  type: `TokenDetectionController:addDetectedTokensViaPolling`;\n  handler: TokenDetectionController['addDetectedTokensViaPolling'];\n};\n\n/**\n * Union of all TokenDetectionController action types.\n */\nexport type TokenDetectionControllerMethodActions =\n  | TokenDetectionControllerEnableAction\n  | TokenDetectionControllerDisableAction\n  | TokenDetectionControllerStartAction\n  | TokenDetectionControllerStopAction\n  | TokenDetectionControllerDetectTokensAction\n  | TokenDetectionControllerAddDetectedTokensViaWsAction\n  | TokenDetectionControllerAddDetectedTokensViaPollingAction;\n"]}
+{"version":3,"file":"TokenDetectionController-method-action-types.cjs","sourceRoot":"","sources":["../src/TokenDetectionController-method-action-types.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/**\n * This file is auto generated.\n * Do not edit manually.\n */\n\nimport type { TokenDetectionController } from './TokenDetectionController';\n\n/**\n * Allows controller to make active and passive polling requests\n */\nexport type TokenDetectionControllerEnableAction = {\n  type: `TokenDetectionController:enable`;\n  handler: TokenDetectionController['enable'];\n};\n\n/**\n * Blocks controller from making network calls\n */\nexport type TokenDetectionControllerDisableAction = {\n  type: `TokenDetectionController:disable`;\n  handler: TokenDetectionController['disable'];\n};\n\n/**\n * Start polling for detected tokens.\n */\nexport type TokenDetectionControllerStartAction = {\n  type: `TokenDetectionController:start`;\n  handler: TokenDetectionController['start'];\n};\n\n/**\n * Stop polling for detected tokens.\n */\nexport type TokenDetectionControllerStopAction = {\n  type: `TokenDetectionController:stop`;\n  handler: TokenDetectionController['stop'];\n};\n\n/**\n * 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.\n * 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.\n *\n * @param options - Options for token detection.\n * @param options.chainIds - The chain IDs of the network client to use.\n * @param options.selectedAddress - the selectedAddress against which to detect for token balances.\n * @param options.forceRpc - Force RPC-based token detection for all specified chains,\n * bypassing external services check and ensuring RPC is used even for chains\n * that might otherwise be handled by the Accounts API.\n */\nexport type TokenDetectionControllerDetectTokensAction = {\n  type: `TokenDetectionController:detectTokens`;\n  handler: TokenDetectionController['detectTokens'];\n};\n\n/**\n * Add tokens detected from websocket balance updates\n * This method:\n * - Checks if useTokenDetection preference is enabled (skips if disabled)\n * - Checks if external services are enabled (skips if disabled)\n * - Tokens are expected to be in the tokensChainsCache with full metadata\n * - Balance fetching is skipped since balances are provided by the websocket\n * - Ignored tokens have been filtered out by the caller\n *\n * @param options - The options object\n * @param options.tokensSlice - Array of token addresses detected from websocket (already filtered to exclude ignored tokens)\n * @param options.chainId - Hex chain ID\n * @returns Promise that resolves when tokens are added\n */\nexport type TokenDetectionControllerAddDetectedTokensViaWsAction = {\n  type: `TokenDetectionController:addDetectedTokensViaWs`;\n  handler: TokenDetectionController['addDetectedTokensViaWs'];\n};\n\n/**\n * Add tokens detected from polling balance updates\n * This method:\n * - Checks if useTokenDetection preference is enabled (skips if disabled)\n * - Checks if external services are enabled (skips if disabled)\n * - Filters out tokens already in allTokens or allIgnoredTokens\n * - Tokens are expected to be in the tokensChainsCache with full metadata\n * - Balance fetching is skipped since balances are provided by the caller\n *\n * @param options - The options object\n * @param options.tokensSlice - Array of token addresses detected from polling\n * @param options.chainId - Hex chain ID\n * @returns Promise that resolves when tokens are added\n */\nexport type TokenDetectionControllerAddDetectedTokensViaPollingAction = {\n  type: `TokenDetectionController:addDetectedTokensViaPolling`;\n  handler: TokenDetectionController['addDetectedTokensViaPolling'];\n};\n\n/**\n * Union of all TokenDetectionController action types.\n */\nexport type TokenDetectionControllerMethodActions =\n  | TokenDetectionControllerEnableAction\n  | TokenDetectionControllerDisableAction\n  | TokenDetectionControllerStartAction\n  | TokenDetectionControllerStopAction\n  | TokenDetectionControllerDetectTokensAction\n  | TokenDetectionControllerAddDetectedTokensViaWsAction\n  | TokenDetectionControllerAddDetectedTokensViaPollingAction;\n"]}

package/dist/TokenDetectionController-method-action-types.d.cts

@@ -32,7 +32,7 @@ export type TokenDetectionControllerStopAction = {
     handler: TokenDetectionController['stop'];
 };
 /**
- * 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.

package/dist/TokenDetectionController-method-action-types.d.mts

@@ -32,7 +32,7 @@ export type TokenDetectionControllerStopAction = {
     handler: TokenDetectionController['stop'];
 };
 /**
- * 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.

package/dist/TokenDetectionController-method-action-types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"TokenDetectionController-method-action-types.mjs","sourceRoot":"","sources":["../src/TokenDetectionController-method-action-types.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/**\n * This file is auto generated.\n * Do not edit manually.\n */\n\nimport type { TokenDetectionController } from './TokenDetectionController';\n\n/**\n * Allows controller to make active and passive polling requests\n */\nexport type TokenDetectionControllerEnableAction = {\n  type: `TokenDetectionController:enable`;\n  handler: TokenDetectionController['enable'];\n};\n\n/**\n * Blocks controller from making network calls\n */\nexport type TokenDetectionControllerDisableAction = {\n  type: `TokenDetectionController:disable`;\n  handler: TokenDetectionController['disable'];\n};\n\n/**\n * Start polling for detected tokens.\n */\nexport type TokenDetectionControllerStartAction = {\n  type: `TokenDetectionController:start`;\n  handler: TokenDetectionController['start'];\n};\n\n/**\n * Stop polling for detected tokens.\n */\nexport type TokenDetectionControllerStopAction = {\n  type: `TokenDetectionController:stop`;\n  handler: TokenDetectionController['stop'];\n};\n\n/**\n * 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.\n * 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.\n *\n * @param options - Options for token detection.\n * @param options.chainIds - The chain IDs of the network client to use.\n * @param options.selectedAddress - the selectedAddress against which to detect for token balances.\n * @param options.forceRpc - Force RPC-based token detection for all specified chains,\n * bypassing external services check and ensuring RPC is used even for chains\n * that might otherwise be handled by the Accounts API.\n */\nexport type TokenDetectionControllerDetectTokensAction = {\n  type: `TokenDetectionController:detectTokens`;\n  handler: TokenDetectionController['detectTokens'];\n};\n\n/**\n * Add tokens detected from websocket balance updates\n * This method:\n * - Checks if useTokenDetection preference is enabled (skips if disabled)\n * - Checks if external services are enabled (skips if disabled)\n * - Tokens are expected to be in the tokensChainsCache with full metadata\n * - Balance fetching is skipped since balances are provided by the websocket\n * - Ignored tokens have been filtered out by the caller\n *\n * @param options - The options object\n * @param options.tokensSlice - Array of token addresses detected from websocket (already filtered to exclude ignored tokens)\n * @param options.chainId - Hex chain ID\n * @returns Promise that resolves when tokens are added\n */\nexport type TokenDetectionControllerAddDetectedTokensViaWsAction = {\n  type: `TokenDetectionController:addDetectedTokensViaWs`;\n  handler: TokenDetectionController['addDetectedTokensViaWs'];\n};\n\n/**\n * Add tokens detected from polling balance updates\n * This method:\n * - Checks if useTokenDetection preference is enabled (skips if disabled)\n * - Checks if external services are enabled (skips if disabled)\n * - Filters out tokens already in allTokens or allIgnoredTokens\n * - Tokens are expected to be in the tokensChainsCache with full metadata\n * - Balance fetching is skipped since balances are provided by the caller\n *\n * @param options - The options object\n * @param options.tokensSlice - Array of token addresses detected from polling\n * @param options.chainId - Hex chain ID\n * @returns Promise that resolves when tokens are added\n */\nexport type TokenDetectionControllerAddDetectedTokensViaPollingAction = {\n  type: `TokenDetectionController:addDetectedTokensViaPolling`;\n  handler: TokenDetectionController['addDetectedTokensViaPolling'];\n};\n\n/**\n * Union of all TokenDetectionController action types.\n */\nexport type TokenDetectionControllerMethodActions =\n  | TokenDetectionControllerEnableAction\n  | TokenDetectionControllerDisableAction\n  | TokenDetectionControllerStartAction\n  | TokenDetectionControllerStopAction\n  | TokenDetectionControllerDetectTokensAction\n  | TokenDetectionControllerAddDetectedTokensViaWsAction\n  | TokenDetectionControllerAddDetectedTokensViaPollingAction;\n"]}
+{"version":3,"file":"TokenDetectionController-method-action-types.mjs","sourceRoot":"","sources":["../src/TokenDetectionController-method-action-types.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/**\n * This file is auto generated.\n * Do not edit manually.\n */\n\nimport type { TokenDetectionController } from './TokenDetectionController';\n\n/**\n * Allows controller to make active and passive polling requests\n */\nexport type TokenDetectionControllerEnableAction = {\n  type: `TokenDetectionController:enable`;\n  handler: TokenDetectionController['enable'];\n};\n\n/**\n * Blocks controller from making network calls\n */\nexport type TokenDetectionControllerDisableAction = {\n  type: `TokenDetectionController:disable`;\n  handler: TokenDetectionController['disable'];\n};\n\n/**\n * Start polling for detected tokens.\n */\nexport type TokenDetectionControllerStartAction = {\n  type: `TokenDetectionController:start`;\n  handler: TokenDetectionController['start'];\n};\n\n/**\n * Stop polling for detected tokens.\n */\nexport type TokenDetectionControllerStopAction = {\n  type: `TokenDetectionController:stop`;\n  handler: TokenDetectionController['stop'];\n};\n\n/**\n * 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.\n * 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.\n *\n * @param options - Options for token detection.\n * @param options.chainIds - The chain IDs of the network client to use.\n * @param options.selectedAddress - the selectedAddress against which to detect for token balances.\n * @param options.forceRpc - Force RPC-based token detection for all specified chains,\n * bypassing external services check and ensuring RPC is used even for chains\n * that might otherwise be handled by the Accounts API.\n */\nexport type TokenDetectionControllerDetectTokensAction = {\n  type: `TokenDetectionController:detectTokens`;\n  handler: TokenDetectionController['detectTokens'];\n};\n\n/**\n * Add tokens detected from websocket balance updates\n * This method:\n * - Checks if useTokenDetection preference is enabled (skips if disabled)\n * - Checks if external services are enabled (skips if disabled)\n * - Tokens are expected to be in the tokensChainsCache with full metadata\n * - Balance fetching is skipped since balances are provided by the websocket\n * - Ignored tokens have been filtered out by the caller\n *\n * @param options - The options object\n * @param options.tokensSlice - Array of token addresses detected from websocket (already filtered to exclude ignored tokens)\n * @param options.chainId - Hex chain ID\n * @returns Promise that resolves when tokens are added\n */\nexport type TokenDetectionControllerAddDetectedTokensViaWsAction = {\n  type: `TokenDetectionController:addDetectedTokensViaWs`;\n  handler: TokenDetectionController['addDetectedTokensViaWs'];\n};\n\n/**\n * Add tokens detected from polling balance updates\n * This method:\n * - Checks if useTokenDetection preference is enabled (skips if disabled)\n * - Checks if external services are enabled (skips if disabled)\n * - Filters out tokens already in allTokens or allIgnoredTokens\n * - Tokens are expected to be in the tokensChainsCache with full metadata\n * - Balance fetching is skipped since balances are provided by the caller\n *\n * @param options - The options object\n * @param options.tokensSlice - Array of token addresses detected from polling\n * @param options.chainId - Hex chain ID\n * @returns Promise that resolves when tokens are added\n */\nexport type TokenDetectionControllerAddDetectedTokensViaPollingAction = {\n  type: `TokenDetectionController:addDetectedTokensViaPolling`;\n  handler: TokenDetectionController['addDetectedTokensViaPolling'];\n};\n\n/**\n * Union of all TokenDetectionController action types.\n */\nexport type TokenDetectionControllerMethodActions =\n  | TokenDetectionControllerEnableAction\n  | TokenDetectionControllerDisableAction\n  | TokenDetectionControllerStartAction\n  | TokenDetectionControllerStopAction\n  | TokenDetectionControllerDetectTokensAction\n  | TokenDetectionControllerAddDetectedTokensViaWsAction\n  | TokenDetectionControllerAddDetectedTokensViaPollingAction;\n"]}

package/dist/TokenDetectionController.cjs

@@ -13,13 +13,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-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_buildMusdTokenListToken, _TokenDetectionController_mergeMusdIntoTokenListMap, _TokenDetectionController_applyMusdDefaultToTokensChainsCache, _TokenDetectionController_includeMusdInTokenDetectionSlice, _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;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenDetectionController = exports.controllerName = exports.mapChainIdWithTokenListMap = exports.STATIC_MAINNET_TOKEN_LIST = void 0;
+exports.TokenDetectionController = exports.controllerName = exports.STATIC_MAINNET_TOKEN_LIST = void 0;
 const contract_metadata_1 = __importDefault(require("@metamask/contract-metadata"));
 const controller_utils_1 = require("@metamask/controller-utils");
 const polling_controller_1 = require("@metamask/polling-controller");
-const lodash_1 = require("lodash");
 const assetsUtil_1 = require("./assetsUtil.cjs");
 const constants_1 = require("./constants.cjs");
 const DEFAULT_INTERVAL = 180000;
@@ -36,21 +35,6 @@ exports.STATIC_MAINNET_TOKEN_LIST = Object.entries(contract_metadata_1.default).
     };
 }, {});
 const MUSD_TOKEN_DETECTION_CHAIN_ID_SET = new Set(constants_1.MUSD_TOKEN_DETECTION_CHAIN_IDS);
-/**
- * Function that takes a TokensChainsCache object and maps chainId with TokenListMap.
- *
- * @param tokensChainsCache - TokensChainsCache input object
- * @returns returns the map of chainId with TokenListMap
- */
-function mapChainIdWithTokenListMap(tokensChainsCache) {
-    return (0, lodash_1.mapValues)(tokensChainsCache, (value) => {
-        if ((0, lodash_1.isObject)(value) && 'data' in value) {
-            return (0, lodash_1.get)(value, ['data']);
-        }
-        return value;
-    });
-}
-exports.mapChainIdWithTokenListMap = mapChainIdWithTokenListMap;
 exports.controllerName = 'TokenDetectionController';
 const MESSENGER_EXPOSED_METHODS = [
     'addDetectedTokensViaWs',
@@ -83,6 +67,7 @@ class TokenDetectionController extends (0, polling_controller_1.StaticIntervalPo
      *
      * @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.
@@ -90,7 +75,7 @@ class TokenDetectionController extends (0, polling_controller_1.StaticIntervalPo
      * @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: exports.controllerName,
             messenger,
@@ -100,7 +85,7 @@ class TokenDetectionController extends (0, polling_controller_1.StaticIntervalPo
         _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);
@@ -112,8 +97,7 @@ class TokenDetectionController extends (0, polling_controller_1.StaticIntervalPo
         __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");
@@ -168,7 +152,7 @@ class TokenDetectionController extends (0, polling_controller_1.StaticIntervalPo
         });
     }
     /**
-     * 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.
@@ -225,10 +209,19 @@ class TokenDetectionController extends (0, polling_controller_1.StaticIntervalPo
         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, __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_applyMusdDefaultToTokensChainsCache).call(this, chainId, 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 = [];
@@ -237,7 +230,7 @@ class TokenDetectionController extends (0, polling_controller_1.StaticIntervalPo
             const lowercaseTokenAddress = tokenAddress.toLowerCase();
             const checksummedTokenAddress = (0, controller_utils_1.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;
             }
@@ -293,10 +286,19 @@ class TokenDetectionController extends (0, polling_controller_1.StaticIntervalPo
         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, __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_applyMusdDefaultToTokensChainsCache).call(this, chainId, 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');
@@ -317,7 +319,7 @@ class TokenDetectionController extends (0, polling_controller_1.StaticIntervalPo
                 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;
             }
@@ -351,7 +353,7 @@ class TokenDetectionController extends (0, polling_controller_1.StaticIntervalPo
     }
 }
 exports.TokenDetectionController = TokenDetectionController;
-_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() {
+_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(() => {
@@ -362,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;
@@ -422,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 = (0, lodash_1.isEqual)(cleanTokensChainsCache, cleanPreviousTokensChainsCache);
-    return isEqualValues;
 }, _TokenDetectionController_getCorrectNetworkClientIdByChainId = function _TokenDetectionController_getCorrectNetworkClientIdByChainId(chainIds) {
     const { networkConfigurationsByChainId, selectedNetworkClientId } = this.messenger.call('NetworkController:getState');
     if (!chainIds) {
@@ -461,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 (!(0, assetsUtil_1.isTokenDetectionSupportedForNetwork)(chainId)) {
-        return false;
+        return null;
     }
     if (!__classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f") &&
         chainId !== controller_utils_1.ChainId.mainnet) {
-        return false;
+        return null;
     }
     const isMainnetDetectionInactive = !__classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f") && chainId === controller_utils_1.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, __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_applyMusdDefaultToTokensChainsCache).call(this, chainId, 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, {
@@ -492,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,
@@ -503,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,
@@ -575,13 +576,20 @@ async function _TokenDetectionController_restartTokenDetection({ selectedAddress
         return tokensSlice;
     }
     return [...tokensSlice, constants_1.MUSD_ERC20_ADDRESS_LOWER];
-}, _TokenDetectionController_addDetectedTokens = async function _TokenDetectionController_addDetectedTokens({ tokensSlice, selectedAddress, networkClientId, chainId, }) {
+}, _TokenDetectionController_addDetectedTokens = async function _TokenDetectionController_addDetectedTokens({ tokensSlice, selectedAddress, networkClientId, chainId, chainCache, }) {
     await (0, controller_utils_1.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,
@@ -601,8 +609,7 @@ async function _TokenDetectionController_restartTokenDetection({ selectedAddress
             const musdInSlice = tokensSlice.some((addr) => (0, controller_utils_1.isEqualCaseInsensitive)(addr, constants_1.MUSD_ERC20_ADDRESS_LOWER));
             const musdHasNonZeroFromRpc = Object.keys(balances).some((addr) => (0, controller_utils_1.isEqualCaseInsensitive)(addr, constants_1.MUSD_ERC20_ADDRESS_LOWER));
             if (musdInSlice && !musdHasNonZeroFromRpc) {
-                const listData = __classPrivateFieldGet(this, _TokenDetectionController_tokensChainsCache, "f")[chainId].data;
-                const musdListToken = Object.entries(listData).find(([key]) => (0, controller_utils_1.isEqualCaseInsensitive)(key, constants_1.MUSD_ERC20_ADDRESS_LOWER))?.[1];
+                const musdListToken = Object.entries(chainData).find(([key]) => (0, controller_utils_1.isEqualCaseInsensitive)(key, constants_1.MUSD_ERC20_ADDRESS_LOWER))?.[1];
                 if (musdListToken) {
                     const { decimals, symbol, aggregators, iconUrl, name, rwaData } = musdListToken;
                     eventTokensDetails.push(`${symbol} - ${constants_1.MUSD_ERC20_ADDRESS_LOWER}`);