@metamask/assets-controllers 26.0.0 → 27.0.1

package/dist/chunk-74IP34EL.js

@@ -0,0 +1,1177 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+
+
+
+var _chunkYD3NRMFCjs = require('./chunk-YD3NRMFC.js');
+
+// src/NftController.ts
+var _address = require('@ethersproject/address');
+var _basecontroller = require('@metamask/base-controller');
+
+
+
+
+
+
+
+
+
+
+
+var _controllerutils = require('@metamask/controller-utils');
+var _rpcerrors = require('@metamask/rpc-errors');
+var _utils = require('@metamask/utils');
+var _asyncmutex = require('async-mutex');
+var _bnjs = require('bn.js'); var _bnjs2 = _interopRequireDefault(_bnjs);
+var _events = require('events');
+var _uuid = require('uuid');
+var OpenSeaV2ChainIds = /* @__PURE__ */ ((OpenSeaV2ChainIds2) => {
+  OpenSeaV2ChainIds2["ethereum"] = "ethereum";
+  return OpenSeaV2ChainIds2;
+})(OpenSeaV2ChainIds || {});
+var ALL_NFTS_STATE_KEY = "allNfts";
+var ALL_NFTS_CONTRACTS_STATE_KEY = "allNftContracts";
+var getDefaultNftState = () => {
+  return {
+    allNftContracts: {},
+    allNfts: {},
+    ignoredNfts: []
+  };
+};
+var NftController = class extends _basecontroller.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 (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 = "NftController";
+    this.defaultConfig = {
+      selectedAddress: "",
+      chainId: initialChainId,
+      ipfsGateway: _controllerutils.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(
+      ({
+        selectedAddress,
+        ipfsGateway,
+        openSeaEnabled,
+        isIpfsGatewayEnabled
+      }) => {
+        this.configure({
+          selectedAddress,
+          ipfsGateway,
+          openSeaEnabled,
+          isIpfsGatewayEnabled
+        });
+      }
+    );
+    onNetworkStateChange(({ providerConfig }) => {
+      const { chainId } = providerConfig;
+      this.configure({ chainId });
+    });
+  }
+  getNftApi({
+    contractAddress,
+    tokenId
+  }) {
+    return `${_controllerutils.OPENSEA_PROXY_URL}/chain/${"ethereum" /* ethereum */}/contract/${contractAddress}/nfts/${tokenId}`;
+  }
+  getNftContractInformationApi({
+    contractAddress
+  }) {
+    return `${_controllerutils.OPENSEA_PROXY_URL}/chain/${"ethereum" /* ethereum */}/contract/${contractAddress}`;
+  }
+  getNftCollectionInformationApi({
+    collectionSlug
+  }) {
+    return `${_controllerutils.OPENSEA_PROXY_URL}/collections/${collectionSlug}`;
+  }
+  /**
+   * 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 OpenSea 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 nftInformation = await _controllerutils.fetchWithErrorHandling.call(void 0, {
+      url: this.getNftApi({
+        contractAddress,
+        tokenId
+      })
+    });
+    if (!nftInformation?.nft) {
+      return {
+        name: null,
+        description: null,
+        image: null,
+        standard: null
+      };
+    }
+    const {
+      num_sales,
+      background_color,
+      image_url,
+      image_preview_url,
+      image_thumbnail_url,
+      image_original_url,
+      animation_url,
+      animation_original_url,
+      name,
+      description,
+      external_link,
+      creator,
+      last_sale,
+      asset_contract: { schema_name }
+    } = _chunkYD3NRMFCjs.mapOpenSeaDetailedNftV2ToV1.call(void 0, nftInformation.nft);
+    const nftMetadata = Object.assign(
+      {},
+      { name: name || null },
+      { description: description || null },
+      { image: image_url || null },
+      creator && { creator },
+      num_sales && { numberOfSales: num_sales },
+      background_color && { backgroundColor: background_color },
+      image_preview_url && { imagePreview: image_preview_url },
+      image_thumbnail_url && { imageThumbnail: image_thumbnail_url },
+      image_original_url && { imageOriginal: image_original_url },
+      animation_url && { animation: animation_url },
+      animation_original_url && {
+        animationOriginal: animation_original_url
+      },
+      external_link && { externalLink: external_link },
+      last_sale && { lastSale: last_sale },
+      schema_name && { standard: schema_name }
+    );
+    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 = _chunkYD3NRMFCjs.getFormattedIpfsUrl.call(void 0, ipfsGateway, tokenURI, useIPFSSubdomains);
+    }
+    try {
+      const object = await _controllerutils.handleFetch.call(void 0, 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, _controllerutils.ERC721];
+    } catch {
+    }
+    try {
+      const tokenURI = await this.getERC1155TokenURI(
+        contractAddress,
+        tokenId,
+        networkClientId
+      );
+      if (!tokenURI.includes("{id}")) {
+        return [tokenURI, _controllerutils.ERC1155];
+      }
+      const hexTokenId = _utils.remove0x.call(void 0, _controllerutils.BNToHex.call(void 0, new (0, _bnjs2.default)(tokenId))).padStart(64, "0").toLowerCase();
+      return [tokenURI.replace("{id}", hexTokenId), _controllerutils.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, openSeaMetadata] = await Promise.all([
+      _controllerutils.safelyExecute.call(void 0, 
+        () => this.getNftInformationFromTokenURI(
+          contractAddress,
+          tokenId,
+          networkClientId
+        )
+      ),
+      this.config.openSeaEnabled && chainId === "0x1" ? _controllerutils.safelyExecute.call(void 0, 
+        () => this.getNftInformationFromApi(contractAddress, tokenId)
+      ) : void 0
+    ]);
+    return {
+      ...openSeaMetadata,
+      name: blockchainMetadata?.name ?? openSeaMetadata?.name ?? null,
+      description: blockchainMetadata?.description ?? openSeaMetadata?.description ?? null,
+      image: blockchainMetadata?.image ?? openSeaMetadata?.image ?? null,
+      standard: blockchainMetadata?.standard ?? openSeaMetadata?.standard ?? null,
+      tokenURI: blockchainMetadata?.tokenURI ?? null
+    };
+  }
+  /**
+   * Request NFT contract information from OpenSea API.
+   *
+   * @param contractAddress - Hex address of the NFT contract.
+   * @returns Promise resolving to the current NFT name and image.
+   */
+  async getNftContractInformationFromApi(contractAddress) {
+    const apiNftContractObject = await _controllerutils.fetchWithErrorHandling.call(void 0, {
+      url: this.getNftContractInformationApi({
+        contractAddress
+      })
+    });
+    if (apiNftContractObject) {
+      const collection = await _controllerutils.fetchWithErrorHandling.call(void 0, {
+        url: this.getNftCollectionInformationApi({
+          collectionSlug: apiNftContractObject.collection
+        })
+      });
+      return _chunkYD3NRMFCjs.mapOpenSeaContractV2ToV1.call(void 0, apiNftContractObject, 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
+      }
+    };
+  }
+  /**
+   * 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 OpenSea API.
+   *
+   * @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 NFT contract name, image and description.
+   */
+  async getNftContractInformation(contractAddress, networkClientId) {
+    const chainId = this.getCorrectChainId({
+      networkClientId
+    });
+    const [blockchainContractData, openSeaContractData] = await Promise.all([
+      _controllerutils.safelyExecute.call(void 0, 
+        () => this.getNftContractInformationFromContract(
+          contractAddress,
+          networkClientId
+        )
+      ),
+      this.config.openSeaEnabled && chainId === "0x1" ? _controllerutils.safelyExecute.call(void 0, 
+        () => this.getNftContractInformationFromApi(contractAddress)
+      ) : void 0
+    ]);
+    if (blockchainContractData || openSeaContractData) {
+      return {
+        address: contractAddress,
+        ...openSeaContractData,
+        ...blockchainContractData,
+        collection: {
+          name: null,
+          image_url: null,
+          ...openSeaContractData?.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 = _controllerutils.toChecksumHexAddress.call(void 0, 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 = _chunkYD3NRMFCjs.compareNftMetadata.call(void 0, 
+          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.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
+  }) {
+    const releaseLock = await this.mutex.acquire();
+    try {
+      tokenAddress = _controllerutils.toChecksumHexAddress.call(void 0, 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,
+        networkClientId
+      );
+      const {
+        asset_contract_type,
+        created_date,
+        schema_name,
+        symbol,
+        total_supply,
+        description,
+        external_link,
+        collection: { name, image_url }
+      } = 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 },
+        total_supply !== null && typeof total_supply !== "undefined" && { totalSupply: total_supply },
+        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 = _controllerutils.toChecksumHexAddress.call(void 0, 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 = _controllerutils.toChecksumHexAddress.call(void 0, 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 = _controllerutils.toChecksumHexAddress.call(void 0, 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.rpcErrors.invalidParams("Asset type is required");
+    }
+    if (type !== _controllerutils.ERC721 && type !== _controllerutils.ERC1155) {
+      throw _rpcerrors.rpcErrors.invalidParams(
+        `Non NFT asset type ${type} not supported by watchNft`
+      );
+    }
+    if (!contractAddress || !tokenId) {
+      throw _rpcerrors.rpcErrors.invalidParams("Both address and tokenId are required");
+    }
+    if (!_address.isAddress.call(void 0, contractAddress)) {
+      throw _rpcerrors.rpcErrors.invalidParams("Invalid address");
+    }
+    if (!/^\d+$/u.test(tokenId)) {
+      throw _rpcerrors.rpcErrors.invalidParams("Invalid tokenId");
+    }
+    try {
+      const isOwner = await this.isNftOwner(
+        userAddress,
+        contractAddress,
+        tokenId,
+        { networkClientId }
+      );
+      if (!isOwner) {
+        throw _rpcerrors.rpcErrors.invalidInput(
+          "Suggested NFT is not owned by the selected account"
+        );
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        throw _rpcerrors.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.rpcErrors.invalidInput(
+        `Suggested NFT of type ${nftMetadata.standard} does not match received type ${type}`
+      );
+    }
+    const suggestedNftMeta = {
+      asset: { ...asset, ...nftMetadata },
+      type,
+      id: _uuid.v4.call(void 0, ),
+      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 = _controllerutils.toChecksumHexAddress.call(void 0, tokenAddress);
+    const chainId = this.getCorrectChainId({ networkClientId });
+    const newNftContracts = await this.addNftContract({
+      tokenAddress,
+      userAddress,
+      networkClientId,
+      source
+    });
+    nftMetadata = nftMetadata || await this.getNftInformation(tokenAddress, tokenId, networkClientId);
+    const nftContract = newNftContracts.find(
+      (contract) => contract.address.toLowerCase() === tokenAddress.toLowerCase()
+    );
+    if (nftContract) {
+      await this.addIndividualNft(
+        tokenAddress,
+        tokenId,
+        nftMetadata,
+        nftContract,
+        chainId,
+        userAddress,
+        source
+      );
+    }
+  }
+  /**
+   * 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 = _controllerutils.toChecksumHexAddress.call(void 0, 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 = _controllerutils.toChecksumHexAddress.call(void 0, 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: _controllerutils.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;
+
+
+
+
+
+
+exports.OpenSeaV2ChainIds = OpenSeaV2ChainIds; exports.getDefaultNftState = getDefaultNftState; exports.NftController = NftController; exports.NftController_default = NftController_default;
+//# sourceMappingURL=chunk-74IP34EL.js.map