@ledgerhq/live-common 21.17.2 → 21.19.1

package/src/families/ethereum/modules/erc721.ts

@@ -0,0 +1,146 @@
+import eip55 from "eip55";
+import abi from "ethereumjs-abi";
+import invariant from "invariant";
+import BigNumber from "bignumber.js";
+import {
+  createCustomErrorClass,
+  NotEnoughBalanceInParentAccount,
+} from "@ledgerhq/errors";
+import { validateRecipient } from "../transaction";
+import type { ModeModule, Transaction } from "../types";
+import type { Account } from "../../../types";
+import { apiForCurrency } from "../../../api/Ethereum";
+
+const notOwnedNft = createCustomErrorClass("NotOwnedNft");
+
+export type Modes = "erc721.transfer";
+
+export async function prepareTransaction(
+  account: Account,
+  transaction: Transaction
+): Promise<Transaction> {
+  let t = transaction;
+  const { collection, collectionName, tokenIds } = transaction;
+  if (collection && tokenIds && typeof collectionName === "undefined") {
+    const api = apiForCurrency(account.currency);
+    const [{ status, result }] = await api.getNFTMetadata([
+      {
+        contract: collection,
+        tokenId: tokenIds[0],
+      },
+    ]);
+    let collectionName = ""; // default value fallback if issue
+    if (status === 200) {
+      collectionName = result?.tokenName || "";
+    }
+    t = { ...t, collectionName };
+  }
+  return Promise.resolve(t);
+}
+
+const erc721Transfer: ModeModule = {
+  /**
+   * Tx data is filled during the buildEthereumTx
+   */
+  fillTransactionData(a, t, tx) {
+    const data = serializeTransactionData(a, t);
+    invariant(data, "serializeTransactionData provided no data");
+    tx.data = "0x" + (data as Buffer).toString("hex");
+    tx.to = t.collection;
+    tx.value = "0x00";
+  },
+
+  /**
+   * Tx status is filled after the buildEthereumTx
+   */
+  fillTransactionStatus: (a, t, result) => {
+    validateRecipient(a.currency, t.recipient, result);
+
+    if (!result.errors.recipient) {
+      result.totalSpent = result.estimatedFees;
+      result.amount = new BigNumber(t.amount);
+
+      if (result.estimatedFees.gt(a.spendableBalance)) {
+        result.errors.amount = new NotEnoughBalanceInParentAccount();
+      }
+
+      if (
+        !a.nfts?.find?.(
+          (n) =>
+            n.tokenId === t.tokenIds?.[0] &&
+            n.collection.contract === t.collection
+        )
+      ) {
+        result.errors.amount = new notOwnedNft();
+      }
+    }
+  },
+
+  prepareTransaction,
+
+  /**
+   * This will only be used by LLM & LLD, not the HW.
+   */
+  fillDeviceTransactionConfig(input, fields) {
+    fields.push({
+      type: "text",
+      label: "Type",
+      value: `NFT Transfer`,
+    });
+
+    fields.push({
+      type: "text",
+      label: "To",
+      value: input.transaction.recipient ?? "",
+    });
+
+    fields.push({
+      type: "text",
+      label: "Collection Name",
+      value: input.transaction.collectionName || "",
+    });
+
+    fields.push({
+      type: "address",
+      label: "NFT Address",
+      address: input.transaction.collection ?? "",
+    });
+
+    fields.push({
+      type: "text",
+      label: "NFT ID",
+      value: input.transaction.tokenIds?.[0] ?? "",
+    });
+  },
+
+  /**
+   * Optimistic Operation is filled post signing
+   */
+  fillOptimisticOperation(a, t, op) {
+    op.type = "FEES";
+    op.extra = {
+      ...op.extra,
+      approving: true, // workaround to track the status ENABLING
+    };
+  },
+};
+
+function serializeTransactionData(
+  account: Account,
+  transaction: Transaction
+): Buffer | null | undefined {
+  const from = eip55.encode(account.freshAddress);
+  const to = eip55.encode(transaction.recipient);
+
+  return abi.simpleEncode(
+    "safeTransferFrom(address,address,uint256,bytes)",
+    from,
+    to,
+    transaction.tokenIds?.[0],
+    "0x00"
+  );
+}
+
+export const modes: Record<Modes, ModeModule> = {
+  "erc721.transfer": erc721Transfer,
+};

package/src/families/ethereum/modules/index.ts

@@ -13,15 +13,26 @@ import type { DeviceTransactionField } from "../../../transaction";
 import * as compound from "./compound";
 import * as erc20 from "./erc20";
 import * as send from "./send";
+import * as erc721 from "./erc721";
+import * as erc1155 from "./erc1155";
 import type { Modes as CompoundModes } from "./compound";
 import type { Modes as ERC20Modes } from "./erc20";
 import type { Modes as SendModes } from "./send";
+import type { Modes as ERC721Modes } from "./erc721";
+import type { Modes as ERC1155Modes } from "./erc1155";
 const modules = {
   erc20,
   compound,
   send,
+  erc721,
+  erc1155,
 };
-export type TransactionMode = CompoundModes | ERC20Modes | SendModes;
+export type TransactionMode =
+  | CompoundModes
+  | ERC20Modes
+  | SendModes
+  | ERC721Modes
+  | ERC1155Modes;
 
 /**
  * A ModeModule enable a new transaction mode in Ethereum family
@@ -79,6 +90,14 @@ export type ModeModule = {
     arg1: Transaction,
     arg2: Operation
   ) => void;
+
+  /**
+   * hook to resolve a transaction like the prepareTransaction of the bridge
+   */
+  prepareTransaction?: (
+    account: Account,
+    transaction: Transaction
+  ) => Promise<Transaction>;
 };
 export const modes: Record<TransactionMode, ModeModule> = {} as Record<
   TransactionMode,
@@ -126,6 +145,18 @@ export function hydrate(value: unknown, currency: CryptoCurrency): void {
     }
   }
 }
+export const prepareTransaction = (
+  account: Account,
+  transaction: Transaction
+): Promise<Transaction> =>
+  values(modules)
+    // @ts-expect-error some module implement it
+    .map((m) => m.prepareTransaction)
+    .filter(Boolean)
+    .reduce(
+      (p, fn) => p.then((t) => fn(account, t)),
+      Promise.resolve(transaction)
+    );
 export const prepareTokenAccounts = (
   currency: CryptoCurrency,
   subAccounts: TokenAccount[],

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

@@ -0,0 +1,259 @@
+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);
+  });
+});
+
+/*
+// 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 = {};