@ledgerhq/coin-bitcoin 0.4.0-next.0

package/src/bech32m.ts

@@ -0,0 +1,187 @@
+// Ported from https://github.com/bitcoinjs/bech32/tree/605655d6b37a782345549cd1388db688a96ad56f
+// until we can use bech32 2.0.0
+// We can't directly use bech32 2.0.0 because many of our dependencies are still using bech32 ^1.1.3
+// which conflict on mobile (root cause of https://ledgerhq.atlassian.net/browse/LL-7930)
+// FIXME Remove that file and use bech32 2.0.0 when all dependencies also uses it.
+
+const ENCODING_CONST = 0x2bc830a3;
+const ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+const ALPHABET_MAP: { [key: string]: number } = {};
+for (let z = 0; z < ALPHABET.length; z++) {
+  const x = ALPHABET.charAt(z);
+  ALPHABET_MAP[x] = z;
+}
+
+function prefixChk(prefix: string) {
+  let chk = 1;
+  for (let i = 0; i < prefix.length; ++i) {
+    const c = prefix.charCodeAt(i);
+    if (c < 33 || c > 126) return "Invalid prefix (" + prefix + ")";
+    chk = polymodStep(chk) ^ (c >> 5);
+  }
+  chk = polymodStep(chk);
+  for (let i = 0; i < prefix.length; ++i) {
+    const v = prefix.charCodeAt(i);
+    chk = polymodStep(chk) ^ (v & 0x1f);
+  }
+  return chk;
+}
+
+function polymodStep(pre: number): number {
+  const b = pre >> 25;
+  return (
+    ((pre & 0x1ffffff) << 5) ^
+    (-((b >> 0) & 1) & 0x3b6a57b2) ^
+    (-((b >> 1) & 1) & 0x26508e6d) ^
+    (-((b >> 2) & 1) & 0x1ea119fa) ^
+    (-((b >> 3) & 1) & 0x3d4233dd) ^
+    (-((b >> 4) & 1) & 0x2a1462b3)
+  );
+}
+
+function encode(prefix: string, words: ArrayLike<number>, LIMIT?: number): string {
+  LIMIT = LIMIT || 90;
+  if (prefix.length + 7 + words.length > LIMIT) throw new TypeError("Exceeds length limit");
+
+  prefix = prefix.toLowerCase();
+
+  // determine chk mod
+  let chk = prefixChk(prefix);
+  if (typeof chk === "string") throw new Error(chk);
+
+  let result = prefix + "1";
+  for (let i = 0; i < words.length; ++i) {
+    const x = words[i];
+    if (x >> 5 !== 0) throw new Error("Non 5-bit word");
+
+    chk = polymodStep(chk) ^ x;
+    result += ALPHABET.charAt(x);
+  }
+
+  for (let i = 0; i < 6; ++i) {
+    chk = polymodStep(chk);
+  }
+  chk ^= ENCODING_CONST;
+
+  for (let i = 0; i < 6; ++i) {
+    const v = (chk >> ((5 - i) * 5)) & 0x1f;
+    result += ALPHABET.charAt(v);
+  }
+
+  return result;
+}
+
+function __decode(str: string, LIMIT?: number) {
+  LIMIT = LIMIT || 90;
+  if (str.length < 8) return str + " too short";
+  if (str.length > LIMIT) return "Exceeds length limit";
+
+  // don't allow mixed case
+  const lowered = str.toLowerCase();
+  const uppered = str.toUpperCase();
+  if (str !== lowered && str !== uppered) return "Mixed-case string " + str;
+  str = lowered;
+
+  const split = str.lastIndexOf("1");
+  if (split === -1) return "No separator character for " + str;
+  if (split === 0) return "Missing prefix for " + str;
+
+  const prefix = str.slice(0, split);
+  const wordChars = str.slice(split + 1);
+  if (wordChars.length < 6) return "Data too short";
+
+  let chk = prefixChk(prefix);
+  if (typeof chk === "string") return chk;
+
+  const words: number[] = [];
+  for (let i = 0; i < wordChars.length; ++i) {
+    const c = wordChars.charAt(i);
+    const v = ALPHABET_MAP[c];
+    if (v === undefined) return "Unknown character " + c;
+    chk = polymodStep(chk) ^ v;
+
+    // not in the checksum?
+    if (i + 6 >= wordChars.length) continue;
+    words.push(v);
+  }
+
+  if (chk !== ENCODING_CONST) return "Invalid checksum for " + str;
+  return { prefix, words };
+}
+
+function decodeUnsafe(str: string, LIMIT?: number): any {
+  const res = __decode(str, LIMIT);
+  if (typeof res === "object") return res;
+}
+
+function decode(str: string, LIMIT?: number): any {
+  const res = __decode(str, LIMIT);
+  if (typeof res === "object") return res;
+
+  throw new Error(res);
+}
+
+function convert(data: ArrayLike<number>, inBits: number, outBits: number, pad: true): number[];
+function convert(
+  data: ArrayLike<number>,
+  inBits: number,
+  outBits: number,
+  pad: false,
+): number[] | string;
+function convert(
+  data: ArrayLike<number>,
+  inBits: number,
+  outBits: number,
+  pad: boolean,
+): number[] | string {
+  let value = 0;
+  let bits = 0;
+  const maxV = (1 << outBits) - 1;
+
+  const result: number[] = [];
+  for (let i = 0; i < data.length; ++i) {
+    value = (value << inBits) | data[i];
+    bits += inBits;
+
+    while (bits >= outBits) {
+      bits -= outBits;
+      result.push((value >> bits) & maxV);
+    }
+  }
+
+  if (pad) {
+    if (bits > 0) {
+      result.push((value << (outBits - bits)) & maxV);
+    }
+  } else {
+    if (bits >= inBits) return "Excess padding";
+    if ((value << (outBits - bits)) & maxV) return "Non-zero padding";
+  }
+
+  return result;
+}
+
+function toWords(bytes: ArrayLike<number>): number[] {
+  return convert(bytes, 8, 5, true);
+}
+
+function fromWordsUnsafe(words: ArrayLike<number>): number[] | undefined {
+  const res = convert(words, 5, 8, false);
+  if (Array.isArray(res)) return res;
+}
+
+function fromWords(words: ArrayLike<number>): number[] {
+  const res = convert(words, 5, 8, false);
+  if (Array.isArray(res)) return res;
+
+  throw new Error(res);
+}
+
+export const bech32m = {
+  decodeUnsafe,
+  decode,
+  encode,
+  toWords,
+  fromWordsUnsafe,
+  fromWords,
+};

package/src/bridge/js.ts

@@ -0,0 +1,96 @@
+import { Account, BroadcastArg } from "@ledgerhq/types-live";
+import {
+  defaultUpdateTransaction,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+  makeSync,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import type { Transaction } from "../types";
+import { StartSpan, makeGetAccountShape, postSync } from "../js-synchronisation";
+import createTransaction from "../js-createTransaction";
+import prepareTransaction from "../js-prepareTransaction";
+import getTransactionStatus from "../js-getTransactionStatus";
+import estimateMaxSpendable from "../js-estimateMaxSpendable";
+import buildSignOperation from "../js-signOperation";
+import broadcast from "../js-broadcast";
+import { calculateFees } from "./../cache";
+import { perCoinLogic } from "../logic";
+import { assignFromAccountRaw, assignToAccountRaw } from "../serialization";
+import resolver from "../hw-getAddress";
+import { SignerContext } from "../signer";
+
+function buildCurrencyBridge(signerContext: SignerContext, perfLogger: PerfLogger) {
+  const getAddress = resolver(signerContext);
+  const scanAccounts = makeScanAccounts({
+    getAccountShape: makeGetAccountShape(signerContext, perfLogger.startSpan),
+    getAddressFn: getAddressWrapper(getAddress),
+  });
+
+  return {
+    scanAccounts,
+    preload: () => Promise.resolve({}),
+    hydrate: () => {},
+  };
+}
+
+function buildAccountBridge(signerContext: SignerContext, perfLogger: PerfLogger) {
+  const sync = makeSync({
+    getAccountShape: makeGetAccountShape(signerContext, perfLogger.startSpan),
+    postSync,
+  });
+
+  const getAddress = resolver(signerContext);
+  const injectGetAddressParams = (account: Account): any => {
+    const perCoin = perCoinLogic[account.currency.id];
+
+    if (perCoin && perCoin.injectGetAddressParams) {
+      return perCoin.injectGetAddressParams(account);
+    }
+  };
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress), {
+    injectGetAddressParams,
+  });
+
+  const updateTransaction = (tx: Transaction, patch: Partial<Transaction>): any => {
+    const updatedT = defaultUpdateTransaction(tx, patch);
+
+    // We accept case-insensitive addresses as input from user,
+    // but segwit addresses need to be converted to lowercase to be valid
+    if (updatedT.recipient.toLowerCase().indexOf("bc1") === 0) {
+      updatedT.recipient = updatedT.recipient.toLowerCase();
+    }
+
+    return updatedT;
+  };
+
+  return {
+    estimateMaxSpendable,
+    createTransaction,
+    prepareTransaction,
+    updateTransaction,
+    getTransactionStatus,
+    receive,
+    sync,
+    signOperation: buildSignOperation(signerContext),
+    broadcast: async ({ account, signedOperation }: BroadcastArg) => {
+      calculateFees.reset();
+      return broadcast({
+        account,
+        signedOperation,
+      });
+    },
+    assignFromAccountRaw,
+    assignToAccountRaw,
+  };
+}
+
+export type PerfLogger = {
+  startSpan: StartSpan;
+};
+export function createBridges(signerContext: SignerContext, perfLogger: PerfLogger) {
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext, perfLogger),
+    accountBridge: buildAccountBridge(signerContext, perfLogger),
+  };
+}

package/src/bridge.integration.test.ts

@@ -0,0 +1,47 @@
+import { DatasetTest } from "@ledgerhq/types-live";
+
+import type { Transaction } from "./types";
+import bitcoin from "./datasets/bitcoin";
+import bitcoin_cash from "./datasets/bitcoin_cash";
+import bitcoin_gold from "./datasets/bitcoin_gold";
+import dash from "./datasets/dash";
+import decred from "./datasets/decred";
+import digibyte from "./datasets/digibyte";
+import dogecoin from "./datasets/dogecoin";
+import zencash from "./datasets/zencash";
+import komodo from "./datasets/komodo";
+import litecoin from "./datasets/litecoin";
+import peercoin from "./datasets/peercoin";
+import pivx from "./datasets/pivx";
+import qtum from "./datasets/qtum";
+import vertcoin from "./datasets/vertcoin";
+import viacoin from "./datasets/viacoin";
+import zcash from "./datasets/zcash";
+
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["js", "mock"],
+  currencies: {
+    bitcoin,
+    bitcoin_cash,
+    bitcoin_gold,
+    dash,
+    decred,
+    digibyte,
+    dogecoin,
+    zencash,
+    komodo,
+    litecoin,
+    peercoin,
+    pivx,
+    qtum,
+    vertcoin,
+    viacoin,
+    zcash,
+  },
+};
+
+describe("Bitcoin bridge", () => {
+  test.todo(
+    "This is an empty test to make jest command pass. Remove it once there is a real test.",
+  );
+});

package/src/cache.ts

@@ -0,0 +1,73 @@
+import { RecipientRequired } from "@ledgerhq/errors";
+import { makeLRUCache } from "@ledgerhq/live-network/cache";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import type { Account } from "@ledgerhq/types-live";
+import getFeesForTransaction from "./js-getFeesForTransaction";
+import { isValidRecipient } from "./logic";
+import type { Transaction } from "./types";
+import { Currency, isTaprootAddress } from "./wallet-btc";
+
+const getCacheKeyForCalculateFees = ({ a, t }: { a: Account; t: Transaction }) =>
+  `${a.id}_${a.blockHeight || 0}_${t.amount.toString()}_${String(t.useAllAmount)}_${t.recipient}_${
+    t.feePerByte ? t.feePerByte.toString() : ""
+  }_${0}_${t.utxoStrategy.strategy}_${String(t.rbf)}_${t.utxoStrategy.excludeUTXOs
+    .map(({ hash, outputIndex }) => `${hash}@${outputIndex}`)
+    .join("+")}`;
+
+export const calculateFees = makeLRUCache(
+  async ({ account, transaction }: { account: Account; transaction: Transaction }) =>
+    getFeesForTransaction({
+      account,
+      transaction,
+    }),
+  ({ account, transaction }) =>
+    getCacheKeyForCalculateFees({
+      a: account,
+      t: transaction,
+    }),
+  {
+    ttl: 5 * 60 * 1000, // 5 minutes
+  },
+);
+
+export const validateRecipient: (
+  arg0: CryptoCurrency,
+  arg1: string | null | undefined,
+) => Promise<{
+  recipientError: Error | null | undefined;
+  recipientWarning: Error | null | undefined;
+}> = makeLRUCache(
+  async (currency, recipient) => {
+    if (!recipient) {
+      return {
+        recipientError: new RecipientRequired(""),
+        recipientWarning: null,
+      };
+    }
+
+    try {
+      const recipientWarning = await isValidRecipient({
+        currency,
+        recipient,
+      });
+      return {
+        recipientError: null,
+        recipientWarning,
+      };
+    } catch (e) {
+      return {
+        recipientError: e instanceof Error ? e : null,
+        recipientWarning: null,
+      };
+    }
+  },
+  (currency, recipient) => `${currency.id}_${recipient || ""}`,
+);
+
+export const isTaprootRecipient: (arg0: CryptoCurrency, arg1: string) => Promise<boolean> =
+  makeLRUCache(
+    async (currency, recipient) => {
+      return isTaprootAddress(recipient, <Currency>currency.id);
+    },
+    (currency, recipient) => `${currency.id}_${recipient || ""}`,
+  );

package/src/cli-transaction.ts

@@ -0,0 +1,73 @@
+import invariant from "invariant";
+import { BigNumber } from "bignumber.js";
+import type { Transaction } from "./types";
+import { bitcoinPickingStrategy } from "./types";
+import type { AccountLike } from "@ledgerhq/types-live";
+
+const options = [
+  {
+    name: "feePerByte",
+    type: String,
+    desc: "how much fee per byte",
+  },
+  {
+    name: "excludeUTXO",
+    alias: "E",
+    type: String,
+    multiple: true,
+    desc: "exclude utxo by their txhash@index (example: -E hash@3 -E hash@0)",
+  },
+  {
+    name: "rbf",
+    type: Boolean,
+    desc: "enable replace-by-fee",
+  },
+  {
+    name: "bitcoin-pick-strategy",
+    type: String,
+    desc: "utxo picking strategy, one of: " + Object.keys(bitcoinPickingStrategy).join(" | "),
+  },
+];
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+  }>,
+  opts: Record<string, any>,
+): Transaction[] {
+  const feePerByte = new BigNumber(opts.feePerByte === undefined ? 1 : opts.feePerByte);
+  return transactions.map(({ transaction }) => {
+    invariant(transaction.family === "bitcoin", "bitcoin family");
+
+    const bitcoinStragegy = opts["bitcoin-pick-strategy"];
+    if (!(bitcoinStragegy in bitcoinPickingStrategy)) {
+      throw new Error("Unknown bitcoinStragegy");
+    }
+
+    return {
+      ...transaction,
+      feePerByte,
+      rbf: opts.rbf || false,
+      utxoStrategy: {
+        strategy:
+          bitcoinPickingStrategy[bitcoinStragegy as keyof typeof bitcoinPickingStrategy] || 0,
+        excludeUTXOs: (opts.excludeUTXO || []).map((str: string) => {
+          const [hash, index] = str.split("@");
+          invariant(hash && index && !isNaN(Number(index)), "invalid format for --excludeUTXO, -E");
+          return {
+            hash,
+            outputIndex: parseInt(index, 10),
+          };
+        }),
+      },
+    };
+  });
+}
+
+export default function makeCliTools() {
+  return {
+    options,
+    inferTransactions,
+  };
+}

package/src/crypto-util.ts

@@ -0,0 +1,15 @@
+import RIPEMD160 from "ripemd160";
+import sha from "sha.js";
+
+export function sha256(buffer: Buffer | string) {
+  return sha("sha256").update(buffer).digest();
+}
+export function hash256(buffer: Buffer | string) {
+  return sha256(sha256(buffer));
+}
+export function ripemd160(buffer: Buffer | string) {
+  return new RIPEMD160().update(buffer).digest();
+}
+export function hash160(buffer: Buffer | string) {
+  return ripemd160(sha256(buffer));
+}