@ledgerhq/live-common 21.5.1-btcjs.3 → 21.7.1

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

@@ -1,229 +0,0 @@
-import BigNumber from "bignumber.js";
-import { flatten, sortBy } from "lodash";
-import { NotEnoughBalance } from "@ledgerhq/errors";
-import { Output } from "../storage/types";
-import Xpub from "../xpub";
-import { PickingStrategy } from "./types";
-import * as utils from "../utils";
-import { Merge } from "./Merge";
-
-export class CoinSelect extends PickingStrategy {
-  // eslint-disable-next-line class-methods-use-this
-  async selectUnspentUtxosToUse(
-    xpub: Xpub,
-    amount: BigNumber,
-    feePerByte: number,
-    nbOutputsWithoutChange: number
-  ) {
-    // get the utxos to use as input
-    // from all addresses of the account
-    const addresses = await xpub.getXpubAddresses();
-
-    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
-    );
-
-    /*
-     * This coin selection is inspired from the one used in Bitcoin Core
-     * for more details please refer to SelectCoinsBnB
-     * https://github.com/bitcoin/bitcoin/blob/0c5f67b8e5d9a502c6d321c5e0696bc3e9b4690d/src/wallet/coinselection.cpp
-     * A coin selection is considered valid if its total value is within the range : [targetAmount, targetAmount + costOfChange]
-     */
-    // refer to https://github.com/LedgerHQ/lib-ledger-core/blob/master/core/src/wallet/bitcoin/transaction_builders/BitcoinLikeStrategyUtxoPicker.cpp#L168
-    const TOTAL_TRIES = 100000;
-    const longTermFees = 20;
-
-    // Compute cost of change
-    const fixedSize = utils.estimateTxSize(
-      0,
-      0,
-      this.crypto,
-      this.derivationMode
-    );
-    // Size of only 1 output (without fixed size)
-    const oneOutputSize =
-      utils.estimateTxSize(0, 1, this.crypto, this.derivationMode) - fixedSize;
-    // Size 1 signed UTXO (signed input)
-    const signedUTXOSize =
-      utils.estimateTxSize(1, 0, this.crypto, this.derivationMode) - fixedSize;
-
-    // Size of unsigned change
-    const changeSize = oneOutputSize;
-    // Size of signed change
-    const signedChangeSize = signedUTXOSize;
-
-    const effectiveFees = feePerByte;
-    // Here signedChangeSize should be multiplied by discard fees
-    // but since we don't have access to estimateSmartFees, we assume
-    // that discard fees are equal to effectiveFees
-    const costOfChange = effectiveFees * (signedChangeSize + changeSize);
-
-    // Calculate effective value of outputs
-    let currentAvailableValue = 0;
-    let effectiveUtxos: Array<{
-      index: number;
-      effectiveFees: number;
-      longTermFees: number;
-      effectiveValue: number;
-    }> = [];
-
-    for (let i = 0; i < unspentUtxos.length; i += 1) {
-      const outEffectiveValue =
-        Number(unspentUtxos[i].value) - effectiveFees * signedUTXOSize;
-      if (outEffectiveValue > 0) {
-        const outEffectiveFees = effectiveFees * signedUTXOSize;
-        const outLongTermFees = longTermFees * signedUTXOSize;
-        const effectiveUtxo = {
-          index: i,
-          effectiveFees: outEffectiveFees,
-          longTermFees: outLongTermFees,
-          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 =
-      effectiveFees * (fixedSize + oneOutputSize * nbOutputsWithoutChange); // at least fixed size and outputs(version...)
-
-    // Start coin selection algorithm (according to SelectCoinBnb from Bitcoin Core)
-    let currentValue = 0;
-    // std::vector<bool> currentSelection;
-    // currentSelection.reserve(utxos.size());
-    const currentSelection: boolean[] = [];
-
-    // Actual amount we are targetting
-    const actualTarget = notInputFees + amount.toNumber();
-
-    // Insufficient funds
-    if (currentAvailableValue < actualTarget) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      throw new (NotEnoughBalance as any)();
-    }
-    // Sort utxos by effectiveValue
-    effectiveUtxos = sortBy(effectiveUtxos, "effectiveValue");
-    effectiveUtxos = effectiveUtxos.reverse();
-
-    let currentWaste = 0;
-    let bestWaste = Number.MAX_SAFE_INTEGER;
-    let bestSelection: boolean[] = [];
-
-    // Deep first search loop to choose UTXOs
-    for (let i = 0; i < TOTAL_TRIES; i += 1) {
-      // Condition for starting a backtrack
-      let backtrack = false;
-      if (
-        currentValue + currentAvailableValue < actualTarget || // Cannot reach target with the amount remaining in currentAvailableValue
-        currentValue > actualTarget + costOfChange || // Selected value is out of range, go back and try other branch
-        (currentWaste > bestWaste &&
-          effectiveUtxos[0].effectiveFees - effectiveUtxos[0].longTermFees > 0)
-      ) {
-        // avoid selecting utxos producing more waste
-        backtrack = true;
-      } else if (currentValue >= actualTarget) {
-        // Selected valued is within range
-        currentWaste += currentValue - actualTarget;
-        if (currentWaste <= bestWaste) {
-          bestSelection = currentSelection.slice();
-          while (effectiveUtxos.length > bestSelection.length) {
-            bestSelection.push(false);
-          }
-          bestSelection.length = effectiveUtxos.length;
-          bestWaste = currentWaste;
-        }
-        // remove the excess value as we will be selecting different coins now
-        currentWaste -= currentValue - actualTarget;
-        backtrack = true;
-      }
-      // Move backwards
-      if (backtrack) {
-        // Walk backwards to find the last included UTXO that still needs to have its omission branch traversed.
-        while (
-          currentSelection.length > 0 &&
-          !currentSelection[currentSelection.length - 1]
-        ) {
-          currentSelection.pop();
-          currentAvailableValue +=
-            effectiveUtxos[currentSelection.length].effectiveValue;
-        }
-
-        // Case we walked back to the first utxos and all solutions searched.
-        if (currentSelection.length === 0) {
-          break;
-        }
-
-        // Output was included on previous iterations, try excluding now
-        currentSelection[currentSelection.length - 1] = false;
-        const eu = effectiveUtxos[currentSelection.length - 1];
-        currentValue -= eu.effectiveValue;
-        currentWaste -= eu.effectiveFees - eu.longTermFees;
-      } else {
-        // Moving forwards, continuing down this branch
-        const eu = effectiveUtxos[currentSelection.length];
-        // Remove this utxos from currentAvailableValue
-        currentAvailableValue -= eu.effectiveValue;
-
-        // Avoid searching a branch if the previous UTXO has the same value and same waste and was excluded. Since the ratio of fee to
-        // long term fee is the same, we only need to check if one of those values match in order to know that the waste is the same.
-        if (
-          currentSelection.length > 0 &&
-          !currentSelection[currentSelection.length - 1] &&
-          eu.effectiveValue ===
-            effectiveUtxos[currentSelection.length - 1].effectiveValue &&
-          eu.effectiveFees ===
-            effectiveUtxos[currentSelection.length - 1].effectiveFees
-        ) {
-          currentSelection.push(false);
-        } else {
-          // Inclusion branch first
-          currentSelection.push(true);
-          currentValue += eu.effectiveValue;
-          currentWaste += eu.effectiveFees - eu.longTermFees;
-        }
-      }
-    }
-    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 = utils.estimateTxSize(
-        unspentUtxoSelected.length,
-        nbOutputsWithoutChange,
-        this.crypto,
-        this.derivationMode
-      );
-      return {
-        totalValue: total,
-        unspentUtxos: unspentUtxoSelected,
-        fee: Math.ceil(fee),
-        needChangeoutput: false,
-      };
-    }
-    const pickingStrategy = new Merge(
-      this.crypto,
-      this.derivationMode,
-      this.excludedUTXOs
-    );
-    return pickingStrategy.selectUnspentUtxosToUse(
-      xpub,
-      amount,
-      feePerByte,
-      nbOutputsWithoutChange
-    );
-  }
-}

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

@@ -1,81 +0,0 @@
-import BigNumber from "bignumber.js";
-import { flatten, sortBy } from "lodash";
-import { NotEnoughBalance } from "@ledgerhq/errors";
-import { Output } from "../storage/types";
-import Xpub from "../xpub";
-import { PickingStrategy } from "./types";
-import * as utils from "../utils";
-
-export class DeepFirst extends PickingStrategy {
-  // eslint-disable-next-line class-methods-use-this
-  async selectUnspentUtxosToUse(
-    xpub: Xpub,
-    amount: BigNumber,
-    feePerByte: number,
-    nbOutputsWithoutChange: number
-  ) {
-    // get the utxos to use as input
-    // from all addresses of the account
-    const addresses = await xpub.getXpubAddresses();
-
-    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
-    );
-
-    unspentUtxos = sortBy(unspentUtxos, "block_height");
-    // https://metamug.com/article/security/bitcoin-transaction-fee-satoshi-per-byte.html
-    const txSizeNoInput = utils.estimateTxSize(
-      0,
-      nbOutputsWithoutChange,
-      this.crypto,
-      this.derivationMode
-    );
-    let fee = txSizeNoInput * feePerByte;
-    const sizePerInput =
-      utils.estimateTxSize(1, 0, this.crypto, this.derivationMode) -
-      utils.estimateTxSize(0, 0, this.crypto, this.derivationMode);
-
-    const sizePerOutput =
-      utils.estimateTxSize(0, 1, this.crypto, this.derivationMode) -
-      utils.estimateTxSize(0, 0, this.crypto, this.derivationMode);
-
-    let total = new BigNumber(0);
-    const unspentUtxoSelected: Output[] = [];
-
-    let i = 0;
-    while (total.lt(amount.plus(fee))) {
-      if (!unspentUtxos[i]) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        throw new (NotEnoughBalance as any)();
-      }
-      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,
-    };
-  }
-}

package/src/families/bitcoin/wallet-btc/pickingstrategies/Merge.ts

@@ -1,81 +0,0 @@
-import BigNumber from "bignumber.js";
-import { flatten, sortBy } from "lodash";
-import { NotEnoughBalance } from "@ledgerhq/errors";
-import { Output } from "../storage/types";
-import Xpub from "../xpub";
-import { PickingStrategy } from "./types";
-import * as utils from "../utils";
-
-export class Merge extends PickingStrategy {
-  // eslint-disable-next-line class-methods-use-this
-  async selectUnspentUtxosToUse(
-    xpub: Xpub,
-    amount: BigNumber,
-    feePerByte: number,
-    nbOutputsWithoutChange: number
-  ) {
-    // get the utxos to use as input
-    // from all addresses of the account
-    const addresses = await xpub.getXpubAddresses();
-
-    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 sizePerInput =
-      utils.estimateTxSize(1, 0, this.crypto, this.derivationMode) -
-      utils.estimateTxSize(0, 0, this.crypto, this.derivationMode);
-
-    const sizePerOutput =
-      utils.estimateTxSize(0, 1, this.crypto, this.derivationMode) -
-      utils.estimateTxSize(0, 0, this.crypto, this.derivationMode);
-
-    unspentUtxos = sortBy(unspentUtxos, "value");
-    // https://metamug.com/article/security/bitcoin-transaction-fee-satoshi-per-byte.html
-    const txSizeNoInput = utils.estimateTxSize(
-      0,
-      nbOutputsWithoutChange,
-      this.crypto,
-      this.derivationMode
-    );
-    let fee = txSizeNoInput * feePerByte;
-
-    let total = new BigNumber(0);
-    const unspentUtxoSelected: Output[] = [];
-
-    let i = 0;
-    while (total.lt(amount.plus(fee))) {
-      if (!unspentUtxos[i]) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        throw new (NotEnoughBalance as any)();
-      }
-      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,
-    };
-  }
-}

package/src/families/bitcoin/wallet-btc/pickingstrategies/types.ts

@@ -1,41 +0,0 @@
-import BigNumber from "bignumber.js";
-import { ICrypto } from "../crypto/types";
-import { Output } from "../storage/types";
-import Xpub from "../xpub";
-
-export abstract class PickingStrategy {
-  crypto: ICrypto;
-
-  derivationMode: string;
-
-  // TODO Write tests for excluded UTXOs
-  excludedUTXOs: Array<{
-    hash: string;
-    outputIndex: number;
-  }>;
-
-  constructor(
-    crypto: ICrypto,
-    derivationMode: string,
-    excludedUTXOs: Array<{
-      hash: string;
-      outputIndex: number;
-    }>
-  ) {
-    this.crypto = crypto;
-    this.derivationMode = derivationMode;
-    this.excludedUTXOs = excludedUTXOs;
-  }
-
-  abstract selectUnspentUtxosToUse(
-    xpub: Xpub,
-    amount: BigNumber,
-    feePerByte: number,
-    nbOutputsWithoutChange: number
-  ): Promise<{
-    unspentUtxos: Output[];
-    totalValue: BigNumber;
-    fee: number;
-    needChangeoutput: boolean;
-  }>;
-}

package/src/families/bitcoin/wallet-btc/storage/index.ts

@@ -1,186 +0,0 @@
-import { findLast, filter, uniqBy, findIndex, has } from "lodash";
-import { Input, IStorage, Output, TX, Address } from "./types";
-
-// a mock storage class that just use js objects
-// sql.js would be perfect for the job
-class Mock implements IStorage {
-  txs: TX[] = [];
-
-  // indexes
-  primaryIndex: { [key: string]: number } = {};
-
-  // accounting
-  unspentUtxos: { [key: string]: Output[] } = {};
-
-  // only needed to handle the case when the input
-  // is seen before the output (typically explorer
-  // returning unordered tx within the same block)
-  spentUtxos: { [key: string]: Input[] } = {};
-
-  async getLastTx(txFilter: {
-    account?: number;
-    index?: number;
-    address?: string;
-    confirmed?: boolean;
-  }) {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    const tx: TX | undefined = findLast(this.txs, (t) => {
-      return (
-        (!has(txFilter, "account") || t.account === txFilter.account) &&
-        (!has(txFilter, "index") || t.index === txFilter.index) &&
-        (!has(txFilter, "address") || t.address === txFilter.address) &&
-        (!has(txFilter, "confirmed") ||
-          (txFilter.confirmed && t.block) ||
-          (!txFilter.confirmed && !t.block))
-      );
-    });
-    return tx;
-  }
-
-  async getTx(address: string, hash: string) {
-    const index = `${address}-${hash}`;
-    return this.txs[this.primaryIndex[index]];
-  }
-
-  // TODO: only expose unspentUtxos
-  async getAddressUnspentUtxos(address: Address) {
-    const indexAddress = address.address;
-    return this.unspentUtxos[indexAddress];
-  }
-
-  async appendTxs(txs: TX[]) {
-    const lastLength = this.txs.length;
-
-    txs.forEach((tx) => {
-      const indexAddress = tx.address;
-      const index = `${indexAddress}-${tx.hash}`;
-
-      // we reject already seen tx
-      if (this.txs[this.primaryIndex[index]]) {
-        return;
-      }
-
-      this.primaryIndex[index] = this.txs.push(tx) - 1;
-      this.unspentUtxos[indexAddress] = this.unspentUtxos[indexAddress] || [];
-      this.spentUtxos[indexAddress] = this.spentUtxos[indexAddress] || [];
-
-      tx.outputs.forEach((output) => {
-        if (output.address === tx.address) {
-          this.unspentUtxos[indexAddress].push(output);
-        }
-      });
-
-      tx.inputs.forEach((input) => {
-        if (input.address === tx.address) {
-          this.spentUtxos[indexAddress].push(input);
-        }
-      });
-
-      this.unspentUtxos[indexAddress] = this.unspentUtxos[indexAddress].filter(
-        (output) => {
-          const matchIndex = findIndex(
-            this.spentUtxos[indexAddress],
-            (input: Input) =>
-              input.output_hash === output.output_hash &&
-              input.output_index === output.output_index
-          );
-          if (matchIndex > -1) {
-            this.spentUtxos[indexAddress].splice(matchIndex, 1);
-            return false;
-          }
-          return true;
-        }
-      );
-    });
-
-    return this.txs.length - lastLength;
-  }
-
-  async getUniquesAddresses(addressesFilter: {
-    account?: number;
-    index?: number;
-  }) {
-    // TODO: to speed up, create more useful indexes in appendTxs
-    return uniqBy(
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      filter(this.txs, addressesFilter).map((tx: TX) => ({
-        address: tx.address,
-        account: tx.account,
-        index: tx.index,
-      })),
-      "address"
-    );
-  }
-
-  async removeTxs(txsFilter: { account: number; index: number }) {
-    const newTxs: TX[] = [];
-
-    this.txs.forEach((tx: TX) => {
-      if (tx.account !== txsFilter.account || tx.index !== txsFilter.index) {
-        newTxs.push(tx);
-        return;
-      }
-
-      // clean
-      const indexAddress = tx.address;
-      const index = `${indexAddress}-${tx.hash}`;
-
-      delete this.primaryIndex[index];
-      delete this.unspentUtxos[indexAddress];
-      delete this.spentUtxos[indexAddress];
-    });
-
-    this.txs = newTxs;
-  }
-
-  // We are a bit ugly because we can't rely undo unspentUTXO
-  // So we clean the address and rebuild without the pendings
-  async removePendingTxs(txsFilter: { account: number; index: number }) {
-    const newTxs: TX[] = [];
-    const txsToReAdd: TX[] = [];
-
-    this.txs.forEach((tx: TX) => {
-      if (tx.account !== txsFilter.account || tx.index !== txsFilter.index) {
-        newTxs.push(tx);
-        return;
-      }
-
-      if (tx.block) {
-        txsToReAdd.push(tx);
-      }
-
-      // clean
-      const indexAddress = tx.address;
-      const index = `${indexAddress}-${tx.hash}`;
-
-      delete this.primaryIndex[index];
-      delete this.unspentUtxos[indexAddress];
-      delete this.spentUtxos[indexAddress];
-    });
-
-    this.txs = newTxs;
-    await this.appendTxs(txsToReAdd);
-  }
-
-  async export() {
-    return {
-      txs: this.txs,
-      primaryIndex: this.primaryIndex,
-      unspentUtxos: this.unspentUtxos,
-    };
-  }
-
-  async load(data: {
-    txs: TX[];
-    primaryIndex: { [key: string]: number };
-    unspentUtxos: { [key: string]: Output[] };
-  }) {
-    this.txs = data.txs;
-    this.primaryIndex = data.primaryIndex;
-    this.unspentUtxos = data.unspentUtxos;
-  }
-}
-
-export default Mock;