@leather.io/bitcoin 0.36.6 → 0.37.0

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.0",
   "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.17",
+    "@leather.io/models": "0.54.0",
+    "@leather.io/utils": "0.50.0",
+    "@leather.io/constants": "0.32.0"
   },
   "devDependencies": {
     "prettier": "3.5.1",
@@ -43,10 +43,10 @@
     "tslib": "2.6.2",
     "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.11",
     "@leather.io/tsconfig-config": "0.11.1",
-    "@leather.io/rpc": "2.21.10"
+    "@leather.io/prettier-config": "0.9.0"
   },
   "keywords": [
     "bitcoin",

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,
     });
@@ -231,3 +241,44 @@ describe(determineUtxosForSpend.name, () => {
     expect(fee).toEqual(735);
   });
 });
+
+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);
+  });
+});

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,
     });
   }

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,22 +75,23 @@ 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,
@@ -71,7 +99,7 @@ export function getSpendableAmount<T extends { value: number }>({
   const balance = utxos.map(utxo => utxo.value).reduce((prevVal, curVal) => prevVal + curVal, 0);
 
   const size = getSizeInfo({
-    inputLength: utxos.length,
+    utxos,
     recipients,
   });
   const fee = Math.ceil(size.txVBytes * feeRate);
@@ -83,7 +111,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

@@ -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, taprootAddress } from '../mocks/mocks';
+import { recipientAddress } from '../mocks/mocks';
 import { getBitcoinFees, getBitcoinTransactionFee } from './bitcoin-fees';
 
 describe('getBitcoinTransactionFee', () => {
@@ -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,
@@ -68,7 +68,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';
 

package/src/transactions/generate-unsigned-transaction.ts

@@ -1,4 +1,5 @@
 import * as btc from '@scure/btc-signer';
+import type { InputData } from 'coin-selection/coin-selection.utils';
 
 import {
   CoinSelectionRecipient,
@@ -24,7 +25,7 @@ export interface GenerateBitcoinUnsignedTransactionArgs<T> {
   payerLookup(keyOrigin: string): BitcoinNativeSegwitPayer | BitcoinTaprootPayer | undefined;
 }
 export function generateBitcoinUnsignedTransaction<
-  T extends { txid: string; vout: number; value: number; keyOrigin: string },
+  T extends InputData & { vout: number; keyOrigin: string },
 >({
   feeRate,
   isSendingMax,