@metamask-previews/assets-controllers 100.1.0-preview-384cfdfef → 100.1.0-preview-15dd7d63f

package/CHANGELOG.md

@@ -7,20 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Added
-
-- Add optional `networkConfigurationsByChainId` parameter to `calculateBalanceForAllWallets`, `calculateBalanceChangeForAllWallets`, and `calculateBalanceChangeForAccountGroup`. When provided, native (and staked-native) token balances fall back to `CurrencyRateController` when `TokenRatesController` has no market data for the chain, so aggregated balance can be displayed when only a native-currency rate is available. Export type `NetworkConfigurationNativeCurrency` for consumers passing network configs into these functions ([#8141](https://github.com/MetaMask/core/pull/8141))
-
 ### Changed
 
-- Optimize NFT Controller state writes from O(2n) to O(2) for NFT detection by batching contract and NFT additions ([#8079](https://github.com/MetaMask/core/pull/8079))
-- Remove on-chain ERC-721 RPC fallback for contract name and symbol in `NftController`; contract metadata is now sourced exclusively from the NFT API, eliminating `getERC721AssetName`/`getERC721AssetSymbol` calls during NFT detection. NFT contracts that previously had `name` or `symbol` populated via on-chain calls will no longer have those fields if the NFT API does not supply them ([#8079](https://github.com/MetaMask/core/pull/8079))
 - When `isHomepageSectionsV1Enabled` is true, `AccountTrackerController` now uses all popular EVM networks (via `NetworkEnablementController:listPopularEvmNetworks`) for balance refresh on account change and keyring unlock, instead of only the enabled networks from `NetworkEnablementController` state ([#8117](https://github.com/MetaMask/core/pull/8117))
 
 ### Fixed
 
 - Gate `TokenListController` polling on controller initialization to avoid duplicate token list API requests during startup races ([#8113](https://github.com/MetaMask/core/pull/8113))
-- Update token balance fallback behavior so missing ERC-20 balances from `AccountsApiBalanceFetcher` are returned as `unprocessedTokens` and fetched through RPC fallback, rather than being forcibly set to zero ([#8132](https://github.com/MetaMask/core/pull/8132))
 
 ## [100.1.0]
 

package/dist/NftController.cjs

@@ -13,7 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-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;
+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;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NftController = exports.getDefaultNftControllerState = void 0;
 const address_1 = require("@ethersproject/address");
@@ -234,35 +234,23 @@ class NftController extends base_controller_1.BaseController {
             // Sanitize provided metadata
             nftMetadata = await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_sanitizeNftMetadata).call(this, nftMetadata);
         }
-        const { contracts: newNftContracts } = await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addNftContracts).call(this, addressToSearch, [
-            {
-                tokenAddress: checksumHexAddress,
-                networkClientId,
-                source,
-                nftMetadata,
-            },
-        ]);
+        const newNftContracts = await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addNftContract).call(this, networkClientId, {
+            tokenAddress: checksumHexAddress,
+            userAddress: addressToSearch,
+            source,
+            nftMetadata,
+        });
         // If NFT contract was not added, do not add individual NFT
-        const nftContract = Object.values(newNftContracts)
-            .flat()
-            .find((contract) => contract.address.toLowerCase() === checksumHexAddress.toLowerCase());
+        const nftContract = newNftContracts.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 = (0, controller_utils_1.convertHexToDecimal)(chainId);
         }
+        // If NFT contract information, add individual NFT
         if (nftContract) {
-            await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addMultipleNfts).call(this, addressToSearch, [
-                {
-                    tokenAddress: checksumHexAddress,
-                    tokenId,
-                    nftMetadata,
-                    nftContract,
-                    chainId,
-                    source,
-                },
-            ]);
+            await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addIndividualNft).call(this, checksumHexAddress, tokenId, nftMetadata, nftContract, chainId, addressToSearch, source);
         }
     }
     /**
@@ -283,51 +271,23 @@ class NftController extends base_controller_1.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()) {
-            try {
-                const checksumHexAddress = (0, controller_utils_1.toChecksumHexAddress)(nft.tokenAddress);
-                const hexChainId = (0, controller_utils_1.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());
+            const checksumHexAddress = (0, controller_utils_1.toChecksumHexAddress)(nft.tokenAddress);
+            const hexChainId = (0, controller_utils_1.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
             if (nftContract) {
-                nftsToAdd.push({
-                    tokenAddress: checksumHexAddress,
-                    tokenId,
-                    nftMetadata: sanitizedMetadata,
-                    nftContract,
-                    chainId: hexChainId,
-                    source,
-                });
+                await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addIndividualNft).call(this, checksumHexAddress, nft.tokenId, sanitizedNftMetadata[index], nftContract, hexChainId, addressToSearch, source);
             }
         }
-        if (nftsToAdd.length > 0) {
-            await __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_addMultipleNfts).call(this, addressToSearch, nftsToAdd);
-        }
     }
     /**
      * Refetches NFT metadata and updates the state
@@ -910,16 +870,43 @@ 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_getNftContractInformation = function _NftController_getNftContractInformation(contractAddress, nftMetadataFromApi) {
-    const name = nftMetadataFromApi.collection?.name;
-    const symbol = nftMetadataFromApi.collection?.symbol;
-    if (name !== undefined ||
-        symbol !== undefined ||
+}, _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 (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,
             schema_name: nftMetadataFromApi?.standard ?? null,
-            ...(symbol !== undefined && { symbol }),
             collection: {
                 name: null,
                 image_url: nftMetadataFromApi?.collection?.image ??
@@ -927,7 +914,7 @@ async function _NftController_getNftInformation(contractAddress, tokenId, networ
                     null,
                 tokenCount: nftMetadataFromApi?.collection?.tokenCount ?? null,
                 ...nftMetadataFromApi?.collection,
-                ...(name !== undefined && { name }),
+                ...blockchainContractData?.collection,
             },
         };
     }
@@ -943,157 +930,122 @@ async function _NftController_getNftInformation(contractAddress, tokenId, networ
         external_link: null,
         collection: { name: null, image_url: null },
     };
-}, _NftController_addMultipleNfts = 
+}, _NftController_addIndividualNft = 
 /**
- * Adds multiple NFTs to the stored NFT list for a given user.
+ * Adds an individual NFT to the stored NFT list.
  *
- * @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.
+ * @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_addMultipleNfts(userAddress, nfts) {
+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 allNftsForUser = allNfts[userAddress] || {};
-        const allNftsForUserPerChain = {};
-        const modifiedChainIds = new Set();
-        const pendingCallbacks = [];
-        for (const { tokenAddress, tokenId, nftMetadata, nftContract, chainId, source, } of nfts) {
-            try {
-                const checksumHexAddress = (0, controller_utils_1.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 = (0, assetsUtil_1.compareNftMetadata)(nftMetadata, existingEntry);
-                    const hasNewFields = (0, assetsUtil_1.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 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;
             }
-            catch (error) {
-                console.error('Failed to add NFT', tokenAddress, tokenId, error);
+            const indexToUpdate = nfts.findIndex((nft) => nft.address.toLowerCase() === checksumHexAddress.toLowerCase() &&
+                nft.tokenId === tokenId);
+            if (indexToUpdate !== -1) {
+                nfts[indexToUpdate] = {
+                    ...existingEntry,
+                    ...nftMetadata,
+                };
             }
         }
-        for (const chainId of modifiedChainIds) {
-            __classPrivateFieldGet(this, _NftController_instances, "m", _NftController_updateNestedNftState).call(this, allNftsForUserPerChain[chainId], ALL_NFTS_STATE_KEY, { chainId, userAddress });
+        else {
+            const newEntry = {
+                address: checksumHexAddress,
+                tokenId,
+                favorite: false,
+                isCurrentlyOwned: true,
+                ...nftMetadata,
+            };
+            nfts.push(newEntry);
         }
-        for (const callbackData of pendingCallbacks) {
-            __classPrivateFieldGet(this, _NftController_onNftAdded, "f")?.call(this, callbackData);
+        __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_addNftContracts = 
+}, _NftController_addNftContract = 
 /**
- * Adds multiple NFT contracts to the stored NFT contracts list for a given user.
+ * Adds an NFT contract to the stored 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.
+ * @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.
  */
-async function _NftController_addNftContracts(userAddress, contracts) {
+async function _NftController_addNftContract(networkClientId, { tokenAddress, userAddress, 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 allNftContractsForUser = allNftContracts[userAddress] || {};
-        const nftContractsForUserPerChain = {};
-        const modifiedChainIds = new Set();
-        for (const { networkClientId, tokenAddress, source, nftMetadata, } of contracts) {
-            try {
-                const checksumHexAddress = (0, controller_utils_1.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 === 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;
-                    })) {
-                    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);
-            }
+        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;
         }
-        // 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 });
+        // 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 === 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;
         }
-        return { contracts: nftContractsForUserPerChain };
+        /* 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();