@ledgerhq/coin-bitcoin 0.4.0-nightly.0

package/src/wallet-btc/crypto/zen.ts

@@ -0,0 +1,88 @@
+import bs58check from "bs58check";
+import { InvalidAddress } from "@ledgerhq/errors";
+import Base from "./base";
+import * as bjs from "bitcoinjs-lib";
+
+class Zen extends Base {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  network: any;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor({ network }: { network: any }) {
+    super({ network });
+    // refer to https://github.com/HorizenOfficial/zen/blob/master/src/chainparams.cpp for the blockchain params
+    this.network = network;
+    this.network.versions = {
+      bip32: {
+        public: 0x043587cf,
+        private: 0x04358394,
+      },
+      bip44: 121,
+      private: 0x80,
+      public: 0x2089,
+      scripthash: 0x2096,
+    };
+    this.network.name = "Zencash";
+    this.network.unit = "ZEN";
+    this.network.messagePrefix = "Zencash Signed Message:\n";
+    this.network.wif = 0x80;
+    this.network.pubKeyHash = 0x2089;
+    this.network.scriptHash = 0x2096;
+    this.network.dustThreshold = 10000;
+    this.network.dustPolicy = "FIXED";
+    this.network.usesTimestampedTransaction = false;
+  }
+
+  async getLegacyAddress(xpub: string, account: number, index: number): Promise<string> {
+    const pk = bjs.crypto.hash160(await this.getPubkeyAt(xpub, account, index));
+    const payload = Buffer.allocUnsafe(22);
+    payload.writeUInt16BE(this.network.pubKeyHash, 0);
+    pk.copy(payload, 2);
+    return bs58check.encode(payload);
+  }
+
+  async customGetAddress(
+    derivationMode: string,
+    xpub: string,
+    account: number,
+    index: number,
+  ): Promise<string> {
+    return await this.getLegacyAddress(xpub, account, index);
+  }
+
+  toOutputScript(address: string): Buffer {
+    if (!this.validateAddress(address)) {
+      throw new InvalidAddress();
+    }
+    let outputScript: Buffer;
+    const version = Number("0x" + bs58check.decode(address).slice(0, 2).toString("hex"));
+    if (version === this.network.pubKeyHash) {
+      //Pay-to-PubkeyHash
+      outputScript = bjs.payments.p2pkh({
+        hash: bs58check.decode(address).slice(2),
+      }).output as Buffer;
+    } else if (version === this.network.scriptHash) {
+      //Pay-to-Script-Hash
+      outputScript = bjs.payments.p2sh({
+        hash: bs58check.decode(address).slice(2),
+      }).output as Buffer;
+    } else {
+      throw new InvalidAddress();
+    }
+    // refer to https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/scripts/BitcoinLikeScript.cpp#L139 and https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/networks.cpp#L39 for bip115 Script and its network parameters
+    const bip115Script = Buffer.from(
+      "209ec9845acb02fab24e1c0368b3b517c1a4488fba97f0e3459ac053ea0100000003c01f02b4",
+      "hex",
+    );
+    return Buffer.concat([outputScript, bip115Script]);
+  }
+
+  validateAddress(address: string): boolean {
+    const res = bs58check.decodeUnsafe(address);
+    if (!res) return false;
+    // refer to https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/networks.cpp#L142
+    return res && res.length > 3 && res[0] === 0x20 && (res[1] === 0x89 || res[1] === 0x96);
+  }
+}
+
+export default Zen;

package/src/wallet-btc/explorer/index.ts

@@ -0,0 +1,197 @@
+import { Address, Block, TX } from "../storage/types";
+import network from "@ledgerhq/live-network/network";
+import { IExplorer } from "./types";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { blockchainBaseURL } from "../../explorer";
+
+type ExplorerParams = {
+  batch_size?: number;
+  from_height?: number;
+  to_height?: number;
+  order?: "ascending" | "descending";
+};
+
+class BitcoinLikeExplorer implements IExplorer {
+  baseUrl: string;
+  constructor({
+    cryptoCurrency,
+    forcedExplorerURI,
+  }: {
+    cryptoCurrency: CryptoCurrency;
+    forcedExplorerURI?: string;
+  }) {
+    this.baseUrl =
+      forcedExplorerURI != null ? forcedExplorerURI : blockchainBaseURL(cryptoCurrency);
+  }
+
+  async broadcast(tx: string): Promise<{ data: { result: string } }> {
+    const url = `${this.baseUrl}/tx/send`;
+    const res = await network({
+      method: "POST",
+      url,
+      data: { tx },
+    });
+    return res;
+  }
+
+  async getTxHex(txId: string): Promise<string> {
+    // TODO add a test for failure (at the sync level)
+    const { data } = await network({
+      method: "GET",
+      url: `${this.baseUrl}/tx/${txId}/hex`,
+    });
+    return data.hex;
+  }
+
+  async getCurrentBlock(): Promise<Block | null> {
+    const url = `${this.baseUrl}/block/current`;
+    const { data } = await network({
+      method: "GET",
+      url,
+    });
+    return data ? { height: data.height, hash: data.hash, time: data.time } : null;
+  }
+
+  async getBlockByHeight(height: number): Promise<Block | null> {
+    const { data } = await network({
+      method: "GET",
+      url: `${this.baseUrl}/block/${height}`,
+    });
+    return data[0] ? { height: data[0].height, hash: data[0].hash, time: data[0].time } : null;
+  }
+
+  async getFees(): Promise<{ [key: string]: number }> {
+    // TODO add a test for failure (at the sync level)
+    const { data } = await network({
+      method: "GET",
+      url: `${this.baseUrl}/fees`,
+    });
+    return data;
+  }
+
+  async getPendings(address: Address, nbMax = 1000): Promise<TX[]> {
+    const params: ExplorerParams = {
+      batch_size: nbMax,
+    };
+    const pendingsTxs = await this.fetchPendingTxs(address, params);
+    pendingsTxs.forEach(tx => this.hydrateTx(address, tx));
+    return pendingsTxs;
+  }
+
+  async fetchTxs(address: Address, params: ExplorerParams): Promise<TX[]> {
+    const { data } = await network({
+      method: "GET",
+      url: `${this.baseUrl}/address/${address.address}/txs`,
+      params,
+    });
+    return data.data;
+  }
+
+  async fetchPendingTxs(address: Address, params: ExplorerParams): Promise<TX[]> {
+    const { data } = await network({
+      method: "GET",
+      url: `${this.baseUrl}/address/${address.address}/txs/pending`,
+      params,
+    });
+    return data;
+  }
+
+  /**
+   * When we get a raw tx from the explorer,
+   * we need to remove some fields that are not needed and fill up some fields that are required
+   * to be consistent with our transaction model
+   */
+  hydrateTx(address: Address, tx: TX): void {
+    // no need to keep those as they change
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    // eslint-disable-next-line no-param-reassign
+    delete tx.confirmations;
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    delete tx.hash;
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    delete tx.lock_time;
+
+    // eslint-disable-next-line no-param-reassign
+    tx.account = address.account;
+    // eslint-disable-next-line no-param-reassign
+    tx.index = address.index;
+    // eslint-disable-next-line no-param-reassign
+    tx.address = address.address;
+    tx.inputs.forEach(input => {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      delete input.txinwitness;
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      delete input.script_signature;
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      delete input.input_index;
+    });
+    tx.outputs.forEach(output => {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      delete output.script_hex;
+      // eslint-disable-next-line no-param-reassign
+      output.output_hash = tx.id;
+      // eslint-disable-next-line no-param-reassign
+      output.block_height = tx.block ? tx.block.height : null;
+      // Definition of replaceable, per the standard: https://github.com/bitcoin/bips/blob/61ccc84930051e5b4a99926510d0db4a8475a4e6/bip-0125.mediawiki#summary
+      output.rbf = tx.inputs[0] ? tx.inputs[0].sequence < 0xffffffff : false;
+    });
+  }
+
+  /**
+   * Get transactions for an address since a block height
+   * @param batchSize number of transactions to fetch
+   * @param address address to fetch transactions for
+   * @param fromBlockheight block height to fetch transactions from
+   * @param toBlockheight block height to fetch transactions to
+   * @param isPending whether to fetch only pending transactions or only confirmed transactions
+   */
+  async getTxsSinceBlockheight(
+    batchSize: number,
+    address: Address,
+    fromBlockheight: number,
+    toBlockheight: number | undefined,
+    isPending: boolean,
+  ): Promise<TX[]> {
+    const params: ExplorerParams = {
+      batch_size: batchSize,
+    };
+    // when isPending = false,
+    // we use https://explorers.api.live.ledger.com/blockchain/v4/btc/address/{address}/txs?batch_size={batch_size}&from_height={fromBlockheight}&order=ascending&to_height={toBlockheight} to fetch confirmed txs
+    // when isPending = true,
+    // we use https://explorers.api.live.ledger.com/blockchain/v4/btc/address/{address}/txs/pending?batch_size={batch_size} to fetch pending txs
+    if (!isPending) {
+      // toBlockheight is height of the current block
+      // but in some cases, we don't set this value (e.g. integration tests), so toBlockheight = undefined and we skip this optimization
+      if (toBlockheight && fromBlockheight > toBlockheight) {
+        return [];
+      }
+      params.from_height = fromBlockheight;
+      params.order = "ascending";
+      if (toBlockheight) {
+        params.to_height = toBlockheight;
+      }
+    }
+    const txs = isPending
+      ? await this.fetchPendingTxs(address, params)
+      : await this.fetchTxs(address, params);
+
+    const hydratedTxs: TX[] = [];
+
+    // faster than mapping
+    txs.forEach(tx => {
+      this.hydrateTx(address, tx);
+      hydratedTxs.push(tx);
+    });
+
+    return hydratedTxs;
+  }
+}
+
+export default BitcoinLikeExplorer;

package/src/wallet-btc/explorer/types.ts

@@ -0,0 +1,19 @@
+import { TX, Address, Block } from "../storage/types";
+
+// abstract explorer api used, abstract batching logic, pagination, and retries
+export interface IExplorer {
+  baseUrl: string;
+  broadcast(tx: string): Promise<{ data: { result: string } }>;
+  getTxHex(txId: string): Promise<string>;
+  getFees(): Promise<{ [key: string]: number }>;
+  getCurrentBlock(): Promise<Block | null>;
+  getBlockByHeight(height: number): Promise<Block | null>;
+  getPendings(address: Address, nbMax?: number): Promise<TX[]>;
+  getTxsSinceBlockheight(
+    batchSize: number,
+    address: Address,
+    fromBlockheight: number,
+    toBlockheight: number | undefined,
+    isPending: boolean,
+  ): Promise<TX[]>;
+}

package/src/wallet-btc/index.ts

@@ -0,0 +1,52 @@
+import { Currency } from "./crypto/types";
+import BitcoinLikeWallet from "./wallet";
+import { DerivationModes, InputInfo, OutputInfo, TransactionInfo } from "./types";
+import { Account, SerializedAccount } from "./account";
+import { TX, Input, Output } from "./storage/types";
+import { CoinSelect } from "./pickingstrategies/CoinSelect";
+import { DeepFirst } from "./pickingstrategies/DeepFirst";
+import { Merge } from "./pickingstrategies/Merge";
+import { isValidAddress, isTaprootAddress } from "./utils";
+
+import type { Account as WalletAccount } from "./account";
+import type { Account as LiveAccount } from "@ledgerhq/types-live";
+import { AccountNeedResync } from "../errors";
+import { BitcoinAccount } from "../types";
+
+export {
+  BitcoinLikeWallet,
+  type Account,
+  type SerializedAccount,
+  DerivationModes,
+  type Input,
+  type Output,
+  type InputInfo,
+  type OutputInfo,
+  type TransactionInfo,
+  type TX,
+  CoinSelect,
+  DeepFirst,
+  Merge,
+  isValidAddress,
+  isTaprootAddress,
+  type Currency,
+};
+
+let wallet: BitcoinLikeWallet | null = null;
+
+export const getWalletAccount = (account: LiveAccount): WalletAccount => {
+  const walletAccount = (account as BitcoinAccount).bitcoinResources?.walletAccount;
+  if (account.id.startsWith("libcore") || !walletAccount) {
+    throw new AccountNeedResync();
+  }
+  return walletAccount;
+};
+
+const getWallet = () => {
+  if (!wallet) {
+    wallet = new BitcoinLikeWallet();
+  }
+  return wallet;
+};
+
+export default getWallet();

package/src/wallet-btc/pickingstrategies/CoinSelect.ts

@@ -0,0 +1,183 @@
+import BigNumber from "bignumber.js";
+import flatten from "lodash/flatten";
+import sortBy from "lodash/sortBy";
+import { NotEnoughBalance } from "@ledgerhq/errors";
+import { Output } from "../storage/types";
+import Xpub from "../xpub";
+import { PickingStrategy } from "./types";
+import * as utils from "../utils";
+import { DeepFirst } from "./DeepFirst";
+import { log } from "@ledgerhq/logs";
+import { OutputInfo } from "..";
+
+/**
+ * Coinselect algorithm
+ * Aims to pick the best UTXOs to minimize the transaction fees in the current transaction
+ */
+export class CoinSelect extends PickingStrategy {
+  async selectUnspentUtxosToUse(
+    xpub: Xpub,
+    outputs: OutputInfo[],
+    feePerByte: number,
+  ): Promise<{
+    unspentUtxos: Output[];
+    totalValue: BigNumber;
+    fee: number;
+    needChangeoutput: boolean;
+  }> {
+    // get the utxos to use as input
+    // from all addresses of the account
+    const addresses = await xpub.getXpubAddresses();
+    log("picking strategy", "Coinselect");
+
+    const unspentUtxos = flatten(
+      await Promise.all(addresses.map(address => xpub.storage.getAddressUnspentUtxos(address))),
+    ).filter(
+      o =>
+        !this.excludedUTXOs.filter(
+          x => x.hash === o.output_hash && x.outputIndex === o.output_index,
+        ).length,
+    );
+    const TOTAL_TRIES = 100000;
+    log("picking strategy", "utxos", unspentUtxos);
+    // Compute cost of change
+    const fixedSize = utils.maxTxSize(0, [], false, this.crypto, this.derivationMode);
+    const outputScripts = outputs.map(o => o.script);
+    // Size of only 1 output (without fixed size)
+    const oneOutputSize =
+      outputScripts.length > 0
+        ? utils.maxTxSize(0, [outputScripts[0]], false, this.crypto, this.derivationMode) -
+          fixedSize
+        : utils.maxTxSize(0, [], true, this.crypto, this.derivationMode) - fixedSize;
+    // Size 1 signed UTXO (signed input)
+    const oneInputSize =
+      utils.maxTxSize(1, [], false, this.crypto, this.derivationMode) - fixedSize;
+
+    // Calculate effective value of outputs
+    let currentAvailableValue = 0;
+    let effectiveUtxos: Array<{
+      index: number;
+      effectiveValue: number;
+    }> = [];
+
+    for (let i = 0; i < unspentUtxos.length; i += 1) {
+      const outEffectiveValue = Number(unspentUtxos[i].value) - feePerByte * oneInputSize;
+      if (outEffectiveValue > 0) {
+        const effectiveUtxo = {
+          index: i,
+          effectiveValue: outEffectiveValue,
+        };
+        effectiveUtxos.push(effectiveUtxo);
+        currentAvailableValue += outEffectiveValue;
+      }
+    }
+
+    // Get no inputs fees
+    // At beginning, there are no outputs in tx, so noInputFees are fixed fees
+    const notInputFees = feePerByte * (fixedSize + oneOutputSize * outputs.length);
+
+    // Start coin selection algorithm (according to SelectCoinBnb from Bitcoin Core)
+    let currentValue = 0;
+    const currentSelection: boolean[] = [];
+
+    const amount = outputs.reduce((sum, output) => sum.plus(output.value), new BigNumber(0));
+    // Actual amount we are targetting
+    const actualTarget = notInputFees + amount.toNumber();
+
+    // Insufficient funds
+    if (currentAvailableValue < actualTarget) {
+      throw new NotEnoughBalance();
+    }
+    // Sort utxos by effectiveValue
+    effectiveUtxos = sortBy(effectiveUtxos, "effectiveValue");
+    effectiveUtxos = effectiveUtxos.reverse();
+    let currentWaste = 0;
+    let bestWaste = Number.MAX_SAFE_INTEGER;
+    let bestSelection: boolean[] = [];
+
+    // Dfs to find a solution with minimal fees
+    let bestSelectionNeedChangeoutput = false;
+    let currentSelectionNeedChangeoutput = false;
+    for (let i = 0; i < TOTAL_TRIES; i += 1) {
+      let backtrack = false;
+      const nbInput = currentSelection.filter(x => x).length;
+      if (currentValue >= actualTarget) {
+        if (currentValue - actualTarget > feePerByte * oneOutputSize) {
+          // changeoutput is required
+          currentSelectionNeedChangeoutput = true;
+          currentWaste =
+            feePerByte *
+            utils.maxTxSizeCeil(nbInput, outputScripts, true, this.crypto, this.derivationMode);
+        } else {
+          // changeoutput is not required
+          currentSelectionNeedChangeoutput = false;
+          currentWaste =
+            feePerByte *
+              utils.maxTxSizeCeil(nbInput, outputScripts, false, this.crypto, this.derivationMode) +
+            currentValue -
+            actualTarget;
+        }
+        if (currentWaste <= bestWaste) {
+          bestSelection = currentSelection.slice();
+          while (effectiveUtxos.length > bestSelection.length) {
+            bestSelection.push(false);
+          }
+          bestSelection.length = effectiveUtxos.length;
+          bestWaste = currentWaste;
+          bestSelectionNeedChangeoutput = currentSelectionNeedChangeoutput;
+        }
+        backtrack = true;
+      }
+      if (currentSelection.length >= effectiveUtxos.length) {
+        backtrack = true;
+      }
+      // Move backwards
+      if (backtrack) {
+        while (currentSelection.length > 0 && !currentSelection[currentSelection.length - 1]) {
+          currentSelection.pop();
+        }
+        // Case we walked back to the first utxos and all solutions searched.
+        if (currentSelection.length === 0) {
+          break;
+        }
+        currentSelection[currentSelection.length - 1] = false;
+        const eu = effectiveUtxos[currentSelection.length - 1];
+        currentValue -= eu.effectiveValue;
+      } else {
+        // Moving forwards, continuing down this branch
+        const eu = effectiveUtxos[currentSelection.length];
+        currentSelection.push(true);
+        currentValue += eu.effectiveValue;
+      }
+    }
+    // solution found
+    if (bestSelection.length > 0) {
+      let total = new BigNumber(0);
+      const unspentUtxoSelected: Output[] = [];
+      for (let i = 0; i < bestSelection.length; i += 1) {
+        if (bestSelection[i]) {
+          unspentUtxoSelected.push(unspentUtxos[effectiveUtxos[i].index]);
+          total = total.plus(unspentUtxos[effectiveUtxos[i].index].value);
+        }
+      }
+      const fee =
+        feePerByte *
+        utils.maxTxSizeCeil(
+          unspentUtxoSelected.length,
+          outputScripts,
+          bestSelectionNeedChangeoutput,
+          this.crypto,
+          this.derivationMode,
+        );
+      return {
+        totalValue: total,
+        unspentUtxos: unspentUtxoSelected,
+        fee: Math.ceil(fee),
+        needChangeoutput: bestSelectionNeedChangeoutput,
+      };
+    }
+
+    const pickingStrategy = new DeepFirst(this.crypto, this.derivationMode, this.excludedUTXOs);
+    return pickingStrategy.selectUnspentUtxosToUse(xpub, outputs, feePerByte);
+  }
+}

package/src/wallet-btc/pickingstrategies/DeepFirst.ts

@@ -0,0 +1,92 @@
+import BigNumber from "bignumber.js";
+import flatten from "lodash/flatten";
+import sortBy from "lodash/sortBy";
+import { NotEnoughBalance } from "@ledgerhq/errors";
+import { Output } from "../storage/types";
+import Xpub from "../xpub";
+import { PickingStrategy } from "./types";
+import * as utils from "../utils";
+import { log } from "@ledgerhq/logs";
+import { OutputInfo } from "..";
+
+/**
+ * prioritizes the oldest UTXOs in the current transaction
+ */
+export class DeepFirst extends PickingStrategy {
+  async selectUnspentUtxosToUse(
+    xpub: Xpub,
+    outputs: OutputInfo[],
+    feePerByte: number,
+  ): Promise<{
+    unspentUtxos: Output[];
+    totalValue: BigNumber;
+    fee: number;
+    needChangeoutput: boolean;
+  }> {
+    // get the utxos to use as input
+    // from all addresses of the account
+    const addresses = await xpub.getXpubAddresses();
+    log("picking strategy", "Deepfirst");
+
+    let unspentUtxos = flatten(
+      await Promise.all(addresses.map(address => xpub.storage.getAddressUnspentUtxos(address))),
+    ).filter(
+      o =>
+        !this.excludedUTXOs.filter(
+          x => x.hash === o.output_hash && x.outputIndex === o.output_index,
+        ).length,
+    );
+
+    const outputScripts = outputs.map(o => o.script);
+    unspentUtxos = sortBy(unspentUtxos, "block_height");
+    // https://metamug.com/article/security/bitcoin-transaction-fee-satoshi-per-byte.html
+    const txSizeNoInput = utils.maxTxSize(
+      0,
+      outputScripts,
+      false,
+      this.crypto,
+      this.derivationMode,
+    );
+    let fee = txSizeNoInput * feePerByte;
+    const emptyTxSize = utils.maxTxSizeCeil(0, [], false, this.crypto, this.derivationMode);
+    const sizePerInput =
+      utils.maxTxSize(1, [], false, this.crypto, this.derivationMode) - emptyTxSize;
+
+    const sizePerOutput =
+      (outputScripts[0]
+        ? utils.maxTxSize(0, [outputScripts[0]], false, this.crypto, this.derivationMode)
+        : utils.maxTxSize(0, [], true, this.crypto, this.derivationMode)) - emptyTxSize;
+
+    let total = new BigNumber(0);
+    const unspentUtxoSelected: Output[] = [];
+
+    const amount = outputs.reduce((sum, output) => sum.plus(output.value), new BigNumber(0));
+    let i = 0;
+    while (total.lt(amount.plus(fee))) {
+      if (!unspentUtxos[i]) {
+        throw new NotEnoughBalance();
+      }
+      total = total.plus(unspentUtxos[i].value);
+      unspentUtxoSelected.push(unspentUtxos[i]);
+      fee += sizePerInput * feePerByte;
+      i += 1;
+    }
+
+    if (total.minus(amount.plus(fee)).lt(sizePerOutput * feePerByte)) {
+      // not enough fund to make a change output
+      return {
+        totalValue: total,
+        unspentUtxos: unspentUtxoSelected,
+        fee: Math.ceil(fee),
+        needChangeoutput: false,
+      };
+    }
+    fee += sizePerOutput * feePerByte; // fee to make a change output
+    return {
+      totalValue: total,
+      unspentUtxos: unspentUtxoSelected,
+      fee: Math.ceil(fee),
+      needChangeoutput: true,
+    };
+  }
+}