@ledgerhq/live-common 31.2.0 → 31.3.0-next.0

package/src/families/stacks/bridge/utils/misc.ts

@@ -0,0 +1,212 @@
+import { BigNumber } from "bignumber.js";
+import BN from "bn.js";
+import flatMap from "lodash/flatMap";
+import { Account, Address, Operation } from "@ledgerhq/types-live";
+import {
+  makeUnsignedSTXTokenTransfer,
+  UnsignedTokenTransferOptions,
+  createMessageSignature,
+} from "@stacks/transactions";
+
+import { GetAccountShape, AccountShapeInfo } from "../../../../bridge/jsHelpers";
+import { decodeAccountId, encodeAccountId } from "../../../../account";
+import {
+  fetchBalances,
+  fetchBlockHeight,
+  fetchFullMempoolTxs,
+  fetchFullTxs,
+  fetchNonce,
+} from "../../bridge/utils/api";
+import { StacksNetwork, TransactionResponse } from "./api.types";
+import { getCryptoCurrencyById } from "../../../../currencies";
+import { encodeOperationId } from "../../../../operation";
+
+export const getTxToBroadcast = async (
+  operation: Operation,
+  signature: string,
+  signatureRaw: Record<string, any>,
+): Promise<Buffer> => {
+  const {
+    value,
+    recipients,
+    fee,
+    extra: { memo },
+  } = operation;
+
+  const { anchorMode, network, xpub } = signatureRaw;
+
+  const options: UnsignedTokenTransferOptions = {
+    amount: new BN(BigNumber(value).minus(fee).toFixed()),
+    recipient: recipients[0],
+    anchorMode,
+    memo,
+    network: StacksNetwork[network],
+    publicKey: xpub,
+    fee: new BN(BigNumber(fee).toFixed()),
+    nonce: new BN(operation.transactionSequenceNumber ?? 0),
+  };
+
+  const tx = await makeUnsignedSTXTokenTransfer(options);
+
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore need to ignore the TS error here
+  tx.auth.spendingCondition.signature = createMessageSignature(signature);
+
+  return tx.serialize();
+};
+
+export const getUnit = () => getCryptoCurrencyById("stacks").units[0];
+
+export const getAddress = (a: Account): Address =>
+  a.freshAddresses.length > 0
+    ? a.freshAddresses[0]
+    : { address: a.freshAddress, derivationPath: a.freshAddressPath };
+
+export const mapTxToOps =
+  (accountID, { address }: AccountShapeInfo) =>
+  (tx: TransactionResponse): Operation[] => {
+    const { sender, recipient, amount } = tx.stx_transfers[0];
+    const { tx_id, fee_rate, nonce, block_height, burn_block_time, token_transfer } = tx.tx;
+    const { memo: memoHex } = token_transfer;
+
+    const ops: Operation[] = [];
+
+    const date = new Date(burn_block_time * 1000);
+    const value = new BigNumber(amount || "0");
+    const feeToUse = new BigNumber(fee_rate || "0");
+
+    const isSending = address === sender;
+    const isReceiving = address === recipient;
+
+    const memo = Buffer.from(memoHex.substring(2), "hex").toString().replaceAll("\x00", "");
+
+    if (isSending) {
+      ops.push({
+        id: encodeOperationId(accountID, tx_id, "OUT"),
+        hash: tx_id,
+        type: "OUT",
+        value: value.plus(feeToUse),
+        fee: feeToUse,
+        blockHeight: block_height,
+        blockHash: null,
+        accountId: accountID,
+        senders: [sender],
+        recipients: [recipient],
+        transactionSequenceNumber: nonce,
+        date,
+        extra: {
+          memo,
+        },
+      });
+    }
+
+    if (isReceiving) {
+      ops.push({
+        id: encodeOperationId(accountID, tx_id, "IN"),
+        hash: tx_id,
+        type: "IN",
+        value,
+        fee: feeToUse,
+        blockHeight: block_height,
+        blockHash: null,
+        accountId: accountID,
+        senders: [sender],
+        recipients: [recipient],
+        transactionSequenceNumber: nonce,
+        date,
+        extra: {
+          memo,
+        },
+      });
+    }
+
+    return ops;
+  };
+
+export const getAccountShape: GetAccountShape = async info => {
+  const { initialAccount, address, currency, rest = {}, derivationMode } = info;
+
+  const publicKey = reconciliatePublicKey(rest.publicKey, initialAccount);
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: publicKey,
+    derivationMode,
+  });
+
+  const blockHeight = await fetchBlockHeight();
+  const balanceResp = await fetchBalances(address);
+  const rawTxs = await fetchFullTxs(address);
+  const mempoolTxs = await fetchFullMempoolTxs(address);
+
+  const balance = new BigNumber(balanceResp.balance);
+  let spendableBalance = new BigNumber(balanceResp.balance);
+  for (const tx of mempoolTxs) {
+    spendableBalance = spendableBalance
+      .minus(new BigNumber(tx.fee_rate))
+      .minus(new BigNumber(tx.token_transfer.amount));
+  }
+
+  const result: Partial<Account> = {
+    id: accountId,
+    xpub: publicKey,
+    freshAddress: address,
+    balance,
+    spendableBalance,
+    operations: flatMap(rawTxs, mapTxToOps(accountId, info)),
+    blockHeight: blockHeight.chain_tip.block_height,
+  };
+
+  return result;
+};
+
+function reconciliatePublicKey(
+  publicKey: string | undefined,
+  initialAccount: Account | undefined,
+): string {
+  if (publicKey) return publicKey;
+  if (initialAccount) {
+    const { xpubOrAddress } = decodeAccountId(initialAccount.id);
+    return xpubOrAddress;
+  }
+  throw new Error("publicKey wasn't properly restored");
+}
+
+export const findNextNonce = async (
+  senderAddress: string,
+  pendingOps: Operation[],
+): Promise<BigNumber> => {
+  let nextNonce = BigNumber(0);
+
+  for (const op of pendingOps) {
+    const nonce = op.transactionSequenceNumber
+      ? new BigNumber(op.transactionSequenceNumber)
+      : new BigNumber(0);
+
+    if (nonce.gt(nextNonce)) {
+      nextNonce = nonce;
+    }
+  }
+
+  const allMempoolTxns = await fetchFullMempoolTxs(senderAddress);
+  for (const tx of allMempoolTxns) {
+    const nonce = BigNumber(tx.nonce);
+    if (nonce.gt(nextNonce)) {
+      nextNonce = nonce;
+    }
+  }
+
+  if (!nextNonce.eq(0)) {
+    nextNonce = nextNonce.plus(1);
+  }
+
+  const nonceResp = await fetchNonce(senderAddress);
+  const possibleNextNonce = new BigNumber(nonceResp.possible_next_nonce);
+  if (possibleNextNonce.gt(nextNonce)) {
+    nextNonce = possibleNextNonce;
+  }
+
+  return nextNonce;
+};

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

@@ -0,0 +1,133 @@
+import { CurrenciesData } from "@ledgerhq/types-live";
+import { AnchorMode } from "@stacks/transactions";
+import type { DatasetTest } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import {
+  AmountRequired,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+} from "@ledgerhq/errors";
+
+import "../../__tests__/test-helpers/setup";
+import type { Transaction } from "./types";
+import { fromTransactionRaw } from "./transaction";
+import { testBridge } from "../../__tests__/test-helpers/bridge";
+
+const SEED_IDENTIFIER = "SP3KS7VMY2ZNE6SB88PHR4SKRK2EEPHS8N8MCCBR9";
+const ACCOUNT_1 = "SP2DV2RVZP1A69Q6VAG5PHEQ6ZHQHZPCV84TMYNGN";
+
+const stacks: CurrenciesData<Transaction> = {
+  FIXME_ignoreAccountFields: [],
+  scanAccounts: [
+    {
+      name: "stacks seed 1",
+      apdus: `
+      => 09010016142c0000807d160080000000800000000000000000
+      <= 022a460decc9dba8c452927fecb33d7ae25a8d79dc5442b84feaf8f3aa0e2b575d5350334b5337564d59325a4e45365342383850485234534b524b324545504853384e384d43434252399000
+      => 09010016142c0000807d160080000000800000000001000000
+      <= 03a2d4bbb54c2f44c3a205b15ca7d2049a2bb66e50e100304f932b3b99ed3a99cb5350324136463652374632395a3338533259434a4d37484a44564532345332564757543542545a50419000
+      => 09010016142c0000807d160080010000800000000000000000
+      <= 034bbb21911e9d4502ac170162c5c05cbba65cbb79e5b46adf95152af2d0e78a4553503244563252565a503141363951365641473550484551365a4851485a5043563834544d594e474e9000
+      `,
+    },
+  ],
+  accounts: [
+    {
+      raw: {
+        id: `js:2:stacks:${SEED_IDENTIFIER}:`,
+        seedIdentifier: SEED_IDENTIFIER,
+        name: "Stacks 1",
+        derivationMode: "",
+        index: 0,
+        freshAddress: SEED_IDENTIFIER,
+        freshAddressPath: "44'/5757'/0'/0/0",
+        freshAddresses: [],
+        blockHeight: 0,
+        operations: [],
+        pendingOperations: [],
+        currencyId: "stacks",
+        unitMagnitude: 6,
+        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: {},
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    stacks,
+  },
+};
+
+testBridge(dataset);

package/src/families/stacks/cli-transaction.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 "../../generated/types";
+
+const options = [];
+
+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 {
+  options,
+  inferAccounts,
+  inferTransactions,
+};

package/src/families/stacks/deviceTransactionConfig.ts

@@ -0,0 +1,55 @@
+import { BigNumber } from "bignumber.js";
+import type { Account, AccountLike } from "@ledgerhq/types-live";
+import type { DeviceTransactionField } from "../../transaction";
+import type { Transaction, TransactionStatus } from "./types";
+
+export type ExtraDeviceTransactionField =
+  | {
+      type: "stacks.memo";
+      label: string;
+      value: string;
+    }
+  | {
+      type: "stacks.extendedAmount";
+      label: string;
+      value: BigNumber;
+    };
+
+function getDeviceTransactionConfig(input: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "stacks.extendedAmount",
+    label: "Amount",
+    value: input.transaction.amount,
+  });
+  fields.push({
+    type: "stacks.extendedAmount",
+    label: "Fees",
+    value: input.transaction.fee ? input.transaction.fee : new BigNumber(0),
+  });
+  fields.push({
+    type: "address",
+    label: "Recipient",
+    address: input.transaction.recipient,
+  });
+  fields.push({
+    type: "text",
+    label: "Nonce",
+    value: input.transaction.nonce ? input.transaction.nonce.toFixed() : "0",
+  });
+  fields.push({
+    type: "stacks.memo",
+    label: "Memo",
+    value: input.transaction.memo || "",
+  });
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/families/stacks/errors.ts

@@ -0,0 +1,3 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const StacksMemoTooLong = createCustomErrorClass("StacksMemoTooLong");

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

@@ -0,0 +1,23 @@
+import BlockstackApp from "@zondax/ledger-stacks";
+import { AddressVersion } from "@stacks/transactions/dist";
+
+import type { Resolver } from "../../hw/getAddress/types";
+import { getPath, throwIfError } from "./utils";
+
+const resolver: Resolver = async (transport, { path, verify }) => {
+  const blockstack = new BlockstackApp(transport);
+
+  const r = verify
+    ? await blockstack.showAddressAndPubKey(getPath(path), AddressVersion.MainnetSingleSig)
+    : await blockstack.getAddressAndPubKey(getPath(path), AddressVersion.MainnetSingleSig);
+
+  throwIfError(r);
+
+  return {
+    path,
+    address: r.address,
+    publicKey: r.publicKey.toString("hex"),
+  };
+};
+
+export default resolver;

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

@@ -0,0 +1,25 @@
+import BlockstackApp from "@zondax/ledger-stacks";
+
+import type { SignMessage, Result } from "../../hw/signMessage/types";
+import { getBufferFromString, getPath, throwIfError } from "./utils";
+
+const signMessage: SignMessage = async (transport, account, { message }): Promise<Result> => {
+  const blockstack = new BlockstackApp(transport);
+
+  if (!message) throw new Error(`Message cannot be empty`);
+  if (typeof message !== "string") throw new Error(`Message must be string`);
+
+  const r = await blockstack.sign(getPath(account.freshAddressPath), getBufferFromString(message));
+  throwIfError(r);
+
+  return {
+    rsv: {
+      r: r.signatureCompact.slice(0, 32).toString("hex"),
+      s: r.signatureCompact.slice(32, 64).toString("hex"),
+      v: parseInt(r.signatureCompact.slice(64, 65).toString("hex"), 16),
+    },
+    signature: `0x${r.signatureVRS.toString("hex")}`,
+  };
+};
+
+export default { signMessage };

package/src/families/stacks/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 "../../currencies";
+import { pickSiblings, botTest } from "../../bot/specs";
+import type { AppSpec } from "../../bot/types";
+import { acceptTransaction } from "./speculos-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/families/stacks/speculos-deviceActions.ts

@@ -0,0 +1,47 @@
+import type { DeviceAction } from "../../bot/types";
+import type { Transaction } from "./types";
+import { deviceActionFlow, SpeculosButton } from "../../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/families/stacks/transaction.ts

@@ -0,0 +1,75 @@
+import BigNumber from "bignumber.js";
+import { StacksNetwork } from "./bridge/utils/api.types";
+import type { Account } from "@ledgerhq/types-live";
+
+import type { Transaction, TransactionRaw } from "./types";
+import {
+  formatTransactionStatusCommon as formatTransactionStatus,
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/transaction/common";
+import { getAccountUnit } from "../../account";
+import { formatCurrencyUnit } from "../../currencies";
+
+export const formatTransaction = (
+  { recipient, useAllAmount, amount }: Transaction,
+  account: Account,
+): string => `
+SEND ${
+  useAllAmount
+    ? "MAX"
+    : amount.isZero()
+    ? ""
+    : " " +
+      formatCurrencyUnit(getAccountUnit(account), amount, {
+        showCode: true,
+        disableRounding: true,
+      })
+}
+TO ${recipient}`;
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+
+  // validate if network is valid
+  if (!StacksNetwork[tr.network]) {
+    throw new Error(`network ${tr.network} not valid`);
+  }
+
+  return {
+    ...common,
+    family: tr.family,
+    nonce: tr.nonce !== undefined ? new BigNumber(tr.nonce) : undefined,
+    fee: tr.fee !== undefined ? new BigNumber(tr.fee) : undefined,
+    amount: new BigNumber(tr.amount),
+    network: tr.network as keyof typeof StacksNetwork,
+    anchorMode: tr.anchorMode,
+    memo: tr.memo,
+  };
+};
+
+const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+
+  return {
+    ...common,
+    family: t.family,
+    fee: t.fee !== undefined ? t.fee.toFixed() : undefined,
+    nonce: t.nonce !== undefined ? t.nonce.toFixed() : undefined,
+    amount: t.amount.toFixed(),
+    network: t.network,
+    anchorMode: t.anchorMode,
+    memo: t.memo,
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  formatTransactionStatus,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+};