@metamask/assets-controllers 26.0.0 → 27.0.0

package/dist/chunk-J6HPEQL3.mjs

@@ -0,0 +1,704 @@
+import {
+  ERC1155Standard
+} from "./chunk-TDKCVCGP.mjs";
+import {
+  ERC20Standard
+} from "./chunk-J2JQQNHN.mjs";
+import {
+  TOKEN_METADATA_NO_SUPPORT_ERROR,
+  fetchTokenMetadata
+} from "./chunk-QHRPRO5U.mjs";
+import {
+  formatAggregatorNames,
+  formatIconUrlWithProxy
+} from "./chunk-5C7ZVZNM.mjs";
+
+// src/TokensController.ts
+import { Contract } from "@ethersproject/contracts";
+import { Web3Provider } from "@ethersproject/providers";
+import { BaseControllerV1 } from "@metamask/base-controller";
+import contractsMap from "@metamask/contract-metadata";
+import {
+  toChecksumHexAddress,
+  ERC721_INTERFACE_ID,
+  ORIGIN_METAMASK,
+  ApprovalType,
+  ERC20,
+  ERC721,
+  ERC1155,
+  isValidHexAddress,
+  safelyExecute
+} from "@metamask/controller-utils";
+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 controllerName = "TokensController";
+var getDefaultTokensState = () => {
+  return {
+    tokens: [],
+    ignoredTokens: [],
+    detectedTokens: [],
+    allTokens: {},
+    allIgnoredTokens: {},
+    allDetectedTokens: {}
+  };
+};
+var TokensController = class extends BaseControllerV1 {
+  /**
+   * Creates a TokensController instance.
+   *
+   * @param options - The controller options.
+   * @param options.chainId - The chain ID of the current network.
+   * @param options.config - Initial options used to configure this controller.
+   * @param options.state - Initial state to set on this controller.
+   * @param options.messenger - The controller messenger.
+   */
+  constructor({
+    chainId: initialChainId,
+    config,
+    state,
+    messenger
+  }) {
+    super(config, state);
+    this.mutex = new Mutex();
+    /**
+     * EventEmitter instance used to listen to specific EIP747 events
+     */
+    this.hub = new EventEmitter();
+    /**
+     * Name of this controller used during composition
+     */
+    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;
+    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] ?? []
+        });
+      }
+    );
+    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] || []
+        });
+      }
+    );
+    this.messagingSystem.subscribe(
+      "TokenListController:stateChange",
+      ({ tokenList }) => {
+        const { tokens } = this.state;
+        if (tokens.length && !tokens[0].name) {
+          this.updateTokensAttribute(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.
+   *
+   * @param options - The method argument object.
+   * @param options.address - Hex address of the token contract.
+   * @param options.symbol - Symbol of the token.
+   * @param options.decimals - Number of decimals the token uses.
+   * @param options.name - Name of the token.
+   * @param options.image - Image of the token.
+   * @param options.interactingAddress - The address of the account to add a token to.
+   * @param options.networkClientId - Network Client ID.
+   * @returns Current token list.
+   */
+  async addToken({
+    address,
+    symbol,
+    decimals,
+    name,
+    image,
+    interactingAddress,
+    networkClientId
+  }) {
+    const { chainId, selectedAddress } = this.config;
+    const releaseLock = await this.mutex.acquire();
+    const { allTokens, allIgnoredTokens, allDetectedTokens } = this.state;
+    let currentChainId = chainId;
+    if (networkClientId) {
+      currentChainId = this.messagingSystem.call(
+        "NetworkController:getNetworkClientById",
+        networkClientId
+      ).configuration.chainId;
+    }
+    const accountAddress = interactingAddress || selectedAddress;
+    const isInteractingWithWalletAccount = accountAddress === selectedAddress;
+    try {
+      address = toChecksumHexAddress(address);
+      const tokens = allTokens[currentChainId]?.[accountAddress] || [];
+      const ignoredTokens = allIgnoredTokens[currentChainId]?.[accountAddress] || [];
+      const detectedTokens = allDetectedTokens[currentChainId]?.[accountAddress] || [];
+      const newTokens = [...tokens];
+      const [isERC721, tokenMetadata] = await Promise.all([
+        this._detectIsERC721(address, networkClientId),
+        // TODO parameterize the token metadata fetch by networkClientId
+        this.fetchTokenMetadata(address)
+      ]);
+      if (!networkClientId && currentChainId !== this.config.chainId) {
+        throw new Error(
+          "TokensController Error: Switched networks while adding token"
+        );
+      }
+      const newEntry = {
+        address,
+        symbol,
+        decimals,
+        image: image || formatIconUrlWithProxy({
+          chainId: currentChainId,
+          tokenAddress: address
+        }),
+        isERC721,
+        aggregators: formatAggregatorNames(tokenMetadata?.aggregators || []),
+        name
+      };
+      const previousIndex = newTokens.findIndex(
+        (token) => token.address.toLowerCase() === address.toLowerCase()
+      );
+      if (previousIndex !== -1) {
+        newTokens[previousIndex] = newEntry;
+      } else {
+        newTokens.push(newEntry);
+      }
+      const newIgnoredTokens = ignoredTokens.filter(
+        (tokenAddress) => tokenAddress.toLowerCase() !== address.toLowerCase()
+      );
+      const newDetectedTokens = detectedTokens.filter(
+        (token) => token.address.toLowerCase() !== address.toLowerCase()
+      );
+      const { newAllTokens, newAllIgnoredTokens, newAllDetectedTokens } = this._getNewAllTokensState({
+        newTokens,
+        newIgnoredTokens,
+        newDetectedTokens,
+        interactingAddress: accountAddress,
+        interactingChainId: currentChainId
+      });
+      let newState = {
+        allTokens: newAllTokens,
+        allIgnoredTokens: newAllIgnoredTokens,
+        allDetectedTokens: newAllDetectedTokens
+      };
+      if (isInteractingWithWalletAccount) {
+        newState = {
+          ...newState,
+          tokens: newTokens,
+          ignoredTokens: newIgnoredTokens,
+          detectedTokens: newDetectedTokens
+        };
+      }
+      this.update(newState);
+      return newTokens;
+    } finally {
+      releaseLock();
+    }
+  }
+  /**
+   * Add a batch of tokens.
+   *
+   * @param tokensToImport - Array of tokens to import.
+   * @param networkClientId - Optional network client ID used to determine interacting chain ID.
+   */
+  async addTokens(tokensToImport, networkClientId) {
+    const releaseLock = await this.mutex.acquire();
+    const { tokens, detectedTokens, ignoredTokens } = this.state;
+    const importedTokensMap = {};
+    const newTokensMap = tokens.reduce((output, current) => {
+      output[current.address] = current;
+      return output;
+    }, {});
+    try {
+      tokensToImport.forEach((tokenToAdd) => {
+        const { address, symbol, decimals, image, aggregators, name } = tokenToAdd;
+        const checksumAddress = toChecksumHexAddress(address);
+        const formattedToken = {
+          address: checksumAddress,
+          symbol,
+          decimals,
+          image,
+          aggregators,
+          name
+        };
+        newTokensMap[address] = formattedToken;
+        importedTokensMap[address.toLowerCase()] = true;
+        return formattedToken;
+      });
+      const newTokens = Object.values(newTokensMap);
+      const newDetectedTokens = detectedTokens.filter(
+        (token) => !importedTokensMap[token.address.toLowerCase()]
+      );
+      const newIgnoredTokens = ignoredTokens.filter(
+        (tokenAddress) => !newTokensMap[tokenAddress.toLowerCase()]
+      );
+      let interactingChainId;
+      if (networkClientId) {
+        interactingChainId = this.messagingSystem.call(
+          "NetworkController:getNetworkClientById",
+          networkClientId
+        ).configuration.chainId;
+      }
+      const { newAllTokens, newAllDetectedTokens, newAllIgnoredTokens } = this._getNewAllTokensState({
+        newTokens,
+        newDetectedTokens,
+        newIgnoredTokens,
+        interactingChainId
+      });
+      this.update({
+        tokens: newTokens,
+        allTokens: newAllTokens,
+        detectedTokens: newDetectedTokens,
+        allDetectedTokens: newAllDetectedTokens,
+        ignoredTokens: newIgnoredTokens,
+        allIgnoredTokens: newAllIgnoredTokens
+      });
+    } finally {
+      releaseLock();
+    }
+  }
+  /**
+   * Ignore a batch of tokens.
+   *
+   * @param tokenAddressesToIgnore - Array of token addresses to ignore.
+   */
+  ignoreTokens(tokenAddressesToIgnore) {
+    const { ignoredTokens, detectedTokens, tokens } = this.state;
+    const ignoredTokensMap = {};
+    let newIgnoredTokens = [...ignoredTokens];
+    const checksummedTokenAddresses = tokenAddressesToIgnore.map((address) => {
+      const checksumAddress = toChecksumHexAddress(address);
+      ignoredTokensMap[address.toLowerCase()] = true;
+      return checksumAddress;
+    });
+    newIgnoredTokens = [...ignoredTokens, ...checksummedTokenAddresses];
+    const newDetectedTokens = detectedTokens.filter(
+      (token) => !ignoredTokensMap[token.address.toLowerCase()]
+    );
+    const newTokens = tokens.filter(
+      (token) => !ignoredTokensMap[token.address.toLowerCase()]
+    );
+    const { newAllIgnoredTokens, newAllDetectedTokens, newAllTokens } = this._getNewAllTokensState({
+      newIgnoredTokens,
+      newDetectedTokens,
+      newTokens
+    });
+    this.update({
+      ignoredTokens: newIgnoredTokens,
+      tokens: newTokens,
+      detectedTokens: newDetectedTokens,
+      allIgnoredTokens: newAllIgnoredTokens,
+      allDetectedTokens: newAllDetectedTokens,
+      allTokens: newAllTokens
+    });
+  }
+  /**
+   * Adds a batch of detected tokens to the stored token list.
+   *
+   * @param incomingDetectedTokens - Array of detected tokens to be added or updated.
+   * @param detectionDetails - An object containing the chain ID and address of the currently selected network on which the incomingDetectedTokens were detected.
+   * @param detectionDetails.selectedAddress - the account address on which the incomingDetectedTokens were detected.
+   * @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 { allTokens, allDetectedTokens, allIgnoredTokens } = this.state;
+    let newTokens = [...allTokens?.[chainId]?.[accountAddress] ?? []];
+    let newDetectedTokens = [
+      ...allDetectedTokens?.[chainId]?.[accountAddress] ?? []
+    ];
+    try {
+      incomingDetectedTokens.forEach((tokenToAdd) => {
+        const {
+          address,
+          symbol,
+          decimals,
+          image,
+          aggregators,
+          isERC721,
+          name
+        } = tokenToAdd;
+        const checksumAddress = toChecksumHexAddress(address);
+        const newEntry = {
+          address: checksumAddress,
+          symbol,
+          decimals,
+          image,
+          isERC721,
+          aggregators,
+          name
+        };
+        const previousImportedIndex = newTokens.findIndex(
+          (token) => token.address.toLowerCase() === checksumAddress.toLowerCase()
+        );
+        if (previousImportedIndex !== -1) {
+          newTokens[previousImportedIndex] = newEntry;
+        } else {
+          const ignoredTokenIndex = allIgnoredTokens?.[chainId]?.[accountAddress]?.indexOf(address) ?? -1;
+          if (ignoredTokenIndex === -1) {
+            const previousDetectedIndex = newDetectedTokens.findIndex(
+              (token) => token.address.toLowerCase() === checksumAddress.toLowerCase()
+            );
+            if (previousDetectedIndex !== -1) {
+              newDetectedTokens[previousDetectedIndex] = newEntry;
+            } else {
+              newDetectedTokens.push(newEntry);
+            }
+          }
+        }
+      });
+      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
+      });
+    } finally {
+      releaseLock();
+    }
+  }
+  /**
+   * Adds isERC721 field to token object. This is called when a user attempts to add tokens that
+   * were previously added which do not yet had isERC721 field.
+   *
+   * @param tokenAddress - The contract address of the token requiring the isERC721 field added.
+   * @returns The new token object with the added isERC721 field.
+   */
+  async updateTokenType(tokenAddress) {
+    const isERC721 = await this._detectIsERC721(tokenAddress);
+    const { tokens } = this.state;
+    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 };
+    });
+    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();
+  }
+  /**
+   * Adds a new suggestedAsset to the list of watched assets.
+   * Parameters will be validated according to the asset type being watched.
+   *
+   * @param options - The method options.
+   * @param options.asset - The asset to be watched. For now only ERC20 tokens are accepted.
+   * @param options.type - The asset type.
+   * @param options.interactingAddress - The address of the account that is requesting to watch the asset.
+   * @param options.networkClientId - Network Client ID.
+   * @returns A promise that resolves if the asset was watched successfully, and rejects otherwise.
+   */
+  async watchAsset({
+    asset,
+    type,
+    interactingAddress,
+    networkClientId
+  }) {
+    if (type !== ERC20) {
+      throw new Error(`Asset of type ${type} not supported`);
+    }
+    if (!asset.address) {
+      throw rpcErrors.invalidParams("Address must be specified");
+    }
+    if (!isValidHexAddress(asset.address)) {
+      throw rpcErrors.invalidParams(`Invalid address "${asset.address}"`);
+    }
+    if (await this._detectIsERC721(asset.address, networkClientId)) {
+      throw rpcErrors.invalidParams(
+        `Contract ${asset.address} must match type ${type}, but was detected as ${ERC721}`
+      );
+    }
+    const provider = this._getProvider(networkClientId);
+    const isErc1155 = await safelyExecute(
+      () => new ERC1155Standard(provider).contractSupportsBase1155Interface(
+        asset.address
+      )
+    );
+    if (isErc1155) {
+      throw rpcErrors.invalidParams(
+        `Contract ${asset.address} must match type ${type}, but was detected as ${ERC1155}`
+      );
+    }
+    const erc20 = new ERC20Standard(provider);
+    const [contractName, contractSymbol, contractDecimals] = await Promise.all([
+      safelyExecute(() => erc20.getTokenName(asset.address)),
+      safelyExecute(() => erc20.getTokenSymbol(asset.address)),
+      safelyExecute(async () => erc20.getTokenDecimals(asset.address))
+    ]);
+    asset.name = contractName;
+    if (!asset.symbol && !contractSymbol) {
+      throw rpcErrors.invalidParams(
+        "A symbol is required, but was not found in either the request or contract"
+      );
+    }
+    if (contractSymbol !== void 0 && asset.symbol !== void 0 && asset.symbol.toUpperCase() !== contractSymbol.toUpperCase()) {
+      throw rpcErrors.invalidParams(
+        `The symbol in the request (${asset.symbol}) does not match the symbol in the contract (${contractSymbol})`
+      );
+    }
+    asset.symbol = contractSymbol ?? asset.symbol;
+    if (typeof asset.symbol !== "string") {
+      throw rpcErrors.invalidParams(`Invalid symbol: not a string`);
+    }
+    if (asset.symbol.length > 11) {
+      throw rpcErrors.invalidParams(
+        `Invalid symbol "${asset.symbol}": longer than 11 characters`
+      );
+    }
+    if (asset.decimals === void 0 && contractDecimals === void 0) {
+      throw rpcErrors.invalidParams(
+        "Decimals are required, but were not found in either the request or contract"
+      );
+    }
+    if (contractDecimals !== void 0 && asset.decimals !== void 0 && String(asset.decimals) !== contractDecimals) {
+      throw rpcErrors.invalidParams(
+        `The decimals in the request (${asset.decimals}) do not match the decimals in the contract (${contractDecimals})`
+      );
+    }
+    const decimalsStr = contractDecimals ?? asset.decimals;
+    const decimalsNum = parseInt(decimalsStr, 10);
+    if (!Number.isInteger(decimalsNum) || decimalsNum > 36 || decimalsNum < 0) {
+      throw rpcErrors.invalidParams(
+        `Invalid decimals "${decimalsStr}": must be an integer 0 <= 36`
+      );
+    }
+    asset.decimals = decimalsNum;
+    const suggestedAssetMeta = {
+      asset,
+      id: this._generateRandomId(),
+      time: Date.now(),
+      type,
+      interactingAddress: interactingAddress || this.config.selectedAddress
+    };
+    await this._requestApproval(suggestedAssetMeta);
+    const { address, symbol, decimals, name, image } = asset;
+    await this.addToken({
+      address,
+      symbol,
+      decimals,
+      name,
+      image,
+      interactingAddress: suggestedAssetMeta.interactingAddress,
+      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: {} });
+  }
+  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
+    );
+  }
+};
+var TokensController_default = TokensController;
+
+export {
+  getDefaultTokensState,
+  TokensController,
+  TokensController_default
+};
+//# sourceMappingURL=chunk-J6HPEQL3.mjs.map