@leather.io/bitcoin 0.8.0

package/src/bitcoin.utils.ts

@@ -0,0 +1,277 @@
+import { hexToBytes } from '@noble/hashes/utils';
+import { HDKey, Versions } from '@scure/bip32';
+import { mnemonicToSeedSync } from '@scure/bip39';
+import * as btc from '@scure/btc-signer';
+import { TransactionInput, TransactionOutput } from '@scure/btc-signer/psbt';
+
+import { DerivationPathDepth, extractAccountIndexFromPath } from '@leather.io/crypto';
+import { BitcoinNetworkModes, NetworkModes } from '@leather.io/models';
+import type { PaymentTypes } from '@leather.io/rpc';
+import { defaultWalletKeyId, isDefined, whenNetwork } from '@leather.io/utils';
+
+import { BtcSignerNetwork, getBtcSignerLibNetworkConfigByMode } from './bitcoin.network';
+import { getTaprootPayment } from './p2tr-address-gen';
+
+export interface BitcoinAccount {
+  type: PaymentTypes;
+  derivationPath: string;
+  keychain: HDKey;
+  accountIndex: number;
+  network: BitcoinNetworkModes;
+}
+export function initBitcoinAccount(derivationPath: string, policy: string): BitcoinAccount {
+  const xpub = extractExtendedPublicKeyFromPolicy(policy);
+  const network = inferNetworkFromPath(derivationPath);
+  return {
+    keychain: HDKey.fromExtendedKey(xpub, getHdKeyVersionsFromNetwork(network)),
+    network,
+    derivationPath,
+    type: inferPaymentTypeFromPath(derivationPath),
+    accountIndex: extractAccountIndexFromPath(derivationPath),
+  };
+}
+
+/**
+ * Represents a map of `BitcoinNetworkModes` to `NetworkModes`. While Bitcoin
+ * has a number of networks, its often only necessary to consider the higher
+ * level concepts of mainnet and testnet
+ */
+export const bitcoinNetworkToCoreNetworkMap: Record<BitcoinNetworkModes, NetworkModes> = {
+  mainnet: 'mainnet',
+  testnet: 'testnet',
+  regtest: 'testnet',
+  signet: 'testnet',
+};
+export function bitcoinNetworkModeToCoreNetworkMode(mode: BitcoinNetworkModes) {
+  return bitcoinNetworkToCoreNetworkMap[mode];
+}
+
+/**
+ * Map representing the "Coin Type" section of a derivation path.
+ * Consider example below, Coin type is one, thus testnet
+ * @example
+ * `m/86'/1'/0'/0/0`
+ */
+export const coinTypeMap: Record<NetworkModes, 0 | 1> = {
+  mainnet: 0,
+  testnet: 1,
+};
+
+export function getBitcoinCoinTypeIndexByNetwork(network: BitcoinNetworkModes) {
+  return coinTypeMap[bitcoinNetworkModeToCoreNetworkMode(network)];
+}
+
+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);
+}
+
+export function deriveAddressIndexZeroFromAccount(keychain: HDKey) {
+  return deriveAddressIndexKeychainFromAccount(keychain)(0);
+}
+
+export const ecdsaPublicKeyLength = 33;
+
+export function ecdsaPublicKeyToSchnorr(pubKey: Uint8Array) {
+  if (pubKey.byteLength !== ecdsaPublicKeyLength) throw new Error('Invalid public key length');
+  return pubKey.slice(1);
+}
+
+// Basically same as above, to remove
+export const toXOnly = (pubKey: Buffer) => (pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33));
+
+export function decodeBitcoinTx(tx: string): ReturnType<typeof btc.RawTx.decode> {
+  return btc.RawTx.decode(hexToBytes(tx));
+}
+
+export function getAddressFromOutScript(script: Uint8Array, bitcoinNetwork: BtcSignerNetwork) {
+  const outputScript = btc.OutScript.decode(script);
+
+  if (outputScript.type === 'pk' || outputScript.type === 'tr') {
+    return btc.Address(bitcoinNetwork).encode({
+      type: outputScript.type,
+      pubkey: outputScript.pubkey,
+    });
+  }
+  if (outputScript.type === 'ms' || outputScript.type === 'tr_ms') {
+    return btc.Address(bitcoinNetwork).encode({
+      type: outputScript.type,
+      pubkeys: outputScript.pubkeys,
+      m: outputScript.m,
+    });
+  }
+  if (outputScript.type === 'tr_ns') {
+    return btc.Address(bitcoinNetwork).encode({
+      type: outputScript.type,
+      pubkeys: outputScript.pubkeys,
+    });
+  }
+  if (outputScript.type === 'unknown') {
+    return 'unknown';
+  }
+  return btc.Address(bitcoinNetwork).encode({
+    type: outputScript.type,
+    hash: outputScript.hash,
+  });
+}
+
+/**
+ * Payment type identifiers, as described by `@scure/btc-signer` library
+ */
+export type BtcSignerLibPaymentTypeIdentifers = 'wpkh' | 'wsh' | 'tr' | 'pkh' | 'sh';
+
+export const paymentTypeMap: Record<BtcSignerLibPaymentTypeIdentifers, PaymentTypes> = {
+  wpkh: 'p2wpkh',
+  wsh: 'p2wpkh-p2sh',
+  tr: 'p2tr',
+  pkh: 'p2pkh',
+  sh: 'p2sh',
+};
+
+export function btcSignerLibPaymentTypeToPaymentTypeMap(
+  payment: BtcSignerLibPaymentTypeIdentifers
+) {
+  return paymentTypeMap[payment];
+}
+
+export function isBtcSignerLibPaymentType(
+  payment: string
+): payment is BtcSignerLibPaymentTypeIdentifers {
+  return payment in paymentTypeMap;
+}
+
+export function parseKnownPaymentType(payment: BtcSignerLibPaymentTypeIdentifers | PaymentTypes) {
+  return isBtcSignerLibPaymentType(payment)
+    ? btcSignerLibPaymentTypeToPaymentTypeMap(payment)
+    : payment;
+}
+
+export type PaymentTypeMap<T> = Record<PaymentTypes, T>;
+export function whenPaymentType(mode: PaymentTypes | BtcSignerLibPaymentTypeIdentifers) {
+  return <T extends unknown>(paymentMap: PaymentTypeMap<T>): T =>
+    paymentMap[parseKnownPaymentType(mode)];
+}
+
+/**
+ * Infers the Bitcoin payment type from the derivation path.
+ * Below we see path has 86 in it, per convention, this refers to taproot payments
+ * @example
+ * `m/86'/1'/0'/0/0`
+ */
+export function inferPaymentTypeFromPath(path: string): PaymentTypes {
+  if (path.startsWith('m/84')) return 'p2wpkh';
+  if (path.startsWith('m/86')) return 'p2tr';
+  if (path.startsWith('m/44')) return 'p2pkh';
+  throw new Error(`Unable to infer payment type from path=${path}`);
+}
+
+export function inferNetworkFromPath(path: string): NetworkModes {
+  return path.split('/')[2].startsWith('0') ? 'mainnet' : 'testnet';
+}
+
+export function extractExtendedPublicKeyFromPolicy(policy: string) {
+  return policy.split(']')[1];
+}
+
+export function createWalletIdDecoratedPath(policy: string, walletId: string) {
+  return policy.split(']')[0].replace('[', '').replace('m', walletId);
+}
+
+// Primarily used to get the correct `Version` when passing Ledger Bitcoin
+// extended public keys to the HDKey constructor
+export function getHdKeyVersionsFromNetwork(network: NetworkModes) {
+  return whenNetwork(network)({
+    mainnet: undefined,
+    testnet: {
+      private: 0x00000000,
+      public: 0x043587cf,
+    } as Versions,
+  });
+}
+
+export function getBitcoinInputAddress(input: TransactionInput, bitcoinNetwork: BtcSignerNetwork) {
+  if (isDefined(input.witnessUtxo))
+    return getAddressFromOutScript(input.witnessUtxo.script, bitcoinNetwork);
+  if (isDefined(input.nonWitnessUtxo) && isDefined(input.index))
+    return getAddressFromOutScript(
+      input.nonWitnessUtxo.outputs[input.index]?.script,
+      bitcoinNetwork
+    );
+  return '';
+}
+
+export function getInputPaymentType(
+  input: TransactionInput,
+  network: BitcoinNetworkModes
+): PaymentTypes {
+  const address = getBitcoinInputAddress(input, getBtcSignerLibNetworkConfigByMode(network));
+  if (address === '') throw new Error('Input address cannot be empty');
+  if (address.startsWith('bc1p') || address.startsWith('tb1p') || address.startsWith('bcrt1p'))
+    return 'p2tr';
+  if (address.startsWith('bc1q') || address.startsWith('tb1q') || address.startsWith('bcrt1q'))
+    return 'p2wpkh';
+  throw new Error('Unable to infer payment type from input address');
+}
+
+// Ledger wallets are keyed by their derivation path. To reuse the look up logic
+// between payment types, this factory fn accepts a fn that generates the path
+export function lookUpLedgerKeysByPath(
+  getDerivationPath: (network: BitcoinNetworkModes, accountIndex: number) => string
+) {
+  return (
+      ledgerKeyMap: Record<string, { policy: string } | undefined>,
+      network: BitcoinNetworkModes
+    ) =>
+    (accountIndex: number) => {
+      const path = getDerivationPath(network, accountIndex);
+      // Single wallet mode, hardcoded default walletId
+      const account = ledgerKeyMap[path.replace('m', defaultWalletKeyId)];
+      if (!account) return;
+      return initBitcoinAccount(path, account.policy);
+    };
+}
+
+export interface GetTaprootAddressArgs {
+  index: number;
+  keychain?: HDKey;
+  network: BitcoinNetworkModes;
+}
+export function getTaprootAddress({ index, keychain, network }: GetTaprootAddressArgs) {
+  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);
+
+  if (!addressIndex.publicKey) {
+    throw new Error('Expected publicKey to be defined');
+  }
+
+  const payment = getTaprootPayment(addressIndex.publicKey, network);
+
+  if (!payment.address) throw new Error('Expected address to be defined');
+
+  return payment.address;
+}
+
+export function mnemonicToRootNode(secretKey: string) {
+  const seed = mnemonicToSeedSync(secretKey);
+  return HDKey.fromMasterSeed(seed);
+}
+
+export function getPsbtTxInputs(psbtTx: btc.Transaction): TransactionInput[] {
+  const inputsLength = psbtTx.inputsLength;
+  const inputs: TransactionInput[] = [];
+  for (let i = 0; i < inputsLength; i++) inputs.push(psbtTx.getInput(i));
+  return inputs;
+}
+
+export function getPsbtTxOutputs(psbtTx: btc.Transaction): TransactionOutput[] {
+  const outputsLength = psbtTx.outputsLength;
+  const outputs: TransactionOutput[] = [];
+  for (let i = 0; i < outputsLength; i++) outputs.push(psbtTx.getOutput(i));
+  return outputs;
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './bip322/bip322-utils';
+export * from './bip322/sign-message-bip322-bitcoinjs';
+export * from './bitcoin-signer';
+export * from './bitcoin.network';
+export * from './bitcoin.utils';
+export * from './p2tr-address-gen';
+export * from './p2wpkh-address-gen';
+export * from './p2wsh-p2sh-address-gen';

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

@@ -0,0 +1,37 @@
+import { HDKey } from '@scure/bip32';
+import { mnemonicToSeedSync } from '@scure/bip39';
+
+import { deriveAddressIndexKeychainFromAccount } from './bitcoin.utils';
+import { deriveTaprootAccount, getTaprootPaymentFromAddressIndex } from './p2tr-address-gen';
+
+// TODO: this is a SECRET_KEY from @tests/mocks folder.
+// Temporary until we move @tests/mocks folder to monorepo.
+export const SECRET_KEY =
+  'invite helmet save lion indicate chuckle world pride afford hard broom draft';
+
+// Source:
+// generated in Sparrow with same secret key used in tests
+const addresses = [
+  'tb1p05uectcay8ptepqneycknxf0ewvdejcl0zdqex98ux87w7tzqjfsd7yxyl',
+  'tb1papsqvj9s2yn9mavhtuk9jyw4arlwcxey33n49g02rpjcajx88qrszpytxl',
+  'tb1pfnegsp8x0gnjrgzu0p5xrltrms50prpl8c5a3rwfcrp9p9vumnfsv7zn84',
+  'tb1pzqp06cvvcmftc4g69kuqt5z59k3uyuuwzsg796c00scav0vxjevs3gsvpr',
+  'tb1p2acyvr7wzvdr2m9fprg2e48k03rjvvq8au680jtrxqrz5m9m5kdsurrp2z',
+  'tb1p3kautzlyralsnxf2fv7rudlgyhu6u0lcvzdnlhaywl4h8l7yk0ds59lvfg',
+];
+
+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);
+  });
+});

package/src/p2tr-address-gen.ts

@@ -0,0 +1,57 @@
+import { HDKey } from '@scure/bip32';
+import * as btc from '@scure/btc-signer';
+
+import { DerivationPathDepth } from '@leather.io/crypto';
+import { BitcoinNetworkModes } from '@leather.io/models';
+
+import { getBtcSignerLibNetworkConfigByMode } from './bitcoin.network';
+import {
+  BitcoinAccount,
+  ecdsaPublicKeyToSchnorr,
+  getBitcoinCoinTypeIndexByNetwork,
+} from './bitcoin.utils';
+
+export function getTaprootAccountDerivationPath(
+  network: BitcoinNetworkModes,
+  accountIndex: number
+) {
+  return `m/86'/${getBitcoinCoinTypeIndexByNetwork(network)}'/${accountIndex}'`;
+}
+
+export function getTaprootAddressIndexDerivationPath(
+  network: BitcoinNetworkModes,
+  accountIndex: number,
+  addressIndex: number
+) {
+  return getTaprootAccountDerivationPath(network, accountIndex) + `/0/${addressIndex}`;
+}
+
+export function deriveTaprootAccount(keychain: HDKey, network: BitcoinNetworkModes) {
+  if (keychain.depth !== DerivationPathDepth.Root)
+    throw new Error('Keychain passed is not an account');
+
+  return (accountIndex: number): BitcoinAccount => ({
+    type: 'p2tr',
+    network,
+    accountIndex,
+    derivationPath: getTaprootAccountDerivationPath(network, accountIndex),
+    keychain: keychain.derive(getTaprootAccountDerivationPath(network, accountIndex)),
+  });
+}
+
+export function getTaprootPayment(publicKey: Uint8Array, network: BitcoinNetworkModes) {
+  return btc.p2tr(
+    ecdsaPublicKeyToSchnorr(publicKey),
+    undefined,
+    getBtcSignerLibNetworkConfigByMode(network)
+  );
+}
+
+export function getTaprootPaymentFromAddressIndex(keychain: HDKey, network: BitcoinNetworkModes) {
+  if (keychain.depth !== DerivationPathDepth.AddressIndex)
+    throw new Error('Keychain passed is not an address index');
+
+  if (!keychain.publicKey) throw new Error('Keychain has no public key');
+
+  return getTaprootPayment(keychain.publicKey, network);
+}

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

@@ -0,0 +1,45 @@
+import { deriveNativeSegWitReceiveAddressIndex } from './p2wpkh-address-gen';
+
+describe('Bitcoin bech32 (P2WPKH address derivation', () => {
+  describe('from extended public key', () => {
+    const accounts = [
+      {
+        path: "m/84'/0'/0'",
+        extended_public_key:
+          'xpub6CwY13JDrzeY2oWjP9dbiyLHQh3JVWCvBTCfD7WREBUpBUmtCu4bgxfSGrvaLDbZaMdw2nsPeTFv6AokWkVqh4rbKpsxg7GgEu543Qwvyff',
+        private_key: 'L1FA9VHZNkgCBW9fS76zDHcjuK72LE4gGVAMnN67onRRCoDJvZJi',
+        public_key: '0211758b68eb9b0e4e9610c49739f2ce039732033ba47e125bbdf64ef6cd586ef3',
+        zeroIndexChildAddress: 'bc1qa4ypkks2kfpawyy5mautjfqc6wv703ckm7puux',
+      },
+      {
+        path: "m/84'/0'/1'",
+        mnemonic:
+          'token spatial butter drill city debate pipe shoot target pencil tonight gallery dog globe copy hybrid convince spell load maximum impose crazy engage way',
+        extended_public_key:
+          'xpub6CwY13JDrzeY55xGbiHxHwZSZpbkmrM7QMag3yVgZi62zaYFsBAUam1kghZZx4hDgDdkDzAMxc8xmpcyGAb1EoXoB7Vn7WTiUEaCEd3CcPq',
+        private_key: 'Kyhx4Zz1iYmCGx1gLnPE5ZFphBf16BoRKokU6B8KbxkJ7tM511de',
+        public_key: '025f6abba7947109c5e5ba0fed5e7b99b0ce5b06ccbca86539e6eca261c4507559',
+        zeroIndexChildAddress: 'bc1q5aptjy5l9q4qcykvccpwlqcvzydg744qkv94d3',
+      },
+      {
+        path: "m/84'/0'/2'",
+        mnemonic:
+          'token spatial butter drill city debate pipe shoot target pencil tonight gallery dog globe copy hybrid convince spell load maximum impose crazy engage way',
+        extended_public_key:
+          'xpub6CwY13JDrzeY7qyP5MCBqA3hmB9oX8mjpbt6YWPfCRb9fus8Yrt84xxzh1Ci2wyW8intyoxmr3MjCHCtbs458uboWZVV8WFeHZBveJHVG71',
+        private_key: 'L1CzwqocLUQgH6GeH6bBKRaRnGLF81249Wbd14uTzLaUGE5qMdD7',
+        public_key: '022b804094c9b74a93d51e6bb3b1ae8378027e810058bbcb34ac54f3a307a225d1',
+        zeroIndexChildAddress: 'bc1q253fdeyzuwx58xxssd3a2xw2gq7khhpmr6vgnh',
+      },
+    ];
+
+    describe.each(accounts)('Account', account => {
+      const keychain = deriveNativeSegWitReceiveAddressIndex({
+        xpub: account.extended_public_key,
+        network: 'mainnet',
+      });
+      test('bech 32 address', () =>
+        expect(keychain?.address).toEqual(account.zeroIndexChildAddress));
+    });
+  });
+});

package/src/p2wpkh-address-gen.ts

@@ -0,0 +1,68 @@
+import { HDKey } from '@scure/bip32';
+import * as btc from '@scure/btc-signer';
+
+import { DerivationPathDepth } from '@leather.io/crypto';
+import { BitcoinNetworkModes } from '@leather.io/models';
+
+import { getBtcSignerLibNetworkConfigByMode } from './bitcoin.network';
+import {
+  BitcoinAccount,
+  deriveAddressIndexZeroFromAccount,
+  getBitcoinCoinTypeIndexByNetwork,
+} from './bitcoin.utils';
+
+export function getNativeSegwitAccountDerivationPath(
+  network: BitcoinNetworkModes,
+  accountIndex: number
+) {
+  return `m/84'/${getBitcoinCoinTypeIndexByNetwork(network)}'/${accountIndex}'`;
+}
+
+export function getNativeSegwitAddressIndexDerivationPath(
+  network: BitcoinNetworkModes,
+  accountIndex: number,
+  addressIndex: number
+) {
+  return getNativeSegwitAccountDerivationPath(network, accountIndex) + `/0/${addressIndex}`;
+}
+
+export function deriveNativeSegwitAccountFromRootKeychain(
+  keychain: HDKey,
+  network: BitcoinNetworkModes
+) {
+  if (keychain.depth !== DerivationPathDepth.Root) throw new Error('Keychain passed is not a root');
+  return (accountIndex: number): BitcoinAccount => ({
+    type: 'p2wpkh',
+    network,
+    accountIndex,
+    derivationPath: getNativeSegwitAccountDerivationPath(network, accountIndex),
+    keychain: keychain.derive(getNativeSegwitAccountDerivationPath(network, accountIndex)),
+  });
+}
+
+export function getNativeSegWitPaymentFromAddressIndex(
+  keychain: HDKey,
+  network: BitcoinNetworkModes
+) {
+  if (keychain.depth !== DerivationPathDepth.AddressIndex)
+    throw new Error('Keychain passed is not an address index');
+
+  if (!keychain.publicKey) throw new Error('Keychain does not have a public key');
+
+  return btc.p2wpkh(keychain.publicKey, getBtcSignerLibNetworkConfigByMode(network));
+}
+
+interface DeriveNativeSegWitReceiveAddressIndexArgs {
+  xpub: string;
+  network: BitcoinNetworkModes;
+}
+export function deriveNativeSegWitReceiveAddressIndex({
+  xpub,
+  network,
+}: DeriveNativeSegWitReceiveAddressIndexArgs) {
+  if (!xpub) return;
+  const keychain = HDKey.fromExtendedKey(xpub);
+  if (!keychain) return;
+  const zeroAddressIndex = deriveAddressIndexZeroFromAccount(keychain);
+  return getNativeSegWitPaymentFromAddressIndex(zeroAddressIndex, network);
+}

package/src/p2wsh-p2sh-address-gen.spec.ts

@@ -0,0 +1,180 @@
+import ecc from '@bitcoinerlab/secp256k1';
+import { sha256 } from '@noble/hashes/sha256';
+import { base58check } from '@scure/base';
+import { HDKey } from '@scure/bip32';
+import { mnemonicToSeedSync } from '@scure/bip39';
+import { hashP2WPKH } from '@stacks/transactions';
+import { BIP32Factory } from 'bip32';
+import * as bitcoin from 'bitcoinjs-lib';
+
+import {
+  decodeCompressedWifPrivateKey,
+  deriveBtcBip49SeedFromMnemonic,
+  deriveRootBtcKeychain,
+  makePayToScriptHashAddress,
+  makePayToScriptHashAddressBytes,
+  makePayToScriptHashKeyHash,
+  payToScriptHashTestnetPrefix,
+  publicKeyToPayToScriptHashAddress,
+} from './p2wsh-p2sh-address-gen';
+
+describe('Bitcoin SegWit (P2WPKH-P2SH) address generation', () => {
+  const bip32 = BIP32Factory(ecc);
+
+  const phrase =
+    'above view guide write long gift chimney own guide mirror word ski code monster gauge bracket until stem feed scale smart truth toy limb';
+
+  describe('Verify against wagyu results', () => {
+    // Keys generated with `wagyu`
+    // $ wagyu bitcoin import-hd -m "<phrase>" -d "m/49'/0'/0'/0/0" --format segwit --json
+    const keys = [
+      {
+        path: "m/49'/0'/0'/0/0",
+        extended_private_key:
+          'xprvA2WTEJy9NLu57C55yCCPvXLzGq6mGjL3oc81T7vMv2WYREFuAJV3HT4pJYF4a3JRCnyU95rgq4eY2X6cCJTJQYEHmHrvyfy5pCnPcqeTikK',
+        extended_public_key:
+          'xpub6FVodpW3CiTNKg9Z5DjQHfHiprwFgC3uAq3cFWKyUN3XJ2b3hqoHqFPJ9p9r4QK5f9fs1VztRMrjSy6M6HvVLtpC6KipJ2whmAhk9V3GZZ2',
+        private_key: 'L5iYDFDUDSGnjtWUT8gKDvCcsfMna5fAk6pQo5DZandks5r7Av4Q',
+        public_key: '03715f44ce96a11743c97e4ef5954e78482107a9658f1c5f33bc9e70dc171e56e5',
+        address: '3CTTwjVZ59ykFH2DSQpF3iLWM3fESjFcJ9',
+        format: 'p2sh_p2wpkh',
+        network: 'mainnet',
+      },
+      {
+        path: "m/49'/0'/0'/0/1",
+        extended_private_key:
+          'xprvA2WTEJy9NLu5ANouN242mgeiXNcndxwCRHRj3B3C96zWPj7Cgp22frkXKLGiRK59fg6nkGHHityZkVdjBfp7oLP8gf2jy2iHf21qaTWHQfd',
+        extended_public_key:
+          'xpub6FVodpW3CiTNNrtNU3b38pbT5QTH3Rf3nWMKqZSohSXVGXSMEMLHDf51AZpFphHQXCZzAMXGHraNyBmRXHKbgKQETn8mr6oUTAXBYJJBGEy',
+        private_key: 'L4Xt5Ricu9HAg3t92uyqNpnFXKXCgt6DuUtVMkaTsqgXs7rnxjSY',
+        public_key: '02166ce8acc10a07f877436d673c1876ad2b68d7c78075972d4b2d9f8e1d0d984d',
+        address: '36R4QBx4HqRSiRswcFeCe6KUgk2JY9aP87',
+        format: 'p2sh_p2wpkh',
+        network: 'mainnet',
+      },
+      {
+        path: "m/49'/0'/0'/0/2",
+        extended_private_key:
+          'xprvA2WTEJy9NLu5E4vHyjZWFKoTnibqRqNquBzPR7sRoMn44bvpq6ES7cbRmxmxZAtiTDFvRUFWzpsYqbuNF4WapLdJJzrYTDDY6k4QhqHEkXG',
+        extended_public_key:
+          'xpub6FVodpW3CiTNSYzm5m6WcTkCLkSKqJ6hGQuzDWH3MhK2wQFyNdYgfQuudCnLj4afakVMnLpHBuAY13aHFh3giri7MRZ8gEddLtr9wdgcvpn',
+        private_key: 'L2aBwidPCi2YjxDriNAtxfrMFbS3PsKeUUSnnt8cQQRKvpPciUqo',
+        public_key: '0218e2229c75d57f2a0bd6dfdfa50a1a736d19fb40a1f18a675d34960b088df01e',
+        address: '3BU1wA95ELhgweMSazGh42CHD5K64XGUop',
+        format: 'p2sh_p2wpkh',
+        network: 'mainnet',
+      },
+      {
+        path: "m/49'/0'/0'/0/3",
+        extended_private_key:
+          'xprvA2WTEJy9NLu5FKNrRe3coYxbKXjjzibJ6uouC9v29s6Ut8KJvmqXWmvzPTb9wPfRjYzvcq91QyV6B7P38XmZpTquTDoVyp4vv5baiyf8EZT',
+        extended_public_key:
+          'xpub6FVodpW3CiTNToTKXfadAguKsZaEQBK9U8jVzYKdiCdTkveTUK9n4aFUEiuixKhQeqrrqX9iKTYFmpJXdc2im8y2JzYCuiEZvegLuTAetxJ',
+        private_key: 'L2Mx4mkmuQMnRxf1gCYSSEugDj6TeDS45eYjXYdanJ7MEX9Xp8Fe',
+        public_key: '02bf94312be9021d61d1ed917c5e8542d215180afe5db35c5574e3382b3b8469f0',
+        address: '3MCzNqbNy7k8hnyenwpsdHahY2yBVQJQsz',
+        format: 'p2sh_p2wpkh',
+        network: 'mainnet',
+      },
+    ] as const;
+
+    describe.each(keys)('Core libraries: bip32, bip39, bitcoinjs-lib', key => {
+      const seed = mnemonicToSeedSync(phrase);
+      const root = bip32.fromSeed(Buffer.from(seed));
+      const child = root.derivePath(key.path);
+
+      describe(key.path, () => {
+        test(`public key`, () => expect(child.publicKey.toString('hex')).toEqual(key.public_key));
+
+        test(`extended public key`, () =>
+          expect(child.neutered().toBase58()).toEqual(key.extended_public_key));
+
+        test(`private key`, () =>
+          expect(child.privateKey).toEqual(
+            Buffer.from(decodeCompressedWifPrivateKey(key.private_key))
+          ));
+
+        test(`extended private key`, () =>
+          expect(child.privateKey).toEqual(bip32.fromBase58(key.extended_private_key).privateKey));
+
+        test(`segwit address`, () => {
+          const bitcoinPayment = bitcoin.payments.p2sh({
+            redeem: bitcoin.payments.p2wpkh({ pubkey: child.publicKey }),
+          });
+          expect(bitcoinPayment.address).toEqual(key.address);
+        });
+      });
+    });
+
+    describe.each(keys)('@scure/*', key => {
+      let seed: Uint8Array;
+      let root: HDKey;
+      let child: HDKey;
+
+      beforeAll(async () => {
+        seed = await deriveBtcBip49SeedFromMnemonic(phrase);
+        root = deriveRootBtcKeychain(seed);
+        child = root.derive(key.path);
+      });
+
+      describe(key.path, () => {
+        test(`public key`, () =>
+          expect(Buffer.from(child.publicKey!).toString('hex')).toEqual(key.public_key));
+
+        test(`extended public key`, () =>
+          expect(child.publicExtendedKey).toEqual(key.extended_public_key));
+
+        test(`private key`, () =>
+          expect(child.privateKey).toEqual(decodeCompressedWifPrivateKey(key.private_key)));
+
+        test(`extended private key`, () =>
+          expect(child.privateKey).toEqual(
+            HDKey.fromExtendedKey(key.extended_private_key).privateKey
+          ));
+
+        test(`extended private key`, () =>
+          expect(child.privateExtendedKey).toEqual(key.extended_private_key));
+
+        test(`segwit address`, () => {
+          expect(publicKeyToPayToScriptHashAddress(child.publicKey!, key.network)).toEqual(
+            key.address
+          );
+        });
+      });
+    });
+  });
+
+  // Replicating test vector from BIP
+  // https://en.bitcoin.it/wiki/BIP_0049
+  test('BIP-0049 test vector', () => {
+    const publicKey = Buffer.from(
+      '03a1af804ac108a8a51782198c2d034b28bf90c8803f5a53f76276fa69a4eae77f',
+      'hex'
+    );
+    const hash = makePayToScriptHashKeyHash(publicKey);
+
+    // stacks.js implementation
+    const addressBytesFromStacks = hashP2WPKH(publicKey);
+    expect(addressBytesFromStacks).toEqual('336caa13e08b96080a32b5d818d59b4ab3b36742');
+
+    // wallet implementation
+    const addressBytes = makePayToScriptHashAddressBytes(hash);
+    const addressBytesHex = Buffer.from(addressBytes).toString('hex');
+    expect(addressBytesHex).toEqual('336caa13e08b96080a32b5d818d59b4ab3b36742');
+
+    // compare lib output
+    expect(addressBytesFromStacks).toEqual(addressBytesHex);
+
+    const address = base58check(sha256).encode(
+      Buffer.concat([
+        Buffer.of(payToScriptHashTestnetPrefix),
+        Buffer.from(addressBytesFromStacks, 'hex'),
+      ])
+    );
+    const addressWithLib = makePayToScriptHashAddress(addressBytes, 'testnet');
+
+    expect(address).toEqual(addressWithLib);
+
+    expect(addressWithLib).toEqual('2Mww8dCYPUpKHofjgcXcBCEGmniw9CoaiD2');
+  });
+});