@metamask/assets-controllers 41.0.0 → 43.0.0

package/dist/TokenBalancesController.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"TokenBalancesController.mjs","sourceRoot":"","sources":["../src/TokenBalancesController.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AccountsControllerGetSelectedAccountAction } from '@metamask/accounts-controller';\nimport type {\n  RestrictedControllerMessenger,\n  ControllerGetStateAction,\n  ControllerStateChangeEvent,\n} from '@metamask/base-controller';\nimport { BaseController } from '@metamask/base-controller';\nimport { safelyExecute, toHex } from '@metamask/controller-utils';\n\nimport type { AssetsContractControllerGetERC20BalanceOfAction } from './AssetsContractController';\nimport type { Token } from './TokenRatesController';\nimport type { TokensControllerStateChangeEvent } from './TokensController';\n\nconst DEFAULT_INTERVAL = 180000;\n\nconst controllerName = 'TokenBalancesController';\n\nconst metadata = {\n  contractBalances: { persist: true, anonymous: false },\n};\n\n/**\n * Token balances controller options\n * @property interval - Polling interval used to fetch new token balances.\n * @property tokens - List of tokens to track balances for.\n * @property disabled - If set to true, all tracked tokens contract balances updates are blocked.\n */\ntype TokenBalancesControllerOptions = {\n  interval?: number;\n  tokens?: Token[];\n  disabled?: boolean;\n  messenger: TokenBalancesControllerMessenger;\n  state?: Partial<TokenBalancesControllerState>;\n};\n\n/**\n * Represents a mapping of hash token contract addresses to their balances.\n */\ntype ContractBalances = Record<string, string>;\n\n/**\n * Token balances controller state\n * @property contractBalances - Hash of token contract addresses to balances\n */\nexport type TokenBalancesControllerState = {\n  contractBalances: ContractBalances;\n};\n\nexport type TokenBalancesControllerGetStateAction = ControllerGetStateAction<\n  typeof controllerName,\n  TokenBalancesControllerState\n>;\n\nexport type TokenBalancesControllerActions =\n  TokenBalancesControllerGetStateAction;\n\nexport type AllowedActions =\n  | AccountsControllerGetSelectedAccountAction\n  | AssetsContractControllerGetERC20BalanceOfAction;\n\nexport type TokenBalancesControllerStateChangeEvent =\n  ControllerStateChangeEvent<\n    typeof controllerName,\n    TokenBalancesControllerState\n  >;\n\nexport type TokenBalancesControllerEvents =\n  TokenBalancesControllerStateChangeEvent;\n\nexport type AllowedEvents = TokensControllerStateChangeEvent;\n\nexport type TokenBalancesControllerMessenger = RestrictedControllerMessenger<\n  typeof controllerName,\n  TokenBalancesControllerActions | AllowedActions,\n  TokenBalancesControllerEvents | AllowedEvents,\n  AllowedActions['type'],\n  AllowedEvents['type']\n>;\n\n/**\n * Get the default TokenBalancesController state.\n *\n * @returns The default TokenBalancesController state.\n */\nexport function getDefaultTokenBalancesState(): TokenBalancesControllerState {\n  return {\n    contractBalances: {},\n  };\n}\n\n/**\n * Controller that passively polls on a set interval token balances\n * for tokens stored in the TokensController\n */\nexport class TokenBalancesController extends BaseController<\n  typeof controllerName,\n  TokenBalancesControllerState,\n  TokenBalancesControllerMessenger\n> {\n  #handle?: ReturnType<typeof setTimeout>;\n\n  #interval: number;\n\n  #tokens: Token[];\n\n  #disabled: boolean;\n\n  /**\n   * Construct a Token Balances Controller.\n   *\n   * @param options - The controller options.\n   * @param options.interval - Polling interval used to fetch new token balances.\n   * @param options.tokens - List of tokens to track balances for.\n   * @param options.disabled - If set to true, all tracked tokens contract balances updates are blocked.\n   * @param options.state - Initial state to set on this controller.\n   * @param options.messenger - The controller restricted messenger.\n   */\n  constructor({\n    interval = DEFAULT_INTERVAL,\n    tokens = [],\n    disabled = false,\n    messenger,\n    state = {},\n  }: TokenBalancesControllerOptions) {\n    super({\n      name: controllerName,\n      metadata,\n      messenger,\n      state: {\n        ...getDefaultTokenBalancesState(),\n        ...state,\n      },\n    });\n\n    this.#disabled = disabled;\n    this.#interval = interval;\n    this.#tokens = tokens;\n\n    this.messagingSystem.subscribe(\n      'TokensController:stateChange',\n      ({ tokens: newTokens, detectedTokens }) => {\n        this.#tokens = [...newTokens, ...detectedTokens];\n        // TODO: Either fix this lint violation or explain why it's necessary to ignore.\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        this.updateBalances();\n      },\n    );\n\n    // TODO: Either fix this lint violation or explain why it's necessary to ignore.\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.poll();\n  }\n\n  /**\n   * Allows controller to update tracked tokens contract balances.\n   */\n  enable() {\n    this.#disabled = false;\n  }\n\n  /**\n   * Blocks controller from updating tracked tokens contract balances.\n   */\n  disable() {\n    this.#disabled = true;\n  }\n\n  /**\n   * Starts a new polling interval.\n   *\n   * @param interval - Polling interval used to fetch new token balances.\n   */\n  async poll(interval?: number): Promise<void> {\n    if (interval) {\n      this.#interval = interval;\n    }\n\n    if (this.#handle) {\n      clearTimeout(this.#handle);\n    }\n\n    await safelyExecute(() => this.updateBalances());\n\n    this.#handle = setTimeout(() => {\n      // TODO: Either fix this lint violation or explain why it's necessary to ignore.\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this.poll(this.#interval);\n    }, this.#interval);\n  }\n\n  /**\n   * Updates balances for all tokens.\n   */\n  async updateBalances() {\n    if (this.#disabled) {\n      return;\n    }\n    const selectedInternalAccount = this.messagingSystem.call(\n      'AccountsController:getSelectedAccount',\n    );\n\n    const newContractBalances: ContractBalances = {};\n    for (const token of this.#tokens) {\n      const { address } = token;\n      try {\n        const balance = await this.messagingSystem.call(\n          'AssetsContractController:getERC20BalanceOf',\n          address,\n          selectedInternalAccount.address,\n        );\n        newContractBalances[address] = toHex(balance);\n        token.hasBalanceError = false;\n      } catch (error) {\n        newContractBalances[address] = toHex(0);\n        token.hasBalanceError = true;\n      }\n    }\n\n    this.update((state) => {\n      state.contractBalances = newContractBalances;\n    });\n  }\n}\n\nexport default TokenBalancesController;\n"]}
+{"version":3,"file":"TokenBalancesController.mjs","sourceRoot":"","sources":["../src/TokenBalancesController.ts"],"names":[],"mappings":";;;;;;;;;;;;AAMA,OAAO,EAAE,cAAc,EAAE,kCAAkC;AAC3D,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,mCAAmC;AAMlE,MAAM,gBAAgB,GAAG,MAAM,CAAC;AAEhC,MAAM,cAAc,GAAG,yBAAyB,CAAC;AAEjD,MAAM,QAAQ,GAAG;IACf,gBAAgB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE;CACtD,CAAC;AA4DF;;;;GAIG;AACH,MAAM,UAAU,4BAA4B;IAC1C,OAAO;QACL,gBAAgB,EAAE,EAAE;KACrB,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,OAAO,uBAAwB,SAAQ,cAI5C;IASC;;;;;;;;;OASG;IACH,YAAY,EACV,QAAQ,GAAG,gBAAgB,EAC3B,MAAM,GAAG,EAAE,EACX,QAAQ,GAAG,KAAK,EAChB,SAAS,EACT,KAAK,GAAG,EAAE,GACqB;QAC/B,KAAK,CAAC;YACJ,IAAI,EAAE,cAAc;YACpB,QAAQ;YACR,SAAS;YACT,KAAK,EAAE;gBACL,GAAG,4BAA4B,EAAE;gBACjC,GAAG,KAAK;aACT;SACF,CAAC,CAAC;QAjCL,kDAAwC;QAExC,oDAAkB;QAElB,kDAAiB;QAEjB,oDAAmB;QA6BjB,uBAAA,IAAI,qCAAa,QAAQ,MAAA,CAAC;QAC1B,uBAAA,IAAI,qCAAa,QAAQ,MAAA,CAAC;QAC1B,uBAAA,IAAI,mCAAW,MAAM,MAAA,CAAC;QAEtB,IAAI,CAAC,eAAe,CAAC,SAAS,CAC5B,8BAA8B,EAC9B,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,EAAE,EAAE;YACxC,uBAAA,IAAI,mCAAW,CAAC,GAAG,SAAS,EAAE,GAAG,cAAc,CAAC,MAAA,CAAC;YACjD,gFAAgF;YAChF,mEAAmE;YACnE,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,CAAC,CACF,CAAC;QAEF,gFAAgF;QAChF,mEAAmE;QACnE,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,uBAAA,IAAI,qCAAa,KAAK,MAAA,CAAC;IACzB,CAAC;IAED;;OAEG;IACH,OAAO;QACL,uBAAA,IAAI,qCAAa,IAAI,MAAA,CAAC;IACxB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,IAAI,CAAC,QAAiB;QAC1B,IAAI,QAAQ,EAAE;YACZ,uBAAA,IAAI,qCAAa,QAAQ,MAAA,CAAC;SAC3B;QAED,IAAI,uBAAA,IAAI,uCAAQ,EAAE;YAChB,YAAY,CAAC,uBAAA,IAAI,uCAAQ,CAAC,CAAC;SAC5B;QAED,MAAM,aAAa,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;QAEjD,uBAAA,IAAI,mCAAW,UAAU,CAAC,GAAG,EAAE;YAC7B,gFAAgF;YAChF,mEAAmE;YACnE,IAAI,CAAC,IAAI,CAAC,uBAAA,IAAI,yCAAU,CAAC,CAAC;QAC5B,CAAC,EAAE,uBAAA,IAAI,yCAAU,CAAC,MAAA,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,cAAc;QAClB,IAAI,uBAAA,IAAI,yCAAU,EAAE;YAClB,OAAO;SACR;QACD,MAAM,uBAAuB,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CACvD,uCAAuC,CACxC,CAAC;QAEF,MAAM,mBAAmB,GAAqB,EAAE,CAAC;QACjD,KAAK,MAAM,KAAK,IAAI,uBAAA,IAAI,uCAAQ,EAAE;YAChC,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;YAC1B,IAAI;gBACF,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAC7C,4CAA4C,EAC5C,OAAO,EACP,uBAAuB,CAAC,OAAO,CAChC,CAAC;gBACF,mBAAmB,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;gBAC9C,KAAK,CAAC,eAAe,GAAG,KAAK,CAAC;aAC/B;YAAC,OAAO,KAAK,EAAE;gBACd,mBAAmB,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;gBACxC,KAAK,CAAC,eAAe,GAAG,IAAI,CAAC;aAC9B;SACF;QAED,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE;YACpB,KAAK,CAAC,gBAAgB,GAAG,mBAAmB,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,UAAU;QACR,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE;YACf,OAAO,4BAA4B,EAAE,CAAC;QACxC,CAAC,CAAC,CAAC;IACL,CAAC;CACF;;AAED,eAAe,uBAAuB,CAAC","sourcesContent":["import type { AccountsControllerGetSelectedAccountAction } from '@metamask/accounts-controller';\nimport type {\n  RestrictedControllerMessenger,\n  ControllerGetStateAction,\n  ControllerStateChangeEvent,\n} from '@metamask/base-controller';\nimport { BaseController } from '@metamask/base-controller';\nimport { safelyExecute, toHex } from '@metamask/controller-utils';\n\nimport type { AssetsContractControllerGetERC20BalanceOfAction } from './AssetsContractController';\nimport type { Token } from './TokenRatesController';\nimport type { TokensControllerStateChangeEvent } from './TokensController';\n\nconst DEFAULT_INTERVAL = 180000;\n\nconst controllerName = 'TokenBalancesController';\n\nconst metadata = {\n  contractBalances: { persist: true, anonymous: false },\n};\n\n/**\n * Token balances controller options\n * @property interval - Polling interval used to fetch new token balances.\n * @property tokens - List of tokens to track balances for.\n * @property disabled - If set to true, all tracked tokens contract balances updates are blocked.\n */\ntype TokenBalancesControllerOptions = {\n  interval?: number;\n  tokens?: Token[];\n  disabled?: boolean;\n  messenger: TokenBalancesControllerMessenger;\n  state?: Partial<TokenBalancesControllerState>;\n};\n\n/**\n * Represents a mapping of hash token contract addresses to their balances.\n */\ntype ContractBalances = Record<string, string>;\n\n/**\n * Token balances controller state\n * @property contractBalances - Hash of token contract addresses to balances\n */\nexport type TokenBalancesControllerState = {\n  contractBalances: ContractBalances;\n};\n\nexport type TokenBalancesControllerGetStateAction = ControllerGetStateAction<\n  typeof controllerName,\n  TokenBalancesControllerState\n>;\n\nexport type TokenBalancesControllerActions =\n  TokenBalancesControllerGetStateAction;\n\nexport type AllowedActions =\n  | AccountsControllerGetSelectedAccountAction\n  | AssetsContractControllerGetERC20BalanceOfAction;\n\nexport type TokenBalancesControllerStateChangeEvent =\n  ControllerStateChangeEvent<\n    typeof controllerName,\n    TokenBalancesControllerState\n  >;\n\nexport type TokenBalancesControllerEvents =\n  TokenBalancesControllerStateChangeEvent;\n\nexport type AllowedEvents = TokensControllerStateChangeEvent;\n\nexport type TokenBalancesControllerMessenger = RestrictedControllerMessenger<\n  typeof controllerName,\n  TokenBalancesControllerActions | AllowedActions,\n  TokenBalancesControllerEvents | AllowedEvents,\n  AllowedActions['type'],\n  AllowedEvents['type']\n>;\n\n/**\n * Get the default TokenBalancesController state.\n *\n * @returns The default TokenBalancesController state.\n */\nexport function getDefaultTokenBalancesState(): TokenBalancesControllerState {\n  return {\n    contractBalances: {},\n  };\n}\n\n/**\n * Controller that passively polls on a set interval token balances\n * for tokens stored in the TokensController\n */\nexport class TokenBalancesController extends BaseController<\n  typeof controllerName,\n  TokenBalancesControllerState,\n  TokenBalancesControllerMessenger\n> {\n  #handle?: ReturnType<typeof setTimeout>;\n\n  #interval: number;\n\n  #tokens: Token[];\n\n  #disabled: boolean;\n\n  /**\n   * Construct a Token Balances Controller.\n   *\n   * @param options - The controller options.\n   * @param options.interval - Polling interval used to fetch new token balances.\n   * @param options.tokens - List of tokens to track balances for.\n   * @param options.disabled - If set to true, all tracked tokens contract balances updates are blocked.\n   * @param options.state - Initial state to set on this controller.\n   * @param options.messenger - The controller restricted messenger.\n   */\n  constructor({\n    interval = DEFAULT_INTERVAL,\n    tokens = [],\n    disabled = false,\n    messenger,\n    state = {},\n  }: TokenBalancesControllerOptions) {\n    super({\n      name: controllerName,\n      metadata,\n      messenger,\n      state: {\n        ...getDefaultTokenBalancesState(),\n        ...state,\n      },\n    });\n\n    this.#disabled = disabled;\n    this.#interval = interval;\n    this.#tokens = tokens;\n\n    this.messagingSystem.subscribe(\n      'TokensController:stateChange',\n      ({ tokens: newTokens, detectedTokens }) => {\n        this.#tokens = [...newTokens, ...detectedTokens];\n        // TODO: Either fix this lint violation or explain why it's necessary to ignore.\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        this.updateBalances();\n      },\n    );\n\n    // TODO: Either fix this lint violation or explain why it's necessary to ignore.\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.poll();\n  }\n\n  /**\n   * Allows controller to update tracked tokens contract balances.\n   */\n  enable() {\n    this.#disabled = false;\n  }\n\n  /**\n   * Blocks controller from updating tracked tokens contract balances.\n   */\n  disable() {\n    this.#disabled = true;\n  }\n\n  /**\n   * Starts a new polling interval.\n   *\n   * @param interval - Polling interval used to fetch new token balances.\n   */\n  async poll(interval?: number): Promise<void> {\n    if (interval) {\n      this.#interval = interval;\n    }\n\n    if (this.#handle) {\n      clearTimeout(this.#handle);\n    }\n\n    await safelyExecute(() => this.updateBalances());\n\n    this.#handle = setTimeout(() => {\n      // TODO: Either fix this lint violation or explain why it's necessary to ignore.\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this.poll(this.#interval);\n    }, this.#interval);\n  }\n\n  /**\n   * Updates balances for all tokens.\n   */\n  async updateBalances() {\n    if (this.#disabled) {\n      return;\n    }\n    const selectedInternalAccount = this.messagingSystem.call(\n      'AccountsController:getSelectedAccount',\n    );\n\n    const newContractBalances: ContractBalances = {};\n    for (const token of this.#tokens) {\n      const { address } = token;\n      try {\n        const balance = await this.messagingSystem.call(\n          'AssetsContractController:getERC20BalanceOf',\n          address,\n          selectedInternalAccount.address,\n        );\n        newContractBalances[address] = toHex(balance);\n        token.hasBalanceError = false;\n      } catch (error) {\n        newContractBalances[address] = toHex(0);\n        token.hasBalanceError = true;\n      }\n    }\n\n    this.update((state) => {\n      state.contractBalances = newContractBalances;\n    });\n  }\n\n  /**\n   * Reset the controller state to the default state.\n   */\n  resetState() {\n    this.update(() => {\n      return getDefaultTokenBalancesState();\n    });\n  }\n}\n\nexport default TokenBalancesController;\n"]}

package/dist/TokenDetectionController.cjs

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