@ledgerhq/live-common 21.14.1 → 21.16.2

package/src/families/ethereum/signOperation.ts

@@ -13,6 +13,7 @@ import { getGasLimit, buildEthereumTx } from "./transaction";
 import { apiForCurrency } from "../../api/Ethereum";
 import { withDevice } from "../../hw/deviceAccess";
 import { modes } from "./modules";
+import { getEnv } from "../../env";
 export const signOperation = ({
   account,
   deviceId,
@@ -61,6 +62,13 @@ export const signOperation = ({
                 "0x" + (tx.value.toString("hex") || "0")
               );
               const eth = new Eth(transport);
+              if (getEnv("NFT")) {
+                eth.setLoadConfig({
+                  // FIXME drop this after LL-8001
+                  nftExplorerBaseURL:
+                    "https://nft.staging.aws.ledger.fr/v1/ethereum",
+                });
+              }
               // FIXME this part is still required for compound to correctly display info on the device
               const addrs =
                 (fillTransactionDataResult &&

package/src/families/ethereum/synchronisation.ts

@@ -4,7 +4,7 @@ import throttle from "lodash/throttle";
 import flatMap from "lodash/flatMap";
 import eip55 from "eip55";
 import { log } from "@ledgerhq/logs";
-import { mergeOps } from "../../bridge/jsHelpers";
+import { mergeNfts, mergeOps } from "../../bridge/jsHelpers";
 import type { GetAccountShape } from "../../bridge/jsHelpers";
 import {
   encodeTokenAccountId,
@@ -15,10 +15,14 @@ import {
 } from "../../account";
 import { listTokensForCryptoCurrency } from "../../currencies";
 import { encodeAccountId } from "../../account";
-import type { Operation, TokenAccount, Account } from "../../types";
+import type { Operation, TokenAccount, Account, NFT } from "../../types";
 import { API, apiForCurrency, Tx } from "../../api/Ethereum";
 import { digestTokenAccounts, prepareTokenAccounts } from "./modules";
 import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
+import { encodeNftId, nftsFromOperations } from "../../nft";
+import { NFT_VERSION } from "./versions";
+import { getEnv } from "../../env";
+
 export const getAccountShape: GetAccountShape = async (
   infoInput,
   { blacklistedTokenIds }
@@ -47,11 +51,15 @@ export const getAccountShape: GetAccountShape = async (
       withDelisted: true,
     }).length;
   const outdatedBlacklist = initialAccount?.syncHash !== syncHash;
+  const firstNftSync =
+    getEnv("NFT") && typeof initialAccount?.nfts === "undefined";
   const pullFromBlockHash =
     initialAccount &&
     areAllOperationsLoaded(initialAccount) &&
     mostRecentStableOperation &&
-    !outdatedBlacklist
+    !outdatedBlacklist &&
+    !firstNftSync &&
+    NFT_VERSION
       ? mostRecentStableOperation.blockHash
       : undefined;
   const txsP = fetchAllTransactions(api, address, pullFromBlockHash);
@@ -75,8 +83,10 @@ export const getAccountShape: GetAccountShape = async (
   let newOps = flatMap(txs, txToOps({ address, id: accountId, currency }));
   // extracting out the sub operations by token account
   const perTokenAccountIdOperations = {};
+  // extracting and concat all nft operations for an account
+  const flatNftOps: Operation[] = [];
   newOps.forEach((op) => {
-    const { subOperations } = op;
+    const { subOperations, nftOperations } = op;
 
     if (subOperations?.length) {
       subOperations.forEach((sop) => {
@@ -87,6 +97,10 @@ export const getAccountShape: GetAccountShape = async (
         perTokenAccountIdOperations[sop.accountId].push(sop);
       });
     }
+
+    if (nftOperations?.length) {
+      nftOperations.forEach((nop) => flatNftOps.push(nop));
+    }
   });
   const subAccountsExisting = {};
   initialAccount?.subAccounts?.forEach((a) => {
@@ -158,6 +172,11 @@ export const getAccountShape: GetAccountShape = async (
     subOperations: inferSubOperations(o.hash, subAccounts),
   }));
   const operations = mergeOps(initialStableOperations, newOps);
+
+  const nfts = getEnv("NFT")
+    ? mergeNfts(initialAccount?.nfts, await getNfts(flatNftOps))
+    : undefined;
+
   const accountShape: Partial<Account> = {
     id: accountId,
     operations,
@@ -168,6 +187,7 @@ export const getAccountShape: GetAccountShape = async (
     lastSyncDate: new Date(),
     balanceHistory: undefined,
     syncHash,
+    nfts,
   };
   return accountShape;
 };
@@ -188,7 +208,14 @@ const txToOps =
   (tx: Tx): Operation[] => {
     // workaround bugs in our explorer that don't treat partial/optimistic operation really well
     if (!tx.gas_used) return [];
-    const { hash, block, actions, transfer_events } = tx;
+    const {
+      hash,
+      block,
+      actions,
+      transfer_events,
+      erc721_transfer_events,
+      erc1155_transfer_events,
+    } = tx;
     const addr = address;
     const from = safeEncodeEIP55(tx.from);
     const to = safeEncodeEIP55(tx.to);
@@ -305,6 +332,148 @@ const txToOps =
 
           return all;
         });
+
+    // Creating NFTOps from transfer events related to ERC721 only
+    const erc721Operations = !erc721_transfer_events
+      ? []
+      : flatMap(erc721_transfer_events, (event) => {
+          const sender = safeEncodeEIP55(event.sender);
+          const receiver = safeEncodeEIP55(event.receiver);
+          const contract = safeEncodeEIP55(event.contract);
+          const tokenId = event.token_id;
+          const nftId = encodeNftId(id, event.contract, tokenId);
+          const sending = addr === sender;
+          const receiving = addr === receiver;
+
+          if (!sending && !receiving) {
+            return [];
+          }
+
+          const all: Operation[] = [];
+
+          if (sending) {
+            const type = "NFT_OUT";
+            all.push({
+              id: `${nftId}-${hash}-${type}`,
+              senders: [sender],
+              recipients: [receiver],
+              contract,
+              fee,
+              standard: "ERC721",
+              tokenId,
+              value: new BigNumber(1),
+              hash,
+              type,
+              blockHeight,
+              blockHash,
+              date,
+              transactionSequenceNumber,
+              accountId: id,
+              extra: {},
+            });
+          }
+
+          if (receiving) {
+            const type = "NFT_IN";
+            all.push({
+              id: `${nftId}-${hash}-${type}`,
+              senders: [sender],
+              recipients: [receiver],
+              contract,
+              fee,
+              standard: "ERC721",
+              tokenId,
+              value: new BigNumber(1),
+              hash,
+              type,
+              blockHeight,
+              blockHash,
+              date,
+              transactionSequenceNumber,
+              accountId: id,
+              extra: {},
+            });
+          }
+
+          return all;
+        });
+
+    // Creating NFTOps from transfer events related to ERC1155 only
+    const erc1155Operations = !erc1155_transfer_events
+      ? []
+      : flatMap(erc1155_transfer_events, (event) => {
+          const sender = safeEncodeEIP55(event.sender);
+          const receiver = safeEncodeEIP55(event.receiver);
+          const contract = safeEncodeEIP55(event.contract);
+          const operator = safeEncodeEIP55(event.operator);
+          const sending = addr === sender;
+          const receiving = addr === receiver;
+
+          if (!sending && !receiving) {
+            return [];
+          }
+
+          const all: Operation[] = [];
+
+          event.transfers.forEach((transfer) => {
+            const tokenId = transfer.id;
+            const value = new BigNumber(transfer.value);
+            const nftId = encodeNftId(id, event.contract, tokenId);
+
+            if (sending) {
+              const type = "NFT_OUT";
+              all.push({
+                id: `${nftId}-${hash}-${type}`,
+                senders: [sender],
+                recipients: [receiver],
+                contract,
+                fee,
+                operator,
+                standard: "ERC1155",
+                tokenId,
+                value,
+                hash,
+                type,
+                blockHeight,
+                blockHash,
+                date,
+                transactionSequenceNumber,
+                accountId: id,
+                extra: {},
+              });
+            }
+
+            if (receiving) {
+              const type = "NFT_IN";
+              all.push({
+                id: `${nftId}-${hash}-${type}`,
+                senders: [sender],
+                recipients: [receiver],
+                contract,
+                fee,
+                operator,
+                standard: "ERC1155",
+                tokenId,
+                value,
+                hash,
+                type,
+                blockHeight,
+                blockHash,
+                date,
+                transactionSequenceNumber,
+                accountId: id,
+                extra: {},
+              });
+            }
+          });
+
+          return all;
+        });
+
+    const nftOperations = erc721Operations
+      .concat(erc1155Operations)
+      /** @warning is this necessary ? Do we need the operations to be chronologically organised for LLD/LLM ? */
+      .sort((a, b) => b.date.getTime() - a.date.getTime());
     const ops: Operation[] = [];
 
     if (sending) {
@@ -325,6 +494,7 @@ const txToOps =
         hasFailed,
         internalOperations: internalOperations,
         subOperations,
+        nftOperations,
         transactionSequenceNumber,
       });
     }
@@ -347,6 +517,7 @@ const txToOps =
         internalOperations: sending ? [] : internalOperations,
         // if it was already in sending, we don't add twice
         subOperations: sending ? [] : subOperations,
+        nftOperations,
         transactionSequenceNumber,
       });
     }
@@ -354,7 +525,9 @@ const txToOps =
     if (
       !sending &&
       !receiving &&
-      (internalOperations.length || subOperations.length)
+      (internalOperations.length ||
+        subOperations.length ||
+        nftOperations.length)
     ) {
       ops.push({
         id: `${id}-${hash}-NONE`,
@@ -371,6 +544,7 @@ const txToOps =
         extra: {},
         internalOperations,
         subOperations,
+        nftOperations,
         transactionSequenceNumber,
       });
     }
@@ -445,6 +619,11 @@ async function loadERC20Balances(tokenAccounts, address, api) {
     .filter(Boolean);
 }
 
+function getNfts(nftOperations: Operation[]): NFT[] {
+  const nfts: NFT[] = nftsFromOperations(nftOperations);
+  return nfts.filter((nft) => nft.amount.gt(0));
+}
+
 const SAFE_REORG_THRESHOLD = 80;
 
 function stableOperations(a) {

package/src/families/ethereum/versions.ts

@@ -0,0 +1 @@
+export const NFT_VERSION = 1;

package/src/nft/NftMetadataProvider/index.tsx

@@ -0,0 +1,205 @@
+import React, {
+  createContext,
+  useContext,
+  useMemo,
+  useState,
+  useEffect,
+} from "react";
+import { Currency, findCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import { API, apiForCurrency } from "../../api/Ethereum";
+import { NFTMetadataResponse } from "../../types";
+import { 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);
+
+const NftMetadataContext = createContext<NFTMetadataContextType>({
+  cache: {},
+  loadNFTMetadata: () => 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();
+      });
+    },
+  };
+})();
+
+export function useNftMetadata(contract: string, tokenId: string): NFTResource {
+  const { cache, loadNFTMetadata } = useContext(NftMetadataContext);
+
+  const key = getNftKey(contract, tokenId);
+
+  const cachedData = cache[key];
+
+  useEffect(() => {
+    if (!cachedData || isOutdated(cachedData)) {
+      loadNFTMetadata(contract, tokenId);
+    }
+  }, [contract, tokenId, cachedData, loadNFTMetadata]);
+
+  if (cachedData) {
+    return cachedData;
+  } else {
+    return {
+      status: "queued",
+    };
+  }
+}
+
+export function useNftAPI(): NFTMetadataContextAPI {
+  const { clearCache, loadNFTMetadata } = useContext(NftMetadataContext);
+
+  return {
+    clearCache,
+    loadNFTMetadata,
+  };
+}
+
+type NFTMetadataProviderProps = {
+  children: React.ReactNode;
+};
+
+export function NftMetadataProvider({
+  children,
+}: NFTMetadataProviderProps): React.ReactElement {
+  const [state, setState] = useState<NFTMetadataContextState>({
+    cache: {},
+  });
+
+  const api = useMemo(
+    () => ({
+      loadNFTMetadata: async (contract: string, tokenId: string) => {
+        const key = getNftKey(contract, tokenId);
+
+        setState((oldState) => ({
+          ...oldState,
+          cache: {
+            ...oldState.cache,
+            [key]: {
+              status: "loading",
+            },
+          },
+        }));
+
+        try {
+          const { status, result } = await metadataCallBatcher.load({
+            contract,
+            tokenId,
+          });
+
+          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(),
+              },
+            },
+          }));
+        }
+      },
+      clearCache: () => {
+        setState((oldState) => ({
+          ...oldState,
+          cache: {},
+        }));
+      },
+    }),
+    []
+  );
+
+  const value = { ...state, ...api };
+  return (
+    <NftMetadataContext.Provider value={value}>
+      {children}
+    </NftMetadataContext.Provider>
+  );
+}

package/src/nft/NftMetadataProvider/logic.ts

@@ -0,0 +1,20 @@
+import { NFTResource } from "./types";
+
+// Handle lifecycle of cached data.
+// Expiration date depend on the resource's status.
+export function isOutdated(resource: NFTResource): boolean {
+  const now = Date.now();
+
+  switch (resource.status) {
+    case "loaded": {
+      return now - resource.updatedAt > 14 * 24 * 60 * 60 * 1 * 1000; // 14 days
+    }
+    case "error": {
+      return now - resource.updatedAt > 1 * 1000; // 1 second
+    }
+    case "nodata": {
+      return now - resource.updatedAt > 24 * 60 * 60 * 1 * 1000; // 1 day
+    }
+  }
+  return false;
+}

package/src/nft/NftMetadataProvider/types.ts

@@ -0,0 +1,60 @@
+import { NFTMetadataResponse } from "../../types";
+
+export type NFTResourceQueued = {
+  status: "queued";
+};
+
+export type NFTResourceLoading = {
+  status: "loading";
+};
+
+export type NFTResourceLoaded = {
+  status: "loaded";
+  metadata: Pick<NFTMetadataResponse, "result">;
+  updatedAt: number;
+};
+
+export type NFTResourceError = {
+  status: "error";
+  error: any;
+  updatedAt: number;
+};
+
+export type NFTResourceNoData = {
+  status: "nodata";
+  updatedAt: number;
+};
+
+export type NFTResource =
+  | NFTResourceQueued
+  | NFTResourceLoading
+  | NFTResourceLoaded
+  | NFTResourceError
+  | NFTResourceNoData;
+
+export type NFTMetadataContextState = {
+  cache: Record<string, NFTResource>;
+};
+
+export type NFTMetadataContextAPI = {
+  loadNFTMetadata: (contract: string, tokenId: string) => Promise<void>;
+  clearCache: () => void;
+};
+
+export type NFTMetadataContextType = NFTMetadataContextState &
+  NFTMetadataContextAPI;
+
+export type BatchElement = {
+  couple: {
+    contract: string;
+    tokenId: string;
+  };
+  resolve: (value: NFTMetadataResponse) => void;
+  reject: (reason?: Error) => void;
+};
+
+export type Batch = {
+  couples: Array<BatchElement["couple"]>;
+  resolvers: Array<BatchElement["resolve"]>;
+  rejecters: Array<BatchElement["reject"]>;
+};

package/src/nft/helpers.ts

@@ -0,0 +1,78 @@
+import eip55 from "eip55";
+import BigNumber from "bignumber.js";
+import { NFT, Operation } from "../types";
+
+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[] => {
+  const nftsMap = ops
+    // 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) => {
+      if (!nftOp?.contract) {
+        return acc;
+      }
+
+      // Creating a "token for a contract" unique key
+      const contract = eip55.encode(nftOp.contract!);
+      const nftKey = contract + nftOp.tokenId!;
+      const { tokenId, standard, id } = nftOp;
+
+      const nft = (acc[nftKey] ?? {
+        id,
+        tokenId: tokenId!,
+        amount: new BigNumber(0),
+        collection: {
+          contract,
+          standard: standard!,
+        },
+      }) as NFT;
+
+      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);
+      }
+
+      acc[nftKey] = nft;
+
+      return acc;
+    }, {});
+
+  return Object.values(nftsMap);
+};
+
+export const nftsByCollections = (
+  nfts: NFT[] = [],
+  collectionAddress?: string
+): CollectionWithNFT[] => {
+  const filteredNfts = collectionAddress
+    ? nfts.filter((n) => n.collection.contract === collectionAddress)
+    : nfts;
+
+  const collectionMap = filteredNfts.reduce(
+    (acc: CollectionMap<CollectionWithNFT>, nft: NFT) => {
+      const { collection, ...nftWithoutCollection } = nft;
+
+      if (!acc[collection.contract]) {
+        acc[collection.contract] = { ...collection, nfts: [] };
+      }
+      acc[collection.contract].nfts.push(nftWithoutCollection);
+
+      return acc;
+    },
+    {} as CollectionMap<CollectionWithNFT>
+  );
+
+  return Object.values(collectionMap);
+};
+
+export const getNftKey = (contract: string, tokenId: string): string => {
+  return `${contract}-${tokenId}`;
+};

package/src/nft/index.ts

@@ -0,0 +1,3 @@
+export * from "./nftId";
+export * from "./helpers";
+export * from "./NftMetadataProvider";

package/src/nft/nftId.ts

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