@ledgerhq/live-common 21.36.2 → 22.0.0

package/src/generated/types.ts

@@ -1,195 +1,34 @@
-import { reflect as algorandReflect } from "../families/algorand/types";
-import { CoreStatics as CoreStatics_algorand } from "../families/algorand/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_algorand } from "../families/algorand/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_algorand } from "../families/algorand/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_algorand } from "../families/algorand/types";
 import { Transaction as algorandTransaction } from "../families/algorand/types";
 import { TransactionRaw as algorandTransactionRaw } from "../families/algorand/types";
-import { reflect as bitcoinReflect } from "../families/bitcoin/types";
-import { CoreStatics as CoreStatics_bitcoin } from "../families/bitcoin/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_bitcoin } from "../families/bitcoin/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_bitcoin } from "../families/bitcoin/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_bitcoin } from "../families/bitcoin/types";
 import { Transaction as bitcoinTransaction } from "../families/bitcoin/types";
 import { TransactionRaw as bitcoinTransactionRaw } from "../families/bitcoin/types";
-import { NetworkInfo as bitcoinNetworkInfo } from "../families/bitcoin/types";
-import { NetworkInfoRaw as bitcoinNetworkInfoRaw } from "../families/bitcoin/types";
-import { reflect as celoReflect } from "../families/celo/types";
-import { CoreStatics as CoreStatics_celo } from "../families/celo/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_celo } from "../families/celo/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_celo } from "../families/celo/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_celo } from "../families/celo/types";
 import { Transaction as celoTransaction } from "../families/celo/types";
 import { TransactionRaw as celoTransactionRaw } from "../families/celo/types";
-import { reflect as cosmosReflect } from "../families/cosmos/types";
-import { CoreStatics as CoreStatics_cosmos } from "../families/cosmos/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_cosmos } from "../families/cosmos/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_cosmos } from "../families/cosmos/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_cosmos } from "../families/cosmos/types";
 import { Transaction as cosmosTransaction } from "../families/cosmos/types";
 import { TransactionRaw as cosmosTransactionRaw } from "../families/cosmos/types";
-import { NetworkInfo as cosmosNetworkInfo } from "../families/cosmos/types";
-import { NetworkInfoRaw as cosmosNetworkInfoRaw } from "../families/cosmos/types";
-import { reflect as crypto_orgReflect } from "../families/crypto_org/types";
-import { CoreStatics as CoreStatics_crypto_org } from "../families/crypto_org/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_crypto_org } from "../families/crypto_org/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_crypto_org } from "../families/crypto_org/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_crypto_org } from "../families/crypto_org/types";
 import { Transaction as crypto_orgTransaction } from "../families/crypto_org/types";
 import { TransactionRaw as crypto_orgTransactionRaw } from "../families/crypto_org/types";
-import { NetworkInfo as crypto_orgNetworkInfo } from "../families/crypto_org/types";
-import { NetworkInfoRaw as crypto_orgNetworkInfoRaw } from "../families/crypto_org/types";
-import { reflect as elrondReflect } from "../families/elrond/types";
-import { CoreStatics as CoreStatics_elrond } from "../families/elrond/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_elrond } from "../families/elrond/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_elrond } from "../families/elrond/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_elrond } from "../families/elrond/types";
 import { Transaction as elrondTransaction } from "../families/elrond/types";
 import { TransactionRaw as elrondTransactionRaw } from "../families/elrond/types";
-import { NetworkInfo as elrondNetworkInfo } from "../families/elrond/types";
-import { NetworkInfoRaw as elrondNetworkInfoRaw } from "../families/elrond/types";
-import { reflect as ethereumReflect } from "../families/ethereum/types";
-import { CoreStatics as CoreStatics_ethereum } from "../families/ethereum/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_ethereum } from "../families/ethereum/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_ethereum } from "../families/ethereum/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_ethereum } from "../families/ethereum/types";
 import { Transaction as ethereumTransaction } from "../families/ethereum/types";
 import { TransactionRaw as ethereumTransactionRaw } from "../families/ethereum/types";
-import { NetworkInfo as ethereumNetworkInfo } from "../families/ethereum/types";
-import { NetworkInfoRaw as ethereumNetworkInfoRaw } from "../families/ethereum/types";
-import { reflect as filecoinReflect } from "../families/filecoin/types";
-import { CoreStatics as CoreStatics_filecoin } from "../families/filecoin/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_filecoin } from "../families/filecoin/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_filecoin } from "../families/filecoin/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_filecoin } from "../families/filecoin/types";
 import { Transaction as filecoinTransaction } from "../families/filecoin/types";
 import { TransactionRaw as filecoinTransactionRaw } from "../families/filecoin/types";
-import { NetworkInfo as filecoinNetworkInfo } from "../families/filecoin/types";
-import { NetworkInfoRaw as filecoinNetworkInfoRaw } from "../families/filecoin/types";
-import { reflect as neoReflect } from "../families/neo/types";
-import { CoreStatics as CoreStatics_neo } from "../families/neo/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_neo } from "../families/neo/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_neo } from "../families/neo/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_neo } from "../families/neo/types";
 import { Transaction as neoTransaction } from "../families/neo/types";
 import { TransactionRaw as neoTransactionRaw } from "../families/neo/types";
-import { NetworkInfo as neoNetworkInfo } from "../families/neo/types";
-import { NetworkInfoRaw as neoNetworkInfoRaw } from "../families/neo/types";
-import { reflect as polkadotReflect } from "../families/polkadot/types";
-import { CoreStatics as CoreStatics_polkadot } from "../families/polkadot/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_polkadot } from "../families/polkadot/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_polkadot } from "../families/polkadot/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_polkadot } from "../families/polkadot/types";
 import { Transaction as polkadotTransaction } from "../families/polkadot/types";
 import { TransactionRaw as polkadotTransactionRaw } from "../families/polkadot/types";
-import { reflect as rippleReflect } from "../families/ripple/types";
-import { CoreStatics as CoreStatics_ripple } from "../families/ripple/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_ripple } from "../families/ripple/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_ripple } from "../families/ripple/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_ripple } from "../families/ripple/types";
 import { Transaction as rippleTransaction } from "../families/ripple/types";
 import { TransactionRaw as rippleTransactionRaw } from "../families/ripple/types";
-import { NetworkInfo as rippleNetworkInfo } from "../families/ripple/types";
-import { NetworkInfoRaw as rippleNetworkInfoRaw } from "../families/ripple/types";
-import { reflect as solanaReflect } from "../families/solana/types";
-import { CoreStatics as CoreStatics_solana } from "../families/solana/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_solana } from "../families/solana/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_solana } from "../families/solana/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_solana } from "../families/solana/types";
 import { Transaction as solanaTransaction } from "../families/solana/types";
 import { TransactionRaw as solanaTransactionRaw } from "../families/solana/types";
-import { reflect as stellarReflect } from "../families/stellar/types";
-import { CoreStatics as CoreStatics_stellar } from "../families/stellar/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_stellar } from "../families/stellar/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_stellar } from "../families/stellar/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_stellar } from "../families/stellar/types";
 import { Transaction as stellarTransaction } from "../families/stellar/types";
 import { TransactionRaw as stellarTransactionRaw } from "../families/stellar/types";
-import { NetworkInfo as stellarNetworkInfo } from "../families/stellar/types";
-import { NetworkInfoRaw as stellarNetworkInfoRaw } from "../families/stellar/types";
-import { reflect as tezosReflect } from "../families/tezos/types";
-import { CoreStatics as CoreStatics_tezos } from "../families/tezos/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_tezos } from "../families/tezos/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_tezos } from "../families/tezos/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_tezos } from "../families/tezos/types";
 import { Transaction as tezosTransaction } from "../families/tezos/types";
 import { TransactionRaw as tezosTransactionRaw } from "../families/tezos/types";
-import { NetworkInfo as tezosNetworkInfo } from "../families/tezos/types";
-import { NetworkInfoRaw as tezosNetworkInfoRaw } from "../families/tezos/types";
-import { reflect as tronReflect } from "../families/tron/types";
-import { CoreStatics as CoreStatics_tron } from "../families/tron/types";
-import { CoreAccountSpecifics as CoreAccountSpecifics_tron } from "../families/tron/types";
-import { CoreOperationSpecifics as CoreOperationSpecifics_tron } from "../families/tron/types";
-import { CoreCurrencySpecifics as CoreCurrencySpecifics_tron } from "../families/tron/types";
 import { Transaction as tronTransaction } from "../families/tron/types";
 import { TransactionRaw as tronTransactionRaw } from "../families/tron/types";
-import { NetworkInfo as tronNetworkInfo } from "../families/tron/types";
-import { NetworkInfoRaw as tronNetworkInfoRaw } from "../families/tron/types";
 
-export type SpecificStatics = {}
-& CoreStatics_algorand
-& CoreStatics_bitcoin
-& CoreStatics_celo
-& CoreStatics_cosmos
-& CoreStatics_crypto_org
-& CoreStatics_elrond
-& CoreStatics_ethereum
-& CoreStatics_filecoin
-& CoreStatics_neo
-& CoreStatics_polkadot
-& CoreStatics_ripple
-& CoreStatics_solana
-& CoreStatics_stellar
-& CoreStatics_tezos
-& CoreStatics_tron
-export type CoreAccountSpecifics = {}
-& CoreAccountSpecifics_algorand
-& CoreAccountSpecifics_bitcoin
-& CoreAccountSpecifics_celo
-& CoreAccountSpecifics_cosmos
-& CoreAccountSpecifics_crypto_org
-& CoreAccountSpecifics_elrond
-& CoreAccountSpecifics_ethereum
-& CoreAccountSpecifics_filecoin
-& CoreAccountSpecifics_neo
-& CoreAccountSpecifics_polkadot
-& CoreAccountSpecifics_ripple
-& CoreAccountSpecifics_solana
-& CoreAccountSpecifics_stellar
-& CoreAccountSpecifics_tezos
-& CoreAccountSpecifics_tron
-export type CoreOperationSpecifics = {}
-& CoreOperationSpecifics_algorand
-& CoreOperationSpecifics_bitcoin
-& CoreOperationSpecifics_celo
-& CoreOperationSpecifics_cosmos
-& CoreOperationSpecifics_crypto_org
-& CoreOperationSpecifics_elrond
-& CoreOperationSpecifics_ethereum
-& CoreOperationSpecifics_filecoin
-& CoreOperationSpecifics_neo
-& CoreOperationSpecifics_polkadot
-& CoreOperationSpecifics_ripple
-& CoreOperationSpecifics_solana
-& CoreOperationSpecifics_stellar
-& CoreOperationSpecifics_tezos
-& CoreOperationSpecifics_tron
-export type CoreCurrencySpecifics = {}
-& CoreCurrencySpecifics_algorand
-& CoreCurrencySpecifics_bitcoin
-& CoreCurrencySpecifics_celo
-& CoreCurrencySpecifics_cosmos
-& CoreCurrencySpecifics_crypto_org
-& CoreCurrencySpecifics_elrond
-& CoreCurrencySpecifics_ethereum
-& CoreCurrencySpecifics_filecoin
-& CoreCurrencySpecifics_neo
-& CoreCurrencySpecifics_polkadot
-& CoreCurrencySpecifics_ripple
-& CoreCurrencySpecifics_solana
-& CoreCurrencySpecifics_stellar
-& CoreCurrencySpecifics_tezos
-& CoreCurrencySpecifics_tron
 export type Transaction =
   | algorandTransaction
   | bitcoinTransaction
@@ -222,44 +61,3 @@ export type TransactionRaw =
   | stellarTransactionRaw
   | tezosTransactionRaw
   | tronTransactionRaw
-export type NetworkInfo =
-  | bitcoinNetworkInfo
-  | cosmosNetworkInfo
-  | crypto_orgNetworkInfo
-  | elrondNetworkInfo
-  | ethereumNetworkInfo
-  | filecoinNetworkInfo
-  | neoNetworkInfo
-  | rippleNetworkInfo
-  | stellarNetworkInfo
-  | tezosNetworkInfo
-  | tronNetworkInfo
-export type NetworkInfoRaw =
-  | bitcoinNetworkInfoRaw
-  | cosmosNetworkInfoRaw
-  | crypto_orgNetworkInfoRaw
-  | elrondNetworkInfoRaw
-  | ethereumNetworkInfoRaw
-  | filecoinNetworkInfoRaw
-  | neoNetworkInfoRaw
-  | rippleNetworkInfoRaw
-  | stellarNetworkInfoRaw
-  | tezosNetworkInfoRaw
-  | tronNetworkInfoRaw
-export const reflectSpecifics = (declare: any): Array<{ OperationMethods: Record<string, unknown>, AccountMethods: Record<string, unknown> }> => [
-  algorandReflect(declare),
-  bitcoinReflect(declare),
-  celoReflect(declare),
-  cosmosReflect(declare),
-  crypto_orgReflect(declare),
-  elrondReflect(declare),
-  ethereumReflect(declare),
-  filecoinReflect(declare),
-  neoReflect(declare),
-  polkadotReflect(declare),
-  rippleReflect(declare),
-  solanaReflect(declare),
-  stellarReflect(declare),
-  tezosReflect(declare),
-  tronReflect(declare),
-] as Array<{ OperationMethods: Record<string, unknown>, AccountMethods: Record<string, unknown> }>;

package/src/mock/account.ts

@@ -397,7 +397,13 @@ export function genAccount(
   };
 
   if (
-    ["ethereum", "ethereum_ropsten", "tron", "algorand"].includes(currency.id)
+    [
+      "ethereum",
+      "ethereum_ropsten",
+      "ethereum_goerli",
+      "tron",
+      "algorand",
+    ].includes(currency.id)
   ) {
     const tokenCount =
       typeof opts.subAccountsCount === "number"

package/src/nft/NftMetadataProvider/index.tsx

@@ -5,95 +5,69 @@ import React, {
   useState,
   useEffect,
 } from "react";
-import { Currency, findCryptoCurrencyById } from "@ledgerhq/cryptoassets";
-import { API, apiForCurrency } from "../../api/Ethereum";
-import { NFT, NFTMetadataResponse } from "../../types";
-import { getNftKey } from "../helpers";
+import { getNftCollectionKey, getNftKey } from "../helpers";
 import {
-  Batch,
-  BatchElement,
   NFTMetadataContextAPI,
   NFTMetadataContextState,
   NFTMetadataContextType,
   NFTResource,
 } from "./types";
 import { isOutdated } from "./logic";
-
-const currency: Currency = findCryptoCurrencyById("ethereum")!;
-const ethApi: API = apiForCurrency(currency);
+import { getCurrencyBridge } from "../../bridge";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import { NFT, ProtoNFT } from "../../types";
 
 const NftMetadataContext = createContext<NFTMetadataContextType>({
   cache: {},
   loadNFTMetadata: () => Promise.resolve(),
+  loadCollectionMetadata: () => Promise.resolve(),
   clearCache: () => {},
 });
 
-export const metadataCallBatcher = (() => {
-  const batch: BatchElement[] = [];
-
-  let debounce;
-  const timeoutBatchCall = () => {
-    // Clear the previous scheduled call if it was existing
-    clearTimeout(debounce);
-
-    // Schedule a new call with the whole batch
-    debounce = setTimeout(() => {
-      // Seperate each batch element properties into arrays by type and index
-      const { couples, resolvers, rejecters } = batch.reduce(
-        (acc, { couple, resolve, reject }) => {
-          acc.couples.push(couple);
-          acc.resolvers.push(resolve);
-          acc.rejecters.push(reject);
-
-          return acc;
-        },
-        { couples: [], resolvers: [], rejecters: [] } as Batch
-      );
-      // Empty the batch
-      batch.length = 0;
-
-      // Make the call with all the couples of contract and tokenId at once
-      ethApi
-        .getNFTMetadata(couples)
-        .then((res) => {
-          // Resolve each batch element with its own resolver and only its response
-          res.forEach((metadata, index) => resolvers[index](metadata));
-        })
-        .catch((err) => {
-          // Reject all batch element with the error
-          rejecters.forEach((reject) => reject(err));
-        });
-    });
-  };
-
-  return {
-    // Load the metadata for a given couple contract + tokenId
-    load({ contract, tokenId }): Promise<NFTMetadataResponse> {
-      return new Promise((resolve, reject) => {
-        batch.push({ couple: { contract, tokenId }, resolve, reject });
-        timeoutBatchCall();
-      });
-    },
-  };
-})();
-
-// DEPRECATED, use useNftResource
 export function useNftMetadata(
   contract: string | undefined,
-  tokenId: string | undefined
+  tokenId: string | undefined,
+  currencyId: string | undefined
 ): NFTResource {
   const { cache, loadNFTMetadata } = useContext(NftMetadataContext);
+  const key =
+    contract && tokenId && currencyId
+      ? getNftKey(contract, tokenId, currencyId)
+      : "";
+  const cachedData = cache[key];
 
-  const key = contract && tokenId ? getNftKey(contract, tokenId) : "";
+  useEffect(() => {
+    if (!contract || !tokenId || !currencyId) return;
+    if (!cachedData || isOutdated(cachedData)) {
+      loadNFTMetadata(contract, tokenId, currencyId);
+    }
+  }, [contract, tokenId, cachedData, loadNFTMetadata, currencyId]);
+
+  if (cachedData) {
+    return cachedData;
+  } else {
+    return {
+      status: "queued",
+    };
+  }
+}
+
+export function useNftCollectionMetadata(
+  contract: string | undefined,
+  currencyId: string | undefined
+): NFTResource {
+  const { cache, loadCollectionMetadata } = useContext(NftMetadataContext);
+  const key =
+    contract && currencyId ? getNftCollectionKey(contract, currencyId) : "";
 
   const cachedData = cache[key];
 
   useEffect(() => {
-    if (!contract || !tokenId) return;
+    if (!contract || !currencyId) return;
     if (!cachedData || isOutdated(cachedData)) {
-      loadNFTMetadata(contract, tokenId);
+      loadCollectionMetadata(contract, currencyId);
     }
-  }, [contract, tokenId, cachedData, loadNFTMetadata]);
+  }, [contract, cachedData, currencyId, loadCollectionMetadata]);
 
   if (cachedData) {
     return cachedData;
@@ -104,16 +78,44 @@ export function useNftMetadata(
   }
 }
 
-export function useNftResource(nft: NFT | undefined): NFTResource {
-  return useNftMetadata(nft?.collection.contract, nft?.tokenId);
+type UseNFTResponse =
+  | { status: Exclude<NFTResource["status"], "loaded"> }
+  | { status: "loaded"; nft: NFT };
+
+export function useNft(protoNft: ProtoNFT): UseNFTResponse {
+  const data = useNftMetadata(
+    protoNft.contract,
+    protoNft.tokenId,
+    protoNft.currencyId
+  );
+
+  const { status } = data;
+  const metadata = useMemo(
+    () => (status === "loaded" ? data.metadata : null),
+    [data, status]
+  );
+
+  const nft = useMemo(
+    () => (status === "loaded" && metadata ? { ...protoNft, metadata } : null),
+    [protoNft, metadata]
+  ) as NFT | null;
+
+  return status !== "loaded"
+    ? { status }
+    : {
+        status,
+        nft: nft!,
+      };
 }
 
 export function useNftAPI(): NFTMetadataContextAPI {
-  const { clearCache, loadNFTMetadata } = useContext(NftMetadataContext);
+  const { clearCache, loadNFTMetadata, loadCollectionMetadata } =
+    useContext(NftMetadataContext);
 
   return {
     clearCache,
     loadNFTMetadata,
+    loadCollectionMetadata,
   };
 }
 
@@ -128,10 +130,94 @@ export function NftMetadataProvider({
     cache: {},
   });
 
-  const api = useMemo(
+  const api: NFTMetadataContextAPI = useMemo(
     () => ({
-      loadNFTMetadata: async (contract: string, tokenId: string) => {
-        const key = getNftKey(contract, tokenId);
+      loadNFTMetadata: async (
+        contract: string,
+        tokenId: string,
+        currencyId: string
+      ) => {
+        const key = getNftKey(contract, tokenId, currencyId);
+        const currency = getCryptoCurrencyById(currencyId);
+        const currencyBridge = getCurrencyBridge(currency);
+
+        if (!currencyBridge.nftResolvers?.nftMetadata) {
+          throw new Error("Currency doesn't support NFT metadata");
+        }
+
+        setState((oldState) => ({
+          ...oldState,
+          cache: {
+            ...oldState.cache,
+            [key]: {
+              status: "loading",
+            },
+          },
+        }));
+
+        try {
+          const { status, result } =
+            await currencyBridge.nftResolvers.nftMetadata({
+              contract,
+              tokenId,
+              currencyId: currency.id,
+            });
+
+          switch (status) {
+            case 500:
+              throw new Error("NFT Metadata Provider failed");
+            case 404:
+              setState((oldState) => ({
+                ...oldState,
+                cache: {
+                  ...oldState.cache,
+                  [key]: {
+                    status: "nodata",
+                    metadata: null,
+                    updatedAt: Date.now(),
+                  },
+                },
+              }));
+              break;
+            case 200:
+              setState((oldState) => ({
+                ...oldState,
+                cache: {
+                  ...oldState.cache,
+                  [key]: {
+                    status: "loaded",
+                    metadata: result,
+                    updatedAt: Date.now(),
+                  },
+                },
+              }));
+              break;
+            default:
+              break;
+          }
+        } catch (error) {
+          setState((oldState) => ({
+            ...oldState,
+            cache: {
+              ...oldState.cache,
+              [key]: {
+                status: "error",
+                error,
+                updatedAt: Date.now(),
+              },
+            },
+          }));
+        }
+      },
+
+      loadCollectionMetadata: async (contract: string, currencyId: string) => {
+        const key = getNftCollectionKey(contract, currencyId);
+        const currency = getCryptoCurrencyById(currencyId);
+        const currencyBridge = getCurrencyBridge(currency);
+
+        if (!currencyBridge?.nftResolvers?.collectionMetadata) {
+          throw new Error("Currency doesn't support Collection Metadata");
+        }
 
         setState((oldState) => ({
           ...oldState,
@@ -144,10 +230,11 @@ export function NftMetadataProvider({
         }));
 
         try {
-          const { status, result } = await metadataCallBatcher.load({
-            contract,
-            tokenId,
-          });
+          const { status, result } =
+            await currencyBridge.nftResolvers.collectionMetadata({
+              contract,
+              currencyId: currency.id,
+            });
 
           switch (status) {
             case 500:
@@ -172,7 +259,7 @@ export function NftMetadataProvider({
                   ...oldState.cache,
                   [key]: {
                     status: "loaded",
-                    metadata: result || {},
+                    metadata: result,
                     updatedAt: Date.now(),
                   },
                 },
@@ -206,6 +293,7 @@ export function NftMetadataProvider({
   );
 
   const value = { ...state, ...api };
+
   return (
     <NftMetadataContext.Provider value={value}>
       {children}

package/src/nft/NftMetadataProvider/types.ts

@@ -1,4 +1,7 @@
-import { NFTMetadataResponse } from "../../types";
+import {
+  NFTCollectionMetadataResponse,
+  NFTMetadataResponse,
+} from "../../types";
 
 export type NFTResourceQueued = {
   status: "queued";
@@ -10,7 +13,9 @@ export type NFTResourceLoading = {
 
 export type NFTResourceLoaded = {
   status: "loaded";
-  metadata: Pick<NFTMetadataResponse, "result">;
+  metadata:
+    | NFTMetadataResponse["result"]
+    | NFTCollectionMetadataResponse["result"];
   updatedAt: number;
 };
 
@@ -37,24 +42,42 @@ export type NFTMetadataContextState = {
 };
 
 export type NFTMetadataContextAPI = {
-  loadNFTMetadata: (contract: string, tokenId: string) => Promise<void>;
+  loadNFTMetadata: (
+    contract: string,
+    tokenId: string,
+    currencyId: string
+  ) => Promise<void>;
+  loadCollectionMetadata: (
+    contract: string,
+    currencyId: string
+  ) => Promise<void>;
   clearCache: () => void;
 };
 
 export type NFTMetadataContextType = NFTMetadataContextState &
   NFTMetadataContextAPI;
 
+export type Batcher = {
+  load: (
+    element:
+      | {
+          contract: string;
+          tokenId: string;
+        }
+      | {
+          contract: string;
+        }
+  ) => Promise<NFTMetadataResponse | NFTCollectionMetadataResponse>;
+};
+
 export type BatchElement = {
-  couple: {
-    contract: string;
-    tokenId: string;
-  };
+  element: any;
   resolve: (value: NFTMetadataResponse) => void;
   reject: (reason?: Error) => void;
 };
 
 export type Batch = {
-  couples: Array<BatchElement["couple"]>;
+  elements: Array<BatchElement["element"]>;
   resolvers: Array<BatchElement["resolve"]>;
   rejecters: Array<BatchElement["reject"]>;
 };