@ledgerhq/coin-bitcoin 0.4.0-nightly.0

package/src/descriptor.ts

@@ -0,0 +1,205 @@
+import { Observable, from, of, EMPTY } from "rxjs";
+import { concatMap } from "rxjs/operators";
+import invariant from "invariant";
+import bs58 from "bs58";
+import type {
+  GetAddressOptions,
+  StepAddressInput,
+  Result,
+} from "@ledgerhq/coin-framework/derivation";
+import { hash256, hash160 } from "./crypto-util";
+import {
+  walletDerivation,
+  getDerivationModesForCurrency,
+  runAccountDerivationScheme,
+  getDerivationScheme,
+} from "@ledgerhq/coin-framework/derivation";
+import getAddress from "./hw-getAddress";
+import type { Account, DerivationMode } from "@ledgerhq/types-live";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { decodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { SignerContext } from "./signer";
+
+export type AccountDescriptor = {
+  internal: string;
+  external: string;
+};
+const perDerivation: Partial<
+  Record<DerivationMode, ((arg0: string) => string) | null | undefined>
+> = {
+  "": fragment => `pkh(${fragment})`,
+  segwit: fragment => `sh(wpkh(${fragment}))`,
+  native_segwit: fragment => `wpkh(${fragment})`,
+  taproot: fragment => `tr(${fragment})`,
+};
+
+function makeFingerprint(compressedPubKey: Buffer) {
+  return hash160(compressedPubKey).slice(0, 4);
+}
+
+function makeDescriptor({
+  currency,
+  index,
+  derivationMode,
+  fingerprint,
+  xpub,
+}: {
+  currency: CryptoCurrency;
+  index: number;
+  derivationMode: DerivationMode;
+  fingerprint: Buffer;
+  xpub: string;
+}) {
+  const tmpl = perDerivation[derivationMode];
+  if (!tmpl || !xpub) return;
+  const keyOrigin = fingerprint.toString("hex");
+  const scheme = getDerivationScheme({
+    currency,
+    derivationMode,
+  });
+  const accountPath = runAccountDerivationScheme(scheme, currency, {
+    account: index,
+  });
+  return {
+    external: tmpl(`[${keyOrigin}/${accountPath}]${xpub}/0/*`),
+    internal: tmpl(`[${keyOrigin}/${accountPath}]${xpub}/1/*`),
+  };
+}
+
+export function inferDescriptorFromAccount(account: Account): AccountDescriptor | null | undefined {
+  if (account.currency.family !== "bitcoin") return;
+  const { id, derivationMode, seedIdentifier, currency, index } = account;
+  const xpub = decodeAccountId(id).xpubOrAddress;
+  const fingerprint = makeFingerprint(compressPublicKeySECP256(Buffer.from(seedIdentifier, "hex")));
+  return makeDescriptor({
+    derivationMode,
+    currency,
+    fingerprint,
+    xpub,
+    index,
+  });
+}
+
+function asBufferUInt32BE(n: number) {
+  const buf = Buffer.allocUnsafe(4);
+  buf.writeUInt32BE(n, 0);
+  return buf;
+}
+
+const compressPublicKeySECP256 = (publicKey: Buffer) =>
+  Buffer.concat([Buffer.from([0x02 + (publicKey[64] & 0x01)]), publicKey.slice(1, 33)]);
+
+function makeXpub({
+  version,
+  depth,
+  parentFingerprint,
+  index,
+  chainCode,
+  pubKey,
+}: {
+  version: number;
+  depth: number;
+  parentFingerprint: Buffer;
+  index: number;
+  chainCode: Buffer;
+  pubKey: Buffer;
+}) {
+  const indexBuffer = asBufferUInt32BE(index);
+  indexBuffer[0] |= 0x80;
+  const extendedKeyBytes = Buffer.concat([
+    asBufferUInt32BE(version),
+    Buffer.from([depth]),
+    parentFingerprint,
+    indexBuffer,
+    chainCode,
+    pubKey,
+  ]);
+  const checksum = hash256(extendedKeyBytes).slice(0, 4);
+  return bs58.encode(Buffer.concat([extendedKeyBytes, checksum]));
+}
+
+export function inferDescriptorFromDeviceInfo({
+  derivationMode,
+  currency,
+  index,
+  parentDerivation,
+  accountDerivation,
+}: {
+  derivationMode: DerivationMode;
+  currency: CryptoCurrency;
+  index: number;
+  parentDerivation: Result;
+  accountDerivation: Result;
+}): AccountDescriptor | null | undefined {
+  invariant(currency.bitcoinLikeInfo, "bitcoin currency expected");
+  const { bitcoinLikeInfo } = currency;
+  const { XPUBVersion } = bitcoinLikeInfo as {
+    P2PKH: number;
+    P2SH: number;
+    XPUBVersion?: number;
+    hasTimestamp?: boolean;
+  };
+  invariant(XPUBVersion, "unsupported bitcoin fork %s", currency.id);
+  const { chainCode } = accountDerivation;
+  invariant(chainCode, "chainCode is required");
+  const fingerprint = makeFingerprint(
+    compressPublicKeySECP256(Buffer.from(parentDerivation.publicKey, "hex")),
+  );
+  const xpub = makeXpub({
+    version: XPUBVersion,
+    depth: 3,
+    parentFingerprint: fingerprint,
+    index,
+    chainCode: Buffer.from(chainCode as string, "hex"),
+    pubKey: compressPublicKeySECP256(Buffer.from(accountDerivation.publicKey, "hex")),
+  });
+  return makeDescriptor({
+    derivationMode,
+    currency,
+    fingerprint,
+    xpub,
+    index,
+  });
+}
+export function scanDescriptors(
+  deviceId: string,
+  currency: CryptoCurrency,
+  signerContext: SignerContext,
+  limit = 10,
+): Observable<AccountDescriptor> {
+  const derivateAddress = (opts: GetAddressOptions) =>
+    from(getAddress(signerContext)(deviceId, opts));
+
+  function stepAddress({
+    index,
+    accountDerivation,
+    parentDerivation,
+    derivationMode,
+  }: StepAddressInput) {
+    const result = inferDescriptorFromDeviceInfo({
+      derivationMode,
+      currency,
+      index,
+      parentDerivation,
+      accountDerivation,
+    });
+    return !result
+      ? EMPTY
+      : of({
+          result,
+          complete: index >= limit,
+        });
+  }
+
+  return from(getDerivationModesForCurrency(currency)).pipe(
+    concatMap(derivationMode =>
+      walletDerivation({
+        currency,
+        derivationMode,
+        derivateAddress,
+        stepAddress,
+        shouldDerivesOnAccount: true,
+      }),
+    ),
+  );
+}

package/src/deviceTransactionConfig.ts

@@ -0,0 +1,39 @@
+import type { Transaction, TransactionStatus } from "./types";
+import type { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+import type { Account, AccountLike } from "@ledgerhq/types-live";
+
+function getDeviceTransactionConfig({
+  status: { amount, estimatedFees, opReturnData },
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const fields: Array<{ label: string; type: string }> = [];
+
+  if (!amount.isZero()) {
+    fields.push({
+      type: "amount",
+      label: "Amount",
+    });
+  }
+
+  if (estimatedFees && !estimatedFees.isZero()) {
+    fields.push({
+      type: "fees",
+      label: "Fees",
+    });
+  }
+
+  if (opReturnData) {
+    fields.push({
+      type: "opReturnData",
+      label: "OP_RETURN",
+    });
+  }
+
+  return fields as Array<DeviceTransactionField>;
+}
+
+export default getDeviceTransactionConfig;

package/src/errors.ts

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

package/src/explorer.ts

@@ -0,0 +1,40 @@
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import invariant from "invariant";
+import { getEnv } from "@ledgerhq/live-env";
+
+type LedgerExplorer = {
+  version: string;
+  id: string;
+  endpoint: string;
+};
+
+const findCurrencyExplorer = (currency: CryptoCurrency): LedgerExplorer | null | undefined => {
+  if (getEnv("SATSTACK") && currency.id === "bitcoin") {
+    return {
+      endpoint: getEnv("EXPLORER_SATSTACK"),
+      id: "btc",
+      version: "v3",
+    };
+  }
+
+  if (currency.explorerId == null) {
+    console.warn("no explorerId for", currency.id);
+  }
+
+  return {
+    endpoint: getEnv("EXPLORER"),
+    id: currency.explorerId ?? currency.id,
+    version: "v4",
+  };
+};
+
+export const getCurrencyExplorer = (currency: CryptoCurrency): LedgerExplorer => {
+  const res = findCurrencyExplorer(currency);
+  invariant(res, `no Ledger explorer for ${currency.id}`);
+  return <LedgerExplorer>res;
+};
+
+export const blockchainBaseURL = (currency: CryptoCurrency): string => {
+  const { id, version, endpoint } = getCurrencyExplorer(currency);
+  return `${endpoint}/blockchain/${version}/${id}`;
+};

package/src/formatters.ts

@@ -0,0 +1,52 @@
+import { getEnv } from "@ledgerhq/live-env";
+import type { BitcoinAccount, BitcoinInput, BitcoinOutput } from "./types";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+
+const sortUTXO = (a: BitcoinOutput, b: BitcoinOutput) => b.value.minus(a.value).toNumber();
+
+export function formatInput(account: BitcoinAccount, input: BitcoinInput): string {
+  return `${(input.value
+    ? formatCurrencyUnit(account.unit, input.value, {
+        showCode: false,
+      })
+    : ""
+  ).padEnd(12)} ${input.address || ""} ${input.previousTxHash || ""}@${input.previousOutputIndex}`;
+}
+export function formatOutput(account: BitcoinAccount, o: BitcoinOutput): string {
+  return [
+    formatCurrencyUnit(account.unit, o.value, {
+      showCode: false,
+    }).padEnd(12),
+    o.address,
+    o.isChange ? "(change)" : "",
+    o.rbf ? "rbf" : "",
+    o.hash,
+    `@${o.outputIndex} (${o.blockHeight ? account.blockHeight - o.blockHeight : 0})`,
+  ]
+    .filter(Boolean)
+    .join(" ");
+}
+
+function formatAccountSpecifics(account: BitcoinAccount): string {
+  if (!account.bitcoinResources) return "";
+  const { utxos } = account.bitcoinResources;
+  let str = `\n${utxos.length} UTXOs`;
+  const n = getEnv("DEBUG_UTXO_DISPLAY");
+  const displayAll = utxos.length <= n;
+  str += utxos
+    .slice(0)
+    .sort(sortUTXO)
+    .slice(0, displayAll ? utxos.length : n)
+    .map(utxo => `\n${formatOutput(account, utxo)}`)
+    .join("");
+
+  if (!displayAll) {
+    str += "\n...";
+  }
+
+  return str;
+}
+
+export default {
+  formatAccountSpecifics,
+};

package/src/getAccountNetworkInfo.test.ts

@@ -0,0 +1,37 @@
+import { BigNumber } from "bignumber.js";
+import { avoidDups } from "./getAccountNetworkInfo";
+test("avoidFeeDupsInFeePerByte [3,2,2] => [4,3,2]", async () => {
+  expect(avoidDups([new BigNumber(3), new BigNumber(3), new BigNumber(2)])).toEqual([
+    new BigNumber(4),
+    new BigNumber(3),
+    new BigNumber(2),
+  ]);
+});
+test("avoidFeeDupsInFeePerByte [2,2,1] => [3,2,1]", async () => {
+  expect(avoidDups([new BigNumber(2), new BigNumber(2), new BigNumber(1)])).toEqual([
+    new BigNumber(3),
+    new BigNumber(2),
+    new BigNumber(1),
+  ]);
+});
+test("avoidFeeDupsInFeePerByte [3,3,3] => [5,4,3]", async () => {
+  expect(avoidDups([new BigNumber(3), new BigNumber(3), new BigNumber(3)])).toEqual([
+    new BigNumber(5),
+    new BigNumber(4),
+    new BigNumber(3),
+  ]);
+});
+test("avoidFeeDupsInFeePerByte [3,2,1] => [3,2,1]", async () => {
+  expect(avoidDups([new BigNumber(3), new BigNumber(2), new BigNumber(1)])).toEqual([
+    new BigNumber(3),
+    new BigNumber(2),
+    new BigNumber(1),
+  ]);
+});
+test("avoidFeeDupsInFeePerByte [100,100,1] => [101,100,1]", async () => {
+  expect(avoidDups([new BigNumber(100), new BigNumber(100), new BigNumber(1)])).toEqual([
+    new BigNumber(101),
+    new BigNumber(100),
+    new BigNumber(1),
+  ]);
+});

package/src/getAccountNetworkInfo.ts

@@ -0,0 +1,54 @@
+import flow from "lodash/flow";
+import { BigNumber } from "bignumber.js";
+import type { NetworkInfo } from "./types";
+import { getWalletAccount } from "./wallet-btc";
+import { Account } from "@ledgerhq/types-live";
+const speeds = ["fast", "medium", "slow"];
+export function avoidDups(nums: Array<BigNumber>): Array<BigNumber> {
+  nums = nums.slice(0);
+
+  for (let i = nums.length - 2; i >= 0; i--) {
+    if (nums[i + 1].gte(nums[i])) {
+      nums[i] = nums[i + 1].plus(1);
+    }
+  }
+
+  return nums;
+}
+export async function getAccountNetworkInfo(account: Account): Promise<NetworkInfo> {
+  const walletAccount = getWalletAccount(account);
+  const rawFees = await walletAccount.xpub.explorer.getFees();
+  // Convoluted logic to convert from:
+  // { "2": 2435, "3": 1241, "6": 1009, "last_updated": 1627973170 }
+  // to:
+  // { 2435, 1241, 1009 }
+  const feesPerByte: BigNumber[] = flow([
+    // Remove the 'last_updated' key
+    Object.entries,
+    entries => entries.filter(([key]: [string]) => !isNaN(Number(key))),
+    // Reconstruct the array with only the values
+    Object.fromEntries,
+    Object.values,
+    // Safety against invalid data
+    f => f.filter((f: unknown) => f != null && typeof f === "number"),
+    // Normalize values
+    f => f.map((f: number) => new BigNumber(f).div(1000).integerValue(BigNumber.ROUND_CEIL)),
+    avoidDups,
+  ])(rawFees);
+
+  if (feesPerByte.length !== 3) {
+    throw new Error("cardinality of feesPerByte should be exactly 3");
+  }
+  const feeItems = {
+    items: feesPerByte.map((feePerByte, i: number) => ({
+      key: String(i),
+      speed: speeds[i],
+      feePerByte,
+    })),
+    defaultFeePerByte: feesPerByte[Math.floor(feesPerByte.length / 2)] || new BigNumber(0),
+  };
+  return {
+    family: "bitcoin",
+    feeItems,
+  };
+}

package/src/hw-getAddress.ts

@@ -0,0 +1,52 @@
+import { log } from "@ledgerhq/logs";
+import {
+  getAddressFormatDerivationMode,
+  type GetAddressOptions,
+} from "@ledgerhq/coin-framework/derivation";
+import { UnsupportedDerivation } from "@ledgerhq/coin-framework/errors";
+import { AddressFormat, BitcoinAddress, SignerContext } from "./signer";
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+
+const resolver = (signerContext: SignerContext): GetAddressFn => {
+  return async (
+    deviceId: string,
+    { currency, path, verify, derivationMode, forceFormat }: GetAddressOptions,
+  ) => {
+    const format = forceFormat || getAddressFormatDerivationMode(derivationMode);
+
+    let result;
+    try {
+      result = (await signerContext(deviceId, currency, signer =>
+        signer.getWalletPublicKey(path, {
+          verify,
+          format: format as AddressFormat,
+        }),
+      )) as BitcoinAddress;
+    } catch (e: any) {
+      // TODO Should normalize error returned from ledgerjs
+      if (
+        e &&
+        e.message &&
+        (e.message.includes("invalid format") || e.message.includes("Unsupported address format"))
+      ) {
+        throw new UnsupportedDerivation();
+      }
+      throw e;
+    }
+
+    const { bitcoinAddress, publicKey, chainCode } = result;
+
+    log(
+      "hw",
+      `getAddress ${currency.id} path=${path} address=${bitcoinAddress} publicKey=${publicKey} chainCode=${chainCode}`,
+    );
+    return {
+      address: bitcoinAddress,
+      path,
+      publicKey,
+      chainCode,
+    };
+  };
+};
+
+export default resolver;

package/src/hw-signMessage.ts

@@ -0,0 +1,23 @@
+import { Account, AnyMessage } from "@ledgerhq/types-live";
+import { BitcoinSignature, SignerContext } from "./signer";
+
+export const signMessage =
+  (signerContext: SignerContext) =>
+  async (deviceId: string, account: Account, { message }: AnyMessage) => {
+    if (typeof message !== "string") {
+      throw new Error("Invalid message type");
+    }
+
+    const hexMessage = Buffer.from(message).toString("hex");
+    const result = (await signerContext(deviceId, account.currency, signer =>
+      signer.signMessage(account.freshAddressPath, hexMessage),
+    )) as BitcoinSignature;
+    const v = result["v"] + 27 + 4;
+    const signature = Buffer.from(`${v.toString(16)}${result["r"]}${result["s"]}`, "hex").toString(
+      "base64",
+    );
+    return {
+      rsv: result,
+      signature,
+    };
+  };

package/src/js-broadcast.ts

@@ -0,0 +1,22 @@
+import type { Account, Operation, SignedOperation } from "@ledgerhq/types-live";
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import wallet, { getWalletAccount } from "./wallet-btc";
+
+/**
+ * Broadcast a signed transaction
+ * @param {signature: string, operation: string} signedOperation
+ */
+const broadcast = async ({
+  account,
+  signedOperation,
+}: {
+  account: Account;
+  signedOperation: SignedOperation;
+}): Promise<Operation> => {
+  const { signature, operation } = signedOperation;
+  const walletAccount = getWalletAccount(account);
+  const hash = await wallet.broadcastTx(walletAccount, signature);
+  return patchOperationWithHash(operation, hash);
+};
+
+export default broadcast;

package/src/js-buildTransaction.ts

@@ -0,0 +1,68 @@
+import {
+  CoinSelect,
+  DeepFirst,
+  Merge,
+  type Account as WalletAccount,
+  type TransactionInfo as WalletTxInfo,
+} from "./wallet-btc";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+
+import type { Transaction, UtxoStrategy } from "./types";
+import { bitcoinPickingStrategy } from "./types";
+import wallet, { getWalletAccount } from "./wallet-btc";
+import { log } from "@ledgerhq/logs";
+import { Account } from "@ledgerhq/types-live";
+
+const selectUtxoPickingStrategy = (walletAccount: WalletAccount, utxoStrategy: UtxoStrategy) => {
+  const handler = {
+    [bitcoinPickingStrategy.MERGE_OUTPUTS]: Merge,
+    [bitcoinPickingStrategy.DEEP_OUTPUTS_FIRST]: DeepFirst,
+    [bitcoinPickingStrategy.OPTIMIZE_SIZE]: CoinSelect,
+  }[utxoStrategy.strategy];
+  if (!handler) throw new Error("Unsupported Bitcoin UTXO picking strategy");
+
+  return new handler(
+    walletAccount.xpub.crypto,
+    walletAccount.xpub.derivationMode,
+    utxoStrategy.excludeUTXOs,
+  );
+};
+
+export const buildTransaction = async (
+  account: Account,
+  transaction: Transaction,
+): Promise<WalletTxInfo> => {
+  const { feePerByte, recipient, opReturnData, utxoStrategy } = transaction;
+
+  if (!feePerByte) {
+    throw new FeeNotLoaded();
+  }
+
+  const walletAccount = getWalletAccount(account);
+  const utxoPickingStrategy = selectUtxoPickingStrategy(walletAccount, transaction.utxoStrategy);
+
+  const maxSpendable = await wallet.estimateAccountMaxSpendable(
+    walletAccount,
+    feePerByte.toNumber(), //!\ wallet-btc handles fees as JS number
+    utxoStrategy.excludeUTXOs,
+    [recipient],
+    opReturnData,
+  );
+
+  log("btcwallet", "building transaction", transaction);
+
+  const txInfo = await wallet.buildAccountTx({
+    fromAccount: walletAccount,
+    dest: transaction.recipient,
+    amount: transaction.useAllAmount ? maxSpendable : transaction.amount,
+    feePerByte: feePerByte.toNumber(), //!\ wallet-btc handles fees as JS number
+    utxoPickingStrategy,
+    // Definition of replaceable, per the standard: https://github.com/bitcoin/bips/blob/61ccc84930051e5b4a99926510d0db4a8475a4e6/bip-0125.mediawiki#summary
+    sequence: transaction.rbf ? 0 : 0xffffffff,
+    opReturnData,
+  });
+
+  log("btcwallet", "txInfo", txInfo);
+
+  return txInfo;
+};

package/src/js-createTransaction.ts

@@ -0,0 +1,26 @@
+import { BigNumber } from "bignumber.js";
+import type { Transaction } from "./types";
+
+/**
+ * Create an empty transaction
+ *
+ * @returns {Transaction}
+ */
+const createTransaction = (): Transaction => {
+  return {
+    family: "bitcoin",
+    amount: new BigNumber(0),
+    utxoStrategy: {
+      strategy: 0,
+      excludeUTXOs: [],
+    },
+    recipient: "",
+    rbf: false,
+    feePerByte: null,
+    networkInfo: null,
+    useAllAmount: false,
+    feesStrategy: "medium",
+  };
+};
+
+export default createTransaction;

package/src/js-estimateMaxSpendable.ts

@@ -0,0 +1,41 @@
+import { BigNumber } from "bignumber.js";
+import type { Transaction } from "./types";
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import wallet, { getWalletAccount } from "./wallet-btc";
+import { getAccountNetworkInfo } from "./getAccountNetworkInfo";
+import type { Account, AccountLike } from "@ledgerhq/types-live";
+
+/**
+ * Returns the maximum possible amount for transaction
+ *
+ * @param {Object} param - the account, parentAccount and transaction
+ */
+const estimateMaxSpendable = async ({
+  account,
+  parentAccount,
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction | null | undefined;
+}): Promise<BigNumber> => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const walletAccount = getWalletAccount(mainAccount);
+  let feePerByte = transaction?.feePerByte;
+  if (!feePerByte) {
+    const networkInfo = await getAccountNetworkInfo(mainAccount);
+    feePerByte = networkInfo.feeItems.defaultFeePerByte;
+  }
+
+  const maxSpendable = await wallet.estimateAccountMaxSpendable(
+    walletAccount,
+    feePerByte.toNumber(), //!\ wallet-btc handles fees as JS number
+    transaction?.utxoStrategy?.excludeUTXOs || [],
+    transaction ? [transaction.recipient] : [],
+    transaction?.opReturnData,
+  );
+
+  return maxSpendable.lt(0) ? new BigNumber(0) : maxSpendable;
+};
+
+export default estimateMaxSpendable;