@leather.io/bitcoin 0.26.8 → 0.26.10

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

@@ -3,14 +3,13 @@ import BigNumber from 'bignumber.js';
 import type { AverageBitcoinFeeRates, Money } from '@leather.io/models';
 import { createMoney, satToBtc } from '@leather.io/utils';
 
-import { CoinSelectionUtxo } from './coin-selection';
 import { filterUneconomicalUtxos, getSpendableAmount } from './coin-selection.utils';
 
 interface CalculateMaxSpendArgs {
   // recipient is intentionally string instead of BitcoinAddress, as it's being validated
   // with a fallback in a subroutine.
   recipient: string;
-  utxos: CoinSelectionUtxo[];
+  utxos: { value: number; txid: string }[];
   feeRates?: AverageBitcoinFeeRates;
   feeRate?: number;
 }

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

@@ -2,7 +2,7 @@ import { sha256 } from '@noble/hashes/sha256';
 import { hexToBytes } from '@noble/hashes/utils';
 import BigNumber from 'bignumber.js';
 
-import { CoinSelectionUtxo } from './coin-selection';
+import { OwnedUtxo } from '@leather.io/models';
 
 function generateMockHex() {
   return Math.floor(Math.random() * 0xffffff)
@@ -10,9 +10,11 @@ function generateMockHex() {
     .padEnd(6, '0');
 }
 
-function generateMockUtxo(value: number): CoinSelectionUtxo {
+function generateMockUtxo(value: number): OwnedUtxo {
   return {
     address: 'tb1qxy5r9rlmpcxgwp92x2594q3gg026y4kdv2rsl8',
+    path: `m/84'/1'/0'/0/0`,
+    keyOrigin: `deadbeef/84'/1'/0'/0/0`,
     txid: sha256(sha256(hexToBytes(generateMockHex()))).toString(),
     value,
     vout: 0,

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

@@ -13,29 +13,21 @@ export interface CoinSelectionOutput {
   address?: string;
 }
 
-export interface CoinSelectionUtxo {
-  address: string;
-  txid: string;
-  value: number;
-  vout: number;
-}
-
 export interface CoinSelectionRecipient {
   address: string;
   amount: Money;
 }
 
-export interface DetermineUtxosForSpendArgs {
+export interface DetermineUtxosForSpendArgs<T> {
   feeRate: number;
   recipients: CoinSelectionRecipient[];
-  utxos: CoinSelectionUtxo[];
+  utxos: T[];
 }
-
-export function determineUtxosForSpendAll({
+export function determineUtxosForSpendAll<T extends { value: number; txid: string }>({
   feeRate,
   recipients,
   utxos,
-}: DetermineUtxosForSpendArgs) {
+}: DetermineUtxosForSpendArgs<T>) {
   recipients.forEach(recipient => {
     if (!validate(recipient.address)) throw new BitcoinError('InvalidAddress');
   });
@@ -63,7 +55,11 @@ export function determineUtxosForSpendAll({
   };
 }
 
-export function determineUtxosForSpend({ feeRate, recipients, utxos }: DetermineUtxosForSpendArgs) {
+export function determineUtxosForSpend<T extends { value: number; txid: string }>({
+  feeRate,
+  recipients,
+  utxos,
+}: DetermineUtxosForSpendArgs<T>) {
   recipients.forEach(recipient => {
     if (!validate(recipient.address)) throw new BitcoinError('InvalidAddress');
   });
@@ -77,7 +73,7 @@ export function determineUtxosForSpend({ feeRate, recipients, utxos }: Determine
   const amount = sumMoney(recipients.map(recipient => recipient.amount));
 
   // Prepopulate with first utxo, at least one is needed
-  const neededUtxos: CoinSelectionUtxo[] = [filteredUtxos[0]];
+  const neededUtxos: T[] = [filteredUtxos[0]];
 
   function estimateTransactionSize() {
     return getSizeInfo({

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

@@ -5,9 +5,9 @@ import { BTC_P2WPKH_DUST_AMOUNT } from '@leather.io/constants';
 import { sumNumbers } from '@leather.io/utils';
 
 import { BtcSizeFeeEstimator } from '../fees/btc-size-fee-estimator';
-import { CoinSelectionRecipient, CoinSelectionUtxo } from './coin-selection';
+import { CoinSelectionRecipient } from './coin-selection';
 
-export function getUtxoTotal(utxos: CoinSelectionUtxo[]) {
+export function getUtxoTotal<T extends { value: number }>(utxos: T[]) {
   return sumNumbers(utxos.map(utxo => utxo.value));
 }
 
@@ -57,16 +57,18 @@ export function getSizeInfo(payload: {
 
   return sizeInfo;
 }
-interface GetSpendableAmountArgs {
-  utxos: CoinSelectionUtxo[];
+interface GetSpendableAmountArgs<T> {
+  utxos: T[];
   feeRate: number;
   recipients: CoinSelectionRecipient[];
   isSendMax?: boolean;
 }
-export function getSpendableAmount({ utxos, feeRate, recipients }: GetSpendableAmountArgs) {
-  const balance = utxos
-    .map(utxo => Number(utxo.value))
-    .reduce((prevVal, curVal) => prevVal + curVal, 0);
+export function getSpendableAmount<T extends { value: number }>({
+  utxos,
+  feeRate,
+  recipients,
+}: GetSpendableAmountArgs<T>) {
+  const balance = utxos.map(utxo => utxo.value).reduce((prevVal, curVal) => prevVal + curVal, 0);
 
   const size = getSizeInfo({
     inputLength: utxos.length,
@@ -81,12 +83,12 @@ export function getSpendableAmount({ utxos, feeRate, recipients }: GetSpendableA
 }
 
 // Check if the spendable amount drops when adding a utxo
-export function filterUneconomicalUtxos({
+export function filterUneconomicalUtxos<T extends { value: number; txid: string }>({
   utxos,
   feeRate,
   recipients,
 }: {
-  utxos: CoinSelectionUtxo[];
+  utxos: T[];
   feeRate: number;
   recipients: CoinSelectionRecipient[];
 }) {
@@ -97,7 +99,7 @@ export function filterUneconomicalUtxos({
   });
 
   const filteredUtxos = utxos
-    .filter(utxo => utxo.value >= BTC_P2WPKH_DUST_AMOUNT)
+    .filter(utxo => Number(utxo.value) >= BTC_P2WPKH_DUST_AMOUNT)
     .filter(utxo => {
       // Calculate spendableAmount without that utxo
       const { spendableAmount } = getSpendableAmount({

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

@@ -3,7 +3,7 @@ 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 { CoinSelectionRecipient } from '../coin-selection/coin-selection';
 import { recipientAddress, taprootAddress } from '../mocks/mocks';
 import { getBitcoinFees, getBitcoinTransactionFee } from './bitcoin-fees';
 
@@ -66,13 +66,13 @@ describe('getBitcoinFees', () => {
     const recipients: CoinSelectionRecipient[] = [
       { address: recipientAddress, amount: createMoney(1000, 'BTC') },
     ];
-    const utxos: CoinSelectionUtxo[] = [
+    const utxos = [
       {
         address: taprootAddress,
         txid: '8192e8e20088c5f052fc7351b86b8f60a9454937860b281227e53e19f3e9c3f6',
         vout: 0,
         value: 2000,
-      },
+      } as const,
     ];
 
     const fees = getBitcoinFees({ feeRates, recipients, utxos });

package/src/fees/bitcoin-fees.ts

@@ -2,13 +2,12 @@ import { AverageBitcoinFeeRates, Money } from '@leather.io/models';
 
 import {
   CoinSelectionRecipient,
-  CoinSelectionUtxo,
   DetermineUtxosForSpendArgs,
   determineUtxosForSpend,
   determineUtxosForSpendAll,
 } from '../coin-selection/coin-selection';
 
-type GetBitcoinTransactionFeeArgs = DetermineUtxosForSpendArgs & {
+type GetBitcoinTransactionFeeArgs = DetermineUtxosForSpendArgs<{ value: number; txid: string }> & {
   isSendingMax?: boolean;
 };
 
@@ -34,7 +33,7 @@ export interface GetBitcoinFeesArgs {
   feeRates: AverageBitcoinFeeRates;
   isSendingMax?: boolean;
   recipients: CoinSelectionRecipient[];
-  utxos: CoinSelectionUtxo[];
+  utxos: { value: number; txid: string }[];
 }
 export function getBitcoinFees({ feeRates, isSendingMax, recipients, utxos }: GetBitcoinFeesArgs) {
   const defaultArgs = {

package/src/signer/bitcoin-signer.ts

@@ -9,6 +9,8 @@ import {
   appendAddressIndexToPath,
   decomposeDescriptor,
   deriveKeychainFromXpub,
+  extractAddressIndexFromPath,
+  extractChangeIndexFromPath,
   keyOriginToDerivationPath,
 } from '@leather.io/crypto';
 import type { BitcoinAddress, BitcoinNetworkModes, ValueOf } from '@leather.io/models';
@@ -83,7 +85,7 @@ export function initializeBitcoinAccountKeychainFromDescriptor(
 }
 
 export interface BitcoinPayerInfo {
-  receive?: number;
+  change: number;
   addressIndex: number;
 }
 export function deriveBitcoinPayerFromAccount(descriptor: string, network: BitcoinNetworkModes) {
@@ -94,8 +96,8 @@ export function deriveBitcoinPayerFromAccount(descriptor: string, network: Bitco
   if (accountKeychain.depth !== DerivationPathDepth.Account)
     throw new Error('Keychain passed is not an account');
 
-  return ({ receive = 0, addressIndex }: BitcoinPayerInfo) => {
-    const childKeychain = accountKeychain.deriveChild(receive).deriveChild(addressIndex);
+  return ({ change, addressIndex }: BitcoinPayerInfo) => {
+    const childKeychain = accountKeychain.deriveChild(change).deriveChild(addressIndex);
 
     const derivePayerFromAccount = whenSupportedPaymentType(paymentType)({
       p2tr: getTaprootPaymentFromAddressIndex,
@@ -105,7 +107,7 @@ export function deriveBitcoinPayerFromAccount(descriptor: string, network: Bitco
     const payment = derivePayerFromAccount(childKeychain, network);
 
     return {
-      keyOrigin: appendAddressIndexToPath(keyOrigin, 0),
+      keyOrigin: appendAddressIndexToPath(keyOrigin, change, addressIndex),
       masterKeyFingerprint: fingerprint,
       paymentType,
       network,
@@ -213,6 +215,13 @@ export function payerToBip32DerivationBitcoinJsLib(
   };
 }
 
+export function extractPayerInfoFromDerivationPath(path: string) {
+  return {
+    change: extractChangeIndexFromPath(path),
+    addressIndex: extractAddressIndexFromPath(path),
+  };
+}
+
 /**
  * @description
  * Turns key format from @scure/btc-signer lib back into key origin string

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

@@ -1,18 +1,26 @@
-import { hexToBytes } from '@noble/hashes/utils';
+import { hex } from '@scure/base';
+import * as btc from '@scure/btc-signer';
 import { describe, expect, it } from 'vitest';
 
+import { OwnedUtxo } from '@leather.io/models';
 import { createMoney } from '@leather.io/utils';
 
 import { getBtcSignerLibNetworkConfigByMode } from '../utils/bitcoin.network';
+import { createBitcoinAddress } from '../validation/bitcoin-address';
 import {
   GenerateBitcoinUnsignedTransactionArgs,
-  generateBitcoinUnsignedTransactionNativeSegwit,
+  generateBitcoinUnsignedTransaction,
 } from './generate-unsigned-transaction';
 
+const publicKey = hex.decode('030000000000000000000000000000000000000000000000000000000000000001');
+const payment = btc.p2wpkh(publicKey, btc.TEST_NETWORK);
+
 const mockResult = {
   inputs: [
     {
-      address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+      path: "m/84'/1'/0'/0/1",
+      keyOrigin: "deadbeef/84'/1'/0'/0/1",
+      address: payment.address!,
       txid: 'c715ea469c8d794f6dd7e0043148631f69d411c428ef0ab2b04e4528ffe8319f',
       vout: 1,
       value: 200000,
@@ -21,19 +29,12 @@ const mockResult = {
   fee: createMoney(141, 'BTC'),
 };
 
-describe('generateBitcoinUnsignedTransactionNativeSegwit', () => {
-  const mockArgs: GenerateBitcoinUnsignedTransactionArgs = {
+describe(generateBitcoinUnsignedTransaction.name, () => {
+  const mockArgs: GenerateBitcoinUnsignedTransactionArgs<OwnedUtxo> = {
     feeRate: 1,
     isSendingMax: false,
     network: getBtcSignerLibNetworkConfigByMode('testnet'),
-    payerAddress: 'tb1qxy5r9rlmpcxgwp92x2594q3gg026y4kdv2rsl8',
-    payerPublicKey: '0329b076bc20f7b1592b2a1a5cb91dfefe8c966e50e256458e23dd2c5d63f8f1af',
-    bip32Derivation: [
-      [
-        hexToBytes('0329b076bc20f7b1592b2a1a5cb91dfefe8c966e50e256458e23dd2c5d63f8f1af'),
-        { fingerprint: 400738063, path: [2147483732, 2147483649, 2147483648, 0, 0] },
-      ],
-    ],
+    changeAddress: createBitcoinAddress(payment.address!),
     recipients: [
       {
         address: 'tb1qsqncyhhqdtfn07t3dhupx7smv5gk83ds6k0gfa',
@@ -42,22 +43,40 @@ describe('generateBitcoinUnsignedTransactionNativeSegwit', () => {
     ],
     utxos: [
       {
-        address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+        address: payment.address!,
+        path: "m/84'/1'/0'/0/0",
+        keyOrigin: "deadbeef/84'/1'/0'/0/0",
         txid: '8192e8e20088c5f052fc7351b86b8f60a9454937860b281227e53e19f3e9c3f6',
         vout: 0,
         value: 100000,
       },
       {
-        address: 'tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m',
+        address: payment.address!,
+        path: "m/84'/1'/0'/0/1",
+        keyOrigin: "deadbeef/84'/1'/0'/0/1",
         txid: 'c715ea469c8d794f6dd7e0043148631f69d411c428ef0ab2b04e4528ffe8319f',
         vout: 1,
         value: 200000,
       },
     ],
+    payerLookup() {
+      return {
+        paymentType: 'p2wpkh',
+        address: createBitcoinAddress(payment.address!),
+        keyOrigin: "deadbeef/84'/1'/0'/0/0",
+        masterKeyFingerprint: 'deadbeef',
+        network: 'testnet',
+        payment: {
+          script: payment.script,
+          type: 'p2wpkh',
+        },
+        publicKey,
+      };
+    },
   };
 
   it('should generate an unsigned transaction with correct inputs and outputs', () => {
-    const result = generateBitcoinUnsignedTransactionNativeSegwit(mockArgs);
+    const result = generateBitcoinUnsignedTransaction(mockArgs);
     if (result) {
       expect(result.inputs).toEqual(mockResult.inputs);
       expect(result.fee).toEqual(mockResult.fee);
@@ -67,7 +86,7 @@ describe('generateBitcoinUnsignedTransactionNativeSegwit', () => {
   });
 
   it('should add change address to output correctly', () => {
-    const result = generateBitcoinUnsignedTransactionNativeSegwit(mockArgs);
+    const result = generateBitcoinUnsignedTransaction(mockArgs);
 
     if (result) {
       expect(result.tx.outputsLength).toBe(2);
@@ -76,12 +95,12 @@ describe('generateBitcoinUnsignedTransactionNativeSegwit', () => {
   });
 
   it('should throw an error if inputs are empty', () => {
-    const argsWithNoInputs: GenerateBitcoinUnsignedTransactionArgs = {
+    const argsWithNoInputs: GenerateBitcoinUnsignedTransactionArgs<any> = {
       ...mockArgs,
       utxos: [],
     };
 
-    expect(() => generateBitcoinUnsignedTransactionNativeSegwit(argsWithNoInputs)).toThrowError(
+    expect(() => generateBitcoinUnsignedTransaction(argsWithNoInputs)).toThrowError(
       'InsufficientFunds'
     );
   });

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

@@ -1,37 +1,39 @@
-import { hexToBytes } from '@noble/hashes/utils';
 import * as btc from '@scure/btc-signer';
 
 import {
   CoinSelectionRecipient,
-  CoinSelectionUtxo,
   determineUtxosForSpend,
   determineUtxosForSpendAll,
 } from '../coin-selection/coin-selection';
-import { BtcSignerDefaultBip32Derivation } from '../signer/bitcoin-signer';
+import {
+  BitcoinNativeSegwitPayer,
+  BitcoinTaprootPayer,
+  payerToBip32Derivation,
+  payerToTapBip32Derivation,
+} from '../signer/bitcoin-signer';
 import { BtcSignerNetwork } from '../utils/bitcoin.network';
 import { BitcoinError } from '../validation/bitcoin-error';
 
-export interface GenerateBitcoinUnsignedTransactionArgs {
+export interface GenerateBitcoinUnsignedTransactionArgs<T> {
   feeRate: number;
   isSendingMax?: boolean;
-  payerAddress: string;
-  payerPublicKey: string;
-  bip32Derivation: BtcSignerDefaultBip32Derivation[];
   network: BtcSignerNetwork;
   recipients: CoinSelectionRecipient[];
-  utxos: CoinSelectionUtxo[];
+  utxos: T[];
+  changeAddress: string;
+  payerLookup(keyOrigin: string): BitcoinNativeSegwitPayer | BitcoinTaprootPayer | undefined;
 }
-
-export function generateBitcoinUnsignedTransactionNativeSegwit({
+export function generateBitcoinUnsignedTransaction<
+  T extends { txid: string; vout: number; value: number; keyOrigin: string },
+>({
   feeRate,
   isSendingMax,
-  payerAddress,
-  payerPublicKey,
-  bip32Derivation,
   network,
   recipients,
+  changeAddress,
   utxos,
-}: GenerateBitcoinUnsignedTransactionArgs) {
+  payerLookup,
+}: GenerateBitcoinUnsignedTransactionArgs<T>) {
   const determineUtxosArgs = { feeRate, recipients, utxos };
   const { inputs, outputs, fee } = isSendingMax
     ? determineUtxosForSpendAll(determineUtxosArgs)
@@ -41,19 +43,33 @@ export function generateBitcoinUnsignedTransactionNativeSegwit({
   if (!outputs.length) throw new BitcoinError('NoOutputsToSign');
 
   const tx = new btc.Transaction();
-  const p2wpkh = btc.p2wpkh(hexToBytes(payerPublicKey), network);
 
   for (const input of inputs) {
+    const payer = payerLookup(input.keyOrigin);
+
+    if (!payer) {
+      // eslint-disable-next-line no-console
+      console.log(`No payer found for input with keyOrigin ${input.keyOrigin}`);
+      continue;
+    }
+
+    const bip32Derivation =
+      payer.paymentType === 'p2tr'
+        ? { tapBip32Derivation: [payerToTapBip32Derivation(payer)] }
+        : { bip32Derivation: [payerToBip32Derivation(payer)] };
+
+    const tapInternalKey =
+      payer.paymentType === 'p2tr' ? { tapInternalKey: payer.payment.tapInternalKey } : {};
+
     tx.addInput({
       txid: input.txid,
       index: input.vout,
-      sequence: 0,
-      bip32Derivation,
       witnessUtxo: {
-        // script = 0014 + pubKeyHash
-        script: p2wpkh.script,
+        script: payer.payment.script,
         amount: BigInt(input.value),
       },
+      ...bip32Derivation,
+      ...tapInternalKey,
     });
   }
 
@@ -61,7 +77,7 @@ export function generateBitcoinUnsignedTransactionNativeSegwit({
     // 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);
+      tx.addOutputAddress(changeAddress, BigInt(output.value), network);
       return;
     }
     tx.addOutputAddress(output.address, BigInt(output.value), network);