@metamask/assets-controllers 30.0.0 → 32.0.0

package/dist/{chunk-7MMEHAKG.mjs → chunk-73F3SN5O.mjs}

@@ -7,16 +7,22 @@ import {
 import {
   TOKEN_METADATA_NO_SUPPORT_ERROR,
   fetchTokenMetadata
-} from "./chunk-Z3OQU4XW.mjs";
+} from "./chunk-5W5OO2Q5.mjs";
 import {
   formatAggregatorNames,
   formatIconUrlWithProxy
 } from "./chunk-Q5JRBGWO.mjs";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "./chunk-XUI43LEZ.mjs";
 
 // src/TokensController.ts
 import { Contract } from "@ethersproject/contracts";
 import { Web3Provider } from "@ethersproject/providers";
-import { BaseControllerV1 } from "@metamask/base-controller";
+import { BaseController } from "@metamask/base-controller";
 import contractsMap from "@metamask/contract-metadata";
 import {
   toChecksumHexAddress,
@@ -32,8 +38,33 @@ import {
 import { abiERC721 } from "@metamask/metamask-eth-abis";
 import { rpcErrors } from "@metamask/rpc-errors";
 import { Mutex } from "async-mutex";
-import { EventEmitter } from "events";
 import { v1 as random } from "uuid";
+var metadata = {
+  tokens: {
+    persist: true,
+    anonymous: false
+  },
+  ignoredTokens: {
+    persist: true,
+    anonymous: false
+  },
+  detectedTokens: {
+    persist: true,
+    anonymous: false
+  },
+  allTokens: {
+    persist: true,
+    anonymous: false
+  },
+  allIgnoredTokens: {
+    persist: true,
+    anonymous: false
+  },
+  allDetectedTokens: {
+    persist: true,
+    anonymous: false
+  }
+};
 var controllerName = "TokensController";
 var getDefaultTokensState = () => {
   return {
@@ -45,109 +76,117 @@ var getDefaultTokensState = () => {
     allDetectedTokens: {}
   };
 };
-var TokensController = class extends BaseControllerV1 {
+var _mutex, _chainId, _selectedAddress, _provider, _abortController, _onNetworkDidChange, onNetworkDidChange_fn, _onPreferenceControllerStateChange, onPreferenceControllerStateChange_fn, _fetchTokenMetadata, fetchTokenMetadata_fn, _updateTokensAttribute, updateTokensAttribute_fn, _detectIsERC721, detectIsERC721_fn, _getProvider, getProvider_fn, _createEthersContract, createEthersContract_fn, _generateRandomId, generateRandomId_fn, _getNewAllTokensState, getNewAllTokensState_fn, _requestApproval, requestApproval_fn;
+var TokensController = class extends BaseController {
   /**
-   * Creates a TokensController instance.
-   *
-   * @param options - The controller options.
+   * Tokens controller options
+   * @param options - Constructor options.
    * @param options.chainId - The chain ID of the current network.
-   * @param options.config - Initial options used to configure this controller.
+   * @param options.selectedAddress - Vault selected address
+   * @param options.provider - Network provider.
    * @param options.state - Initial state to set on this controller.
    * @param options.messenger - The controller messenger.
    */
   constructor({
     chainId: initialChainId,
-    config,
+    selectedAddress,
+    provider,
     state,
     messenger
   }) {
-    super(config, state);
-    this.mutex = new Mutex();
+    super({
+      name: controllerName,
+      metadata,
+      messenger,
+      state: {
+        ...getDefaultTokensState(),
+        ...state
+      }
+    });
     /**
-     * EventEmitter instance used to listen to specific EIP747 events
+     * Handles the event when the network changes.
+     *
+     * @param networkState - The changed network state.
+     * @param networkState.providerConfig - RPC URL and network name provider settings of the currently connected network
      */
-    this.hub = new EventEmitter();
+    __privateAdd(this, _onNetworkDidChange);
     /**
-     * Name of this controller used during composition
+     * Handles the state change of the preference controller.
+     * @param preferencesState - The new state of the preference controller.
+     * @param preferencesState.selectedAddress - The current selected address of the preference controller.
      */
-    this.name = "TokensController";
-    this.defaultConfig = {
-      selectedAddress: "",
-      chainId: initialChainId,
-      provider: void 0,
-      ...config
-    };
-    this.defaultState = {
-      ...getDefaultTokensState(),
-      ...state
-    };
-    this.initialize();
-    this.abortController = new AbortController();
-    this.messagingSystem = messenger;
+    __privateAdd(this, _onPreferenceControllerStateChange);
+    /**
+     * Fetch metadata for a token.
+     *
+     * @param tokenAddress - The address of the token.
+     * @returns The token metadata.
+     */
+    __privateAdd(this, _fetchTokenMetadata);
+    /**
+     * This is a function that updates the tokens name for the tokens name if it is not defined.
+     *
+     * @param tokenList - Represents the fetched token list from service API
+     * @param tokenAttribute - Represents the token attribute that we want to update on the token list
+     */
+    __privateAdd(this, _updateTokensAttribute);
+    /**
+     * Detects whether or not a token is ERC-721 compatible.
+     *
+     * @param tokenAddress - The token contract address.
+     * @param networkClientId - Optional network client ID to fetch contract info with.
+     * @returns A boolean indicating whether the token address passed in supports the EIP-721
+     * interface.
+     */
+    __privateAdd(this, _detectIsERC721);
+    __privateAdd(this, _getProvider);
+    __privateAdd(this, _createEthersContract);
+    __privateAdd(this, _generateRandomId);
+    /**
+     * Takes a new tokens and ignoredTokens array for the current network/account combination
+     * and returns new allTokens and allIgnoredTokens state to update to.
+     *
+     * @param params - Object that holds token params.
+     * @param params.newTokens - The new tokens to set for the current network and selected account.
+     * @param params.newIgnoredTokens - The new ignored tokens to set for the current network and selected account.
+     * @param params.newDetectedTokens - The new detected tokens to set for the current network and selected account.
+     * @param params.interactingAddress - The account address to use to store the tokens.
+     * @param params.interactingChainId - The chainId to use to store the tokens.
+     * @returns The updated `allTokens` and `allIgnoredTokens` state.
+     */
+    __privateAdd(this, _getNewAllTokensState);
+    __privateAdd(this, _requestApproval);
+    __privateAdd(this, _mutex, new Mutex());
+    __privateAdd(this, _chainId, void 0);
+    __privateAdd(this, _selectedAddress, void 0);
+    __privateAdd(this, _provider, void 0);
+    __privateAdd(this, _abortController, void 0);
+    __privateSet(this, _chainId, initialChainId);
+    __privateSet(this, _provider, provider);
+    __privateSet(this, _selectedAddress, selectedAddress);
+    __privateSet(this, _abortController, new AbortController());
     this.messagingSystem.registerActionHandler(
       `${controllerName}:addDetectedTokens`,
       this.addDetectedTokens.bind(this)
     );
     this.messagingSystem.subscribe(
       "PreferencesController:stateChange",
-      ({ selectedAddress }) => {
-        const { allTokens, allIgnoredTokens, allDetectedTokens } = this.state;
-        const { chainId } = this.config;
-        this.configure({ selectedAddress });
-        this.update({
-          tokens: allTokens[chainId]?.[selectedAddress] ?? [],
-          ignoredTokens: allIgnoredTokens[chainId]?.[selectedAddress] ?? [],
-          detectedTokens: allDetectedTokens[chainId]?.[selectedAddress] ?? []
-        });
-      }
+      __privateMethod(this, _onPreferenceControllerStateChange, onPreferenceControllerStateChange_fn).bind(this)
     );
     this.messagingSystem.subscribe(
       "NetworkController:networkDidChange",
-      ({ providerConfig }) => {
-        const { allTokens, allIgnoredTokens, allDetectedTokens } = this.state;
-        const { selectedAddress } = this.config;
-        const { chainId } = providerConfig;
-        this.abortController.abort();
-        this.abortController = new AbortController();
-        this.configure({ chainId });
-        this.update({
-          tokens: allTokens[chainId]?.[selectedAddress] || [],
-          ignoredTokens: allIgnoredTokens[chainId]?.[selectedAddress] || [],
-          detectedTokens: allDetectedTokens[chainId]?.[selectedAddress] || []
-        });
-      }
+      __privateMethod(this, _onNetworkDidChange, onNetworkDidChange_fn).bind(this)
     );
     this.messagingSystem.subscribe(
       "TokenListController:stateChange",
       ({ tokenList }) => {
         const { tokens } = this.state;
         if (tokens.length && !tokens[0].name) {
-          this.updateTokensAttribute(tokenList, "name");
+          __privateMethod(this, _updateTokensAttribute, updateTokensAttribute_fn).call(this, tokenList, "name");
         }
       }
     );
   }
-  /**
-   * Fetch metadata for a token.
-   *
-   * @param tokenAddress - The address of the token.
-   * @returns The token metadata.
-   */
-  async fetchTokenMetadata(tokenAddress) {
-    try {
-      const token = await fetchTokenMetadata(
-        this.config.chainId,
-        tokenAddress,
-        this.abortController.signal
-      );
-      return token;
-    } catch (error) {
-      if (error instanceof Error && error.message.includes(TOKEN_METADATA_NO_SUPPORT_ERROR)) {
-        return void 0;
-      }
-      throw error;
-    }
-  }
   /**
    * Adds a token to the stored token list.
    *
@@ -170,8 +209,9 @@ var TokensController = class extends BaseControllerV1 {
     interactingAddress,
     networkClientId
   }) {
-    const { chainId, selectedAddress } = this.config;
-    const releaseLock = await this.mutex.acquire();
+    const chainId = __privateGet(this, _chainId);
+    const selectedAddress = __privateGet(this, _selectedAddress);
+    const releaseLock = await __privateGet(this, _mutex).acquire();
     const { allTokens, allIgnoredTokens, allDetectedTokens } = this.state;
     let currentChainId = chainId;
     if (networkClientId) {
@@ -189,11 +229,11 @@ var TokensController = class extends BaseControllerV1 {
       const detectedTokens = allDetectedTokens[currentChainId]?.[accountAddress] || [];
       const newTokens = [...tokens];
       const [isERC721, tokenMetadata] = await Promise.all([
-        this._detectIsERC721(address, networkClientId),
+        __privateMethod(this, _detectIsERC721, detectIsERC721_fn).call(this, address, networkClientId),
         // TODO parameterize the token metadata fetch by networkClientId
-        this.fetchTokenMetadata(address)
+        __privateMethod(this, _fetchTokenMetadata, fetchTokenMetadata_fn).call(this, address)
       ]);
-      if (!networkClientId && currentChainId !== this.config.chainId) {
+      if (!networkClientId && currentChainId !== __privateGet(this, _chainId)) {
         throw new Error(
           "TokensController Error: Switched networks while adding token"
         );
@@ -224,7 +264,7 @@ var TokensController = class extends BaseControllerV1 {
       const newDetectedTokens = detectedTokens.filter(
         (token) => token.address.toLowerCase() !== address.toLowerCase()
       );
-      const { newAllTokens, newAllIgnoredTokens, newAllDetectedTokens } = this._getNewAllTokensState({
+      const { newAllTokens, newAllIgnoredTokens, newAllDetectedTokens } = __privateMethod(this, _getNewAllTokensState, getNewAllTokensState_fn).call(this, {
         newTokens,
         newIgnoredTokens,
         newDetectedTokens,
@@ -244,7 +284,9 @@ var TokensController = class extends BaseControllerV1 {
           detectedTokens: newDetectedTokens
         };
       }
-      this.update(newState);
+      this.update((state) => {
+        Object.assign(state, newState);
+      });
       return newTokens;
     } finally {
       releaseLock();
@@ -257,7 +299,7 @@ var TokensController = class extends BaseControllerV1 {
    * @param networkClientId - Optional network client ID used to determine interacting chain ID.
    */
   async addTokens(tokensToImport, networkClientId) {
-    const releaseLock = await this.mutex.acquire();
+    const releaseLock = await __privateGet(this, _mutex).acquire();
     const { tokens, detectedTokens, ignoredTokens } = this.state;
     const importedTokensMap = {};
     const newTokensMap = tokens.reduce((output, current) => {
@@ -294,19 +336,19 @@ var TokensController = class extends BaseControllerV1 {
           networkClientId
         ).configuration.chainId;
       }
-      const { newAllTokens, newAllDetectedTokens, newAllIgnoredTokens } = this._getNewAllTokensState({
+      const { newAllTokens, newAllDetectedTokens, newAllIgnoredTokens } = __privateMethod(this, _getNewAllTokensState, getNewAllTokensState_fn).call(this, {
         newTokens,
         newDetectedTokens,
         newIgnoredTokens,
         interactingChainId
       });
-      this.update({
-        tokens: newTokens,
-        allTokens: newAllTokens,
-        detectedTokens: newDetectedTokens,
-        allDetectedTokens: newAllDetectedTokens,
-        ignoredTokens: newIgnoredTokens,
-        allIgnoredTokens: newAllIgnoredTokens
+      this.update((state) => {
+        state.tokens = newTokens;
+        state.allTokens = newAllTokens;
+        state.detectedTokens = newDetectedTokens;
+        state.allDetectedTokens = newAllDetectedTokens;
+        state.ignoredTokens = newIgnoredTokens;
+        state.allIgnoredTokens = newAllIgnoredTokens;
       });
     } finally {
       releaseLock();
@@ -333,18 +375,18 @@ var TokensController = class extends BaseControllerV1 {
     const newTokens = tokens.filter(
       (token) => !ignoredTokensMap[token.address.toLowerCase()]
     );
-    const { newAllIgnoredTokens, newAllDetectedTokens, newAllTokens } = this._getNewAllTokensState({
+    const { newAllIgnoredTokens, newAllDetectedTokens, newAllTokens } = __privateMethod(this, _getNewAllTokensState, getNewAllTokensState_fn).call(this, {
       newIgnoredTokens,
       newDetectedTokens,
       newTokens
     });
-    this.update({
-      ignoredTokens: newIgnoredTokens,
-      tokens: newTokens,
-      detectedTokens: newDetectedTokens,
-      allIgnoredTokens: newAllIgnoredTokens,
-      allDetectedTokens: newAllDetectedTokens,
-      allTokens: newAllTokens
+    this.update((state) => {
+      state.ignoredTokens = newIgnoredTokens;
+      state.tokens = newTokens;
+      state.detectedTokens = newDetectedTokens;
+      state.allIgnoredTokens = newAllIgnoredTokens;
+      state.allDetectedTokens = newAllDetectedTokens;
+      state.allTokens = newAllTokens;
     });
   }
   /**
@@ -356,9 +398,9 @@ var TokensController = class extends BaseControllerV1 {
    * @param detectionDetails.chainId - the chainId on which the incomingDetectedTokens were detected.
    */
   async addDetectedTokens(incomingDetectedTokens, detectionDetails) {
-    const releaseLock = await this.mutex.acquire();
-    const chainId = detectionDetails?.chainId ?? this.config.chainId;
-    const accountAddress = detectionDetails?.selectedAddress ?? this.config.selectedAddress;
+    const releaseLock = await __privateGet(this, _mutex).acquire();
+    const chainId = detectionDetails?.chainId ?? __privateGet(this, _chainId);
+    const accountAddress = detectionDetails?.selectedAddress ?? __privateGet(this, _selectedAddress);
     const { allTokens, allDetectedTokens, allIgnoredTokens } = this.state;
     let newTokens = [...allTokens?.[chainId]?.[accountAddress] ?? []];
     let newDetectedTokens = [
@@ -404,22 +446,19 @@ var TokensController = class extends BaseControllerV1 {
           }
         }
       });
-      const { newAllTokens, newAllDetectedTokens } = this._getNewAllTokensState(
-        {
-          newTokens,
-          newDetectedTokens,
-          interactingAddress: accountAddress,
-          interactingChainId: chainId
-        }
-      );
-      const { chainId: currentChain, selectedAddress: currentAddress } = this.config;
-      newTokens = newAllTokens?.[currentChain]?.[currentAddress] || [];
-      newDetectedTokens = newAllDetectedTokens?.[currentChain]?.[currentAddress] || [];
-      this.update({
-        tokens: newTokens,
-        allTokens: newAllTokens,
-        detectedTokens: newDetectedTokens,
-        allDetectedTokens: newAllDetectedTokens
+      const { newAllTokens, newAllDetectedTokens } = __privateMethod(this, _getNewAllTokensState, getNewAllTokensState_fn).call(this, {
+        newTokens,
+        newDetectedTokens,
+        interactingAddress: accountAddress,
+        interactingChainId: chainId
+      });
+      newTokens = newAllTokens?.[__privateGet(this, _chainId)]?.[__privateGet(this, _selectedAddress)] || [];
+      newDetectedTokens = newAllDetectedTokens?.[__privateGet(this, _chainId)]?.[__privateGet(this, _selectedAddress)] || [];
+      this.update((state) => {
+        state.tokens = newTokens;
+        state.allTokens = newAllTokens;
+        state.detectedTokens = newDetectedTokens;
+        state.allDetectedTokens = newAllDetectedTokens;
       });
     } finally {
       releaseLock();
@@ -433,71 +472,17 @@ var TokensController = class extends BaseControllerV1 {
    * @returns The new token object with the added isERC721 field.
    */
   async updateTokenType(tokenAddress) {
-    const isERC721 = await this._detectIsERC721(tokenAddress);
-    const { tokens } = this.state;
+    const isERC721 = await __privateMethod(this, _detectIsERC721, detectIsERC721_fn).call(this, tokenAddress);
+    const tokens = [...this.state.tokens];
     const tokenIndex = tokens.findIndex((token) => {
       return token.address.toLowerCase() === tokenAddress.toLowerCase();
     });
-    tokens[tokenIndex].isERC721 = isERC721;
-    this.update({ tokens });
-    return tokens[tokenIndex];
-  }
-  /**
-   * This is a function that updates the tokens name for the tokens name if it is not defined.
-   *
-   * @param tokenList - Represents the fetched token list from service API
-   * @param tokenAttribute - Represents the token attribute that we want to update on the token list
-   */
-  updateTokensAttribute(tokenList, tokenAttribute) {
-    const { tokens } = this.state;
-    const newTokens = tokens.map((token) => {
-      const newToken = tokenList[token.address.toLowerCase()];
-      return !token[tokenAttribute] && newToken?.[tokenAttribute] ? { ...token, [tokenAttribute]: newToken[tokenAttribute] } : { ...token };
+    const updatedToken = { ...tokens[tokenIndex], isERC721 };
+    tokens[tokenIndex] = updatedToken;
+    this.update((state) => {
+      state.tokens = tokens;
     });
-    this.update({ tokens: newTokens });
-  }
-  /**
-   * Detects whether or not a token is ERC-721 compatible.
-   *
-   * @param tokenAddress - The token contract address.
-   * @param networkClientId - Optional network client ID to fetch contract info with.
-   * @returns A boolean indicating whether the token address passed in supports the EIP-721
-   * interface.
-   */
-  async _detectIsERC721(tokenAddress, networkClientId) {
-    const checksumAddress = toChecksumHexAddress(tokenAddress);
-    if (contractsMap[checksumAddress]?.erc721 === true) {
-      return Promise.resolve(true);
-    } else if (contractsMap[checksumAddress]?.erc20 === true) {
-      return Promise.resolve(false);
-    }
-    const tokenContract = this._createEthersContract(
-      tokenAddress,
-      abiERC721,
-      networkClientId
-    );
-    try {
-      return await tokenContract.supportsInterface(ERC721_INTERFACE_ID);
-    } catch (error) {
-      return false;
-    }
-  }
-  _getProvider(networkClientId) {
-    return new Web3Provider(
-      // @ts-expect-error TODO: remove this annotation once the `Eip1193Provider` class is released
-      networkClientId ? this.messagingSystem.call(
-        "NetworkController:getNetworkClientById",
-        networkClientId
-      ).provider : this.config.provider
-    );
-  }
-  _createEthersContract(tokenAddress, abi, networkClientId) {
-    const web3provider = this._getProvider(networkClientId);
-    const tokenContract = new Contract(tokenAddress, abi, web3provider);
-    return tokenContract;
-  }
-  _generateRandomId() {
-    return random();
+    return updatedToken;
   }
   /**
    * Adds a new suggestedAsset to the list of watched assets.
@@ -525,12 +510,12 @@ var TokensController = class extends BaseControllerV1 {
     if (!isValidHexAddress(asset.address)) {
       throw rpcErrors.invalidParams(`Invalid address "${asset.address}"`);
     }
-    if (await this._detectIsERC721(asset.address, networkClientId)) {
+    if (await __privateMethod(this, _detectIsERC721, detectIsERC721_fn).call(this, asset.address, networkClientId)) {
       throw rpcErrors.invalidParams(
         `Contract ${asset.address} must match type ${type}, but was detected as ${ERC721}`
       );
     }
-    const provider = this._getProvider(networkClientId);
+    const provider = __privateMethod(this, _getProvider, getProvider_fn).call(this, networkClientId);
     const isErc1155 = await safelyExecute(
       () => new ERC1155Standard(provider).contractSupportsBase1155Interface(
         asset.address
@@ -587,12 +572,12 @@ var TokensController = class extends BaseControllerV1 {
     asset.decimals = decimalsNum;
     const suggestedAssetMeta = {
       asset,
-      id: this._generateRandomId(),
+      id: __privateMethod(this, _generateRandomId, generateRandomId_fn).call(this),
       time: Date.now(),
       type,
-      interactingAddress: interactingAddress || this.config.selectedAddress
+      interactingAddress: interactingAddress || __privateGet(this, _selectedAddress)
     };
-    await this._requestApproval(suggestedAssetMeta);
+    await __privateMethod(this, _requestApproval, requestApproval_fn).call(this, suggestedAssetMeta);
     const { address, symbol, decimals, name, image } = asset;
     await this.addToken({
       address,
@@ -604,95 +589,177 @@ var TokensController = class extends BaseControllerV1 {
       networkClientId
     });
   }
-  /**
-   * Takes a new tokens and ignoredTokens array for the current network/account combination
-   * and returns new allTokens and allIgnoredTokens state to update to.
-   *
-   * @param params - Object that holds token params.
-   * @param params.newTokens - The new tokens to set for the current network and selected account.
-   * @param params.newIgnoredTokens - The new ignored tokens to set for the current network and selected account.
-   * @param params.newDetectedTokens - The new detected tokens to set for the current network and selected account.
-   * @param params.interactingAddress - The account address to use to store the tokens.
-   * @param params.interactingChainId - The chainId to use to store the tokens.
-   * @returns The updated `allTokens` and `allIgnoredTokens` state.
-   */
-  _getNewAllTokensState(params) {
-    const {
-      newTokens,
-      newIgnoredTokens,
-      newDetectedTokens,
-      interactingAddress,
-      interactingChainId
-    } = params;
-    const { allTokens, allIgnoredTokens, allDetectedTokens } = this.state;
-    const { chainId, selectedAddress } = this.config;
-    const userAddressToAddTokens = interactingAddress ?? selectedAddress;
-    const chainIdToAddTokens = interactingChainId ?? chainId;
-    let newAllTokens = allTokens;
-    if (newTokens?.length || newTokens && allTokens && allTokens[chainIdToAddTokens] && allTokens[chainIdToAddTokens][userAddressToAddTokens]) {
-      const networkTokens = allTokens[chainIdToAddTokens];
-      const newNetworkTokens = {
-        ...networkTokens,
-        ...{ [userAddressToAddTokens]: newTokens }
-      };
-      newAllTokens = {
-        ...allTokens,
-        ...{ [chainIdToAddTokens]: newNetworkTokens }
-      };
-    }
-    let newAllIgnoredTokens = allIgnoredTokens;
-    if (newIgnoredTokens?.length || newIgnoredTokens && allIgnoredTokens && allIgnoredTokens[chainIdToAddTokens] && allIgnoredTokens[chainIdToAddTokens][userAddressToAddTokens]) {
-      const networkIgnoredTokens = allIgnoredTokens[chainIdToAddTokens];
-      const newIgnoredNetworkTokens = {
-        ...networkIgnoredTokens,
-        ...{ [userAddressToAddTokens]: newIgnoredTokens }
-      };
-      newAllIgnoredTokens = {
-        ...allIgnoredTokens,
-        ...{ [chainIdToAddTokens]: newIgnoredNetworkTokens }
-      };
-    }
-    let newAllDetectedTokens = allDetectedTokens;
-    if (newDetectedTokens?.length || newDetectedTokens && allDetectedTokens && allDetectedTokens[chainIdToAddTokens] && allDetectedTokens[chainIdToAddTokens][userAddressToAddTokens]) {
-      const networkDetectedTokens = allDetectedTokens[chainIdToAddTokens];
-      const newDetectedNetworkTokens = {
-        ...networkDetectedTokens,
-        ...{ [userAddressToAddTokens]: newDetectedTokens }
-      };
-      newAllDetectedTokens = {
-        ...allDetectedTokens,
-        ...{ [chainIdToAddTokens]: newDetectedNetworkTokens }
-      };
-    }
-    return { newAllTokens, newAllIgnoredTokens, newAllDetectedTokens };
-  }
   /**
    * Removes all tokens from the ignored list.
    */
   clearIgnoredTokens() {
-    this.update({ ignoredTokens: [], allIgnoredTokens: {} });
+    this.update((state) => {
+      state.ignoredTokens = [];
+      state.allIgnoredTokens = {};
+    });
   }
-  async _requestApproval(suggestedAssetMeta) {
-    return this.messagingSystem.call(
-      "ApprovalController:addRequest",
-      {
-        id: suggestedAssetMeta.id,
-        origin: ORIGIN_METAMASK,
-        type: ApprovalType.WatchAsset,
-        requestData: {
-          id: suggestedAssetMeta.id,
-          interactingAddress: suggestedAssetMeta.interactingAddress,
-          asset: {
-            address: suggestedAssetMeta.asset.address,
-            decimals: suggestedAssetMeta.asset.decimals,
-            symbol: suggestedAssetMeta.asset.symbol,
-            image: suggestedAssetMeta.asset.image || null
-          }
-        }
-      },
-      true
+};
+_mutex = new WeakMap();
+_chainId = new WeakMap();
+_selectedAddress = new WeakMap();
+_provider = new WeakMap();
+_abortController = new WeakMap();
+_onNetworkDidChange = new WeakSet();
+onNetworkDidChange_fn = function({ providerConfig }) {
+  const { allTokens, allIgnoredTokens, allDetectedTokens } = this.state;
+  const { chainId } = providerConfig;
+  __privateGet(this, _abortController).abort();
+  __privateSet(this, _abortController, new AbortController());
+  __privateSet(this, _chainId, chainId);
+  this.update((state) => {
+    state.tokens = allTokens[chainId]?.[__privateGet(this, _selectedAddress)] || [];
+    state.ignoredTokens = allIgnoredTokens[chainId]?.[__privateGet(this, _selectedAddress)] || [];
+    state.detectedTokens = allDetectedTokens[chainId]?.[__privateGet(this, _selectedAddress)] || [];
+  });
+};
+_onPreferenceControllerStateChange = new WeakSet();
+onPreferenceControllerStateChange_fn = function({ selectedAddress }) {
+  const { allTokens, allIgnoredTokens, allDetectedTokens } = this.state;
+  __privateSet(this, _selectedAddress, selectedAddress);
+  this.update((state) => {
+    state.tokens = allTokens[__privateGet(this, _chainId)]?.[selectedAddress] ?? [];
+    state.ignoredTokens = allIgnoredTokens[__privateGet(this, _chainId)]?.[selectedAddress] ?? [];
+    state.detectedTokens = allDetectedTokens[__privateGet(this, _chainId)]?.[selectedAddress] ?? [];
+  });
+};
+_fetchTokenMetadata = new WeakSet();
+fetchTokenMetadata_fn = async function(tokenAddress) {
+  try {
+    const token = await fetchTokenMetadata(
+      __privateGet(this, _chainId),
+      tokenAddress,
+      __privateGet(this, _abortController).signal
     );
+    return token;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes(TOKEN_METADATA_NO_SUPPORT_ERROR)) {
+      return void 0;
+    }
+    throw error;
+  }
+};
+_updateTokensAttribute = new WeakSet();
+updateTokensAttribute_fn = function(tokenList, tokenAttribute) {
+  const { tokens } = this.state;
+  const newTokens = tokens.map((token) => {
+    const newToken = tokenList[token.address.toLowerCase()];
+    return !token[tokenAttribute] && newToken?.[tokenAttribute] ? { ...token, [tokenAttribute]: newToken[tokenAttribute] } : { ...token };
+  });
+  this.update((state) => {
+    state.tokens = newTokens;
+  });
+};
+_detectIsERC721 = new WeakSet();
+detectIsERC721_fn = async function(tokenAddress, networkClientId) {
+  const checksumAddress = toChecksumHexAddress(tokenAddress);
+  if (contractsMap[checksumAddress]?.erc721 === true) {
+    return Promise.resolve(true);
+  } else if (contractsMap[checksumAddress]?.erc20 === true) {
+    return Promise.resolve(false);
+  }
+  const tokenContract = __privateMethod(this, _createEthersContract, createEthersContract_fn).call(this, tokenAddress, abiERC721, networkClientId);
+  try {
+    return await tokenContract.supportsInterface(ERC721_INTERFACE_ID);
+  } catch (error) {
+    return false;
+  }
+};
+_getProvider = new WeakSet();
+getProvider_fn = function(networkClientId) {
+  return new Web3Provider(
+    // @ts-expect-error TODO: remove this annotation once the `Eip1193Provider` class is released
+    networkClientId ? this.messagingSystem.call(
+      "NetworkController:getNetworkClientById",
+      networkClientId
+    ).provider : __privateGet(this, _provider)
+  );
+};
+_createEthersContract = new WeakSet();
+createEthersContract_fn = function(tokenAddress, abi, networkClientId) {
+  const web3provider = __privateMethod(this, _getProvider, getProvider_fn).call(this, networkClientId);
+  const tokenContract = new Contract(tokenAddress, abi, web3provider);
+  return tokenContract;
+};
+_generateRandomId = new WeakSet();
+generateRandomId_fn = function() {
+  return random();
+};
+_getNewAllTokensState = new WeakSet();
+getNewAllTokensState_fn = function(params) {
+  const {
+    newTokens,
+    newIgnoredTokens,
+    newDetectedTokens,
+    interactingAddress,
+    interactingChainId
+  } = params;
+  const { allTokens, allIgnoredTokens, allDetectedTokens } = this.state;
+  const userAddressToAddTokens = interactingAddress ?? __privateGet(this, _selectedAddress);
+  const chainIdToAddTokens = interactingChainId ?? __privateGet(this, _chainId);
+  let newAllTokens = allTokens;
+  if (newTokens?.length || newTokens && allTokens && allTokens[chainIdToAddTokens] && allTokens[chainIdToAddTokens][userAddressToAddTokens]) {
+    const networkTokens = allTokens[chainIdToAddTokens];
+    const newNetworkTokens = {
+      ...networkTokens,
+      ...{ [userAddressToAddTokens]: newTokens }
+    };
+    newAllTokens = {
+      ...allTokens,
+      ...{ [chainIdToAddTokens]: newNetworkTokens }
+    };
   }
+  let newAllIgnoredTokens = allIgnoredTokens;
+  if (newIgnoredTokens?.length || newIgnoredTokens && allIgnoredTokens && allIgnoredTokens[chainIdToAddTokens] && allIgnoredTokens[chainIdToAddTokens][userAddressToAddTokens]) {
+    const networkIgnoredTokens = allIgnoredTokens[chainIdToAddTokens];
+    const newIgnoredNetworkTokens = {
+      ...networkIgnoredTokens,
+      ...{ [userAddressToAddTokens]: newIgnoredTokens }
+    };
+    newAllIgnoredTokens = {
+      ...allIgnoredTokens,
+      ...{ [chainIdToAddTokens]: newIgnoredNetworkTokens }
+    };
+  }
+  let newAllDetectedTokens = allDetectedTokens;
+  if (newDetectedTokens?.length || newDetectedTokens && allDetectedTokens && allDetectedTokens[chainIdToAddTokens] && allDetectedTokens[chainIdToAddTokens][userAddressToAddTokens]) {
+    const networkDetectedTokens = allDetectedTokens[chainIdToAddTokens];
+    const newDetectedNetworkTokens = {
+      ...networkDetectedTokens,
+      ...{ [userAddressToAddTokens]: newDetectedTokens }
+    };
+    newAllDetectedTokens = {
+      ...allDetectedTokens,
+      ...{ [chainIdToAddTokens]: newDetectedNetworkTokens }
+    };
+  }
+  return { newAllTokens, newAllIgnoredTokens, newAllDetectedTokens };
+};
+_requestApproval = new WeakSet();
+requestApproval_fn = async function(suggestedAssetMeta) {
+  return this.messagingSystem.call(
+    "ApprovalController:addRequest",
+    {
+      id: suggestedAssetMeta.id,
+      origin: ORIGIN_METAMASK,
+      type: ApprovalType.WatchAsset,
+      requestData: {
+        id: suggestedAssetMeta.id,
+        interactingAddress: suggestedAssetMeta.interactingAddress,
+        asset: {
+          address: suggestedAssetMeta.asset.address,
+          decimals: suggestedAssetMeta.asset.decimals,
+          symbol: suggestedAssetMeta.asset.symbol,
+          image: suggestedAssetMeta.asset.image || null
+        }
+      }
+    },
+    true
+  );
 };
 var TokensController_default = TokensController;
 
@@ -701,4 +768,4 @@ export {
   TokensController,
   TokensController_default
 };
-//# sourceMappingURL=chunk-7MMEHAKG.mjs.map
+//# sourceMappingURL=chunk-73F3SN5O.mjs.map