@leather.io/bitcoin 0.36.6 → 0.37.1

package/src/coin-selection/coin-selection.utils.spec.ts

@@ -1,8 +1,17 @@
 import { createMoney } from '@leather.io/utils';
 
 import { recipientAddress } from '../mocks/mocks';
-import { mockUtxos } from './coin-selection.mocks';
-import { filterUneconomicalUtxos } from './coin-selection.utils';
+import {
+  generateMockTaprootTransactions,
+  generateMockTransactions,
+  mockTaprootUtxos,
+  mockUtxos,
+} from './coin-selection.mocks';
+import {
+  countInputsByScriptType,
+  filterUneconomicalUtxos,
+  getSpendableAmount,
+} from './coin-selection.utils';
 
 describe(filterUneconomicalUtxos.name, () => {
   const recipients = [
@@ -62,4 +71,106 @@ describe(filterUneconomicalUtxos.name, () => {
     });
     expect(filteredUtxos.length).toEqual(2);
   });
+
+  describe('with taproot utxos', () => {
+    test('that every surviving taproot utxo increases spendable amount', () => {
+      const feeRate = 200;
+      const survivors = filterUneconomicalUtxos({
+        utxos: mockTaprootUtxos,
+        feeRate,
+        recipients,
+      });
+
+      const { spendableAmount: fullAmount } = getSpendableAmount({
+        utxos: mockTaprootUtxos,
+        feeRate,
+        recipients,
+      });
+
+      for (const utxo of survivors) {
+        const { spendableAmount: withoutUtxo } = getSpendableAmount({
+          utxos: mockTaprootUtxos.filter(u => u.txid !== utxo.txid),
+          feeRate,
+          recipients,
+        });
+        expect(fullAmount.toNumber()).toBeGreaterThan(withoutUtxo.toNumber());
+      }
+    });
+
+    test('that every filtered taproot utxo does not increase spendable amount', () => {
+      const feeRate = 200;
+      const survivors = filterUneconomicalUtxos({
+        utxos: mockTaprootUtxos,
+        feeRate,
+        recipients,
+      });
+      const filtered = mockTaprootUtxos.filter(u => !survivors.some(s => s.txid === u.txid));
+
+      expect(filtered.length).toBeGreaterThan(0);
+
+      const { spendableAmount: fullAmount } = getSpendableAmount({
+        utxos: mockTaprootUtxos,
+        feeRate,
+        recipients,
+      });
+
+      for (const utxo of filtered) {
+        const { spendableAmount: withoutUtxo } = getSpendableAmount({
+          utxos: mockTaprootUtxos.filter(u => u.txid !== utxo.txid),
+          feeRate,
+          recipients,
+        });
+        expect(withoutUtxo.toNumber()).toBeGreaterThanOrEqual(fullAmount.toNumber());
+      }
+    });
+
+    test('that taproot inputs are cheaper so more survive than native segwit', () => {
+      const feeRate = 10;
+      const segwitResult = filterUneconomicalUtxos({
+        utxos: mockUtxos,
+        feeRate,
+        recipients,
+      });
+      const taprootResult = filterUneconomicalUtxos({
+        utxos: mockTaprootUtxos,
+        feeRate,
+        recipients,
+      });
+
+      expect(taprootResult.length).toBeGreaterThan(segwitResult.length);
+    });
+
+    test('that taproot utxo below dust threshold is filtered even at low fee rate', () => {
+      const utxosWithDust = generateMockTaprootTransactions([200, 50000000]);
+      const result = filterUneconomicalUtxos({
+        utxos: utxosWithDust,
+        feeRate: 1,
+        recipients,
+      });
+
+      expect(result.length).toEqual(1);
+      expect(result[0].value).toEqual(50000000);
+    });
+  });
+});
+
+describe(countInputsByScriptType.name, () => {
+  test('all native segwit utxos', () => {
+    const result = countInputsByScriptType(mockUtxos);
+    expect(result).toEqual({ p2wpkh: 9, p2tr: 0 });
+  });
+
+  test('all taproot utxos', () => {
+    const result = countInputsByScriptType(mockTaprootUtxos);
+    expect(result).toEqual({ p2wpkh: 0, p2tr: 9 });
+  });
+
+  test('mixed utxos', () => {
+    const mixed = [
+      ...generateMockTransactions([1000, 2000]),
+      ...generateMockTaprootTransactions([3000, 4000, 5000]),
+    ];
+    const result = countInputsByScriptType(mixed);
+    expect(result).toEqual({ p2wpkh: 2, p2tr: 3 });
+  });
 });

package/src/coin-selection/coin-selection.utils.ts

@@ -5,18 +5,45 @@ import { BTC_P2WPKH_DUST_AMOUNT } from '@leather.io/constants';
 import { sumNumbers } from '@leather.io/utils';
 
 import { BtcSizeFeeEstimator } from '../fees/btc-size-fee-estimator';
+import { inferPaymentTypeFromAddress } from '../utils/bitcoin.utils';
+import { createBitcoinAddress } from '../validation/bitcoin-address';
 import { CoinSelectionRecipient } from './coin-selection';
 
-export function getUtxoTotal<T extends { value: number }>(utxos: T[]) {
+export interface InputData {
+  value: number;
+  txid: string;
+  address: string;
+}
+
+export function getUtxoTotal<T extends InputData>(utxos: T[]) {
   return sumNumbers(utxos.map(utxo => utxo.value));
 }
 
-export function getSizeInfo(payload: {
-  inputLength: number;
+interface CountInputsByScriptTypeResponse {
+  p2wpkh: number;
+  p2tr: number;
+}
+export function countInputsByScriptType<T extends InputData>(
+  utxos: T[]
+): CountInputsByScriptTypeResponse {
+  return utxos.reduce(
+    (acc, utxo) => {
+      const paymentType = inferPaymentTypeFromAddress(createBitcoinAddress(utxo.address));
+      return {
+        ...acc,
+        [paymentType]: acc[paymentType] + 1,
+      };
+    },
+    { p2tr: 0, p2wpkh: 0 }
+  );
+}
+
+export function getSizeInfo<T extends InputData>(payload: {
+  utxos: T[];
   recipients: CoinSelectionRecipient[];
   isSendMax?: boolean;
 }) {
-  const { inputLength, recipients, isSendMax } = payload;
+  const { utxos, recipients, isSendMax } = payload;
 
   const validAddressesInfo = recipients
     .map(recipient => validate(recipient.address) && getAddressInfo(recipient.address))
@@ -48,31 +75,34 @@ export function getSizeInfo(payload: {
     {} as Record<string, number>
   );
 
+  const { p2wpkh, p2tr } = countInputsByScriptType(utxos);
   const txSizer = new BtcSizeFeeEstimator();
-  const sizeInfo = txSizer.calcTxSize({
-    input_script: 'p2wpkh',
-    input_count: inputLength,
+
+  return txSizer.calcMixedInputTxSize({
+    p2wpkh_input_count: p2wpkh,
+    p2tr_input_count: p2tr,
     ...outputsData,
   });
-
-  return sizeInfo;
 }
+
 interface GetSpendableAmountArgs<T> {
   utxos: T[];
   feeRate: number;
   recipients: CoinSelectionRecipient[];
   isSendMax?: boolean;
 }
-export function getSpendableAmount<T extends { value: number }>({
+export function getSpendableAmount<T extends InputData>({
   utxos,
   feeRate,
   recipients,
+  isSendMax,
 }: GetSpendableAmountArgs<T>) {
   const balance = utxos.map(utxo => utxo.value).reduce((prevVal, curVal) => prevVal + curVal, 0);
 
   const size = getSizeInfo({
-    inputLength: utxos.length,
+    utxos,
     recipients,
+    isSendMax,
   });
   const fee = Math.ceil(size.txVBytes * feeRate);
   const bigNumberBalance = BigNumber(balance);
@@ -83,7 +113,7 @@ export function getSpendableAmount<T extends { value: number }>({
 }
 
 // Check if the spendable amount drops when adding a utxo
-export function filterUneconomicalUtxos<T extends { value: number; txid: string }>({
+export function filterUneconomicalUtxos<T extends InputData>({
   utxos,
   feeRate,
   recipients,

package/src/fees/bitcoin-fees.spec.ts

@@ -13,7 +13,7 @@ describe('getBitcoinTransactionFee', () => {
       recipients: [{ address: recipientAddress, amount: createMoney(1000, 'BTC') }],
       utxos: [
         {
-          address: taprootAddress,
+          address: recipientAddress,
           txid: '8192e8e20088c5f052fc7351b86b8f60a9454937860b281227e53e19f3e9c3f6',
           vout: 0,
           value: 2000,
@@ -32,7 +32,7 @@ describe('getBitcoinTransactionFee', () => {
       recipients: [{ address: recipientAddress, amount: createMoney(2000, 'BTC') }],
       utxos: [
         {
-          address: taprootAddress,
+          address: recipientAddress,
           txid: '8192e8e20088c5f052fc7351b86b8f60a9454937860b281227e53e19f3e9c3f6',
           vout: 0,
           value: 2000,
@@ -56,6 +56,74 @@ describe('getBitcoinTransactionFee', () => {
   });
 });
 
+describe('getBitcoinTransactionFee with taproot', () => {
+  const mockTxid = '8192e8e20088c5f052fc7351b86b8f60a9454937860b281227e53e19f3e9c3f6';
+  const defaultRecipients = [{ address: recipientAddress, amount: createMoney(1000, 'BTC') }];
+
+  it('should return a lower fee for a taproot UTXO than native segwit', () => {
+    const segwitFee = getBitcoinTransactionFee({
+      recipients: defaultRecipients,
+      utxos: [{ address: recipientAddress, txid: mockTxid, value: 2000 }],
+      feeRate: 1,
+    });
+    const taprootFee = getBitcoinTransactionFee({
+      recipients: defaultRecipients,
+      utxos: [{ address: taprootAddress, txid: mockTxid, value: 2000 }],
+      feeRate: 1,
+    });
+
+    expect(segwitFee).not.toBeNull();
+    expect(taprootFee).not.toBeNull();
+    expect(taprootFee!.amount.toNumber()).toBeLessThan(segwitFee!.amount.toNumber());
+  });
+
+  it('should return a lower fee for taproot max send than native segwit', () => {
+    const maxSendRecipients = [{ address: recipientAddress, amount: createMoney(2000, 'BTC') }];
+
+    const segwitFee = getBitcoinTransactionFee({
+      isSendingMax: true,
+      recipients: maxSendRecipients,
+      utxos: [{ address: recipientAddress, txid: mockTxid, value: 2000 }],
+      feeRate: 2,
+    });
+    const taprootFee = getBitcoinTransactionFee({
+      isSendingMax: true,
+      recipients: maxSendRecipients,
+      utxos: [{ address: taprootAddress, txid: mockTxid, value: 2000 }],
+      feeRate: 2,
+    });
+
+    expect(segwitFee).not.toBeNull();
+    expect(taprootFee).not.toBeNull();
+    expect(taprootFee!.amount.toNumber()).toBeLessThan(segwitFee!.amount.toNumber());
+  });
+
+  it('should return a lower fee for mixed UTXOs than all native segwit', () => {
+    const mixedRecipients = [{ address: recipientAddress, amount: createMoney(15000, 'BTC') }];
+
+    const allSegwitFee = getBitcoinTransactionFee({
+      recipients: mixedRecipients,
+      utxos: [
+        { address: recipientAddress, txid: mockTxid, value: 10000 },
+        { address: recipientAddress, txid: mockTxid, value: 10000 },
+      ],
+      feeRate: 1,
+    });
+    const mixedFee = getBitcoinTransactionFee({
+      recipients: mixedRecipients,
+      utxos: [
+        { address: recipientAddress, txid: mockTxid, value: 10000 },
+        { address: taprootAddress, txid: mockTxid, value: 10000 },
+      ],
+      feeRate: 1,
+    });
+
+    expect(allSegwitFee).not.toBeNull();
+    expect(mixedFee).not.toBeNull();
+    expect(mixedFee!.amount.toNumber()).toBeLessThan(allSegwitFee!.amount.toNumber());
+  });
+});
+
 describe('getBitcoinFees', () => {
   it('should return the fees for different fee rates', () => {
     const feeRates: AverageBitcoinFeeRates = {
@@ -68,7 +136,7 @@ describe('getBitcoinFees', () => {
     ];
     const utxos = [
       {
-        address: taprootAddress,
+        address: recipientAddress,
         txid: '8192e8e20088c5f052fc7351b86b8f60a9454937860b281227e53e19f3e9c3f6',
         vout: 0,
         value: 2000,

package/src/fees/bitcoin-fees.ts

@@ -1,3 +1,5 @@
+import type { InputData } from 'coin-selection/coin-selection.utils';
+
 import { AverageBitcoinFeeRates, Money } from '@leather.io/models';
 
 import {
@@ -7,7 +9,7 @@ import {
   determineUtxosForSpendAll,
 } from '../coin-selection/coin-selection';
 
-type GetBitcoinTransactionFeeArgs = DetermineUtxosForSpendArgs<{ value: number; txid: string }> & {
+type GetBitcoinTransactionFeeArgs = DetermineUtxosForSpendArgs<InputData> & {
   isSendingMax?: boolean;
 };
 
@@ -33,7 +35,7 @@ export interface GetBitcoinFeesArgs {
   feeRates: AverageBitcoinFeeRates;
   isSendingMax?: boolean;
   recipients: CoinSelectionRecipient[];
-  utxos: { value: number; txid: string }[];
+  utxos: InputData[];
 }
 export function getBitcoinFees({ feeRates, isSendingMax, recipients, utxos }: GetBitcoinFeesArgs) {
   const defaultArgs = {

package/src/fees/btc-size-fee-estimator.spec.ts

@@ -110,4 +110,78 @@ describe('BtcSizeFeeEstimator', () => {
       expect(feeRange).toBe('900 - 1100');
     });
   });
+
+  describe('calcMixedInputTxSize', () => {
+    it('should calculate size for p2wpkh-only inputs', () => {
+      const { txVBytes, txBytes, txWeight } = estimator.calcMixedInputTxSize({
+        p2wpkh_input_count: 2,
+        p2tr_input_count: 0,
+        p2wpkh_output_count: 1,
+      });
+
+      // overhead: 10.75, inputs: 2 * 67.75 = 135.5, outputs: 1 * 31 = 31
+      expect(txVBytes).toEqual(177.25);
+      // extraRawBytes: 2.25, witnessBytes: 2 * 107 = 214
+      expect(txBytes).toEqual(393.5);
+      expect(txWeight).toEqual(709);
+    });
+
+    it('should calculate size for p2tr-only inputs', () => {
+      const { txVBytes, txBytes, txWeight } = estimator.calcMixedInputTxSize({
+        p2wpkh_input_count: 0,
+        p2tr_input_count: 2,
+        p2tr_output_count: 1,
+      });
+
+      // overhead: 10.75, inputs: 2 * 57.25 = 114.5, outputs: 1 * 43 = 43
+      expect(txVBytes).toEqual(168.25);
+      // extraRawBytes: 2.25, witnessBytes: 2 * 65 = 130
+      expect(txBytes).toEqual(300.5);
+      expect(txWeight).toEqual(673);
+    });
+
+    it('should calculate size for mixed p2wpkh and p2tr inputs', () => {
+      const { txVBytes, txBytes, txWeight } = estimator.calcMixedInputTxSize({
+        p2wpkh_input_count: 1,
+        p2tr_input_count: 1,
+        p2wpkh_output_count: 1,
+        p2tr_output_count: 1,
+      });
+
+      // overhead: 10.75, inputs: 1 * 67.75 + 1 * 57.25 = 125, outputs: 31 + 43 = 74
+      expect(txVBytes).toEqual(209.75);
+      // extraRawBytes: 2.25, witnessBytes: 107 + 65 = 172
+      expect(txBytes).toEqual(384);
+      expect(txWeight).toEqual(839);
+    });
+
+    it('should default optional output counts to zero', () => {
+      const { txVBytes } = estimator.calcMixedInputTxSize({
+        p2wpkh_input_count: 1,
+        p2tr_input_count: 0,
+      });
+
+      // overhead: 10.75, inputs: 1 * 67.75, outputs: 0
+      expect(txVBytes).toEqual(78.5);
+    });
+
+    it('should calculate size with multiple output types', () => {
+      const { txVBytes, txBytes, txWeight } = estimator.calcMixedInputTxSize({
+        p2wpkh_input_count: 2,
+        p2tr_input_count: 1,
+        p2pkh_output_count: 1,
+        p2sh_output_count: 1,
+        p2wpkh_output_count: 1,
+        p2tr_output_count: 1,
+      });
+
+      // overhead: getTxOverheadVBytes('p2wpkh', 3, 4) = 4 + 1 + 1 + 4 + 0.75 = 10.75
+      // inputs: 2 * 67.75 + 1 * 57.25 = 192.75
+      // outputs: 34 + 32 + 31 + 43 = 140
+      expect(txVBytes).toEqual(343.5);
+      // extraRawBytes: 2.25, witnessBytes: 2 * 107 + 1 * 65 = 279
+      expect(txBytes).toEqual(624.75);
+      expect(txWeight).toEqual(1374);
+    });
+  });
 });

package/src/fees/btc-size-fee-estimator.ts

@@ -26,6 +26,26 @@ export interface TxSizerParams {
   p2tr_output_count: number;
 }
 
+export interface MixedInputTxSizerParams {
+  p2wpkh_input_count: number;
+  p2tr_input_count: number;
+  p2pkh_input_count?: number;
+  p2sh_input_count?: number;
+  p2sh_p2wpkh_input_count?: number;
+  p2sh_p2wsh_input_count?: number;
+  p2wsh_input_count?: number;
+  input_m?: number;
+  input_n?: number;
+  p2pkh_output_count?: number;
+  p2sh_output_count?: number;
+  p2sh_p2wpkh_output_count?: number;
+  p2sh_p2wsh_output_count?: number;
+  p2wpkh_output_count?: number;
+  p2wsh_output_count?: number;
+  p2tr_output_count?: number;
+  _forceSegwit?: boolean;
+}
+
 export class BtcSizeFeeEstimator {
   P2PKH_IN_SIZE = 148;
   P2PKH_OUT_SIZE = 34;
@@ -310,6 +330,50 @@ export class BtcSizeFeeEstimator {
     return { txVBytes, txBytes, txWeight };
   }
 
+  calcMixedInputTxSize(opts: MixedInputTxSizerParams) {
+    const { p2wpkh_input_count, p2tr_input_count } = opts;
+    const totalInputCount = p2wpkh_input_count + p2tr_input_count;
+
+    const p2pkh_output_count = opts.p2pkh_output_count ?? 0;
+    const p2sh_output_count = opts.p2sh_output_count ?? 0;
+    const p2sh_p2wpkh_output_count = opts.p2sh_p2wpkh_output_count ?? 0;
+    const p2sh_p2wsh_output_count = opts.p2sh_p2wsh_output_count ?? 0;
+    const p2wpkh_output_count = opts.p2wpkh_output_count ?? 0;
+    const p2wsh_output_count = opts.p2wsh_output_count ?? 0;
+    const p2tr_output_count = opts.p2tr_output_count ?? 0;
+
+    const output_count =
+      p2pkh_output_count +
+      p2sh_output_count +
+      p2sh_p2wpkh_output_count +
+      p2sh_p2wsh_output_count +
+      p2wpkh_output_count +
+      p2wsh_output_count +
+      p2tr_output_count;
+
+    const inputVBytes =
+      p2wpkh_input_count * this.P2WPKH_IN_SIZE + p2tr_input_count * this.P2TR_IN_SIZE;
+
+    const inputWitnessBytes = p2wpkh_input_count * 107 + p2tr_input_count * 65;
+
+    const txVBytes =
+      this.getTxOverheadVBytes('p2wpkh', totalInputCount, output_count) +
+      inputVBytes +
+      this.P2PKH_OUT_SIZE * p2pkh_output_count +
+      this.P2SH_OUT_SIZE * p2sh_output_count +
+      this.P2SH_P2WPKH_OUT_SIZE * p2sh_p2wpkh_output_count +
+      this.P2SH_P2WSH_OUT_SIZE * p2sh_p2wsh_output_count +
+      this.P2WPKH_OUT_SIZE * p2wpkh_output_count +
+      this.P2WSH_OUT_SIZE * p2wsh_output_count +
+      this.P2TR_OUT_SIZE * p2tr_output_count;
+
+    const txBytes =
+      this.getTxOverheadExtraRawBytes('p2wpkh', totalInputCount) + txVBytes + inputWitnessBytes;
+    const txWeight = txVBytes * 4;
+
+    return { txVBytes, txBytes, txWeight };
+  }
+
   estimateFee(vbyte: number, satVb: number) {
     if (isNaN(vbyte) || isNaN(satVb)) {
       throw new Error('Parameters should be numbers');

package/src/index.ts

@@ -7,6 +7,7 @@ export * from './coin-selection/coin-selection';
 export * from './coin-selection/coin-selection.utils';
 
 export * from './fees/bitcoin-fees';
+export * from './fees/btc-size-fee-estimator';
 
 export * from './mocks/mocks';