@ledgerhq/live-common 21.17.2 → 21.19.1

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

@@ -86,15 +86,40 @@ export const formatTransaction = (
     (t.subAccountId &&
       (mainAccount.subAccounts || []).find((a) => a.id === t.subAccountId)) ||
     mainAccount;
+
+  const header = (() => {
+    switch (t.mode) {
+      case "erc721.transfer":
+        return `${t.mode.toUpperCase()} Collection: ${t.collection} (${
+          t.collectionName || ""
+        }) TokenId: ${t.tokenIds?.[0]}`;
+      case "erc1155.transfer":
+        return (
+          `${t.mode.toUpperCase()} Collection: ${t.collection} (${
+            t.collectionName || ""
+          })` +
+          t.tokenIds
+            ?.map((tokenId, index) => {
+              return `\n  - TokenId: ${tokenId} Quantity: ${
+                t.quantities?.[index]?.toFixed() ?? 0
+              }`;
+            })
+            .join(",")
+        );
+      default:
+        return `${t.mode.toUpperCase()} ${
+          t.useAllAmount
+            ? "MAX"
+            : formatCurrencyUnit(getAccountUnit(account), t.amount, {
+                showCode: true,
+                disableRounding: true,
+              })
+        }`;
+    }
+  })();
+
   return `
-${t.mode.toUpperCase()} ${
-    t.useAllAmount
-      ? "MAX"
-      : formatCurrencyUnit(getAccountUnit(account), t.amount, {
-          showCode: true,
-          disableRounding: true,
-        })
-  }
+${header}
 TO ${t.recipient}
 with gasPrice=${formatCurrencyUnit(
     mainAccount.currency.units[1] || mainAccount.currency.units[0],
@@ -102,6 +127,7 @@ with gasPrice=${formatCurrencyUnit(
   )}
 with gasLimit=${gasLimit.toString()}`;
 };
+
 const defaultGasLimit = new BigNumber(0x5208);
 export const getGasLimit = (t: Transaction): BigNumber =>
   t.userGasLimit || t.estimatedGasLimit || defaultGasLimit;
@@ -127,6 +153,10 @@ export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
     },
     allowZeroAmount: tr.allowZeroAmount,
     feesStrategy: tr.feesStrategy,
+    tokenIds: tr.tokenIds,
+    collection: tr.collection,
+    collectionName: tr.collectionName,
+    quantities: tr.quantities?.map((q) => new BigNumber(q)),
   };
 };
 export const toTransactionRaw = (t: Transaction): TransactionRaw => {
@@ -151,6 +181,10 @@ export const toTransactionRaw = (t: Transaction): TransactionRaw => {
     },
     allowZeroAmount: t.allowZeroAmount,
     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

@@ -37,6 +37,10 @@ export type Transaction = TransactionCommon & {
   feeCustomUnit: Unit | null | undefined;
   networkInfo: NetworkInfo | null | undefined;
   allowZeroAmount?: boolean;
+  collection?: string;
+  collectionName?: string;
+  tokenIds?: string[];
+  quantities?: BigNumber[];
 };
 export type TransactionRaw = TransactionCommonRaw & {
   family: "ethereum";
@@ -49,6 +53,10 @@ export type TransactionRaw = TransactionCommonRaw & {
   feeCustomUnit: Unit | null | undefined;
   networkInfo: NetworkInfoRaw | null | undefined;
   allowZeroAmount?: boolean;
+  tokenIds?: string[];
+  collection?: string;
+  collectionName?: string;
+  quantities?: string[];
 };
 export type TypedMessage = {
   types: {

package/src/hw/uninstallApp.ts

@@ -9,14 +9,19 @@ export default function uninstallApp(
   targetId: string | number,
   app: ApplicationVersion | App
 ): Observable<any> {
-  return ManagerAPI.install(transport, "uninstall-app", {
-    targetId,
-    perso: app.perso,
-    deleteKey: app.delete_key,
-    firmware: app.delete,
-    firmwareKey: app.delete_key,
-    hash: app.hash,
-  }).pipe(
+  return ManagerAPI.install(
+    transport,
+    "uninstall-app",
+    {
+      targetId,
+      perso: app.perso,
+      deleteKey: app.delete_key,
+      firmware: app.delete,
+      firmwareKey: app.delete_key,
+      hash: app.hash,
+    },
+    true
+  ).pipe(
     ignoreElements(),
     catchError((e: Error) => {
       if (!e || !e.message) return throwError(e);

package/src/nft/helpers.ts

@@ -24,7 +24,7 @@ export const nftsFromOperations = (ops: Operation[]): NFT[] => {
       const nftKey = contract + nftOp.tokenId!;
       const { tokenId, standard, id } = nftOp;
 
-      const nft = (acc[nftKey] ?? {
+      const nft = (acc[nftKey] || {
         id,
         tokenId: tokenId!,
         amount: new BigNumber(0),

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/types/account.ts

@@ -215,7 +215,7 @@ export type Account = {
   swapHistory: SwapOperation[];
   // Hash used to discard tx history on sync
   syncHash?: string;
-  // Array of NFTs computed by diffing NFTOperations
+  // Array of NFTs computed by diffing NFTOperations ordered from newest to oldest
   nfts?: NFT[];
 };
 export type SubAccount = TokenAccount | ChildAccount;