@metamask/assets-controllers 30.0.0 → 31.0.0

package/dist/chunk-46UZDIXW.mjs

@@ -1,1205 +0,0 @@
-import {
-  compareNftMetadata,
-  getFormattedIpfsUrl
-} from "./chunk-Q5JRBGWO.mjs";
-
-// src/NftController.ts
-import { isAddress } from "@ethersproject/address";
-import { BaseControllerV1 } from "@metamask/base-controller";
-import {
-  safelyExecute,
-  handleFetch,
-  toChecksumHexAddress,
-  BNToHex,
-  fetchWithErrorHandling,
-  IPFS_DEFAULT_GATEWAY_URL,
-  ERC721,
-  ERC1155,
-  ApprovalType,
-  NFT_API_BASE_URL
-} from "@metamask/controller-utils";
-import { rpcErrors } from "@metamask/rpc-errors";
-import { remove0x } from "@metamask/utils";
-import { Mutex } from "async-mutex";
-import BN from "bn.js";
-import { EventEmitter } from "events";
-import { v4 as random } from "uuid";
-var ALL_NFTS_STATE_KEY = "allNfts";
-var ALL_NFTS_CONTRACTS_STATE_KEY = "allNftContracts";
-var getDefaultNftState = () => {
-  return {
-    allNftContracts: {},
-    allNfts: {},
-    ignoredNfts: []
-  };
-};
-var NftController = class extends BaseControllerV1 {
-  /**
-   * Creates an NftController instance.
-   *
-   * @param options - The controller options.
-   * @param options.chainId - The chain ID of the current network.
-   * @param options.onPreferencesStateChange - Allows subscribing to preference controller state changes.
-   * @param options.onNetworkStateChange - Allows subscribing to network controller state changes.
-   * @param options.getERC721AssetName - Gets the name of the asset at the given address.
-   * @param options.getERC721AssetSymbol - Gets the symbol of the asset at the given address.
-   * @param options.getERC721TokenURI - Gets the URI of the ERC721 token at the given address, with the given ID.
-   * @param options.getERC721OwnerOf - Get the owner of a ERC-721 NFT.
-   * @param options.getERC1155BalanceOf - Gets balance of a ERC-1155 NFT.
-   * @param options.getERC1155TokenURI - Gets the URI of the ERC1155 token at the given address, with the given ID.
-   * @param options.getNetworkClientById - Gets the network client for the given networkClientId.
-   * @param options.onNftAdded - Callback that is called when an NFT is added. Currently used pass data
-   * for tracking the NFT added event.
-   * @param options.messenger - The controller messenger.
-   * @param config - Initial options used to configure this controller.
-   * @param state - Initial state to set on this controller.
-   */
-  constructor({
-    chainId: initialChainId,
-    onPreferencesStateChange,
-    onNetworkStateChange,
-    getERC721AssetName,
-    getERC721AssetSymbol,
-    getERC721TokenURI,
-    getERC721OwnerOf,
-    getERC1155BalanceOf,
-    getERC1155TokenURI,
-    getNetworkClientById,
-    onNftAdded,
-    messenger
-  }, config, state) {
-    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 = "NftController";
-    this.defaultConfig = {
-      selectedAddress: "",
-      chainId: initialChainId,
-      ipfsGateway: IPFS_DEFAULT_GATEWAY_URL,
-      openSeaEnabled: false,
-      useIPFSSubdomains: true,
-      isIpfsGatewayEnabled: true
-    };
-    this.defaultState = getDefaultNftState();
-    this.initialize();
-    this.getERC721AssetName = getERC721AssetName;
-    this.getERC721AssetSymbol = getERC721AssetSymbol;
-    this.getERC721TokenURI = getERC721TokenURI;
-    this.getERC721OwnerOf = getERC721OwnerOf;
-    this.getERC1155BalanceOf = getERC1155BalanceOf;
-    this.getERC1155TokenURI = getERC1155TokenURI;
-    this.getNetworkClientById = getNetworkClientById;
-    this.onNftAdded = onNftAdded;
-    this.messagingSystem = messenger;
-    onPreferencesStateChange(
-      async ({
-        selectedAddress,
-        ipfsGateway,
-        openSeaEnabled,
-        isIpfsGatewayEnabled
-      }) => {
-        this.configure({
-          selectedAddress,
-          ipfsGateway,
-          openSeaEnabled,
-          isIpfsGatewayEnabled
-        });
-        const needsUpdateNftMetadata = isIpfsGatewayEnabled && ipfsGateway !== "" || openSeaEnabled;
-        if (needsUpdateNftMetadata) {
-          const { chainId } = this.config;
-          const nfts = this.state.allNfts[selectedAddress]?.[chainId] ?? [];
-          const nftsToUpdate = nfts.filter(
-            (singleNft) => !singleNft.name && !singleNft.description && !singleNft.image
-          );
-          if (nftsToUpdate.length !== 0) {
-            await this.updateNftMetadata({
-              nfts: nftsToUpdate,
-              userAddress: selectedAddress
-            });
-          }
-        }
-      }
-    );
-    onNetworkStateChange(({ selectedNetworkClientId }) => {
-      const selectedNetworkClient = getNetworkClientById(
-        selectedNetworkClientId
-      );
-      const { chainId } = selectedNetworkClient.configuration;
-      this.configure({ chainId });
-    });
-  }
-  getNftApi() {
-    return `${NFT_API_BASE_URL}/tokens`;
-  }
-  /**
-   * Helper method to update nested state for allNfts and allNftContracts.
-   *
-   * @param newCollection - the modified piece of state to update in the controller's store
-   * @param baseStateKey - The root key in the store to update.
-   * @param passedConfig - An object containing the selectedAddress and chainId that are passed through the auto-detection flow.
-   * @param passedConfig.userAddress - the address passed through the NFT detection flow to ensure assets are stored to the correct account
-   * @param passedConfig.chainId - the chainId passed through the NFT detection flow to ensure assets are stored to the correct account
-   */
-  updateNestedNftState(newCollection, baseStateKey, { userAddress, chainId }) {
-    const { [baseStateKey]: oldState } = this.state;
-    const addressState = oldState[userAddress];
-    const newAddressState = {
-      ...addressState,
-      ...{ [chainId]: newCollection }
-    };
-    const newState = {
-      ...oldState,
-      ...{ [userAddress]: newAddressState }
-    };
-    this.update({
-      [baseStateKey]: newState
-    });
-  }
-  /**
-   * Request individual NFT information from NFT API.
-   *
-   * @param contractAddress - Hex address of the NFT contract.
-   * @param tokenId - The NFT identifier.
-   * @returns Promise resolving to the current NFT name and image.
-   */
-  async getNftInformationFromApi(contractAddress, tokenId) {
-    const urlParams = new URLSearchParams({
-      chainIds: "1",
-      tokens: `${contractAddress}:${tokenId}`,
-      includeTopBid: "true",
-      includeAttributes: "true",
-      includeLastSale: "true"
-    }).toString();
-    const nftInformation = await fetchWithErrorHandling({
-      url: `${this.getNftApi()}?${urlParams}`,
-      options: {
-        headers: {
-          Version: "1"
-        }
-      }
-    });
-    if (!nftInformation?.tokens?.[0]?.token) {
-      return {
-        name: null,
-        description: null,
-        image: null,
-        standard: null
-      };
-    }
-    const {
-      image,
-      metadata: { imageOriginal } = {},
-      name,
-      description,
-      collection,
-      kind,
-      rarityRank,
-      rarity,
-      attributes,
-      lastSale,
-      imageSmall
-    } = nftInformation.tokens[0].token;
-    const nftMetadata = Object.assign(
-      {},
-      { name: name || null },
-      { description: description || null },
-      { image: image || null },
-      collection?.creator && { creator: collection.creator },
-      imageOriginal && { imageOriginal },
-      imageSmall && { imageThumbnail: imageSmall },
-      kind && { standard: kind.toUpperCase() },
-      lastSale && { lastSale },
-      attributes && { attributes },
-      nftInformation.tokens[0].market?.topBid && {
-        topBid: nftInformation.tokens[0].market?.topBid
-      },
-      rarityRank && { rarityRank },
-      rarity && { rarity },
-      collection && { collection }
-    );
-    return nftMetadata;
-  }
-  /**
-   * Request individual NFT information from contracts that follows Metadata Interface.
-   *
-   * @param contractAddress - Hex address of the NFT contract.
-   * @param tokenId - The NFT identifier.
-   * @param networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @returns Promise resolving to the current NFT name and image.
-   */
-  async getNftInformationFromTokenURI(contractAddress, tokenId, networkClientId) {
-    const { ipfsGateway, useIPFSSubdomains, isIpfsGatewayEnabled } = this.config;
-    const result = await this.getNftURIAndStandard(
-      contractAddress,
-      tokenId,
-      networkClientId
-    );
-    let tokenURI = result[0];
-    const standard = result[1];
-    const hasIpfsTokenURI = tokenURI.startsWith("ipfs://");
-    if (hasIpfsTokenURI && !isIpfsGatewayEnabled) {
-      return {
-        image: null,
-        name: null,
-        description: null,
-        standard: standard || null,
-        favorite: false,
-        tokenURI: tokenURI ?? null
-      };
-    }
-    const isDisplayNFTMediaToggleEnabled = this.config.openSeaEnabled;
-    if (!hasIpfsTokenURI && !isDisplayNFTMediaToggleEnabled) {
-      return {
-        image: null,
-        name: null,
-        description: null,
-        standard: standard || null,
-        favorite: false,
-        tokenURI: tokenURI ?? null
-      };
-    }
-    if (hasIpfsTokenURI) {
-      tokenURI = getFormattedIpfsUrl(ipfsGateway, tokenURI, useIPFSSubdomains);
-    }
-    try {
-      const object = await handleFetch(tokenURI);
-      const image = Object.prototype.hasOwnProperty.call(object, "image") ? "image" : (
-        /* istanbul ignore next */
-        "image_url"
-      );
-      return {
-        image: object[image],
-        name: object.name,
-        description: object.description,
-        standard,
-        favorite: false,
-        tokenURI: tokenURI ?? null
-      };
-    } catch {
-      return {
-        image: null,
-        name: null,
-        description: null,
-        standard: standard || null,
-        favorite: false,
-        tokenURI: tokenURI ?? null
-      };
-    }
-  }
-  /**
-   * Retrieve NFT uri with  metadata. TODO Update method to use IPFS.
-   *
-   * @param contractAddress - NFT contract address.
-   * @param tokenId - NFT token id.
-   * @param networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @returns Promise resolving NFT uri and token standard.
-   */
-  async getNftURIAndStandard(contractAddress, tokenId, networkClientId) {
-    try {
-      const uri = await this.getERC721TokenURI(
-        contractAddress,
-        tokenId,
-        networkClientId
-      );
-      return [uri, ERC721];
-    } catch {
-    }
-    try {
-      const tokenURI = await this.getERC1155TokenURI(
-        contractAddress,
-        tokenId,
-        networkClientId
-      );
-      if (!tokenURI.includes("{id}")) {
-        return [tokenURI, ERC1155];
-      }
-      const hexTokenId = remove0x(BNToHex(new BN(tokenId))).padStart(64, "0").toLowerCase();
-      return [tokenURI.replace("{id}", hexTokenId), ERC1155];
-    } catch {
-    }
-    return ["", ""];
-  }
-  /**
-   * Request individual NFT information (name, image url and description).
-   *
-   * @param contractAddress - Hex address of the NFT contract.
-   * @param tokenId - The NFT identifier.
-   * @param networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @returns Promise resolving to the current NFT name and image.
-   */
-  async getNftInformation(contractAddress, tokenId, networkClientId) {
-    const chainId = this.getCorrectChainId({
-      networkClientId
-    });
-    const [blockchainMetadata, nftApiMetadata] = await Promise.all([
-      safelyExecute(
-        () => this.getNftInformationFromTokenURI(
-          contractAddress,
-          tokenId,
-          networkClientId
-        )
-      ),
-      this.config.openSeaEnabled && chainId === "0x1" ? safelyExecute(
-        () => this.getNftInformationFromApi(contractAddress, tokenId)
-      ) : void 0
-    ]);
-    return {
-      ...nftApiMetadata,
-      name: blockchainMetadata?.name ?? nftApiMetadata?.name ?? null,
-      description: blockchainMetadata?.description ?? nftApiMetadata?.description ?? null,
-      image: blockchainMetadata?.image ?? nftApiMetadata?.image ?? null,
-      standard: blockchainMetadata?.standard ?? nftApiMetadata?.standard ?? null,
-      tokenURI: blockchainMetadata?.tokenURI ?? null
-    };
-  }
-  /**
-   * Request NFT contract information from the contract itself.
-   *
-   * @param contractAddress - Hex address of the NFT contract.
-   * @param networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @returns Promise resolving to the current NFT name and image.
-   */
-  async getNftContractInformationFromContract(contractAddress, networkClientId) {
-    const [name, symbol] = await Promise.all([
-      this.getERC721AssetName(contractAddress, networkClientId),
-      this.getERC721AssetSymbol(contractAddress, networkClientId)
-    ]);
-    return {
-      collection: { name },
-      symbol,
-      address: contractAddress
-    };
-  }
-  /**
-   * Request NFT contract information from Blockchain and aggregate with received data from NFTMetadata.
-   *
-   * @param contractAddress - Hex address of the NFT contract.
-   * @param nftMetadataFromApi - Received NFT information to be aggregated with blockchain contract information.
-   * @param networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @returns Promise resolving to the NFT contract name, image and description.
-   */
-  async getNftContractInformation(contractAddress, nftMetadataFromApi, networkClientId) {
-    const blockchainContractData = await safelyExecute(
-      () => this.getNftContractInformationFromContract(
-        contractAddress,
-        networkClientId
-      )
-    );
-    if (blockchainContractData || !Object.values(nftMetadataFromApi).every((value) => value === null)) {
-      return {
-        address: contractAddress,
-        ...blockchainContractData,
-        schema_name: nftMetadataFromApi?.standard ?? null,
-        collection: {
-          name: null,
-          image_url: nftMetadataFromApi?.collection?.image ?? nftMetadataFromApi?.collection?.imageUrl ?? null,
-          tokenCount: nftMetadataFromApi?.collection?.tokenCount ?? null,
-          ...nftMetadataFromApi?.collection,
-          ...blockchainContractData?.collection
-        }
-      };
-    }
-    return {
-      address: contractAddress,
-      asset_contract_type: null,
-      created_date: null,
-      schema_name: null,
-      symbol: null,
-      total_supply: null,
-      description: null,
-      external_link: null,
-      collection: { name: null, image_url: null }
-    };
-  }
-  /**
-   * Adds an individual NFT to the stored NFT list.
-   *
-   * @param tokenAddress - Hex address of the NFT contract.
-   * @param tokenId - The NFT identifier.
-   * @param nftMetadata - NFT optional information (name, image and description).
-   * @param nftContract - An object containing contract data of the NFT being added.
-   * @param chainId - The chainId of the network where the NFT is being added.
-   * @param userAddress - The address of the account where the NFT is being added.
-   * @param source - Whether the NFT was detected, added manually or suggested by a dapp.
-   * @returns Promise resolving to the current NFT list.
-   */
-  async addIndividualNft(tokenAddress, tokenId, nftMetadata, nftContract, chainId, userAddress, source) {
-    const releaseLock = await this.mutex.acquire();
-    try {
-      tokenAddress = toChecksumHexAddress(tokenAddress);
-      const { allNfts } = this.state;
-      const nfts = allNfts[userAddress]?.[chainId] || [];
-      const existingEntry = nfts.find(
-        (nft) => nft.address.toLowerCase() === tokenAddress.toLowerCase() && nft.tokenId === tokenId
-      );
-      if (existingEntry) {
-        const differentMetadata = compareNftMetadata(
-          nftMetadata,
-          existingEntry
-        );
-        if (differentMetadata || !existingEntry.isCurrentlyOwned) {
-          const indexToRemove = nfts.findIndex(
-            (nft) => nft.address.toLowerCase() === tokenAddress.toLowerCase() && nft.tokenId === tokenId
-          );
-          if (indexToRemove !== -1) {
-            nfts.splice(indexToRemove, 1);
-          }
-        } else {
-          return nfts;
-        }
-      }
-      const newEntry = {
-        address: tokenAddress,
-        tokenId,
-        favorite: existingEntry?.favorite || false,
-        isCurrentlyOwned: true,
-        ...nftMetadata
-      };
-      const newNfts = [...nfts, newEntry];
-      this.updateNestedNftState(newNfts, ALL_NFTS_STATE_KEY, {
-        chainId,
-        userAddress
-      });
-      if (this.onNftAdded) {
-        this.onNftAdded({
-          address: tokenAddress,
-          symbol: nftContract.symbol,
-          tokenId: tokenId.toString(),
-          standard: nftMetadata.standard,
-          source
-        });
-      }
-      return newNfts;
-    } finally {
-      releaseLock();
-    }
-  }
-  /**
-   * Adds an NFT contract to the stored NFT contracts list.
-   *
-   * @param options - options.
-   * @param options.tokenAddress - Hex address of the NFT contract.
-   * @param options.userAddress - The address of the account where the NFT is being added.
-   * @param options.nftMetadata - The retrieved NFTMetadata from API.
-   * @param options.networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @param options.source - Whether the NFT was detected, added manually or suggested by a dapp.
-   * @returns Promise resolving to the current NFT contracts list.
-   */
-  async addNftContract({
-    tokenAddress,
-    userAddress,
-    networkClientId,
-    source,
-    nftMetadata
-  }) {
-    const releaseLock = await this.mutex.acquire();
-    try {
-      tokenAddress = toChecksumHexAddress(tokenAddress);
-      const { allNftContracts } = this.state;
-      const chainId = this.getCorrectChainId({
-        networkClientId
-      });
-      const nftContracts = allNftContracts[userAddress]?.[chainId] || [];
-      const existingEntry = nftContracts.find(
-        (nftContract) => nftContract.address.toLowerCase() === tokenAddress.toLowerCase()
-      );
-      if (existingEntry) {
-        return nftContracts;
-      }
-      const contractInformation = await this.getNftContractInformation(
-        tokenAddress,
-        nftMetadata,
-        networkClientId
-      );
-      const {
-        asset_contract_type,
-        created_date,
-        symbol,
-        description,
-        external_link,
-        schema_name,
-        collection: { name, image_url, tokenCount }
-      } = contractInformation;
-      if (source === "detected" /* Detected */ && "address" in contractInformation && typeof contractInformation.address === "string" && "collection" in contractInformation && contractInformation.collection.name === null && "image_url" in contractInformation.collection && contractInformation.collection.image_url === null && Object.entries(contractInformation).every(([key, value]) => {
-        return key === "address" || key === "collection" || !value;
-      })) {
-        return nftContracts;
-      }
-      const newEntry = Object.assign(
-        {},
-        { address: tokenAddress },
-        description && { description },
-        name && { name },
-        image_url && { logo: image_url },
-        symbol && { symbol },
-        tokenCount !== null && typeof tokenCount !== "undefined" && { totalSupply: tokenCount },
-        asset_contract_type && { assetContractType: asset_contract_type },
-        created_date && { createdDate: created_date },
-        schema_name && { schemaName: schema_name },
-        external_link && { externalLink: external_link }
-      );
-      const newNftContracts = [...nftContracts, newEntry];
-      this.updateNestedNftState(newNftContracts, ALL_NFTS_CONTRACTS_STATE_KEY, {
-        chainId,
-        userAddress
-      });
-      return newNftContracts;
-    } finally {
-      releaseLock();
-    }
-  }
-  /**
-   * Removes an individual NFT from the stored token list and saves it in ignored NFTs list.
-   *
-   * @param address - Hex address of the NFT contract.
-   * @param tokenId - Token identifier of the NFT.
-   * @param options - options.
-   * @param options.chainId - The chainId of the network where the NFT is being removed.
-   * @param options.userAddress - The address of the account where the NFT is being removed.
-   */
-  removeAndIgnoreIndividualNft(address, tokenId, {
-    chainId,
-    userAddress
-  }) {
-    address = toChecksumHexAddress(address);
-    const { allNfts, ignoredNfts } = this.state;
-    const newIgnoredNfts = [...ignoredNfts];
-    const nfts = allNfts[userAddress]?.[chainId] || [];
-    const newNfts = nfts.filter((nft) => {
-      if (nft.address.toLowerCase() === address.toLowerCase() && nft.tokenId === tokenId) {
-        const alreadyIgnored = newIgnoredNfts.find(
-          (c) => c.address === address && c.tokenId === tokenId
-        );
-        !alreadyIgnored && newIgnoredNfts.push(nft);
-        return false;
-      }
-      return true;
-    });
-    this.updateNestedNftState(newNfts, ALL_NFTS_STATE_KEY, {
-      userAddress,
-      chainId
-    });
-    this.update({
-      ignoredNfts: newIgnoredNfts
-    });
-  }
-  /**
-   * Removes an individual NFT from the stored token list.
-   *
-   * @param address - Hex address of the NFT contract.
-   * @param tokenId - Token identifier of the NFT.
-   * @param options - options.
-   * @param options.chainId - The chainId of the network where the NFT is being removed.
-   * @param options.userAddress - The address of the account where the NFT is being removed.
-   */
-  removeIndividualNft(address, tokenId, { chainId, userAddress }) {
-    address = toChecksumHexAddress(address);
-    const { allNfts } = this.state;
-    const nfts = allNfts[userAddress]?.[chainId] || [];
-    const newNfts = nfts.filter(
-      (nft) => !(nft.address.toLowerCase() === address.toLowerCase() && nft.tokenId === tokenId)
-    );
-    this.updateNestedNftState(newNfts, ALL_NFTS_STATE_KEY, {
-      userAddress,
-      chainId
-    });
-  }
-  /**
-   * Removes an NFT contract to the stored NFT contracts list.
-   *
-   * @param address - Hex address of the NFT contract.
-   * @param options - options.
-   * @param options.chainId - The chainId of the network where the NFT is being removed.
-   * @param options.userAddress - The address of the account where the NFT is being removed.
-   * @returns Promise resolving to the current NFT contracts list.
-   */
-  removeNftContract(address, { chainId, userAddress }) {
-    address = toChecksumHexAddress(address);
-    const { allNftContracts } = this.state;
-    const nftContracts = allNftContracts[userAddress]?.[chainId] || [];
-    const newNftContracts = nftContracts.filter(
-      (nftContract) => !(nftContract.address.toLowerCase() === address.toLowerCase())
-    );
-    this.updateNestedNftState(newNftContracts, ALL_NFTS_CONTRACTS_STATE_KEY, {
-      chainId,
-      userAddress
-    });
-    return newNftContracts;
-  }
-  async validateWatchNft(asset, type, userAddress, { networkClientId } = {}) {
-    const { address: contractAddress, tokenId } = asset;
-    if (!type) {
-      throw rpcErrors.invalidParams("Asset type is required");
-    }
-    if (type !== ERC721 && type !== ERC1155) {
-      throw rpcErrors.invalidParams(
-        `Non NFT asset type ${type} not supported by watchNft`
-      );
-    }
-    if (!contractAddress || !tokenId) {
-      throw rpcErrors.invalidParams("Both address and tokenId are required");
-    }
-    if (!isAddress(contractAddress)) {
-      throw rpcErrors.invalidParams("Invalid address");
-    }
-    if (!/^\d+$/u.test(tokenId)) {
-      throw rpcErrors.invalidParams("Invalid tokenId");
-    }
-    try {
-      const isOwner = await this.isNftOwner(
-        userAddress,
-        contractAddress,
-        tokenId,
-        { networkClientId }
-      );
-      if (!isOwner) {
-        throw rpcErrors.invalidInput(
-          "Suggested NFT is not owned by the selected account"
-        );
-      }
-    } catch (error) {
-      if (error instanceof Error) {
-        throw rpcErrors.resourceUnavailable(error.message);
-      }
-      throw error;
-    }
-  }
-  // temporary method to get the correct chainId until we remove chainId from the config & the chainId arg from the detection logic
-  // Just a helper method to prefer the networkClient chainId first then the chainId argument and then finally the config chainId
-  getCorrectChainId({
-    networkClientId
-  }) {
-    if (networkClientId) {
-      return this.getNetworkClientById(networkClientId).configuration.chainId;
-    }
-    return this.config.chainId;
-  }
-  /**
-   * Adds a new suggestedAsset to state. Parameters will be validated according to
-   * asset type being watched. A `<suggestedNftMeta.id>:pending` hub event will be emitted once added.
-   *
-   * @param asset - The asset to be watched. For now ERC721 and ERC1155 tokens are accepted.
-   * @param asset.address - The address of the asset contract.
-   * @param asset.tokenId - The ID of the asset.
-   * @param type - The asset type.
-   * @param origin - Domain origin to register the asset from.
-   * @param options - Options bag.
-   * @param options.networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @param options.userAddress - The address of the account where the NFT is being added.
-   * @returns Object containing a Promise resolving to the suggestedAsset address if accepted.
-   */
-  async watchNft(asset, type, origin, {
-    networkClientId,
-    userAddress = this.config.selectedAddress
-  } = {
-    userAddress: this.config.selectedAddress
-  }) {
-    await this.validateWatchNft(asset, type, userAddress);
-    const nftMetadata = await this.getNftInformation(
-      asset.address,
-      asset.tokenId,
-      networkClientId
-    );
-    if (nftMetadata.standard && nftMetadata.standard !== type) {
-      throw rpcErrors.invalidInput(
-        `Suggested NFT of type ${nftMetadata.standard} does not match received type ${type}`
-      );
-    }
-    const suggestedNftMeta = {
-      asset: { ...asset, ...nftMetadata },
-      type,
-      id: random(),
-      time: Date.now(),
-      interactingAddress: userAddress,
-      origin
-    };
-    await this._requestApproval(suggestedNftMeta);
-    const { address, tokenId } = asset;
-    const { name, standard, description, image } = nftMetadata;
-    await this.addNft(address, tokenId, {
-      nftMetadata: {
-        name: name ?? null,
-        description: description ?? null,
-        image: image ?? null,
-        standard: standard ?? null
-      },
-      userAddress,
-      source: "dapp" /* Dapp */,
-      networkClientId
-    });
-  }
-  /**
-   * Sets an OpenSea API key to retrieve NFT information.
-   *
-   * @param openSeaApiKey - OpenSea API key.
-   */
-  setApiKey(openSeaApiKey) {
-    this.openSeaApiKey = openSeaApiKey;
-  }
-  /**
-   * Checks the ownership of a ERC-721 or ERC-1155 NFT for a given address.
-   *
-   * @param ownerAddress - User public address.
-   * @param nftAddress - NFT contract address.
-   * @param tokenId - NFT token ID.
-   * @param options - Options bag.
-   * @param options.networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @returns Promise resolving the NFT ownership.
-   */
-  async isNftOwner(ownerAddress, nftAddress, tokenId, {
-    networkClientId
-  } = {}) {
-    try {
-      const owner = await this.getERC721OwnerOf(
-        nftAddress,
-        tokenId,
-        networkClientId
-      );
-      return ownerAddress.toLowerCase() === owner.toLowerCase();
-    } catch {
-    }
-    try {
-      const balance = await this.getERC1155BalanceOf(
-        ownerAddress,
-        nftAddress,
-        tokenId,
-        networkClientId
-      );
-      return !balance.isZero();
-    } catch {
-    }
-    throw new Error(
-      `Unable to verify ownership. Possibly because the standard is not supported or the user's currently selected network does not match the chain of the asset in question.`
-    );
-  }
-  /**
-   * Verifies currently selected address owns entered NFT address/tokenId combo and
-   * adds the NFT and respective NFT contract to the stored NFT and NFT contracts lists.
-   *
-   * @param address - Hex address of the NFT contract.
-   * @param tokenId - The NFT identifier.
-   * @param options - an object of arguments
-   * @param options.userAddress - The address of the current user.
-   * @param options.networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @param options.source - Whether the NFT was detected, added manually or suggested by a dapp.
-   */
-  async addNftVerifyOwnership(address, tokenId, {
-    userAddress = this.config.selectedAddress,
-    networkClientId,
-    source
-  } = {
-    userAddress: this.config.selectedAddress
-  }) {
-    if (!await this.isNftOwner(userAddress, address, tokenId, {
-      networkClientId
-    })) {
-      throw new Error("This NFT is not owned by the user");
-    }
-    await this.addNft(address, tokenId, {
-      networkClientId,
-      userAddress,
-      source
-    });
-  }
-  /**
-   * Adds an NFT and respective NFT contract to the stored NFT and NFT contracts lists.
-   *
-   * @param tokenAddress - Hex address of the NFT contract.
-   * @param tokenId - The NFT identifier.
-   * @param options - an object of arguments
-   * @param options.nftMetadata - NFT optional metadata.
-   * @param options.userAddress - The address of the current user.
-   * @param options.source - Whether the NFT was detected, added manually or suggested by a dapp.
-   * @param options.networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @returns Promise resolving to the current NFT list.
-   */
-  async addNft(tokenAddress, tokenId, {
-    nftMetadata,
-    userAddress = this.config.selectedAddress,
-    source = "custom" /* Custom */,
-    networkClientId
-  } = { userAddress: this.config.selectedAddress }) {
-    tokenAddress = toChecksumHexAddress(tokenAddress);
-    const chainId = this.getCorrectChainId({ networkClientId });
-    nftMetadata = nftMetadata || await this.getNftInformation(tokenAddress, tokenId, networkClientId);
-    const newNftContracts = await this.addNftContract({
-      tokenAddress,
-      userAddress,
-      networkClientId,
-      source,
-      nftMetadata
-    });
-    const nftContract = newNftContracts.find(
-      (contract) => contract.address.toLowerCase() === tokenAddress.toLowerCase()
-    );
-    if (nftContract) {
-      await this.addIndividualNft(
-        tokenAddress,
-        tokenId,
-        nftMetadata,
-        nftContract,
-        chainId,
-        userAddress,
-        source
-      );
-    }
-  }
-  /**
-   * Refetches NFT metadata and updates the state
-   *
-   * @param options - Options for refetching NFT metadata
-   * @param options.nfts - nfts to update metadata for.
-   * @param options.userAddress - The current user address
-   * @param options.networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   */
-  async updateNftMetadata({
-    nfts,
-    userAddress = this.config.selectedAddress,
-    networkClientId
-  }) {
-    const chainId = this.getCorrectChainId({ networkClientId });
-    const nftsWithChecksumAdr = nfts.map((nft) => {
-      return {
-        ...nft,
-        address: toChecksumHexAddress(nft.address)
-      };
-    });
-    const nftMetadataResults = await Promise.allSettled(
-      nftsWithChecksumAdr.map(async (nft) => {
-        const resMetadata = await this.getNftInformation(
-          nft.address,
-          nft.tokenId,
-          networkClientId
-        );
-        return {
-          nft,
-          newMetadata: resMetadata
-        };
-      })
-    );
-    const successfulNewFetchedNfts = nftMetadataResults.filter(
-      (result) => result.status === "fulfilled"
-    );
-    const nftsWithDifferentMetadata = [];
-    const { allNfts } = this.state;
-    const stateNfts = allNfts[userAddress]?.[chainId] || [];
-    successfulNewFetchedNfts.forEach((singleNft) => {
-      const existingEntry = stateNfts.find(
-        (nft) => nft.address.toLowerCase() === singleNft.value.nft.address.toLowerCase() && nft.tokenId === singleNft.value.nft.tokenId
-      );
-      if (existingEntry) {
-        const differentMetadata = compareNftMetadata(
-          singleNft.value.newMetadata,
-          existingEntry
-        );
-        if (differentMetadata) {
-          nftsWithDifferentMetadata.push(singleNft);
-        }
-      }
-    });
-    if (nftsWithDifferentMetadata.length !== 0) {
-      nftsWithDifferentMetadata.forEach(
-        (elm) => this.updateNft(
-          elm.value.nft,
-          elm.value.newMetadata,
-          userAddress,
-          chainId
-        )
-      );
-    }
-  }
-  /**
-   * Removes an NFT from the stored token list.
-   *
-   * @param address - Hex address of the NFT contract.
-   * @param tokenId - Token identifier of the NFT.
-   * @param options - an object of arguments
-   * @param options.networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @param options.userAddress - The address of the account where the NFT is being removed.
-   */
-  removeNft(address, tokenId, {
-    networkClientId,
-    userAddress = this.config.selectedAddress
-  } = {
-    userAddress: this.config.selectedAddress
-  }) {
-    const chainId = this.getCorrectChainId({ networkClientId });
-    address = toChecksumHexAddress(address);
-    this.removeIndividualNft(address, tokenId, { chainId, userAddress });
-    const { allNfts } = this.state;
-    const nfts = allNfts[userAddress]?.[chainId] || [];
-    const remainingNft = nfts.find(
-      (nft) => nft.address.toLowerCase() === address.toLowerCase()
-    );
-    if (!remainingNft) {
-      this.removeNftContract(address, { chainId, userAddress });
-    }
-  }
-  /**
-   * Removes an NFT from the stored token list and saves it in ignored NFTs list.
-   *
-   * @param address - Hex address of the NFT contract.
-   * @param tokenId - Token identifier of the NFT.
-   * @param options - an object of arguments
-   * @param options.networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @param options.userAddress - The address of the account where the NFT is being removed.
-   */
-  removeAndIgnoreNft(address, tokenId, {
-    networkClientId,
-    userAddress = this.config.selectedAddress
-  } = {
-    userAddress: this.config.selectedAddress
-  }) {
-    const chainId = this.getCorrectChainId({ networkClientId });
-    address = toChecksumHexAddress(address);
-    this.removeAndIgnoreIndividualNft(address, tokenId, {
-      chainId,
-      userAddress
-    });
-    const { allNfts } = this.state;
-    const nfts = allNfts[userAddress]?.[chainId] || [];
-    const remainingNft = nfts.find(
-      (nft) => nft.address.toLowerCase() === address.toLowerCase()
-    );
-    if (!remainingNft) {
-      this.removeNftContract(address, { chainId, userAddress });
-    }
-  }
-  /**
-   * Removes all NFTs from the ignored list.
-   */
-  clearIgnoredNfts() {
-    this.update({ ignoredNfts: [] });
-  }
-  /**
-   * Checks whether input NFT is still owned by the user
-   * And updates the isCurrentlyOwned value on the NFT object accordingly.
-   *
-   * @param nft - The NFT object to check and update.
-   * @param batch - A boolean indicating whether this method is being called as part of a batch or single update.
-   * @param accountParams - The userAddress and chainId to check ownership against
-   * @param accountParams.userAddress - the address passed through the confirmed transaction flow to ensure assets are stored to the correct account
-   * @param accountParams.networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @returns the NFT with the updated isCurrentlyOwned value
-   */
-  async checkAndUpdateSingleNftOwnershipStatus(nft, batch, {
-    userAddress = this.config.selectedAddress,
-    networkClientId
-  } = {
-    userAddress: this.config.selectedAddress
-  }) {
-    const chainId = this.getCorrectChainId({ networkClientId });
-    const { address, tokenId } = nft;
-    let isOwned = nft.isCurrentlyOwned;
-    try {
-      isOwned = await this.isNftOwner(userAddress, address, tokenId, {
-        networkClientId
-      });
-    } catch {
-    }
-    nft.isCurrentlyOwned = isOwned;
-    if (batch) {
-      return nft;
-    }
-    const { allNfts } = this.state;
-    const nfts = allNfts[userAddress]?.[chainId] || [];
-    const nftToUpdate = nfts.find(
-      (item) => item.tokenId === tokenId && item.address.toLowerCase() === address.toLowerCase()
-    );
-    if (nftToUpdate) {
-      nftToUpdate.isCurrentlyOwned = isOwned;
-      this.updateNestedNftState(nfts, ALL_NFTS_STATE_KEY, {
-        userAddress,
-        chainId
-      });
-    }
-    return nft;
-  }
-  /**
-   * Checks whether NFTs associated with current selectedAddress/chainId combination are still owned by the user
-   * And updates the isCurrentlyOwned value on each accordingly.
-   * @param options - an object of arguments
-   * @param options.networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @param options.userAddress - The address of the account where the NFT ownership status is checked/updated.
-   */
-  async checkAndUpdateAllNftsOwnershipStatus({
-    networkClientId,
-    userAddress = this.config.selectedAddress
-  } = {
-    userAddress: this.config.selectedAddress
-  }) {
-    const chainId = this.getCorrectChainId({ networkClientId });
-    const { allNfts } = this.state;
-    const nfts = allNfts[userAddress]?.[chainId] || [];
-    const updatedNfts = await Promise.all(
-      nfts.map(async (nft) => {
-        return await this.checkAndUpdateSingleNftOwnershipStatus(nft, true, {
-          networkClientId,
-          userAddress
-        }) ?? nft;
-      })
-    );
-    this.updateNestedNftState(updatedNfts, ALL_NFTS_STATE_KEY, {
-      userAddress,
-      chainId
-    });
-  }
-  /**
-   * Update NFT favorite status.
-   *
-   * @param address - Hex address of the NFT contract.
-   * @param tokenId - Hex address of the NFT contract.
-   * @param favorite - NFT new favorite status.
-   * @param options - an object of arguments
-   * @param options.networkClientId - The networkClientId that can be used to identify the network client to use for this request.
-   * @param options.userAddress - The address of the account where the NFT is being removed.
-   */
-  updateNftFavoriteStatus(address, tokenId, favorite, {
-    networkClientId,
-    userAddress = this.config.selectedAddress
-  } = {
-    userAddress: this.config.selectedAddress
-  }) {
-    const chainId = this.getCorrectChainId({ networkClientId });
-    const { allNfts } = this.state;
-    const nfts = allNfts[userAddress]?.[chainId] || [];
-    const index = nfts.findIndex(
-      (nft) => nft.address === address && nft.tokenId === tokenId
-    );
-    if (index === -1) {
-      return;
-    }
-    const updatedNft = {
-      ...nfts[index],
-      favorite
-    };
-    nfts[index] = updatedNft;
-    this.updateNestedNftState(nfts, ALL_NFTS_STATE_KEY, {
-      chainId,
-      userAddress
-    });
-  }
-  /**
-   * Returns an NFT by the address and token id.
-   *
-   * @param address - Hex address of the NFT contract.
-   * @param tokenId - Number that represents the id of the token.
-   * @param selectedAddress - Hex address of the user account.
-   * @param chainId - Id of the current network.
-   * @returns Object containing the NFT and its position in the array
-   */
-  findNftByAddressAndTokenId(address, tokenId, selectedAddress, chainId) {
-    const { allNfts } = this.state;
-    const nfts = allNfts[selectedAddress]?.[chainId] || [];
-    const index = nfts.findIndex(
-      (nft) => nft.address.toLowerCase() === address.toLowerCase() && nft.tokenId === tokenId
-    );
-    if (index === -1) {
-      return null;
-    }
-    return { nft: nfts[index], index };
-  }
-  /**
-   * Update NFT data.
-   *
-   * @param nft - NFT object to find the right NFT to updates.
-   * @param updates - NFT partial object to update properties of the NFT.
-   * @param selectedAddress - Hex address of the user account.
-   * @param chainId - Id of the current network.
-   */
-  updateNft(nft, updates, selectedAddress, chainId) {
-    const { allNfts } = this.state;
-    const nfts = allNfts[selectedAddress]?.[chainId] || [];
-    const nftInfo = this.findNftByAddressAndTokenId(
-      nft.address,
-      nft.tokenId,
-      selectedAddress,
-      chainId
-    );
-    if (!nftInfo) {
-      return;
-    }
-    const updatedNft = {
-      ...nft,
-      ...updates
-    };
-    const newNfts = [
-      ...nfts.slice(0, nftInfo.index),
-      updatedNft,
-      ...nfts.slice(nftInfo.index + 1)
-    ];
-    this.updateNestedNftState(newNfts, ALL_NFTS_STATE_KEY, {
-      chainId,
-      userAddress: selectedAddress
-    });
-  }
-  /**
-   * Resets the transaction status of an NFT.
-   *
-   * @param transactionId - NFT transaction id.
-   * @param selectedAddress - Hex address of the user account.
-   * @param chainId - Id of the current network.
-   * @returns a boolean indicating if the reset was well succeeded or not
-   */
-  resetNftTransactionStatusByTransactionId(transactionId, selectedAddress, chainId) {
-    const { allNfts } = this.state;
-    const nfts = allNfts[selectedAddress]?.[chainId] || [];
-    const index = nfts.findIndex(
-      (nft) => nft.transactionId === transactionId
-    );
-    if (index === -1) {
-      return false;
-    }
-    const updatedNft = {
-      ...nfts[index],
-      transactionId: void 0
-    };
-    const newNfts = [
-      ...nfts.slice(0, index),
-      updatedNft,
-      ...nfts.slice(index + 1)
-    ];
-    this.updateNestedNftState(newNfts, ALL_NFTS_STATE_KEY, {
-      chainId,
-      userAddress: selectedAddress
-    });
-    return true;
-  }
-  async _requestApproval(suggestedNftMeta) {
-    return this.messagingSystem.call(
-      "ApprovalController:addRequest",
-      {
-        id: suggestedNftMeta.id,
-        origin: suggestedNftMeta.origin,
-        type: ApprovalType.WatchAsset,
-        requestData: {
-          id: suggestedNftMeta.id,
-          interactingAddress: suggestedNftMeta.interactingAddress,
-          asset: {
-            address: suggestedNftMeta.asset.address,
-            tokenId: suggestedNftMeta.asset.tokenId,
-            name: suggestedNftMeta.asset.name,
-            description: suggestedNftMeta.asset.description,
-            image: suggestedNftMeta.asset.image,
-            standard: suggestedNftMeta.asset.standard
-          }
-        }
-      },
-      true
-    );
-  }
-};
-var NftController_default = NftController;
-
-export {
-  getDefaultNftState,
-  NftController,
-  NftController_default
-};
-//# sourceMappingURL=chunk-46UZDIXW.mjs.map