@leather.io/bitcoin 0.16.7 → 0.17.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @leather.io/bitcoin@0.16.7 build /home/runner/work/mono/mono/packages/bitcoin
+> @leather.io/bitcoin@0.17.0 build /home/runner/work/mono/mono/packages/bitcoin
 > tsup
 
 CLI Building entry: src/index.ts
@@ -10,7 +10,7 @@ CLI Target: es2022
 ESM Build start
 ESM dist/index.js     25.37 KB
 ESM dist/index.js.map 49.31 KB
-ESM ⚡️ Build success in 57ms
+ESM ⚡️ Build success in 39ms
 DTS Build start
-DTS ⚡️ Build success in 4044ms
+DTS ⚡️ Build success in 4101ms
 DTS dist/index.d.ts 16.04 KB

package/CHANGELOG.md

@@ -310,6 +310,13 @@
   * devDependencies
     * @leather.io/rpc bumped to 2.1.20
 
+## [0.17.0](https://github.com/leather-io/mono/compare/@leather.io/bitcoin-v0.16.7...@leather.io/bitcoin-v0.17.0) (2024-11-26)
+
+
+### Features
+
+* migrate btc coin selection, closes LEA-1734 ([0cad7aa](https://github.com/leather-io/mono/commit/0cad7aaa35fbc8704d959a16d12965502757fe89))
+
 ## [0.16.4](https://github.com/leather-io/mono/compare/@leather.io/bitcoin-v0.16.3...@leather.io/bitcoin-v0.16.4) (2024-11-19)
 
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "@leather.io/bitcoin",
   "author": "Leather.io contact@leather.io",
   "description": "Shared bitcoin utilities",
-  "version": "0.16.7",
+  "version": "0.17.0",
   "license": "MIT",
   "homepage": "https://github.com/leather.io/mono/tree/dev/packages/bitcoin",
   "repository": {
@@ -25,15 +25,17 @@
     "@scure/btc-signer": "1.4.0",
     "@stacks/common": "6.13.0",
     "@stacks/transactions": "6.17.0",
+    "bignumber.js": "9.1.2",
     "bip32": "4.0.0",
+    "bitcoin-address-validation": "2.2.3",
     "bitcoinjs-lib": "6.1.5",
     "ecpair": "2.1.0",
     "just-memoize": "2.2.0",
     "varuint-bitcoin": "1.1.2",
-    "@leather.io/constants": "0.13.5",
     "@leather.io/crypto": "1.6.14",
-    "@leather.io/utils": "0.20.0",
-    "@leather.io/models": "0.22.0"
+    "@leather.io/constants": "0.13.5",
+    "@leather.io/models": "0.22.0",
+    "@leather.io/utils": "0.20.0"
   },
   "devDependencies": {
     "eslint": "8.53.0",
@@ -43,9 +45,9 @@
     "typescript": "5.5.4",
     "vitest": "2.1.5",
     "@leather.io/eslint-config": "0.7.0",
-    "@leather.io/rpc": "2.1.20",
+    "@leather.io/prettier-config": "0.6.0",
     "@leather.io/tsconfig-config": "0.6.0",
-    "@leather.io/prettier-config": "0.6.0"
+    "@leather.io/rpc": "2.1.20"
   },
   "keywords": [
     "bitcoin",

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

@@ -0,0 +1,109 @@
+import { describe, expect, it } from 'vitest';
+
+import { BtcSizeFeeEstimator } from './btc-size-fee-estimator';
+
+describe('BtcSizeFeeEstimator', () => {
+  const estimator = new BtcSizeFeeEstimator();
+
+  describe('getSizeOfScriptLengthElement', () => {
+    it('should return the correct size for small lengths', () => {
+      expect(estimator.getSizeOfScriptLengthElement(75)).toBe(2);
+    });
+
+    it('should return the correct size for large lengths', () => {
+      expect(estimator.getSizeOfScriptLengthElement(512)).toBe(3);
+    });
+  });
+
+  describe('getSizeOfletInt', () => {
+    it('should return 1 for values <= 0xFC', () => {
+      expect(estimator.getSizeOfletInt(250)).toBe(1);
+    });
+
+    it('should return 3 for values <= 0xFFFF', () => {
+      expect(estimator.getSizeOfletInt(0xabcd)).toBe(3);
+    });
+
+    it('should return 5 for values <= 0xFFFFFFFF', () => {
+      expect(estimator.getSizeOfletInt(0xabcdef)).toBe(5);
+    });
+  });
+
+  describe('getTxOverheadVBytes', () => {
+    it('should calculate the transaction overhead correctly', () => {
+      const result = estimator.getTxOverheadVBytes('p2wpkh', 1, 1);
+      expect(result).toEqual(10.75);
+    });
+  });
+
+  describe('prepareParams', () => {
+    it('should validate and return formatted parameters', () => {
+      const params = estimator.prepareParams({
+        input_count: 2,
+        input_script: 'p2wpkh',
+        input_m: 1,
+        input_n: 1,
+        p2pkh_output_count: 1,
+        p2sh_output_count: 1,
+        p2sh_p2wpkh_output_count: 1,
+        p2sh_p2wsh_output_count: 1,
+        p2wpkh_output_count: 1,
+        p2wsh_output_count: 1,
+        p2tr_output_count: 1,
+      });
+
+      expect(params.input_count).toBe(2);
+      expect(params.input_script).toBe('p2wpkh');
+      expect(params.input_m).toBe(1);
+      expect(params.input_n).toBe(1);
+      expect(params.p2pkh_output_count).toBe(1);
+      expect(params.p2sh_output_count).toBe(1);
+      expect(params.p2sh_p2wpkh_output_count).toBe(1);
+      expect(params.p2sh_p2wsh_output_count).toBe(1);
+      expect(params.p2wpkh_output_count).toBe(1);
+      expect(params.p2wsh_output_count).toBe(1);
+      expect(params.p2tr_output_count).toBe(1);
+    });
+  });
+
+  describe('calcTxSize', () => {
+    it('should calculate transaction size correctly', () => {
+      const { txVBytes, txBytes, txWeight } = estimator.calcTxSize({
+        input_count: 2,
+        input_script: 'p2wpkh',
+        input_m: 1,
+        input_n: 1,
+        p2pkh_output_count: 1,
+        p2sh_output_count: 1,
+        p2sh_p2wpkh_output_count: 1,
+        p2sh_p2wsh_output_count: 1,
+        p2wpkh_output_count: 1,
+        p2wsh_output_count: 1,
+        p2tr_output_count: 1,
+      });
+
+      expect(txVBytes).toEqual(393.25);
+      expect(txBytes).toEqual(609.5);
+      expect(txWeight).toEqual(1573);
+    });
+  });
+
+  describe('estimateFee', () => {
+    it('should calculate the correct fee based on transaction size and fee rate', () => {
+      const fee = estimator.estimateFee(250, 20);
+      expect(fee).toBe(5000);
+    });
+
+    it('should return 0 fee if fee rate is 0', () => {
+      const fee = estimator.estimateFee(250, 0);
+      expect(fee).toBe(0);
+    });
+  });
+
+  describe('formatFeeRange', () => {
+    it('should format fee range correctly', () => {
+      const feeRange = estimator.formatFeeRange(1000, 0.1);
+      expect(feeRange).toBe('900 - 1100');
+    });
+  });
+});

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

@@ -0,0 +1,327 @@
+// https://github.com/argvil19/bitcoin-transaction-size-calculator/blob/master/index.js
+import BigNumber from 'bignumber.js';
+
+export type InputScriptType =
+  | 'p2pkh'
+  | 'p2sh'
+  | 'p2sh-p2wpkh'
+  | 'p2sh-p2wsh'
+  | 'p2wpkh'
+  | 'p2wsh'
+  | 'p2tr';
+
+export interface TxSizerParams {
+  input_count: number;
+  input_script: InputScriptType;
+  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;
+}
+
+export class BtcSizeFeeEstimator {
+  P2PKH_IN_SIZE = 148;
+  P2PKH_OUT_SIZE = 34;
+  P2SH_OUT_SIZE = 32;
+  P2SH_P2WPKH_OUT_SIZE = 32;
+  P2SH_P2WSH_OUT_SIZE = 32;
+  P2SH_P2WPKH_IN_SIZE = 91;
+  P2WPKH_IN_SIZE = 67.75;
+  P2WPKH_OUT_SIZE = 31;
+  P2WSH_OUT_SIZE = 43;
+  P2TR_OUT_SIZE = 43;
+  P2TR_IN_SIZE = 57.25;
+  PUBKEY_SIZE = 33;
+  SIGNATURE_SIZE = 72;
+  SUPPORTED_INPUT_SCRIPT_TYPES: InputScriptType[] = [
+    'p2pkh',
+    'p2sh',
+    'p2sh-p2wpkh',
+    'p2sh-p2wsh',
+    'p2wpkh',
+    'p2wsh',
+    'p2tr',
+  ];
+
+  defaultParams: TxSizerParams = {
+    input_count: 0,
+    input_script: 'p2wpkh',
+    input_m: 0,
+    input_n: 0,
+    p2pkh_output_count: 0,
+    p2sh_output_count: 0,
+    p2sh_p2wpkh_output_count: 0,
+    p2sh_p2wsh_output_count: 0,
+    p2wpkh_output_count: 0,
+    p2wsh_output_count: 0,
+    p2tr_output_count: 0,
+  };
+
+  params: TxSizerParams = { ...this.defaultParams };
+
+  getSizeOfScriptLengthElement(length: number) {
+    if (length < 75) {
+      return 1;
+    } else if (length <= 255) {
+      return 2;
+    } else if (length <= 65535) {
+      return 3;
+    } else if (length <= 4294967295) {
+      return 5;
+    } else {
+      throw new Error('Size of redeem script is too large');
+    }
+  }
+
+  getSizeOfletInt(length: number) {
+    if (length < 253) {
+      return 1;
+    } else if (length < 65535) {
+      return 3;
+    } else if (length < 4294967295) {
+      return 5;
+    } else if (new BigNumber(length).isLessThan('18446744073709551615')) {
+      return 9;
+    } else {
+      throw new Error('Invalid let int');
+    }
+  }
+
+  getTxOverheadVBytes(input_script: InputScriptType, input_count: number, output_count: number) {
+    let witness_vbytes;
+    if (input_script === 'p2pkh' || input_script === 'p2sh') {
+      witness_vbytes = 0;
+    } else {
+      // Transactions with segwit inputs have extra overhead
+      witness_vbytes =
+        0.25 + // segwit marker
+        0.25 + // segwit flag
+        this.getSizeOfletInt(input_count) / 4; // witness element count
+    }
+
+    return (
+      4 + // nVersion
+      this.getSizeOfletInt(input_count) + // number of inputs
+      this.getSizeOfletInt(output_count) + // number of outputs
+      4 + // nLockTime
+      witness_vbytes
+    );
+  }
+
+  getTxOverheadExtraRawBytes(input_script: InputScriptType, input_count: number) {
+    let witness_vbytes;
+    if (input_script === 'p2pkh' || input_script === 'p2sh') {
+      witness_vbytes = 0;
+    } else {
+      // Transactions with segwit inputs have extra overhead
+      witness_vbytes =
+        0.25 + // segwit marker
+        0.25 + // segwit flag
+        this.getSizeOfletInt(input_count) / 4; // witness element count
+    }
+
+    return witness_vbytes * 3;
+  }
+
+  prepareParams(opts: Partial<TxSizerParams>) {
+    // Verify opts and set them to this.params
+    opts = opts || Object.assign(this.defaultParams);
+
+    const input_count = opts.input_count || this.defaultParams.input_count;
+    if (!Number.isInteger(input_count) || input_count < 0) {
+      throw new Error('expecting positive input count, got: ' + input_count);
+    }
+
+    const input_script = opts.input_script || this.defaultParams.input_script;
+    if (this.SUPPORTED_INPUT_SCRIPT_TYPES.indexOf(input_script) === -1) {
+      throw new Error('Not supported input script type');
+    }
+
+    const input_m = opts.input_m || this.defaultParams.input_m;
+    if (!Number.isInteger(input_m) || input_m < 0) {
+      throw new Error('expecting positive signature count');
+    }
+
+    const input_n = opts.input_n || this.defaultParams.input_n;
+    if (!Number.isInteger(input_n) || input_n < 0) {
+      throw new Error('expecting positive pubkey count');
+    }
+
+    const p2pkh_output_count = opts.p2pkh_output_count || this.defaultParams.p2pkh_output_count;
+    if (!Number.isInteger(p2pkh_output_count) || p2pkh_output_count < 0) {
+      throw new Error('expecting positive p2pkh output count');
+    }
+
+    const p2sh_output_count = opts.p2sh_output_count || this.defaultParams.p2sh_output_count;
+    if (!Number.isInteger(p2sh_output_count) || p2sh_output_count < 0) {
+      throw new Error('expecting positive p2sh output count');
+    }
+
+    const p2sh_p2wpkh_output_count =
+      opts.p2sh_p2wpkh_output_count || this.defaultParams.p2sh_p2wpkh_output_count;
+    if (!Number.isInteger(p2sh_p2wpkh_output_count) || p2sh_p2wpkh_output_count < 0) {
+      throw new Error('expecting positive p2sh-p2wpkh output count');
+    }
+
+    const p2sh_p2wsh_output_count =
+      opts.p2sh_p2wsh_output_count || this.defaultParams.p2sh_p2wsh_output_count;
+    if (!Number.isInteger(p2sh_p2wsh_output_count) || p2sh_p2wsh_output_count < 0) {
+      throw new Error('expecting positive p2sh-p2wsh output count');
+    }
+
+    const p2wpkh_output_count = opts.p2wpkh_output_count || this.defaultParams.p2wpkh_output_count;
+    if (!Number.isInteger(p2wpkh_output_count) || p2wpkh_output_count < 0) {
+      throw new Error('expecting positive p2wpkh output count');
+    }
+
+    const p2wsh_output_count = opts.p2wsh_output_count || this.defaultParams.p2wsh_output_count;
+    if (!Number.isInteger(p2wsh_output_count) || p2wsh_output_count < 0) {
+      throw new Error('expecting positive p2wsh output count');
+    }
+
+    const p2tr_output_count = opts.p2tr_output_count || this.defaultParams.p2tr_output_count;
+    if (!Number.isInteger(p2tr_output_count) || p2tr_output_count < 0) {
+      throw new Error('expecting positive p2tr output count');
+    }
+
+    this.params = {
+      input_count,
+      input_script,
+      input_m,
+      input_n,
+      p2pkh_output_count,
+      p2sh_output_count,
+      p2sh_p2wpkh_output_count,
+      p2sh_p2wsh_output_count,
+      p2wpkh_output_count,
+      p2wsh_output_count,
+      p2tr_output_count,
+    };
+
+    return this.params;
+  }
+
+  getOutputCount() {
+    return (
+      this.params.p2pkh_output_count +
+      this.params.p2sh_output_count +
+      this.params.p2sh_p2wpkh_output_count +
+      this.params.p2sh_p2wsh_output_count +
+      this.params.p2wpkh_output_count +
+      this.params.p2wsh_output_count +
+      this.params.p2tr_output_count
+    );
+  }
+
+  getSizeBasedOnInputType() {
+    // In most cases the input size is predictable. For multisig inputs we need to perform a detailed calculation
+    let inputSize = 0; // in virtual bytes
+    let inputWitnessSize = 0;
+    let redeemScriptSize;
+    switch (this.params.input_script) {
+      case 'p2pkh':
+        inputSize = this.P2PKH_IN_SIZE;
+        break;
+      case 'p2sh-p2wpkh':
+        inputSize = this.P2SH_P2WPKH_IN_SIZE;
+        inputWitnessSize = 107; // size(signature) + signature + size(pubkey) + pubkey
+        break;
+      case 'p2wpkh':
+        inputSize = this.P2WPKH_IN_SIZE;
+        inputWitnessSize = 107; // size(signature) + signature + size(pubkey) + pubkey
+        break;
+      case 'p2tr': // Only consider the cooperative taproot signing path assume multisig is done via aggregate signatures
+        inputSize = this.P2TR_IN_SIZE;
+        inputWitnessSize = 65; // getSizeOfletInt(schnorrSignature) + schnorrSignature
+        break;
+      case 'p2sh':
+        redeemScriptSize =
+          1 + // OP_M
+          this.params.input_n * (1 + this.PUBKEY_SIZE) + // OP_PUSH33 <pubkey>
+          1 + // OP_N
+          1; // OP_CHECKMULTISIG
+        const scriptSigSize =
+          1 + // size(0)
+          this.params.input_m * (1 + this.SIGNATURE_SIZE) + // size(SIGNATURE_SIZE) + signature
+          this.getSizeOfScriptLengthElement(redeemScriptSize) +
+          redeemScriptSize;
+        inputSize = 32 + 4 + this.getSizeOfletInt(scriptSigSize) + scriptSigSize + 4;
+        break;
+      case 'p2sh-p2wsh':
+      case 'p2wsh':
+        redeemScriptSize =
+          1 + // OP_M
+          this.params.input_n * (1 + this.PUBKEY_SIZE) + // OP_PUSH33 <pubkey>
+          1 + // OP_N
+          1; // OP_CHECKMULTISIG
+        inputWitnessSize =
+          1 + // size(0)
+          this.params.input_m * (1 + this.SIGNATURE_SIZE) + // size(SIGNATURE_SIZE) + signature
+          this.getSizeOfScriptLengthElement(redeemScriptSize) +
+          redeemScriptSize;
+        inputSize =
+          36 + // outpoint (spent UTXO ID)
+          inputWitnessSize / 4 + // witness program
+          4; // nSequence
+        if (this.params.input_script === 'p2sh-p2wsh') {
+          inputSize += 32 + 3; // P2SH wrapper (redeemscript hash) + overhead?
+        }
+    }
+
+    return {
+      inputSize,
+      inputWitnessSize,
+    };
+  }
+
+  calcTxSize(opts: Partial<TxSizerParams>) {
+    this.prepareParams(opts);
+    const output_count = this.getOutputCount();
+    const { inputSize, inputWitnessSize } = this.getSizeBasedOnInputType();
+
+    const txVBytes =
+      this.getTxOverheadVBytes(this.params.input_script, this.params.input_count, output_count) +
+      inputSize * this.params.input_count +
+      this.P2PKH_OUT_SIZE * this.params.p2pkh_output_count +
+      this.P2SH_OUT_SIZE * this.params.p2sh_output_count +
+      this.P2SH_P2WPKH_OUT_SIZE * this.params.p2sh_p2wpkh_output_count +
+      this.P2SH_P2WSH_OUT_SIZE * this.params.p2sh_p2wsh_output_count +
+      this.P2WPKH_OUT_SIZE * this.params.p2wpkh_output_count +
+      this.P2WSH_OUT_SIZE * this.params.p2wsh_output_count +
+      this.P2TR_OUT_SIZE * this.params.p2tr_output_count;
+
+    const txBytes =
+      this.getTxOverheadExtraRawBytes(this.params.input_script, this.params.input_count) +
+      txVBytes +
+      inputWitnessSize * this.params.input_count;
+    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');
+    }
+    return vbyte * satVb;
+  }
+
+  formatFeeRange(fee: number, multiplier: number) {
+    if (isNaN(fee) || isNaN(multiplier)) {
+      throw new Error('Parameters should be numbers');
+    }
+
+    if (multiplier < 0) {
+      throw new Error('Multiplier cant be negative');
+    }
+
+    const multipliedFee = fee * multiplier;
+
+    return fee - multipliedFee + ' - ' + (fee + multipliedFee);
+  }
+}

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

@@ -0,0 +1,54 @@
+import { calculateMaxBitcoinSpend } from './calculate-max-spend';
+import { generateMockAverageFee, mockUtxos } from './coin-selection.mocks';
+
+describe(calculateMaxBitcoinSpend.name, () => {
+  test('with 1 sat/vb fee', () => {
+    const fee = 1;
+    const maxBitcoinSpend = calculateMaxBitcoinSpend({
+      address: '',
+      utxos: mockUtxos,
+      fetchedFeeRates: generateMockAverageFee(fee),
+    });
+    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50087948);
+  });
+
+  test('with 5 sat/vb fee', () => {
+    const fee = 5;
+    const maxBitcoinSpend = calculateMaxBitcoinSpend({
+      address: '',
+      utxos: mockUtxos,
+      fetchedFeeRates: generateMockAverageFee(fee),
+    });
+    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50085342);
+  });
+
+  test('with 30 sat/vb fee', () => {
+    const fee = 30;
+    const maxBitcoinSpend = calculateMaxBitcoinSpend({
+      address: '',
+      utxos: mockUtxos,
+      fetchedFeeRates: generateMockAverageFee(fee),
+    });
+    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50073585);
+  });
+
+  test('with 100 sat/vb fee', () => {
+    const fee = 100;
+    const maxBitcoinSpend = calculateMaxBitcoinSpend({
+      address: '',
+      utxos: mockUtxos,
+      fetchedFeeRates: generateMockAverageFee(fee),
+    });
+    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50046950);
+  });
+
+  test('with 400 sat/vb fee', () => {
+    const fee = 400;
+    const maxBitcoinSpend = calculateMaxBitcoinSpend({
+      address: '',
+      utxos: mockUtxos,
+      fetchedFeeRates: generateMockAverageFee(fee),
+    });
+    expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(49969100);
+  });
+});

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

@@ -0,0 +1,47 @@
+import BigNumber from 'bignumber.js';
+
+import type { AverageBitcoinFeeRates } from '@leather.io/models';
+import { createMoney, satToBtc } from '@leather.io/utils';
+
+import { Utxo, filterUneconomicalUtxos, getSpendableAmount } from './coin-selection.utils';
+
+interface CalculateMaxBitcoinSpend {
+  address: string;
+  utxos: Utxo[];
+  fetchedFeeRates?: AverageBitcoinFeeRates;
+  feeRate?: number;
+}
+
+export function calculateMaxBitcoinSpend({
+  address,
+  utxos,
+  feeRate,
+  fetchedFeeRates,
+}: CalculateMaxBitcoinSpend) {
+  if (!utxos.length || !fetchedFeeRates)
+    return {
+      spendAllFee: 0,
+      amount: createMoney(0, 'BTC'),
+      spendableBitcoin: new BigNumber(0),
+    };
+
+  const currentFeeRate = feeRate ?? fetchedFeeRates.halfHourFee.toNumber();
+
+  const filteredUtxos = filterUneconomicalUtxos({
+    utxos,
+    feeRate: currentFeeRate,
+    recipients: [{ address, amount: createMoney(0, 'BTC') }],
+  });
+
+  const { spendableAmount, fee } = getSpendableAmount({
+    utxos: filteredUtxos,
+    feeRate: currentFeeRate,
+    recipients: [{ address, amount: createMoney(0, 'BTC') }],
+  });
+
+  return {
+    spendAllFee: fee,
+    amount: createMoney(spendableAmount, 'BTC'),
+    spendableBitcoin: satToBtc(spendableAmount),
+  };
+}

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

@@ -0,0 +1,43 @@
+import { sha256 } from '@noble/hashes/sha256';
+import { hexToBytes } from '@noble/hashes/utils';
+import BigNumber from 'bignumber.js';
+
+import { Utxo } from './coin-selection.utils';
+
+function generateMockHex() {
+  return Math.floor(Math.random() * 0xffffff)
+    .toString(16)
+    .padEnd(6, '0');
+}
+
+function generateMockTxId(value: number): Utxo {
+  return {
+    txid: sha256(sha256(hexToBytes(generateMockHex()))).toString(),
+    vout: 0,
+    status: {
+      confirmed: true,
+      block_height: 2568495,
+      block_hash: '000000000000008622fafce4a5388861b252d534f819d0f7cb5d4f2c5f9c1638',
+      block_time: 1703787327,
+    },
+    value,
+  };
+}
+
+export function generateMockTransactions(values: number[]) {
+  return values.map(val => generateMockTxId(val));
+}
+
+export function generateMockAverageFee(value: number) {
+  return {
+    hourFee: BigNumber(value / 2),
+    halfHourFee: BigNumber(value),
+    fastestFee: BigNumber(value * 2),
+  };
+}
+
+export const mockUtxos = generateMockTransactions([
+  600, 600, 1200, 1200, 10000, 10000, 25000, 40000, 50000000,
+]);
+
+export const mockAverageFee = generateMockAverageFee(10);

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

@@ -0,0 +1,230 @@
+import { BTC_P2WPKH_DUST_AMOUNT } from '@leather.io/constants';
+import { createMoney, createNullArrayOfLength, sumNumbers } from '@leather.io/utils';
+
+import { determineUtxosForSpend, determineUtxosForSpendAll } from './coin-selection';
+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 },
+];
+
+function generate10kSpendWithDummyUtxoSet(recipient: string) {
+  return determineUtxosForSpend({
+    utxos: demoUtxos as any,
+    feeRate: 20,
+    recipients: [{ address: recipient, amount: createMoney(10_000, 'BTC') }],
+  });
+}
+
+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[],
+        recipients: [
+          {
+            address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+            amount: createMoney(40_000, 'BTC'),
+          },
+        ],
+        feeRate: 20,
+      });
+      expect(estimation.txVBytes).toBeGreaterThan(140);
+      expect(estimation.txVBytes).toBeLessThan(142);
+    });
+
+    test('that Native Segwit, 2 input 2 outputs weighs 200vBytes', () => {
+      const estimation = determineUtxosForSpend({
+        utxos: [{ value: 50_000 }, { value: 50_000 }] as any[],
+        recipients: [
+          {
+            address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+            amount: createMoney(60_000, 'BTC'),
+          },
+        ],
+        feeRate: 20,
+      });
+      expect(estimation.txVBytes).toBeGreaterThan(208);
+      expect(estimation.txVBytes).toBeLessThan(209);
+    });
+
+    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[],
+        recipients: [
+          {
+            address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+            amount: createMoney(100_000, 'BTC'),
+          },
+        ],
+        feeRate: 20,
+      });
+      expect(estimation.txVBytes).toBeGreaterThan(750);
+      expect(estimation.txVBytes).toBeLessThan(751);
+    });
+  });
+
+  describe('sorting algorithm', () => {
+    test('that it filters out dust utxos', () => {
+      const result = generate10kSpendWithDummyUtxoSet('tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m');
+      const hasDust = result.filteredUtxos.some(utxo => utxo.value <= BTC_P2WPKH_DUST_AMOUNT);
+      expect(hasDust).toBeFalsy();
+    });
+
+    test('that it sorts utxos in decending order', () => {
+      const result = generate10kSpendWithDummyUtxoSet('tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m');
+      result.inputs.forEach((u, i) => {
+        const nextUtxo = result.inputs[i + 1];
+        if (!nextUtxo) return;
+        expect(u.value >= nextUtxo.value).toEqual(true);
+      });
+    });
+  });
+
+  test('that it accepts a wrapped segwit address', () =>
+    expect(() =>
+      generate10kSpendWithDummyUtxoSet('33SVjoCHJovrXxjDKLFSXo1h3t5KgkPzfH')
+    ).not.toThrowError());
+
+  test('that it accepts a legacy addresses', () =>
+    expect(() =>
+      generate10kSpendWithDummyUtxoSet('15PyZveQd28E2SHZu2ugkWZBp6iER41vXj')
+    ).not.toThrowError());
+
+  test('that it throws an error with non-legit address', () => {
+    expect(() =>
+      generate10kSpendWithDummyUtxoSet('whoop-de-da-boop-da-de-not-a-bitcoin-address')
+    ).toThrowError();
+  });
+
+  test('that given a set of utxos, legacy is more expensive', () => {
+    const legacy = generate10kSpendWithDummyUtxoSet('15PyZveQd28E2SHZu2ugkWZBp6iER41vXj');
+    const segwit = generate10kSpendWithDummyUtxoSet('33SVjoCHJovrXxjDKLFSXo1h3t5KgkPzfH');
+    expect(legacy.fee).toBeGreaterThan(segwit.fee);
+  });
+
+  test('that given a set of utxos, wrapped segwit is more expensive than native', () => {
+    const segwit = generate10kSpendWithDummyUtxoSet('33SVjoCHJovrXxjDKLFSXo1h3t5KgkPzfH');
+    const native = generate10kSpendWithDummyUtxoSet('tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m');
+    expect(segwit.fee).toBeGreaterThan(native.fee);
+  });
+
+  test('that given a set of utxos, taproot is more expensive than native segwit', () => {
+    // Non-obvious behaviour.
+    // P2TR outputs = 34 vBytes
+    // P2WPKH outputs = 22 vBytes
+    const native = generate10kSpendWithDummyUtxoSet('tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m');
+    const taproot = generate10kSpendWithDummyUtxoSet(
+      'tb1parwmj7533de3k2fw2kntyqacspvhm67qnjcmpqnnpfvzu05l69nsczdywd'
+    );
+    expect(taproot.fee).toBeGreaterThan(native.fee);
+  });
+
+  test('against a random set of generated utxos', () => {
+    const testData = createNullArrayOfLength(50).map(() => ({
+      value: Math.ceil(Math.random() * 10000),
+    }));
+    const amount = 29123n;
+    const result = determineUtxosForSpend({
+      utxos: testData as any,
+      recipients: [
+        {
+          address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+          amount: createMoney(Number(amount), 'BTC'),
+        },
+      ],
+      feeRate: 3,
+    });
+    expect(result.outputs[0].value).toEqual(29123n);
+
+    expect(result.outputs[1].value.toString()).toEqual(
+      sumNumbers(result.inputs.map(i => i.value))
+        .minus(result.fee)
+        .minus(amount.toString())
+        .toString()
+    );
+  });
+
+  test('that spending all economical spendable utxos does not result in dust utxos', () => {
+    const feeRate = 3;
+    const recipients = [
+      {
+        address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+        amount: createMoney(Number(1), 'BTC'),
+      },
+    ];
+    const filteredUtxos = filterUneconomicalUtxos({
+      utxos: demoUtxos.sort((a, b) => b.value - a.value) as any,
+      feeRate,
+      recipients,
+    });
+    const amount = filteredUtxos.reduce((total, utxo) => total + utxo.value, 0) - 2251;
+    recipients[0].amount = createMoney(Number(amount), 'BTC');
+
+    const result = determineUtxosForSpend({
+      utxos: filteredUtxos as any,
+      recipients: [
+        {
+          address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+          amount: createMoney(Number(amount), 'BTC'),
+        },
+      ],
+      feeRate,
+    });
+    expect(result.inputs.length).toEqual(10);
+    expect(result.outputs.length).toEqual(1);
+    expect(result.fee).toEqual(2251);
+  });
+
+  test('that spending all utxos with sendMax does not result in dust utxos', () => {
+    const utxos = [{ value: 1000 }, { value: 2000 }, { value: 3000 }];
+    const recipients = [
+      {
+        address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+        amount: createMoney(Number(1), 'BTC'),
+      },
+    ];
+    const sizeInfo = getSizeInfo({
+      inputLength: utxos.length,
+      isSendMax: true,
+      recipients,
+    });
+    const feeRate = 3;
+    const fee = Math.floor(sizeInfo.txVBytes * feeRate);
+    const amount = utxos.reduce((total, utxo) => total + utxo.value, 0) - fee;
+    recipients[0].amount = createMoney(Number(amount), 'BTC');
+
+    const result = determineUtxosForSpendAll({
+      utxos: utxos as any,
+      recipients,
+      feeRate,
+    });
+    expect(result.inputs.length).toEqual(utxos.length);
+    expect(result.outputs.length).toEqual(1);
+    expect(result.fee).toEqual(735);
+    expect(fee).toEqual(735);
+  });
+});

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

@@ -0,0 +1,140 @@
+import BigNumber from 'bignumber.js';
+import { validate } from 'bitcoin-address-validation';
+
+import { BTC_P2WPKH_DUST_AMOUNT } from '@leather.io/constants';
+import { sumMoney, sumNumbers } from '@leather.io/utils';
+
+import {
+  TransferRecipient,
+  Utxo,
+  filterUneconomicalUtxos,
+  getSizeInfo,
+} from './coin-selection.utils';
+
+export class InsufficientFundsError extends Error {
+  constructor() {
+    super('Insufficient funds');
+  }
+}
+
+interface Output {
+  value: bigint;
+  address?: string;
+}
+
+export interface DetermineUtxosForSpendArgs {
+  feeRate: number;
+  recipients: TransferRecipient[];
+  utxos: Utxo[];
+}
+
+function getUtxoTotal(utxos: Utxo[]) {
+  return sumNumbers(utxos.map(utxo => utxo.value));
+}
+
+export function determineUtxosForSpendAll({
+  feeRate,
+  recipients,
+  utxos,
+}: DetermineUtxosForSpendArgs) {
+  recipients.forEach(recipient => {
+    if (!validate(recipient.address))
+      throw new Error('Cannot calculate spend of invalid address type');
+  });
+  const filteredUtxos = filterUneconomicalUtxos({ utxos, feeRate, recipients });
+
+  const sizeInfo = getSizeInfo({
+    inputLength: filteredUtxos.length,
+    isSendMax: true,
+    recipients,
+  });
+
+  // Fee has already been deducted from the amount with send all
+  const outputs = recipients.map(({ address, amount }) => ({
+    value: BigInt(amount.amount.toNumber()),
+    address,
+  }));
+
+  const fee = Math.ceil(sizeInfo.txVBytes * feeRate);
+
+  return {
+    inputs: filteredUtxos,
+    outputs,
+    size: sizeInfo.txVBytes,
+    fee,
+  };
+}
+
+export function determineUtxosForSpend({ feeRate, recipients, utxos }: DetermineUtxosForSpendArgs) {
+  recipients.forEach(recipient => {
+    if (!validate(recipient.address))
+      throw new Error('Cannot calculate spend of invalid address type');
+  });
+  const filteredUtxos = filterUneconomicalUtxos({
+    utxos: utxos.sort((a, b) => b.value - a.value),
+    feeRate,
+    recipients,
+  });
+  if (!filteredUtxos.length) throw new InsufficientFundsError();
+
+  const amount = sumMoney(recipients.map(recipient => recipient.amount));
+
+  // Prepopulate with first UTXO, at least one is needed
+  const neededUtxos: Utxo[] = [filteredUtxos[0]];
+
+  function estimateTransactionSize() {
+    return getSizeInfo({
+      inputLength: neededUtxos.length,
+      recipients,
+    });
+  }
+
+  function hasSufficientUtxosForTx() {
+    const txEstimation = estimateTransactionSize();
+    const neededAmount = new BigNumber(txEstimation.txVBytes * feeRate).plus(amount.amount);
+    return getUtxoTotal(neededUtxos).isGreaterThanOrEqualTo(neededAmount);
+  }
+
+  function getRemainingUnspentUtxos() {
+    return filteredUtxos.filter(utxo => !neededUtxos.includes(utxo));
+  }
+
+  while (!hasSufficientUtxosForTx()) {
+    const [nextUtxo] = getRemainingUnspentUtxos();
+    if (!nextUtxo) throw new InsufficientFundsError();
+    neededUtxos.push(nextUtxo);
+  }
+
+  const fee = Math.ceil(
+    new BigNumber(estimateTransactionSize().txVBytes).multipliedBy(feeRate).toNumber()
+  );
+
+  const changeAmount =
+    BigInt(getUtxoTotal(neededUtxos).toString()) - BigInt(amount.amount.toNumber()) - BigInt(fee);
+
+  const changeUtxos: Output[] =
+    changeAmount > BTC_P2WPKH_DUST_AMOUNT
+      ? [
+          {
+            value: changeAmount,
+          },
+        ]
+      : [];
+
+  const outputs: Output[] = [
+    ...recipients.map(({ address, amount }) => ({
+      value: BigInt(amount.amount.toNumber()),
+      address,
+    })),
+    ...changeUtxos,
+  ];
+
+  return {
+    filteredUtxos,
+    inputs: neededUtxos,
+    outputs,
+    size: estimateTransactionSize().txVBytes,
+    fee,
+    ...estimateTransactionSize(),
+  };
+}

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

@@ -0,0 +1,64 @@
+import { createMoney } from '@leather.io/utils';
+
+import { mockUtxos } from './coin-selection.mocks';
+import { filterUneconomicalUtxos } from './coin-selection.utils';
+
+describe(filterUneconomicalUtxos.name, () => {
+  const recipients = [
+    {
+      address: '',
+      amount: createMoney(0, 'BTC'),
+    },
+  ];
+
+  test('with 1 sat/vb fee', () => {
+    const fee = 1;
+    const filteredUtxos = filterUneconomicalUtxos({
+      utxos: mockUtxos,
+      feeRate: fee,
+      recipients,
+    });
+
+    expect(filteredUtxos.length).toEqual(9);
+  });
+
+  test('with 10 sat/vb fee', () => {
+    const fee = 10;
+    const filteredUtxos = filterUneconomicalUtxos({
+      recipients,
+      utxos: mockUtxos,
+      feeRate: fee,
+    });
+    expect(filteredUtxos.length).toEqual(7);
+  });
+
+  test('with 30 sat/vb fee', () => {
+    const fee = 30;
+    const filteredUtxos = filterUneconomicalUtxos({
+      recipients,
+      utxos: mockUtxos,
+      feeRate: fee,
+    });
+    expect(filteredUtxos.length).toEqual(5);
+  });
+
+  test('with 200 sat/vb fee', () => {
+    const fee = 200;
+    const filteredUtxos = filterUneconomicalUtxos({
+      recipients,
+      utxos: mockUtxos,
+      feeRate: fee,
+    });
+    expect(filteredUtxos.length).toEqual(3);
+  });
+
+  test('with 400 sat/vb fee', () => {
+    const fee = 400;
+    const filteredUtxos = filterUneconomicalUtxos({
+      recipients,
+      utxos: mockUtxos,
+      feeRate: fee,
+    });
+    expect(filteredUtxos.length).toEqual(2);
+  });
+});

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

@@ -0,0 +1,118 @@
+import BigNumber from 'bignumber.js';
+import validate, { AddressInfo, AddressType, getAddressInfo } from 'bitcoin-address-validation';
+
+import { BTC_P2WPKH_DUST_AMOUNT } from '@leather.io/constants';
+import { Money } from '@leather.io/models';
+
+import { BtcSizeFeeEstimator } from '../btc-size-fee-estimator';
+
+export interface TransferRecipient {
+  address: string;
+  amount: Money;
+}
+
+export interface Utxo extends Record<string, any> {
+  txid: string;
+  value: number;
+}
+
+export function getSizeInfo(payload: {
+  inputLength: number;
+  recipients: TransferRecipient[];
+  isSendMax?: boolean;
+}) {
+  const { inputLength, recipients, isSendMax } = payload;
+
+  const validAddressesInfo = recipients
+    .map(recipient => validate(recipient.address) && getAddressInfo(recipient.address))
+    .filter(Boolean) as AddressInfo[];
+
+  function getTxOutputsLengthByPaymentType() {
+    return validAddressesInfo.reduce(
+      (acc, { type }) => {
+        acc[type] = (acc[type] || 0) + 1;
+        return acc;
+      },
+      {} as Record<AddressType, number>
+    );
+  }
+
+  const outputTypesCount = getTxOutputsLengthByPaymentType();
+
+  // Add a change address if not sending max (defaults to p2wpkh)
+  if (!isSendMax) {
+    outputTypesCount[AddressType.p2wpkh] = (outputTypesCount[AddressType.p2wpkh] || 0) + 1;
+  }
+
+  // Prepare the output data map for consumption by the txSizer
+  const outputsData = Object.entries(outputTypesCount).reduce(
+    (acc, [type, count]) => {
+      acc[type + '_output_count'] = count;
+      return acc;
+    },
+    {} as Record<string, number>
+  );
+
+  const txSizer = new BtcSizeFeeEstimator();
+  const sizeInfo = txSizer.calcTxSize({
+    input_script: 'p2wpkh',
+    input_count: inputLength,
+    ...outputsData,
+  });
+
+  return sizeInfo;
+}
+
+export function getSpendableAmount({
+  utxos,
+  feeRate,
+  recipients,
+}: {
+  utxos: Utxo[];
+  feeRate: number;
+  recipients: TransferRecipient[];
+}) {
+  const balance = utxos.map(utxo => utxo.value).reduce((prevVal, curVal) => prevVal + curVal, 0);
+
+  const size = getSizeInfo({
+    inputLength: utxos.length,
+    recipients,
+  });
+  const fee = Math.ceil(size.txVBytes * feeRate);
+  const bigNumberBalance = BigNumber(balance);
+  return {
+    spendableAmount: BigNumber.max(0, bigNumberBalance.minus(fee)),
+    fee,
+  };
+}
+
+// Check if the spendable amount drops when adding a utxo
+export function filterUneconomicalUtxos({
+  utxos,
+  feeRate,
+  recipients,
+}: {
+  utxos: Utxo[];
+  feeRate: number;
+  recipients: TransferRecipient[];
+}) {
+  const { spendableAmount: fullSpendableAmount } = getSpendableAmount({
+    utxos,
+    feeRate,
+    recipients,
+  });
+
+  const filteredUtxos = utxos
+    .filter(utxo => utxo.value >= BTC_P2WPKH_DUST_AMOUNT)
+    .filter(utxo => {
+      // Calculate spendableAmount without that utxo
+      const { spendableAmount } = getSpendableAmount({
+        utxos: utxos.filter(u => u.txid !== utxo.txid),
+        feeRate,
+        recipients,
+      });
+      // If fullSpendableAmount is greater, do not use that utxo
+      return spendableAmount.toNumber() < fullSpendableAmount.toNumber();
+    });
+  return filteredUtxos;
+}