@metamask/assets-controllers 100.0.3 → 100.2.0

package/dist/NftController.mjs

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _NftController_instances, _NftController_mutex, _NftController_selectedAccountId, _NftController_ipfsGateway, _NftController_displayNftMedia, _NftController_useIpfsSubdomains, _NftController_isIpfsGatewayEnabled, _NftController_onNftAdded, _NftController_onPreferencesControllerStateChange, _NftController_onSelectedAccountChange, _NftController_updateNestedNftState, _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_getAddressOrSelectedAddress, _NftController_updateNftUpdateForAccount, _NftController_bulkSanitizeNftMetadata, _NftController_sanitizeNftMetadata;
+var _NftController_instances, _NftController_mutex, _NftController_selectedAccountId, _NftController_ipfsGateway, _NftController_displayNftMedia, _NftController_useIpfsSubdomains, _NftController_isIpfsGatewayEnabled, _NftController_onNftAdded, _NftController_onPreferencesControllerStateChange, _NftController_onSelectedAccountChange, _NftController_updateNestedNftState, _NftController_getNftInformationFromApi, _NftController_getNftInformationFromTokenURI, _NftController_getNftURIAndStandard, _NftController_getNftInformation, _NftController_getNftContractInformation, _NftController_addMultipleNfts, _NftController_addNftContracts, _NftController_removeAndIgnoreIndividualNft, _NftController_removeIndividualNft, _NftController_removeNftContract, _NftController_validateWatchNft, _NftController_getAddressOrSelectedAddress, _NftController_updateNftUpdateForAccount, _NftController_bulkSanitizeNftMetadata, _NftController_sanitizeNftMetadata;
 function $importDefault(module) {
     if (module?.__esModule) {
         return module.default;
@@ -234,23 +234,35 @@ export class NftController extends BaseController {
             // Sanitize provided metadata
             nftMetadata = await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_sanitizeNftMetadata).call(this, nftMetadata);
         }
-        const newNftContracts = await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addNftContract).call(this, networkClientId, {
-            tokenAddress: checksumHexAddress,
-            userAddress: addressToSearch,
-            source,
-            nftMetadata,
-        });
+        const { contracts: newNftContracts } = await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addNftContracts).call(this, addressToSearch, [
+            {
+                tokenAddress: checksumHexAddress,
+                networkClientId,
+                source,
+                nftMetadata,
+            },
+        ]);
         // If NFT contract was not added, do not add individual NFT
-        const nftContract = newNftContracts.find((contract) => contract.address.toLowerCase() === checksumHexAddress.toLowerCase());
+        const nftContract = Object.values(newNftContracts)
+            .flat()
+            .find((contract) => contract.address.toLowerCase() === checksumHexAddress.toLowerCase());
         const { configuration: { chainId }, } = this.messenger.call('NetworkController:getNetworkClientById', networkClientId);
         // This is the case when the NFT is added manually and not detected automatically
         // TODO: An improvement would be to make the chainId a required field and return it when getting the NFT information
         if (!nftMetadata.chainId) {
             nftMetadata.chainId = convertHexToDecimal(chainId);
         }
-        // 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);
+            await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addMultipleNfts).call(this, addressToSearch, [
+                {
+                    tokenAddress: checksumHexAddress,
+                    tokenId,
+                    nftMetadata,
+                    nftContract,
+                    chainId,
+                    source,
+                },
+            ]);
         }
     }
     /**
@@ -271,23 +283,51 @@ export class NftController extends BaseController {
         }
         // Remember max number of urls this allows is 250
         const sanitizedNftMetadata = await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_bulkSanitizeNftMetadata).call(this, nfts.map((nft) => nft.nftMetadata));
+        // Resolve network client IDs per item up front. Items that fail (e.g.,
+        // the user removes a network during detection) are skipped individually
+        // so the rest of the batch is unaffected. Resolved data is bundled into
+        // one object per NFT to avoid index-alignment issues between the two loops.
+        const resolvedNfts = [];
         for (const [index, nft] of nfts.entries()) {
-            const checksumHexAddress = toChecksumHexAddress(nft.tokenAddress);
-            const hexChainId = toHex(nft.nftMetadata.chainId);
-            const networkClientId = this.messenger.call('NetworkController:findNetworkClientIdByChainId', hexChainId);
-            const newNftContracts = await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addNftContract).call(this, networkClientId, {
-                tokenAddress: checksumHexAddress,
-                userAddress: addressToSearch,
-                source,
-                nftMetadata: sanitizedNftMetadata[index],
-            });
-            // 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
+            try {
+                const checksumHexAddress = toChecksumHexAddress(nft.tokenAddress);
+                const hexChainId = toHex(nft.nftMetadata.chainId);
+                const networkClientId = this.messenger.call('NetworkController:findNetworkClientIdByChainId', hexChainId);
+                resolvedNfts.push({
+                    contractToAdd: {
+                        networkClientId,
+                        tokenAddress: checksumHexAddress,
+                        source,
+                        nftMetadata: sanitizedNftMetadata[index],
+                    },
+                    tokenId: nft.tokenId,
+                    checksumHexAddress,
+                    hexChainId,
+                    sanitizedMetadata: sanitizedNftMetadata[index],
+                });
+            }
+            catch (error) {
+                console.error('Failed to resolve network for NFT', nft.tokenAddress, error);
+            }
+        }
+        const { contracts: newNftContracts } = await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addNftContracts).call(this, addressToSearch, resolvedNfts.map((item) => item.contractToAdd));
+        const nftsToAdd = [];
+        for (const { checksumHexAddress, tokenId, hexChainId, sanitizedMetadata, } of resolvedNfts) {
+            const nftContract = newNftContracts[hexChainId]?.find((contract) => contract.address.toLowerCase() === checksumHexAddress.toLowerCase());
             if (nftContract) {
-                await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addIndividualNft).call(this, checksumHexAddress, nft.tokenId, sanitizedNftMetadata[index], nftContract, hexChainId, addressToSearch, source);
+                nftsToAdd.push({
+                    tokenAddress: checksumHexAddress,
+                    tokenId,
+                    nftMetadata: sanitizedMetadata,
+                    nftContract,
+                    chainId: hexChainId,
+                    source,
+                });
             }
         }
+        if (nftsToAdd.length > 0) {
+            await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addMultipleNfts).call(this, addressToSearch, nftsToAdd);
+        }
     }
     /**
      * Refetches NFT metadata and updates the state
@@ -869,43 +909,16 @@ async function _NftController_getNftInformation(contractAddress, tokenId, networ
     };
     // Sanitize the metadata by checking external links against phishing protection
     return await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_sanitizeNftMetadata).call(this, metadata);
-}, _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(
-// TODO for calls to blockchain we need to explicitly pass the currentNetworkClientId since its relying on the provider
-contractAddress, networkClientId) {
-    const [name, symbol] = await Promise.all([
-        this.messenger.call('AssetsContractController:getERC721AssetName', contractAddress, networkClientId),
-        this.messenger.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 safelyExecute(() => __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getNftContractInformationFromContract).call(this, contractAddress, networkClientId));
-    if (blockchainContractData ||
+}, _NftController_getNftContractInformation = function _NftController_getNftContractInformation(contractAddress, nftMetadataFromApi) {
+    const name = nftMetadataFromApi.collection?.name;
+    const symbol = nftMetadataFromApi.collection?.symbol;
+    if (name !== undefined ||
+        symbol !== undefined ||
         !Object.values(nftMetadataFromApi).every((value) => value === null)) {
         return {
             address: contractAddress,
-            ...blockchainContractData,
             schema_name: nftMetadataFromApi?.standard ?? null,
+            ...(symbol !== undefined && { symbol }),
             collection: {
                 name: null,
                 image_url: nftMetadataFromApi?.collection?.image ??
@@ -913,7 +926,7 @@ async function _NftController_getNftContractInformation(contractAddress, nftMeta
                     null,
                 tokenCount: nftMetadataFromApi?.collection?.tokenCount ?? null,
                 ...nftMetadataFromApi?.collection,
-                ...blockchainContractData?.collection,
+                ...(name !== undefined && { name }),
             },
         };
     }
@@ -929,122 +942,157 @@ async function _NftController_getNftContractInformation(contractAddress, nftMeta
         external_link: null,
         collection: { name: null, image_url: null },
     };
-}, _NftController_addIndividualNft = 
+}, _NftController_addMultipleNfts = 
 /**
- * Adds an individual NFT to the stored NFT list.
+ * Adds multiple NFTs to the stored NFT list for a given user.
  *
- * @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`.
+ * @param userAddress - The address of the account where the NFTs are being added.
+ * @param nfts - Array of NFT objects to add.
+ * @param nfts[].tokenAddress - Hex address of the NFT contract.
+ * @param nfts[].tokenId - The NFT identifier.
+ * @param nfts[].nftMetadata - NFT optional information (name, image and description).
+ * @param nfts[].nftContract - An object containing contract data of the NFT being added.
+ * @param nfts[].chainId - The chainId of the network where the NFT is being added.
+ * @param nfts[].source - Whether the NFT was detected, added manually or suggested by a dapp.
  */
-async function _NftController_addIndividualNft(tokenAddress, tokenId, nftMetadata, nftContract, chainId, userAddress, source) {
+async function _NftController_addMultipleNfts(userAddress, nfts) {
     const releaseLock = await __classPrivateFieldGet(this, _NftController_mutex, "f").acquire();
     try {
-        const checksumHexAddress = 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 = compareNftMetadata(nftMetadata, existingEntry);
-            const hasNewFields = hasNewCollectionFields(nftMetadata, existingEntry);
-            if (!differentMetadata &&
-                existingEntry.isCurrentlyOwned &&
-                !hasNewFields) {
-                return;
+        const allNftsForUser = allNfts[userAddress] || {};
+        const allNftsForUserPerChain = {};
+        const modifiedChainIds = new Set();
+        const pendingCallbacks = [];
+        for (const { tokenAddress, tokenId, nftMetadata, nftContract, chainId, source, } of nfts) {
+            try {
+                const checksumHexAddress = toChecksumHexAddress(tokenAddress);
+                if (!allNftsForUserPerChain[chainId]) {
+                    allNftsForUserPerChain[chainId] = [
+                        ...(allNftsForUser?.[chainId] ?? []),
+                    ];
+                }
+                const existingEntry = allNftsForUserPerChain[chainId].find((nft) => nft.address.toLowerCase() === checksumHexAddress.toLowerCase() &&
+                    nft.tokenId === tokenId);
+                if (existingEntry) {
+                    const differentMetadata = compareNftMetadata(nftMetadata, existingEntry);
+                    const hasNewFields = hasNewCollectionFields(nftMetadata, existingEntry);
+                    if (!differentMetadata &&
+                        existingEntry.isCurrentlyOwned &&
+                        !hasNewFields) {
+                        continue;
+                    }
+                    const indexToUpdate = allNftsForUserPerChain[chainId].findIndex((nft) => nft.address.toLowerCase() ===
+                        checksumHexAddress.toLowerCase() && nft.tokenId === tokenId);
+                    if (indexToUpdate !== -1) {
+                        allNftsForUserPerChain[chainId][indexToUpdate] = {
+                            ...existingEntry,
+                            ...nftMetadata,
+                        };
+                    }
+                }
+                else {
+                    const newEntry = {
+                        address: checksumHexAddress,
+                        tokenId,
+                        favorite: false,
+                        isCurrentlyOwned: true,
+                        ...nftMetadata,
+                    };
+                    allNftsForUserPerChain[chainId].push(newEntry);
+                }
+                modifiedChainIds.add(chainId);
+                if (__classPrivateFieldGet(this, _NftController_onNftAdded, "f")) {
+                    pendingCallbacks.push({
+                        address: checksumHexAddress,
+                        symbol: nftContract.symbol,
+                        tokenId: tokenId.toString(),
+                        standard: nftMetadata.standard,
+                        source,
+                    });
+                }
             }
-            const indexToUpdate = nfts.findIndex((nft) => nft.address.toLowerCase() === checksumHexAddress.toLowerCase() &&
-                nft.tokenId === tokenId);
-            if (indexToUpdate !== -1) {
-                nfts[indexToUpdate] = {
-                    ...existingEntry,
-                    ...nftMetadata,
-                };
+            catch (error) {
+                console.error('Failed to add NFT', tokenAddress, tokenId, error);
             }
         }
-        else {
-            const newEntry = {
-                address: checksumHexAddress,
-                tokenId,
-                favorite: false,
-                isCurrentlyOwned: true,
-                ...nftMetadata,
-            };
-            nfts.push(newEntry);
+        for (const chainId of modifiedChainIds) {
+            __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNestedNftState).call(this, allNftsForUserPerChain[chainId], ALL_NFTS_STATE_KEY, { chainId, userAddress });
         }
-        __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,
-            });
+        for (const callbackData of pendingCallbacks) {
+            __classPrivateFieldGet(this, _NftController_onNftAdded, "f")?.call(this, callbackData);
         }
     }
     finally {
         releaseLock();
     }
-}, _NftController_addNftContract = 
+}, _NftController_addNftContracts = 
 /**
- * Adds an NFT contract to the stored NFT contracts list.
+ * Adds multiple NFT contracts to the stored NFT contracts list for a given user.
  *
- * @param networkClientId - The networkClientId that can be used to identify the network client to use for this request.
- * @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.source - Whether the NFT was detected, added manually or suggested by a dapp.
- * @returns Promise resolving to the current NFT contracts list.
+ * @param userAddress - The address of the account where the NFT contracts are being added.
+ * @param contracts - Array of contract objects to add.
+ * @param contracts[].networkClientId - The networkClientId used to identify the network client for the request.
+ * @param contracts[].tokenAddress - Hex address of the NFT contract.
+ * @param contracts[].nftMetadata - The retrieved NFT metadata from the API.
+ * @param contracts[].source - Whether the NFT was detected, added manually or suggested by a dapp.
+ * @returns Promise resolving to an object mapping chainIds to their updated NFT contract arrays.
  */
-async function _NftController_addNftContract(networkClientId, { tokenAddress, userAddress, source, nftMetadata, }) {
+async function _NftController_addNftContracts(userAddress, contracts) {
     const releaseLock = await __classPrivateFieldGet(this, _NftController_mutex, "f").acquire();
     try {
-        const checksumHexAddress = toChecksumHexAddress(tokenAddress);
         const { allNftContracts } = this.state;
-        const { configuration: { chainId }, } = this.messenger.call('NetworkController:getNetworkClientById', networkClientId);
-        const nftContracts = allNftContracts[userAddress]?.[chainId] || [];
-        const existingEntry = nftContracts.find((nftContract) => nftContract.address.toLowerCase() ===
-            checksumHexAddress.toLowerCase());
-        if (existingEntry) {
-            return nftContracts;
+        const allNftContractsForUser = allNftContracts[userAddress] || {};
+        const nftContractsForUserPerChain = {};
+        const modifiedChainIds = new Set();
+        for (const { networkClientId, tokenAddress, source, nftMetadata, } of contracts) {
+            try {
+                const checksumHexAddress = toChecksumHexAddress(tokenAddress);
+                const { configuration: { chainId }, } = this.messenger.call('NetworkController:getNetworkClientById', networkClientId);
+                // Initialised before the existingEntry check so pre-existing contracts
+                // are still present in the returned map for callers to look up.
+                if (!nftContractsForUserPerChain[chainId]) {
+                    nftContractsForUserPerChain[chainId] = [
+                        ...(allNftContractsForUser?.[chainId] ?? []),
+                    ];
+                }
+                const existingEntry = nftContractsForUserPerChain[chainId].find((nftContract) => nftContract.address.toLowerCase() ===
+                    checksumHexAddress.toLowerCase());
+                if (existingEntry) {
+                    continue;
+                }
+                // 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 = __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_getNftContractInformation).call(this, checksumHexAddress, nftMetadata);
+                // If the nft is auto-detected we want some valid metadata to be present
+                if (source === 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;
+                    })) {
+                    continue;
+                }
+                const { asset_contract_type, created_date, symbol, description, external_link, schema_name, collection: { name, image_url, tokenCount }, } = contractInformation;
+                /* 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 });
+                nftContractsForUserPerChain[chainId].push(newEntry);
+                modifiedChainIds.add(chainId);
+            }
+            catch (error) {
+                console.error('Failed to add NFT contract', tokenAddress, error);
+            }
         }
-        // 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 { asset_contract_type, created_date, symbol, description, external_link, schema_name, collection: { name, image_url, tokenCount }, } = contractInformation;
-        // If the nft is auto-detected we want some valid metadata to be present
-        if (source === 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;
+        // Loops once per chain (not once per NFT contract)
+        for (const chainId of modifiedChainIds) {
+            __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNestedNftState).call(this, nftContractsForUserPerChain[chainId], ALL_NFTS_CONTRACTS_STATE_KEY, { chainId, userAddress });
         }
-        /* 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;
+        return { contracts: nftContractsForUserPerChain };
     }
     finally {
         releaseLock();