@ledgerhq/live-common 33.1.1 → 33.2.0-next.0

package/src/families/casper/bridge/currency.ts

@@ -0,0 +1,11 @@
+import { makeScanAccounts } from "../../../bridge/jsHelpers";
+import { CurrencyBridge } from "@ledgerhq/types-live";
+import { getAccountShape } from "./bridgeHelpers/accountShape";
+
+const scanAccounts = makeScanAccounts({ getAccountShape });
+
+export const currencyBridge: CurrencyBridge = {
+  preload: () => Promise.resolve({}),
+  hydrate: () => {},
+  scanAccounts,
+};

package/src/families/casper/bridge/js.ts

@@ -0,0 +1,7 @@
+import { currencyBridge } from "./currency";
+import { accountBridge } from "./account";
+
+export default {
+  currencyBridge,
+  accountBridge,
+};

package/src/families/casper/bridge/mock.ts

@@ -0,0 +1,169 @@
+import { BigNumber } from "bignumber.js";
+import {
+  AmountRequired,
+  NotEnoughBalance,
+  RecipientRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+} from "@ledgerhq/errors";
+import type { Account, AccountBridge, AccountLike, CurrencyBridge } from "@ledgerhq/types-live";
+import type { Transaction, TransactionStatus } from "../types";
+import {
+  scanAccounts,
+  signOperation,
+  broadcast,
+  sync,
+  makeAccountBridgeReceive,
+} from "../../../bridge/mockHelpers";
+import { getEstimatedFees } from "./bridgeHelpers/fee";
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { getAddress, isAddressValid } from "./bridgeHelpers/addresses";
+import { isTransferIdValid } from "./bridgeHelpers/transferId";
+import { CasperInvalidTransferId, InvalidMinimumAmount, MayBlockAccount } from "../errors";
+import {
+  CASPER_FEES_CSPR,
+  CASPER_MAX_TRANSFER_ID,
+  CASPER_MINIMUM_VALID_AMOUNT_CSPR,
+  CASPER_MINIMUM_VALID_AMOUNT_MOTES,
+} from "../consts";
+import { getMainAccount } from "../../../account/helpers";
+
+const receive = makeAccountBridgeReceive();
+
+const createTransaction = (): Transaction => ({
+  family: "casper",
+  amount: new BigNumber(0),
+  fees: getEstimatedFees(),
+  recipient: "",
+  useAllAmount: false,
+});
+
+const getTransactionStatus = async (a: Account, t: Transaction): Promise<TransactionStatus> => {
+  const errors: TransactionStatus["errors"] = {};
+  const warnings: TransactionStatus["warnings"] = {};
+
+  const { balance, spendableBalance } = a;
+  const { address } = getAddress(a);
+  const { recipient, useAllAmount } = t;
+  let { amount } = t;
+
+  if (!recipient) errors.recipient = new RecipientRequired();
+  else if (!isAddressValid(recipient))
+    errors.recipient = new InvalidAddress("", {
+      currencyName: a.currency.name,
+    });
+  else if (recipient.toLowerCase() === address.toLowerCase())
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+
+  if (!isAddressValid(address))
+    errors.sender = new InvalidAddress("", {
+      currencyName: a.currency.name,
+    });
+  else if (!isTransferIdValid(t.transferId)) {
+    errors.sender = new CasperInvalidTransferId("", {
+      maxTransferId: CASPER_MAX_TRANSFER_ID,
+    });
+  }
+
+  const estimatedFees = t.fees;
+
+  let totalSpent = BigNumber(0);
+
+  if (useAllAmount) {
+    totalSpent = a.spendableBalance;
+    amount = totalSpent.minus(estimatedFees);
+    if (amount.lte(0) || totalSpent.gt(balance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  }
+
+  if (!useAllAmount) {
+    totalSpent = amount.plus(estimatedFees);
+    if (amount.eq(0)) {
+      errors.amount = new AmountRequired();
+    }
+
+    if (totalSpent.gt(a.spendableBalance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  }
+
+  if (amount.lt(CASPER_MINIMUM_VALID_AMOUNT_MOTES) && !errors.amount)
+    errors.amount = new InvalidMinimumAmount("", {
+      minAmount: `${CASPER_MINIMUM_VALID_AMOUNT_CSPR} CSPR`,
+    });
+
+  if (spendableBalance.minus(totalSpent).minus(estimatedFees).lt(CASPER_MINIMUM_VALID_AMOUNT_MOTES))
+    warnings.amount = new MayBlockAccount("", {
+      minAmount: `${CASPER_MINIMUM_VALID_AMOUNT_CSPR + CASPER_FEES_CSPR} CSPR`,
+    });
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+};
+
+const prepareTransaction = async (a: Account, t: Transaction): Promise<Transaction> => {
+  const { address } = getAddress(a);
+  const { recipient } = t;
+
+  if (recipient && address) {
+    if (t.useAllAmount) {
+      const amount = a.spendableBalance.minus(t.fees);
+      return { ...t, amount };
+    }
+  }
+
+  return t;
+};
+
+const estimateMaxSpendable = async ({
+  account,
+  parentAccount,
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount?: Account | null | undefined;
+  transaction?: Transaction | null | undefined;
+}): Promise<BigNumber> => {
+  const a = getMainAccount(account, parentAccount);
+  let balance = a.spendableBalance;
+
+  if (balance.eq(0)) return balance;
+
+  const estimatedFees = transaction?.fees ?? getEstimatedFees();
+
+  if (balance.lte(estimatedFees)) return new BigNumber(0);
+
+  balance = balance.minus(estimatedFees);
+
+  return balance;
+};
+const preload = async () => ({});
+
+const hydrate = () => {};
+
+const currencyBridge: CurrencyBridge = {
+  preload,
+  hydrate,
+  scanAccounts,
+};
+const accountBridge: AccountBridge<Transaction> = {
+  createTransaction,
+  updateTransaction: defaultUpdateTransaction,
+  prepareTransaction,
+  getTransactionStatus,
+  sync,
+  receive,
+  signOperation,
+  broadcast,
+  estimateMaxSpendable,
+};
+export default {
+  currencyBridge,
+  accountBridge,
+};

package/src/families/casper/bridge.integration.test.ts

@@ -0,0 +1,168 @@
+import "../../__tests__/test-helpers/setup";
+import { testBridge } from "../../__tests__/test-helpers/bridge";
+import type { CurrenciesData, DatasetTest } from "@ledgerhq/types-live";
+import type { Transaction } from "./types";
+import { fromTransactionRaw } from "./transaction";
+import BigNumber from "bignumber.js";
+import { AmountRequired, InvalidAddress, NotEnoughBalance } from "@ledgerhq/errors";
+
+import { CasperInvalidTransferId, InvalidMinimumAmount, MayBlockAccount } from "./errors";
+import { getEstimatedFees } from "./bridge/bridgeHelpers/fee";
+
+const SEED_IDENTIFIER = "0202ba6dc98cbe677711a45bf028a03646f9e588996eb223fad2485e8bc391b01581";
+const ACCOUNT_2 = "0203A17118eC0e64c4e4FdbDbEe0eA14D118C9aAf08C6c81bbB776Cae607cEB84EcB";
+
+const casper: CurrenciesData<Transaction> = {
+  scanAccounts: [
+    {
+      name: "casper seed 1",
+      apdus: `
+      => 11010000142c000080fa010080000000800000000000000000
+      <= 038c8cb0f62b4efcd0c7868c2e749dda649affe30ff0f95fc91ce48ea67f077d1630323033384338636230663632623445466344304337383638633265373439446461363439614646453330664630663935666339314345343845413637463037374431369000
+      => 11010000142c000080fa010080000000800000000001000000
+      <= 02ba6dc98cbe677711a45bf028a03646f9e588996eb223fad2485e8bc391b0158130323032624136444339386362453637373731316134356266303238413033363436463965353838393936654232323366616432343835653862633339316230313538319000
+      => 11010000142c000080fa010080000000800000000002000000
+      <= 022aab9b6ed404f8cffe76ce493e1995d195b5f141ee7d5b7fb20fce60f2a4969130323032324141423942364544343034663843464645373663653439334531393935643139354235463134314565374435423766623230464345363066324134393639319000
+      `,
+    },
+  ],
+  accounts: [
+    {
+      raw: {
+        id: `js:2:casper:${SEED_IDENTIFIER}:casper_wallet`,
+        seedIdentifier: SEED_IDENTIFIER,
+        name: "Casper 1",
+        derivationMode: "casper_wallet" as const,
+        index: 0,
+        freshAddress: SEED_IDENTIFIER,
+        freshAddressPath: "44'/506'/0'/0/1",
+        freshAddresses: [],
+        blockHeight: 0,
+        operations: [],
+        pendingOperations: [],
+        currencyId: "casper",
+        unitMagnitude: 9,
+        lastSyncDate: "",
+        balance: "1000",
+      },
+      transactions: [
+        {
+          name: "Not a valid address",
+          transaction: fromTransactionRaw({
+            family: "casper",
+            recipient: "novalidaddress",
+            fees: getEstimatedFees().toString(),
+            amount: "1000",
+          }),
+          expectedStatus: {
+            errors: {
+              recipient: new InvalidAddress(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Not enough balance",
+          transaction: fromTransactionRaw({
+            family: "casper",
+            recipient: ACCOUNT_2,
+            fees: getEstimatedFees().toString(),
+            amount: (300 * 1e9).toString(),
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Amount Required",
+          transaction: fromTransactionRaw({
+            family: "casper",
+            recipient: ACCOUNT_2,
+            amount: "0",
+            fees: getEstimatedFees().toString(),
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new AmountRequired(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Minimum Amount Required",
+          transaction: fromTransactionRaw({
+            family: "casper",
+            fees: getEstimatedFees().toString(),
+            recipient: ACCOUNT_2,
+            amount: "1",
+          }),
+
+          expectedStatus: {
+            errors: {
+              amount: new InvalidMinimumAmount(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "New account and sufficient amount",
+          transaction: fromTransactionRaw({
+            family: "casper",
+            recipient: ACCOUNT_2,
+            amount: "3",
+            fees: getEstimatedFees().toString(),
+          }),
+          expectedStatus: {
+            amount: new BigNumber("3"),
+            errors: {},
+            warnings: {},
+          },
+        },
+        {
+          name: "Invalid TransferID",
+          transaction: fromTransactionRaw({
+            family: "casper",
+            recipient: ACCOUNT_2,
+            fees: getEstimatedFees().toString(),
+            amount: "3",
+            transferId: "afdsaf1",
+          }),
+          expectedStatus: {
+            amount: new BigNumber("3"),
+            errors: {
+              sender: new CasperInvalidTransferId(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "May block account warning",
+          transaction: fromTransactionRaw({
+            family: "casper",
+            recipient: ACCOUNT_2,
+            fees: getEstimatedFees().toString(),
+            amount: (999 * 1e9).toString(),
+          }),
+          expectedStatus: {
+            errors: {},
+            warnings: {
+              amount: new MayBlockAccount(),
+            },
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    casper,
+  },
+};
+
+testBridge(dataset);

package/src/families/casper/consts.ts

@@ -0,0 +1,19 @@
+import { InvalidMinimumAmount, MayBlockAccount } from "./errors";
+
+export const CASPER_FEES_MOTES = 0.1 * 1e9;
+export const CASPER_FEES_CSPR = 0.1;
+export const CASPER_MINIMUM_VALID_AMOUNT_MOTES = 2.5 * 1e9;
+export const CASPER_MINIMUM_VALID_AMOUNT_CSPR = 2.5;
+export const CASPER_SMALL_BYTES_COUNT = 75;
+export const CASPER_NETWORK = "casper";
+export const CASPER_CHECKSUM_HEX_LEN = 32;
+
+export const CASPER_MAX_TRANSFER_ID = "18446744073709551615";
+
+export const MayBlockAccountError = new MayBlockAccount("", {
+  minAmount: `${CASPER_MINIMUM_VALID_AMOUNT_CSPR + CASPER_FEES_CSPR} CSPR`,
+});
+
+export const InvalidMinimumAmountError = new InvalidMinimumAmount("", {
+  minAmount: `${CASPER_MINIMUM_VALID_AMOUNT_CSPR} CSPR`,
+});

package/src/families/casper/deviceTransactionConfig.ts

@@ -0,0 +1,44 @@
+import { log } from "@ledgerhq/logs";
+import { Account, AccountLike } from "@ledgerhq/types-live";
+import type { DeviceTransactionField } from "../../transaction";
+import { Transaction, TransactionStatus } from "./types";
+import { methodToString } from "./msc-utils";
+import BigNumber from "bignumber.js";
+
+export type ExtraDeviceTransactionField = {
+  type: "casper.extendedAmount";
+  label: string;
+  value: number | BigNumber;
+};
+
+function getDeviceTransactionConfig({
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const fields: Array<DeviceTransactionField> = [];
+  fields.push({
+    type: "text",
+    label: "Type",
+    value: methodToString(0),
+  });
+  fields.push({
+    type: "casper.extendedAmount",
+    label: "Fee",
+    value: transaction.fees,
+  });
+  fields.push({
+    type: "casper.extendedAmount",
+    label: "Amount",
+    value: transaction.amount,
+  });
+
+  log("debug", `Transaction config ${JSON.stringify(fields)}`);
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/families/casper/errors.ts

@@ -0,0 +1,5 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const CasperInvalidTransferId = createCustomErrorClass("CasperInvalidTransferId");
+export const InvalidMinimumAmount = createCustomErrorClass("InvalidMinimumAmount");
+export const MayBlockAccount = createCustomErrorClass("MayBlockAccount");

package/src/families/casper/hw-getAddress.ts

@@ -0,0 +1,26 @@
+import Casper from "@zondax/ledger-casper";
+import { log } from "@ledgerhq/logs";
+
+import type { Resolver } from "../../hw/getAddress/types";
+import { getPath, isError } from "./msc-utils";
+import { casperAddressFromPubKey } from "./bridge/bridgeHelpers/addresses";
+
+const resolver: Resolver = async (transport, { path, verify }) => {
+  log("debug", "start getAddress process");
+
+  const casper = new Casper(transport);
+
+  const r = verify
+    ? await casper.showAddressAndPubKey(getPath(path))
+    : await casper.getAddressAndPubKey(getPath(path));
+
+  isError(r);
+
+  return {
+    path,
+    address: r.Address.length ? r.Address.toString() : casperAddressFromPubKey(r.publicKey),
+    publicKey: r.publicKey.toString("hex"),
+  };
+};
+
+export default resolver;

package/src/families/casper/hw-signMessage.ts

@@ -0,0 +1,28 @@
+import Casper from "@zondax/ledger-casper";
+import { log } from "@ledgerhq/logs";
+
+import type { SignMessage, Result } from "../../hw/signMessage/types";
+import { getBufferFromString, getPath, isError } from "./msc-utils";
+
+const signMessage: SignMessage = async (transport, account, { message }): Promise<Result> => {
+  log("debug", "start signMessage process");
+
+  const casper = new Casper(transport);
+
+  if (!message) throw new Error(`Message cannot be empty`);
+  if (typeof message !== "string") throw new Error(`Signing EIP712Message not supported`);
+
+  const r = await casper.sign(getPath(account.freshAddressPath), getBufferFromString(message));
+  isError(r);
+
+  return {
+    rsv: {
+      r: r.signature_compact.slice(0, 32).toString("hex"),
+      s: r.signature_compact.slice(32, 64).toString("hex"),
+      v: parseInt(r.signature_compact.slice(64, 65).toString("hex"), 16),
+    },
+    signature: `0x${r.signature_compact.toString("hex")}`,
+  };
+};
+
+export default { signMessage };

package/src/families/casper/msc-utils.ts

@@ -0,0 +1,53 @@
+import BigNumber from "bignumber.js";
+
+const validHexRegExp = new RegExp(/[0-9A-Fa-f]{6}/g);
+const validBase64RegExp = new RegExp(
+  /^(?:[A-Za-z\d+/]{4})*(?:[A-Za-z\d+/]{3}=|[A-Za-z\d+/]{2}==)?$/,
+);
+
+export const isNoErrorReturnCode = (code: number): boolean => code === 0x9000;
+
+export const getPath = (path: string): string =>
+  path && path.substring(0, 2) !== "m/" ? `m/${path}` : path;
+
+export const isValidHex = (msg: string): boolean => validHexRegExp.test(msg);
+export const isValidBase64 = (msg: string): boolean => validBase64RegExp.test(msg);
+
+export const isError = (r: { returnCode: number; errorMessage: string }): void => {
+  if (!isNoErrorReturnCode(r.returnCode)) throw new Error(`${r.returnCode} - ${r.errorMessage}`);
+};
+
+export const methodToString = (method: number): string => {
+  switch (method) {
+    case 0:
+      return "Token transfer";
+    default:
+      return "Unknown";
+  }
+};
+
+export const getBufferFromString = (message: string): Buffer => {
+  if (isValidHex(message)) {
+    return Buffer.from(message, "hex");
+  }
+
+  if (isValidBase64(message)) {
+    return Buffer.from(message, "base64");
+  }
+
+  return Buffer.from(message);
+};
+
+function randomIntFromInterval(min, max): string {
+  const minBig = new BigNumber(min);
+  const maxBig = new BigNumber(max);
+
+  const random = BigNumber.random().multipliedBy(maxBig.minus(minBig).plus(1)).plus(minBig);
+  const randomInt = random.integerValue(BigNumber.ROUND_FLOOR);
+
+  return randomInt.toString();
+}
+
+export function getRandomTransferID(): string {
+  return randomIntFromInterval(0, Number.MAX_SAFE_INTEGER);
+}

package/src/families/casper/specs.ts

@@ -0,0 +1,126 @@
+import invariant from "invariant";
+import { DeviceModelId } from "@ledgerhq/devices";
+import BigNumber from "bignumber.js";
+import expect from "expect";
+
+import type { Transaction } from "../../families/casper/types";
+import { getCryptoCurrencyById } from "../../currencies";
+import { genericTestDestination, pickSiblings, botTest } from "../../bot/specs";
+import type { AppSpec } from "../../bot/types";
+import { acceptTransaction } from "./speculos-deviceActions";
+import { CASPER_MINIMUM_VALID_AMOUNT_MOTES, MayBlockAccountError } from "./consts";
+import { getRandomTransferID } from "./msc-utils";
+
+const MIN_SAFE = new BigNumber(CASPER_MINIMUM_VALID_AMOUNT_MOTES);
+const maxAccount = 6;
+
+const casperSpecs: AppSpec<Transaction> = {
+  name: "Casper",
+  currency: getCryptoCurrencyById("casper"),
+  appQuery: {
+    model: DeviceModelId.nanoSP,
+    appName: "Casper",
+  },
+  genericDeviceAction: acceptTransaction,
+  testTimeout: 6 * 60 * 1000,
+  minViableAmount: MIN_SAFE,
+  transactionCheck: ({ maxSpendable }) => {
+    invariant(maxSpendable.gt(MIN_SAFE), "balance is too low");
+  },
+  mutations: [
+    {
+      name: "Send ~50%",
+      maxRun: 1,
+      testDestination: genericTestDestination,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(MIN_SAFE), "balance is too low");
+        const sibling = pickSiblings(siblings, maxAccount);
+        const recipient = sibling.freshAddress;
+        const amount = maxSpendable.div(2).integerValue();
+
+        const transaction = bridge.createTransaction(account);
+        const updates: Array<Partial<Transaction>> = [
+          {
+            recipient,
+          },
+          { amount },
+        ];
+
+        if (Math.random() < 0.5) {
+          updates.push({
+            transferId: getRandomTransferID(),
+          });
+        }
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+
+      test: ({ accountBeforeTransaction, operation, account, transaction }) => {
+        botTest("account spendable balance decreased with operation", () =>
+          expect(account.spendableBalance).toEqual(
+            accountBeforeTransaction.spendableBalance.minus(operation.value),
+          ),
+        );
+
+        if (transaction.transferId) {
+          botTest("operation transferId", () =>
+            expect(operation.extra).toMatchObject({
+              transferId: transaction.transferId,
+            }),
+          );
+        }
+      },
+    },
+    {
+      name: "Transfer Max",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge }) => {
+        const updates: Array<Partial<Transaction>> = [
+          {
+            recipient: pickSiblings(siblings, maxAccount).freshAddress,
+          },
+          {
+            useAllAmount: true,
+          },
+        ];
+
+        if (Math.random() < 0.5) {
+          updates.push({
+            transferId: getRandomTransferID(),
+          });
+        }
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates,
+        };
+      },
+      expectStatusWarnings: _ => {
+        return {
+          amount: MayBlockAccountError,
+        };
+      },
+      testDestination: genericTestDestination,
+      test: ({ account, transaction, operation }) => {
+        botTest("account spendable balance is zero", () =>
+          expect(account.spendableBalance.toString()).toBe("0"),
+        );
+
+        if (transaction.transferId) {
+          botTest("operation transferId", () =>
+            expect(operation.extra).toMatchObject({
+              transferId: transaction.transferId,
+            }),
+          );
+        }
+      },
+    },
+  ],
+};
+
+export default {
+  casperSpecs,
+};