@ledgerhq/live-common 21.19.0 → 21.19.4

package/src/families/ethereum/synchronisation.ts

@@ -15,13 +15,12 @@ import {
 } from "../../account";
 import { listTokensForCryptoCurrency } from "../../currencies";
 import { encodeAccountId } from "../../account";
-import type { Operation, TokenAccount, Account, NFT } from "../../types";
+import type { Operation, TokenAccount, Account } 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 { encodeNftId, isNFTActive, nftsFromOperations } from "../../nft";
 import { NFT_VERSION } from "./versions";
-import { getEnv } from "../../env";
 
 export const getAccountShape: GetAccountShape = async (
   infoInput,
@@ -41,24 +40,24 @@ export const getAccountShape: GetAccountShape = async (
   const initialStableOperations = initialAccount
     ? stableOperations(initialAccount)
     : [];
+  const shouldNFTBeActive = isNFTActive(currency);
   // fetch transactions, incrementally if possible
   const mostRecentStableOperation = initialStableOperations[0];
   // when new tokens are added / blacklist changes, we need to sync again because we need to go through all operations again
   const syncHash =
     JSON.stringify(blacklistedTokenIds || []) +
     "_" +
+    shouldNFTBeActive +
+    "_" +
     listTokensForCryptoCurrency(currency, {
       withDelisted: true,
     }).length;
-  const outdatedBlacklist = initialAccount?.syncHash !== syncHash;
-  const firstNftSync =
-    getEnv("NFT") && typeof initialAccount?.nfts === "undefined";
+  const outdatedSyncHash = initialAccount?.syncHash !== syncHash;
   const pullFromBlockHash =
     initialAccount &&
     areAllOperationsLoaded(initialAccount) &&
     mostRecentStableOperation &&
-    !outdatedBlacklist &&
-    !firstNftSync &&
+    !outdatedSyncHash &&
     NFT_VERSION
       ? mostRecentStableOperation.blockHash
       : undefined;
@@ -83,10 +82,8 @@ 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, nftOperations } = op;
+    const { subOperations } = op;
 
     if (subOperations?.length) {
       subOperations.forEach((sop) => {
@@ -97,10 +94,6 @@ 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) => {
@@ -173,8 +166,8 @@ export const getAccountShape: GetAccountShape = async (
   }));
   const operations = mergeOps(initialStableOperations, newOps);
 
-  const nfts = getEnv("NFT")
-    ? mergeNfts(initialAccount?.nfts, await getNfts(flatNftOps))
+  const nfts = isNFTActive(currency)
+    ? mergeNfts(initialAccount?.nfts, nftsFromOperations(operations))
     : undefined;
 
   const accountShape: Partial<Account> = {
@@ -334,91 +327,23 @@ const txToOps =
         });
 
     // 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 erc721Operations =
+      !erc721_transfer_events || !isNFTActive(currency)
+        ? []
+        : 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;
 
-          const all: Operation[] = [];
+            if (!sending && !receiving) {
+              return [];
+            }
 
-          event.transfers.forEach((transfer) => {
-            const tokenId = transfer.id;
-            const value = new BigNumber(transfer.value);
-            const nftId = encodeNftId(id, event.contract, tokenId);
+            const all: Operation[] = [];
 
             if (sending) {
               const type = "NFT_OUT";
@@ -428,10 +353,9 @@ const txToOps =
                 recipients: [receiver],
                 contract,
                 fee,
-                operator,
-                standard: "ERC1155",
+                standard: "ERC721",
                 tokenId,
-                value,
+                value: new BigNumber(1),
                 hash,
                 type,
                 blockHeight,
@@ -451,10 +375,9 @@ const txToOps =
                 recipients: [receiver],
                 contract,
                 fee,
-                operator,
-                standard: "ERC1155",
+                standard: "ERC721",
                 tokenId,
-                value,
+                value: new BigNumber(1),
                 hash,
                 type,
                 blockHeight,
@@ -465,15 +388,88 @@ const txToOps =
                 extra: {},
               });
             }
+
+            return all;
           });
 
-          return all;
-        });
+    // Creating NFTOps from transfer events related to ERC1155 only
+    const erc1155Operations =
+      !erc1155_transfer_events || !isNFTActive(currency)
+        ? []
+        : 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) {
@@ -619,11 +615,6 @@ 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/transaction.ts

@@ -90,12 +90,14 @@ export const formatTransaction = (
   const header = (() => {
     switch (t.mode) {
       case "erc721.transfer":
-        return `${t.mode.toUpperCase()} Collection: ${t.collection} TokenId: ${
-          t.tokenIds?.[0]
-        }`;
+        return `${t.mode.toUpperCase()} Collection: ${t.collection} (${
+          t.collectionName || ""
+        }) TokenId: ${t.tokenIds?.[0]}`;
       case "erc1155.transfer":
         return (
-          `${t.mode.toUpperCase()} Collection: ${t.collection}` +
+          `${t.mode.toUpperCase()} Collection: ${t.collection} (${
+            t.collectionName || ""
+          })` +
           t.tokenIds
             ?.map((tokenId, index) => {
               return `\n  - TokenId: ${tokenId} Quantity: ${
@@ -153,6 +155,7 @@ export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
     feesStrategy: tr.feesStrategy,
     tokenIds: tr.tokenIds,
     collection: tr.collection,
+    collectionName: tr.collectionName,
     quantities: tr.quantities?.map((q) => new BigNumber(q)),
   };
 };
@@ -180,6 +183,7 @@ export const toTransactionRaw = (t: Transaction): TransactionRaw => {
     feesStrategy: t.feesStrategy,
     tokenIds: t.tokenIds,
     collection: t.collection,
+    collectionName: t.collectionName,
     quantities: t.quantities?.map((q) => q.toString()),
   };
 };

package/src/families/ethereum/types.ts

@@ -38,6 +38,7 @@ export type Transaction = TransactionCommon & {
   networkInfo: NetworkInfo | null | undefined;
   allowZeroAmount?: boolean;
   collection?: string;
+  collectionName?: string;
   tokenIds?: string[];
   quantities?: BigNumber[];
 };
@@ -54,6 +55,7 @@ export type TransactionRaw = TransactionCommonRaw & {
   allowZeroAmount?: boolean;
   tokenIds?: string[];
   collection?: string;
+  collectionName?: string;
   quantities?: string[];
 };
 export type TypedMessage = {

package/src/nft/helpers.ts

@@ -1,6 +1,7 @@
 import eip55 from "eip55";
 import BigNumber from "bignumber.js";
-import { NFT, Operation, Transaction } from "../types";
+import { NFT, Operation } from "../types";
+import { encodeNftId } from ".";
 
 type Collection = NFT["collection"];
 
@@ -15,23 +16,22 @@ export const nftsFromOperations = (ops: Operation[]): NFT[] => {
     // 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) {
+      let { contract } = nftOp;
+      if (!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;
+      contract = eip55.encode(contract);
+      const { tokenId, standard, accountId } = nftOp;
+      if (!tokenId || !standard) return acc;
+      const id = encodeNftId(accountId, contract, tokenId || "");
 
-      const nft = (acc[nftKey] ?? {
+      const nft = (acc[id] || {
         id,
-        tokenId: tokenId!,
+        tokenId,
         amount: new BigNumber(0),
-        collection: {
-          contract,
-          standard: standard!,
-        },
+        collection: { contract, standard },
       }) as NFT;
 
       if (nftOp.type === "NFT_IN") {
@@ -40,12 +40,12 @@ export const nftsFromOperations = (ops: Operation[]): NFT[] => {
         nft.amount = nft.amount.minus(nftOp.value);
       }
 
-      acc[nftKey] = nft;
+      acc[id] = nft;
 
       return acc;
     }, {});
 
-  return Object.values(nftsMap);
+  return Object.values(nftsMap).filter((n) => n.amount.gt(0));
 };
 
 export const nftsByCollections = (
@@ -76,11 +76,3 @@ export const nftsByCollections = (
 export const getNftKey = (contract: string, tokenId: string): string => {
   return `${contract}-${tokenId}`;
 };
-
-export const isNftTransaction = (transaction: Transaction): boolean => {
-  if (transaction.family === "ethereum") {
-    return ["erc721.transfer", "erc1155.transfer"].includes(transaction.mode);
-  }
-
-  return false;
-};

package/src/nft/index.ts

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

package/src/nft/support.ts

@@ -0,0 +1,16 @@
+import { Transaction, CryptoCurrency } from "../types";
+import { getEnv } from "../env";
+
+export const isNftTransaction = (transaction: Transaction): boolean => {
+  if (transaction.family === "ethereum") {
+    return ["erc721.transfer", "erc1155.transfer"].includes(transaction.mode);
+  }
+
+  return false;
+};
+
+export function isNFTActive(currency: CryptoCurrency): boolean {
+  return (
+    getEnv("NFT") && getEnv("NFT_CURRENCIES").split(",").includes(currency.id)
+  );
+}

package/src/reconciliation.ts

@@ -384,7 +384,10 @@ export function patchAccount(
   }
 
   const nfts = updatedRaw?.nfts?.map(fromNFTRaw);
-  if (updatedRaw.nfts && !isEqual(account.nfts, nfts)) {
+  if (!updatedRaw.nfts && account.nfts) {
+    delete next.nfts;
+    changed = true;
+  } else if (!isEqual(account.nfts, nfts)) {
     next.nfts = nfts;
     changed = true;
   }