@ledgerhq/coin-casper 1.4.0-next.0

package/src/test/bot-specs.ts

@@ -0,0 +1,127 @@
+import invariant from "invariant";
+import { DeviceModelId } from "@ledgerhq/devices";
+import BigNumber from "bignumber.js";
+import expect from "expect";
+import type { Transaction } from "../types";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { genericTestDestination, pickSiblings, botTest } from "@ledgerhq/coin-framework/bot/specs";
+import type { AppSpec } from "@ledgerhq/coin-framework/bot/types";
+import { acceptTransaction } from "./speculos-deviceActions";
+import { CASPER_MINIMUM_VALID_AMOUNT_MOTES, MayBlockAccountError } from "../consts";
+import { getRandomTransferID } from "../common-logic";
+
+const MIN_SAFE = new BigNumber(CASPER_MINIMUM_VALID_AMOUNT_MOTES * 2);
+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%",
+      feature: "send",
+      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",
+      feature: "sendMax",
+      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,
+};

package/src/test/bridgeDatasetTest.ts

@@ -0,0 +1,178 @@
+import type { CurrenciesData, DatasetTest } from "@ledgerhq/types-live";
+import type { Transaction } from "../types";
+import { fromTransactionRaw } from "../bridge/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 RECIPIENT_ADDRESS_SECP256k1 =
+  "0203A17118eC0e64c4e4FdbDbEe0eA14D118C9aAf08C6c81bbB776Cae607cEB84EcB";
+const RECIPIENT_ADDRESS_EDSA25519 =
+  "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",
+        blockHeight: 0,
+        operations: [],
+        pendingOperations: [],
+        currencyId: "casper",
+        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: RECIPIENT_ADDRESS_SECP256k1,
+            fees: getEstimatedFees().toString(),
+            amount: (300 * 1e9).toString(),
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "amount required",
+          transaction: fromTransactionRaw({
+            family: "casper",
+            recipient: RECIPIENT_ADDRESS_SECP256k1,
+            amount: "0",
+            fees: getEstimatedFees().toString(),
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new AmountRequired(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "minimum amount required",
+          transaction: fromTransactionRaw({
+            family: "casper",
+            fees: getEstimatedFees().toString(),
+            recipient: RECIPIENT_ADDRESS_SECP256k1,
+            amount: "1",
+          }),
+
+          expectedStatus: {
+            errors: {
+              amount: new InvalidMinimumAmount(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "sufficient amount - recipient address secp256k1",
+          transaction: fromTransactionRaw({
+            family: "casper",
+            recipient: RECIPIENT_ADDRESS_SECP256k1,
+            amount: "3",
+            fees: getEstimatedFees().toString(),
+          }),
+          expectedStatus: {
+            amount: new BigNumber("3"),
+            errors: {},
+            warnings: {},
+          },
+        },
+        {
+          name: "sufficient amount - recipient address ed25519",
+          transaction: fromTransactionRaw({
+            family: "casper",
+            recipient: RECIPIENT_ADDRESS_EDSA25519,
+            amount: "3",
+            fees: getEstimatedFees().toString(),
+          }),
+          expectedStatus: {
+            amount: new BigNumber("3"),
+            errors: {},
+            warnings: {},
+          },
+        },
+        {
+          name: "invalid transferID",
+          transaction: fromTransactionRaw({
+            family: "casper",
+            recipient: RECIPIENT_ADDRESS_SECP256k1,
+            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: RECIPIENT_ADDRESS_SECP256k1,
+            fees: getEstimatedFees().toString(),
+            amount: (999 * 1e9).toString(),
+          }),
+          expectedStatus: {
+            errors: {},
+            warnings: {
+              amount: new MayBlockAccount(),
+            },
+          },
+        },
+      ],
+    },
+  ],
+};
+
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    casper,
+  },
+};

package/src/test/cli.ts

@@ -0,0 +1,36 @@
+import type { Account, AccountLike, AccountLikeArray } from "@ledgerhq/types-live";
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+import type { Transaction } from "../types";
+
+function inferAccounts(account: Account): AccountLikeArray {
+  invariant(account.currency.family === "casper", "casper family");
+
+  const accounts: Account[] = [account];
+  return accounts;
+}
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+    mainAccount: Account;
+  }>,
+): Transaction[] {
+  return flatMap(transactions, ({ transaction }) => {
+    invariant(transaction.family === "casper", "casper family");
+
+    return {
+      ...transaction,
+      family: "casper",
+    } as Transaction;
+  });
+}
+
+export default function makeCliTools() {
+  return {
+    options: [],
+    inferAccounts,
+    inferTransactions,
+  };
+}

package/src/test/index.ts

@@ -0,0 +1,3 @@
+export * from "./bridgeDatasetTest";
+export * from "./bot-specs";
+export * from "./speculos-deviceActions";

package/src/test/speculos-deviceActions.ts

@@ -0,0 +1,54 @@
+import { deviceActionFlow, SpeculosButton } from "@ledgerhq/coin-framework/bot/specs";
+import { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+import { casperGetCLPublicKey } from "../bridge/bridgeHelpers/addresses";
+import type { Transaction } from "../types";
+
+export const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Please",
+      button: SpeculosButton.RIGHT,
+      expectedValue: () => "review",
+    },
+    {
+      title: "Txn hash",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "Type",
+      button: SpeculosButton.RIGHT,
+      expectedValue: () => "Token transfer",
+    },
+    {
+      title: "Chain ID",
+      button: SpeculosButton.RIGHT,
+      expectedValue: () => "casper",
+    },
+    {
+      title: "Account",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account }) => casperGetCLPublicKey(account.freshAddress).toHex(true),
+    },
+    {
+      title: "Fee",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) =>
+        `${transaction.fees.toNumber().toLocaleString("en-US").replace(/,/g, " ")} motes`,
+    },
+    {
+      title: "Target",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => casperGetCLPublicKey(transaction.recipient).toHex(true),
+    },
+    {
+      title: "Amount",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ status }) =>
+        `${status.amount.toNumber().toLocaleString("en-US").replace(/,/g, " ")} motes`,
+    },
+    {
+      title: "APPROVE",
+      button: SpeculosButton.BOTH,
+    },
+  ],
+});

package/src/types/common.ts

@@ -0,0 +1,38 @@
+import {
+  Account,
+  Operation,
+  TransactionCommon,
+  TransactionCommonRaw,
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { ExtraDeviceTransactionField } from "../bridge/deviceTransactionConfig";
+
+type FamilyType = "casper";
+
+export type CasperAccount = Account;
+
+export type Transaction = TransactionCommon & {
+  family: FamilyType;
+  fees: BigNumber;
+  transferId?: string | undefined;
+};
+
+export type CasperOperation = Operation<CasperOperationExtra>;
+
+interface CasperOperationExtra {
+  transferId?: string | undefined;
+}
+
+export type TransactionRaw = TransactionCommonRaw & {
+  family: FamilyType;
+  transferId?: string | undefined;
+  fees: string;
+};
+
+export type TransactionStatus = TransactionStatusCommon;
+
+export type TransactionStatusRaw = TransactionStatusCommonRaw;
+
+export type { ExtraDeviceTransactionField };

package/src/types/index.ts

@@ -0,0 +1,2 @@
+export * from "./common";
+export * from "./signer";

package/src/types/signer.ts

@@ -0,0 +1,20 @@
+export type CasperSignature = {
+  errorMessage: string;
+  returnCode: number;
+  signatureRS: Buffer;
+  signatureRSV: Buffer;
+  signature_compact: Uint8Array;
+};
+
+export type CasperGetAddrResponse = {
+  errorMessage: string;
+  returnCode: number;
+  publicKey: Buffer;
+  Address: any;
+};
+
+export interface CasperSigner {
+  showAddressAndPubKey(path: string): Promise<CasperGetAddrResponse>;
+  getAddressAndPubKey(path: string): Promise<CasperGetAddrResponse>;
+  sign(path: string, message: Buffer): Promise<CasperSignature>;
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../../tsconfig.base",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "downlevelIteration": true,
+    "lib": ["es2020", "dom"],
+    "rootDir": "./src",
+    "outDir": "lib",
+    "exactOptionalPropertyTypes": true,
+    "module": "esnext",
+    "moduleResolution": "bundler"
+  },
+  "include": ["src/**/*", "deviceTransactionConfig.ts", "transaction.ts"]
+}