@leather.io/bitcoin 0.35.8 → 0.36.3

package/package.json

@@ -2,7 +2,7 @@
   "name": "@leather.io/bitcoin",
   "author": "Leather.io contact@leather.io",
   "description": "Shared bitcoin utilities",
-  "version": "0.35.8",
+  "version": "0.36.3",
   "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.28.4",
-    "@leather.io/crypto": "1.12.10",
-    "@leather.io/models": "0.51.0",
-    "@leather.io/utils": "0.49.4"
+    "@leather.io/constants": "0.30.0",
+    "@leather.io/crypto": "1.12.13",
+    "@leather.io/utils": "0.49.7",
+    "@leather.io/models": "0.52.0"
   },
   "devDependencies": {
     "prettier": "3.5.1",
@@ -44,9 +44,9 @@
     "typescript": "5.9.3",
     "vitest": "2.1.9",
     "@leather.io/prettier-config": "0.9.0",
+    "@leather.io/rpc": "2.21.7",
     "@leather.io/test-config": "0.1.2",
-    "@leather.io/tsconfig-config": "0.11.1",
-    "@leather.io/rpc": "2.21.4"
+    "@leather.io/tsconfig-config": "0.11.1"
   },
   "keywords": [
     "bitcoin",
@@ -60,7 +60,7 @@
   "types": "./dist/index.d.ts",
   "scripts": {
     "build": "tsdown",
-    "build:watch": "tsdown --watch",
+    "build:watch": "tsdown --no-clean --watch",
     "format": "prettier . --write --ignore-path ../../.prettierignore",
     "format:check": "prettier . --check --ignore-path ../../.prettierignore",
     "lint": "eslint --cache --max-warnings 0",

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

@@ -1,55 +1,50 @@
 import { createBitcoinAddress } from '../validation/bitcoin-address';
 import { calculateMaxSpend } from './calculate-max-spend';
-import { generateMockAverageFee, mockUtxos } from './coin-selection.mocks';
+import { mockUtxos } from './coin-selection.mocks';
 
 const recipient = createBitcoinAddress('');
 describe(calculateMaxSpend.name, () => {
   test('with 1 sat/vb fee', () => {
-    const fee = 1;
     const maxBitcoinSpend = calculateMaxSpend({
       recipient,
       utxos: mockUtxos,
-      feeRates: generateMockAverageFee(fee),
+      feeRate: 1,
     });
     expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50087948);
   });
 
   test('with 5 sat/vb fee', () => {
-    const fee = 5;
     const maxBitcoinSpend = calculateMaxSpend({
       recipient,
       utxos: mockUtxos,
-      feeRates: generateMockAverageFee(fee),
+      feeRate: 5,
     });
     expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50085342);
   });
 
   test('with 30 sat/vb fee', () => {
-    const fee = 30;
     const maxBitcoinSpend = calculateMaxSpend({
       recipient,
       utxos: mockUtxos,
-      feeRates: generateMockAverageFee(fee),
+      feeRate: 30,
     });
     expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50073585);
   });
 
   test('with 100 sat/vb fee', () => {
-    const fee = 100;
     const maxBitcoinSpend = calculateMaxSpend({
       recipient,
       utxos: mockUtxos,
-      feeRates: generateMockAverageFee(fee),
+      feeRate: 100,
     });
     expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(50046950);
   });
 
   test('with 400 sat/vb fee', () => {
-    const fee = 400;
     const maxBitcoinSpend = calculateMaxSpend({
       recipient,
       utxos: mockUtxos,
-      feeRates: generateMockAverageFee(fee),
+      feeRate: 400,
     });
     expect(maxBitcoinSpend.amount.amount.toNumber()).toEqual(49969100);
   });

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

@@ -1,17 +1,14 @@
 import BigNumber from 'bignumber.js';
 
-import type { AverageBitcoinFeeRates, Money } from '@leather.io/models';
+import type { Money } from '@leather.io/models';
 import { createMoney, satToBtc } from '@leather.io/utils';
 
 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.
+interface CalculateMaxSpendParams {
   recipient: string;
   utxos: { value: number; txid: string }[];
-  feeRates?: AverageBitcoinFeeRates;
-  feeRate?: number;
+  feeRate: number;
 }
 
 export interface CalculateMaxSpendResponse {
@@ -23,26 +20,23 @@ export function calculateMaxSpend({
   recipient,
   utxos,
   feeRate,
-  feeRates,
-}: CalculateMaxSpendArgs): CalculateMaxSpendResponse {
-  if (!utxos.length || !feeRates)
+}: CalculateMaxSpendParams): CalculateMaxSpendResponse {
+  if (!utxos.length)
     return {
       spendAllFee: 0,
       amount: createMoney(0, 'BTC'),
       spendableBitcoin: new BigNumber(0),
     };
 
-  const currentFeeRate = feeRate ?? feeRates.halfHourFee.toNumber();
-
   const filteredUtxos = filterUneconomicalUtxos({
     utxos,
-    feeRate: currentFeeRate,
+    feeRate,
     recipients: [{ address: recipient, amount: createMoney(0, 'BTC') }],
   });
 
   const { spendableAmount, fee } = getSpendableAmount({
     utxos: filteredUtxos,
-    feeRate: currentFeeRate,
+    feeRate,
     recipients: [{ address: recipient, amount: createMoney(0, 'BTC') }],
     isSendMax: true,
   });

package/src/index.ts

@@ -30,9 +30,9 @@ export * from './validation/address-validation';
 export * from './validation/amount-validation';
 export * from './validation/bitcoin-address';
 export * from './validation/bitcoin-error';
-export * from './validation/transaction-validation';
 
 export * from './utils/bitcoin.descriptors';
 export * from './utils/bitcoin.network';
 export * from './utils/bitcoin.utils';
 export * from './utils/lookup-derivation-by-address';
+export * from './utils/deconstruct-btc-address';

package/src/payments/p2tr-address-gen.spec.ts

@@ -1,8 +1,14 @@
 import { HDKey } from '@scure/bip32';
 import { mnemonicToSeedSync } from '@scure/bip39';
 
+import { extractAddressIndexFromPath, extractChangeIndexFromPath } from '@leather.io/crypto';
+
 import { deriveAddressIndexKeychainFromAccount } from '../utils/bitcoin.utils';
-import { deriveTaprootAccount, getTaprootPaymentFromAddressIndex } from './p2tr-address-gen';
+import {
+  deriveTaprootAccount,
+  getTaprootPaymentFromAddressIndex,
+  makeTaprootAddressIndexDerivationPath,
+} from './p2tr-address-gen';
 
 // TODO: this is a SECRET_KEY from @tests/mocks folder.
 // Temporary until we move @tests/mocks folder to monorepo.
@@ -11,27 +17,73 @@ export const SECRET_KEY =
 
 // Source:
 // generated in Sparrow with same secret key used in tests
-const addresses = [
-  'tb1p05uectcay8ptepqneycknxf0ewvdejcl0zdqex98ux87w7tzqjfsd7yxyl',
-  'tb1papsqvj9s2yn9mavhtuk9jyw4arlwcxey33n49g02rpjcajx88qrszpytxl',
-  'tb1pfnegsp8x0gnjrgzu0p5xrltrms50prpl8c5a3rwfcrp9p9vumnfsv7zn84',
-  'tb1pzqp06cvvcmftc4g69kuqt5z59k3uyuuwzsg796c00scav0vxjevs3gsvpr',
-  'tb1p2acyvr7wzvdr2m9fprg2e48k03rjvvq8au680jtrxqrz5m9m5kdsurrp2z',
-  'tb1p3kautzlyralsnxf2fv7rudlgyhu6u0lcvzdnlhaywl4h8l7yk0ds59lvfg',
-];
+const addresses = {
+  "m/86'/0'/0'/0/0": 'tb1p05uectcay8ptepqneycknxf0ewvdejcl0zdqex98ux87w7tzqjfsd7yxyl',
+  "m/86'/0'/0'/1/0": 'tb1p8vf4ljcj43f0dqd8xprsf2w8g8wcqktsmly2rd92sh235nnjlg6qf2g4c6',
+  "m/86'/0'/0'/0/1": 'tb1papsqvj9s2yn9mavhtuk9jyw4arlwcxey33n49g02rpjcajx88qrszpytxl',
+  "m/86'/0'/0'/1/1": 'tb1p40xhx5m44fznk6vzxmyn4grlgmzunwrx3slqwzslg8rag9r236vsqmnkf3',
+  "m/86'/0'/0'/0/2": 'tb1pfnegsp8x0gnjrgzu0p5xrltrms50prpl8c5a3rwfcrp9p9vumnfsv7zn84',
+  "m/86'/0'/0'/1/2": 'tb1pn98uf3ln2lxn6n99rkk7nxx5u54g9rrlcfe2ere0w7m3hww93vuqrwmwwy',
+  "m/86'/0'/0'/0/3": 'tb1pzqp06cvvcmftc4g69kuqt5z59k3uyuuwzsg796c00scav0vxjevs3gsvpr',
+  "m/86'/0'/0'/1/3": 'tb1pnap8rexj2gqcjtq3vncav29duu4ungcys0kgcste5sdy04mg98usfcp90t',
+  "m/86'/0'/0'/0/4": 'tb1p2acyvr7wzvdr2m9fprg2e48k03rjvvq8au680jtrxqrz5m9m5kdsurrp2z',
+  "m/86'/0'/0'/1/4": 'tb1p4ssvcjmhuzlvwp48828zswvktjw8g6s9lwrcq5ecc5yjqwv5pp9s9624v6',
+  "m/86'/0'/0'/0/5": 'tb1p3kautzlyralsnxf2fv7rudlgyhu6u0lcvzdnlhaywl4h8l7yk0ds59lvfg',
+  "m/86'/0'/0'/1/5": 'tb1p3m3yxhjtnq86r9s62h6t9cnweu5se07c0srdureyly3z9kny68pqc5cnnn',
+};
 
 describe('taproot address gen', () => {
-  test.each(addresses)('should generate taproot addresses', address => {
-    const keychain = HDKey.fromMasterSeed(mnemonicToSeedSync(SECRET_KEY));
-    const index = addresses.indexOf(address);
-    const accountZero = deriveTaprootAccount(keychain, 'testnet')(0);
-
-    const addressIndexDetails = getTaprootPaymentFromAddressIndex(
-      deriveAddressIndexKeychainFromAccount(accountZero.keychain)(index),
-      'testnet'
-    );
-    if (!accountZero.keychain.privateKey) throw new Error('No private key found');
-
-    expect(addressIndexDetails.address).toEqual(address);
+  test.each(Object.entries(addresses))(
+    'should generate taproot addresses',
+    (derivationPath, address) => {
+      const keychain = HDKey.fromMasterSeed(mnemonicToSeedSync(SECRET_KEY));
+      const addressIndex = extractAddressIndexFromPath(derivationPath);
+      const changeIndex = extractChangeIndexFromPath(derivationPath);
+      const accountZero = deriveTaprootAccount(keychain, 'testnet')(0);
+
+      const addressIndexDetails = getTaprootPaymentFromAddressIndex(
+        deriveAddressIndexKeychainFromAccount(accountZero.keychain)({
+          addressIndex,
+          changeIndex,
+        }),
+        'testnet'
+      );
+      if (!accountZero.keychain.privateKey) throw new Error('No private key found');
+
+      expect(addressIndexDetails.address).toEqual(address);
+    }
+  );
+});
+
+describe(makeTaprootAddressIndexDerivationPath.name, () => {
+  it('creates mainnet receive path', () => {
+    expect(
+      makeTaprootAddressIndexDerivationPath({
+        network: 'mainnet',
+        accountIndex: 5,
+        changeIndex: 0,
+        addressIndex: 0,
+      })
+    ).toEqual("m/86'/0'/5'/0/0");
+  });
+  it('creates mainnet change path', () => {
+    expect(
+      makeTaprootAddressIndexDerivationPath({
+        network: 'mainnet',
+        accountIndex: 42,
+        changeIndex: 1,
+        addressIndex: 5,
+      })
+    ).toEqual("m/86'/0'/42'/1/5");
+  });
+  it('creates testnet change path', () => {
+    expect(
+      makeTaprootAddressIndexDerivationPath({
+        network: 'testnet',
+        accountIndex: 0,
+        changeIndex: 1,
+        addressIndex: 1,
+      })
+    ).toEqual("m/86'/1'/0'/1/1");
   });
 });

package/src/payments/p2tr-address-gen.ts

@@ -21,12 +21,20 @@ export function makeTaprootAccountDerivationPath(
 /** @deprecated Use makeTaprootAccountDerivationPath */
 export const getTaprootAccountDerivationPath = makeTaprootAccountDerivationPath;
 
-export function makeTaprootAddressIndexDerivationPath(
-  network: BitcoinNetworkModes,
-  accountIndex: number,
-  addressIndex: number
-) {
-  return makeTaprootAccountDerivationPath(network, accountIndex) + `/0/${addressIndex}`;
+export function makeTaprootAddressIndexDerivationPath({
+  network,
+  accountIndex,
+  changeIndex,
+  addressIndex,
+}: {
+  network: BitcoinNetworkModes;
+  accountIndex: number;
+  changeIndex: number;
+  addressIndex: number;
+}) {
+  return (
+    makeTaprootAccountDerivationPath(network, accountIndex) + `/${changeIndex}/${addressIndex}`
+  );
 }
 /** @deprecated Use makeTaprootAddressIndexDerivationPath */
 export const getTaprootAddressIndexDerivationPath = makeTaprootAddressIndexDerivationPath;

package/src/payments/p2wpkh-address-gen.spec.ts

@@ -1,6 +1,9 @@
 import { deriveKeychainFromXpub } from '@leather.io/crypto';
 
-import { deriveNativeSegwitReceiveAddressIndexZero } from './p2wpkh-address-gen';
+import {
+  deriveNativeSegwitReceiveAddressIndexZero,
+  makeNativeSegwitAddressIndexDerivationPath,
+} from './p2wpkh-address-gen';
 
 describe('Bitcoin bech32 (P2WPKH address derivation', () => {
   describe('from extended public key', () => {
@@ -46,3 +49,36 @@ describe('Bitcoin bech32 (P2WPKH address derivation', () => {
     });
   });
 });
+
+describe(makeNativeSegwitAddressIndexDerivationPath.name, () => {
+  it('creates mainnet receive path', () => {
+    expect(
+      makeNativeSegwitAddressIndexDerivationPath({
+        network: 'mainnet',
+        accountIndex: 5,
+        changeIndex: 0,
+        addressIndex: 0,
+      })
+    ).toEqual("m/84'/0'/5'/0/0");
+  });
+  it('creates mainnet change path', () => {
+    expect(
+      makeNativeSegwitAddressIndexDerivationPath({
+        network: 'mainnet',
+        accountIndex: 42,
+        changeIndex: 1,
+        addressIndex: 5,
+      })
+    ).toEqual("m/84'/0'/42'/1/5");
+  });
+  it('creates testnet change path', () => {
+    expect(
+      makeNativeSegwitAddressIndexDerivationPath({
+        network: 'testnet',
+        accountIndex: 0,
+        changeIndex: 1,
+        addressIndex: 1,
+      })
+    ).toEqual("m/84'/1'/0'/1/1");
+  });
+});

package/src/payments/p2wpkh-address-gen.ts

@@ -21,12 +21,20 @@ export function makeNativeSegwitAccountDerivationPath(
 /** @deprecated Use makeNativeSegwitAccountDerivationPath */
 export const getNativeSegwitAccountDerivationPath = makeNativeSegwitAccountDerivationPath;
 
-export function makeNativeSegwitAddressIndexDerivationPath(
-  network: BitcoinNetworkModes,
-  accountIndex: number,
-  addressIndex: number
-) {
-  return makeNativeSegwitAccountDerivationPath(network, accountIndex) + `/0/${addressIndex}`;
+export function makeNativeSegwitAddressIndexDerivationPath({
+  network,
+  accountIndex,
+  changeIndex,
+  addressIndex,
+}: {
+  network: BitcoinNetworkModes;
+  accountIndex: number;
+  changeIndex: number;
+  addressIndex: number;
+}) {
+  return (
+    makeNativeSegwitAccountDerivationPath(network, accountIndex) + `/${changeIndex}/${addressIndex}`
+  );
 }
 
 /** @deprecated Use makeNativeSegwitAddressIndexDerivationPath */

package/src/utils/bitcoin.descriptors.ts

@@ -71,15 +71,27 @@ export function deriveAddressesFromDescriptor({
 
   const results: DeriveAddressesFromDescriptorResult[] = [];
 
-  for (let i = 0; i < limit; i++) {
-    const address = whenSupportedPaymentType(paymentType)({
-      p2tr: getTaprootAddress({ index: i, keychain: accountKeychain, network }),
-      p2wpkh: getNativeSegwitAddress({ index: i, keychain: accountKeychain, network }),
-    });
-    results.push({
-      address,
-      path: derivationPathFn(network, accountKeychain.index - HARDENED_OFFSET, i),
-    });
+  for (let addressIndex = 0; addressIndex < limit; ++addressIndex) {
+    for (let changeIndex = 0; changeIndex < 2; ++changeIndex) {
+      const address = whenSupportedPaymentType(paymentType)({
+        p2tr: getTaprootAddress({ addressIndex, changeIndex, keychain: accountKeychain, network }),
+        p2wpkh: getNativeSegwitAddress({
+          addressIndex,
+          changeIndex,
+          keychain: accountKeychain,
+          network,
+        }),
+      });
+      results.push({
+        address,
+        path: derivationPathFn({
+          network,
+          accountIndex: accountKeychain.index - HARDENED_OFFSET,
+          addressIndex,
+          changeIndex,
+        }),
+      });
+    }
   }
   return results;
 }

package/src/utils/bitcoin.utils.spec.ts

@@ -1,7 +1,20 @@
 import { describe, expect, it } from 'vitest';
 
+import { deriveRootKeychainFromMnemonic } from '@leather.io/crypto';
+import { testMnemonic } from '@leather.io/test-config';
+
+import { deriveTaprootAccount } from '../payments/p2tr-address-gen';
+import { deriveNativeSegwitAccountFromRootKeychain } from '../payments/p2wpkh-address-gen';
 import { createBitcoinAddress } from '../validation/bitcoin-address';
-import { inferNetworkFromAddress, inferPaymentTypeFromAddress } from './bitcoin.utils';
+import {
+  deriveAddressIndexZeroFromAccount,
+  getNativeSegwitAddress,
+  getTaprootAddress,
+  inferNetworkFromAddress,
+  inferPaymentTypeFromAddress,
+  isNativeSegwitDerivationPath,
+  isTaprootDerivationPath,
+} from './bitcoin.utils';
 
 describe(inferNetworkFromAddress.name, () => {
   it('should return "mainnet" for P2PKH mainnet addresses', () => {
@@ -83,3 +96,99 @@ describe(inferPaymentTypeFromAddress.name, () => {
     expect(inferPaymentTypeFromAddress(address)).toBe('p2tr');
   });
 });
+
+describe(getNativeSegwitAddress.name, async () => {
+  const rootKeychain = await deriveRootKeychainFromMnemonic(testMnemonic);
+
+  const nativeSegwitKeychain = deriveNativeSegwitAccountFromRootKeychain(rootKeychain, 'mainnet');
+  it('creates mainnet receive address', () => {
+    expect(
+      getNativeSegwitAddress({
+        network: 'mainnet',
+        keychain: nativeSegwitKeychain(5).keychain,
+        changeIndex: 0,
+        addressIndex: 0,
+      })
+    ).toEqual('bc1q32mr73d2hynzw8wwdg58ek62fll0hsl8n9d2cn');
+  });
+  it('creates mainnet change address', () => {
+    expect(
+      getNativeSegwitAddress({
+        network: 'mainnet',
+        keychain: nativeSegwitKeychain(42).keychain,
+        changeIndex: 1,
+        addressIndex: 5,
+      })
+    ).toEqual('bc1qph55pqy085m9ktqz5w7c70dznkkjhyw2wpxh9t');
+  });
+  it('creates testnet change address', () => {
+    expect(
+      getNativeSegwitAddress({
+        network: 'testnet',
+        keychain: nativeSegwitKeychain(0).keychain,
+        changeIndex: 1,
+        addressIndex: 1,
+      })
+    ).toEqual('tb1qy4qarz6r4n283hez44sxrtanz6adkg04r86nlt');
+  });
+});
+
+describe(getTaprootAddress.name, async () => {
+  const rootKeychain = await deriveRootKeychainFromMnemonic(testMnemonic);
+  const taprootKeychain = deriveTaprootAccount(rootKeychain, 'mainnet');
+  it('creates mainnet receive address', () => {
+    expect(
+      getTaprootAddress({
+        network: 'mainnet',
+        keychain: taprootKeychain(5).keychain,
+        changeIndex: 0,
+        addressIndex: 0,
+      })
+    ).toEqual('bc1p3afedj4370xaqhj8yj5nv2pksh8xh2xzz5xdk5pg42twxh0xyx6ql4kwwk');
+  });
+  it('creates mainnet change address', () => {
+    expect(
+      getTaprootAddress({
+        network: 'mainnet',
+        keychain: taprootKeychain(42).keychain,
+        changeIndex: 1,
+        addressIndex: 5,
+      })
+    ).toEqual('bc1phj8a25u5wdvcc936uv3usu36l680jt2g3ddgc7thy6hu934e9ltqx7fmnk');
+  });
+  it('creates testnet change address', () => {
+    expect(
+      getTaprootAddress({
+        network: 'testnet',
+        keychain: taprootKeychain(0).keychain,
+        changeIndex: 1,
+        addressIndex: 1,
+      })
+    ).toEqual('tb1p7heq86wmpyj26fjt97yhuq2f5z6xk5nhhkc4xx64lu77ufsdhl0s73c6u5');
+  });
+});
+
+describe(deriveAddressIndexZeroFromAccount.name, async () => {
+  const rootKeychain = await deriveRootKeychainFromMnemonic(testMnemonic);
+  const taprootKeychain = deriveTaprootAccount(rootKeychain, 'mainnet');
+  const accountKeychain = taprootKeychain(0).keychain;
+  const changeKeychain = accountKeychain.deriveChild(0);
+  expect(accountKeychain.fingerprint).toBe(changeKeychain.parentFingerprint);
+
+  const addressKeychain = deriveAddressIndexZeroFromAccount(accountKeychain);
+  expect(changeKeychain.fingerprint).toBe(addressKeychain.parentFingerprint);
+});
+
+describe(isTaprootDerivationPath.name, () => {
+  test('should correctly check taproot derivation path', () => {
+    expect(isTaprootDerivationPath("m/86'/1'/3'/0/5")).toBe(true);
+    expect(isTaprootDerivationPath("m/84'/0'/5'/1/7")).toBe(false);
+  });
+});
+
+describe(isNativeSegwitDerivationPath.name, () => {
+  test('should correctly check native segwit derivation path', () => {
+    expect(isNativeSegwitDerivationPath("m/86'/1'/3'/0/5")).toBe(false);
+    expect(isNativeSegwitDerivationPath("m/84'/0'/5'/1/7")).toBe(true);
+  });
+});

package/src/utils/bitcoin.utils.ts

@@ -78,11 +78,15 @@ export function deriveAddressIndexKeychainFromAccount(keychain: HDKey) {
   if (keychain.depth !== DerivationPathDepth.Account)
     throw new Error('Keychain passed is not an account');
 
-  return (index: number) => keychain.deriveChild(0).deriveChild(index);
+  return ({ changeIndex, addressIndex }: { changeIndex: number; addressIndex: number }) =>
+    keychain.deriveChild(changeIndex).deriveChild(addressIndex);
 }
 
 export function deriveAddressIndexZeroFromAccount(keychain: HDKey) {
-  return deriveAddressIndexKeychainFromAccount(keychain)(0);
+  return deriveAddressIndexKeychainFromAccount(keychain)({
+    changeIndex: 0,
+    addressIndex: 0,
+  });
 }
 
 export const ecdsaPublicKeyLength = 33;
@@ -268,38 +272,55 @@ export function lookUpLedgerKeysByPath(
 }
 
 interface GetAddressArgs {
-  index: number;
+  changeIndex: number;
+  addressIndex: number;
   keychain?: HDKey;
   network: BitcoinNetworkModes;
 }
 
-export function getTaprootAddress({ index, keychain, network }: GetAddressArgs) {
+export function getTaprootAddress({
+  changeIndex,
+  addressIndex,
+  keychain,
+  network,
+}: GetAddressArgs) {
   if (!keychain) throw new Error('Expected keychain to be provided');
 
   if (keychain.depth !== DerivationPathDepth.Account)
     throw new Error('Expects keychain to be on the account index');
 
-  const addressIndex = deriveAddressIndexKeychainFromAccount(keychain)(index);
+  const addresskeychain = deriveAddressIndexKeychainFromAccount(keychain)({
+    changeIndex,
+    addressIndex,
+  });
 
-  if (!addressIndex.publicKey) throw new Error('Expected publicKey to be defined');
+  if (!addresskeychain.publicKey) throw new Error('Expected publicKey to be defined');
 
-  const payment = getTaprootPayment(addressIndex.publicKey, network);
+  const payment = getTaprootPayment(addresskeychain.publicKey, network);
 
   if (!payment.address) throw new Error('Expected address to be defined');
   return payment.address;
 }
 
-export function getNativeSegwitAddress({ index, keychain, network }: GetAddressArgs) {
+export function getNativeSegwitAddress({
+  changeIndex,
+  addressIndex,
+  keychain,
+  network,
+}: GetAddressArgs) {
   if (!keychain) throw new Error('Expected keychain to be provided');
 
   if (keychain.depth !== DerivationPathDepth.Account)
     throw new Error('Expects keychain to be on the account index');
 
-  const addressIndex = deriveAddressIndexKeychainFromAccount(keychain)(index);
+  const addressKeychain = deriveAddressIndexKeychainFromAccount(keychain)({
+    changeIndex,
+    addressIndex,
+  });
 
-  if (!addressIndex.publicKey) throw new Error('Expected publicKey to be defined');
+  if (!addressKeychain.publicKey) throw new Error('Expected publicKey to be defined');
 
-  const payment = getNativeSegwitPaymentFromAddressIndex(addressIndex, network);
+  const payment = getNativeSegwitPaymentFromAddressIndex(addressKeychain, network);
 
   if (!payment.address) throw new Error('Expected address to be defined');
   return payment.address;
@@ -359,3 +380,11 @@ export function getBitcoinInputValue(input: TransactionInput) {
   // logger.warn('Unable to find either `witnessUtxo` or `nonWitnessUtxo` in input. Defaulting to 0');
   return 0;
 }
+
+export function isTaprootDerivationPath(path: string) {
+  return extractPurposeFromPath(path) === 86;
+}
+
+export function isNativeSegwitDerivationPath(path: string) {
+  return extractPurposeFromPath(path) === 84;
+}

package/src/utils/deconstruct-btc-address.ts

@@ -0,0 +1,32 @@
+import { AddressType, getAddressInfo } from 'bitcoin-address-validation';
+import * as bitcoin from 'bitcoinjs-lib';
+
+export function deconstructBtcAddress(address: string) {
+  const typeMapping = {
+    [AddressType.p2pkh]: '0x00',
+    [AddressType.p2sh]: '0x01',
+    [AddressType.p2wpkh]: '0x04',
+    [AddressType.p2wsh]: '0x05',
+    [AddressType.p2tr]: '0x06',
+  };
+
+  const addressInfo = getAddressInfo(address);
+
+  const { bech32 } = addressInfo;
+  let hashbytes: Uint8Array;
+  if (bech32) {
+    hashbytes = bitcoin.address.fromBech32(address).data;
+  } else {
+    hashbytes = bitcoin.address.fromBase58Check(address).hash;
+  }
+
+  const type = typeMapping[addressInfo.type];
+  if (!type) {
+    throw new Error(`Unsupported address type: ${addressInfo.type}`);
+  }
+
+  return {
+    type,
+    hashbytes,
+  };
+}