@ledgerhq/live-common 21.16.4 → 21.18.0

package/src/families/bitcoin/wallet-btc/crypto/zen.ts

@@ -84,11 +84,16 @@ class Zen implements ICrypto {
     if (!this.validateAddress(address)) {
       throw new InvalidAddress();
     }
-    // TODO find a better way to calculate the script from zen address instead of converting to bitcoin address
-    return toOutputScript(
+    const outputScript = toOutputScript(
       Zen.toBitcoinAddr(address),
       coininfo.bitcoin.main.toBitcoinJS()
     );
+    // refer to https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/scripts/BitcoinLikeScript.cpp#L139 and https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/networks.cpp#L39 for bip115 Script and its network parameters
+    const bip115Script = Buffer.from(
+      "209ec9845acb02fab24e1c0368b3b517c1a4488fba97f0e3459ac053ea0100000003c01f02b4",
+      "hex"
+    );
+    return Buffer.concat([outputScript, bip115Script]);
   }
 
   // eslint-disable-next-line class-methods-use-this

package/src/families/ethereum/cli-transaction.ts

@@ -23,6 +23,16 @@ const options = [
     desc: "use an token account children of the account",
     multiple: true,
   },
+  {
+    name: "collection",
+    type: String,
+    desc: "determine the collection of an NFT (related to the --tokenId)",
+  },
+  {
+    name: "tokenId",
+    type: String,
+    desc: "determine the tokenId of an NFT (related to the --colection)",
+  },
   {
     name: "gasPrice",
     type: String,

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

@@ -0,0 +1,142 @@
+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";
+
+const notOwnedNft = createCustomErrorClass("NotOwnedNft");
+const notEnoughNftOwned = createCustomErrorClass("NotEnoughNftOwned");
+const notTokenIdsProvided = createCustomErrorClass("NotTokenIdsProvided");
+
+export type Modes = "erc1155.transfer";
+
+const erc1155Transfer: 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();
+      }
+
+      const enoughTokensOwned: true | Error =
+        t.tokenIds?.reduce((acc, tokenId, index) => {
+          if (acc instanceof Error) {
+            return acc;
+          }
+
+          const nft = a.nfts?.find((n) => n.tokenId === tokenId);
+          const transferQuantity = Number(t.quantities?.[index]);
+
+          if (!nft) {
+            return new notOwnedNft();
+          }
+
+          if (transferQuantity && !nft.amount.gte(transferQuantity)) {
+            return new notEnoughNftOwned();
+          }
+
+          return true;
+        }, true as true | Error) || new notTokenIdsProvided();
+
+      if (!enoughTokensOwned || enoughTokensOwned instanceof Error) {
+        result.errors.amount = enoughTokensOwned;
+      }
+    }
+  },
+
+  /**
+   * This will only be used by LLM & LLD, not the HW.
+   */
+  fillDeviceTransactionConfig(input, fields) {
+    fields.push({
+      type: "text",
+      label: "Type",
+      value: `ERC721.transfer`,
+    });
+
+    fields.push({
+      type: "text",
+      label: "Collection",
+      value: input.transaction.collection ?? "",
+    });
+
+    fields.push({
+      type: "text",
+      label: "Token IDs",
+      value: input.transaction.tokenIds?.join(",") ?? "",
+    });
+
+    fields.push({
+      type: "text",
+      label: "Quantities",
+      value: input.transaction.quantities?.join(",") ?? "",
+    });
+  },
+
+  /**
+   * 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);
+  const tokenIds = transaction.tokenIds || [];
+  const quantities = transaction.quantities?.map((q) => q.toFixed()) || [];
+
+  return tokenIds?.length > 1
+    ? abi.simpleEncode(
+        "safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)",
+        from,
+        to,
+        tokenIds,
+        quantities,
+        "0x00"
+      )
+    : abi.simpleEncode(
+        "safeTransferFrom(address,address,uint256,uint256,bytes)",
+        from,
+        to,
+        tokenIds[0],
+        quantities[0],
+        "0x00"
+      );
+}
+
+export const modes: Record<Modes, ModeModule> = {
+  "erc1155.transfer": erc1155Transfer,
+};

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

@@ -0,0 +1,108 @@
+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";
+
+const notOwnedNft = createCustomErrorClass("NotOwnedNft");
+
+export type Modes = "erc721.transfer";
+
+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();
+      }
+    }
+  },
+
+  /**
+   * This will only be used by LLM & LLD, not the HW.
+   */
+  fillDeviceTransactionConfig(input, fields) {
+    fields.push({
+      type: "text",
+      label: "Type",
+      value: `ERC721.transfer`,
+    });
+
+    fields.push({
+      type: "text",
+      label: "Collection",
+      value: input.transaction.collection ?? "",
+    });
+
+    fields.push({
+      type: "text",
+      label: "Token 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

package/src/families/ethereum/transaction.ts

@@ -86,15 +86,38 @@ 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} TokenId: ${
+          t.tokenIds?.[0]
+        }`;
+      case "erc1155.transfer":
+        return (
+          `${t.mode.toUpperCase()} Collection: ${t.collection}` +
+          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 +125,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 +151,9 @@ export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
     },
     allowZeroAmount: tr.allowZeroAmount,
     feesStrategy: tr.feesStrategy,
+    tokenIds: tr.tokenIds,
+    collection: tr.collection,
+    quantities: tr.quantities?.map((q) => new BigNumber(q)),
   };
 };
 export const toTransactionRaw = (t: Transaction): TransactionRaw => {
@@ -151,6 +178,9 @@ export const toTransactionRaw = (t: Transaction): TransactionRaw => {
     },
     allowZeroAmount: t.allowZeroAmount,
     feesStrategy: t.feesStrategy,
+    tokenIds: t.tokenIds,
+    collection: t.collection,
+    quantities: t.quantities?.map((q) => q.toString()),
   };
 };
 

package/src/families/ethereum/types.ts

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