@leather.io/bitcoin 0.17.0 → 0.18.0

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

@@ -2,34 +2,33 @@ 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');
-  }
-}
+import { Money } from '@leather.io/models';
+import { createMoney, sumMoney } from '@leather.io/utils';
+
+import { BitcoinError, BitcoinErrorMessage } from '../bitcoin-error';
+import { filterUneconomicalUtxos, getSizeInfo, getUtxoTotal } from './coin-selection.utils';
 
-interface Output {
+export interface CoinSelectionOutput {
   value: bigint;
   address?: string;
 }
 
-export interface DetermineUtxosForSpendArgs {
-  feeRate: number;
-  recipients: TransferRecipient[];
-  utxos: Utxo[];
+export interface CoinSelectionUtxo {
+  address: string;
+  txid: string;
+  value: number;
+  vout: number;
 }
 
-function getUtxoTotal(utxos: Utxo[]) {
-  return sumNumbers(utxos.map(utxo => utxo.value));
+export interface CoinSelectionRecipient {
+  address: string;
+  amount: Money;
+}
+
+export interface DetermineUtxosForSpendArgs {
+  feeRate: number;
+  recipients: CoinSelectionRecipient[];
+  utxos: CoinSelectionUtxo[];
 }
 
 export function determineUtxosForSpendAll({
@@ -61,7 +60,7 @@ export function determineUtxosForSpendAll({
     inputs: filteredUtxos,
     outputs,
     size: sizeInfo.txVBytes,
-    fee,
+    fee: createMoney(new BigNumber(fee), 'BTC'),
   };
 }
 
@@ -75,12 +74,12 @@ export function determineUtxosForSpend({ feeRate, recipients, utxos }: Determine
     feeRate,
     recipients,
   });
-  if (!filteredUtxos.length) throw new InsufficientFundsError();
+  if (!filteredUtxos.length) throw new BitcoinError(BitcoinErrorMessage.InsufficientFunds);
 
   const amount = sumMoney(recipients.map(recipient => recipient.amount));
 
-  // Prepopulate with first UTXO, at least one is needed
-  const neededUtxos: Utxo[] = [filteredUtxos[0]];
+  // Prepopulate with first utxo, at least one is needed
+  const neededUtxos: CoinSelectionUtxo[] = [filteredUtxos[0]];
 
   function estimateTransactionSize() {
     return getSizeInfo({
@@ -101,7 +100,7 @@ export function determineUtxosForSpend({ feeRate, recipients, utxos }: Determine
 
   while (!hasSufficientUtxosForTx()) {
     const [nextUtxo] = getRemainingUnspentUtxos();
-    if (!nextUtxo) throw new InsufficientFundsError();
+    if (!nextUtxo) throw new BitcoinError(BitcoinErrorMessage.InsufficientFunds);
     neededUtxos.push(nextUtxo);
   }
 
@@ -112,7 +111,7 @@ export function determineUtxosForSpend({ feeRate, recipients, utxos }: Determine
   const changeAmount =
     BigInt(getUtxoTotal(neededUtxos).toString()) - BigInt(amount.amount.toNumber()) - BigInt(fee);
 
-  const changeUtxos: Output[] =
+  const changeUtxos: CoinSelectionOutput[] =
     changeAmount > BTC_P2WPKH_DUST_AMOUNT
       ? [
           {
@@ -121,7 +120,7 @@ export function determineUtxosForSpend({ feeRate, recipients, utxos }: Determine
         ]
       : [];
 
-  const outputs: Output[] = [
+  const outputs: CoinSelectionOutput[] = [
     ...recipients.map(({ address, amount }) => ({
       value: BigInt(amount.amount.toNumber()),
       address,
@@ -134,7 +133,7 @@ export function determineUtxosForSpend({ feeRate, recipients, utxos }: Determine
     inputs: neededUtxos,
     outputs,
     size: estimateTransactionSize().txVBytes,
-    fee,
+    fee: createMoney(new BigNumber(fee), 'BTC'),
     ...estimateTransactionSize(),
   };
 }

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

@@ -6,7 +6,7 @@ import { filterUneconomicalUtxos } from './coin-selection.utils';
 describe(filterUneconomicalUtxos.name, () => {
   const recipients = [
     {
-      address: '',
+      address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
       amount: createMoney(0, 'BTC'),
     },
   ];

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

@@ -2,23 +2,18 @@ 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 { sumNumbers } from '@leather.io/utils';
 
 import { BtcSizeFeeEstimator } from '../btc-size-fee-estimator';
+import { CoinSelectionRecipient, CoinSelectionUtxo } from './coin-selection';
 
-export interface TransferRecipient {
-  address: string;
-  amount: Money;
-}
-
-export interface Utxo extends Record<string, any> {
-  txid: string;
-  value: number;
+export function getUtxoTotal(utxos: CoinSelectionUtxo[]) {
+  return sumNumbers(utxos.map(utxo => utxo.value));
 }
 
 export function getSizeInfo(payload: {
   inputLength: number;
-  recipients: TransferRecipient[];
+  recipients: CoinSelectionRecipient[];
   isSendMax?: boolean;
 }) {
   const { inputLength, recipients, isSendMax } = payload;
@@ -68,11 +63,13 @@ export function getSpendableAmount({
   feeRate,
   recipients,
 }: {
-  utxos: Utxo[];
+  utxos: CoinSelectionUtxo[];
   feeRate: number;
-  recipients: TransferRecipient[];
+  recipients: CoinSelectionRecipient[];
 }) {
-  const balance = utxos.map(utxo => utxo.value).reduce((prevVal, curVal) => prevVal + curVal, 0);
+  const balance = utxos
+    .map(utxo => Number(utxo.value))
+    .reduce((prevVal, curVal) => prevVal + curVal, 0);
 
   const size = getSizeInfo({
     inputLength: utxos.length,
@@ -92,9 +89,9 @@ export function filterUneconomicalUtxos({
   feeRate,
   recipients,
 }: {
-  utxos: Utxo[];
+  utxos: CoinSelectionUtxo[];
   feeRate: number;
-  recipients: TransferRecipient[];
+  recipients: CoinSelectionRecipient[];
 }) {
   const { spendableAmount: fullSpendableAmount } = getSpendableAmount({
     utxos,
@@ -111,7 +108,7 @@ export function filterUneconomicalUtxos({
         feeRate,
         recipients,
       });
-      // If fullSpendableAmount is greater, do not use that utxo
+      // If fullSpendableAmount is greater, do not use utxo
       return spendableAmount.toNumber() < fullSpendableAmount.toNumber();
     });
   return filteredUtxos;

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

@@ -0,0 +1,90 @@
+import BigNumber from 'bignumber.js';
+
+import { AverageBitcoinFeeRates } from '@leather.io/models';
+import { createMoney } from '@leather.io/utils';
+
+import { CoinSelectionRecipient, CoinSelectionUtxo } from '../coin-selection/coin-selection';
+import { getBitcoinFees, getBitcoinTransactionFee } from './bitcoin-fees';
+
+describe('getBitcoinTransactionFee', () => {
+  it('should return the fee for a normal transaction', () => {
+    const args = {
+      recipients: [
+        { address: 'tb1qsqncyhhqdtfn07t3dhupx7smv5gk83ds6k0gfa', amount: createMoney(1000, 'BTC') },
+      ],
+      utxos: [
+        {
+          address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+          txid: '8192e8e20088c5f052fc7351b86b8f60a9454937860b281227e53e19f3e9c3f6',
+          vout: 0,
+          value: 2000,
+        },
+      ],
+      feeRate: 1,
+    };
+    const fee = getBitcoinTransactionFee(args);
+    const expectedFee = createMoney(141, 'BTC');
+    expect(fee).toEqual(expectedFee);
+  });
+
+  it('should return the fee for a max send transaction', () => {
+    const args = {
+      isSendingMax: true,
+      recipients: [
+        { address: 'tb1qsqncyhhqdtfn07t3dhupx7smv5gk83ds6k0gfa', amount: createMoney(2000, 'BTC') },
+      ],
+      utxos: [
+        {
+          address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+          txid: '8192e8e20088c5f052fc7351b86b8f60a9454937860b281227e53e19f3e9c3f6',
+          vout: 0,
+          value: 2000,
+        },
+      ],
+      feeRate: 2,
+    };
+    const fee = getBitcoinTransactionFee(args);
+    const expectedFee = createMoney(219, 'BTC');
+    expect(fee).toEqual(expectedFee);
+  });
+
+  it('should return null if an error occurs', () => {
+    const args = {
+      recipients: [],
+      utxos: [],
+      feeRate: 1,
+    };
+    const fee = getBitcoinTransactionFee(args);
+    expect(fee).toBeNull();
+  });
+});
+
+describe('getBitcoinFees', () => {
+  it('should return the fees for different fee rates', () => {
+    const feeRates: AverageBitcoinFeeRates = {
+      fastestFee: new BigNumber(3),
+      halfHourFee: new BigNumber(2),
+      hourFee: new BigNumber(1),
+    };
+    const recipients: CoinSelectionRecipient[] = [
+      { address: 'tb1qsqncyhhqdtfn07t3dhupx7smv5gk83ds6k0gfa', amount: createMoney(1000, 'BTC') },
+    ];
+    const utxos: CoinSelectionUtxo[] = [
+      {
+        address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+        txid: '8192e8e20088c5f052fc7351b86b8f60a9454937860b281227e53e19f3e9c3f6',
+        vout: 0,
+        value: 2000,
+      },
+    ];
+
+    const fees = getBitcoinFees({ feeRates, recipients, utxos });
+    const expectedFees = {
+      high: { feeRate: 3, fee: createMoney(422, 'BTC') },
+      standard: { feeRate: 2, fee: createMoney(281, 'BTC') },
+      low: { feeRate: 1, fee: createMoney(141, 'BTC') },
+    };
+
+    expect(fees).toEqual(expectedFees);
+  });
+});

package/src/fees/bitcoin-fees.ts

@@ -0,0 +1,68 @@
+import { AverageBitcoinFeeRates, Money } from '@leather.io/models';
+
+import {
+  CoinSelectionRecipient,
+  CoinSelectionUtxo,
+  DetermineUtxosForSpendArgs,
+  determineUtxosForSpend,
+  determineUtxosForSpendAll,
+} from '../coin-selection/coin-selection';
+
+type GetBitcoinTransactionFeeArgs = DetermineUtxosForSpendArgs & {
+  isSendingMax?: boolean;
+};
+
+export function getBitcoinTransactionFee({ isSendingMax, ...props }: GetBitcoinTransactionFeeArgs) {
+  try {
+    const { fee } = isSendingMax
+      ? determineUtxosForSpendAll({ ...props })
+      : determineUtxosForSpend({ ...props });
+    return fee;
+  } catch (error) {
+    return null;
+  }
+}
+
+export interface BitcoinFees {
+  blockchain: 'bitcoin';
+  high: { fee: Money | null; feeRate: number };
+  standard: { fee: Money | null; feeRate: number };
+  low: { fee: Money | null; feeRate: number };
+}
+
+export interface GetBitcoinFeesArgs {
+  feeRates: AverageBitcoinFeeRates;
+  isSendingMax?: boolean;
+  recipients: CoinSelectionRecipient[];
+  utxos: CoinSelectionUtxo[];
+}
+export function getBitcoinFees({ feeRates, isSendingMax, recipients, utxos }: GetBitcoinFeesArgs) {
+  const defaultArgs = {
+    isSendingMax,
+    recipients,
+    utxos,
+  };
+
+  const highFeeRate = feeRates.fastestFee.toNumber();
+  const standardFeeRate = feeRates.halfHourFee.toNumber();
+  const lowFeeRate = feeRates.hourFee.toNumber();
+
+  const highFeeValue = getBitcoinTransactionFee({
+    ...defaultArgs,
+    feeRate: highFeeRate,
+  });
+  const standardFeeValue = getBitcoinTransactionFee({
+    ...defaultArgs,
+    feeRate: standardFeeRate,
+  });
+  const lowFeeValue = getBitcoinTransactionFee({
+    ...defaultArgs,
+    feeRate: lowFeeRate,
+  });
+
+  return {
+    high: { feeRate: highFeeRate, fee: highFeeValue },
+    standard: { feeRate: standardFeeRate, fee: standardFeeValue },
+    low: { feeRate: lowFeeRate, fee: lowFeeValue },
+  };
+}

package/src/index.ts

@@ -1,5 +1,15 @@
 export * from './bip322/bip322-utils';
 export * from './bip322/sign-message-bip322-bitcoinjs';
+
+export * from './coin-selection/calculate-max-spend';
+export * from './coin-selection/coin-selection';
+export * from './coin-selection/coin-selection.utils';
+
+export * from './fees/bitcoin-fees';
+
+export * from './transactions/generate-unsigned-transaction';
+
+export * from './bitcoin-error';
 export * from './bitcoin-signer';
 export * from './bitcoin.network';
 export * from './bitcoin.utils';

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

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest';
+
+import { createMoney } from '@leather.io/utils';
+
+import { getBtcSignerLibNetworkConfigByMode } from '../bitcoin.network';
+import {
+  GenerateBitcoinUnsignedTransactionArgs,
+  generateBitcoinUnsignedTransactionNativeSegwit,
+} from './generate-unsigned-transaction';
+
+const mockResult = {
+  inputs: [
+    {
+      address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+      txid: 'c715ea469c8d794f6dd7e0043148631f69d411c428ef0ab2b04e4528ffe8319f',
+      vout: 1,
+      value: 200000,
+    },
+  ],
+  fee: createMoney(141, 'BTC'),
+};
+
+describe('generateBitcoinUnsignedTransactionNativeSegwit', () => {
+  const mockArgs: GenerateBitcoinUnsignedTransactionArgs = {
+    feeRate: 1,
+    isSendingMax: false,
+    network: getBtcSignerLibNetworkConfigByMode('testnet'),
+    payerAddress: 'tb1qxy5r9rlmpcxgwp92x2594q3gg026y4kdv2rsl8',
+    payerPublicKey: '0329b076bc20f7b1592b2a1a5cb91dfefe8c966e50e256458e23dd2c5d63f8f1af',
+    recipients: [
+      {
+        address: 'tb1qsqncyhhqdtfn07t3dhupx7smv5gk83ds6k0gfa',
+        amount: createMoney(150000, 'BTC'),
+      },
+    ],
+    utxos: [
+      {
+        address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+        txid: '8192e8e20088c5f052fc7351b86b8f60a9454937860b281227e53e19f3e9c3f6',
+        vout: 0,
+        value: 100000,
+      },
+      {
+        address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+        txid: 'c715ea469c8d794f6dd7e0043148631f69d411c428ef0ab2b04e4528ffe8319f',
+        vout: 1,
+        value: 200000,
+      },
+    ],
+  };
+
+  it('should generate an unsigned transaction with correct inputs and outputs', async () => {
+    const result = await generateBitcoinUnsignedTransactionNativeSegwit(mockArgs);
+    if (result) {
+      expect(result.inputs).toEqual(mockResult.inputs);
+      expect(result.fee).toEqual(mockResult.fee);
+      expect(result.hex).toBeDefined();
+      expect(result.psbt).toBeDefined();
+    }
+  });
+
+  it('should add change address to output correctly', async () => {
+    const result = await generateBitcoinUnsignedTransactionNativeSegwit(mockArgs);
+
+    if (result) {
+      expect(result.tx.outputsLength).toBe(2);
+      expect(result.tx.getOutput(1).script).toBeDefined();
+    }
+  });
+
+  it('should throw an error if inputs are empty', async () => {
+    const argsWithNoInputs: GenerateBitcoinUnsignedTransactionArgs = {
+      ...mockArgs,
+      utxos: [],
+    };
+
+    const result = await generateBitcoinUnsignedTransactionNativeSegwit(argsWithNoInputs);
+
+    if (result) {
+      expect(result.inputs.length).toBe(0);
+    }
+  });
+});

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

@@ -0,0 +1,71 @@
+import { hexToBytes } from '@noble/hashes/utils';
+import * as btc from '@scure/btc-signer';
+
+import { BitcoinError, BitcoinErrorMessage } from '../bitcoin-error';
+import { BtcSignerNetwork } from '../bitcoin.network';
+import {
+  CoinSelectionRecipient,
+  CoinSelectionUtxo,
+  determineUtxosForSpend,
+  determineUtxosForSpendAll,
+} from '../coin-selection/coin-selection';
+
+export interface GenerateBitcoinUnsignedTransactionArgs {
+  feeRate: number;
+  isSendingMax?: boolean;
+  payerAddress: string;
+  payerPublicKey: string;
+  network: BtcSignerNetwork;
+  recipients: CoinSelectionRecipient[];
+  utxos: CoinSelectionUtxo[];
+}
+
+export async function generateBitcoinUnsignedTransactionNativeSegwit({
+  feeRate,
+  isSendingMax,
+  payerAddress,
+  payerPublicKey,
+  network,
+  recipients,
+  utxos,
+}: GenerateBitcoinUnsignedTransactionArgs) {
+  try {
+    const determineUtxosArgs = { feeRate, recipients, utxos };
+    const { inputs, outputs, fee } = isSendingMax
+      ? determineUtxosForSpendAll(determineUtxosArgs)
+      : determineUtxosForSpend(determineUtxosArgs);
+
+    if (!inputs.length) throw new BitcoinError(BitcoinErrorMessage.NoInputsToSign);
+    if (!outputs.length) throw new BitcoinError(BitcoinErrorMessage.NoOutputsToSign);
+
+    const tx = new btc.Transaction();
+    const p2wpkh = btc.p2wpkh(hexToBytes(payerPublicKey), network);
+
+    for (const input of inputs) {
+      tx.addInput({
+        txid: input.txid,
+        index: input.vout,
+        sequence: 0,
+        witnessUtxo: {
+          // script = 0014 + pubKeyHash
+          script: p2wpkh.script,
+          amount: BigInt(input.value),
+        },
+      });
+    }
+
+    outputs.forEach(output => {
+      // When coin selection returns an output with no address,
+      // we assume it is a change output
+      if (!output.address) {
+        tx.addOutputAddress(payerAddress, BigInt(output.value), network);
+        return;
+      }
+      tx.addOutputAddress(output.address, BigInt(output.value), network);
+    });
+
+    return { tx, hex: tx.hex, psbt: tx.toPSBT(), inputs, fee };
+  } catch (e) {
+    return null;
+  }
+}