@metamask/assets-controllers 24.0.0 → 26.0.0

package/dist/TokenDetectionController.d.ts

@@ -1,26 +1,43 @@
+import type { AccountsControllerGetSelectedAccountAction, AccountsControllerSelectedAccountChangeEvent } from '@metamask/accounts-controller';
 import type { RestrictedControllerMessenger, ControllerGetStateAction, ControllerStateChangeEvent } from '@metamask/base-controller';
-import type { NetworkClientId, NetworkControllerNetworkDidChangeEvent, NetworkControllerStateChangeEvent, NetworkControllerGetNetworkConfigurationByNetworkClientId } from '@metamask/network-controller';
+import type { KeyringControllerGetStateAction, KeyringControllerLockEvent, KeyringControllerUnlockEvent } from '@metamask/keyring-controller';
+import type { NetworkClientId, NetworkControllerGetNetworkClientByIdAction, NetworkControllerGetNetworkConfigurationByNetworkClientId, NetworkControllerGetStateAction, NetworkControllerNetworkDidChangeEvent } from '@metamask/network-controller';
 import { StaticIntervalPollingController } from '@metamask/polling-controller';
-import type { PreferencesState } from '@metamask/preferences-controller';
+import type { PreferencesControllerGetStateAction, PreferencesControllerStateChangeEvent } from '@metamask/preferences-controller';
 import type { AssetsContractController } from './AssetsContractController';
-import type { GetTokenListState, TokenListStateChange } from './TokenListController';
-import type { TokensController, TokensState } from './TokensController';
+import type { GetTokenListState, TokenListMap, TokenListStateChange } from './TokenListController';
+import type { TokensControllerAddDetectedTokensAction, TokensControllerGetStateAction } from './TokensController';
+/**
+ * Compare 2 given strings and return boolean
+ * eg: "foo" and "FOO" => true
+ * eg: "foo" and "bar" => false
+ * eg: "foo" and 123 => false
+ *
+ * @param value1 - first string to compare
+ * @param value2 - first string to compare
+ * @returns true if 2 strings are identical when they are lowercase
+ */
+export declare function isEqualCaseInsensitive(value1: string, value2: string): boolean;
+declare type TokenDetectionMap = {
+    [P in keyof TokenListMap]: Omit<TokenListMap[P], 'occurrences'>;
+};
+export declare const STATIC_MAINNET_TOKEN_LIST: TokenDetectionMap;
 export declare const controllerName = "TokenDetectionController";
 export declare type TokenDetectionState = Record<never, never>;
 export declare type TokenDetectionControllerGetStateAction = ControllerGetStateAction<typeof controllerName, TokenDetectionState>;
 export declare type TokenDetectionControllerActions = TokenDetectionControllerGetStateAction;
-export declare type AllowedActions = NetworkControllerGetNetworkConfigurationByNetworkClientId | GetTokenListState;
+export declare type AllowedActions = AccountsControllerGetSelectedAccountAction | NetworkControllerGetNetworkClientByIdAction | NetworkControllerGetNetworkConfigurationByNetworkClientId | NetworkControllerGetStateAction | GetTokenListState | KeyringControllerGetStateAction | PreferencesControllerGetStateAction | TokensControllerGetStateAction | TokensControllerAddDetectedTokensAction;
 export declare type TokenDetectionControllerStateChangeEvent = ControllerStateChangeEvent<typeof controllerName, TokenDetectionState>;
 export declare type TokenDetectionControllerEvents = TokenDetectionControllerStateChangeEvent;
-export declare type AllowedEvents = NetworkControllerStateChangeEvent | NetworkControllerNetworkDidChangeEvent | TokenListStateChange;
+export declare type AllowedEvents = AccountsControllerSelectedAccountChangeEvent | NetworkControllerNetworkDidChangeEvent | TokenListStateChange | KeyringControllerLockEvent | KeyringControllerUnlockEvent | PreferencesControllerStateChangeEvent;
 export declare type TokenDetectionControllerMessenger = RestrictedControllerMessenger<typeof controllerName, TokenDetectionControllerActions | AllowedActions, TokenDetectionControllerEvents | AllowedEvents, AllowedActions['type'], AllowedEvents['type']>;
 /**
  * Controller that passively polls on a set interval for Tokens auto detection
  * @property intervalId - Polling interval used to fetch new token rates
- * @property chainId - The chain ID of the current network
  * @property selectedAddress - Vault selected address
  * @property networkClientId - The network client ID of the current selected network
  * @property disabled - Boolean to track if network requests are blocked
+ * @property isUnlocked - Boolean to track if the keyring state is unlocked
  * @property isDetectionEnabledFromPreferences - Boolean to track if detection is enabled from PreferencesController
  * @property isDetectionEnabledForNetwork - Boolean to track if detected is enabled for current network
  */
@@ -33,24 +50,24 @@ export declare class TokenDetectionController extends StaticIntervalPollingContr
      * @param options.messenger - The controller messaging system.
      * @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.networkClientId - The selected network client ID of the current network
      * @param options.selectedAddress - Vault selected address
-     * @param options.onPreferencesStateChange - Allows subscribing to preferences controller state changes.
-     * @param options.addDetectedTokens - Add a list of detected tokens.
      * @param options.getBalancesInSingleCall - Gets the balances of a list of tokens for the given address.
-     * @param options.getTokensState - Gets the current state of the Tokens controller.
-     * @param options.getPreferencesState - Gets the state of the preferences controller.
+     * @param options.trackMetaMetricsEvent - Sets options for MetaMetrics event tracking.
      */
-    constructor({ networkClientId, selectedAddress, interval, disabled, onPreferencesStateChange, getBalancesInSingleCall, addDetectedTokens, getPreferencesState, getTokensState, messenger, }: {
-        networkClientId: NetworkClientId;
+    constructor({ selectedAddress, interval, disabled, getBalancesInSingleCall, trackMetaMetricsEvent, messenger, }: {
         selectedAddress?: string;
         interval?: number;
         disabled?: boolean;
-        onPreferencesStateChange: (listener: (preferencesState: PreferencesState) => void) => void;
-        addDetectedTokens: TokensController['addDetectedTokens'];
         getBalancesInSingleCall: AssetsContractController['getBalancesInSingleCall'];
-        getTokensState: () => TokensState;
-        getPreferencesState: () => PreferencesState;
+        trackMetaMetricsEvent: (options: {
+            event: string;
+            category: string;
+            properties: {
+                tokens: string[];
+                token_standard: string;
+                asset_type: string;
+            };
+        }) => void;
         messenger: TokenDetectionControllerMessenger;
     });
     /**
@@ -61,6 +78,11 @@ export declare class TokenDetectionController extends StaticIntervalPollingContr
      * Blocks controller from making network calls
      */
     disable(): void;
+    /**
+     * Internal isActive state
+     * @type {boolean}
+     */
+    get isActive(): boolean;
     /**
      * Start polling for detected tokens.
      */
@@ -69,19 +91,20 @@ export declare class TokenDetectionController extends StaticIntervalPollingContr
      * Stop polling for detected tokens.
      */
     stop(): void;
-    _executePoll(networkClientId: string, options: {
+    _executePoll(networkClientId: NetworkClientId, options: {
         address: string;
     }): Promise<void>;
     /**
-     * Triggers asset ERC20 token auto detection for each contract address in contract metadata on mainnet.
+     * 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.
+     * 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 to detect tokens.
+     * @param options - Options for token detection.
      * @param options.networkClientId - The ID of the network client to use.
-     * @param options.accountAddress - The account address to use.
+     * @param options.selectedAddress - the selectedAddress against which to detect for token balances.
      */
-    detectTokens({ networkClientId, accountAddress, }?: {
+    detectTokens({ networkClientId, selectedAddress, }?: {
         networkClientId?: NetworkClientId;
-        accountAddress?: string;
+        selectedAddress?: string;
     }): Promise<void>;
 }
 export default TokenDetectionController;

package/dist/TokenDetectionController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TokenDetectionController.d.ts","sourceRoot":"","sources":["../src/TokenDetectionController.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"TokenDetectionController.d.ts","sourceRoot":"","sources":["../src/TokenDetectionController.ts"],"names":[],"mappings":"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"}

package/dist/TokenDetectionController.js

@@ -19,21 +19,57 @@ 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_chainId, _TokenDetectionController_selectedAddress, _TokenDetectionController_networkClientId, _TokenDetectionController_disabled, _TokenDetectionController_isDetectionEnabledFromPreferences, _TokenDetectionController_isDetectionEnabledForNetwork, _TokenDetectionController_addDetectedTokens, _TokenDetectionController_getBalancesInSingleCall, _TokenDetectionController_getTokensState, _TokenDetectionController_stopPolling, _TokenDetectionController_startPolling, _TokenDetectionController_getCorrectChainId;
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _TokenDetectionController_instances, _TokenDetectionController_intervalId, _TokenDetectionController_selectedAddress, _TokenDetectionController_networkClientId, _TokenDetectionController_tokenList, _TokenDetectionController_disabled, _TokenDetectionController_isUnlocked, _TokenDetectionController_isDetectionEnabledFromPreferences, _TokenDetectionController_isDetectionEnabledForNetwork, _TokenDetectionController_getBalancesInSingleCall, _TokenDetectionController_trackMetaMetricsEvent, _TokenDetectionController_registerEventListeners, _TokenDetectionController_stopPolling, _TokenDetectionController_startPolling, _TokenDetectionController_getCorrectChainIdAndNetworkClientId, _TokenDetectionController_restartTokenDetection, _TokenDetectionController_getSlicesOfTokensToDetect, _TokenDetectionController_addDetectedTokens;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenDetectionController = exports.controllerName = void 0;
+exports.TokenDetectionController = exports.controllerName = exports.STATIC_MAINNET_TOKEN_LIST = exports.isEqualCaseInsensitive = 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 assetsUtil_1 = require("./assetsUtil");
 const DEFAULT_INTERVAL = 180000;
+/**
+ * Compare 2 given strings and return boolean
+ * eg: "foo" and "FOO" => true
+ * eg: "foo" and "bar" => false
+ * eg: "foo" and 123 => false
+ *
+ * @param value1 - first string to compare
+ * @param value2 - first string to compare
+ * @returns true if 2 strings are identical when they are lowercase
+ */
+function isEqualCaseInsensitive(value1, value2) {
+    if (typeof value1 !== 'string' || typeof value2 !== 'string') {
+        return false;
+    }
+    return value1.toLowerCase() === value2.toLowerCase();
+}
+exports.isEqualCaseInsensitive = isEqualCaseInsensitive;
+exports.STATIC_MAINNET_TOKEN_LIST = Object.entries(contract_metadata_1.default).reduce((acc, [base, contract]) => {
+    const { logo, erc20, erc721 } = contract, tokenMetadata = __rest(contract, ["logo", "erc20", "erc721"]);
+    return Object.assign(Object.assign({}, acc), { [base.toLowerCase()]: Object.assign(Object.assign({}, tokenMetadata), { address: base.toLowerCase(), iconUrl: `images/contract/${logo}`, aggregators: [] }) });
+}, {});
 exports.controllerName = 'TokenDetectionController';
 /**
  * Controller that passively polls on a set interval for Tokens auto detection
  * @property intervalId - Polling interval used to fetch new token rates
- * @property chainId - The chain ID of the current network
  * @property selectedAddress - Vault selected address
  * @property networkClientId - The network client ID of the current selected network
  * @property disabled - Boolean to track if network requests are blocked
+ * @property isUnlocked - Boolean to track if the keyring state is unlocked
  * @property isDetectionEnabledFromPreferences - Boolean to track if detection is enabled from PreferencesController
  * @property isDetectionEnabledForNetwork - Boolean to track if detected is enabled for current network
  */
@@ -45,16 +81,11 @@ class TokenDetectionController extends polling_controller_1.StaticIntervalPollin
      * @param options.messenger - The controller messaging system.
      * @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.networkClientId - The selected network client ID of the current network
      * @param options.selectedAddress - Vault selected address
-     * @param options.onPreferencesStateChange - Allows subscribing to preferences controller state changes.
-     * @param options.addDetectedTokens - Add a list of detected tokens.
      * @param options.getBalancesInSingleCall - Gets the balances of a list of tokens for the given address.
-     * @param options.getTokensState - Gets the current state of the Tokens controller.
-     * @param options.getPreferencesState - Gets the state of the preferences controller.
+     * @param options.trackMetaMetricsEvent - Sets options for MetaMetrics event tracking.
      */
-    constructor({ networkClientId, selectedAddress = '', interval = DEFAULT_INTERVAL, disabled = true, onPreferencesStateChange, getBalancesInSingleCall, addDetectedTokens, getPreferencesState, getTokensState, messenger, }) {
-        const { useTokenDetection: defaultUseTokenDetection } = getPreferencesState();
+    constructor({ selectedAddress, interval = DEFAULT_INTERVAL, disabled = true, getBalancesInSingleCall, trackMetaMetricsEvent, messenger, }) {
         super({
             name: exports.controllerName,
             messenger,
@@ -63,51 +94,29 @@ class TokenDetectionController extends polling_controller_1.StaticIntervalPollin
         });
         _TokenDetectionController_instances.add(this);
         _TokenDetectionController_intervalId.set(this, void 0);
-        _TokenDetectionController_chainId.set(this, void 0);
         _TokenDetectionController_selectedAddress.set(this, void 0);
         _TokenDetectionController_networkClientId.set(this, void 0);
+        _TokenDetectionController_tokenList.set(this, {});
         _TokenDetectionController_disabled.set(this, void 0);
+        _TokenDetectionController_isUnlocked.set(this, void 0);
         _TokenDetectionController_isDetectionEnabledFromPreferences.set(this, void 0);
         _TokenDetectionController_isDetectionEnabledForNetwork.set(this, void 0);
-        _TokenDetectionController_addDetectedTokens.set(this, void 0);
         _TokenDetectionController_getBalancesInSingleCall.set(this, void 0);
-        _TokenDetectionController_getTokensState.set(this, void 0);
+        _TokenDetectionController_trackMetaMetricsEvent.set(this, void 0);
         __classPrivateFieldSet(this, _TokenDetectionController_disabled, disabled, "f");
         this.setIntervalLength(interval);
+        __classPrivateFieldSet(this, _TokenDetectionController_selectedAddress, selectedAddress !== null && selectedAddress !== void 0 ? selectedAddress : this.messagingSystem.call('AccountsController:getSelectedAccount')
+            .address, "f");
+        const { chainId, networkClientId } = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getCorrectChainIdAndNetworkClientId).call(this);
         __classPrivateFieldSet(this, _TokenDetectionController_networkClientId, networkClientId, "f");
-        __classPrivateFieldSet(this, _TokenDetectionController_selectedAddress, selectedAddress, "f");
-        __classPrivateFieldSet(this, _TokenDetectionController_chainId, __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getCorrectChainId).call(this, networkClientId), "f");
+        const { useTokenDetection: defaultUseTokenDetection } = this.messagingSystem.call('PreferencesController:getState');
         __classPrivateFieldSet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, defaultUseTokenDetection, "f");
-        __classPrivateFieldSet(this, _TokenDetectionController_isDetectionEnabledForNetwork, (0, assetsUtil_1.isTokenDetectionSupportedForNetwork)(__classPrivateFieldGet(this, _TokenDetectionController_chainId, "f")), "f");
-        __classPrivateFieldSet(this, _TokenDetectionController_addDetectedTokens, addDetectedTokens, "f");
+        __classPrivateFieldSet(this, _TokenDetectionController_isDetectionEnabledForNetwork, (0, assetsUtil_1.isTokenDetectionSupportedForNetwork)(chainId), "f");
         __classPrivateFieldSet(this, _TokenDetectionController_getBalancesInSingleCall, getBalancesInSingleCall, "f");
-        __classPrivateFieldSet(this, _TokenDetectionController_getTokensState, getTokensState, "f");
-        this.messagingSystem.subscribe('TokenListController:stateChange', ({ tokenList }) => __awaiter(this, void 0, void 0, function* () {
-            const hasTokens = Object.keys(tokenList).length;
-            if (hasTokens) {
-                yield this.detectTokens();
-            }
-        }));
-        onPreferencesStateChange(({ selectedAddress: newSelectedAddress, useTokenDetection }) => __awaiter(this, void 0, void 0, function* () {
-            const isSelectedAddressChanged = __classPrivateFieldGet(this, _TokenDetectionController_selectedAddress, "f") !== newSelectedAddress;
-            const isDetectionChangedFromPreferences = __classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f") !== useTokenDetection;
-            __classPrivateFieldSet(this, _TokenDetectionController_selectedAddress, newSelectedAddress, "f");
-            __classPrivateFieldSet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, useTokenDetection, "f");
-            if (useTokenDetection &&
-                (isSelectedAddressChanged || isDetectionChangedFromPreferences)) {
-                yield this.detectTokens();
-            }
-        }));
-        this.messagingSystem.subscribe('NetworkController:networkDidChange', ({ selectedNetworkClientId }) => __awaiter(this, void 0, void 0, function* () {
-            __classPrivateFieldSet(this, _TokenDetectionController_networkClientId, selectedNetworkClientId, "f");
-            const newChainId = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getCorrectChainId).call(this, selectedNetworkClientId);
-            const isChainIdChanged = __classPrivateFieldGet(this, _TokenDetectionController_chainId, "f") !== newChainId;
-            __classPrivateFieldSet(this, _TokenDetectionController_chainId, newChainId, "f");
-            __classPrivateFieldSet(this, _TokenDetectionController_isDetectionEnabledForNetwork, (0, assetsUtil_1.isTokenDetectionSupportedForNetwork)(newChainId), "f");
-            if (__classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledForNetwork, "f") && isChainIdChanged) {
-                yield this.detectTokens();
-            }
-        }));
+        __classPrivateFieldSet(this, _TokenDetectionController_trackMetaMetricsEvent, trackMetaMetricsEvent, "f");
+        const { isUnlocked } = this.messagingSystem.call('KeyringController:getState');
+        __classPrivateFieldSet(this, _TokenDetectionController_isUnlocked, isUnlocked, "f");
+        __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_registerEventListeners).call(this);
     }
     /**
      * Allows controller to make active and passive polling requests
@@ -121,6 +130,13 @@ class TokenDetectionController extends polling_controller_1.StaticIntervalPollin
     disable() {
         __classPrivateFieldSet(this, _TokenDetectionController_disabled, true, "f");
     }
+    /**
+     * Internal isActive state
+     * @type {boolean}
+     */
+    get isActive() {
+        return !__classPrivateFieldGet(this, _TokenDetectionController_disabled, "f") && __classPrivateFieldGet(this, _TokenDetectionController_isUnlocked, "f");
+    }
     /**
      * Start polling for detected tokens.
      */
@@ -139,96 +155,116 @@ class TokenDetectionController extends polling_controller_1.StaticIntervalPollin
     }
     _executePoll(networkClientId, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (__classPrivateFieldGet(this, _TokenDetectionController_disabled, "f")) {
+            if (!this.isActive) {
                 return;
             }
             yield this.detectTokens({
                 networkClientId,
-                accountAddress: options.address,
+                selectedAddress: options.address,
             });
         });
     }
     /**
-     * Triggers asset ERC20 token auto detection for each contract address in contract metadata on mainnet.
+     * 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.
+     * 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 to detect tokens.
+     * @param options - Options for token detection.
      * @param options.networkClientId - The ID of the network client to use.
-     * @param options.accountAddress - The account address to use.
+     * @param options.selectedAddress - the selectedAddress against which to detect for token balances.
      */
-    detectTokens({ networkClientId, accountAddress, } = {}) {
+    detectTokens({ networkClientId, selectedAddress, } = {}) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (__classPrivateFieldGet(this, _TokenDetectionController_disabled, "f") ||
-                !__classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledForNetwork, "f") ||
-                !__classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f")) {
+            if (!this.isActive) {
                 return;
             }
-            const { tokens } = __classPrivateFieldGet(this, _TokenDetectionController_getTokensState, "f").call(this);
-            const selectedAddress = accountAddress || __classPrivateFieldGet(this, _TokenDetectionController_selectedAddress, "f");
-            const chainId = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getCorrectChainId).call(this, networkClientId);
-            const tokensAddresses = tokens.map(
-            /* istanbul ignore next*/ (token) => token.address.toLowerCase());
-            const { tokenList } = this.messagingSystem.call('TokenListController:getState');
-            const tokensToDetect = [];
-            for (const address of Object.keys(tokenList)) {
-                if (!tokensAddresses.includes(address)) {
-                    tokensToDetect.push(address);
-                }
+            const addressAgainstWhichToDetect = selectedAddress !== null && selectedAddress !== void 0 ? selectedAddress : __classPrivateFieldGet(this, _TokenDetectionController_selectedAddress, "f");
+            const { chainId, networkClientId: selectedNetworkClientId } = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getCorrectChainIdAndNetworkClientId).call(this, networkClientId);
+            const chainIdAgainstWhichToDetect = chainId;
+            const networkClientIdAgainstWhichToDetect = selectedNetworkClientId;
+            if (!(0, assetsUtil_1.isTokenDetectionSupportedForNetwork)(chainIdAgainstWhichToDetect)) {
+                return;
             }
-            const sliceOfTokensToDetect = [];
-            sliceOfTokensToDetect[0] = tokensToDetect.slice(0, 1000);
-            sliceOfTokensToDetect[1] = tokensToDetect.slice(1000, tokensToDetect.length - 1);
-            /* istanbul ignore else */
-            if (!selectedAddress) {
+            if (!__classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f") &&
+                chainIdAgainstWhichToDetect !== controller_utils_1.ChainId.mainnet) {
                 return;
             }
-            for (const tokensSlice of sliceOfTokensToDetect) {
-                if (tokensSlice.length === 0) {
-                    break;
-                }
-                yield (0, controller_utils_1.safelyExecute)(() => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    const balances = yield __classPrivateFieldGet(this, _TokenDetectionController_getBalancesInSingleCall, "f").call(this, selectedAddress, tokensSlice);
-                    const tokensToAdd = [];
-                    for (const tokenAddress of Object.keys(balances)) {
-                        let ignored;
-                        /* istanbul ignore else */
-                        const { ignoredTokens } = __classPrivateFieldGet(this, _TokenDetectionController_getTokensState, "f").call(this);
-                        if (ignoredTokens.length) {
-                            ignored = ignoredTokens.find((ignoredTokenAddress) => ignoredTokenAddress === (0, controller_utils_1.toChecksumHexAddress)(tokenAddress));
-                        }
-                        const caseInsensitiveTokenKey = (_a = Object.keys(tokenList).find((i) => i.toLowerCase() === tokenAddress.toLowerCase())) !== null && _a !== void 0 ? _a : '';
-                        if (ignored === undefined) {
-                            const { decimals, symbol, aggregators, iconUrl, name } = tokenList[caseInsensitiveTokenKey];
-                            tokensToAdd.push({
-                                address: tokenAddress,
-                                decimals,
-                                symbol,
-                                aggregators,
-                                image: iconUrl,
-                                isERC721: false,
-                                name,
-                            });
-                        }
-                    }
-                    if (tokensToAdd.length) {
-                        yield __classPrivateFieldGet(this, _TokenDetectionController_addDetectedTokens, "f").call(this, tokensToAdd, {
-                            selectedAddress,
-                            chainId,
-                        });
-                    }
-                }));
+            const isTokenDetectionInactiveInMainnet = !__classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f") &&
+                chainIdAgainstWhichToDetect === controller_utils_1.ChainId.mainnet;
+            const { tokensChainsCache } = this.messagingSystem.call('TokenListController:getState');
+            __classPrivateFieldSet(this, _TokenDetectionController_tokenList, isTokenDetectionInactiveInMainnet
+                ? exports.STATIC_MAINNET_TOKEN_LIST
+                : (_b = (_a = tokensChainsCache[chainIdAgainstWhichToDetect]) === null || _a === void 0 ? void 0 : _a.data) !== null && _b !== void 0 ? _b : {}, "f");
+            for (const tokensSlice of __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getSlicesOfTokensToDetect).call(this, {
+                chainId: chainIdAgainstWhichToDetect,
+                selectedAddress: addressAgainstWhichToDetect,
+            })) {
+                yield __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_addDetectedTokens).call(this, {
+                    tokensSlice,
+                    selectedAddress: addressAgainstWhichToDetect,
+                    networkClientId: networkClientIdAgainstWhichToDetect,
+                    chainId: chainIdAgainstWhichToDetect,
+                });
             }
         });
     }
 }
 exports.TokenDetectionController = TokenDetectionController;
-_TokenDetectionController_intervalId = new WeakMap(), _TokenDetectionController_chainId = new WeakMap(), _TokenDetectionController_selectedAddress = new WeakMap(), _TokenDetectionController_networkClientId = new WeakMap(), _TokenDetectionController_disabled = new WeakMap(), _TokenDetectionController_isDetectionEnabledFromPreferences = new WeakMap(), _TokenDetectionController_isDetectionEnabledForNetwork = new WeakMap(), _TokenDetectionController_addDetectedTokens = new WeakMap(), _TokenDetectionController_getBalancesInSingleCall = new WeakMap(), _TokenDetectionController_getTokensState = new WeakMap(), _TokenDetectionController_instances = new WeakSet(), _TokenDetectionController_stopPolling = function _TokenDetectionController_stopPolling() {
+_TokenDetectionController_intervalId = new WeakMap(), _TokenDetectionController_selectedAddress = new WeakMap(), _TokenDetectionController_networkClientId = new WeakMap(), _TokenDetectionController_tokenList = new WeakMap(), _TokenDetectionController_disabled = new WeakMap(), _TokenDetectionController_isUnlocked = new WeakMap(), _TokenDetectionController_isDetectionEnabledFromPreferences = new WeakMap(), _TokenDetectionController_isDetectionEnabledForNetwork = new WeakMap(), _TokenDetectionController_getBalancesInSingleCall = new WeakMap(), _TokenDetectionController_trackMetaMetricsEvent = new WeakMap(), _TokenDetectionController_instances = new WeakSet(), _TokenDetectionController_registerEventListeners = function _TokenDetectionController_registerEventListeners() {
+    this.messagingSystem.subscribe('KeyringController:unlock', () => __awaiter(this, void 0, void 0, function* () {
+        __classPrivateFieldSet(this, _TokenDetectionController_isUnlocked, true, "f");
+        yield __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this);
+    }));
+    this.messagingSystem.subscribe('KeyringController:lock', () => {
+        __classPrivateFieldSet(this, _TokenDetectionController_isUnlocked, false, "f");
+        __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_stopPolling).call(this);
+    });
+    this.messagingSystem.subscribe('TokenListController:stateChange', ({ tokenList }) => __awaiter(this, void 0, void 0, function* () {
+        const hasTokens = Object.keys(tokenList).length;
+        if (hasTokens) {
+            yield __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this);
+        }
+    }));
+    this.messagingSystem.subscribe('PreferencesController:stateChange', ({ selectedAddress: newSelectedAddress, useTokenDetection }) => __awaiter(this, void 0, void 0, function* () {
+        const isSelectedAddressChanged = __classPrivateFieldGet(this, _TokenDetectionController_selectedAddress, "f") !== newSelectedAddress;
+        const isDetectionChangedFromPreferences = __classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f") !== useTokenDetection;
+        __classPrivateFieldSet(this, _TokenDetectionController_selectedAddress, newSelectedAddress, "f");
+        __classPrivateFieldSet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, useTokenDetection, "f");
+        if (useTokenDetection &&
+            (isSelectedAddressChanged || isDetectionChangedFromPreferences)) {
+            yield __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this, {
+                selectedAddress: __classPrivateFieldGet(this, _TokenDetectionController_selectedAddress, "f"),
+            });
+        }
+    }));
+    this.messagingSystem.subscribe('AccountsController:selectedAccountChange', ({ address: newSelectedAddress }) => __awaiter(this, void 0, void 0, function* () {
+        const isSelectedAddressChanged = __classPrivateFieldGet(this, _TokenDetectionController_selectedAddress, "f") !== newSelectedAddress;
+        if (isSelectedAddressChanged &&
+            __classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledFromPreferences, "f")) {
+            __classPrivateFieldSet(this, _TokenDetectionController_selectedAddress, newSelectedAddress, "f");
+            yield __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this, {
+                selectedAddress: __classPrivateFieldGet(this, _TokenDetectionController_selectedAddress, "f"),
+            });
+        }
+    }));
+    this.messagingSystem.subscribe('NetworkController:networkDidChange', ({ selectedNetworkClientId }) => __awaiter(this, void 0, void 0, function* () {
+        const isNetworkClientIdChanged = __classPrivateFieldGet(this, _TokenDetectionController_networkClientId, "f") !== selectedNetworkClientId;
+        const { chainId: newChainId } = __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_getCorrectChainIdAndNetworkClientId).call(this, selectedNetworkClientId);
+        __classPrivateFieldSet(this, _TokenDetectionController_isDetectionEnabledForNetwork, (0, assetsUtil_1.isTokenDetectionSupportedForNetwork)(newChainId), "f");
+        if (isNetworkClientIdChanged && __classPrivateFieldGet(this, _TokenDetectionController_isDetectionEnabledForNetwork, "f")) {
+            __classPrivateFieldSet(this, _TokenDetectionController_networkClientId, selectedNetworkClientId, "f");
+            yield __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_restartTokenDetection).call(this, {
+                networkClientId: __classPrivateFieldGet(this, _TokenDetectionController_networkClientId, "f"),
+            });
+        }
+    }));
+}, _TokenDetectionController_stopPolling = function _TokenDetectionController_stopPolling() {
     if (__classPrivateFieldGet(this, _TokenDetectionController_intervalId, "f")) {
         clearInterval(__classPrivateFieldGet(this, _TokenDetectionController_intervalId, "f"));
     }
 }, _TokenDetectionController_startPolling = function _TokenDetectionController_startPolling() {
     return __awaiter(this, void 0, void 0, function* () {
-        if (__classPrivateFieldGet(this, _TokenDetectionController_disabled, "f")) {
+        if (!this.isActive) {
             return;
         }
         __classPrivateFieldGet(this, _TokenDetectionController_instances, "m", _TokenDetectionController_stopPolling).call(this);
@@ -237,10 +273,91 @@ _TokenDetectionController_intervalId = new WeakMap(), _TokenDetectionController_
             yield this.detectTokens();
         }), this.getIntervalLength()), "f");
     });
-}, _TokenDetectionController_getCorrectChainId = function _TokenDetectionController_getCorrectChainId(networkClientId) {
-    var _a;
-    const { chainId } = (_a = this.messagingSystem.call('NetworkController:getNetworkConfigurationByNetworkClientId', networkClientId !== null && networkClientId !== void 0 ? networkClientId : __classPrivateFieldGet(this, _TokenDetectionController_networkClientId, "f"))) !== null && _a !== void 0 ? _a : {};
-    return chainId !== null && chainId !== void 0 ? chainId : __classPrivateFieldGet(this, _TokenDetectionController_chainId, "f");
+}, _TokenDetectionController_getCorrectChainIdAndNetworkClientId = function _TokenDetectionController_getCorrectChainIdAndNetworkClientId(networkClientId) {
+    if (networkClientId) {
+        const networkConfiguration = this.messagingSystem.call('NetworkController:getNetworkConfigurationByNetworkClientId', networkClientId);
+        if (networkConfiguration) {
+            return {
+                chainId: networkConfiguration.chainId,
+                networkClientId,
+            };
+        }
+    }
+    const { selectedNetworkClientId } = this.messagingSystem.call('NetworkController:getState');
+    const { configuration: { chainId }, } = this.messagingSystem.call('NetworkController:getNetworkClientById', selectedNetworkClientId);
+    return {
+        chainId,
+        networkClientId: selectedNetworkClientId,
+    };
+}, _TokenDetectionController_restartTokenDetection = function _TokenDetectionController_restartTokenDetection({ selectedAddress, networkClientId, } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield this.detectTokens({
+            networkClientId,
+            selectedAddress,
+        });
+        this.setIntervalLength(DEFAULT_INTERVAL);
+    });
+}, _TokenDetectionController_getSlicesOfTokensToDetect = function _TokenDetectionController_getSlicesOfTokensToDetect({ chainId, selectedAddress, }) {
+    const { allTokens, allDetectedTokens, allIgnoredTokens } = this.messagingSystem.call('TokensController:getState');
+    const [tokensAddresses, detectedTokensAddresses, ignoredTokensAddresses] = [
+        allTokens,
+        allDetectedTokens,
+        allIgnoredTokens,
+    ].map((tokens) => {
+        var _a, _b;
+        return ((_b = (_a = tokens[chainId]) === null || _a === void 0 ? void 0 : _a[selectedAddress]) !== null && _b !== void 0 ? _b : []).map((value) => typeof value === 'string' ? value : value.address);
+    });
+    const tokensToDetect = [];
+    for (const tokenAddress of Object.keys(__classPrivateFieldGet(this, _TokenDetectionController_tokenList, "f"))) {
+        if ([
+            tokensAddresses,
+            detectedTokensAddresses,
+            ignoredTokensAddresses,
+        ].every((addresses) => !addresses.find((address) => isEqualCaseInsensitive(address, tokenAddress)))) {
+            tokensToDetect.push(tokenAddress);
+        }
+    }
+    const slicesOfTokensToDetect = [];
+    for (let i = 0, size = 1000; i < tokensToDetect.length; i += size) {
+        slicesOfTokensToDetect.push(tokensToDetect.slice(i, i + size));
+    }
+    return slicesOfTokensToDetect;
+}, _TokenDetectionController_addDetectedTokens = function _TokenDetectionController_addDetectedTokens({ tokensSlice, selectedAddress, networkClientId, chainId, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, controller_utils_1.safelyExecute)(() => __awaiter(this, void 0, void 0, function* () {
+            const balances = yield __classPrivateFieldGet(this, _TokenDetectionController_getBalancesInSingleCall, "f").call(this, selectedAddress, tokensSlice, networkClientId);
+            const tokensWithBalance = [];
+            const eventTokensDetails = [];
+            for (const nonZeroTokenAddress of Object.keys(balances)) {
+                const { decimals, symbol, aggregators, iconUrl, name } = __classPrivateFieldGet(this, _TokenDetectionController_tokenList, "f")[nonZeroTokenAddress];
+                eventTokensDetails.push(`${symbol} - ${nonZeroTokenAddress}`);
+                tokensWithBalance.push({
+                    address: nonZeroTokenAddress,
+                    decimals,
+                    symbol,
+                    aggregators,
+                    image: iconUrl,
+                    isERC721: false,
+                    name,
+                });
+            }
+            if (tokensWithBalance.length) {
+                __classPrivateFieldGet(this, _TokenDetectionController_trackMetaMetricsEvent, "f").call(this, {
+                    event: 'Token Detected',
+                    category: 'Wallet',
+                    properties: {
+                        tokens: eventTokensDetails,
+                        token_standard: 'ERC20',
+                        asset_type: 'TOKEN',
+                    },
+                });
+                yield this.messagingSystem.call('TokensController:addDetectedTokens', tokensWithBalance, {
+                    selectedAddress,
+                    chainId,
+                });
+            }
+        }));
+    });
 };
 exports.default = TokenDetectionController;
 //# sourceMappingURL=TokenDetectionController.js.map