@ledgerhq/coin-stacks 0.1.1-next.0

package/src/test/bot-deviceActions.ts

@@ -0,0 +1,47 @@
+import type { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+import type { Transaction } from "../types";
+import { deviceActionFlow, SpeculosButton } from "@ledgerhq/coin-framework/bot/specs";
+
+export const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Please",
+      button: SpeculosButton.RIGHT,
+      expectedValue: () => "review",
+    },
+    {
+      title: "Origin",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account }) => account.freshAddress,
+    },
+    {
+      title: "Nonce",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => (transaction.nonce ? transaction.nonce.toFixed() : "0"),
+    },
+    {
+      title: "Fee (uSTX)",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => (transaction.fee ? transaction.fee.toFixed() : "0"),
+    },
+    {
+      title: "Amount uSTX",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ status }) => status.amount.toFixed(),
+    },
+    {
+      title: "To",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => transaction.recipient,
+    },
+    {
+      title: "Memo",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => transaction.memo || "",
+    },
+    {
+      title: "APPROVE",
+      button: SpeculosButton.BOTH,
+    },
+  ],
+});

package/src/test/bot-specs.ts

@@ -0,0 +1,82 @@
+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 { botTest, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+import type { AppSpec } from "@ledgerhq/coin-framework/bot/types";
+import { acceptTransaction } from "./bot-deviceActions";
+
+const MIN_SAFE = new BigNumber(10000);
+const stacksSpecs: AppSpec<Transaction> = {
+  name: "Stacks",
+  currency: getCryptoCurrencyById("stacks"),
+  appQuery: {
+    model: DeviceModelId.nanoSP,
+    appName: "Stacks",
+  },
+  genericDeviceAction: acceptTransaction,
+  // FIXME Stacks operations can take much longer to be confirmed
+  // Need an evolution of the bot to tolerate unconfirmed ops and just warn maybe instead of error
+  testTimeout: 25 * 60 * 1000,
+  transactionCheck: ({ maxSpendable }) => {
+    invariant(maxSpendable.gt(MIN_SAFE), "balance is too low");
+  },
+  mutations: [
+    {
+      name: "Send 50%~",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge }) => {
+        const sibling = pickSiblings(siblings, 2);
+        const recipient = sibling.freshAddress;
+
+        let amount = account.spendableBalance.div(1.9 + 0.2 * Math.random()).integerValue();
+
+        if (!sibling.used && amount.lt(MIN_SAFE)) {
+          invariant(account.spendableBalance.gt(MIN_SAFE), "send is too low to activate account");
+          amount = MIN_SAFE;
+        }
+
+        const transaction = bridge.createTransaction(account);
+        const updates = [{ recipient }, { amount }];
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({ account, accountBeforeTransaction, operation }) => {
+        botTest("account balance decreased with operation value", () =>
+          expect(account.balance.toFixed()).toBe(
+            accountBeforeTransaction.balance.minus(operation.value).toFixed(),
+          ),
+        );
+      },
+    },
+    {
+      name: "Transfer Max",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge }) => {
+        const sibling = pickSiblings(siblings, 2);
+        const recipient = sibling.freshAddress;
+
+        const transaction = bridge.createTransaction(account);
+        const updates = [{ recipient }, { useAllAmount: true }];
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({ account }) => {
+        botTest("account balance is 0", () => expect(account.balance.toFixed()).toBe("0"));
+      },
+    },
+  ],
+};
+
+export default {
+  stacksSpecs,
+};

package/src/test/bridgeDatasetTest.ts

@@ -0,0 +1,134 @@
+import { CurrenciesData } from "@ledgerhq/types-live";
+import { AnchorMode } from "@stacks/transactions";
+import type { DatasetTest } from "@ledgerhq/types-live";
+import type { Transaction } from "../types";
+import { fromTransactionRaw } from "../bridge/transaction";
+import { BigNumber } from "bignumber.js";
+import {
+  AmountRequired,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+} from "@ledgerhq/errors";
+
+const SEED_IDENTIFIER = "SP3KS7VMY2ZNE6SB88PHR4SKRK2EEPHS8N8MCCBR9";
+const SEED_IDENTIFIER_PUBKEY = "022a460decc9dba8c452927fecb33d7ae25a8d79dc5442b84feaf8f3aa0e2b575d";
+const ACCOUNT_1 = "SP2DV2RVZP1A69Q6VAG5PHEQ6ZHQHZPCV84TMYNGN";
+
+const stacks: CurrenciesData<Transaction> = {
+  FIXME_ignoreAccountFields: [],
+  IgnorePrepareTransactionFields: ["fee"],
+  scanAccounts: [
+    {
+      name: "stacks seed 1",
+      apdus: `
+        => 09010016142c0000807d160080000000800000000000000000
+        <= 022a460decc9dba8c452927fecb33d7ae25a8d79dc5442b84feaf8f3aa0e2b575d5350334b5337564d59325a4e45365342383850485234534b524b324545504853384e384d43434252399000
+        => 09010016142c0000807d160080000000800000000001000000
+        <= 03a2d4bbb54c2f44c3a205b15ca7d2049a2bb66e50e100304f932b3b99ed3a99cb5350324136463652374632395a3338533259434a4d37484a44564532345332564757543542545a50419000
+        => 09010016142c0000807d160080010000800000000000000000
+        <= 034bbb21911e9d4502ac170162c5c05cbba65cbb79e5b46adf95152af2d0e78a4553503244563252565a503141363951365641473550484551365a4851485a5043563834544d594e474e9000
+        => 09010016142c0000807d160080020000800000000000000000
+        <= 020637c4d824458f6a11551f51df9e5be9e96c2e3a2e5bdb25d2916cc1dd5ba2d753504e5a4e434333433244525450574a4a384e534d484d575744304643415459413843565a3834459000
+        => 09010016142c0000807d160080030000800000000000000000
+        <= 02e57bb8c28c4c768cf65f8e28935482e40afbb33168d26810199f39a719cc05f0535031564d30584546574251345a543838384654333447333047474635324459395951575a434151309000
+        => 09010016142c0000807d160080040000800000000000000000
+        <= 0264b6d44f720fa50055dc294276bf15ce22e4f3dec48510b317ab8c07419c1b7753503248574a58594e4747594354535952545036323636424a483858565a4759504d455248514538529000
+        `,
+    },
+  ],
+  accounts: [
+    {
+      raw: {
+        id: `js:2:stacks:${SEED_IDENTIFIER_PUBKEY}:`,
+        seedIdentifier: SEED_IDENTIFIER,
+        name: "Stacks 1",
+        derivationMode: "",
+        index: 0,
+        freshAddress: SEED_IDENTIFIER,
+        freshAddressPath: "",
+        blockHeight: 0,
+        operations: [],
+        xpub: SEED_IDENTIFIER_PUBKEY,
+        pendingOperations: [],
+        currencyId: "stacks",
+        lastSyncDate: "",
+        balance: "1000",
+      },
+      transactions: [
+        {
+          name: "Source and destination are the equal",
+          transaction: fromTransactionRaw({
+            family: "stacks",
+            nonce: "1",
+            network: "mainnet",
+            anchorMode: AnchorMode.Any,
+            recipient: SEED_IDENTIFIER,
+            amount: "1",
+          }),
+          expectedStatus: {
+            errors: {
+              recipient: new InvalidAddressBecauseDestinationIsAlsoSource(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Not enough balance",
+          transaction: fromTransactionRaw({
+            family: "stacks",
+            nonce: "1",
+            network: "mainnet",
+            anchorMode: AnchorMode.Any,
+            recipient: ACCOUNT_1,
+            amount: "10000000000",
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Amount Required",
+          transaction: fromTransactionRaw({
+            family: "stacks",
+            nonce: "1",
+            network: "mainnet",
+            anchorMode: AnchorMode.Any,
+            recipient: ACCOUNT_1,
+            amount: "0",
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new AmountRequired(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "New account and sufficient amount",
+          transaction: fromTransactionRaw({
+            family: "stacks",
+            nonce: "1",
+            network: "mainnet",
+            anchorMode: AnchorMode.Any,
+            recipient: ACCOUNT_1,
+            amount: "1",
+          }),
+          expectedStatus: {
+            amount: new BigNumber("1"),
+            errors: {},
+            warnings: {},
+          },
+        },
+      ],
+    },
+  ],
+};
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    stacks,
+  },
+};

package/src/test/cli.ts

@@ -0,0 +1,38 @@
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+
+import type { Account, AccountLike, AccountLikeArray } from "@ledgerhq/types-live";
+
+import type { Transaction } from "../types";
+
+function inferAccounts(account: Account): AccountLikeArray {
+  invariant(account.currency.family === "stacks", "stacks 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 === "stacks", "stacks family");
+
+    return {
+      ...transaction,
+      family: "stacks",
+    } as Transaction;
+  });
+}
+
+export default function makeCliTools() {
+  return {
+    options: [],
+    inferAccounts,
+    inferTransactions,
+  };
+}

package/src/test/index.ts

@@ -0,0 +1,5 @@
+import makeCliTools from "./cli";
+export { makeCliTools };
+export * from "./bot-deviceActions";
+export * from "./bot-specs";
+export * from "./bridgeDatasetTest";

package/src/types/bridge.ts

@@ -0,0 +1,49 @@
+import { AnchorMode } from "@stacks/transactions";
+import BigNumber from "bignumber.js";
+
+import {
+  Operation,
+  TransactionCommon,
+  TransactionCommonRaw,
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+
+import { StacksNetwork } from "../network/api.types";
+
+type FamilyType = "stacks";
+
+export type NetworkInfo = {
+  family: FamilyType;
+};
+export type NetworkInfoRaw = {
+  family: FamilyType;
+};
+
+export type Transaction = TransactionCommon & {
+  family: FamilyType;
+  fee?: BigNumber;
+  nonce?: BigNumber;
+  memo?: string;
+  network: keyof typeof StacksNetwork;
+  anchorMode: AnchorMode;
+};
+
+export type TransactionRaw = TransactionCommonRaw & {
+  family: FamilyType;
+  fee?: string;
+  nonce?: string;
+  memo?: string;
+  network: string;
+  anchorMode: number;
+};
+
+export type TransactionStatus = TransactionStatusCommon;
+
+export type TransactionStatusRaw = TransactionStatusCommonRaw;
+
+export type StacksOperation = Operation<StacksOperationExtra>;
+
+export type StacksOperationExtra = {
+  memo?: string | undefined;
+};

package/src/types/index.ts

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

package/src/types/signer.ts

@@ -0,0 +1,16 @@
+import type { AddressVersion } from "@stacks/transactions";
+import { ResponseAddress } from "@zondax/ledger-stacks";
+
+export type StacksAddress = {
+  publicKey: string;
+  address: string;
+  chainCode?: string;
+};
+
+export type StacksSignature = string; // `0x${string}`
+
+export interface StacksSigner {
+  showAddressAndPubKey(path: string, version: AddressVersion): Promise<ResponseAddress>;
+  getAddressAndPubKey(path: string, version: AddressVersion): Promise<ResponseAddress>;
+  sign(path: string, message: Buffer): Promise<any>;
+}

package/src/utils.ts

@@ -0,0 +1,24 @@
+import { ResponseAddress } from "@zondax/ledger-stacks";
+
+// NOTE: inlined now, this shared utils code will be moved to coin-framework in a future PR
+const validHexRegExp = new RegExp(/^(0x)?[a-fA-F0-9]+$/);
+const validBase64RegExp = new RegExp(
+  /^(?:[A-Za-z\d+/]{4})*(?:[A-Za-z\d+/]{3}=|[A-Za-z\d+/]{2}==)?$/,
+);
+export const isValidHex = (msg: string) => validHexRegExp.test(msg) && msg.length % 2 === 0;
+export const isValidBase64 = (msg: string) => validBase64RegExp.test(msg);
+
+export const isNoErrorReturnCode = (code: number) => code === 0x9000;
+
+export const getPath = (path: string) => (path && path.substr(0, 2) !== "m/" ? `m/${path}` : path);
+
+export const throwIfError = (r: ResponseAddress) => {
+  if (!isNoErrorReturnCode(r.returnCode)) throw new Error(`${r.returnCode} - ${r.errorMessage}`);
+};
+
+export const getBufferFromString = (message: string): Buffer =>
+  isValidHex(message)
+    ? Buffer.from(message, "hex")
+    : isValidBase64(message)
+      ? Buffer.from(message, "base64")
+      : Buffer.from(message);

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../../tsconfig.base",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "noImplicitAny": false,
+    "module": "commonjs",
+    "downlevelIteration": true,
+    "lib": ["es2020", "dom"],
+    "outDir": "lib",
+    "typeRoots": ["./types", "./node_modules/@types"]
+  },
+  "include": ["src/**/*"]
+}