@metamask/assets-controllers 30.0.0 → 31.0.0

package/dist/chunk-MBCN3MNX.js

@@ -1,704 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var _chunkB5YY22QQjs = require('./chunk-B5YY22QQ.js');
-
-
-var _chunkBOTVAG4Ajs = require('./chunk-BOTVAG4A.js');
-
-
-
-var _chunk3R43XIIXjs = require('./chunk-3R43XIIX.js');
-
-
-
-var _chunkNEXY7SE2js = require('./chunk-NEXY7SE2.js');
-
-// src/TokensController.ts
-var _contracts = require('@ethersproject/contracts');
-var _providers = require('@ethersproject/providers');
-var _basecontroller = require('@metamask/base-controller');
-var _contractmetadata = require('@metamask/contract-metadata'); var _contractmetadata2 = _interopRequireDefault(_contractmetadata);
-
-
-
-
-
-
-
-
-
-
-var _controllerutils = require('@metamask/controller-utils');
-var _metamaskethabis = require('@metamask/metamask-eth-abis');
-var _rpcerrors = require('@metamask/rpc-errors');
-var _asyncmutex = require('async-mutex');
-var _events = require('events');
-var _uuid = require('uuid');
-var controllerName = "TokensController";
-var getDefaultTokensState = () => {
-  return {
-    tokens: [],
-    ignoredTokens: [],
-    detectedTokens: [],
-    allTokens: {},
-    allIgnoredTokens: {},
-    allDetectedTokens: {}
-  };
-};
-var TokensController = class extends _basecontroller.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 (0, _asyncmutex.Mutex)();
-    /**
-     * EventEmitter instance used to listen to specific EIP747 events
-     */
-    this.hub = new (0, _events.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 _chunk3R43XIIXjs.fetchTokenMetadata.call(void 0, 
-        this.config.chainId,
-        tokenAddress,
-        this.abortController.signal
-      );
-      return token;
-    } catch (error) {
-      if (error instanceof Error && error.message.includes(_chunk3R43XIIXjs.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 = _controllerutils.toChecksumHexAddress.call(void 0, 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 || _chunkNEXY7SE2js.formatIconUrlWithProxy.call(void 0, {
-          chainId: currentChainId,
-          tokenAddress: address
-        }),
-        isERC721,
-        aggregators: _chunkNEXY7SE2js.formatAggregatorNames.call(void 0, 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 = _controllerutils.toChecksumHexAddress.call(void 0, 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 = _controllerutils.toChecksumHexAddress.call(void 0, 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 = _controllerutils.toChecksumHexAddress.call(void 0, 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 = _controllerutils.toChecksumHexAddress.call(void 0, tokenAddress);
-    if (_contractmetadata2.default[checksumAddress]?.erc721 === true) {
-      return Promise.resolve(true);
-    } else if (_contractmetadata2.default[checksumAddress]?.erc20 === true) {
-      return Promise.resolve(false);
-    }
-    const tokenContract = this._createEthersContract(
-      tokenAddress,
-      _metamaskethabis.abiERC721,
-      networkClientId
-    );
-    try {
-      return await tokenContract.supportsInterface(_controllerutils.ERC721_INTERFACE_ID);
-    } catch (error) {
-      return false;
-    }
-  }
-  _getProvider(networkClientId) {
-    return new (0, _providers.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 (0, _contracts.Contract)(tokenAddress, abi, web3provider);
-    return tokenContract;
-  }
-  _generateRandomId() {
-    return _uuid.v1.call(void 0, );
-  }
-  /**
-   * 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 !== _controllerutils.ERC20) {
-      throw new Error(`Asset of type ${type} not supported`);
-    }
-    if (!asset.address) {
-      throw _rpcerrors.rpcErrors.invalidParams("Address must be specified");
-    }
-    if (!_controllerutils.isValidHexAddress.call(void 0, asset.address)) {
-      throw _rpcerrors.rpcErrors.invalidParams(`Invalid address "${asset.address}"`);
-    }
-    if (await this._detectIsERC721(asset.address, networkClientId)) {
-      throw _rpcerrors.rpcErrors.invalidParams(
-        `Contract ${asset.address} must match type ${type}, but was detected as ${_controllerutils.ERC721}`
-      );
-    }
-    const provider = this._getProvider(networkClientId);
-    const isErc1155 = await _controllerutils.safelyExecute.call(void 0, 
-      () => new (0, _chunkBOTVAG4Ajs.ERC1155Standard)(provider).contractSupportsBase1155Interface(
-        asset.address
-      )
-    );
-    if (isErc1155) {
-      throw _rpcerrors.rpcErrors.invalidParams(
-        `Contract ${asset.address} must match type ${type}, but was detected as ${_controllerutils.ERC1155}`
-      );
-    }
-    const erc20 = new (0, _chunkB5YY22QQjs.ERC20Standard)(provider);
-    const [contractName, contractSymbol, contractDecimals] = await Promise.all([
-      _controllerutils.safelyExecute.call(void 0, () => erc20.getTokenName(asset.address)),
-      _controllerutils.safelyExecute.call(void 0, () => erc20.getTokenSymbol(asset.address)),
-      _controllerutils.safelyExecute.call(void 0, async () => erc20.getTokenDecimals(asset.address))
-    ]);
-    asset.name = contractName;
-    if (!asset.symbol && !contractSymbol) {
-      throw _rpcerrors.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.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.rpcErrors.invalidParams(`Invalid symbol: not a string`);
-    }
-    if (asset.symbol.length > 11) {
-      throw _rpcerrors.rpcErrors.invalidParams(
-        `Invalid symbol "${asset.symbol}": longer than 11 characters`
-      );
-    }
-    if (asset.decimals === void 0 && contractDecimals === void 0) {
-      throw _rpcerrors.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.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.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: _controllerutils.ORIGIN_METAMASK,
-        type: _controllerutils.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;
-
-
-
-
-
-exports.getDefaultTokensState = getDefaultTokensState; exports.TokensController = TokensController; exports.TokensController_default = TokensController_default;
-//# sourceMappingURL=chunk-MBCN3MNX.js.map