@leather.io/bitcoin 0.8.0

package/dist/index.js

@@ -0,0 +1,516 @@
+// src/bip322/bip322-utils.ts
+import ecc from "@bitcoinerlab/secp256k1";
+import { sha256 } from "@noble/hashes/sha256";
+import { hexToBytes as hexToBytes2, utf8ToBytes } from "@stacks/common";
+import * as bitcoin from "bitcoinjs-lib";
+import { ECPairFactory } from "ecpair";
+import { encode } from "varuint-bitcoin";
+import { isString } from "@leather.io/utils";
+
+// src/bitcoin.utils.ts
+import { hexToBytes } from "@noble/hashes/utils";
+import { HDKey } from "@scure/bip32";
+import { mnemonicToSeedSync } from "@scure/bip39";
+import * as btc2 from "@scure/btc-signer";
+import { DerivationPathDepth as DerivationPathDepth2, extractAccountIndexFromPath } from "@leather.io/crypto";
+import { defaultWalletKeyId, isDefined, whenNetwork } from "@leather.io/utils";
+
+// src/bitcoin.network.ts
+import * as bitcoinJs from "bitcoinjs-lib";
+var bitcoinMainnet = {
+  bech32: "bc",
+  pubKeyHash: 0,
+  scriptHash: 5,
+  wif: 128
+};
+var bitcoinTestnet = {
+  bech32: "tb",
+  pubKeyHash: 111,
+  scriptHash: 196,
+  wif: 239
+};
+var bitcoinRegtest = {
+  bech32: "bcrt",
+  pubKeyHash: 111,
+  scriptHash: 196,
+  wif: 239
+};
+var btcSignerLibNetworks = {
+  mainnet: bitcoinMainnet,
+  testnet: bitcoinTestnet,
+  regtest: bitcoinRegtest,
+  // Signet originally was going to have its own prefix but authors decided to
+  // copy testnet
+  signet: bitcoinTestnet
+};
+function getBtcSignerLibNetworkConfigByMode(network) {
+  return btcSignerLibNetworks[network];
+}
+var bitcoinJsLibNetworks = {
+  mainnet: bitcoinJs.networks.bitcoin,
+  testnet: bitcoinJs.networks.testnet,
+  regtest: bitcoinJs.networks.regtest,
+  signet: bitcoinJs.networks.testnet
+};
+function getBitcoinJsLibNetworkConfigByMode(network) {
+  return bitcoinJsLibNetworks[network];
+}
+
+// src/p2tr-address-gen.ts
+import * as btc from "@scure/btc-signer";
+import { DerivationPathDepth } from "@leather.io/crypto";
+function getTaprootAccountDerivationPath(network, accountIndex) {
+  return `m/86'/${getBitcoinCoinTypeIndexByNetwork(network)}'/${accountIndex}'`;
+}
+function getTaprootAddressIndexDerivationPath(network, accountIndex, addressIndex) {
+  return getTaprootAccountDerivationPath(network, accountIndex) + `/0/${addressIndex}`;
+}
+function deriveTaprootAccount(keychain, network) {
+  if (keychain.depth !== DerivationPathDepth.Root)
+    throw new Error("Keychain passed is not an account");
+  return (accountIndex) => ({
+    type: "p2tr",
+    network,
+    accountIndex,
+    derivationPath: getTaprootAccountDerivationPath(network, accountIndex),
+    keychain: keychain.derive(getTaprootAccountDerivationPath(network, accountIndex))
+  });
+}
+function getTaprootPayment(publicKey, network) {
+  return btc.p2tr(
+    ecdsaPublicKeyToSchnorr(publicKey),
+    void 0,
+    getBtcSignerLibNetworkConfigByMode(network)
+  );
+}
+function getTaprootPaymentFromAddressIndex(keychain, network) {
+  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);
+}
+
+// src/bitcoin.utils.ts
+function initBitcoinAccount(derivationPath, policy) {
+  const xpub = extractExtendedPublicKeyFromPolicy(policy);
+  const network = inferNetworkFromPath(derivationPath);
+  return {
+    keychain: HDKey.fromExtendedKey(xpub, getHdKeyVersionsFromNetwork(network)),
+    network,
+    derivationPath,
+    type: inferPaymentTypeFromPath(derivationPath),
+    accountIndex: extractAccountIndexFromPath(derivationPath)
+  };
+}
+var bitcoinNetworkToCoreNetworkMap = {
+  mainnet: "mainnet",
+  testnet: "testnet",
+  regtest: "testnet",
+  signet: "testnet"
+};
+function bitcoinNetworkModeToCoreNetworkMode(mode) {
+  return bitcoinNetworkToCoreNetworkMap[mode];
+}
+var coinTypeMap = {
+  mainnet: 0,
+  testnet: 1
+};
+function getBitcoinCoinTypeIndexByNetwork(network) {
+  return coinTypeMap[bitcoinNetworkModeToCoreNetworkMode(network)];
+}
+function deriveAddressIndexKeychainFromAccount(keychain) {
+  if (keychain.depth !== DerivationPathDepth2.Account)
+    throw new Error("Keychain passed is not an account");
+  return (index) => keychain.deriveChild(0).deriveChild(index);
+}
+function deriveAddressIndexZeroFromAccount(keychain) {
+  return deriveAddressIndexKeychainFromAccount(keychain)(0);
+}
+var ecdsaPublicKeyLength = 33;
+function ecdsaPublicKeyToSchnorr(pubKey) {
+  if (pubKey.byteLength !== ecdsaPublicKeyLength) throw new Error("Invalid public key length");
+  return pubKey.slice(1);
+}
+var toXOnly = (pubKey) => pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33);
+function decodeBitcoinTx(tx) {
+  return btc2.RawTx.decode(hexToBytes(tx));
+}
+function getAddressFromOutScript(script2, bitcoinNetwork) {
+  const outputScript = btc2.OutScript.decode(script2);
+  if (outputScript.type === "pk" || outputScript.type === "tr") {
+    return btc2.Address(bitcoinNetwork).encode({
+      type: outputScript.type,
+      pubkey: outputScript.pubkey
+    });
+  }
+  if (outputScript.type === "ms" || outputScript.type === "tr_ms") {
+    return btc2.Address(bitcoinNetwork).encode({
+      type: outputScript.type,
+      pubkeys: outputScript.pubkeys,
+      m: outputScript.m
+    });
+  }
+  if (outputScript.type === "tr_ns") {
+    return btc2.Address(bitcoinNetwork).encode({
+      type: outputScript.type,
+      pubkeys: outputScript.pubkeys
+    });
+  }
+  if (outputScript.type === "unknown") {
+    return "unknown";
+  }
+  return btc2.Address(bitcoinNetwork).encode({
+    type: outputScript.type,
+    hash: outputScript.hash
+  });
+}
+var paymentTypeMap = {
+  wpkh: "p2wpkh",
+  wsh: "p2wpkh-p2sh",
+  tr: "p2tr",
+  pkh: "p2pkh",
+  sh: "p2sh"
+};
+function btcSignerLibPaymentTypeToPaymentTypeMap(payment) {
+  return paymentTypeMap[payment];
+}
+function isBtcSignerLibPaymentType(payment) {
+  return payment in paymentTypeMap;
+}
+function parseKnownPaymentType(payment) {
+  return isBtcSignerLibPaymentType(payment) ? btcSignerLibPaymentTypeToPaymentTypeMap(payment) : payment;
+}
+function whenPaymentType(mode) {
+  return (paymentMap) => paymentMap[parseKnownPaymentType(mode)];
+}
+function inferPaymentTypeFromPath(path) {
+  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}`);
+}
+function inferNetworkFromPath(path) {
+  return path.split("/")[2].startsWith("0") ? "mainnet" : "testnet";
+}
+function extractExtendedPublicKeyFromPolicy(policy) {
+  return policy.split("]")[1];
+}
+function createWalletIdDecoratedPath(policy, walletId) {
+  return policy.split("]")[0].replace("[", "").replace("m", walletId);
+}
+function getHdKeyVersionsFromNetwork(network) {
+  return whenNetwork(network)({
+    mainnet: void 0,
+    testnet: {
+      private: 0,
+      public: 70617039
+    }
+  });
+}
+function getBitcoinInputAddress(input, bitcoinNetwork) {
+  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 "";
+}
+function getInputPaymentType(input, network) {
+  const address2 = getBitcoinInputAddress(input, getBtcSignerLibNetworkConfigByMode(network));
+  if (address2 === "") throw new Error("Input address cannot be empty");
+  if (address2.startsWith("bc1p") || address2.startsWith("tb1p") || address2.startsWith("bcrt1p"))
+    return "p2tr";
+  if (address2.startsWith("bc1q") || address2.startsWith("tb1q") || address2.startsWith("bcrt1q"))
+    return "p2wpkh";
+  throw new Error("Unable to infer payment type from input address");
+}
+function lookUpLedgerKeysByPath(getDerivationPath) {
+  return (ledgerKeyMap, network) => (accountIndex) => {
+    const path = getDerivationPath(network, accountIndex);
+    const account = ledgerKeyMap[path.replace("m", defaultWalletKeyId)];
+    if (!account) return;
+    return initBitcoinAccount(path, account.policy);
+  };
+}
+function getTaprootAddress({ index, keychain, network }) {
+  if (!keychain) throw new Error("Expected keychain to be provided");
+  if (keychain.depth !== DerivationPathDepth2.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;
+}
+function mnemonicToRootNode(secretKey) {
+  const seed = mnemonicToSeedSync(secretKey);
+  return HDKey.fromMasterSeed(seed);
+}
+function getPsbtTxInputs(psbtTx) {
+  const inputsLength = psbtTx.inputsLength;
+  const inputs = [];
+  for (let i = 0; i < inputsLength; i++) inputs.push(psbtTx.getInput(i));
+  return inputs;
+}
+function getPsbtTxOutputs(psbtTx) {
+  const outputsLength = psbtTx.outputsLength;
+  const outputs = [];
+  for (let i = 0; i < outputsLength; i++) outputs.push(psbtTx.getOutput(i));
+  return outputs;
+}
+
+// src/bip322/bip322-utils.ts
+var bip322MessageTag = "BIP0322-signed-message";
+var ECPair = ECPairFactory(ecc);
+bitcoin.initEccLib(ecc);
+function ecPairFromPrivateKey(key) {
+  return ECPair.fromPrivateKey(Buffer.from(key));
+}
+var messageTagHash = Uint8Array.from([
+  ...sha256(utf8ToBytes(bip322MessageTag)),
+  ...sha256(utf8ToBytes(bip322MessageTag))
+]);
+function hashBip322Message(message) {
+  return sha256(
+    Uint8Array.from([...messageTagHash, ...isString(message) ? utf8ToBytes(message) : message])
+  );
+}
+var bip322TransactionToSignValues = {
+  prevoutHash: hexToBytes2("0000000000000000000000000000000000000000000000000000000000000000"),
+  prevoutIndex: 4294967295,
+  sequence: 0
+};
+function encodeVarString(b) {
+  return Buffer.concat([encode(b.byteLength), b]);
+}
+var supportedMessageSigningPaymentTypes = ["p2wpkh", "p2tr"];
+function isSupportedMessageSigningPaymentType(paymentType) {
+  return supportedMessageSigningPaymentTypes.includes(paymentType);
+}
+function encodeMessageWitnessData(witnessArray) {
+  const len = encode(witnessArray.length);
+  return Buffer.concat([len, ...witnessArray.map((witness) => encodeVarString(witness))]);
+}
+function tapTweakHash(pubKey, h) {
+  return bitcoin.crypto.taggedHash("TapTweak", Buffer.concat(h ? [pubKey, h] : [pubKey]));
+}
+function tweakSigner(signer, opts = {}) {
+  let privateKey = signer.privateKey;
+  if (!privateKey) {
+    throw new Error("Private key is required for tweaking signer!");
+  }
+  if (signer.publicKey[0] === 3) {
+    privateKey = ecc.privateNegate(privateKey);
+  }
+  const tweakedPrivateKey = ecc.privateAdd(
+    privateKey,
+    tapTweakHash(toXOnly(signer.publicKey), opts.tweakHash)
+  );
+  if (!tweakedPrivateKey) {
+    throw new Error("Invalid tweaked private key!");
+  }
+  return ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
+    network: opts.network
+  });
+}
+
+// src/bip322/sign-message-bip322-bitcoinjs.ts
+import { base64 } from "@scure/base";
+import * as bitcoin2 from "bitcoinjs-lib";
+function createNativeSegwitBitcoinJsSigner(privateKey) {
+  return ecPairFromPrivateKey(privateKey);
+}
+function createTaprootBitcoinJsSigner(privateKey) {
+  return tweakSigner(ecPairFromPrivateKey(privateKey));
+}
+function createToSpendTx(address2, message, network) {
+  const { prevoutHash, prevoutIndex, sequence } = bip322TransactionToSignValues;
+  const script2 = bitcoin2.address.toOutputScript(
+    address2,
+    getBitcoinJsLibNetworkConfigByMode(network)
+  );
+  const hash = hashBip322Message(message);
+  const commands = [0, Buffer.from(hash)];
+  const scriptSig = bitcoin2.script.compile(commands);
+  const virtualToSpend = new bitcoin2.Transaction();
+  virtualToSpend.version = 0;
+  virtualToSpend.addInput(Buffer.from(prevoutHash), prevoutIndex, sequence, scriptSig);
+  virtualToSpend.addOutput(script2, 0);
+  return { virtualToSpend, script: script2 };
+}
+function createToSignTx(toSpendTxHex, script2, network) {
+  const virtualToSign = new bitcoin2.Psbt({ network: getBitcoinJsLibNetworkConfigByMode(network) });
+  virtualToSign.setVersion(0);
+  const prevTxHash = toSpendTxHex;
+  const prevOutIndex = 0;
+  const toSignScriptSig = bitcoin2.script.compile([bitcoin2.script.OPS.OP_RETURN]);
+  virtualToSign.addInput({
+    hash: prevTxHash,
+    index: prevOutIndex,
+    sequence: 0,
+    witnessUtxo: { script: script2, value: 0 }
+  });
+  virtualToSign.addOutput({ script: toSignScriptSig, value: 0 });
+  return virtualToSign;
+}
+async function signBip322MessageSimple(args) {
+  const { address: address2, message, network, signPsbt } = args;
+  const { virtualToSpend, script: script2 } = createToSpendTx(address2, message, network);
+  const virtualToSign = createToSignTx(virtualToSpend.getHash(), script2, network);
+  const signedTx = await signPsbt(virtualToSign);
+  const asBitcoinJsTransaction = bitcoin2.Psbt.fromBuffer(Buffer.from(signedTx.toPSBT()));
+  asBitcoinJsTransaction.finalizeInput(0);
+  const toSignTx = asBitcoinJsTransaction.extractTransaction();
+  const result = encodeMessageWitnessData(toSignTx.ins[0].witness);
+  return {
+    virtualToSpend,
+    virtualToSign: toSignTx,
+    unencodedSig: result,
+    signature: base64.encode(result)
+  };
+}
+
+// src/p2wpkh-address-gen.ts
+import { HDKey as HDKey2 } from "@scure/bip32";
+import * as btc3 from "@scure/btc-signer";
+import { DerivationPathDepth as DerivationPathDepth3 } from "@leather.io/crypto";
+function getNativeSegwitAccountDerivationPath(network, accountIndex) {
+  return `m/84'/${getBitcoinCoinTypeIndexByNetwork(network)}'/${accountIndex}'`;
+}
+function getNativeSegwitAddressIndexDerivationPath(network, accountIndex, addressIndex) {
+  return getNativeSegwitAccountDerivationPath(network, accountIndex) + `/0/${addressIndex}`;
+}
+function deriveNativeSegwitAccountFromRootKeychain(keychain, network) {
+  if (keychain.depth !== DerivationPathDepth3.Root) throw new Error("Keychain passed is not a root");
+  return (accountIndex) => ({
+    type: "p2wpkh",
+    network,
+    accountIndex,
+    derivationPath: getNativeSegwitAccountDerivationPath(network, accountIndex),
+    keychain: keychain.derive(getNativeSegwitAccountDerivationPath(network, accountIndex))
+  });
+}
+function getNativeSegWitPaymentFromAddressIndex(keychain, network) {
+  if (keychain.depth !== DerivationPathDepth3.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 btc3.p2wpkh(keychain.publicKey, getBtcSignerLibNetworkConfigByMode(network));
+}
+function deriveNativeSegWitReceiveAddressIndex({
+  xpub,
+  network
+}) {
+  if (!xpub) return;
+  const keychain = HDKey2.fromExtendedKey(xpub);
+  if (!keychain) return;
+  const zeroAddressIndex = deriveAddressIndexZeroFromAccount(keychain);
+  return getNativeSegWitPaymentFromAddressIndex(zeroAddressIndex, network);
+}
+
+// src/p2wsh-p2sh-address-gen.ts
+import { ripemd160 } from "@noble/hashes/ripemd160";
+import { sha256 as sha2562 } from "@noble/hashes/sha256";
+import { base58check } from "@scure/base";
+import { deriveBip39MnemonicFromSeed, deriveRootBip32Keychain } from "@leather.io/crypto";
+var deriveBtcBip49SeedFromMnemonic = deriveBip39MnemonicFromSeed;
+var deriveRootBtcKeychain = deriveRootBip32Keychain;
+function decodeCompressedWifPrivateKey(key) {
+  const compressedWifFormatPrivateKey = base58check(sha2562).decode(key);
+  return compressedWifFormatPrivateKey.slice(1, compressedWifFormatPrivateKey.length - 1);
+}
+var payToScriptHashMainnetPrefix = 5;
+var payToScriptHashTestnetPrefix = 196;
+var payToScriptHashPrefixMap = {
+  mainnet: payToScriptHashMainnetPrefix,
+  testnet: payToScriptHashTestnetPrefix
+};
+function hash160(input) {
+  return ripemd160(sha2562(input));
+}
+function makePayToScriptHashKeyHash(publicKey) {
+  return hash160(publicKey);
+}
+function makePayToScriptHashAddressBytes(keyHash) {
+  const redeemScript = Uint8Array.from([
+    ...Uint8Array.of(0),
+    ...Uint8Array.of(keyHash.length),
+    ...keyHash
+  ]);
+  return hash160(redeemScript);
+}
+function makePayToScriptHashAddress(addressBytes, network) {
+  const networkByte = payToScriptHashPrefixMap[network];
+  const addressWithPrefix = Uint8Array.from([networkByte, ...addressBytes]);
+  return base58check(sha2562).encode(addressWithPrefix);
+}
+function publicKeyToPayToScriptHashAddress(publicKey, network) {
+  const hash = makePayToScriptHashKeyHash(publicKey);
+  const addrBytes = makePayToScriptHashAddressBytes(hash);
+  return makePayToScriptHashAddress(addrBytes, network);
+}
+export {
+  bip322TransactionToSignValues,
+  bitcoinNetworkModeToCoreNetworkMode,
+  bitcoinNetworkToCoreNetworkMap,
+  btcSignerLibPaymentTypeToPaymentTypeMap,
+  coinTypeMap,
+  createNativeSegwitBitcoinJsSigner,
+  createTaprootBitcoinJsSigner,
+  createToSpendTx,
+  createWalletIdDecoratedPath,
+  decodeBitcoinTx,
+  decodeCompressedWifPrivateKey,
+  deriveAddressIndexKeychainFromAccount,
+  deriveAddressIndexZeroFromAccount,
+  deriveBtcBip49SeedFromMnemonic,
+  deriveNativeSegWitReceiveAddressIndex,
+  deriveNativeSegwitAccountFromRootKeychain,
+  deriveRootBtcKeychain,
+  deriveTaprootAccount,
+  ecPairFromPrivateKey,
+  ecdsaPublicKeyLength,
+  ecdsaPublicKeyToSchnorr,
+  encodeMessageWitnessData,
+  extractExtendedPublicKeyFromPolicy,
+  getAddressFromOutScript,
+  getBitcoinCoinTypeIndexByNetwork,
+  getBitcoinInputAddress,
+  getBitcoinJsLibNetworkConfigByMode,
+  getBtcSignerLibNetworkConfigByMode,
+  getHdKeyVersionsFromNetwork,
+  getInputPaymentType,
+  getNativeSegWitPaymentFromAddressIndex,
+  getNativeSegwitAccountDerivationPath,
+  getNativeSegwitAddressIndexDerivationPath,
+  getPsbtTxInputs,
+  getPsbtTxOutputs,
+  getTaprootAccountDerivationPath,
+  getTaprootAddress,
+  getTaprootAddressIndexDerivationPath,
+  getTaprootPayment,
+  getTaprootPaymentFromAddressIndex,
+  hashBip322Message,
+  inferNetworkFromPath,
+  inferPaymentTypeFromPath,
+  initBitcoinAccount,
+  isBtcSignerLibPaymentType,
+  isSupportedMessageSigningPaymentType,
+  lookUpLedgerKeysByPath,
+  makePayToScriptHashAddress,
+  makePayToScriptHashAddressBytes,
+  makePayToScriptHashKeyHash,
+  mnemonicToRootNode,
+  parseKnownPaymentType,
+  payToScriptHashTestnetPrefix,
+  paymentTypeMap,
+  publicKeyToPayToScriptHashAddress,
+  signBip322MessageSimple,
+  toXOnly,
+  tweakSigner,
+  whenPaymentType
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bip322/bip322-utils.ts","../src/bitcoin.utils.ts","../src/bitcoin.network.ts","../src/p2tr-address-gen.ts","../src/bip322/sign-message-bip322-bitcoinjs.ts","../src/p2wpkh-address-gen.ts","../src/p2wsh-p2sh-address-gen.ts"],"sourcesContent":["import ecc from '@bitcoinerlab/secp256k1';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { hexToBytes, utf8ToBytes } from '@stacks/common';\nimport * as bitcoin from 'bitcoinjs-lib';\nimport { ECPairFactory } from 'ecpair';\nimport { encode } from 'varuint-bitcoin';\n\nimport { PaymentTypes } from '@leather.io/rpc';\nimport { isString } from '@leather.io/utils';\n\nimport { toXOnly } from '../bitcoin.utils';\n\nconst bip322MessageTag = 'BIP0322-signed-message';\n\nconst ECPair = ECPairFactory(ecc);\nbitcoin.initEccLib(ecc);\n\nexport function ecPairFromPrivateKey(key: Uint8Array) {\n  return ECPair.fromPrivateKey(Buffer.from(key));\n}\n\n// See tagged hashes section of BIP-340\n// https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki#design\nconst messageTagHash = Uint8Array.from([\n  ...sha256(utf8ToBytes(bip322MessageTag)),\n  ...sha256(utf8ToBytes(bip322MessageTag)),\n]);\n\nexport function hashBip322Message(message: Uint8Array | string) {\n  return sha256(\n    Uint8Array.from([...messageTagHash, ...(isString(message) ? utf8ToBytes(message) : message)])\n  );\n}\n\nexport const bip322TransactionToSignValues = {\n  prevoutHash: hexToBytes('0000000000000000000000000000000000000000000000000000000000000000'),\n  prevoutIndex: 0xffffffff,\n  sequence: 0,\n};\n\nfunction encodeVarString(b: Buffer) {\n  return Buffer.concat([encode(b.byteLength), b]);\n}\n\nconst supportedMessageSigningPaymentTypes: PaymentTypes[] = ['p2wpkh', 'p2tr'];\n\nexport function isSupportedMessageSigningPaymentType(paymentType: string) {\n  return supportedMessageSigningPaymentTypes.includes(paymentType as PaymentTypes);\n}\n\n/**\n * Encode witness data for a BIP322 message\n * TODO: Refactor to remove `Buffer` use\n */\nexport function encodeMessageWitnessData(witnessArray: Buffer[]) {\n  const len = encode(witnessArray.length);\n  return Buffer.concat([len, ...witnessArray.map(witness => encodeVarString(witness))]);\n}\n\nfunction tapTweakHash(pubKey: Buffer, h: Buffer | undefined): Buffer {\n  return bitcoin.crypto.taggedHash('TapTweak', Buffer.concat(h ? [pubKey, h] : [pubKey]));\n}\n\nexport function tweakSigner(signer: bitcoin.Signer, opts: any = {}): bitcoin.Signer {\n  // @ts-expect-error privateKey exists on signer\n  let privateKey: Uint8Array | undefined = signer.privateKey!;\n  if (!privateKey) {\n    throw new Error('Private key is required for tweaking signer!');\n  }\n  if (signer.publicKey[0] === 3) {\n    privateKey = ecc.privateNegate(privateKey);\n  }\n\n  const tweakedPrivateKey = ecc.privateAdd(\n    privateKey,\n    tapTweakHash(toXOnly(signer.publicKey), opts.tweakHash)\n  );\n  if (!tweakedPrivateKey) {\n    throw new Error('Invalid tweaked private key!');\n  }\n\n  return ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {\n    network: opts.network,\n  });\n}\n","import { hexToBytes } from '@noble/hashes/utils';\nimport { HDKey, Versions } from '@scure/bip32';\nimport { mnemonicToSeedSync } from '@scure/bip39';\nimport * as btc from '@scure/btc-signer';\nimport { TransactionInput, TransactionOutput } from '@scure/btc-signer/psbt';\n\nimport { DerivationPathDepth, extractAccountIndexFromPath } from '@leather.io/crypto';\nimport { BitcoinNetworkModes, NetworkModes } from '@leather.io/models';\nimport type { PaymentTypes } from '@leather.io/rpc';\nimport { defaultWalletKeyId, isDefined, whenNetwork } from '@leather.io/utils';\n\nimport { BtcSignerNetwork, getBtcSignerLibNetworkConfigByMode } from './bitcoin.network';\nimport { getTaprootPayment } from './p2tr-address-gen';\n\nexport interface BitcoinAccount {\n  type: PaymentTypes;\n  derivationPath: string;\n  keychain: HDKey;\n  accountIndex: number;\n  network: BitcoinNetworkModes;\n}\nexport function initBitcoinAccount(derivationPath: string, policy: string): BitcoinAccount {\n  const xpub = extractExtendedPublicKeyFromPolicy(policy);\n  const network = inferNetworkFromPath(derivationPath);\n  return {\n    keychain: HDKey.fromExtendedKey(xpub, getHdKeyVersionsFromNetwork(network)),\n    network,\n    derivationPath,\n    type: inferPaymentTypeFromPath(derivationPath),\n    accountIndex: extractAccountIndexFromPath(derivationPath),\n  };\n}\n\n/**\n * Represents a map of `BitcoinNetworkModes` to `NetworkModes`. While Bitcoin\n * has a number of networks, its often only necessary to consider the higher\n * level concepts of mainnet and testnet\n */\nexport const bitcoinNetworkToCoreNetworkMap: Record<BitcoinNetworkModes, NetworkModes> = {\n  mainnet: 'mainnet',\n  testnet: 'testnet',\n  regtest: 'testnet',\n  signet: 'testnet',\n};\nexport function bitcoinNetworkModeToCoreNetworkMode(mode: BitcoinNetworkModes) {\n  return bitcoinNetworkToCoreNetworkMap[mode];\n}\n\n/**\n * Map representing the \"Coin Type\" section of a derivation path.\n * Consider example below, Coin type is one, thus testnet\n * @example\n * `m/86'/1'/0'/0/0`\n */\nexport const coinTypeMap: Record<NetworkModes, 0 | 1> = {\n  mainnet: 0,\n  testnet: 1,\n};\n\nexport function getBitcoinCoinTypeIndexByNetwork(network: BitcoinNetworkModes) {\n  return coinTypeMap[bitcoinNetworkModeToCoreNetworkMode(network)];\n}\n\nexport function deriveAddressIndexKeychainFromAccount(keychain: HDKey) {\n  if (keychain.depth !== DerivationPathDepth.Account)\n    throw new Error('Keychain passed is not an account');\n\n  return (index: number) => keychain.deriveChild(0).deriveChild(index);\n}\n\nexport function deriveAddressIndexZeroFromAccount(keychain: HDKey) {\n  return deriveAddressIndexKeychainFromAccount(keychain)(0);\n}\n\nexport const ecdsaPublicKeyLength = 33;\n\nexport function ecdsaPublicKeyToSchnorr(pubKey: Uint8Array) {\n  if (pubKey.byteLength !== ecdsaPublicKeyLength) throw new Error('Invalid public key length');\n  return pubKey.slice(1);\n}\n\n// Basically same as above, to remove\nexport const toXOnly = (pubKey: Buffer) => (pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33));\n\nexport function decodeBitcoinTx(tx: string): ReturnType<typeof btc.RawTx.decode> {\n  return btc.RawTx.decode(hexToBytes(tx));\n}\n\nexport function getAddressFromOutScript(script: Uint8Array, bitcoinNetwork: BtcSignerNetwork) {\n  const outputScript = btc.OutScript.decode(script);\n\n  if (outputScript.type === 'pk' || outputScript.type === 'tr') {\n    return btc.Address(bitcoinNetwork).encode({\n      type: outputScript.type,\n      pubkey: outputScript.pubkey,\n    });\n  }\n  if (outputScript.type === 'ms' || outputScript.type === 'tr_ms') {\n    return btc.Address(bitcoinNetwork).encode({\n      type: outputScript.type,\n      pubkeys: outputScript.pubkeys,\n      m: outputScript.m,\n    });\n  }\n  if (outputScript.type === 'tr_ns') {\n    return btc.Address(bitcoinNetwork).encode({\n      type: outputScript.type,\n      pubkeys: outputScript.pubkeys,\n    });\n  }\n  if (outputScript.type === 'unknown') {\n    return 'unknown';\n  }\n  return btc.Address(bitcoinNetwork).encode({\n    type: outputScript.type,\n    hash: outputScript.hash,\n  });\n}\n\n/**\n * Payment type identifiers, as described by `@scure/btc-signer` library\n */\nexport type BtcSignerLibPaymentTypeIdentifers = 'wpkh' | 'wsh' | 'tr' | 'pkh' | 'sh';\n\nexport const paymentTypeMap: Record<BtcSignerLibPaymentTypeIdentifers, PaymentTypes> = {\n  wpkh: 'p2wpkh',\n  wsh: 'p2wpkh-p2sh',\n  tr: 'p2tr',\n  pkh: 'p2pkh',\n  sh: 'p2sh',\n};\n\nexport function btcSignerLibPaymentTypeToPaymentTypeMap(\n  payment: BtcSignerLibPaymentTypeIdentifers\n) {\n  return paymentTypeMap[payment];\n}\n\nexport function isBtcSignerLibPaymentType(\n  payment: string\n): payment is BtcSignerLibPaymentTypeIdentifers {\n  return payment in paymentTypeMap;\n}\n\nexport function parseKnownPaymentType(payment: BtcSignerLibPaymentTypeIdentifers | PaymentTypes) {\n  return isBtcSignerLibPaymentType(payment)\n    ? btcSignerLibPaymentTypeToPaymentTypeMap(payment)\n    : payment;\n}\n\nexport type PaymentTypeMap<T> = Record<PaymentTypes, T>;\nexport function whenPaymentType(mode: PaymentTypes | BtcSignerLibPaymentTypeIdentifers) {\n  return <T extends unknown>(paymentMap: PaymentTypeMap<T>): T =>\n    paymentMap[parseKnownPaymentType(mode)];\n}\n\n/**\n * Infers the Bitcoin payment type from the derivation path.\n * Below we see path has 86 in it, per convention, this refers to taproot payments\n * @example\n * `m/86'/1'/0'/0/0`\n */\nexport function inferPaymentTypeFromPath(path: string): PaymentTypes {\n  if (path.startsWith('m/84')) return 'p2wpkh';\n  if (path.startsWith('m/86')) return 'p2tr';\n  if (path.startsWith('m/44')) return 'p2pkh';\n  throw new Error(`Unable to infer payment type from path=${path}`);\n}\n\nexport function inferNetworkFromPath(path: string): NetworkModes {\n  return path.split('/')[2].startsWith('0') ? 'mainnet' : 'testnet';\n}\n\nexport function extractExtendedPublicKeyFromPolicy(policy: string) {\n  return policy.split(']')[1];\n}\n\nexport function createWalletIdDecoratedPath(policy: string, walletId: string) {\n  return policy.split(']')[0].replace('[', '').replace('m', walletId);\n}\n\n// Primarily used to get the correct `Version` when passing Ledger Bitcoin\n// extended public keys to the HDKey constructor\nexport function getHdKeyVersionsFromNetwork(network: NetworkModes) {\n  return whenNetwork(network)({\n    mainnet: undefined,\n    testnet: {\n      private: 0x00000000,\n      public: 0x043587cf,\n    } as Versions,\n  });\n}\n\nexport function getBitcoinInputAddress(input: TransactionInput, bitcoinNetwork: BtcSignerNetwork) {\n  if (isDefined(input.witnessUtxo))\n    return getAddressFromOutScript(input.witnessUtxo.script, bitcoinNetwork);\n  if (isDefined(input.nonWitnessUtxo) && isDefined(input.index))\n    return getAddressFromOutScript(\n      input.nonWitnessUtxo.outputs[input.index]?.script,\n      bitcoinNetwork\n    );\n  return '';\n}\n\nexport function getInputPaymentType(\n  input: TransactionInput,\n  network: BitcoinNetworkModes\n): PaymentTypes {\n  const address = getBitcoinInputAddress(input, getBtcSignerLibNetworkConfigByMode(network));\n  if (address === '') throw new Error('Input address cannot be empty');\n  if (address.startsWith('bc1p') || address.startsWith('tb1p') || address.startsWith('bcrt1p'))\n    return 'p2tr';\n  if (address.startsWith('bc1q') || address.startsWith('tb1q') || address.startsWith('bcrt1q'))\n    return 'p2wpkh';\n  throw new Error('Unable to infer payment type from input address');\n}\n\n// Ledger wallets are keyed by their derivation path. To reuse the look up logic\n// between payment types, this factory fn accepts a fn that generates the path\nexport function lookUpLedgerKeysByPath(\n  getDerivationPath: (network: BitcoinNetworkModes, accountIndex: number) => string\n) {\n  return (\n      ledgerKeyMap: Record<string, { policy: string } | undefined>,\n      network: BitcoinNetworkModes\n    ) =>\n    (accountIndex: number) => {\n      const path = getDerivationPath(network, accountIndex);\n      // Single wallet mode, hardcoded default walletId\n      const account = ledgerKeyMap[path.replace('m', defaultWalletKeyId)];\n      if (!account) return;\n      return initBitcoinAccount(path, account.policy);\n    };\n}\n\nexport interface GetTaprootAddressArgs {\n  index: number;\n  keychain?: HDKey;\n  network: BitcoinNetworkModes;\n}\nexport function getTaprootAddress({ index, keychain, network }: GetTaprootAddressArgs) {\n  if (!keychain) throw new Error('Expected keychain to be provided');\n\n  if (keychain.depth !== DerivationPathDepth.Account)\n    throw new Error('Expects keychain to be on the account index');\n\n  const addressIndex = deriveAddressIndexKeychainFromAccount(keychain)(index);\n\n  if (!addressIndex.publicKey) {\n    throw new Error('Expected publicKey to be defined');\n  }\n\n  const payment = getTaprootPayment(addressIndex.publicKey, network);\n\n  if (!payment.address) throw new Error('Expected address to be defined');\n\n  return payment.address;\n}\n\nexport function mnemonicToRootNode(secretKey: string) {\n  const seed = mnemonicToSeedSync(secretKey);\n  return HDKey.fromMasterSeed(seed);\n}\n\nexport function getPsbtTxInputs(psbtTx: btc.Transaction): TransactionInput[] {\n  const inputsLength = psbtTx.inputsLength;\n  const inputs: TransactionInput[] = [];\n  for (let i = 0; i < inputsLength; i++) inputs.push(psbtTx.getInput(i));\n  return inputs;\n}\n\nexport function getPsbtTxOutputs(psbtTx: btc.Transaction): TransactionOutput[] {\n  const outputsLength = psbtTx.outputsLength;\n  const outputs: TransactionOutput[] = [];\n  for (let i = 0; i < outputsLength; i++) outputs.push(psbtTx.getOutput(i));\n  return outputs;\n}\n","import * as bitcoinJs from 'bitcoinjs-lib';\n\nimport { BitcoinNetworkModes } from '@leather.io/models';\n\n// See this PR https://github.com/paulmillr/@scure/btc-signer/pull/15\n// Atttempting to add these directly to the library\nexport interface BtcSignerNetwork {\n  bech32: string;\n  pubKeyHash: number;\n  scriptHash: number;\n  wif: number;\n}\n\nconst bitcoinMainnet: BtcSignerNetwork = {\n  bech32: 'bc',\n  pubKeyHash: 0x00,\n  scriptHash: 0x05,\n  wif: 0x80,\n};\n\nconst bitcoinTestnet: BtcSignerNetwork = {\n  bech32: 'tb',\n  pubKeyHash: 0x6f,\n  scriptHash: 0xc4,\n  wif: 0xef,\n};\n\nconst bitcoinRegtest: BtcSignerNetwork = {\n  bech32: 'bcrt',\n  pubKeyHash: 0x6f,\n  scriptHash: 0xc4,\n  wif: 0xef,\n};\n\nconst btcSignerLibNetworks: Record<BitcoinNetworkModes, BtcSignerNetwork> = {\n  mainnet: bitcoinMainnet,\n  testnet: bitcoinTestnet,\n  regtest: bitcoinRegtest,\n  // Signet originally was going to have its own prefix but authors decided to\n  // copy testnet\n  signet: bitcoinTestnet,\n};\n\nexport function getBtcSignerLibNetworkConfigByMode(network: BitcoinNetworkModes) {\n  return btcSignerLibNetworks[network];\n}\n\nconst bitcoinJsLibNetworks: Record<BitcoinNetworkModes, bitcoinJs.Network> = {\n  mainnet: bitcoinJs.networks.bitcoin,\n  testnet: bitcoinJs.networks.testnet,\n  regtest: bitcoinJs.networks.regtest,\n  signet: bitcoinJs.networks.testnet,\n};\n\nexport function getBitcoinJsLibNetworkConfigByMode(network: BitcoinNetworkModes) {\n  return bitcoinJsLibNetworks[network];\n}\n","import { HDKey } from '@scure/bip32';\nimport * as btc from '@scure/btc-signer';\n\nimport { DerivationPathDepth } from '@leather.io/crypto';\nimport { BitcoinNetworkModes } from '@leather.io/models';\n\nimport { getBtcSignerLibNetworkConfigByMode } from './bitcoin.network';\nimport {\n  BitcoinAccount,\n  ecdsaPublicKeyToSchnorr,\n  getBitcoinCoinTypeIndexByNetwork,\n} from './bitcoin.utils';\n\nexport function getTaprootAccountDerivationPath(\n  network: BitcoinNetworkModes,\n  accountIndex: number\n) {\n  return `m/86'/${getBitcoinCoinTypeIndexByNetwork(network)}'/${accountIndex}'`;\n}\n\nexport function getTaprootAddressIndexDerivationPath(\n  network: BitcoinNetworkModes,\n  accountIndex: number,\n  addressIndex: number\n) {\n  return getTaprootAccountDerivationPath(network, accountIndex) + `/0/${addressIndex}`;\n}\n\nexport function deriveTaprootAccount(keychain: HDKey, network: BitcoinNetworkModes) {\n  if (keychain.depth !== DerivationPathDepth.Root)\n    throw new Error('Keychain passed is not an account');\n\n  return (accountIndex: number): BitcoinAccount => ({\n    type: 'p2tr',\n    network,\n    accountIndex,\n    derivationPath: getTaprootAccountDerivationPath(network, accountIndex),\n    keychain: keychain.derive(getTaprootAccountDerivationPath(network, accountIndex)),\n  });\n}\n\nexport function getTaprootPayment(publicKey: Uint8Array, network: BitcoinNetworkModes) {\n  return btc.p2tr(\n    ecdsaPublicKeyToSchnorr(publicKey),\n    undefined,\n    getBtcSignerLibNetworkConfigByMode(network)\n  );\n}\n\nexport function getTaprootPaymentFromAddressIndex(keychain: HDKey, network: BitcoinNetworkModes) {\n  if (keychain.depth !== DerivationPathDepth.AddressIndex)\n    throw new Error('Keychain passed is not an address index');\n\n  if (!keychain.publicKey) throw new Error('Keychain has no public key');\n\n  return getTaprootPayment(keychain.publicKey, network);\n}\n","import { base64 } from '@scure/base';\nimport * as btc from '@scure/btc-signer';\nimport * as bitcoin from 'bitcoinjs-lib';\n\nimport { BitcoinNetworkModes } from '@leather.io/models';\n\nimport { getBitcoinJsLibNetworkConfigByMode } from '../bitcoin.network';\nimport {\n  bip322TransactionToSignValues,\n  ecPairFromPrivateKey,\n  encodeMessageWitnessData,\n  hashBip322Message,\n  tweakSigner,\n} from './bip322-utils';\n\nexport function createNativeSegwitBitcoinJsSigner(privateKey: Buffer) {\n  return ecPairFromPrivateKey(privateKey);\n}\n\nexport function createTaprootBitcoinJsSigner(privateKey: Buffer) {\n  return tweakSigner(ecPairFromPrivateKey(privateKey));\n}\n\nexport function createToSpendTx(address: string, message: string, network: BitcoinNetworkModes) {\n  const { prevoutHash, prevoutIndex, sequence } = bip322TransactionToSignValues;\n\n  const script = bitcoin.address.toOutputScript(\n    address,\n    getBitcoinJsLibNetworkConfigByMode(network)\n  );\n\n  const hash = hashBip322Message(message);\n  const commands = [0, Buffer.from(hash)];\n  const scriptSig = bitcoin.script.compile(commands);\n\n  const virtualToSpend = new bitcoin.Transaction();\n  virtualToSpend.version = 0;\n  virtualToSpend.addInput(Buffer.from(prevoutHash), prevoutIndex, sequence, scriptSig);\n  virtualToSpend.addOutput(script, 0);\n  return { virtualToSpend, script };\n}\n\nfunction createToSignTx(toSpendTxHex: Buffer, script: Buffer, network: BitcoinNetworkModes) {\n  const virtualToSign = new bitcoin.Psbt({ network: getBitcoinJsLibNetworkConfigByMode(network) });\n  virtualToSign.setVersion(0);\n  const prevTxHash = toSpendTxHex;\n  const prevOutIndex = 0;\n  const toSignScriptSig = bitcoin.script.compile([bitcoin.script.OPS.OP_RETURN]);\n\n  virtualToSign.addInput({\n    hash: prevTxHash,\n    index: prevOutIndex,\n    sequence: 0,\n    witnessUtxo: { script, value: 0 },\n  });\n\n  virtualToSign.addOutput({ script: toSignScriptSig, value: 0 });\n  return virtualToSign;\n}\n\ninterface SignBip322MessageSimple {\n  address: string;\n  message: string;\n  network: BitcoinNetworkModes;\n  signPsbt(psbt: bitcoin.Psbt): Promise<btc.Transaction>;\n}\nexport async function signBip322MessageSimple(args: SignBip322MessageSimple) {\n  const { address, message, network, signPsbt } = args;\n\n  const { virtualToSpend, script } = createToSpendTx(address, message, network);\n\n  const virtualToSign = createToSignTx(virtualToSpend.getHash(), script, network);\n\n  const signedTx = await signPsbt(virtualToSign);\n\n  const asBitcoinJsTransaction = bitcoin.Psbt.fromBuffer(Buffer.from(signedTx.toPSBT()));\n\n  asBitcoinJsTransaction.finalizeInput(0);\n\n  // sign the tx\n  // section 5.1\n  // github.com/LegReq/bip0322-signatures/blob/master/BIP0322_signing.ipynb\n  const toSignTx = asBitcoinJsTransaction.extractTransaction();\n\n  const result = encodeMessageWitnessData(toSignTx.ins[0].witness);\n\n  return {\n    virtualToSpend,\n    virtualToSign: toSignTx,\n    unencodedSig: result,\n    signature: base64.encode(result),\n  };\n}\n","import { HDKey } from '@scure/bip32';\nimport * as btc from '@scure/btc-signer';\n\nimport { DerivationPathDepth } from '@leather.io/crypto';\nimport { BitcoinNetworkModes } from '@leather.io/models';\n\nimport { getBtcSignerLibNetworkConfigByMode } from './bitcoin.network';\nimport {\n  BitcoinAccount,\n  deriveAddressIndexZeroFromAccount,\n  getBitcoinCoinTypeIndexByNetwork,\n} from './bitcoin.utils';\n\nexport function getNativeSegwitAccountDerivationPath(\n  network: BitcoinNetworkModes,\n  accountIndex: number\n) {\n  return `m/84'/${getBitcoinCoinTypeIndexByNetwork(network)}'/${accountIndex}'`;\n}\n\nexport function getNativeSegwitAddressIndexDerivationPath(\n  network: BitcoinNetworkModes,\n  accountIndex: number,\n  addressIndex: number\n) {\n  return getNativeSegwitAccountDerivationPath(network, accountIndex) + `/0/${addressIndex}`;\n}\n\nexport function deriveNativeSegwitAccountFromRootKeychain(\n  keychain: HDKey,\n  network: BitcoinNetworkModes\n) {\n  if (keychain.depth !== DerivationPathDepth.Root) throw new Error('Keychain passed is not a root');\n  return (accountIndex: number): BitcoinAccount => ({\n    type: 'p2wpkh',\n    network,\n    accountIndex,\n    derivationPath: getNativeSegwitAccountDerivationPath(network, accountIndex),\n    keychain: keychain.derive(getNativeSegwitAccountDerivationPath(network, accountIndex)),\n  });\n}\n\nexport function getNativeSegWitPaymentFromAddressIndex(\n  keychain: HDKey,\n  network: BitcoinNetworkModes\n) {\n  if (keychain.depth !== DerivationPathDepth.AddressIndex)\n    throw new Error('Keychain passed is not an address index');\n\n  if (!keychain.publicKey) throw new Error('Keychain does not have a public key');\n\n  return btc.p2wpkh(keychain.publicKey, getBtcSignerLibNetworkConfigByMode(network));\n}\n\ninterface DeriveNativeSegWitReceiveAddressIndexArgs {\n  xpub: string;\n  network: BitcoinNetworkModes;\n}\nexport function deriveNativeSegWitReceiveAddressIndex({\n  xpub,\n  network,\n}: DeriveNativeSegWitReceiveAddressIndexArgs) {\n  if (!xpub) return;\n  const keychain = HDKey.fromExtendedKey(xpub);\n  if (!keychain) return;\n  const zeroAddressIndex = deriveAddressIndexZeroFromAccount(keychain);\n  return getNativeSegWitPaymentFromAddressIndex(zeroAddressIndex, network);\n}\n","import { ripemd160 } from '@noble/hashes/ripemd160';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { base58check } from '@scure/base';\n\nimport { deriveBip39MnemonicFromSeed, deriveRootBip32Keychain } from '@leather.io/crypto';\nimport { NetworkModes } from '@leather.io/models';\n\n/**\n * @deprecated\n * Use `deriveBip39MnemonicFromSeed` from `@leather.io/crypto`\n */\nexport const deriveBtcBip49SeedFromMnemonic = deriveBip39MnemonicFromSeed;\n\n/**\n * @deprecated\n * Use `deriveRootBip32Keychain` from `@leather.io/crypto`\n */\nexport const deriveRootBtcKeychain = deriveRootBip32Keychain;\n\nexport function decodeCompressedWifPrivateKey(key: string) {\n  // https://en.bitcoinwiki.org/wiki/Wallet_import_format\n  // Decode Compressed WIF format private key\n  const compressedWifFormatPrivateKey = base58check(sha256).decode(key);\n  // Drop leading network byte, trailing public key SEC format byte\n  return compressedWifFormatPrivateKey.slice(1, compressedWifFormatPrivateKey.length - 1);\n}\n\n// https://en.bitcoin.it/wiki/List_of_address_prefixes\nconst payToScriptHashMainnetPrefix = 0x05;\nexport const payToScriptHashTestnetPrefix = 0xc4;\n\nconst payToScriptHashPrefixMap: Record<NetworkModes, number> = {\n  mainnet: payToScriptHashMainnetPrefix,\n  testnet: payToScriptHashTestnetPrefix,\n};\n\nfunction hash160(input: Uint8Array) {\n  return ripemd160(sha256(input));\n}\n\nexport function makePayToScriptHashKeyHash(publicKey: Uint8Array) {\n  return hash160(publicKey);\n}\n\nexport function makePayToScriptHashAddressBytes(keyHash: Uint8Array) {\n  const redeemScript = Uint8Array.from([\n    ...Uint8Array.of(0x00),\n    ...Uint8Array.of(keyHash.length),\n    ...keyHash,\n  ]);\n  return hash160(redeemScript);\n}\n\nexport function makePayToScriptHashAddress(addressBytes: Uint8Array, network: NetworkModes) {\n  const networkByte = payToScriptHashPrefixMap[network];\n  const addressWithPrefix = Uint8Array.from([networkByte, ...addressBytes]);\n  return base58check(sha256).encode(addressWithPrefix);\n}\n\nexport function publicKeyToPayToScriptHashAddress(publicKey: Uint8Array, network: NetworkModes) {\n  const hash = makePayToScriptHashKeyHash(publicKey);\n  const addrBytes = makePayToScriptHashAddressBytes(hash);\n  return makePayToScriptHashAddress(addrBytes, network);\n}\n"],"mappings":";AAAA,OAAO,SAAS;AAChB,SAAS,cAAc;AACvB,SAAS,cAAAA,aAAY,mBAAmB;AACxC,YAAY,aAAa;AACzB,SAAS,qBAAqB;AAC9B,SAAS,cAAc;AAGvB,SAAS,gBAAgB;;;ACRzB,SAAS,kBAAkB;AAC3B,SAAS,aAAuB;AAChC,SAAS,0BAA0B;AACnC,YAAYC,UAAS;AAGrB,SAAS,uBAAAC,sBAAqB,mCAAmC;AAGjE,SAAS,oBAAoB,WAAW,mBAAmB;;;ACT3D,YAAY,eAAe;AAa3B,IAAM,iBAAmC;AAAA,EACvC,QAAQ;AAAA,EACR,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,KAAK;AACP;AAEA,IAAM,iBAAmC;AAAA,EACvC,QAAQ;AAAA,EACR,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,KAAK;AACP;AAEA,IAAM,iBAAmC;AAAA,EACvC,QAAQ;AAAA,EACR,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,KAAK;AACP;AAEA,IAAM,uBAAsE;AAAA,EAC1E,SAAS;AAAA,EACT,SAAS;AAAA,EACT,SAAS;AAAA;AAAA;AAAA,EAGT,QAAQ;AACV;AAEO,SAAS,mCAAmC,SAA8B;AAC/E,SAAO,qBAAqB,OAAO;AACrC;AAEA,IAAM,uBAAuE;AAAA,EAC3E,SAAmB,mBAAS;AAAA,EAC5B,SAAmB,mBAAS;AAAA,EAC5B,SAAmB,mBAAS;AAAA,EAC5B,QAAkB,mBAAS;AAC7B;AAEO,SAAS,mCAAmC,SAA8B;AAC/E,SAAO,qBAAqB,OAAO;AACrC;;;ACvDA,YAAY,SAAS;AAErB,SAAS,2BAA2B;AAU7B,SAAS,gCACd,SACA,cACA;AACA,SAAO,SAAS,iCAAiC,OAAO,CAAC,KAAK,YAAY;AAC5E;AAEO,SAAS,qCACd,SACA,cACA,cACA;AACA,SAAO,gCAAgC,SAAS,YAAY,IAAI,MAAM,YAAY;AACpF;AAEO,SAAS,qBAAqB,UAAiB,SAA8B;AAClF,MAAI,SAAS,UAAU,oBAAoB;AACzC,UAAM,IAAI,MAAM,mCAAmC;AAErD,SAAO,CAAC,kBAA0C;AAAA,IAChD,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA,gBAAgB,gCAAgC,SAAS,YAAY;AAAA,IACrE,UAAU,SAAS,OAAO,gCAAgC,SAAS,YAAY,CAAC;AAAA,EAClF;AACF;AAEO,SAAS,kBAAkB,WAAuB,SAA8B;AACrF,SAAW;AAAA,IACT,wBAAwB,SAAS;AAAA,IACjC;AAAA,IACA,mCAAmC,OAAO;AAAA,EAC5C;AACF;AAEO,SAAS,kCAAkC,UAAiB,SAA8B;AAC/F,MAAI,SAAS,UAAU,oBAAoB;AACzC,UAAM,IAAI,MAAM,yCAAyC;AAE3D,MAAI,CAAC,SAAS,UAAW,OAAM,IAAI,MAAM,4BAA4B;AAErE,SAAO,kBAAkB,SAAS,WAAW,OAAO;AACtD;;;AFnCO,SAAS,mBAAmB,gBAAwB,QAAgC;AACzF,QAAM,OAAO,mCAAmC,MAAM;AACtD,QAAM,UAAU,qBAAqB,cAAc;AACnD,SAAO;AAAA,IACL,UAAU,MAAM,gBAAgB,MAAM,4BAA4B,OAAO,CAAC;AAAA,IAC1E;AAAA,IACA;AAAA,IACA,MAAM,yBAAyB,cAAc;AAAA,IAC7C,cAAc,4BAA4B,cAAc;AAAA,EAC1D;AACF;AAOO,IAAM,iCAA4E;AAAA,EACvF,SAAS;AAAA,EACT,SAAS;AAAA,EACT,SAAS;AAAA,EACT,QAAQ;AACV;AACO,SAAS,oCAAoC,MAA2B;AAC7E,SAAO,+BAA+B,IAAI;AAC5C;AAQO,IAAM,cAA2C;AAAA,EACtD,SAAS;AAAA,EACT,SAAS;AACX;AAEO,SAAS,iCAAiC,SAA8B;AAC7E,SAAO,YAAY,oCAAoC,OAAO,CAAC;AACjE;AAEO,SAAS,sCAAsC,UAAiB;AACrE,MAAI,SAAS,UAAUC,qBAAoB;AACzC,UAAM,IAAI,MAAM,mCAAmC;AAErD,SAAO,CAAC,UAAkB,SAAS,YAAY,CAAC,EAAE,YAAY,KAAK;AACrE;AAEO,SAAS,kCAAkC,UAAiB;AACjE,SAAO,sCAAsC,QAAQ,EAAE,CAAC;AAC1D;AAEO,IAAM,uBAAuB;AAE7B,SAAS,wBAAwB,QAAoB;AAC1D,MAAI,OAAO,eAAe,qBAAsB,OAAM,IAAI,MAAM,2BAA2B;AAC3F,SAAO,OAAO,MAAM,CAAC;AACvB;AAGO,IAAM,UAAU,CAAC,WAAoB,OAAO,WAAW,KAAK,SAAS,OAAO,SAAS,GAAG,EAAE;AAE1F,SAAS,gBAAgB,IAAiD;AAC/E,SAAW,WAAM,OAAO,WAAW,EAAE,CAAC;AACxC;AAEO,SAAS,wBAAwBC,SAAoB,gBAAkC;AAC5F,QAAM,eAAmB,eAAU,OAAOA,OAAM;AAEhD,MAAI,aAAa,SAAS,QAAQ,aAAa,SAAS,MAAM;AAC5D,WAAW,aAAQ,cAAc,EAAE,OAAO;AAAA,MACxC,MAAM,aAAa;AAAA,MACnB,QAAQ,aAAa;AAAA,IACvB,CAAC;AAAA,EACH;AACA,MAAI,aAAa,SAAS,QAAQ,aAAa,SAAS,SAAS;AAC/D,WAAW,aAAQ,cAAc,EAAE,OAAO;AAAA,MACxC,MAAM,aAAa;AAAA,MACnB,SAAS,aAAa;AAAA,MACtB,GAAG,aAAa;AAAA,IAClB,CAAC;AAAA,EACH;AACA,MAAI,aAAa,SAAS,SAAS;AACjC,WAAW,aAAQ,cAAc,EAAE,OAAO;AAAA,MACxC,MAAM,aAAa;AAAA,MACnB,SAAS,aAAa;AAAA,IACxB,CAAC;AAAA,EACH;AACA,MAAI,aAAa,SAAS,WAAW;AACnC,WAAO;AAAA,EACT;AACA,SAAW,aAAQ,cAAc,EAAE,OAAO;AAAA,IACxC,MAAM,aAAa;AAAA,IACnB,MAAM,aAAa;AAAA,EACrB,CAAC;AACH;AAOO,IAAM,iBAA0E;AAAA,EACrF,MAAM;AAAA,EACN,KAAK;AAAA,EACL,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,IAAI;AACN;AAEO,SAAS,wCACd,SACA;AACA,SAAO,eAAe,OAAO;AAC/B;AAEO,SAAS,0BACd,SAC8C;AAC9C,SAAO,WAAW;AACpB;AAEO,SAAS,sBAAsB,SAA2D;AAC/F,SAAO,0BAA0B,OAAO,IACpC,wCAAwC,OAAO,IAC/C;AACN;AAGO,SAAS,gBAAgB,MAAwD;AACtF,SAAO,CAAoB,eACzB,WAAW,sBAAsB,IAAI,CAAC;AAC1C;AAQO,SAAS,yBAAyB,MAA4B;AACnE,MAAI,KAAK,WAAW,MAAM,EAAG,QAAO;AACpC,MAAI,KAAK,WAAW,MAAM,EAAG,QAAO;AACpC,MAAI,KAAK,WAAW,MAAM,EAAG,QAAO;AACpC,QAAM,IAAI,MAAM,0CAA0C,IAAI,EAAE;AAClE;AAEO,SAAS,qBAAqB,MAA4B;AAC/D,SAAO,KAAK,MAAM,GAAG,EAAE,CAAC,EAAE,WAAW,GAAG,IAAI,YAAY;AAC1D;AAEO,SAAS,mCAAmC,QAAgB;AACjE,SAAO,OAAO,MAAM,GAAG,EAAE,CAAC;AAC5B;AAEO,SAAS,4BAA4B,QAAgB,UAAkB;AAC5E,SAAO,OAAO,MAAM,GAAG,EAAE,CAAC,EAAE,QAAQ,KAAK,EAAE,EAAE,QAAQ,KAAK,QAAQ;AACpE;AAIO,SAAS,4BAA4B,SAAuB;AACjE,SAAO,YAAY,OAAO,EAAE;AAAA,IAC1B,SAAS;AAAA,IACT,SAAS;AAAA,MACP,SAAS;AAAA,MACT,QAAQ;AAAA,IACV;AAAA,EACF,CAAC;AACH;AAEO,SAAS,uBAAuB,OAAyB,gBAAkC;AAChG,MAAI,UAAU,MAAM,WAAW;AAC7B,WAAO,wBAAwB,MAAM,YAAY,QAAQ,cAAc;AACzE,MAAI,UAAU,MAAM,cAAc,KAAK,UAAU,MAAM,KAAK;AAC1D,WAAO;AAAA,MACL,MAAM,eAAe,QAAQ,MAAM,KAAK,GAAG;AAAA,MAC3C;AAAA,IACF;AACF,SAAO;AACT;AAEO,SAAS,oBACd,OACA,SACc;AACd,QAAMC,WAAU,uBAAuB,OAAO,mCAAmC,OAAO,CAAC;AACzF,MAAIA,aAAY,GAAI,OAAM,IAAI,MAAM,+BAA+B;AACnE,MAAIA,SAAQ,WAAW,MAAM,KAAKA,SAAQ,WAAW,MAAM,KAAKA,SAAQ,WAAW,QAAQ;AACzF,WAAO;AACT,MAAIA,SAAQ,WAAW,MAAM,KAAKA,SAAQ,WAAW,MAAM,KAAKA,SAAQ,WAAW,QAAQ;AACzF,WAAO;AACT,QAAM,IAAI,MAAM,iDAAiD;AACnE;AAIO,SAAS,uBACd,mBACA;AACA,SAAO,CACH,cACA,YAEF,CAAC,iBAAyB;AACxB,UAAM,OAAO,kBAAkB,SAAS,YAAY;AAEpD,UAAM,UAAU,aAAa,KAAK,QAAQ,KAAK,kBAAkB,CAAC;AAClE,QAAI,CAAC,QAAS;AACd,WAAO,mBAAmB,MAAM,QAAQ,MAAM;AAAA,EAChD;AACJ;AAOO,SAAS,kBAAkB,EAAE,OAAO,UAAU,QAAQ,GAA0B;AACrF,MAAI,CAAC,SAAU,OAAM,IAAI,MAAM,kCAAkC;AAEjE,MAAI,SAAS,UAAUF,qBAAoB;AACzC,UAAM,IAAI,MAAM,6CAA6C;AAE/D,QAAM,eAAe,sCAAsC,QAAQ,EAAE,KAAK;AAE1E,MAAI,CAAC,aAAa,WAAW;AAC3B,UAAM,IAAI,MAAM,kCAAkC;AAAA,EACpD;AAEA,QAAM,UAAU,kBAAkB,aAAa,WAAW,OAAO;AAEjE,MAAI,CAAC,QAAQ,QAAS,OAAM,IAAI,MAAM,gCAAgC;AAEtE,SAAO,QAAQ;AACjB;AAEO,SAAS,mBAAmB,WAAmB;AACpD,QAAM,OAAO,mBAAmB,SAAS;AACzC,SAAO,MAAM,eAAe,IAAI;AAClC;AAEO,SAAS,gBAAgB,QAA6C;AAC3E,QAAM,eAAe,OAAO;AAC5B,QAAM,SAA6B,CAAC;AACpC,WAAS,IAAI,GAAG,IAAI,cAAc,IAAK,QAAO,KAAK,OAAO,SAAS,CAAC,CAAC;AACrE,SAAO;AACT;AAEO,SAAS,iBAAiB,QAA8C;AAC7E,QAAM,gBAAgB,OAAO;AAC7B,QAAM,UAA+B,CAAC;AACtC,WAAS,IAAI,GAAG,IAAI,eAAe,IAAK,SAAQ,KAAK,OAAO,UAAU,CAAC,CAAC;AACxE,SAAO;AACT;;;ADxQA,IAAM,mBAAmB;AAEzB,IAAM,SAAS,cAAc,GAAG;AACxB,mBAAW,GAAG;AAEf,SAAS,qBAAqB,KAAiB;AACpD,SAAO,OAAO,eAAe,OAAO,KAAK,GAAG,CAAC;AAC/C;AAIA,IAAM,iBAAiB,WAAW,KAAK;AAAA,EACrC,GAAG,OAAO,YAAY,gBAAgB,CAAC;AAAA,EACvC,GAAG,OAAO,YAAY,gBAAgB,CAAC;AACzC,CAAC;AAEM,SAAS,kBAAkB,SAA8B;AAC9D,SAAO;AAAA,IACL,WAAW,KAAK,CAAC,GAAG,gBAAgB,GAAI,SAAS,OAAO,IAAI,YAAY,OAAO,IAAI,OAAQ,CAAC;AAAA,EAC9F;AACF;AAEO,IAAM,gCAAgC;AAAA,EAC3C,aAAaG,YAAW,kEAAkE;AAAA,EAC1F,cAAc;AAAA,EACd,UAAU;AACZ;AAEA,SAAS,gBAAgB,GAAW;AAClC,SAAO,OAAO,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,CAAC,CAAC;AAChD;AAEA,IAAM,sCAAsD,CAAC,UAAU,MAAM;AAEtE,SAAS,qCAAqC,aAAqB;AACxE,SAAO,oCAAoC,SAAS,WAA2B;AACjF;AAMO,SAAS,yBAAyB,cAAwB;AAC/D,QAAM,MAAM,OAAO,aAAa,MAAM;AACtC,SAAO,OAAO,OAAO,CAAC,KAAK,GAAG,aAAa,IAAI,aAAW,gBAAgB,OAAO,CAAC,CAAC,CAAC;AACtF;AAEA,SAAS,aAAa,QAAgB,GAA+B;AACnE,SAAe,eAAO,WAAW,YAAY,OAAO,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AACxF;AAEO,SAAS,YAAY,QAAwB,OAAY,CAAC,GAAmB;AAElF,MAAI,aAAqC,OAAO;AAChD,MAAI,CAAC,YAAY;AACf,UAAM,IAAI,MAAM,8CAA8C;AAAA,EAChE;AACA,MAAI,OAAO,UAAU,CAAC,MAAM,GAAG;AAC7B,iBAAa,IAAI,cAAc,UAAU;AAAA,EAC3C;AAEA,QAAM,oBAAoB,IAAI;AAAA,IAC5B;AAAA,IACA,aAAa,QAAQ,OAAO,SAAS,GAAG,KAAK,SAAS;AAAA,EACxD;AACA,MAAI,CAAC,mBAAmB;AACtB,UAAM,IAAI,MAAM,8BAA8B;AAAA,EAChD;AAEA,SAAO,OAAO,eAAe,OAAO,KAAK,iBAAiB,GAAG;AAAA,IAC3D,SAAS,KAAK;AAAA,EAChB,CAAC;AACH;;;AIpFA,SAAS,cAAc;AAEvB,YAAYC,cAAa;AAalB,SAAS,kCAAkC,YAAoB;AACpE,SAAO,qBAAqB,UAAU;AACxC;AAEO,SAAS,6BAA6B,YAAoB;AAC/D,SAAO,YAAY,qBAAqB,UAAU,CAAC;AACrD;AAEO,SAAS,gBAAgBC,UAAiB,SAAiB,SAA8B;AAC9F,QAAM,EAAE,aAAa,cAAc,SAAS,IAAI;AAEhD,QAAMC,UAAiB,iBAAQ;AAAA,IAC7BD;AAAA,IACA,mCAAmC,OAAO;AAAA,EAC5C;AAEA,QAAM,OAAO,kBAAkB,OAAO;AACtC,QAAM,WAAW,CAAC,GAAG,OAAO,KAAK,IAAI,CAAC;AACtC,QAAM,YAAoB,gBAAO,QAAQ,QAAQ;AAEjD,QAAM,iBAAiB,IAAY,qBAAY;AAC/C,iBAAe,UAAU;AACzB,iBAAe,SAAS,OAAO,KAAK,WAAW,GAAG,cAAc,UAAU,SAAS;AACnF,iBAAe,UAAUC,SAAQ,CAAC;AAClC,SAAO,EAAE,gBAAgB,QAAAA,QAAO;AAClC;AAEA,SAAS,eAAe,cAAsBA,SAAgB,SAA8B;AAC1F,QAAM,gBAAgB,IAAY,cAAK,EAAE,SAAS,mCAAmC,OAAO,EAAE,CAAC;AAC/F,gBAAc,WAAW,CAAC;AAC1B,QAAM,aAAa;AACnB,QAAM,eAAe;AACrB,QAAM,kBAA0B,gBAAO,QAAQ,CAAS,gBAAO,IAAI,SAAS,CAAC;AAE7E,gBAAc,SAAS;AAAA,IACrB,MAAM;AAAA,IACN,OAAO;AAAA,IACP,UAAU;AAAA,IACV,aAAa,EAAE,QAAAA,SAAQ,OAAO,EAAE;AAAA,EAClC,CAAC;AAED,gBAAc,UAAU,EAAE,QAAQ,iBAAiB,OAAO,EAAE,CAAC;AAC7D,SAAO;AACT;AAQA,eAAsB,wBAAwB,MAA+B;AAC3E,QAAM,EAAE,SAAAD,UAAS,SAAS,SAAS,SAAS,IAAI;AAEhD,QAAM,EAAE,gBAAgB,QAAAC,QAAO,IAAI,gBAAgBD,UAAS,SAAS,OAAO;AAE5E,QAAM,gBAAgB,eAAe,eAAe,QAAQ,GAAGC,SAAQ,OAAO;AAE9E,QAAM,WAAW,MAAM,SAAS,aAAa;AAE7C,QAAM,yBAAiC,cAAK,WAAW,OAAO,KAAK,SAAS,OAAO,CAAC,CAAC;AAErF,yBAAuB,cAAc,CAAC;AAKtC,QAAM,WAAW,uBAAuB,mBAAmB;AAE3D,QAAM,SAAS,yBAAyB,SAAS,IAAI,CAAC,EAAE,OAAO;AAE/D,SAAO;AAAA,IACL;AAAA,IACA,eAAe;AAAA,IACf,cAAc;AAAA,IACd,WAAW,OAAO,OAAO,MAAM;AAAA,EACjC;AACF;;;AC5FA,SAAS,SAAAC,cAAa;AACtB,YAAYC,UAAS;AAErB,SAAS,uBAAAC,4BAA2B;AAU7B,SAAS,qCACd,SACA,cACA;AACA,SAAO,SAAS,iCAAiC,OAAO,CAAC,KAAK,YAAY;AAC5E;AAEO,SAAS,0CACd,SACA,cACA,cACA;AACA,SAAO,qCAAqC,SAAS,YAAY,IAAI,MAAM,YAAY;AACzF;AAEO,SAAS,0CACd,UACA,SACA;AACA,MAAI,SAAS,UAAUC,qBAAoB,KAAM,OAAM,IAAI,MAAM,+BAA+B;AAChG,SAAO,CAAC,kBAA0C;AAAA,IAChD,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA,gBAAgB,qCAAqC,SAAS,YAAY;AAAA,IAC1E,UAAU,SAAS,OAAO,qCAAqC,SAAS,YAAY,CAAC;AAAA,EACvF;AACF;AAEO,SAAS,uCACd,UACA,SACA;AACA,MAAI,SAAS,UAAUA,qBAAoB;AACzC,UAAM,IAAI,MAAM,yCAAyC;AAE3D,MAAI,CAAC,SAAS,UAAW,OAAM,IAAI,MAAM,qCAAqC;AAE9E,SAAW,YAAO,SAAS,WAAW,mCAAmC,OAAO,CAAC;AACnF;AAMO,SAAS,sCAAsC;AAAA,EACpD;AAAA,EACA;AACF,GAA8C;AAC5C,MAAI,CAAC,KAAM;AACX,QAAM,WAAWC,OAAM,gBAAgB,IAAI;AAC3C,MAAI,CAAC,SAAU;AACf,QAAM,mBAAmB,kCAAkC,QAAQ;AACnE,SAAO,uCAAuC,kBAAkB,OAAO;AACzE;;;ACnEA,SAAS,iBAAiB;AAC1B,SAAS,UAAAC,eAAc;AACvB,SAAS,mBAAmB;AAE5B,SAAS,6BAA6B,+BAA+B;AAO9D,IAAM,iCAAiC;AAMvC,IAAM,wBAAwB;AAE9B,SAAS,8BAA8B,KAAa;AAGzD,QAAM,gCAAgC,YAAYA,OAAM,EAAE,OAAO,GAAG;AAEpE,SAAO,8BAA8B,MAAM,GAAG,8BAA8B,SAAS,CAAC;AACxF;AAGA,IAAM,+BAA+B;AAC9B,IAAM,+BAA+B;AAE5C,IAAM,2BAAyD;AAAA,EAC7D,SAAS;AAAA,EACT,SAAS;AACX;AAEA,SAAS,QAAQ,OAAmB;AAClC,SAAO,UAAUA,QAAO,KAAK,CAAC;AAChC;AAEO,SAAS,2BAA2B,WAAuB;AAChE,SAAO,QAAQ,SAAS;AAC1B;AAEO,SAAS,gCAAgC,SAAqB;AACnE,QAAM,eAAe,WAAW,KAAK;AAAA,IACnC,GAAG,WAAW,GAAG,CAAI;AAAA,IACrB,GAAG,WAAW,GAAG,QAAQ,MAAM;AAAA,IAC/B,GAAG;AAAA,EACL,CAAC;AACD,SAAO,QAAQ,YAAY;AAC7B;AAEO,SAAS,2BAA2B,cAA0B,SAAuB;AAC1F,QAAM,cAAc,yBAAyB,OAAO;AACpD,QAAM,oBAAoB,WAAW,KAAK,CAAC,aAAa,GAAG,YAAY,CAAC;AACxE,SAAO,YAAYA,OAAM,EAAE,OAAO,iBAAiB;AACrD;AAEO,SAAS,kCAAkC,WAAuB,SAAuB;AAC9F,QAAM,OAAO,2BAA2B,SAAS;AACjD,QAAM,YAAY,gCAAgC,IAAI;AACtD,SAAO,2BAA2B,WAAW,OAAO;AACtD;","names":["hexToBytes","btc","DerivationPathDepth","DerivationPathDepth","script","address","hexToBytes","bitcoin","address","script","HDKey","btc","DerivationPathDepth","DerivationPathDepth","HDKey","sha256"]}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@leather.io/bitcoin",
+  "author": "Leather.io contact@leather.io",
+  "description": "Shared bitcoin utilities",
+  "version": "0.8.0",
+  "license": "MIT",
+  "homepage": "https://github.com/leather.io/mono/tree/dev/packages/bitcoin",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:leather.io/mono.git",
+    "directory": "packages/bitcoin"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "bugs": "https://github.com/leather-io/mono/issues",
+  "dependencies": {
+    "@bitcoinerlab/secp256k1": "1.0.2",
+    "@noble/hashes": "1.4.0",
+    "@noble/secp256k1": "2.1.0",
+    "@scure/base": "1.1.6",
+    "@scure/bip32": "1.4.0",
+    "@scure/bip39": "1.3.0",
+    "@scure/btc-signer": "1.3.2",
+    "@stacks/common": "6.13.0",
+    "@stacks/transactions": "6.15.0",
+    "bip32": "4.0.0",
+    "bitcoinjs-lib": "6.1.5",
+    "ecpair": "2.1.0",
+    "varuint-bitcoin": "1.1.2",
+    "@leather.io/constants": "0.8.0",
+    "@leather.io/crypto": "1.0.2",
+    "@leather.io/utils": "0.9.0",
+    "@leather.io/models": "0.10.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-istanbul": "0.34.6",
+    "eslint": "8.53.0",
+    "prettier": "3.3.0",
+    "tslib": "2.6.2",
+    "tsup": "8.1.0",
+    "typescript": "5.4.5",
+    "vitest": "0.34.6",
+    "@leather.io/eslint-config": "0.6.0",
+    "@leather.io/rpc": "2.0.0",
+    "@leather.io/tsconfig-config": "0.5.0",
+    "@leather.io/prettier-config": "0.5.0"
+  },
+  "keywords": [
+    "bitcoin",
+    "leather",
+    "leather wallet"
+  ],
+  "prettier": "@leather.io/prettier-config",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "format": "prettier . --write --ignore-path ../../.prettierignore",
+    "format:check": "prettier . --check --ignore-path ../../.prettierignore",
+    "lint": "eslint . --fix --ignore-path ../../.eslintignore",
+    "lint:fix": "eslint . --fix --ignore-path ../../.eslintignore",
+    "test:coverage": "vitest run --coverage",
+    "test:unit": "vitest run",
+    "typecheck": "tsc --noEmit -p ./tsconfig.json"
+  }
+}