@metamask/assets-controllers 38.0.0 → 38.0.1

package/dist/NftController.cjs

@@ -0,0 +1,1159 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _NftController_instances, _NftController_mutex, _NftController_selectedAccountId, _NftController_chainId, _NftController_ipfsGateway, _NftController_openSeaEnabled, _NftController_useIpfsSubdomains, _NftController_isIpfsGatewayEnabled, _NftController_onNftAdded, _NftController_onNetworkControllerNetworkDidChange, _NftController_onPreferencesControllerStateChange, _NftController_onSelectedAccountChange, _NftController_updateNestedNftState, _NftController_getNftCollectionApi, _NftController_getNftInformationFromApi, _NftController_getNftInformationFromTokenURI, _NftController_getNftURIAndStandard, _NftController_getNftInformation, _NftController_getNftContractInformationFromContract, _NftController_getNftContractInformation, _NftController_addIndividualNft, _NftController_addNftContract, _NftController_removeAndIgnoreIndividualNft, _NftController_removeIndividualNft, _NftController_removeNftContract, _NftController_validateWatchNft, _NftController_getCorrectChainId, _NftController_getAddressOrSelectedAddress, _NftController_updateNftUpdateForAccount;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NftController = exports.getDefaultNftControllerState = void 0;
+const address_1 = require("@ethersproject/address");
+const base_controller_1 = require("@metamask/base-controller");
+const controller_utils_1 = require("@metamask/controller-utils");
+const rpc_errors_1 = require("@metamask/rpc-errors");
+const utils_1 = require("@metamask/utils");
+const async_mutex_1 = require("async-mutex");
+const bn_js_1 = __importDefault(require("bn.js"));
+const uuid_1 = require("uuid");
+const assetsUtil_1 = require("./assetsUtil.cjs");
+const constants_1 = require("./constants.cjs");
+const nftControllerMetadata = {
+    allNftContracts: { persist: true, anonymous: false },
+    allNfts: { persist: true, anonymous: false },
+    ignoredNfts: { persist: true, anonymous: false },
+};
+const ALL_NFTS_STATE_KEY = 'allNfts';
+const ALL_NFTS_CONTRACTS_STATE_KEY = 'allNftContracts';
+/**
+ * The name of the {@link NftController}.
+ */
+const controllerName = 'NftController';
+const getDefaultNftControllerState = () => ({
+    allNftContracts: {},
+    allNfts: {},
+    ignoredNfts: [],
+});
+exports.getDefaultNftControllerState = getDefaultNftControllerState;
+/**
+ * Controller that stores assets and exposes convenience methods
+ */
+class NftController extends base_controller_1.BaseController {
+    /**
+     * Creates an NftController instance.
+     *
+     * @param options - The controller options.
+     * @param options.chainId - The chain ID of the current network.
+     * @param options.ipfsGateway - The configured IPFS gateway.
+     * @param options.openSeaEnabled - Controls whether the OpenSea API is used.
+     * @param options.useIpfsSubdomains - Controls whether IPFS subdomains are used.
+     * @param options.isIpfsGatewayEnabled - Controls whether IPFS is enabled or not.
+     * @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 options.state - Initial state to set on this controller.
+     */
+    constructor({ chainId: initialChainId, ipfsGateway = controller_utils_1.IPFS_DEFAULT_GATEWAY_URL, openSeaEnabled = false, useIpfsSubdomains = true, isIpfsGatewayEnabled = true, onNftAdded, messenger, state = {}, }) {
+        super({
+            name: controllerName,
+            metadata: nftControllerMetadata,
+            messenger,
+            state: {
+                ...(0, exports.getDefaultNftControllerState)(),
+                ...state,
+            },
+        });
+        _NftController_instances.add(this);
+        _NftController_mutex.set(this, new async_mutex_1.Mutex());
+        _NftController_selectedAccountId.set(this, void 0);
+        _NftController_chainId.set(this, void 0);
+        _NftController_ipfsGateway.set(this, void 0);
+        _NftController_openSeaEnabled.set(this, void 0);
+        _NftController_useIpfsSubdomains.set(this, void 0);
+        _NftController_isIpfsGatewayEnabled.set(this, void 0);
+        _NftController_onNftAdded.set(this, void 0);
+        __classPrivateFieldSet(this, _NftController_selectedAccountId, this.messagingSystem.call('AccountsController:getSelectedAccount').id, "f");
+        __classPrivateFieldSet(this, _NftController_chainId, initialChainId, "f");
+        __classPrivateFieldSet(this, _NftController_ipfsGateway, ipfsGateway, "f");
+        __classPrivateFieldSet(this, _NftController_openSeaEnabled, openSeaEnabled, "f");
+        __classPrivateFieldSet(this, _NftController_useIpfsSubdomains, useIpfsSubdomains, "f");
+        __classPrivateFieldSet(this, _NftController_isIpfsGatewayEnabled, isIpfsGatewayEnabled, "f");
+        __classPrivateFieldSet(this, _NftController_onNftAdded, onNftAdded, "f");
+        this.messagingSystem.subscribe('PreferencesController:stateChange', 
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_onPreferencesControllerStateChange).bind(this));
+        this.messagingSystem.subscribe('NetworkController:networkDidChange', __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_onNetworkControllerNetworkDidChange).bind(this));
+        this.messagingSystem.subscribe('AccountsController:selectedEvmAccountChange', 
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_onSelectedAccountChange).bind(this));
+    }
+    getNftApi() {
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        return `${controller_utils_1.NFT_API_BASE_URL}/tokens`;
+    }
+    /**
+     * 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, } = {}) {
+        const addressToSearch = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getAddressOrSelectedAddress).call(this, userAddress);
+        if (!addressToSearch) {
+            return;
+        }
+        await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_validateWatchNft).call(this, asset, type, addressToSearch);
+        const nftMetadata = await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getNftInformation).call(this, asset.address, asset.tokenId, networkClientId);
+        if (nftMetadata.standard && nftMetadata.standard !== type) {
+            throw rpc_errors_1.rpcErrors.invalidInput(`Suggested NFT of type ${nftMetadata.standard} does not match received type ${type}`);
+        }
+        const suggestedNftMeta = {
+            asset: { ...asset, ...nftMetadata },
+            type,
+            id: (0, uuid_1.v4)(),
+            time: Date.now(),
+            interactingAddress: addressToSearch,
+            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: constants_1.Source.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, } = {}) {
+        // Checks the ownership for ERC-721.
+        try {
+            const owner = await this.messagingSystem.call('AssetsContractController:getERC721OwnerOf', nftAddress, tokenId, networkClientId);
+            return ownerAddress.toLowerCase() === owner.toLowerCase();
+            // eslint-disable-next-line no-empty
+        }
+        catch {
+            // Ignore ERC-721 contract error
+        }
+        // Checks the ownership for ERC-1155.
+        try {
+            const balance = await this.messagingSystem.call('AssetsContractController:getERC1155BalanceOf', ownerAddress, nftAddress, tokenId, networkClientId);
+            return !balance.isZero();
+            // eslint-disable-next-line no-empty
+        }
+        catch {
+            // Ignore ERC-1155 contract error
+        }
+        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, networkClientId, source, } = {}) {
+        const addressToSearch = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getAddressOrSelectedAddress).call(this, userAddress);
+        if (!(await this.isNftOwner(addressToSearch, address, tokenId, {
+            networkClientId,
+        }))) {
+            throw new Error('This NFT is not owned by the user');
+        }
+        await this.addNft(address, tokenId, {
+            networkClientId,
+            userAddress: addressToSearch,
+            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, source = constants_1.Source.Custom, networkClientId, } = {}) {
+        const addressToSearch = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getAddressOrSelectedAddress).call(this, userAddress);
+        if (!addressToSearch) {
+            return;
+        }
+        const checksumHexAddress = (0, controller_utils_1.toChecksumHexAddress)(tokenAddress);
+        const chainId = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getCorrectChainId).call(this, { networkClientId });
+        nftMetadata =
+            nftMetadata ||
+                (await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getNftInformation).call(this, checksumHexAddress, tokenId, networkClientId));
+        const newNftContracts = await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addNftContract).call(this, {
+            tokenAddress: checksumHexAddress,
+            userAddress: addressToSearch,
+            networkClientId,
+            source,
+            nftMetadata,
+        });
+        // If NFT contract was not added, do not add individual NFT
+        const nftContract = newNftContracts.find((contract) => contract.address.toLowerCase() === checksumHexAddress.toLowerCase());
+        // If NFT contract information, add individual NFT
+        if (nftContract) {
+            await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addIndividualNft).call(this, checksumHexAddress, tokenId, nftMetadata, nftContract, chainId, addressToSearch, 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, networkClientId, }) {
+        const addressToSearch = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getAddressOrSelectedAddress).call(this, userAddress);
+        const releaseLock = await __classPrivateFieldGet(this, _NftController_mutex, "f").acquire();
+        try {
+            const chainId = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getCorrectChainId).call(this, { networkClientId });
+            const nftsWithChecksumAdr = nfts.map((nft) => {
+                return {
+                    ...nft,
+                    address: (0, controller_utils_1.toChecksumHexAddress)(nft.address),
+                };
+            });
+            const nftMetadataResults = await Promise.all(nftsWithChecksumAdr.map(async (nft) => {
+                const resMetadata = await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getNftInformation).call(this, nft.address, nft.tokenId, networkClientId);
+                return {
+                    nft,
+                    newMetadata: resMetadata,
+                };
+            }));
+            // We want to avoid updating the state if the state and fetched nft info are the same
+            const nftsWithDifferentMetadata = [];
+            const { allNfts } = this.state;
+            const stateNfts = allNfts[addressToSearch]?.[chainId] || [];
+            nftMetadataResults.forEach((singleNft) => {
+                const existingEntry = stateNfts.find((nft) => nft.address.toLowerCase() === singleNft.nft.address.toLowerCase() &&
+                    nft.tokenId === singleNft.nft.tokenId);
+                if (existingEntry) {
+                    const differentMetadata = (0, assetsUtil_1.compareNftMetadata)(singleNft.newMetadata, existingEntry);
+                    if (differentMetadata) {
+                        nftsWithDifferentMetadata.push(singleNft);
+                    }
+                }
+            });
+            if (nftsWithDifferentMetadata.length !== 0) {
+                nftsWithDifferentMetadata.forEach((elm) => this.updateNft(elm.nft, elm.newMetadata, addressToSearch, chainId));
+            }
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    /**
+     * 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, } = {}) {
+        const addressToSearch = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getAddressOrSelectedAddress).call(this, userAddress);
+        const chainId = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getCorrectChainId).call(this, { networkClientId });
+        const checksumHexAddress = (0, controller_utils_1.toChecksumHexAddress)(address);
+        __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_removeIndividualNft).call(this, checksumHexAddress, tokenId, {
+            chainId,
+            userAddress: addressToSearch,
+        });
+        const { allNfts } = this.state;
+        const nfts = allNfts[addressToSearch]?.[chainId] || [];
+        const remainingNft = nfts.find((nft) => nft.address.toLowerCase() === checksumHexAddress.toLowerCase());
+        if (!remainingNft) {
+            __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_removeNftContract).call(this, checksumHexAddress, {
+                chainId,
+                userAddress: addressToSearch,
+            });
+        }
+    }
+    /**
+     * 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, } = {}) {
+        const addressToSearch = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getAddressOrSelectedAddress).call(this, userAddress);
+        const chainId = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getCorrectChainId).call(this, { networkClientId });
+        const checksumHexAddress = (0, controller_utils_1.toChecksumHexAddress)(address);
+        __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_removeAndIgnoreIndividualNft).call(this, checksumHexAddress, tokenId, {
+            chainId,
+            userAddress: addressToSearch,
+        });
+        const { allNfts } = this.state;
+        const nfts = allNfts[addressToSearch]?.[chainId] || [];
+        const remainingNft = nfts.find((nft) => nft.address.toLowerCase() === checksumHexAddress.toLowerCase());
+        if (!remainingNft) {
+            __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_removeNftContract).call(this, checksumHexAddress, {
+                chainId,
+                userAddress: addressToSearch,
+            });
+        }
+    }
+    /**
+     * Removes all NFTs from the ignored list.
+     */
+    clearIgnoredNfts() {
+        this.update((state) => {
+            state.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, networkClientId, } = {}) {
+        const addressToSearch = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getAddressOrSelectedAddress).call(this, userAddress);
+        const chainId = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getCorrectChainId).call(this, { networkClientId });
+        const { address, tokenId } = nft;
+        let isOwned = nft.isCurrentlyOwned;
+        try {
+            isOwned = await this.isNftOwner(addressToSearch, address, tokenId, {
+                networkClientId,
+            });
+        }
+        catch {
+            // ignore error
+            // this will only throw an error 'Unable to verify ownership' in which case
+            // we want to keep the current value of isCurrentlyOwned for this flow.
+        }
+        const updatedNft = {
+            ...nft,
+            isCurrentlyOwned: isOwned,
+        };
+        if (batch) {
+            return updatedNft;
+        }
+        // if this is not part of a batched update we update this one NFT in state
+        const { allNfts } = this.state;
+        const nfts = [...(allNfts[addressToSearch]?.[chainId] || [])];
+        const indexToUpdate = nfts.findIndex((item) => item.tokenId === tokenId &&
+            item.address.toLowerCase() === address.toLowerCase());
+        if (indexToUpdate !== -1) {
+            nfts[indexToUpdate] = updatedNft;
+            this.update((state) => {
+                state.allNfts[addressToSearch] = Object.assign({}, state.allNfts[addressToSearch], {
+                    [chainId]: nfts,
+                });
+            });
+            __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNestedNftState).call(this, nfts, ALL_NFTS_STATE_KEY, {
+                userAddress: addressToSearch,
+                chainId,
+            });
+        }
+        return updatedNft;
+    }
+    /**
+     * 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, } = {}) {
+        const addressToSearch = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getAddressOrSelectedAddress).call(this, userAddress);
+        const chainId = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getCorrectChainId).call(this, { networkClientId });
+        const { allNfts } = this.state;
+        const nfts = allNfts[addressToSearch]?.[chainId] || [];
+        const updatedNfts = await Promise.all(nfts.map(async (nft) => {
+            return ((await this.checkAndUpdateSingleNftOwnershipStatus(nft, true, {
+                networkClientId,
+                userAddress,
+            })) ?? nft);
+        }));
+        __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNestedNftState).call(this, updatedNfts, ALL_NFTS_STATE_KEY, {
+            userAddress: addressToSearch,
+            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, } = {}) {
+        const addressToSearch = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getAddressOrSelectedAddress).call(this, userAddress);
+        const chainId = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getCorrectChainId).call(this, { networkClientId });
+        const { allNfts } = this.state;
+        const nfts = [...(allNfts[addressToSearch]?.[chainId] || [])];
+        const index = nfts.findIndex((nft) => nft.address === address && nft.tokenId === tokenId);
+        if (index === -1) {
+            return;
+        }
+        const updatedNft = {
+            ...nfts[index],
+            favorite,
+        };
+        // Update Nfts array
+        nfts[index] = updatedNft;
+        __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNestedNftState).call(this, nfts, ALL_NFTS_STATE_KEY, {
+            chainId,
+            userAddress: addressToSearch,
+        });
+    }
+    /**
+     * 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),
+        ];
+        __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNestedNftState).call(this, 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: undefined,
+        };
+        const newNfts = [
+            ...nfts.slice(0, index),
+            updatedNft,
+            ...nfts.slice(index + 1),
+        ];
+        __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNestedNftState).call(this, newNfts, ALL_NFTS_STATE_KEY, {
+            chainId,
+            userAddress: selectedAddress,
+        });
+        return true;
+    }
+    /**
+     * Fetches NFT Collection Metadata from the NFT API.
+     *
+     * @param contractAddresses - The contract addresses of the NFTs.
+     * @param chainId - The chain ID of the network where the NFT is located.
+     * @returns NFT collections metadata.
+     */
+    async getNFTContractInfo(contractAddresses, chainId) {
+        const url = new URL(__classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getNftCollectionApi).call(this));
+        url.searchParams.append('chainId', chainId);
+        for (const address of contractAddresses) {
+            url.searchParams.append('contract', address);
+        }
+        return await (0, controller_utils_1.handleFetch)(url, {
+            headers: {
+                Version: controller_utils_1.NFT_API_VERSION,
+            },
+        });
+    }
+    async _requestApproval(suggestedNftMeta) {
+        return this.messagingSystem.call('ApprovalController:addRequest', {
+            id: suggestedNftMeta.id,
+            origin: suggestedNftMeta.origin,
+            type: controller_utils_1.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);
+    }
+}
+exports.NftController = NftController;
+_NftController_mutex = new WeakMap(), _NftController_selectedAccountId = new WeakMap(), _NftController_chainId = new WeakMap(), _NftController_ipfsGateway = new WeakMap(), _NftController_openSeaEnabled = new WeakMap(), _NftController_useIpfsSubdomains = new WeakMap(), _NftController_isIpfsGatewayEnabled = new WeakMap(), _NftController_onNftAdded = new WeakMap(), _NftController_instances = new WeakSet(), _NftController_onNetworkControllerNetworkDidChange = function _NftController_onNetworkControllerNetworkDidChange({ selectedNetworkClientId, }) {
+    const { configuration: { chainId }, } = this.messagingSystem.call('NetworkController:getNetworkClientById', selectedNetworkClientId);
+    __classPrivateFieldSet(this, _NftController_chainId, chainId, "f");
+}, _NftController_onPreferencesControllerStateChange = 
+/**
+ * Handles the state change of the preference controller.
+ * @param preferencesState - The new state of the preference controller.
+ * @param preferencesState.ipfsGateway - The configured IPFS gateway.
+ * @param preferencesState.openSeaEnabled - Controls whether the OpenSea API is used.
+ * @param preferencesState.isIpfsGatewayEnabled - Controls whether IPFS is enabled or not.
+ */
+async function _NftController_onPreferencesControllerStateChange({ ipfsGateway, openSeaEnabled, isIpfsGatewayEnabled, }) {
+    const selectedAccount = this.messagingSystem.call('AccountsController:getSelectedAccount');
+    __classPrivateFieldSet(this, _NftController_selectedAccountId, selectedAccount.id, "f");
+    __classPrivateFieldSet(this, _NftController_ipfsGateway, ipfsGateway, "f");
+    __classPrivateFieldSet(this, _NftController_openSeaEnabled, openSeaEnabled, "f");
+    __classPrivateFieldSet(this, _NftController_isIpfsGatewayEnabled, isIpfsGatewayEnabled, "f");
+    const needsUpdateNftMetadata = (isIpfsGatewayEnabled && ipfsGateway !== '') || openSeaEnabled;
+    if (needsUpdateNftMetadata && selectedAccount) {
+        await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNftUpdateForAccount).call(this, selectedAccount);
+    }
+}, _NftController_onSelectedAccountChange = 
+/**
+ * Handles the selected account change on the accounts controller.
+ * @param internalAccount - The new selected account.
+ */
+async function _NftController_onSelectedAccountChange(internalAccount) {
+    const oldSelectedAccountId = __classPrivateFieldGet(this, _NftController_selectedAccountId, "f");
+    __classPrivateFieldSet(this, _NftController_selectedAccountId, internalAccount.id, "f");
+    const needsUpdateNftMetadata = ((__classPrivateFieldGet(this, _NftController_isIpfsGatewayEnabled, "f") && __classPrivateFieldGet(this, _NftController_ipfsGateway, "f") !== '') ||
+        __classPrivateFieldGet(this, _NftController_openSeaEnabled, "f")) &&
+        oldSelectedAccountId !== internalAccount.id;
+    if (needsUpdateNftMetadata) {
+        await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNftUpdateForAccount).call(this, internalAccount);
+    }
+}, _NftController_updateNestedNftState = function _NftController_updateNestedNftState(newCollection, baseStateKey, { userAddress, chainId }) {
+    // userAddress can be an empty string if it is not set via an account change or in constructor
+    // while this doesn't cause any issues, we want to ensure that we don't store assets to an empty string address
+    if (!userAddress) {
+        return;
+    }
+    this.update((state) => {
+        const oldState = state[baseStateKey];
+        const addressState = oldState[userAddress] || {};
+        const newAddressState = {
+            ...addressState,
+            [chainId]: newCollection,
+        };
+        state[baseStateKey] = {
+            ...oldState,
+            [userAddress]: newAddressState,
+        };
+    });
+}, _NftController_getNftCollectionApi = function _NftController_getNftCollectionApi() {
+    // False negative.
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    return `${controller_utils_1.NFT_API_BASE_URL}/collections`;
+}, _NftController_getNftInformationFromApi = 
+/**
+ * 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 function _NftController_getNftInformationFromApi(contractAddress, tokenId) {
+    // TODO Parameterize this by chainId for non-mainnet token detection
+    // Attempt to fetch the data with the nft-api
+    const urlParams = new URLSearchParams({
+        chainIds: '1',
+        tokens: `${contractAddress}:${tokenId}`,
+        includeTopBid: 'true',
+        includeAttributes: 'true',
+        includeLastSale: 'true',
+    }).toString();
+    // First fetch token information
+    const nftInformation = await (0, controller_utils_1.fetchWithErrorHandling)({
+        url: `${this.getNftApi()}?${urlParams}`,
+        options: {
+            headers: {
+                Version: controller_utils_1.NFT_API_VERSION,
+            },
+        },
+    });
+    // Params for getCollections API call
+    const getCollectionParams = new URLSearchParams({
+        chainId: '1',
+        id: `${nftInformation?.tokens[0]?.token?.collection?.id}`,
+    }).toString();
+    // Fetch collection information using collectionId
+    const collectionInformation = await (0, controller_utils_1.fetchWithErrorHandling)({
+        url: `${controller_utils_1.NFT_API_BASE_URL}/collections?${getCollectionParams}`,
+        options: {
+            headers: {
+                Version: controller_utils_1.NFT_API_VERSION,
+            },
+        },
+    });
+    // if we were still unable to fetch the data we return out the default/null of `NftMetadata`
+    if (!nftInformation?.tokens?.[0]?.token) {
+        return {
+            name: null,
+            description: null,
+            image: null,
+            standard: null,
+        };
+    }
+    // if we've reached this point, we have successfully fetched some data for nftInformation
+    // now we reconfigure the data to conform to the `NftMetadata` type for storage.
+    const { image, metadata: { imageOriginal } = {}, name, description, collection, kind, rarityRank, rarity, attributes, lastSale, imageSmall, } = nftInformation.tokens[0].token;
+    /* istanbul ignore next */
+    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 || collectionInformation) && {
+        collection: {
+            ...(collection || {}),
+            creator: collection?.creator ||
+                collectionInformation?.collections[0].creator,
+            openseaVerificationStatus: collectionInformation?.collections[0].openseaVerificationStatus,
+            contractDeployedAt: collectionInformation?.collections[0].contractDeployedAt,
+            ownerCount: collectionInformation?.collections[0].ownerCount,
+            topBid: collectionInformation?.collections[0].topBid,
+        },
+    });
+    return nftMetadata;
+}, _NftController_getNftInformationFromTokenURI = 
+/**
+ * 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 function _NftController_getNftInformationFromTokenURI(contractAddress, tokenId, networkClientId) {
+    const result = await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getNftURIAndStandard).call(this, contractAddress, tokenId, networkClientId);
+    let tokenURI = result[0];
+    const standard = result[1];
+    const hasIpfsTokenURI = tokenURI.startsWith('ipfs://');
+    if (hasIpfsTokenURI && !__classPrivateFieldGet(this, _NftController_isIpfsGatewayEnabled, "f")) {
+        return {
+            image: null,
+            name: null,
+            description: null,
+            standard: standard || null,
+            favorite: false,
+            tokenURI: tokenURI ?? null,
+        };
+    }
+    const isDisplayNFTMediaToggleEnabled = __classPrivateFieldGet(this, _NftController_openSeaEnabled, "f");
+    if (!hasIpfsTokenURI && !isDisplayNFTMediaToggleEnabled) {
+        return {
+            image: null,
+            name: null,
+            description: null,
+            standard: standard || null,
+            favorite: false,
+            tokenURI: tokenURI ?? null,
+        };
+    }
+    if (hasIpfsTokenURI) {
+        tokenURI = await (0, assetsUtil_1.getFormattedIpfsUrl)(__classPrivateFieldGet(this, _NftController_ipfsGateway, "f"), tokenURI, __classPrivateFieldGet(this, _NftController_useIpfsSubdomains, "f"));
+    }
+    if (tokenURI.startsWith('data:image/')) {
+        return {
+            image: tokenURI,
+            name: null,
+            description: null,
+            standard: standard || null,
+            favorite: false,
+            tokenURI: tokenURI ?? null,
+        };
+    }
+    try {
+        const object = await (0, controller_utils_1.handleFetch)(tokenURI);
+        // TODO: Check image_url existence. This is not part of EIP721 nor EIP1155
+        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,
+        };
+    }
+}, _NftController_getNftURIAndStandard = 
+/**
+ * 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 function _NftController_getNftURIAndStandard(contractAddress, tokenId, networkClientId) {
+    // try ERC721 uri
+    try {
+        const uri = await this.messagingSystem.call('AssetsContractController:getERC721TokenURI', contractAddress, tokenId, networkClientId);
+        return [uri, controller_utils_1.ERC721];
+    }
+    catch {
+        // Ignore error
+    }
+    // try ERC1155 uri
+    try {
+        const tokenURI = await this.messagingSystem.call('AssetsContractController:getERC1155TokenURI', contractAddress, tokenId, networkClientId);
+        /**
+         * According to EIP1155 the URI value allows for ID substitution
+         * in case the string `{id}` exists.
+         * https://eips.ethereum.org/EIPS/eip-1155#metadata
+         */
+        if (!tokenURI.includes('{id}')) {
+            return [tokenURI, controller_utils_1.ERC1155];
+        }
+        const hexTokenId = (0, utils_1.remove0x)((0, controller_utils_1.BNToHex)(new bn_js_1.default(tokenId)))
+            .padStart(64, '0')
+            .toLowerCase();
+        return [tokenURI.replace('{id}', hexTokenId), controller_utils_1.ERC1155];
+    }
+    catch {
+        // Ignore error
+    }
+    return ['', ''];
+}, _NftController_getNftInformation = 
+/**
+ * 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 function _NftController_getNftInformation(contractAddress, tokenId, networkClientId) {
+    const chainId = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getCorrectChainId).call(this, {
+        networkClientId,
+    });
+    const [blockchainMetadata, nftApiMetadata] = await Promise.all([
+        (0, controller_utils_1.safelyExecute)(() => __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getNftInformationFromTokenURI).call(this, contractAddress, tokenId, networkClientId)),
+        __classPrivateFieldGet(this, _NftController_openSeaEnabled, "f") && chainId === '0x1'
+            ? (0, controller_utils_1.safelyExecute)(() => __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getNftInformationFromApi).call(this, contractAddress, tokenId))
+            : undefined,
+    ]);
+    return {
+        ...nftApiMetadata,
+        name: blockchainMetadata?.name ?? nftApiMetadata?.name ?? null,
+        description: blockchainMetadata?.description ?? nftApiMetadata?.description ?? null,
+        image: nftApiMetadata?.image ?? blockchainMetadata?.image ?? null,
+        standard: blockchainMetadata?.standard ?? nftApiMetadata?.standard ?? null,
+        tokenURI: blockchainMetadata?.tokenURI ?? null,
+    };
+}, _NftController_getNftContractInformationFromContract = 
+/**
+ * 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 function _NftController_getNftContractInformationFromContract(contractAddress, networkClientId) {
+    const [name, symbol] = await Promise.all([
+        this.messagingSystem.call('AssetsContractController:getERC721AssetName', contractAddress, networkClientId),
+        this.messagingSystem.call('AssetsContractController:getERC721AssetSymbol', contractAddress, networkClientId),
+    ]);
+    return {
+        collection: { name },
+        symbol,
+        address: contractAddress,
+    };
+}, _NftController_getNftContractInformation = 
+/**
+ * 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 function _NftController_getNftContractInformation(contractAddress, nftMetadataFromApi, networkClientId) {
+    const blockchainContractData = await (0, controller_utils_1.safelyExecute)(() => __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getNftContractInformationFromContract).call(this, contractAddress, networkClientId));
+    if (blockchainContractData ||
+        !Object.values(nftMetadataFromApi).every((value) => value === null)) {
+        return {
+            address: contractAddress,
+            ...blockchainContractData,
+            // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            schema_name: nftMetadataFromApi?.standard ?? null,
+            collection: {
+                name: null,
+                // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                image_url: nftMetadataFromApi?.collection?.image ??
+                    nftMetadataFromApi?.collection?.imageUrl ??
+                    null,
+                tokenCount: nftMetadataFromApi?.collection?.tokenCount ?? null,
+                ...nftMetadataFromApi?.collection,
+                ...blockchainContractData?.collection,
+            },
+        };
+    }
+    /* istanbul ignore next */
+    return {
+        address: contractAddress,
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        asset_contract_type: null,
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        created_date: null,
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        schema_name: null,
+        symbol: null,
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        total_supply: null,
+        description: null,
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        external_link: null,
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        collection: { name: null, image_url: null },
+    };
+}, _NftController_addIndividualNft = 
+/**
+ * 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 A promise resolving to `undefined`.
+ */
+async function _NftController_addIndividualNft(tokenAddress, tokenId, nftMetadata, nftContract, chainId, userAddress, source) {
+    const releaseLock = await __classPrivateFieldGet(this, _NftController_mutex, "f").acquire();
+    try {
+        const checksumHexAddress = (0, controller_utils_1.toChecksumHexAddress)(tokenAddress);
+        const { allNfts } = this.state;
+        const nfts = [...(allNfts[userAddress]?.[chainId] ?? [])];
+        const existingEntry = nfts.find((nft) => nft.address.toLowerCase() === checksumHexAddress.toLowerCase() &&
+            nft.tokenId === tokenId);
+        if (existingEntry) {
+            const differentMetadata = (0, assetsUtil_1.compareNftMetadata)(nftMetadata, existingEntry);
+            const hasNewFields = (0, assetsUtil_1.hasNewCollectionFields)(nftMetadata, existingEntry);
+            if (!differentMetadata &&
+                existingEntry.isCurrentlyOwned &&
+                !hasNewFields) {
+                return;
+            }
+            const indexToUpdate = nfts.findIndex((nft) => nft.address.toLowerCase() === checksumHexAddress.toLowerCase() &&
+                nft.tokenId === tokenId);
+            if (indexToUpdate !== -1) {
+                nfts[indexToUpdate] = {
+                    ...existingEntry,
+                    ...nftMetadata,
+                };
+            }
+        }
+        else {
+            const newEntry = {
+                address: checksumHexAddress,
+                tokenId,
+                favorite: false,
+                isCurrentlyOwned: true,
+                ...nftMetadata,
+            };
+            nfts.push(newEntry);
+        }
+        __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNestedNftState).call(this, nfts, ALL_NFTS_STATE_KEY, {
+            chainId,
+            userAddress,
+        });
+        if (__classPrivateFieldGet(this, _NftController_onNftAdded, "f")) {
+            __classPrivateFieldGet(this, _NftController_onNftAdded, "f").call(this, {
+                address: checksumHexAddress,
+                symbol: nftContract.symbol,
+                tokenId: tokenId.toString(),
+                standard: nftMetadata.standard,
+                source,
+            });
+        }
+    }
+    finally {
+        releaseLock();
+    }
+}, _NftController_addNftContract = 
+/**
+ * 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 function _NftController_addNftContract({ tokenAddress, userAddress, networkClientId, source, nftMetadata, }) {
+    const releaseLock = await __classPrivateFieldGet(this, _NftController_mutex, "f").acquire();
+    try {
+        const checksumHexAddress = (0, controller_utils_1.toChecksumHexAddress)(tokenAddress);
+        const { allNftContracts } = this.state;
+        const chainId = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getCorrectChainId).call(this, {
+            networkClientId,
+        });
+        const nftContracts = allNftContracts[userAddress]?.[chainId] || [];
+        const existingEntry = nftContracts.find((nftContract) => nftContract.address.toLowerCase() ===
+            checksumHexAddress.toLowerCase());
+        if (existingEntry) {
+            return nftContracts;
+        }
+        // this doesn't work currently for detection if the user switches networks while the detection is processing
+        // will be fixed once detection uses networkClientIds
+        // get name and symbol if ERC721 then put together the metadata
+        const contractInformation = await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getNftContractInformation).call(this, checksumHexAddress, nftMetadata, networkClientId);
+        const { 
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        asset_contract_type, 
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        created_date, symbol, description, 
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        external_link, 
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        schema_name, 
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        collection: { name, image_url, tokenCount }, } = contractInformation;
+        // If the nft is auto-detected we want some valid metadata to be present
+        if (source === constants_1.Source.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;
+        }
+        /* istanbul ignore next */
+        const newEntry = Object.assign({}, { address: checksumHexAddress }, 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];
+        __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNestedNftState).call(this, newNftContracts, ALL_NFTS_CONTRACTS_STATE_KEY, {
+            chainId,
+            userAddress,
+        });
+        return newNftContracts;
+    }
+    finally {
+        releaseLock();
+    }
+}, _NftController_removeAndIgnoreIndividualNft = function _NftController_removeAndIgnoreIndividualNft(address, tokenId, { chainId, userAddress, }) {
+    const checksumHexAddress = (0, controller_utils_1.toChecksumHexAddress)(address);
+    const { allNfts, ignoredNfts } = this.state;
+    const newIgnoredNfts = [...ignoredNfts];
+    const nfts = allNfts[userAddress]?.[chainId] || [];
+    const newNfts = nfts.filter((nft) => {
+        if (nft.address.toLowerCase() === checksumHexAddress.toLowerCase() &&
+            nft.tokenId === tokenId) {
+            const alreadyIgnored = newIgnoredNfts.find((c) => c.address === checksumHexAddress && c.tokenId === tokenId);
+            !alreadyIgnored && newIgnoredNfts.push(nft);
+            return false;
+        }
+        return true;
+    });
+    __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNestedNftState).call(this, newNfts, ALL_NFTS_STATE_KEY, {
+        userAddress,
+        chainId,
+    });
+    this.update((state) => {
+        state.ignoredNfts = newIgnoredNfts;
+    });
+}, _NftController_removeIndividualNft = function _NftController_removeIndividualNft(address, tokenId, { chainId, userAddress }) {
+    const checksumHexAddress = (0, controller_utils_1.toChecksumHexAddress)(address);
+    const { allNfts } = this.state;
+    const nfts = allNfts[userAddress]?.[chainId] || [];
+    const newNfts = nfts.filter((nft) => !(nft.address.toLowerCase() === checksumHexAddress.toLowerCase() &&
+        nft.tokenId === tokenId));
+    __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNestedNftState).call(this, newNfts, ALL_NFTS_STATE_KEY, {
+        userAddress,
+        chainId,
+    });
+}, _NftController_removeNftContract = function _NftController_removeNftContract(address, { chainId, userAddress }) {
+    const checksumHexAddress = (0, controller_utils_1.toChecksumHexAddress)(address);
+    const { allNftContracts } = this.state;
+    const nftContracts = allNftContracts[userAddress]?.[chainId] || [];
+    const newNftContracts = nftContracts.filter((nftContract) => !(nftContract.address.toLowerCase() === checksumHexAddress.toLowerCase()));
+    __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNestedNftState).call(this, newNftContracts, ALL_NFTS_CONTRACTS_STATE_KEY, {
+        chainId,
+        userAddress,
+    });
+    return newNftContracts;
+}, _NftController_validateWatchNft = async function _NftController_validateWatchNft(asset, type, userAddress, { networkClientId } = {}) {
+    const { address: contractAddress, tokenId } = asset;
+    // Validate parameters
+    if (!type) {
+        throw rpc_errors_1.rpcErrors.invalidParams('Asset type is required');
+    }
+    if (type !== controller_utils_1.ERC721 && type !== controller_utils_1.ERC1155) {
+        throw rpc_errors_1.rpcErrors.invalidParams(
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        `Non NFT asset type ${type} not supported by watchNft`);
+    }
+    if (!contractAddress || !tokenId) {
+        throw rpc_errors_1.rpcErrors.invalidParams('Both address and tokenId are required');
+    }
+    if (!(0, address_1.isAddress)(contractAddress)) {
+        throw rpc_errors_1.rpcErrors.invalidParams('Invalid address');
+    }
+    if (!/^\d+$/u.test(tokenId)) {
+        throw rpc_errors_1.rpcErrors.invalidParams('Invalid tokenId');
+    }
+    // Check if the user owns the suggested NFT
+    try {
+        const isOwner = await this.isNftOwner(userAddress, contractAddress, tokenId, { networkClientId });
+        if (!isOwner) {
+            throw rpc_errors_1.rpcErrors.invalidInput('Suggested NFT is not owned by the selected account');
+        }
+    }
+    catch (error) {
+        // error thrown here: "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."
+        if (error instanceof Error) {
+            throw rpc_errors_1.rpcErrors.resourceUnavailable(error.message);
+        }
+        throw error;
+    }
+}, _NftController_getCorrectChainId = function _NftController_getCorrectChainId({ networkClientId, }) {
+    if (networkClientId) {
+        const { configuration: { chainId }, } = this.messagingSystem.call('NetworkController:getNetworkClientById', networkClientId);
+        return chainId;
+    }
+    return __classPrivateFieldGet(this, _NftController_chainId, "f");
+}, _NftController_getAddressOrSelectedAddress = function _NftController_getAddressOrSelectedAddress(address) {
+    if (address) {
+        return address;
+    }
+    // If the address is not defined (or empty), we fallback to the currently selected account's address
+    const selectedAccount = this.messagingSystem.call('AccountsController:getAccount', __classPrivateFieldGet(this, _NftController_selectedAccountId, "f"));
+    return selectedAccount?.address || '';
+}, _NftController_updateNftUpdateForAccount = async function _NftController_updateNftUpdateForAccount(account) {
+    const nfts = this.state.allNfts[account.address]?.[__classPrivateFieldGet(this, _NftController_chainId, "f")] ?? [];
+    // Filter only nfts
+    const nftsToUpdate = nfts.filter((singleNft) => !singleNft.name && !singleNft.description && !singleNft.image);
+    if (nftsToUpdate.length !== 0) {
+        await this.updateNftMetadata({
+            nfts: nftsToUpdate,
+            userAddress: account.address,
+        });
+    }
+};
+exports.default = NftController;
+//# sourceMappingURL=NftController.cjs.map