@leather.io/bitcoin 0.36.6 → 0.37.1

package/package.json

@@ -2,7 +2,7 @@
   "name": "@leather.io/bitcoin",
   "author": "Leather.io contact@leather.io",
   "description": "Shared bitcoin utilities",
-  "version": "0.36.6",
+  "version": "0.37.1",
   "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/constants": "0.31.0",
-    "@leather.io/crypto": "1.12.16",
-    "@leather.io/utils": "0.49.10",
-    "@leather.io/models": "0.53.0"
+    "@leather.io/crypto": "1.12.18",
+    "@leather.io/constants": "0.33.0",
+    "@leather.io/models": "0.54.0",
+    "@leather.io/utils": "0.50.1"
   },
   "devDependencies": {
     "prettier": "3.5.1",
@@ -44,9 +44,9 @@
     "typescript": "5.9.3",
     "vitest": "2.1.9",
     "@leather.io/prettier-config": "0.9.0",
-    "@leather.io/test-config": "0.1.3",
+    "@leather.io/rpc": "2.21.12",
     "@leather.io/tsconfig-config": "0.11.1",
-    "@leather.io/rpc": "2.21.10"
+    "@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/calculate-max-spend.ts

@@ -3,11 +3,15 @@ import BigNumber from 'bignumber.js';
 import type { Money } from '@leather.io/models';
 import { createMoney, satToBtc } from '@leather.io/utils';
 
-import { filterUneconomicalUtxos, getSpendableAmount } from './coin-selection.utils';
+import {
+  type InputData,
+  filterUneconomicalUtxos,
+  getSpendableAmount,
+} from './coin-selection.utils';
 
 interface CalculateMaxSpendParams {
   recipient: string;
-  utxos: { value: number; txid: string }[];
+  utxos: InputData[];
   feeRate: number;
 }
 

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

@@ -37,4 +37,23 @@ export const mockUtxos = generateMockTransactions([
   600, 600, 1200, 1200, 10000, 10000, 25000, 40000, 50000000,
 ]);
 
+function generateMockTaprootUtxo(value: number): OwnedUtxo {
+  return {
+    address: 'tb1parwmj7533de3k2fw2kntyqacspvhm67qnjcmpqnnpfvzu05l69nsczdywd',
+    path: `m/86'/1'/0'/0/0`,
+    keyOrigin: `deadbeef/86'/1'/0'/0/0`,
+    txid: sha256(sha256(hexToBytes(generateMockHex()))).toString(),
+    value,
+    vout: 0,
+  };
+}
+
+export function generateMockTaprootTransactions(values: number[]) {
+  return values.map(val => generateMockTaprootUtxo(val));
+}
+
+export const mockTaprootUtxos = generateMockTaprootTransactions([
+  600, 600, 1200, 1200, 10000, 10000, 25000, 40000, 50000000,
+]);
+
 export const mockAverageFee = generateMockAverageFee(10);

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

@@ -10,22 +10,23 @@ import {
 } from '../mocks/mocks';
 import { isBitcoinAddress } from '../validation/bitcoin-address';
 import { determineUtxosForSpend, determineUtxosForSpendAll } from './coin-selection';
+import { generateMockTaprootTransactions, generateMockTransactions } from './coin-selection.mocks';
 import { filterUneconomicalUtxos, getSizeInfo } from './coin-selection.utils';
 
 const demoUtxos = [
-  { value: 8200 },
-  { value: 8490 },
-  { value: 8790 },
-  { value: 19 },
-  { value: 2000 },
-  { value: 2340 },
-  { value: 1230 },
-  { value: 120 },
-  { value: 8 },
-  { value: 1002 },
-  { value: 1382 },
-  { value: 1400 },
-  { value: 909 },
+  { txid: 'a1', value: 8200, address: recipientAddress },
+  { txid: 'a2', value: 8490, address: recipientAddress },
+  { txid: 'a3', value: 8790, address: recipientAddress },
+  { txid: 'a4', value: 19, address: recipientAddress },
+  { txid: 'a5', value: 2000, address: recipientAddress },
+  { txid: 'a6', value: 2340, address: recipientAddress },
+  { txid: 'a7', value: 1230, address: recipientAddress },
+  { txid: 'a8', value: 120, address: recipientAddress },
+  { txid: 'a9', value: 8, address: recipientAddress },
+  { txid: 'a10', value: 1002, address: recipientAddress },
+  { txid: 'a11', value: 1382, address: recipientAddress },
+  { txid: 'a12', value: 1400, address: recipientAddress },
+  { txid: 'a13', value: 909, address: recipientAddress },
 ];
 
 function generate10kSpendWithDummyUtxoSet(recipient: string) {
@@ -33,7 +34,7 @@ function generate10kSpendWithDummyUtxoSet(recipient: string) {
     throw new Error('Invalid Bitcoin address');
   }
   return determineUtxosForSpend({
-    utxos: demoUtxos as any,
+    utxos: demoUtxos,
     feeRate: 20,
     recipients: [{ address: recipient, amount: createMoney(10_000, 'BTC') }],
   });
@@ -43,7 +44,7 @@ describe(determineUtxosForSpend.name, () => {
   describe('Estimated size', () => {
     test('that Native Segwit, 1 input 2 outputs weighs 140 vBytes', () => {
       const estimation = determineUtxosForSpend({
-        utxos: [{ value: 50_000 }] as any[],
+        utxos: [{ txid: 'b1', value: 50_000, address: recipientAddress }],
         recipients: [
           {
             address: recipientAddress,
@@ -58,7 +59,10 @@ describe(determineUtxosForSpend.name, () => {
 
     test('that Native Segwit, 2 input 2 outputs weighs 200vBytes', () => {
       const estimation = determineUtxosForSpend({
-        utxos: [{ value: 50_000 }, { value: 50_000 }] as any[],
+        utxos: [
+          { txid: 'c1', value: 50_000, address: recipientAddress },
+          { txid: 'c2', value: 50_000, address: recipientAddress },
+        ],
         recipients: [
           {
             address: recipientAddress,
@@ -74,17 +78,17 @@ describe(determineUtxosForSpend.name, () => {
     test('that Native Segwit, 10 input 2 outputs weighs 200vBytes', () => {
       const estimation = determineUtxosForSpend({
         utxos: [
-          { value: 20_000 },
-          { value: 20_000 },
-          { value: 10_000 },
-          { value: 10_000 },
-          { value: 10_000 },
-          { value: 10_000 },
-          { value: 10_000 },
-          { value: 10_000 },
-          { value: 10_000 },
-          { value: 10_000 },
-        ] as any[],
+          { txid: 'd1', value: 20_000, address: recipientAddress },
+          { txid: 'd2', value: 20_000, address: recipientAddress },
+          { txid: 'd3', value: 10_000, address: recipientAddress },
+          { txid: 'd4', value: 10_000, address: recipientAddress },
+          { txid: 'd5', value: 10_000, address: recipientAddress },
+          { txid: 'd6', value: 10_000, address: recipientAddress },
+          { txid: 'd7', value: 10_000, address: recipientAddress },
+          { txid: 'd8', value: 10_000, address: recipientAddress },
+          { txid: 'd9', value: 10_000, address: recipientAddress },
+          { txid: 'd10', value: 10_000, address: recipientAddress },
+        ],
         recipients: [
           {
             address: recipientAddress,
@@ -147,12 +151,14 @@ describe(determineUtxosForSpend.name, () => {
   });
 
   test('against a random set of generated utxos', () => {
-    const testData = createNullArrayOfLength(50).map(() => ({
+    const testData = createNullArrayOfLength(50).map((_, i) => ({
+      txid: `rnd${i}`,
       value: Math.ceil(Math.random() * 10000),
+      address: recipientAddress,
     }));
     const amount = 29123n;
     const result = determineUtxosForSpend({
-      utxos: testData as any,
+      utxos: testData,
       recipients: [
         {
           address: recipientAddress,
@@ -180,7 +186,7 @@ describe(determineUtxosForSpend.name, () => {
       },
     ];
     const filteredUtxos = filterUneconomicalUtxos({
-      utxos: demoUtxos.sort((a, b) => b.value - a.value) as any,
+      utxos: demoUtxos.sort((a, b) => b.value - a.value),
       feeRate,
       recipients,
     });
@@ -188,7 +194,7 @@ describe(determineUtxosForSpend.name, () => {
     recipients[0].amount = createMoney(amount, 'BTC');
 
     const result = determineUtxosForSpend({
-      utxos: filteredUtxos as any,
+      utxos: filteredUtxos,
       recipients: [
         {
           address: recipientAddress,
@@ -203,7 +209,11 @@ describe(determineUtxosForSpend.name, () => {
   });
 
   test('that spending all utxos with sendMax does not result in dust utxos', () => {
-    const utxos = [{ value: 1000 }, { value: 2000 }, { value: 3000 }];
+    const utxos = [
+      { txid: '123', value: 1000, address: recipientAddress },
+      { txid: '1323', value: 2000, address: recipientAddress },
+      { txid: '132355', value: 3000, address: recipientAddress },
+    ];
     const recipients = [
       {
         address: recipientAddress,
@@ -211,7 +221,7 @@ describe(determineUtxosForSpend.name, () => {
       },
     ];
     const sizeInfo = getSizeInfo({
-      inputLength: utxos.length,
+      utxos,
       isSendMax: true,
       recipients,
     });
@@ -221,7 +231,7 @@ describe(determineUtxosForSpend.name, () => {
     recipients[0].amount = createMoney(amount, 'BTC');
 
     const result = determineUtxosForSpendAll({
-      utxos: utxos as any,
+      utxos: utxos,
       recipients,
       feeRate,
     });
@@ -230,4 +240,121 @@ 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', () => {
+  test('that spending from P2TR-only inputs produces correct fee estimation', () => {
+    const taprootUtxos = generateMockTaprootTransactions([50_000]);
+    const estimation = determineUtxosForSpend({
+      utxos: taprootUtxos,
+      recipients: [
+        {
+          address: recipientAddress,
+          amount: createMoney(40_000, 'BTC'),
+        },
+      ],
+      feeRate: 20,
+    });
+    expect(estimation.fee.amount.toNumber()).toBeGreaterThan(0);
+    expect(estimation.inputs).toHaveLength(1);
+    expect(estimation.txVBytes).toBeGreaterThanOrEqual(130);
+    expect(estimation.txVBytes).toBeLessThan(155);
+  });
+
+  test('that spending from mixed P2WPKH + P2TR inputs uses correct vBytes', () => {
+    const nativeSegwitUtxos = generateMockTransactions([30_000]);
+    const taprootUtxos = generateMockTaprootTransactions([30_000]);
+    const mixedUtxos = [...nativeSegwitUtxos, ...taprootUtxos];
+
+    const estimation = determineUtxosForSpend({
+      utxos: mixedUtxos,
+      recipients: [
+        {
+          address: recipientAddress,
+          amount: createMoney(50_000, 'BTC'),
+        },
+      ],
+      feeRate: 20,
+    });
+    expect(estimation.inputs).toHaveLength(2);
+    expect(estimation.fee.amount.toNumber()).toBeGreaterThan(0);
+    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.ts

@@ -6,7 +6,12 @@ import { Money } from '@leather.io/models';
 import { createMoney, sumMoney } from '@leather.io/utils';
 
 import { BitcoinError } from '../validation/bitcoin-error';
-import { filterUneconomicalUtxos, getSizeInfo, getUtxoTotal } from './coin-selection.utils';
+import {
+  type InputData,
+  filterUneconomicalUtxos,
+  getSizeInfo,
+  getUtxoTotal,
+} from './coin-selection.utils';
 
 export interface CoinSelectionOutput {
   value: bigint;
@@ -23,7 +28,7 @@ export interface DetermineUtxosForSpendArgs<T> {
   recipients: CoinSelectionRecipient[];
   utxos: T[];
 }
-export function determineUtxosForSpendAll<T extends { value: number; txid: string }>({
+export function determineUtxosForSpendAll<T extends InputData>({
   feeRate,
   recipients,
   utxos,
@@ -36,7 +41,7 @@ export function determineUtxosForSpendAll<T extends { value: number; txid: strin
   if (!filteredUtxos.length) throw new BitcoinError('InsufficientFunds');
 
   const sizeInfo = getSizeInfo({
-    inputLength: filteredUtxos.length,
+    utxos: filteredUtxos,
     isSendMax: true,
     recipients,
   });
@@ -57,7 +62,7 @@ export function determineUtxosForSpendAll<T extends { value: number; txid: strin
   };
 }
 
-export function determineUtxosForSpend<T extends { value: number; txid: string }>({
+export function determineUtxosForSpend<T extends InputData>({
   feeRate,
   recipients,
   utxos,
@@ -79,7 +84,7 @@ export function determineUtxosForSpend<T extends { value: number; txid: string }
 
   function estimateTransactionSize() {
     return getSizeInfo({
-      inputLength: neededUtxos.length,
+      utxos: neededUtxos,
       recipients,
     });
   }