@ledgerhq/live-common 21.18.0 → 21.19.2

package/src/families/ethereum/nft.test.ts

@@ -0,0 +1,263 @@
+import "../../__tests__/test-helpers/setup";
+import BigNumber from "bignumber.js";
+import { reduce } from "rxjs/operators";
+import { fromAccountRaw, toAccountRaw, toNFTRaw } from "../../account";
+import type { Account, AccountRaw, NFT } from "../../types";
+import { getAccountBridge } from "../../bridge";
+import { makeBridgeCacheSystem } from "../../bridge/cache";
+import { patchAccount } from "../../reconciliation";
+import { setEnv } from "../../env";
+import { mergeNfts } from "../../bridge/jsHelpers";
+import { encodeNftId } from "../../nft";
+
+jest.setTimeout(120000);
+
+const gaspardAccount: AccountRaw = {
+  id: "js:1:ethereum:0xb98d10d9f6d07ba283bfd21b2dfec050f9ae282a:",
+  seedIdentifier: "0xb98d10d9f6d07ba283bfd21b2dfec050f9ae282a",
+  name: "G4sp4rd",
+  derivationMode: "",
+  index: 0,
+  freshAddress: "0xb98d10d9f6d07ba283bfd21b2dfec050f9ae282a",
+  freshAddressPath: "44'/60'/0'/0/0",
+  freshAddresses: [],
+  pendingOperations: [],
+  operations: [],
+  currencyId: "ethereum",
+  unitMagnitude: 18,
+  balance: "",
+  blockHeight: 0,
+  lastSyncDate: "",
+  xpub: "",
+};
+
+/*
+const gaspardPolygonAccount: AccountRaw = {
+  id: "js:1:polygon:0xb98d10d9f6d07ba283bfd21b2dfec050f9ae282a:",
+  seedIdentifier: "0xb98d10d9f6d07ba283bfd21b2dfec050f9ae282a",
+  name: "G4sp4rd",
+  derivationMode: "",
+  index: 0,
+  freshAddress: "0xb98d10d9f6d07ba283bfd21b2dfec050f9ae282a",
+  freshAddressPath: "44'/60'/0'/0/0",
+  freshAddresses: [],
+  pendingOperations: [],
+  operations: [],
+  currencyId: "polygon",
+  unitMagnitude: 18,
+  balance: "",
+  blockHeight: 0,
+  lastSyncDate: "",
+  xpub: "",
+};
+*/
+
+const gaspardBscAccount: AccountRaw = {
+  id: "js:1:bsc:0xb98d10d9f6d07ba283bfd21b2dfec050f9ae282a:",
+  seedIdentifier: "0xb98d10d9f6d07ba283bfd21b2dfec050f9ae282a",
+  name: "G4sp4rd",
+  derivationMode: "",
+  index: 0,
+  freshAddress: "0xb98d10d9f6d07ba283bfd21b2dfec050f9ae282a",
+  freshAddressPath: "44'/60'/0'/0/0",
+  freshAddresses: [],
+  pendingOperations: [],
+  operations: [],
+  currencyId: "bsc",
+  unitMagnitude: 18,
+  balance: "",
+  blockHeight: 0,
+  lastSyncDate: "",
+  xpub: "",
+};
+
+async function sync(account, withNFT = true) {
+  const bridge = getAccountBridge(account);
+  const blacklistedTokenIds = [];
+  setEnv("NFT", withNFT);
+  const r = await bridge
+    .sync(account, {
+      paginationConfig: {},
+      blacklistedTokenIds,
+    })
+    .pipe(reduce((a, f: (arg0: Account) => Account) => f(a), account))
+    .toPromise();
+  setEnv("NFT", false);
+  return r;
+}
+
+const localCache = {};
+const cache = makeBridgeCacheSystem({
+  saveData(c, d) {
+    localCache[c.id] = d;
+    return Promise.resolve();
+  },
+  getData(c) {
+    return Promise.resolve(localCache[c.id]);
+  },
+});
+
+describe("nft merging", () => {
+  const makeNFT = (tokenId: string, contract: string, amount: number): NFT => ({
+    id: encodeNftId("test", contract, tokenId),
+    tokenId,
+    amount: new BigNumber(amount),
+    collection: {
+      contract,
+      standard: "erc721",
+    },
+  });
+  const oldNfts = [
+    makeNFT("1", "contract1", 10),
+    makeNFT("2", "contract1", 1),
+    makeNFT("3", "contract2", 6),
+  ];
+
+  test("should remove first NFT and return new array with same refs", () => {
+    const nfts = [makeNFT("2", "contract1", 1), makeNFT("3", "contract2", 6)];
+    const newNfts = mergeNfts(oldNfts, nfts);
+
+    expect(newNfts.map(toNFTRaw)).toEqual(nfts.map(toNFTRaw));
+    expect(oldNfts[1]).toBe(newNfts[0]);
+    expect(oldNfts[2]).toBe(newNfts[1]);
+  });
+
+  test("should remove any NFT and return new array with same refs", () => {
+    const nfts = [makeNFT("1", "contract1", 10), makeNFT("3", "contract2", 6)];
+    const newNfts = mergeNfts(oldNfts, nfts);
+
+    expect(newNfts.map(toNFTRaw)).toEqual(nfts.map(toNFTRaw));
+    expect(oldNfts[0]).toBe(newNfts[0]);
+    expect(oldNfts[2]).toBe(newNfts[1]);
+  });
+
+  test("should change NFT amount and return new array with new ref", () => {
+    const nfts = [
+      makeNFT("1", "contract1", 10),
+      makeNFT("2", "contract1", 5),
+      makeNFT("3", "contract2", 6),
+    ];
+    const addToNft1 = mergeNfts(oldNfts, nfts);
+
+    expect(addToNft1.map(toNFTRaw)).toEqual(nfts.map(toNFTRaw));
+    expect(oldNfts[0]).toBe(addToNft1[0]);
+    expect(oldNfts[1]).not.toBe(addToNft1[1]);
+    expect(oldNfts[2]).toBe(addToNft1[2]);
+  });
+
+  test("should add NFT and return new array with new ref", () => {
+    const nfts = [
+      makeNFT("1", "contract1", 10),
+      makeNFT("2", "contract1", 1),
+      makeNFT("3", "contract2", 6),
+      makeNFT("4", "contract2", 4),
+    ];
+    const addToNft1 = mergeNfts(oldNfts, nfts);
+
+    expect(addToNft1.map(toNFTRaw)).toEqual(
+      [
+        makeNFT("4", "contract2", 4),
+        makeNFT("1", "contract1", 10),
+        makeNFT("2", "contract1", 1),
+        makeNFT("3", "contract2", 6),
+      ].map(toNFTRaw)
+    );
+    expect(oldNfts[0]).toBe(addToNft1[1]);
+    expect(oldNfts[1]).toBe(addToNft1[2]);
+    expect(oldNfts[2]).toBe(addToNft1[3]);
+    expect(addToNft1[0]).toBe(nfts[3]);
+  });
+});
+
+describe("gaspard NFT on ethereum", () => {
+  let account = fromAccountRaw(gaspardAccount);
+
+  test("first sync & have nfts", async () => {
+    await cache.prepareCurrency(account.currency);
+    account = await sync(account);
+    expect(account.nfts?.length || 0).not.toBe(0);
+  });
+
+  test("remove half NFTs will restore them with operations still here", async () => {
+    const copy = {
+      ...account,
+      nfts: account.nfts?.slice(Math.ceil((account.nfts?.length || 0) / 2)),
+    };
+    const resync = await sync(copy);
+    expect(resync.nfts).toEqual(account.nfts);
+  });
+
+  test("remove half NFTs will restore them with missing operations too", async () => {
+    const copy = {
+      ...account,
+      operations: [],
+      nfts: account.nfts?.slice(Math.ceil((account.nfts?.length || 0) / 2)),
+    };
+    const resync = await sync(copy);
+    expect(resync.nfts).toEqual(account.nfts);
+  });
+
+  test("remove half NFTs will restore them with half operations", async () => {
+    const halfOps = Math.ceil(account.operations.length / 2);
+    const copy = {
+      ...account,
+      operations: account.operations.slice(halfOps),
+      nfts: account.nfts?.slice(Math.ceil((account.nfts?.length || 0) / 2)),
+    };
+    const resync = await sync(copy);
+    expect(resync.nfts).toEqual(account.nfts);
+  });
+
+  test("patchAccount restore new NFTs correctly", async () => {
+    const copy = {
+      ...account,
+      operations: [],
+      nfts: account.nfts?.slice(Math.ceil((account.nfts?.length || 0) / 2)),
+    };
+    const newAccount = patchAccount(copy, toAccountRaw(account));
+    expect(newAccount.nfts).toEqual(account.nfts);
+  });
+
+  test("start account with .nfts and disable the NFT flag should make it disappear", async () => {
+    expect(account.nfts).not.toBeFalsy();
+    const resync = await sync(account, false);
+    expect(resync.nfts).toBeFalsy();
+  });
+
+  test("start account without .nfts and enable the NFT flag should make it appear", async () => {
+    const first = await sync(account, false);
+    expect(first.nfts).toBeFalsy();
+    const second = await sync(first, true);
+    expect(second.nfts).not.toBeFalsy();
+    expect(second.nfts).toEqual(account.nfts);
+  });
+
+  test("no nft should be on quantity 0 or negative", async () => {
+    expect(account.nfts?.find((n) => !n.amount.gt(0))).toEqual(undefined);
+  });
+});
+
+/*
+// this is never ending here... have to disable this test... (backend issue)
+describe("gaspard NFT on polygon", () => {
+  let account = fromAccountRaw(gaspardPolygonAccount);
+  test("first sync", async () => {
+    await cache.prepareCurrency(account.currency);
+    account = await sync(account);
+  });
+  test(".nfts shouldn't be visible", () => {
+    expect(account.nfts).toBeFalsy();
+  });
+});
+*/
+
+describe("gaspard NFT on bsc", () => {
+  let account = fromAccountRaw(gaspardBscAccount);
+  test("first sync", async () => {
+    await cache.prepareCurrency(account.currency);
+    account = await sync(account);
+  });
+  test(".nfts shouldn't be visible", () => {
+    expect(account.nfts).toBeFalsy();
+  });
+});

package/src/families/ethereum/signOperation.ts

@@ -13,7 +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";
+import { isNFTActive } from "../../nft";
 export const signOperation = ({
   account,
   deviceId,
@@ -57,12 +57,11 @@ export const signOperation = ({
                 nonce
               );
               const to = eip55.encode("0x" + tx.to.toString("hex"));
-              const chainId = tx.getChainId();
               const value = new BigNumber(
                 "0x" + (tx.value.toString("hex") || "0")
               );
               const eth = new Eth(transport);
-              if (getEnv("NFT")) {
+              if (isNFTActive(account.currency)) {
                 eth.setLoadConfig({
                   // FIXME drop this after LL-8001
                   nftExplorerBaseURL:
@@ -99,19 +98,7 @@ export const signOperation = ({
                 type: "device-signature-granted",
               });
               // Second, we re-set some tx fields from the device signature
-              let v = result.v;
-
-              if (chainId > 0) {
-                // EIP155 support. check/recalc signature v value.
-                const rv = parseInt(v, 16);
-                let cv = chainId * 2 + 35;
-
-                if (rv !== cv && (rv & cv) !== rv) {
-                  cv += 1; // add signature v bit.
-                }
-
-                v = cv.toString(16);
-              }
+              const v = result.v;
 
               tx.v = Buffer.from(v, "hex");
               tx.r = Buffer.from(result.r, "hex");

package/src/families/ethereum/synchronisation.test.ts

@@ -6,6 +6,7 @@ import type { Account, SubAccount } from "../../types";
 import { getAccountBridge } from "../../bridge";
 import { makeBridgeCacheSystem } from "../../bridge/cache";
 import { ethereum1 } from "./test-dataset";
+
 describe("blacklistedTokenIds functionality", () => {
   const account = fromAccountRaw(ethereum1);
   const localCache = {};

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 = {