@ledgerhq/live-common 21.36.2 → 22.0.0

package/src/nft/helpers.ts

@@ -1,21 +1,26 @@
 import eip55 from "eip55";
 import BigNumber from "bignumber.js";
-import { NFT, Operation } from "../types";
 import { encodeNftId } from ".";
-
-type Collection = NFT["collection"];
-
-type CollectionMap<C> = Record<string, C>;
-
-export type CollectionWithNFT = Collection & {
-  nfts: Array<Omit<NFT, "collection">>;
-};
-
-export const nftsFromOperations = (ops: Operation[]): NFT[] => {
+import { decodeAccountId } from "../account";
+
+import type { Batch, BatchElement, Batcher } from "./NftMetadataProvider/types";
+import type {
+  NFTMetadataResponse,
+  Operation,
+  ProtoNFT,
+  NFT,
+  CryptoCurrency,
+  NFTCollectionMetadataResponse,
+} from "../types";
+import { API, apiForCurrency } from "../api/Ethereum";
+
+export const nftsFromOperations = (ops: Operation[]): ProtoNFT[] => {
   const nftsMap = ops
+    // make sure we have the operation in chronological order (older first)
+    .sort((a, b) => a.date.getTime() - b.date.getTime())
     // if ops are Operations get the prop nftOperations, else ops are considered nftOperations already
     .flatMap((op) => (op?.nftOperations?.length ? op.nftOperations : op))
-    .reduce((acc: Record<string, NFT>, nftOp: Operation) => {
+    .reduce((acc: Record<string, ProtoNFT>, nftOp: Operation) => {
       let { contract } = nftOp;
       if (!contract) {
         return acc;
@@ -24,20 +29,37 @@ export const nftsFromOperations = (ops: Operation[]): NFT[] => {
       // Creating a "token for a contract" unique key
       contract = eip55.encode(contract);
       const { tokenId, standard, accountId } = nftOp;
+      const { currencyId } = decodeAccountId(nftOp.accountId);
       if (!tokenId || !standard) return acc;
-      const id = encodeNftId(accountId, contract, tokenId || "");
+      const id = encodeNftId(accountId, contract, tokenId, currencyId);
 
       const nft = (acc[id] || {
         id,
         tokenId,
         amount: new BigNumber(0),
-        collection: { contract, standard },
-      }) as NFT;
+        contract,
+        standard,
+        currencyId,
+      }) as ProtoNFT;
 
       if (nftOp.type === "NFT_IN") {
         nft.amount = nft.amount.plus(nftOp.value);
       } else if (nftOp.type === "NFT_OUT") {
-        nft.amount = nft.amount.minus(nftOp.value);
+        const newAmount = nft.amount.minus(nftOp.value);
+
+        // In case of OpenSea lazy minting feature (minting an NFT off-chain)
+        // OpenSea will fire a false ERC1155 event saying that you sent an NFT
+        // from your account that you never received first.
+        //
+        // E.g.: I'm creating 10 ERC1155 on OpenSea. It's not going to create anything on-chain.
+        // Then I (bob) decide to transfer 5 to someone (kvn). OpenSea is going to mint the NFT in its
+        // collection (`OpenSea Shared Storefront` / `OpenSea Collections`) and transfer it to kvn.
+        // But the event fired by the Smart Contract is going to be `bob transfered 5 NFT to kvn` which is false.
+        // It would then result in bob have -5 NFTs since he never received them first.
+        // If kvn send 2 back to bob, based on the events we would think that bob has -3 NFTs.
+        //
+        // To mitigate that we put a minimum value of 0 when an account is transferring some NFTs.
+        nft.amount = newAmount.isNegative() ? new BigNumber(0) : newAmount;
       }
 
       acc[id] = nft;
@@ -48,31 +70,143 @@ export const nftsFromOperations = (ops: Operation[]): NFT[] => {
   return Object.values(nftsMap);
 };
 
+/**
+ * Helper to group NFTs by their collection/contract.
+ *
+ * It will either return an object { [contract address]: NFT[] }
+ * or if you specify a collectionAddress it will simply filter
+ * your NFTs for this specific contract and return an NFT[].
+ *
+ * The grouping here can be done with ProtoNFT or NFT.
+ */
 export const nftsByCollections = (
-  nfts: NFT[] = [],
+  nfts: Array<ProtoNFT | NFT> = [],
   collectionAddress?: string
-): CollectionWithNFT[] => {
-  const filteredNfts = collectionAddress
-    ? nfts.filter((n) => n.collection.contract === collectionAddress)
-    : nfts;
+): Record<string, Array<ProtoNFT | NFT>> | Array<ProtoNFT | NFT> => {
+  return collectionAddress
+    ? nfts.filter((n) => n.contract === collectionAddress)
+    : nfts.reduce((acc, nft) => {
+        const { contract } = nft;
 
-  const collectionMap = filteredNfts.reduce(
-    (acc: CollectionMap<CollectionWithNFT>, nft: NFT) => {
-      const { collection, ...nftWithoutCollection } = nft;
+        if (!acc[contract]) {
+          acc[contract] = [];
+        }
+        acc[contract].push(nft);
 
-      if (!acc[collection.contract]) {
-        acc[collection.contract] = { ...collection, nfts: [] };
-      }
-      acc[collection.contract].nfts.push(nftWithoutCollection);
+        return acc;
+      }, {});
+};
 
-      return acc;
-    },
-    {} as CollectionMap<CollectionWithNFT>
-  );
+export const getNftKey = (
+  contract: string,
+  tokenId: string,
+  currencyId: string
+): string => {
+  return `${currencyId}-${contract}-${tokenId}`;
+};
 
-  return Object.values(collectionMap);
+export const getNftCollectionKey = (
+  contract: string,
+  currencyId: string
+): string => {
+  return `${currencyId}-${contract}`;
 };
 
-export const getNftKey = (contract: string, tokenId: string): string => {
-  return `${contract}-${tokenId}`;
+/**
+ * Factory to make a metadata API call batcher.
+ *
+ * It will wait for a complete `tick` to accumulate all the metadata requests
+ * before sending it as one call to a given API.
+ * Once the response is received, it will then spread the metadata to each request Promise,
+ * just like if each request had been made separately.
+ */
+const makeBatcher = (
+  call: API["getNFTMetadata"] | API["getNFTCollectionMetadata"],
+  chainId: number
+): Batcher =>
+  (() => {
+    const queue: 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 { elements, resolvers, rejecters } = queue.reduce(
+          (acc, { element, resolve, reject }) => {
+            acc.elements.push(element);
+            acc.resolvers.push(resolve);
+            acc.rejecters.push(reject);
+
+            return acc;
+          },
+          { elements: [], resolvers: [], rejecters: [] } as Batch
+        );
+        // Empty the queue
+        queue.length = 0;
+
+        // Make the call with all the couples of contract and tokenId at once
+        call(elements, chainId.toString())
+          .then((res: any) => {
+            // 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(
+        element:
+          | {
+              contract: string;
+              tokenId: string;
+            }
+          | { contract: string }
+      ): Promise<NFTMetadataResponse | NFTCollectionMetadataResponse> {
+        return new Promise((resolve, reject) => {
+          queue.push({ element, resolve, reject });
+          timeoutBatchCall();
+        });
+      },
+    };
+  })();
+
+const batchersMap = new Map();
+
+/**
+ * In order to `instanciate`/make only 1 batcher by currency,
+ * they're `cached` in a Map and retrieved by this method
+ * This method is still EVM based for now but can be improved
+ * to implement an even more generic solution
+ */
+export const metadataCallBatcher = (
+  currency: CryptoCurrency
+): { loadNft: Batcher["load"]; loadCollection: Batcher["load"] } => {
+  const api: API = apiForCurrency(currency);
+  const chainId = currency?.ethereumLikeInfo?.chainId;
+
+  if (!chainId || !api) {
+    throw new Error("Ethereum: No API or chainId for this Currency");
+  }
+
+  if (!batchersMap.has(currency.id)) {
+    batchersMap.set(currency.id, {
+      nft: makeBatcher(api.getNFTMetadata, chainId),
+      collection: makeBatcher(api.getNFTCollectionMetadata, chainId),
+    });
+  }
+
+  const batchers = batchersMap.get(currency.id);
+  return {
+    loadNft: batchers.nft.load,
+    loadCollection: batchers.collection.load,
+  };
 };

package/src/nft/nftId.ts

@@ -1,17 +1,26 @@
 export const encodeNftId = (
   accountId: string,
   contract: string,
-  tokenId: string
+  tokenId: string,
+  currencyId: string
 ): string => {
-  return `${accountId}+${contract}+${tokenId.toString()}`;
+  return `${accountId}+${contract}+${tokenId}+${currencyId}`;
 };
 
-export const decodeNftId = (id: string): unknown => {
-  const [accountId, contract, tokenId] = id.split("+");
+export const decodeNftId = (
+  id: string
+): {
+  accountId: string;
+  contract: string;
+  tokenId: string;
+  currencyId: string;
+} => {
+  const [accountId, contract, tokenId, currencyId] = id.split("+");
 
   return {
     accountId,
     contract,
     tokenId,
+    currencyId,
   };
 };

package/src/nft/support.ts

@@ -1,4 +1,4 @@
-import { Transaction, CryptoCurrency } from "../types";
+import { Transaction, CryptoCurrency, ProtoNFT } from "../types";
 import { getEnv } from "../env";
 
 export const isNftTransaction = (transaction: Transaction): boolean => {
@@ -12,3 +12,16 @@ export const isNftTransaction = (transaction: Transaction): boolean => {
 export function isNFTActive(currency: CryptoCurrency): boolean {
   return getEnv("NFT_CURRENCIES").split(",").includes(currency.id);
 }
+
+const nftCapabilities = {
+  hasQuantity: ["ERC1155"],
+};
+
+export const getNftCapabilities = (nft: ProtoNFT) =>
+  Object.entries(nftCapabilities).reduce(
+    (acc, [capability, standards]) => ({
+      ...acc,
+      [capability]: standards.includes(nft.standard),
+    }),
+    {}
+  );

package/src/reconciliation.ts

@@ -1,5 +1,4 @@
-// libcore reconciliation by the React definition. https://reactjs.org/docs/reconciliation.html
-// TODO move to account/
+// reconciliation by the React definition. https://reactjs.org/docs/reconciliation.html
 import isEqual from "lodash/isEqual";
 import { BigNumber } from "bignumber.js";
 import { sameOp } from "./bridge/jsHelpers";
@@ -27,11 +26,12 @@ import {
   fromTezosResourcesRaw,
   fromElrondResourcesRaw,
   fromCryptoOrgResourcesRaw,
+  fromSolanaResourcesRaw,
   fromNFTRaw,
 } from "./account";
 import consoleWarnExpectToEqual from "./consoleWarnExpectToEqual";
 
-// aim to build operations with the minimal diff & call to libcore possible
+// aim to build operations with the minimal diff & call to coin implementation possible
 export async function minimalOperationsBuilder<CO>(
   existingOperations: Operation[],
   coreOperations: CO[],
@@ -383,6 +383,11 @@ export function patchAccount(
     changed = true;
   }
 
+  if (updatedRaw.solanaResources) {
+    next.solanaResources = fromSolanaResourcesRaw(updatedRaw.solanaResources);
+    changed = true;
+  }
+
   const nfts = updatedRaw?.nfts?.map(fromNFTRaw);
   if (!updatedRaw.nfts && account.nfts) {
     delete next.nfts;
@@ -558,12 +563,12 @@ function stepBuilder(state, newOp, i) {
     const rest = state.existingOps.slice(j);
 
     if (rest.length > i + 1) {
-      // if libcore happen to have less ops that what we had,
+      // if coin implementation happen to have less ops that what we had,
       // we actually need to continue because we don't know where hole will be,
       // but we can keep existingOp
       state.operations.push(existingOp);
     } else {
-      // otherwise we stop the libcore iteration and continue with previous data
+      // otherwise we stop the coin implementation iteration and continue with previous data
       // and we're done on the iteration
       if (state.operations.length === 0 && j === 0) {
         // special case: we preserve the operations array as much as possible

package/src/types/account.ts

@@ -31,13 +31,15 @@ import type {
   CryptoOrgResources,
   CryptoOrgResourcesRaw,
 } from "../families/crypto_org/types";
+import { SolanaResources, SolanaResourcesRaw } from "../families/solana/types";
 import type {
   BalanceHistory,
   BalanceHistoryRaw,
   PortfolioRange,
 } from "./portfolio";
 import type { SwapOperation, SwapOperationRaw } from "../exchange/swap/types";
-import type { NFT, NFTRaw } from "./nft";
+import type { ProtoNFT } from "./nft";
+import { ProtoNFTRaw } from ".";
 // This is the old cache and now DEPRECATED (pre v2 portfoli)
 export type BalanceHistoryMap = Partial<Record<PortfolioRange, BalanceHistory>>;
 export type BalanceHistoryRawMap = Record<PortfolioRange, BalanceHistoryRaw>;
@@ -211,12 +213,13 @@ export type Account = {
   tezosResources?: TezosResources;
   elrondResources?: ElrondResources;
   cryptoOrgResources?: CryptoOrgResources;
+  solanaResources?: SolanaResources;
   // Swap operations linked to this account
   swapHistory: SwapOperation[];
   // Hash used to discard tx history on sync
   syncHash?: string;
   // Array of NFTs computed by diffing NFTOperations ordered from newest to oldest
-  nfts?: NFT[];
+  nfts?: ProtoNFT[];
 };
 export type SubAccount = TokenAccount | ChildAccount;
 export type AccountLike = Account | SubAccount;
@@ -300,9 +303,10 @@ export type AccountRaw = {
   elrondResources?: ElrondResourcesRaw;
   tezosResources?: TezosResourcesRaw;
   cryptoOrgResources?: CryptoOrgResourcesRaw;
+  solanaResources?: SolanaResourcesRaw;
   swapHistory?: SwapOperationRaw[];
   syncHash?: string;
-  nfts?: NFTRaw[];
+  nfts?: ProtoNFTRaw[];
 };
 export type SubAccountRaw = TokenAccountRaw | ChildAccountRaw;
 export type AccountRawLike = AccountRaw | SubAccountRaw;

package/src/types/bridge.ts

@@ -18,7 +18,13 @@ import type {
   DerivationMode,
   SyncConfig,
   CryptoCurrencyIds,
+  NFTMetadataResponse,
 } from ".";
+import {
+  NFTCollectionMetadata,
+  NFTCollectionMetadataResponse,
+  NFTMetadata,
+} from "./nft";
 export type ScanAccountEvent = {
   type: "discovered";
   account: Account;
@@ -66,6 +72,19 @@ export interface CurrencyBridge {
     preferredNewAccountScheme?: DerivationMode;
   }): Observable<ScanAccountEvent>;
   getPreloadStrategy?: (currency: CryptoCurrency) => PreloadStrategy;
+  nftResolvers?: {
+    nftMetadata: (arg: {
+      contract: string;
+      tokenId: string;
+      currencyId: string;
+      metadata?: NFTMetadata;
+    }) => Promise<NFTMetadataResponse>;
+    collectionMetadata: (arg: {
+      contract: string;
+      currencyId: string;
+      metadata?: NFTCollectionMetadata;
+    }) => Promise<NFTCollectionMetadataResponse>;
+  };
 }
 // Abstraction related to an account
 export interface AccountBridge<T extends Transaction> {
@@ -128,6 +147,7 @@ type ExpectFn = (...args: Array<any>) => any;
 export type CurrenciesData<T extends Transaction> = {
   FIXME_ignoreAccountFields?: string[];
   FIXME_ignoreOperationFields?: string[];
+  FIXME_ignorePreloadFields?: string[];
   mockDeviceOptions?: any;
   scanAccounts?: Array<{
     name: string;

package/src/types/nft.ts

@@ -1,26 +1,41 @@
 import type BigNumber from "bignumber.js";
+import { CryptoCurrencyIds } from ".";
 
 export type NFTStandards = "ERC721" | "ERC1155";
 
-export type NFT = {
+export type NFTMetadata = {
+  tokenName: string | null;
+  nftName: string | null;
+  media: string | null;
+  description: string | null;
+  properties: Array<Record<"key" | "value", string>>;
+  links: Record<NFTMetadataLinksProviders, string>;
+};
+
+export type NFTCollectionMetadata = {
+  tokenName: string | null;
+};
+
+export type ProtoNFT = {
   // id crafted by live
   id: string;
   // id on chain
   tokenId: string;
   amount: BigNumber;
-  collection: {
-    // contract address. Careful 1 contract address != 1 collection as some collections are off-chain
-    // So 1 contract address from OpenSea for example can reprensent an infinity of collections
-    contract: string;
-    // Carefull to non spec compliant NFTs (cryptopunks, cryptokitties, ethrock, and others?)
-    standard: NFTStandards | string;
-  };
+  contract: string;
+  standard: NFTStandards;
+  currencyId: CryptoCurrencyIds;
+  metadata?: NFTMetadata;
 };
 
-export type NFTRaw = Omit<NFT, "amount"> & {
+export type ProtoNFTRaw = Omit<ProtoNFT, "amount"> & {
   amount: string;
 };
 
+export type NFT = Omit<ProtoNFT, "metadata"> & {
+  metadata: NFTMetadata;
+};
+
 export type NFTMetadataLinksProviders = "opensea" | "rarible" | "etherscan";
 
 export type NFTMetadataResponse = {
@@ -36,3 +51,11 @@ export type NFTMetadataResponse = {
     links: Record<NFTMetadataLinksProviders, string>;
   } | null;
 };
+
+export type NFTCollectionMetadataResponse = {
+  status: 200 | 404 | 500;
+  result?: {
+    contract: string;
+    tokenName: string | null;
+  } | null;
+};

package/lib/__tests__/all.libcore.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=all.libcore.d.ts.map

package/lib/__tests__/all.libcore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"all.libcore.d.ts","sourceRoot":"","sources":["../../src/__tests__/all.libcore.ts"],"names":[],"mappings":""}