@ledgerhq/live-common 21.16.1 → 21.16.2

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

@@ -6,14 +6,14 @@ import Xpub from "../xpub";
 import { PickingStrategy } from "./types";
 import * as utils from "../utils";
 import { log } from "@ledgerhq/logs";
+import { OutputInfo } from "..";
 
 export class Merge extends PickingStrategy {
   // eslint-disable-next-line class-methods-use-this
   async selectUnspentUtxosToUse(
     xpub: Xpub,
-    amount: BigNumber,
-    feePerByte: number,
-    nbOutputsWithoutChange: number
+    outputs: OutputInfo[],
+    feePerByte: number
   ) {
     // get the utxos to use as input
     // from all addresses of the account
@@ -31,19 +31,36 @@ export class Merge extends PickingStrategy {
         ).length
     );
 
+    const outputAddresses = outputs.map((o) => o.address);
+    const emptyTxSize = utils.maxTxSizeCeil(
+      0,
+      [],
+      false,
+      this.crypto,
+      this.derivationMode
+    );
     const sizePerInput =
-      utils.accurateTxSize(1, 0, this.crypto, this.derivationMode) -
-      utils.accurateTxSize(0, 0, this.crypto, this.derivationMode);
+      utils.maxTxSize(1, [], false, this.crypto, this.derivationMode) -
+      emptyTxSize;
 
     const sizePerOutput =
-      utils.accurateTxSize(0, 1, this.crypto, this.derivationMode) -
-      utils.accurateTxSize(0, 0, this.crypto, this.derivationMode);
+      (outputAddresses[0]
+        ? utils.maxTxSize(
+            0,
+            [outputAddresses[0]],
+            false,
+            this.crypto,
+            this.derivationMode
+          )
+        : utils.maxTxSize(0, [], true, this.crypto, this.derivationMode)) -
+      emptyTxSize;
 
     unspentUtxos = sortBy(unspentUtxos, (utxo) => parseInt(utxo.value, 10));
     // https://metamug.com/article/security/bitcoin-transaction-fee-satoshi-per-byte.html
-    const txSizeNoInput = utils.accurateTxSize(
+    const txSizeNoInput = utils.maxTxSize(
       0,
-      nbOutputsWithoutChange,
+      outputAddresses,
+      false,
       this.crypto,
       this.derivationMode
     );
@@ -53,6 +70,10 @@ export class Merge extends PickingStrategy {
     const unspentUtxoSelected: Output[] = [];
 
     let i = 0;
+    const amount = outputs.reduce(
+      (sum, output) => sum.plus(output.value),
+      new BigNumber(0)
+    );
     while (total.lt(amount.plus(fee))) {
       if (!unspentUtxos[i]) {
         throw new NotEnoughBalance();

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

@@ -1,4 +1,5 @@
 import BigNumber from "bignumber.js";
+import { OutputInfo } from "..";
 import { ICrypto } from "../crypto/types";
 import { Output } from "../storage/types";
 import Xpub from "../xpub";
@@ -29,9 +30,8 @@ export abstract class PickingStrategy {
 
   abstract selectUnspentUtxosToUse(
     xpub: Xpub,
-    amount: BigNumber,
-    feePerByte: number,
-    nbOutputsWithoutChange: number
+    outputs: OutputInfo[],
+    feePerByte: number
   ): Promise<{
     unspentUtxos: Output[];
     totalValue: BigNumber;

package/src/families/bitcoin/wallet-btc/utils.ts

@@ -6,6 +6,7 @@ import { DerivationModes } from "./types";
 import { Currency, ICrypto } from "./crypto/types";
 import cryptoFactory from "./crypto/factory";
 import { fallbackValidateAddress } from "./crypto/base";
+import { UnsupportedDerivation } from "../../../errors";
 
 export function parseHexString(str: any) {
   const result: Array<number> = [];
@@ -91,58 +92,129 @@ export function byteSize(count: number) {
   return 9;
 }
 
-// refer to https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/api_impl/BitcoinLikeTransactionApi.cpp#L217
-export function accurateTxSize(
-  inputCount: number,
-  outputCount: number,
-  currency: ICrypto,
-  derivationMode: string
-) {
-  let txSize = 0;
-  let fixedSize = 0;
-  // Fixed size computation
-  fixedSize = 4; // Transaction version
-  if (currency.network.usesTimestampedTransaction) fixedSize += 4; // Timestamp
-  fixedSize += byteSize(inputCount); // Number of inputs
-  fixedSize += byteSize(outputCount); // Number of outputs
-  fixedSize += 4; // Timelock
+const baseByte = 4;
+function fixedWeight(currency: ICrypto, derivationMode: string): number {
+  let fixedWeight = 4 * baseByte; // Transaction version
+  if (currency.network.usesTimestampedTransaction) fixedWeight += 4 * baseByte; // Timestamp
+  fixedWeight += 4 * baseByte; // Timelock
   if (derivationMode !== DerivationModes.LEGACY) {
-    fixedSize += 0.5; // Segwit marker & segwit flag
+    fixedWeight += 2; // Segwit marker & segwit flag, 1 WU per byte
   }
-  // refer to https://medium.com/coinmonks/on-bitcoin-transaction-sizes-part-2-9445373d17f4
-  // and https://bitcoin.stackexchange.com/questions/96017/what-are-the-sizes-of-single-sig-and-2-of-3-multisig-taproot-inputs
-  // and https://bitcoinops.org/en/tools/calc-size/
+  return fixedWeight;
+}
+
+function inputWeight(derivationMode: string): number {
+  let inputWeight = (32 + 4 + 1 + 4) * baseByte;
   if (derivationMode === DerivationModes.TAPROOT) {
-    txSize = fixedSize + 57.75 * inputCount + 43 * outputCount;
-    return txSize;
+    inputWeight += 1 + 1 + 65;
+  } else if (derivationMode === DerivationModes.NATIVE_SEGWIT) {
+    inputWeight += 1 + 1 + 72 + 1 + 33;
+  } else if (derivationMode === DerivationModes.SEGWIT) {
+    inputWeight += 22 * baseByte + 1 + 1 + 72 + 1 + 33;
+  } else if (derivationMode === DerivationModes.LEGACY) {
+    inputWeight += 107 * baseByte;
+  } else {
+    throw UnsupportedDerivation(`Derivation mode ${derivationMode} unknown`);
   }
-  const isSegwit =
-    derivationMode === DerivationModes.NATIVE_SEGWIT ||
-    derivationMode === DerivationModes.SEGWIT;
-  if (isSegwit) {
-    // Native Segwit: 32 PrevTxHash + 4 Index + 1 null byte + 4 sequence
-    // P2SH: 32 PrevTxHash + 4 Index + 23 scriptPubKey + 4 sequence
-    const isNativeSegwit = derivationMode === DerivationModes.NATIVE_SEGWIT;
-    const inputSize = isNativeSegwit ? 41 : 63;
-    const noWitness = fixedSize + inputSize * inputCount + 43 * outputCount; //43 is the biggest output(taproot output) size, we use the biggest one for safety
-    // Include flag and marker size (one byte each)
-    const witnessSize = noWitness + 108 * inputCount + 2;
-    txSize = (noWitness * 3 + witnessSize) / 4;
+  return inputWeight;
+}
+
+function outputWeight(derivationMode: string): number {
+  let outputSize = 8 + 1; // amount + script size
+  if (derivationMode === DerivationModes.TAPROOT) {
+    outputSize += 34; // "1" + PUSH32 + <32 bytes>
+  } else if (derivationMode === DerivationModes.NATIVE_SEGWIT) {
+    outputSize += 22; // "0" + PUSH20 + <20 bytes>
+  } else if (derivationMode === DerivationModes.SEGWIT) {
+    outputSize += 23; // HASH160 + PUSH20 + <20 bytes> + EQUAL
+  } else if (derivationMode === DerivationModes.LEGACY) {
+    outputSize += 25; // DUP + HASH160 + PUSH20 + <20 bytes> + EQUALVERIFY + CHECKSIG
   } else {
-    txSize = fixedSize + 148 * inputCount + 43 * outputCount;
+    throw UnsupportedDerivation(derivationMode);
   }
-  return txSize;
+  return outputSize * 4;
+}
+
+export function outputSize(currency: ICrypto, addr: string): number {
+  const scriptLen = currency.toOutputScript(addr).length;
+  return 1 + 8 + scriptLen;
 }
 
-export function estimateTxSize(
+/**
+ * Calculates the maximun size of an imaginary transaction in virtual bytes
+ * (vB). 1vB = 4 WU (weight units). If a cryptocurrency doesn't use segwit, then
+ * 1 byte = 1 vB. Weight units are used for segwit transactions, where certain
+ * bytes of the transaction is counted as 4 WU and some as 1 WU. The resulting
+ * size is then ceil(totalWU/4) vB.
+ *
+ * refer to https://medium.com/coinmonks/on-bitcoin-transaction-sizes-part-2-9445373d17f4
+ * and https://bitcoin.stackexchange.com/questions/96017/what-are-the-sizes-of-single-sig-and-2-of-3-multisig-taproot-inputs
+ * and https://bitcoinops.org/en/tools/calc-size/
+ *
+ * Suggested improvement: I assume that these calculations won't be exactly
+ * correct for altcoins (but I don't know). Therefore we should move this
+ * functionality into ICrypto, to make it easier to provide slightly different
+ * calculations for different cryptocurrencies.
+ *
+ * The reason for the name maxTxSize, instead of just txSize, is that the size
+ * of modern ecdsa signatures aren't know beforehand. They are either 71 or
+ * 72 bytes. This function always count with 72 byte signatures.
+ *
+ * The size of schnorr signatures is expected to be 65 bytes, since the Bitcoin
+ * hardware app appends the optional sighash type 01 at the end of the
+ * signature. If the app removes that optional byte, this functions should be
+ * updated to use 64 byte schnorr signatures, even if 65 still is an acceptable
+ * maximum.
+ *
+ * @param inputCount Number of inputs of the imaginary transaction
+ * @param outputAddrs The addresses of the outputs, excluding change.
+ * @param includeChange Indicates whether we should add a change output. The
+ * change output will have the same derivation mode as the inputs. See
+ * derivationMode parameter.
+ * @param currency The currency for which the calculation is done.
+ * @param derivationMode The derivation mode used for calculating the size of
+ * the inputs.
+ */
+export function maxTxSize(
   inputCount: number,
-  outputCount: number,
+  outputAddrs: string[],
+  includeChange: boolean,
   currency: ICrypto,
   derivationMode: string
-) {
-  return Math.ceil(
-    accurateTxSize(inputCount, outputCount, currency, derivationMode)
-  ); // We don't allow floating value
+): number {
+  const fixed = fixedWeight(currency, derivationMode);
+
+  let outputsWeight = byteSize(outputAddrs.length) * baseByte; // Number of outputs;
+  outputAddrs.forEach((addr) => {
+    outputsWeight += outputSize(currency, addr) * baseByte;
+  });
+  if (includeChange) {
+    outputsWeight += outputWeight(derivationMode);
+  }
+
+  // Input: 32 PrevTxHash + 4 Index + 1 scriptSigLength + 4 sequence
+  let inputsWeight = byteSize(inputCount) * baseByte; // Number of inputs
+  inputsWeight += inputWeight(derivationMode) * inputCount;
+
+  const txWeight = fixed + inputsWeight + outputsWeight;
+  return txWeight / 4;
+}
+
+export function maxTxSizeCeil(
+  inputCount: number,
+  outputAddrs: string[],
+  includeChange: boolean,
+  currency: ICrypto,
+  derivationMode: string
+): number {
+  const s = maxTxSize(
+    inputCount,
+    outputAddrs,
+    includeChange,
+    currency,
+    derivationMode
+  );
+  return Math.ceil(s);
 }
 
 // refer to https://github.com/LedgerHQ/lib-ledger-core/blob/fc9d762b83fc2b269d072b662065747a64ab2816/core/src/wallet/bitcoin/api_impl/BitcoinLikeTransactionApi.cpp#L253

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

@@ -122,7 +122,8 @@ class BitcoinLikeWallet {
     account: Account,
     feePerByte: number,
     excludeUTXOs: Array<{ hash: string; outputIndex: number }>,
-    pickUnconfirmedRBF: boolean
+    pickUnconfirmedRBF: boolean,
+    outputAddresses: string[] = []
   ) {
     const addresses = await account.xpub.getXpubAddresses();
     const utxos = flatten(
@@ -133,8 +134,8 @@ class BitcoinLikeWallet {
       )
     );
     let balance = new BigNumber(0);
-    let availableUtxoCount = 0;
     log("btcwallet", "estimateAccountMaxSpendable utxos", utxos);
+    let usableUtxoCount = 0;
     utxos.forEach((utxo) => {
       if (
         !excludeUTXOs.find(
@@ -144,20 +145,22 @@ class BitcoinLikeWallet {
         )
       ) {
         if ((pickUnconfirmedRBF && utxo.rbf) || utxo.block_height !== null) {
+          usableUtxoCount++;
           balance = balance.plus(utxo.value);
-          availableUtxoCount += 1;
         }
       }
     });
     // fees if we use all utxo
     const fees =
       feePerByte *
-      utils.estimateTxSize(
-        availableUtxoCount,
-        1,
+      utils.maxTxSizeCeil(
+        usableUtxoCount,
+        outputAddresses,
+        outputAddresses.length == 0,
         account.xpub.crypto,
         account.xpub.derivationMode
       );
+
     log("btcwallet", "estimateAccountMaxSpendable balance", balance);
     log("btcwallet", "estimateAccountMaxSpendable fees", fees);
     const maxSpendable = balance.minus(fees);

package/src/families/bitcoin/wallet-btc/xpub.ts

@@ -288,9 +288,8 @@ class Xpub extends EventEmitter {
       needChangeoutput,
     } = await params.utxoPickingStrategy.selectUnspentUtxosToUse(
       this,
-      params.amount,
-      params.feePerByte,
-      outputs.length
+      outputs,
+      params.feePerByte
     );
 
     const txHexs = await Promise.all(
@@ -320,9 +319,10 @@ class Xpub extends EventEmitter {
       (utxo, index) => [txs[index].account, txs[index].index]
     );
 
-    const txSize = utils.estimateTxSize(
+    const txSize = utils.maxTxSizeCeil(
       unspentUtxoSelected.length,
-      outputs.length + 1,
+      outputs.map((o) => o.address),
+      true,
       this.crypto,
       this.derivationMode
     );

package/src/operation.ts

@@ -167,5 +167,5 @@ export const isConfirmedOperation = (
   confirmationsNb: number
 ): boolean =>
   operation.blockHeight
-    ? account.blockHeight - operation.blockHeight + 1 > confirmationsNb
+    ? account.blockHeight - operation.blockHeight + 1 >= confirmationsNb
     : false;