@leather.io/bitcoin 0.37.0 → 0.37.2

package/package.json

@@ -2,7 +2,7 @@
   "name": "@leather.io/bitcoin",
   "author": "Leather.io contact@leather.io",
   "description": "Shared bitcoin utilities",
-  "version": "0.37.0",
+  "version": "0.37.2",
   "license": "MIT",
   "homepage": "https://github.com/leather.io/mono/tree/dev/packages/bitcoin",
   "repository": {
@@ -32,10 +32,10 @@
     "just-memoize": "2.2.0",
     "varuint-bitcoin": "1.1.2",
     "zod": "4.0.17",
-    "@leather.io/crypto": "1.12.17",
+    "@leather.io/constants": "0.34.0",
     "@leather.io/models": "0.54.0",
-    "@leather.io/utils": "0.50.0",
-    "@leather.io/constants": "0.32.0"
+    "@leather.io/utils": "0.51.0",
+    "@leather.io/crypto": "1.12.19"
   },
   "devDependencies": {
     "prettier": "3.5.1",
@@ -43,10 +43,10 @@
     "tslib": "2.6.2",
     "typescript": "5.9.3",
     "vitest": "2.1.9",
-    "@leather.io/test-config": "0.1.3",
-    "@leather.io/rpc": "2.21.11",
+    "@leather.io/prettier-config": "0.9.0",
+    "@leather.io/rpc": "2.21.13",
     "@leather.io/tsconfig-config": "0.11.1",
-    "@leather.io/prettier-config": "0.9.0"
+    "@leather.io/test-config": "0.1.3"
   },
   "keywords": [
     "bitcoin",

package/src/coin-selection/calculate-max-spend.spec.ts

@@ -1,16 +1,28 @@
+import { createMoney } from '@leather.io/utils';
+
+import { recipientAddress, taprootAddress } from '../mocks/mocks';
 import { createBitcoinAddress } from '../validation/bitcoin-address';
 import { calculateMaxSpend } from './calculate-max-spend';
-import { mockUtxos } from './coin-selection.mocks';
+import { mockTaprootUtxos, mockUtxos } from './coin-selection.mocks';
+import { getSizeInfo } from './coin-selection.utils';
 
 const recipient = createBitcoinAddress('');
 describe(calculateMaxSpend.name, () => {
+  test('that empty utxos returns zero', () => {
+    const result = calculateMaxSpend({ recipient: recipientAddress, utxos: [], feeRate: 1 });
+    expect(result.spendAllFee).toEqual(0);
+    expect(result.amount.amount.toNumber()).toEqual(0);
+    expect(result.spendableBitcoin.toNumber()).toEqual(0);
+  });
+
   test('with 1 sat/vb fee', () => {
     const maxBitcoinSpend = calculateMaxSpend({
       recipient,
       utxos: mockUtxos,
       feeRate: 1,
     });
-    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50087948);
+    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50087979);
+    expect(maxBitcoinSpend.spendAllFee).toEqual(621);
   });
 
   test('with 5 sat/vb fee', () => {
@@ -19,7 +31,8 @@ describe(calculateMaxSpend.name, () => {
       utxos: mockUtxos,
       feeRate: 5,
     });
-    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50085342);
+    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50085497);
+    expect(maxBitcoinSpend.spendAllFee).toEqual(3103);
   });
 
   test('with 30 sat/vb fee', () => {
@@ -28,7 +41,8 @@ describe(calculateMaxSpend.name, () => {
       utxos: mockUtxos,
       feeRate: 30,
     });
-    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50073585);
+    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50074515);
+    expect(maxBitcoinSpend.spendAllFee).toEqual(10485);
   });
 
   test('with 100 sat/vb fee', () => {
@@ -37,7 +51,8 @@ describe(calculateMaxSpend.name, () => {
       utxos: mockUtxos,
       feeRate: 100,
     });
-    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50046950);
+    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50050050);
+    expect(maxBitcoinSpend.spendAllFee).toEqual(34950);
   });
 
   test('with 400 sat/vb fee', () => {
@@ -46,6 +61,110 @@ describe(calculateMaxSpend.name, () => {
       utxos: mockUtxos,
       feeRate: 400,
     });
-    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(49969100);
+    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(49981500);
+    expect(maxBitcoinSpend.spendAllFee).toEqual(58500);
+  });
+
+  describe('with taproot UTXOs', () => {
+    const taprootRecipient = recipientAddress;
+
+    test('with 1 sat/vb fee', () => {
+      const result = calculateMaxSpend({
+        recipient: taprootRecipient,
+        utxos: mockTaprootUtxos,
+        feeRate: 1,
+      });
+      expect(result.amount.amount.toNumber()).toEqual(50088043);
+      expect(result.spendAllFee).toEqual(557);
+      expect(result.spendableBitcoin.toNumber()).toEqual(0.50088043);
+    });
+
+    test('with 5 sat/vb fee', () => {
+      const result = calculateMaxSpend({
+        recipient: taprootRecipient,
+        utxos: mockTaprootUtxos,
+        feeRate: 5,
+      });
+      expect(result.amount.amount.toNumber()).toEqual(50085815);
+      expect(result.spendAllFee).toEqual(2785);
+    });
+
+    test('with 30 sat/vb fee', () => {
+      const result = calculateMaxSpend({
+        recipient: taprootRecipient,
+        utxos: mockTaprootUtxos,
+        feeRate: 30,
+      });
+      expect(result.amount.amount.toNumber()).toEqual(50075160);
+      expect(result.spendAllFee).toEqual(9840);
+    });
+
+    test('with 100 sat/vb fee', () => {
+      const result = calculateMaxSpend({
+        recipient: taprootRecipient,
+        utxos: mockTaprootUtxos,
+        feeRate: 100,
+      });
+      expect(result.amount.amount.toNumber()).toEqual(50052200);
+      expect(result.spendAllFee).toEqual(32800);
+    });
+
+    test('with 400 sat/vb fee', () => {
+      const result = calculateMaxSpend({
+        recipient: taprootRecipient,
+        utxos: mockTaprootUtxos,
+        feeRate: 400,
+      });
+      expect(result.amount.amount.toNumber()).toEqual(49979600);
+      expect(result.spendAllFee).toEqual(85400);
+    });
+
+    test('taproot inputs have lower fees than native segwit at same fee rate', () => {
+      const segwitResult = calculateMaxSpend({
+        recipient: taprootRecipient,
+        utxos: mockUtxos,
+        feeRate: 30,
+      });
+      const taprootResult = calculateMaxSpend({
+        recipient: taprootRecipient,
+        utxos: mockTaprootUtxos,
+        feeRate: 30,
+      });
+      expect(taprootResult.spendAllFee).toBeLessThan(segwitResult.spendAllFee);
+    });
+  });
+
+  test('send-max fee should not include a change output', () => {
+    const feeRate = 10;
+    const utxos = mockTaprootUtxos;
+
+    const result = calculateMaxSpend({ recipient: recipientAddress, utxos, feeRate });
+
+    const correctSize = getSizeInfo({
+      utxos,
+      recipients: [{ address: recipientAddress, amount: createMoney(0, 'BTC') }],
+      isSendMax: true,
+    });
+    const correctFee = Math.ceil(correctSize.txVBytes * feeRate);
+
+    expect(result.spendAllFee).toEqual(correctFee);
+  });
+
+  describe('with taproot recipient', () => {
+    test('P2TR output costs more than P2WPKH output', () => {
+      const segwitRecipientResult = calculateMaxSpend({
+        recipient: recipientAddress,
+        utxos: mockUtxos,
+        feeRate: 30,
+      });
+      const taprootRecipientResult = calculateMaxSpend({
+        recipient: taprootAddress,
+        utxos: mockUtxos,
+        feeRate: 30,
+      });
+      expect(segwitRecipientResult.amount.amount.toNumber()).toEqual(50073585);
+      expect(taprootRecipientResult.amount.amount.toNumber()).toEqual(50073225);
+      expect(taprootRecipientResult.spendAllFee).toBeGreaterThan(segwitRecipientResult.spendAllFee);
+    });
   });
 });

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

@@ -240,6 +240,29 @@ describe(determineUtxosForSpend.name, () => {
     expect(result.fee.amount.isEqualTo(735)).toBeTruthy();
     expect(fee).toEqual(735);
   });
+
+  test('that spending all taproot utxos with sendMax produces lower fee than native segwit', () => {
+    const taprootUtxos = generateMockTaprootTransactions([1000, 2000, 3000]);
+    const segwitUtxos = generateMockTransactions([1000, 2000, 3000]);
+    const feeRate = 2;
+
+    const taprootResult = determineUtxosForSpendAll({
+      utxos: taprootUtxos,
+      recipients: [{ address: recipientAddress, amount: createMoney(5000, 'BTC') }],
+      feeRate,
+    });
+    const segwitResult = determineUtxosForSpendAll({
+      utxos: segwitUtxos,
+      recipients: [{ address: recipientAddress, amount: createMoney(5000, 'BTC') }],
+      feeRate,
+    });
+
+    expect(taprootResult.inputs.length).toEqual(3);
+    expect(taprootResult.outputs.length).toEqual(1);
+    expect(taprootResult.fee.amount.isLessThan(segwitResult.fee.amount)).toBeTruthy();
+    expect(taprootResult.size).toBeGreaterThan(200);
+    expect(taprootResult.size).toBeLessThan(220);
+  });
 });
 
 describe('mixed input types', () => {
@@ -281,4 +304,57 @@ describe('mixed input types', () => {
     expect(estimation.txVBytes).toBeGreaterThan(170);
     expect(estimation.txVBytes).toBeLessThan(210);
   });
+
+  test('that spending all mixed P2WPKH + P2TR utxos includes inputs from both address types', () => {
+    const nativeSegwitUtxos = generateMockTransactions([2000, 3000]);
+    const taprootUtxos = generateMockTaprootTransactions([2000, 3000]);
+    const allTaprootUtxos = generateMockTaprootTransactions([2000, 3000, 2000, 3000]);
+    const mixedUtxos = [...nativeSegwitUtxos, ...taprootUtxos];
+    const feeRate = 4;
+
+    const mixedResult = determineUtxosForSpendAll({
+      utxos: mixedUtxos,
+      recipients: [{ address: recipientAddress, amount: createMoney(8000, 'BTC') }],
+      feeRate,
+    });
+    const allTaprootResult = determineUtxosForSpendAll({
+      utxos: allTaprootUtxos,
+      recipients: [{ address: recipientAddress, amount: createMoney(8000, 'BTC') }],
+      feeRate,
+    });
+
+    expect(mixedResult.inputs.length).toEqual(4);
+    expect(mixedResult.outputs.length).toEqual(1);
+
+    const hasSegwit = mixedResult.inputs.some(u => u.address.startsWith('tb1q'));
+    const hasTaproot = mixedResult.inputs.some(u => u.address.startsWith('tb1p'));
+    expect(hasSegwit).toBeTruthy();
+    expect(hasTaproot).toBeTruthy();
+
+    expect(mixedResult.size).toBeGreaterThan(280);
+    expect(mixedResult.size).toBeLessThan(300);
+    expect(mixedResult.fee.amount.isGreaterThan(allTaprootResult.fee.amount)).toBeTruthy();
+  });
+
+  test('that mixed P2WPKH + P2TR inputs are sorted by value descending', () => {
+    const nativeSegwitUtxos = generateMockTransactions([15_000, 40_000]);
+    const taprootUtxos = generateMockTaprootTransactions([25_000, 30_000]);
+    const utxos = [...nativeSegwitUtxos, ...taprootUtxos];
+
+    const result = determineUtxosForSpend({
+      utxos,
+      recipients: [
+        {
+          address: recipientAddress,
+          amount: createMoney(50_000, 'BTC'),
+        },
+      ],
+      feeRate: 20,
+    });
+    result.inputs.forEach((input, i) => {
+      const nextInput = result.inputs[i + 1];
+      if (!nextInput) return;
+      expect(input.value >= nextInput.value).toEqual(true);
+    });
+  });
 });

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

@@ -95,12 +95,14 @@ 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({
     utxos,
     recipients,
+    isSendMax,
   });
   const fee = Math.ceil(size.txVBytes * feeRate);
   const bigNumberBalance = BigNumber(balance);

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

@@ -4,7 +4,7 @@ import { AverageBitcoinFeeRates } from '@leather.io/models';
 import { createMoney } from '@leather.io/utils';
 
 import { CoinSelectionRecipient } from '../coin-selection/coin-selection';
-import { recipientAddress } from '../mocks/mocks';
+import { recipientAddress, taprootAddress } from '../mocks/mocks';
 import { getBitcoinFees, getBitcoinTransactionFee } from './bitcoin-fees';
 
 describe('getBitcoinTransactionFee', () => {
@@ -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 = {