@leather.io/bitcoin 0.35.4 → 0.35.6

package/dist/index.js

@@ -1,1727 +1,1411 @@
-// src/bip21/bip21.ts
 import { decode, encode } from "bip21";
-import { isError } from "@leather.io/utils";
-var bip21 = {
-  decode: (uri, urnScheme) => {
-    try {
-      const { address: address2, options } = decode(uri, urnScheme);
-      return {
-        success: true,
-        data: { address: address2, ...options }
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: isError(error) ? error.message : "invalid input"
-      };
-    }
-  },
-  encode: (address2, options, urnScheme) => {
-    try {
-      return encode(address2, options, urnScheme);
-    } catch {
-      return null;
-    }
-  }
-};
-
-// src/bip322/bip322-utils.ts
+import { assertUnreachable, createCounter, createMoney, defaultWalletKeyId, hexToNumber, isDefined, isEmptyString, isError, isString, isUndefined, satToBtc, subtractMoney, sumMoney, sumNumbers, toHexString, whenNetwork } from "@leather.io/utils";
 import ecc from "@bitcoinerlab/secp256k1";
 import { sha256 } from "@noble/hashes/sha256";
-import { hexToBytes as hexToBytes2, utf8ToBytes } from "@noble/hashes/utils";
-import * as bitcoin from "bitcoinjs-lib";
+import { bytesToHex, hexToBytes, utf8ToBytes } from "@noble/hashes/utils";
+import * as bitcoinJs from "bitcoinjs-lib";
 import { ECPairFactory } from "ecpair";
-import { encode as encode2 } from "varuint-bitcoin";
-import { isString } from "@leather.io/utils";
-
-// src/utils/bitcoin.utils.ts
-import { hexToBytes } from "@noble/hashes/utils";
-import { HDKey } from "@scure/bip32";
+import { encode as encode$1 } from "varuint-bitcoin";
+import { HARDENED_OFFSET, HDKey } from "@scure/bip32";
 import { mnemonicToSeedSync } from "@scure/bip39";
-import * as btc3 from "@scure/btc-signer";
-import {
-  DerivationPathDepth as DerivationPathDepth3,
-  extractAccountIndexFromPath,
-  extractPurposeFromPath
-} from "@leather.io/crypto";
-import { defaultWalletKeyId, isDefined, whenNetwork } from "@leather.io/utils";
-
-// src/payments/p2tr-address-gen.ts
 import * as btc from "@scure/btc-signer";
-import { DerivationPathDepth } from "@leather.io/crypto";
+import { DerivationPathDepth, appendAddressIndexToPath, decomposeDescriptor, deriveBip39SeedFromMnemonic, deriveKeychainFromXpub, deriveRootBip32Keychain, extractAccountIndexFromPath, extractAddressIndexFromPath, extractChangeIndexFromPath, extractPurposeFromPath, keyOriginToDerivationPath } from "@leather.io/crypto";
+import validate$1, { AddressType, Network, getAddressInfo, validate } from "bitcoin-address-validation";
+import { base58check, base64 } from "@scure/base";
+import BigNumber from "bignumber.js";
+import { BITCOIN_MINIMUM_SPEND_IN_SATS, BTC_P2WPKH_DUST_AMOUNT } from "@leather.io/constants";
+import { z } from "zod";
+import { ripemd160 } from "@noble/hashes/ripemd160";
+import { RawPSBTV0, RawPSBTV2 } from "@scure/btc-signer/psbt";
 
-// src/utils/bitcoin.network.ts
-import * as bitcoinJs from "bitcoinjs-lib";
-var bitcoinMainnet = {
-  bech32: "bc",
-  pubKeyHash: 0,
-  scriptHash: 5,
-  wif: 128
+//#region src/bip21/bip21.ts
+const bip21 = {
+	decode: (uri, urnScheme) => {
+		try {
+			const { address, options } = decode(uri, urnScheme);
+			return {
+				success: true,
+				data: {
+					address,
+					...options
+				}
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: isError(error) ? error.message : "invalid input"
+			};
+		}
+	},
+	encode: (address, options, urnScheme) => {
+		try {
+			return encode(address, options, urnScheme);
+		} catch {
+			return null;
+		}
+	}
 };
-var bitcoinTestnet = {
-  bech32: "tb",
-  pubKeyHash: 111,
-  scriptHash: 196,
-  wif: 239
+
+//#endregion
+//#region src/utils/bitcoin.network.ts
+const bitcoinMainnet = {
+	bech32: "bc",
+	pubKeyHash: 0,
+	scriptHash: 5,
+	wif: 128
 };
-var bitcoinRegtest = {
-  bech32: "bcrt",
-  pubKeyHash: 111,
-  scriptHash: 196,
-  wif: 239
+const bitcoinTestnet = {
+	bech32: "tb",
+	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
+const btcSignerLibNetworks = {
+	mainnet: bitcoinMainnet,
+	testnet: bitcoinTestnet,
+	regtest: {
+		bech32: "bcrt",
+		pubKeyHash: 111,
+		scriptHash: 196,
+		wif: 239
+	},
+	signet: bitcoinTestnet
 };
 function getBtcSignerLibNetworkConfigByMode(network) {
-  return btcSignerLibNetworks[network];
+	return btcSignerLibNetworks[network];
 }
-var bitcoinJsLibNetworks = {
-  mainnet: bitcoinJs.networks.bitcoin,
-  testnet: bitcoinJs.networks.testnet,
-  regtest: bitcoinJs.networks.regtest,
-  signet: bitcoinJs.networks.testnet
+const bitcoinJsLibNetworks = {
+	mainnet: bitcoinJs.networks.bitcoin,
+	testnet: bitcoinJs.networks.testnet,
+	regtest: bitcoinJs.networks.regtest,
+	signet: bitcoinJs.networks.testnet
 };
 function getBitcoinJsLibNetworkConfigByMode(network) {
-  return bitcoinJsLibNetworks[network];
+	return bitcoinJsLibNetworks[network];
 }
 
-// src/payments/p2tr-address-gen.ts
+//#endregion
+//#region src/payments/p2tr-address-gen.ts
 function makeTaprootAccountDerivationPath(network, accountIndex) {
-  return `m/86'/${getBitcoinCoinTypeIndexByNetwork(network)}'/${accountIndex}'`;
+	return `m/86'/${getBitcoinCoinTypeIndexByNetwork(network)}'/${accountIndex}'`;
 }
-var getTaprootAccountDerivationPath = makeTaprootAccountDerivationPath;
+/** @deprecated Use makeTaprootAccountDerivationPath */
+const getTaprootAccountDerivationPath = makeTaprootAccountDerivationPath;
 function makeTaprootAddressIndexDerivationPath(network, accountIndex, addressIndex) {
-  return makeTaprootAccountDerivationPath(network, accountIndex) + `/0/${addressIndex}`;
+	return makeTaprootAccountDerivationPath(network, accountIndex) + `/0/${addressIndex}`;
 }
-var getTaprootAddressIndexDerivationPath = makeTaprootAddressIndexDerivationPath;
+/** @deprecated Use makeTaprootAddressIndexDerivationPath */
+const getTaprootAddressIndexDerivationPath = makeTaprootAddressIndexDerivationPath;
 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: makeTaprootAccountDerivationPath(network, accountIndex),
-    keychain: keychain.derive(makeTaprootAccountDerivationPath(network, accountIndex))
-  });
+	if (keychain.depth !== DerivationPathDepth.Root) throw new Error("Keychain passed is not an account");
+	return (accountIndex) => ({
+		type: "p2tr",
+		network,
+		accountIndex,
+		derivationPath: makeTaprootAccountDerivationPath(network, accountIndex),
+		keychain: keychain.derive(makeTaprootAccountDerivationPath(network, accountIndex))
+	});
 }
 function getTaprootPayment(publicKey, network) {
-  return btc.p2tr(
-    ecdsaPublicKeyToSchnorr(publicKey),
-    void 0,
-    getBtcSignerLibNetworkConfigByMode(network),
-    true
-    // allow unknown outputs
-  );
+	return btc.p2tr(ecdsaPublicKeyToSchnorr(publicKey), void 0, getBtcSignerLibNetworkConfigByMode(network), true);
 }
 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);
-}
-function deriveTaprootReceiveAddressIndexZero({
-  keychain,
-  network
-}) {
-  const zeroAddressIndex = deriveAddressIndexZeroFromAccount(keychain);
-  return {
-    keychain: zeroAddressIndex,
-    payment: getTaprootPaymentFromAddressIndex(zeroAddressIndex, 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);
+}
+function deriveTaprootReceiveAddressIndexZero({ keychain, network }) {
+	const zeroAddressIndex = deriveAddressIndexZeroFromAccount(keychain);
+	return {
+		keychain: zeroAddressIndex,
+		payment: getTaprootPaymentFromAddressIndex(zeroAddressIndex, network)
+	};
 }
 
-// src/payments/p2wpkh-address-gen.ts
-import * as btc2 from "@scure/btc-signer";
-import { DerivationPathDepth as DerivationPathDepth2 } from "@leather.io/crypto";
+//#endregion
+//#region src/payments/p2wpkh-address-gen.ts
 function makeNativeSegwitAccountDerivationPath(network, accountIndex) {
-  return `m/84'/${getBitcoinCoinTypeIndexByNetwork(network)}'/${accountIndex}'`;
+	return `m/84'/${getBitcoinCoinTypeIndexByNetwork(network)}'/${accountIndex}'`;
 }
-var getNativeSegwitAccountDerivationPath = makeNativeSegwitAccountDerivationPath;
+/** @deprecated Use makeNativeSegwitAccountDerivationPath */
+const getNativeSegwitAccountDerivationPath = makeNativeSegwitAccountDerivationPath;
 function makeNativeSegwitAddressIndexDerivationPath(network, accountIndex, addressIndex) {
-  return makeNativeSegwitAccountDerivationPath(network, accountIndex) + `/0/${addressIndex}`;
+	return makeNativeSegwitAccountDerivationPath(network, accountIndex) + `/0/${addressIndex}`;
 }
-var getNativeSegwitAddressIndexDerivationPath = makeNativeSegwitAddressIndexDerivationPath;
+/** @deprecated Use makeNativeSegwitAddressIndexDerivationPath */
+const getNativeSegwitAddressIndexDerivationPath = makeNativeSegwitAddressIndexDerivationPath;
 function deriveNativeSegwitAccountFromRootKeychain(keychain, network) {
-  if (keychain.depth !== DerivationPathDepth2.Root) throw new Error("Keychain passed is not a root");
-  return (accountIndex) => ({
-    type: "p2wpkh",
-    network,
-    accountIndex,
-    derivationPath: makeNativeSegwitAccountDerivationPath(network, accountIndex),
-    keychain: keychain.derive(makeNativeSegwitAccountDerivationPath(network, accountIndex))
-  });
+	if (keychain.depth !== DerivationPathDepth.Root) throw new Error("Keychain passed is not a root");
+	return (accountIndex) => ({
+		type: "p2wpkh",
+		network,
+		accountIndex,
+		derivationPath: makeNativeSegwitAccountDerivationPath(network, accountIndex),
+		keychain: keychain.derive(makeNativeSegwitAccountDerivationPath(network, accountIndex))
+	});
 }
 function getNativeSegwitPaymentFromAddressIndex(keychain, network) {
-  if (keychain.depth !== DerivationPathDepth2.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 btc2.p2wpkh(keychain.publicKey, getBtcSignerLibNetworkConfigByMode(network));
-}
-function deriveNativeSegwitReceiveAddressIndexZero({
-  keychain,
-  network
-}) {
-  const zeroAddressIndex = deriveAddressIndexZeroFromAccount(keychain);
-  return {
-    keychain: zeroAddressIndex,
-    payment: getNativeSegwitPaymentFromAddressIndex(zeroAddressIndex, network)
-  };
+	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));
+}
+function deriveNativeSegwitReceiveAddressIndexZero({ keychain, network }) {
+	const zeroAddressIndex = deriveAddressIndexZeroFromAccount(keychain);
+	return {
+		keychain: zeroAddressIndex,
+		payment: getNativeSegwitPaymentFromAddressIndex(zeroAddressIndex, network)
+	};
 }
 
-// src/validation/address-validation.ts
-import { Network, validate } from "bitcoin-address-validation";
-import { isEmptyString, isUndefined } from "@leather.io/utils";
+//#endregion
+//#region src/validation/address-validation.ts
 function getBitcoinAddressNetworkType(network) {
-  if (network === "signet") return Network.testnet;
-  return network;
+	if (network === "signet") return Network.testnet;
+	return network;
 }
-function isValidBitcoinAddress(address2) {
-  if (isUndefined(address2) || isEmptyString(address2)) {
-    return false;
-  }
-  return validate(address2);
+function isValidBitcoinAddress(address) {
+	if (isUndefined(address) || isEmptyString(address)) return false;
+	return validate(address);
 }
-function isValidBitcoinNetworkAddress(address2, network) {
-  return validate(address2, getBitcoinAddressNetworkType(network));
+function isValidBitcoinNetworkAddress(address, network) {
+	return validate(address, getBitcoinAddressNetworkType(network));
 }
 
-// src/validation/bitcoin-error.ts
+//#endregion
+//#region src/validation/bitcoin-error.ts
 var BitcoinError = class extends Error {
-  message;
-  constructor(message) {
-    super(message);
-    this.name = "BitcoinError";
-    this.message = message;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
+	message;
+	constructor(message) {
+		super(message);
+		this.name = "BitcoinError";
+		this.message = message;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
 };
 
-// src/validation/bitcoin-address.ts
+//#endregion
+//#region src/validation/bitcoin-address.ts
 function isBitcoinAddress(value) {
-  try {
-    isValidBitcoinAddress(value);
-    return true;
-  } catch {
-    return false;
-  }
+	try {
+		isValidBitcoinAddress(value);
+		return true;
+	} catch {
+		return false;
+	}
 }
 function createBitcoinAddress(value) {
-  if (!isBitcoinAddress(value)) {
-    throw new BitcoinError("InvalidAddress");
-  }
-  return value;
+	if (!isBitcoinAddress(value)) throw new BitcoinError("InvalidAddress");
+	return value;
 }
 
-// src/utils/bitcoin.utils.ts
+//#endregion
+//#region src/utils/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"
+	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 concept of mainnet and testnet
+*/
+const bitcoinNetworkToCoreNetworkMap = {
+	mainnet: "mainnet",
+	testnet: "testnet",
+	regtest: "testnet",
+	signet: "testnet"
 };
 function bitcoinNetworkModeToCoreNetworkMode(mode) {
-  return bitcoinNetworkToCoreNetworkMap[mode];
+	return bitcoinNetworkToCoreNetworkMap[mode];
 }
 function whenBitcoinNetwork(mode) {
-  return (networkMap) => networkMap[mode];
-}
-var coinTypeMap = {
-  mainnet: 0,
-  testnet: 1
+	return (networkMap) => networkMap[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`
+*/
+const coinTypeMap = {
+	mainnet: 0,
+	testnet: 1
 };
 function getBitcoinCoinTypeIndexByNetwork(network) {
-  return coinTypeMap[bitcoinNetworkModeToCoreNetworkMode(network)];
+	return coinTypeMap[bitcoinNetworkModeToCoreNetworkMode(network)];
 }
 function deriveAddressIndexKeychainFromAccount(keychain) {
-  if (keychain.depth !== DerivationPathDepth3.Account)
-    throw new Error("Keychain passed is not an account");
-  return (index) => keychain.deriveChild(0).deriveChild(index);
+	if (keychain.depth !== DerivationPathDepth.Account) throw new Error("Keychain passed is not an account");
+	return (index) => keychain.deriveChild(0).deriveChild(index);
 }
 function deriveAddressIndexZeroFromAccount(keychain) {
-  return deriveAddressIndexKeychainFromAccount(keychain)(0);
+	return deriveAddressIndexKeychainFromAccount(keychain)(0);
 }
-var ecdsaPublicKeyLength = 33;
+const ecdsaPublicKeyLength = 33;
 function ecdsaPublicKeyToSchnorr(pubKey) {
-  if (pubKey.byteLength !== ecdsaPublicKeyLength) throw new Error("Invalid public key length");
-  return pubKey.slice(1);
+	if (pubKey.byteLength !== ecdsaPublicKeyLength) throw new Error("Invalid public key length");
+	return pubKey.slice(1);
 }
 function toXOnly(pubKey) {
-  return pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33);
+	return pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33);
 }
 function decodeBitcoinTx(tx) {
-  return btc3.RawTx.decode(hexToBytes(tx));
-}
-function getAddressFromOutScript(script2, bitcoinNetwork) {
-  const outputScript = btc3.OutScript.decode(script2);
-  switch (outputScript.type) {
-    case "pkh":
-    case "sh":
-    case "wpkh":
-    case "wsh":
-      return createBitcoinAddress(
-        btc3.Address(bitcoinNetwork).encode({
-          type: outputScript.type,
-          hash: outputScript.hash
-        })
-      );
-    case "tr":
-      return createBitcoinAddress(
-        btc3.Address(bitcoinNetwork).encode({
-          type: outputScript.type,
-          pubkey: outputScript.pubkey
-        })
-      );
-    case "ms":
-      return createBitcoinAddress(btc3.p2ms(outputScript.m, outputScript.pubkeys).address ?? "");
-    case "pk":
-      return createBitcoinAddress(btc3.p2pk(outputScript.pubkey, bitcoinNetwork).address ?? "");
-    case "unknown":
-    case "tr_ms":
-    case "tr_ns":
-    case "p2a":
-    default:
-      return null;
-  }
-}
-var paymentTypeMap = {
-  wpkh: "p2wpkh",
-  wsh: "p2wpkh-p2sh",
-  tr: "p2tr",
-  pkh: "p2pkh",
-  sh: "p2sh"
+	return btc.RawTx.decode(hexToBytes(tx));
+}
+function getAddressFromOutScript(script, bitcoinNetwork) {
+	const outputScript = btc.OutScript.decode(script);
+	switch (outputScript.type) {
+		case "pkh":
+		case "sh":
+		case "wpkh":
+		case "wsh": return createBitcoinAddress(btc.Address(bitcoinNetwork).encode({
+			type: outputScript.type,
+			hash: outputScript.hash
+		}));
+		case "tr": return createBitcoinAddress(btc.Address(bitcoinNetwork).encode({
+			type: outputScript.type,
+			pubkey: outputScript.pubkey
+		}));
+		case "ms": return createBitcoinAddress(btc.p2ms(outputScript.m, outputScript.pubkeys).address ?? "");
+		case "pk": return createBitcoinAddress(btc.p2pk(outputScript.pubkey, bitcoinNetwork).address ?? "");
+		case "unknown":
+		case "tr_ms":
+		case "tr_ns":
+		case "p2a":
+		default: return null;
+	}
+}
+const paymentTypeMap = {
+	wpkh: "p2wpkh",
+	wsh: "p2wpkh-p2sh",
+	tr: "p2tr",
+	pkh: "p2pkh",
+	sh: "p2sh"
 };
 function btcSignerLibPaymentTypeToPaymentTypeMap(payment) {
-  return paymentTypeMap[payment];
+	return paymentTypeMap[payment];
 }
 function isBtcSignerLibPaymentType(payment) {
-  return payment in paymentTypeMap;
+	return payment in paymentTypeMap;
 }
 function parseKnownPaymentType(payment) {
-  return isBtcSignerLibPaymentType(payment) ? btcSignerLibPaymentTypeToPaymentTypeMap(payment) : payment;
+	return isBtcSignerLibPaymentType(payment) ? btcSignerLibPaymentTypeToPaymentTypeMap(payment) : payment;
 }
 function whenPaymentType(mode) {
-  return (paymentMap) => paymentMap[parseKnownPaymentType(mode)];
+	return (paymentMap) => paymentMap[parseKnownPaymentType(mode)];
 }
 function whenSupportedPaymentType(mode) {
-  return (paymentMap) => paymentMap[mode];
-}
+	return (paymentMap) => paymentMap[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`
+*/
 function inferPaymentTypeFromPath(path) {
-  const purpose = extractPurposeFromPath(path);
-  switch (purpose) {
-    case 84:
-      return "p2wpkh";
-    case 86:
-      return "p2tr";
-    case 44:
-      return "p2pkh";
-    default:
-      throw new Error(`Unable to infer payment type from purpose=${purpose}`);
-  }
+	const purpose = extractPurposeFromPath(path);
+	switch (purpose) {
+		case 84: return "p2wpkh";
+		case 86: return "p2tr";
+		case 44: return "p2pkh";
+		default: throw new Error(`Unable to infer payment type from purpose=${purpose}`);
+	}
 }
 function inferNetworkFromPath(path) {
-  return path.split("/")[2].startsWith("0") ? "mainnet" : "testnet";
+	return path.split("/")[2].startsWith("0") ? "mainnet" : "testnet";
 }
 function extractExtendedPublicKeyFromPolicy(policy) {
-  return policy.split("]")[1];
+	return policy.split("]")[1];
 }
 function createWalletIdDecoratedPath(policy, walletId) {
-  return policy.split("]")[0].replace("[", "").replace("m", walletId);
+	return policy.split("]")[0].replace("[", "").replace("m", walletId);
 }
 function getHdKeyVersionsFromNetwork(network) {
-  return whenNetwork(network)({
-    mainnet: void 0,
-    testnet: {
-      private: 0,
-      public: 70617039
-    }
-  });
+	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 null;
+	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 null;
 }
 function getInputPaymentType(input, network) {
-  const address2 = getBitcoinInputAddress(input, getBtcSignerLibNetworkConfigByMode(network));
-  if (address2 === null) 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");
+	const address = getBitcoinInputAddress(input, getBtcSignerLibNetworkConfigByMode(network));
+	if (address === null) 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");
 }
 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);
-  };
+	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 !== DerivationPathDepth3.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;
+	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;
 }
 function getNativeSegwitAddress({ index, keychain, network }) {
-  if (!keychain) throw new Error("Expected keychain to be provided");
-  if (keychain.depth !== DerivationPathDepth3.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 = getNativeSegwitPaymentFromAddressIndex(addressIndex, network);
-  if (!payment.address) throw new Error("Expected address to be defined");
-  return payment.address;
-}
+	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 = getNativeSegwitPaymentFromAddressIndex(addressIndex, network);
+	if (!payment.address) throw new Error("Expected address to be defined");
+	return payment.address;
+}
+/**
+* @deprecated
+* Use `deriveRootBip32Keychain` in `@leather.io/crypto` instead
+*/
 function mnemonicToRootNode(secretKey) {
-  const seed = mnemonicToSeedSync(secretKey);
-  return HDKey.fromMasterSeed(seed);
+	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;
+	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;
-}
-function inferNetworkFromAddress(address2) {
-  if (address2.startsWith("bc1")) return "mainnet";
-  if (address2.startsWith("tb1")) return "testnet";
-  if (address2.startsWith("bcrt1")) return "regtest";
-  const firstChar = address2[0];
-  if (firstChar === "1" || firstChar === "3") return "mainnet";
-  if (firstChar === "m" || firstChar === "n") return "testnet";
-  if (firstChar === "2") return "testnet";
-  throw new Error("Invalid or unsupported Bitcoin address format");
-}
-function inferPaymentTypeFromAddress(address2) {
-  if (address2.startsWith("bc1q") || address2.startsWith("tb1q") || address2.startsWith("bcrt1q"))
-    return "p2wpkh";
-  if (address2.startsWith("bc1p") || address2.startsWith("tb1p") || address2.startsWith("bcrt1p"))
-    return "p2tr";
-  throw new Error("Unable to infer payment type from address");
+	const outputsLength = psbtTx.outputsLength;
+	const outputs = [];
+	for (let i = 0; i < outputsLength; i++) outputs.push(psbtTx.getOutput(i));
+	return outputs;
+}
+function inferNetworkFromAddress(address) {
+	if (address.startsWith("bc1")) return "mainnet";
+	if (address.startsWith("tb1")) return "testnet";
+	if (address.startsWith("bcrt1")) return "regtest";
+	const firstChar = address[0];
+	if (firstChar === "1" || firstChar === "3") return "mainnet";
+	if (firstChar === "m" || firstChar === "n") return "testnet";
+	if (firstChar === "2") return "testnet";
+	throw new Error("Invalid or unsupported Bitcoin address format");
+}
+function inferPaymentTypeFromAddress(address) {
+	if (address.startsWith("bc1q") || address.startsWith("tb1q") || address.startsWith("bcrt1q")) return "p2wpkh";
+	if (address.startsWith("bc1p") || address.startsWith("tb1p") || address.startsWith("bcrt1p")) return "p2tr";
+	throw new Error("Unable to infer payment type from address");
 }
 function getBitcoinInputValue(input) {
-  if (isDefined(input.witnessUtxo)) return Number(input.witnessUtxo.amount);
-  if (isDefined(input.nonWitnessUtxo) && isDefined(input.index))
-    return Number(input.nonWitnessUtxo.outputs[input.index]?.amount);
-  return 0;
+	if (isDefined(input.witnessUtxo)) return Number(input.witnessUtxo.amount);
+	if (isDefined(input.nonWitnessUtxo) && isDefined(input.index)) return Number(input.nonWitnessUtxo.outputs[input.index]?.amount);
+	return 0;
 }
 
-// src/bip322/bip322-utils.ts
-var bip322MessageTag = "BIP0322-signed-message";
-var ECPair = ECPairFactory(ecc);
-bitcoin.initEccLib(ecc);
+//#endregion
+//#region src/bip322/bip322-utils.ts
+const bip322MessageTag = "BIP0322-signed-message";
+const ECPair = ECPairFactory(ecc);
+bitcoinJs.initEccLib(ecc);
 function ecPairFromPrivateKey(key) {
-  return ECPair.fromPrivateKey(Buffer.from(key));
+	return ECPair.fromPrivateKey(Buffer.from(key));
 }
-var messageTagHash = Uint8Array.from([
-  ...sha256(utf8ToBytes(bip322MessageTag)),
-  ...sha256(utf8ToBytes(bip322MessageTag))
-]);
+const 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
+	return sha256(Uint8Array.from([...messageTagHash, ...isString(message) ? utf8ToBytes(message) : message]));
+}
+const bip322TransactionToSignValues = {
+	prevoutHash: hexToBytes("0000000000000000000000000000000000000000000000000000000000000000"),
+	prevoutIndex: 4294967295,
+	sequence: 0
 };
 function encodeVarString(b) {
-  return Buffer.concat([encode2(b.byteLength), b]);
+	return Buffer.concat([encode$1(b.byteLength), b]);
 }
-var supportedMessageSigningPaymentTypes = ["p2wpkh", "p2tr"];
+const supportedMessageSigningPaymentTypes = ["p2wpkh", "p2tr"];
 function isSupportedMessageSigningPaymentType(paymentType) {
-  return supportedMessageSigningPaymentTypes.includes(paymentType);
+	return supportedMessageSigningPaymentTypes.includes(paymentType);
 }
+/**
+* Encode witness data for a BIP322 message
+* TODO: Refactor to remove `Buffer` use
+*/
 function encodeMessageWitnessData(witnessArray) {
-  const len = encode2(witnessArray.length);
-  return Buffer.concat([len, ...witnessArray.map((witness) => encodeVarString(witness))]);
+	const len = encode$1(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]));
+	return bitcoinJs.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
-  });
+	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";
+//#endregion
+//#region src/bip322/sign-message-bip322-bitcoinjs.ts
 function createNativeSegwitBitcoinJsSigner(privateKey) {
-  return ecPairFromPrivateKey(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;
+	return tweakSigner(ecPairFromPrivateKey(privateKey));
+}
+function createToSpendTx(address, message, network) {
+	const { prevoutHash, prevoutIndex, sequence } = bip322TransactionToSignValues;
+	const script = bitcoinJs.address.toOutputScript(address, getBitcoinJsLibNetworkConfigByMode(network));
+	const hash = hashBip322Message(message);
+	const commands = [0, Buffer.from(hash)];
+	const scriptSig = bitcoinJs.script.compile(commands);
+	const virtualToSpend = new bitcoinJs.Transaction();
+	virtualToSpend.version = 0;
+	virtualToSpend.addInput(Buffer.from(prevoutHash), prevoutIndex, sequence, scriptSig);
+	virtualToSpend.addOutput(script, 0);
+	return {
+		virtualToSpend,
+		script
+	};
+}
+function createToSignTx(toSpendTxHex, script, network) {
+	const virtualToSign = new bitcoinJs.Psbt({ network: getBitcoinJsLibNetworkConfigByMode(network) });
+	virtualToSign.setVersion(0);
+	const prevTxHash = toSpendTxHex;
+	const prevOutIndex = 0;
+	const toSignScriptSig = bitcoinJs.script.compile([bitcoinJs.script.OPS.OP_RETURN]);
+	virtualToSign.addInput({
+		hash: prevTxHash,
+		index: prevOutIndex,
+		sequence: 0,
+		witnessUtxo: {
+			script,
+			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)
-  };
+	const { address, message, network, signPsbt } = args;
+	const { virtualToSpend, script } = createToSpendTx(address, message, network);
+	const signedTx = await signPsbt(createToSignTx(virtualToSpend.getHash(), script, network));
+	const asBitcoinJsTransaction = bitcoinJs.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/coin-selection/calculate-max-spend.ts
-import BigNumber3 from "bignumber.js";
-import { createMoney, satToBtc } from "@leather.io/utils";
-
-// src/coin-selection/coin-selection.utils.ts
-import BigNumber2 from "bignumber.js";
-import validate2, { AddressType, getAddressInfo } from "bitcoin-address-validation";
-import { BTC_P2WPKH_DUST_AMOUNT } from "@leather.io/constants";
-import { sumNumbers } from "@leather.io/utils";
-
-// src/fees/btc-size-fee-estimator.ts
-import BigNumber from "bignumber.js";
-import { assertUnreachable } from "@leather.io/utils";
+//#endregion
+//#region src/fees/btc-size-fee-estimator.ts
 var BtcSizeFeeEstimator = class {
-  P2PKH_IN_SIZE = 148;
-  P2PKH_OUT_SIZE = 34;
-  P2SH_OUT_SIZE = 32;
-  P2SH_P2WPKH_OUT_SIZE = 32;
-  P2SH_P2WSH_OUT_SIZE = 32;
-  P2SH_P2WPKH_IN_SIZE = 91;
-  P2WPKH_IN_SIZE = 67.75;
-  P2WPKH_OUT_SIZE = 31;
-  P2WSH_OUT_SIZE = 43;
-  P2TR_OUT_SIZE = 43;
-  P2TR_IN_SIZE = 57.25;
-  PUBKEY_SIZE = 33;
-  SIGNATURE_SIZE = 72;
-  SUPPORTED_INPUT_SCRIPT_TYPES = [
-    "p2pkh",
-    "p2sh",
-    "p2sh-p2wpkh",
-    "p2sh-p2wsh",
-    "p2wpkh",
-    "p2wsh",
-    "p2tr"
-  ];
-  defaultParams = {
-    input_count: 0,
-    input_script: "p2wpkh",
-    input_m: 0,
-    input_n: 0,
-    p2pkh_output_count: 0,
-    p2sh_output_count: 0,
-    p2sh_p2wpkh_output_count: 0,
-    p2sh_p2wsh_output_count: 0,
-    p2wpkh_output_count: 0,
-    p2wsh_output_count: 0,
-    p2tr_output_count: 0
-  };
-  params = { ...this.defaultParams };
-  getSizeOfScriptLengthElement(length) {
-    if (length < 75) {
-      return 1;
-    } else if (length <= 255) {
-      return 2;
-    } else if (length <= 65535) {
-      return 3;
-    } else if (length <= 4294967295) {
-      return 5;
-    } else {
-      throw new Error("Size of redeem script is too large");
-    }
-  }
-  getSizeOfletInt(length) {
-    if (length < 253) {
-      return 1;
-    } else if (length < 65535) {
-      return 3;
-    } else if (length < 4294967295) {
-      return 5;
-    } else if (new BigNumber(length).isLessThan("18446744073709551615")) {
-      return 9;
-    } else {
-      throw new Error("Invalid let int");
-    }
-  }
-  getTxOverheadVBytes(input_script, input_count, output_count) {
-    let witness_vbytes;
-    if (input_script === "p2pkh" || input_script === "p2sh") {
-      witness_vbytes = 0;
-    } else {
-      witness_vbytes = 0.25 + // segwit marker
-      0.25 + // segwit flag
-      this.getSizeOfletInt(input_count) / 4;
-    }
-    return 4 + // nVersion
-    this.getSizeOfletInt(input_count) + // number of inputs
-    this.getSizeOfletInt(output_count) + // number of outputs
-    4 + // nLockTime
-    witness_vbytes;
-  }
-  getTxOverheadExtraRawBytes(input_script, input_count) {
-    let witness_vbytes;
-    if (input_script === "p2pkh" || input_script === "p2sh") {
-      witness_vbytes = 0;
-    } else {
-      witness_vbytes = 0.25 + // segwit marker
-      0.25 + // segwit flag
-      this.getSizeOfletInt(input_count) / 4;
-    }
-    return witness_vbytes * 3;
-  }
-  prepareParams(opts) {
-    opts = opts || Object.assign(this.defaultParams);
-    const input_count = opts.input_count || this.defaultParams.input_count;
-    if (!Number.isInteger(input_count) || input_count < 0) {
-      throw new Error("expecting positive input count, got: " + input_count);
-    }
-    const input_script = opts.input_script || this.defaultParams.input_script;
-    if (this.SUPPORTED_INPUT_SCRIPT_TYPES.indexOf(input_script) === -1) {
-      throw new Error("Not supported input script type");
-    }
-    const input_m = opts.input_m || this.defaultParams.input_m;
-    if (!Number.isInteger(input_m) || input_m < 0) {
-      throw new Error("expecting positive signature count");
-    }
-    const input_n = opts.input_n || this.defaultParams.input_n;
-    if (!Number.isInteger(input_n) || input_n < 0) {
-      throw new Error("expecting positive pubkey count");
-    }
-    const p2pkh_output_count = opts.p2pkh_output_count || this.defaultParams.p2pkh_output_count;
-    if (!Number.isInteger(p2pkh_output_count) || p2pkh_output_count < 0) {
-      throw new Error("expecting positive p2pkh output count");
-    }
-    const p2sh_output_count = opts.p2sh_output_count || this.defaultParams.p2sh_output_count;
-    if (!Number.isInteger(p2sh_output_count) || p2sh_output_count < 0) {
-      throw new Error("expecting positive p2sh output count");
-    }
-    const p2sh_p2wpkh_output_count = opts.p2sh_p2wpkh_output_count || this.defaultParams.p2sh_p2wpkh_output_count;
-    if (!Number.isInteger(p2sh_p2wpkh_output_count) || p2sh_p2wpkh_output_count < 0) {
-      throw new Error("expecting positive p2sh-p2wpkh output count");
-    }
-    const p2sh_p2wsh_output_count = opts.p2sh_p2wsh_output_count || this.defaultParams.p2sh_p2wsh_output_count;
-    if (!Number.isInteger(p2sh_p2wsh_output_count) || p2sh_p2wsh_output_count < 0) {
-      throw new Error("expecting positive p2sh-p2wsh output count");
-    }
-    const p2wpkh_output_count = opts.p2wpkh_output_count || this.defaultParams.p2wpkh_output_count;
-    if (!Number.isInteger(p2wpkh_output_count) || p2wpkh_output_count < 0) {
-      throw new Error("expecting positive p2wpkh output count");
-    }
-    const p2wsh_output_count = opts.p2wsh_output_count || this.defaultParams.p2wsh_output_count;
-    if (!Number.isInteger(p2wsh_output_count) || p2wsh_output_count < 0) {
-      throw new Error("expecting positive p2wsh output count");
-    }
-    const p2tr_output_count = opts.p2tr_output_count || this.defaultParams.p2tr_output_count;
-    if (!Number.isInteger(p2tr_output_count) || p2tr_output_count < 0) {
-      throw new Error("expecting positive p2tr output count");
-    }
-    this.params = {
-      input_count,
-      input_script,
-      input_m,
-      input_n,
-      p2pkh_output_count,
-      p2sh_output_count,
-      p2sh_p2wpkh_output_count,
-      p2sh_p2wsh_output_count,
-      p2wpkh_output_count,
-      p2wsh_output_count,
-      p2tr_output_count
-    };
-    return this.params;
-  }
-  getOutputCount() {
-    return this.params.p2pkh_output_count + this.params.p2sh_output_count + this.params.p2sh_p2wpkh_output_count + this.params.p2sh_p2wsh_output_count + this.params.p2wpkh_output_count + this.params.p2wsh_output_count + this.params.p2tr_output_count;
-  }
-  getSizeBasedOnInputType() {
-    let inputSize = 0;
-    let inputWitnessSize = 0;
-    let redeemScriptSize;
-    switch (this.params.input_script) {
-      case "p2pkh":
-        inputSize = this.P2PKH_IN_SIZE;
-        break;
-      case "p2sh-p2wpkh":
-        inputSize = this.P2SH_P2WPKH_IN_SIZE;
-        inputWitnessSize = 107;
-        break;
-      case "p2wpkh":
-        inputSize = this.P2WPKH_IN_SIZE;
-        inputWitnessSize = 107;
-        break;
-      case "p2tr":
-        inputSize = this.P2TR_IN_SIZE;
-        inputWitnessSize = 65;
-        break;
-      case "p2sh":
-        redeemScriptSize = 1 + // OP_M
-        this.params.input_n * (1 + this.PUBKEY_SIZE) + // OP_PUSH33 <pubkey>
-        1 + // OP_N
-        1;
-        const scriptSigSize = 1 + // size(0)
-        this.params.input_m * (1 + this.SIGNATURE_SIZE) + // size(SIGNATURE_SIZE) + signature
-        this.getSizeOfScriptLengthElement(redeemScriptSize) + redeemScriptSize;
-        inputSize = 32 + 4 + this.getSizeOfletInt(scriptSigSize) + scriptSigSize + 4;
-        break;
-      case "p2sh-p2wsh":
-      case "p2wsh":
-        redeemScriptSize = 1 + // OP_M
-        this.params.input_n * (1 + this.PUBKEY_SIZE) + // OP_PUSH33 <pubkey>
-        1 + // OP_N
-        1;
-        inputWitnessSize = 1 + // size(0)
-        this.params.input_m * (1 + this.SIGNATURE_SIZE) + // size(SIGNATURE_SIZE) + signature
-        this.getSizeOfScriptLengthElement(redeemScriptSize) + redeemScriptSize;
-        inputSize = 36 + // outpoint (spent UTXO ID)
-        inputWitnessSize / 4 + // witness program
-        4;
-        if (this.params.input_script === "p2sh-p2wsh") {
-          inputSize += 32 + 3;
-        }
-        break;
-      default:
-        assertUnreachable(this.params.input_script);
-    }
-    return {
-      inputSize,
-      inputWitnessSize
-    };
-  }
-  calcTxSize(opts) {
-    this.prepareParams(opts);
-    const output_count = this.getOutputCount();
-    const { inputSize, inputWitnessSize } = this.getSizeBasedOnInputType();
-    const txVBytes = this.getTxOverheadVBytes(this.params.input_script, this.params.input_count, output_count) + inputSize * this.params.input_count + this.P2PKH_OUT_SIZE * this.params.p2pkh_output_count + this.P2SH_OUT_SIZE * this.params.p2sh_output_count + this.P2SH_P2WPKH_OUT_SIZE * this.params.p2sh_p2wpkh_output_count + this.P2SH_P2WSH_OUT_SIZE * this.params.p2sh_p2wsh_output_count + this.P2WPKH_OUT_SIZE * this.params.p2wpkh_output_count + this.P2WSH_OUT_SIZE * this.params.p2wsh_output_count + this.P2TR_OUT_SIZE * this.params.p2tr_output_count;
-    const txBytes = this.getTxOverheadExtraRawBytes(this.params.input_script, this.params.input_count) + txVBytes + inputWitnessSize * this.params.input_count;
-    const txWeight = txVBytes * 4;
-    return { txVBytes, txBytes, txWeight };
-  }
-  estimateFee(vbyte, satVb) {
-    if (isNaN(vbyte) || isNaN(satVb)) {
-      throw new Error("Parameters should be numbers");
-    }
-    return vbyte * satVb;
-  }
-  formatFeeRange(fee, multiplier) {
-    if (isNaN(fee) || isNaN(multiplier)) {
-      throw new Error("Parameters should be numbers");
-    }
-    if (multiplier < 0) {
-      throw new Error("Multiplier cant be negative");
-    }
-    const multipliedFee = fee * multiplier;
-    return fee - multipliedFee + " - " + (fee + multipliedFee);
-  }
+	P2PKH_IN_SIZE = 148;
+	P2PKH_OUT_SIZE = 34;
+	P2SH_OUT_SIZE = 32;
+	P2SH_P2WPKH_OUT_SIZE = 32;
+	P2SH_P2WSH_OUT_SIZE = 32;
+	P2SH_P2WPKH_IN_SIZE = 91;
+	P2WPKH_IN_SIZE = 67.75;
+	P2WPKH_OUT_SIZE = 31;
+	P2WSH_OUT_SIZE = 43;
+	P2TR_OUT_SIZE = 43;
+	P2TR_IN_SIZE = 57.25;
+	PUBKEY_SIZE = 33;
+	SIGNATURE_SIZE = 72;
+	SUPPORTED_INPUT_SCRIPT_TYPES = [
+		"p2pkh",
+		"p2sh",
+		"p2sh-p2wpkh",
+		"p2sh-p2wsh",
+		"p2wpkh",
+		"p2wsh",
+		"p2tr"
+	];
+	defaultParams = {
+		input_count: 0,
+		input_script: "p2wpkh",
+		input_m: 0,
+		input_n: 0,
+		p2pkh_output_count: 0,
+		p2sh_output_count: 0,
+		p2sh_p2wpkh_output_count: 0,
+		p2sh_p2wsh_output_count: 0,
+		p2wpkh_output_count: 0,
+		p2wsh_output_count: 0,
+		p2tr_output_count: 0
+	};
+	params = { ...this.defaultParams };
+	getSizeOfScriptLengthElement(length) {
+		if (length < 75) return 1;
+		else if (length <= 255) return 2;
+		else if (length <= 65535) return 3;
+		else if (length <= 4294967295) return 5;
+		else throw new Error("Size of redeem script is too large");
+	}
+	getSizeOfletInt(length) {
+		if (length < 253) return 1;
+		else if (length < 65535) return 3;
+		else if (length < 4294967295) return 5;
+		else if (new BigNumber(length).isLessThan("18446744073709551615")) return 9;
+		else throw new Error("Invalid let int");
+	}
+	getTxOverheadVBytes(input_script, input_count, output_count) {
+		let witness_vbytes;
+		if (input_script === "p2pkh" || input_script === "p2sh") witness_vbytes = 0;
+		else witness_vbytes = .5 + this.getSizeOfletInt(input_count) / 4;
+		return 4 + this.getSizeOfletInt(input_count) + this.getSizeOfletInt(output_count) + 4 + witness_vbytes;
+	}
+	getTxOverheadExtraRawBytes(input_script, input_count) {
+		let witness_vbytes;
+		if (input_script === "p2pkh" || input_script === "p2sh") witness_vbytes = 0;
+		else witness_vbytes = .5 + this.getSizeOfletInt(input_count) / 4;
+		return witness_vbytes * 3;
+	}
+	prepareParams(opts) {
+		opts = opts || Object.assign(this.defaultParams);
+		const input_count = opts.input_count || this.defaultParams.input_count;
+		if (!Number.isInteger(input_count) || input_count < 0) throw new Error("expecting positive input count, got: " + input_count);
+		const input_script = opts.input_script || this.defaultParams.input_script;
+		if (this.SUPPORTED_INPUT_SCRIPT_TYPES.indexOf(input_script) === -1) throw new Error("Not supported input script type");
+		const input_m = opts.input_m || this.defaultParams.input_m;
+		if (!Number.isInteger(input_m) || input_m < 0) throw new Error("expecting positive signature count");
+		const input_n = opts.input_n || this.defaultParams.input_n;
+		if (!Number.isInteger(input_n) || input_n < 0) throw new Error("expecting positive pubkey count");
+		const p2pkh_output_count = opts.p2pkh_output_count || this.defaultParams.p2pkh_output_count;
+		if (!Number.isInteger(p2pkh_output_count) || p2pkh_output_count < 0) throw new Error("expecting positive p2pkh output count");
+		const p2sh_output_count = opts.p2sh_output_count || this.defaultParams.p2sh_output_count;
+		if (!Number.isInteger(p2sh_output_count) || p2sh_output_count < 0) throw new Error("expecting positive p2sh output count");
+		const p2sh_p2wpkh_output_count = opts.p2sh_p2wpkh_output_count || this.defaultParams.p2sh_p2wpkh_output_count;
+		if (!Number.isInteger(p2sh_p2wpkh_output_count) || p2sh_p2wpkh_output_count < 0) throw new Error("expecting positive p2sh-p2wpkh output count");
+		const p2sh_p2wsh_output_count = opts.p2sh_p2wsh_output_count || this.defaultParams.p2sh_p2wsh_output_count;
+		if (!Number.isInteger(p2sh_p2wsh_output_count) || p2sh_p2wsh_output_count < 0) throw new Error("expecting positive p2sh-p2wsh output count");
+		const p2wpkh_output_count = opts.p2wpkh_output_count || this.defaultParams.p2wpkh_output_count;
+		if (!Number.isInteger(p2wpkh_output_count) || p2wpkh_output_count < 0) throw new Error("expecting positive p2wpkh output count");
+		const p2wsh_output_count = opts.p2wsh_output_count || this.defaultParams.p2wsh_output_count;
+		if (!Number.isInteger(p2wsh_output_count) || p2wsh_output_count < 0) throw new Error("expecting positive p2wsh output count");
+		const p2tr_output_count = opts.p2tr_output_count || this.defaultParams.p2tr_output_count;
+		if (!Number.isInteger(p2tr_output_count) || p2tr_output_count < 0) throw new Error("expecting positive p2tr output count");
+		this.params = {
+			input_count,
+			input_script,
+			input_m,
+			input_n,
+			p2pkh_output_count,
+			p2sh_output_count,
+			p2sh_p2wpkh_output_count,
+			p2sh_p2wsh_output_count,
+			p2wpkh_output_count,
+			p2wsh_output_count,
+			p2tr_output_count
+		};
+		return this.params;
+	}
+	getOutputCount() {
+		return this.params.p2pkh_output_count + this.params.p2sh_output_count + this.params.p2sh_p2wpkh_output_count + this.params.p2sh_p2wsh_output_count + this.params.p2wpkh_output_count + this.params.p2wsh_output_count + this.params.p2tr_output_count;
+	}
+	getSizeBasedOnInputType() {
+		let inputSize = 0;
+		let inputWitnessSize = 0;
+		let redeemScriptSize;
+		switch (this.params.input_script) {
+			case "p2pkh":
+				inputSize = this.P2PKH_IN_SIZE;
+				break;
+			case "p2sh-p2wpkh":
+				inputSize = this.P2SH_P2WPKH_IN_SIZE;
+				inputWitnessSize = 107;
+				break;
+			case "p2wpkh":
+				inputSize = this.P2WPKH_IN_SIZE;
+				inputWitnessSize = 107;
+				break;
+			case "p2tr":
+				inputSize = this.P2TR_IN_SIZE;
+				inputWitnessSize = 65;
+				break;
+			case "p2sh":
+				redeemScriptSize = 1 + this.params.input_n * (1 + this.PUBKEY_SIZE) + 1 + 1;
+				const scriptSigSize = 1 + this.params.input_m * (1 + this.SIGNATURE_SIZE) + this.getSizeOfScriptLengthElement(redeemScriptSize) + redeemScriptSize;
+				inputSize = 36 + this.getSizeOfletInt(scriptSigSize) + scriptSigSize + 4;
+				break;
+			case "p2sh-p2wsh":
+			case "p2wsh":
+				redeemScriptSize = 1 + this.params.input_n * (1 + this.PUBKEY_SIZE) + 1 + 1;
+				inputWitnessSize = 1 + this.params.input_m * (1 + this.SIGNATURE_SIZE) + this.getSizeOfScriptLengthElement(redeemScriptSize) + redeemScriptSize;
+				inputSize = 36 + inputWitnessSize / 4 + 4;
+				if (this.params.input_script === "p2sh-p2wsh") inputSize += 35;
+				break;
+			default: assertUnreachable(this.params.input_script);
+		}
+		return {
+			inputSize,
+			inputWitnessSize
+		};
+	}
+	calcTxSize(opts) {
+		this.prepareParams(opts);
+		const output_count = this.getOutputCount();
+		const { inputSize, inputWitnessSize } = this.getSizeBasedOnInputType();
+		const txVBytes = this.getTxOverheadVBytes(this.params.input_script, this.params.input_count, output_count) + inputSize * this.params.input_count + this.P2PKH_OUT_SIZE * this.params.p2pkh_output_count + this.P2SH_OUT_SIZE * this.params.p2sh_output_count + this.P2SH_P2WPKH_OUT_SIZE * this.params.p2sh_p2wpkh_output_count + this.P2SH_P2WSH_OUT_SIZE * this.params.p2sh_p2wsh_output_count + this.P2WPKH_OUT_SIZE * this.params.p2wpkh_output_count + this.P2WSH_OUT_SIZE * this.params.p2wsh_output_count + this.P2TR_OUT_SIZE * this.params.p2tr_output_count;
+		return {
+			txVBytes,
+			txBytes: this.getTxOverheadExtraRawBytes(this.params.input_script, this.params.input_count) + txVBytes + inputWitnessSize * this.params.input_count,
+			txWeight: txVBytes * 4
+		};
+	}
+	estimateFee(vbyte, satVb) {
+		if (isNaN(vbyte) || isNaN(satVb)) throw new Error("Parameters should be numbers");
+		return vbyte * satVb;
+	}
+	formatFeeRange(fee, multiplier) {
+		if (isNaN(fee) || isNaN(multiplier)) throw new Error("Parameters should be numbers");
+		if (multiplier < 0) throw new Error("Multiplier cant be negative");
+		const multipliedFee = fee * multiplier;
+		return fee - multipliedFee + " - " + (fee + multipliedFee);
+	}
 };
 
-// src/coin-selection/coin-selection.utils.ts
+//#endregion
+//#region src/coin-selection/coin-selection.utils.ts
 function getUtxoTotal(utxos) {
-  return sumNumbers(utxos.map((utxo) => utxo.value));
+	return sumNumbers(utxos.map((utxo) => utxo.value));
 }
 function getSizeInfo(payload) {
-  const { inputLength, recipients, isSendMax } = payload;
-  const validAddressesInfo = recipients.map((recipient) => validate2(recipient.address) && getAddressInfo(recipient.address)).filter(Boolean);
-  function getTxOutputsLengthByPaymentType() {
-    return validAddressesInfo.reduce(
-      (acc, { type }) => {
-        acc[type] = (acc[type] || 0) + 1;
-        return acc;
-      },
-      {}
-    );
-  }
-  const outputTypesCount = getTxOutputsLengthByPaymentType();
-  if (!isSendMax) {
-    outputTypesCount[AddressType.p2wpkh] = (outputTypesCount[AddressType.p2wpkh] || 0) + 1;
-  }
-  const outputsData = Object.entries(outputTypesCount).reduce(
-    (acc, [type, count]) => {
-      acc[type + "_output_count"] = count;
-      return acc;
-    },
-    {}
-  );
-  const txSizer = new BtcSizeFeeEstimator();
-  const sizeInfo = txSizer.calcTxSize({
-    input_script: "p2wpkh",
-    input_count: inputLength,
-    ...outputsData
-  });
-  return sizeInfo;
-}
-function getSpendableAmount({
-  utxos,
-  feeRate,
-  recipients
-}) {
-  const balance = utxos.map((utxo) => utxo.value).reduce((prevVal, curVal) => prevVal + curVal, 0);
-  const size = getSizeInfo({
-    inputLength: utxos.length,
-    recipients
-  });
-  const fee = Math.ceil(size.txVBytes * feeRate);
-  const bigNumberBalance = BigNumber2(balance);
-  return {
-    spendableAmount: BigNumber2.max(0, bigNumberBalance.minus(fee)),
-    fee
-  };
-}
-function filterUneconomicalUtxos({
-  utxos,
-  feeRate,
-  recipients
-}) {
-  const { spendableAmount: fullSpendableAmount } = getSpendableAmount({
-    utxos,
-    feeRate,
-    recipients
-  });
-  const filteredUtxos = utxos.filter((utxo) => Number(utxo.value) >= BTC_P2WPKH_DUST_AMOUNT).filter((utxo) => {
-    const { spendableAmount } = getSpendableAmount({
-      utxos: utxos.filter((u) => u.txid !== utxo.txid),
-      feeRate,
-      recipients
-    });
-    return spendableAmount.toNumber() < fullSpendableAmount.toNumber();
-  });
-  return filteredUtxos;
+	const { inputLength, recipients, isSendMax } = payload;
+	const validAddressesInfo = recipients.map((recipient) => validate$1(recipient.address) && getAddressInfo(recipient.address)).filter(Boolean);
+	function getTxOutputsLengthByPaymentType() {
+		return validAddressesInfo.reduce((acc, { type }) => {
+			acc[type] = (acc[type] || 0) + 1;
+			return acc;
+		}, {});
+	}
+	const outputTypesCount = getTxOutputsLengthByPaymentType();
+	if (!isSendMax) outputTypesCount[AddressType.p2wpkh] = (outputTypesCount[AddressType.p2wpkh] || 0) + 1;
+	const outputsData = Object.entries(outputTypesCount).reduce((acc, [type, count]) => {
+		acc[type + "_output_count"] = count;
+		return acc;
+	}, {});
+	return new BtcSizeFeeEstimator().calcTxSize({
+		input_script: "p2wpkh",
+		input_count: inputLength,
+		...outputsData
+	});
+}
+function getSpendableAmount({ utxos, feeRate, recipients }) {
+	const balance = utxos.map((utxo) => utxo.value).reduce((prevVal, curVal) => prevVal + curVal, 0);
+	const size = getSizeInfo({
+		inputLength: utxos.length,
+		recipients
+	});
+	const fee = Math.ceil(size.txVBytes * feeRate);
+	const bigNumberBalance = BigNumber(balance);
+	return {
+		spendableAmount: BigNumber.max(0, bigNumberBalance.minus(fee)),
+		fee
+	};
+}
+function filterUneconomicalUtxos({ utxos, feeRate, recipients }) {
+	const { spendableAmount: fullSpendableAmount } = getSpendableAmount({
+		utxos,
+		feeRate,
+		recipients
+	});
+	return utxos.filter((utxo) => Number(utxo.value) >= BTC_P2WPKH_DUST_AMOUNT).filter((utxo) => {
+		const { spendableAmount } = getSpendableAmount({
+			utxos: utxos.filter((u) => u.txid !== utxo.txid),
+			feeRate,
+			recipients
+		});
+		return spendableAmount.toNumber() < fullSpendableAmount.toNumber();
+	});
 }
 
-// src/coin-selection/calculate-max-spend.ts
-function calculateMaxSpend({
-  recipient,
-  utxos,
-  feeRate,
-  feeRates
-}) {
-  if (!utxos.length || !feeRates)
-    return {
-      spendAllFee: 0,
-      amount: createMoney(0, "BTC"),
-      spendableBitcoin: new BigNumber3(0)
-    };
-  const currentFeeRate = feeRate ?? feeRates.halfHourFee.toNumber();
-  const filteredUtxos = filterUneconomicalUtxos({
-    utxos,
-    feeRate: currentFeeRate,
-    recipients: [{ address: recipient, amount: createMoney(0, "BTC") }]
-  });
-  const { spendableAmount, fee } = getSpendableAmount({
-    utxos: filteredUtxos,
-    feeRate: currentFeeRate,
-    recipients: [{ address: recipient, amount: createMoney(0, "BTC") }],
-    isSendMax: true
-  });
-  return {
-    spendAllFee: fee,
-    amount: createMoney(spendableAmount, "BTC"),
-    spendableBitcoin: satToBtc(spendableAmount)
-  };
+//#endregion
+//#region src/coin-selection/calculate-max-spend.ts
+function calculateMaxSpend({ recipient, utxos, feeRate, feeRates }) {
+	if (!utxos.length || !feeRates) return {
+		spendAllFee: 0,
+		amount: createMoney(0, "BTC"),
+		spendableBitcoin: new BigNumber(0)
+	};
+	const currentFeeRate = feeRate ?? feeRates.halfHourFee.toNumber();
+	const { spendableAmount, fee } = getSpendableAmount({
+		utxos: filterUneconomicalUtxos({
+			utxos,
+			feeRate: currentFeeRate,
+			recipients: [{
+				address: recipient,
+				amount: createMoney(0, "BTC")
+			}]
+		}),
+		feeRate: currentFeeRate,
+		recipients: [{
+			address: recipient,
+			amount: createMoney(0, "BTC")
+		}],
+		isSendMax: true
+	});
+	return {
+		spendAllFee: fee,
+		amount: createMoney(spendableAmount, "BTC"),
+		spendableBitcoin: satToBtc(spendableAmount)
+	};
 }
 
-// src/coin-selection/coin-selection.ts
-import BigNumber4 from "bignumber.js";
-import { validate as validate3 } from "bitcoin-address-validation";
-import { BTC_P2WPKH_DUST_AMOUNT as BTC_P2WPKH_DUST_AMOUNT2 } from "@leather.io/constants";
-import { createMoney as createMoney2, sumMoney } from "@leather.io/utils";
-function determineUtxosForSpendAll({
-  feeRate,
-  recipients,
-  utxos
-}) {
-  recipients.forEach((recipient) => {
-    if (!validate3(recipient.address)) throw new BitcoinError("InvalidAddress");
-  });
-  const filteredUtxos = filterUneconomicalUtxos({ utxos, feeRate, recipients });
-  const sizeInfo = getSizeInfo({
-    inputLength: filteredUtxos.length,
-    isSendMax: true,
-    recipients
-  });
-  const outputs = recipients.map(({ address: address2, amount }) => ({
-    value: BigInt(amount.amount.toNumber()),
-    address: address2
-  }));
-  const fee = Math.ceil(sizeInfo.txVBytes * feeRate);
-  return {
-    inputs: filteredUtxos,
-    outputs,
-    size: sizeInfo.txVBytes,
-    fee: createMoney2(new BigNumber4(fee), "BTC")
-  };
-}
-function determineUtxosForSpend({
-  feeRate,
-  recipients,
-  utxos
-}) {
-  recipients.forEach((recipient) => {
-    if (!validate3(recipient.address)) throw new BitcoinError("InvalidAddress");
-  });
-  const filteredUtxos = filterUneconomicalUtxos({
-    utxos: utxos.sort((a, b) => b.value - a.value),
-    feeRate,
-    recipients
-  });
-  if (!filteredUtxos.length) throw new BitcoinError("InsufficientFunds");
-  const amount = sumMoney(recipients.map((recipient) => recipient.amount));
-  const neededUtxos = [filteredUtxos[0]];
-  function estimateTransactionSize() {
-    return getSizeInfo({
-      inputLength: neededUtxos.length,
-      recipients
-    });
-  }
-  function hasSufficientUtxosForTx() {
-    const txEstimation = estimateTransactionSize();
-    const neededAmount = new BigNumber4(txEstimation.txVBytes * feeRate).plus(amount.amount);
-    return getUtxoTotal(neededUtxos).isGreaterThanOrEqualTo(neededAmount);
-  }
-  function getRemainingUnspentUtxos() {
-    return filteredUtxos.filter((utxo) => !neededUtxos.includes(utxo));
-  }
-  while (!hasSufficientUtxosForTx()) {
-    const [nextUtxo] = getRemainingUnspentUtxos();
-    if (!nextUtxo) throw new BitcoinError("InsufficientFunds");
-    neededUtxos.push(nextUtxo);
-  }
-  const fee = Math.ceil(
-    new BigNumber4(estimateTransactionSize().txVBytes).multipliedBy(feeRate).toNumber()
-  );
-  const changeAmount = BigInt(getUtxoTotal(neededUtxos).toString()) - BigInt(amount.amount.toNumber()) - BigInt(fee);
-  const changeUtxos = changeAmount > BTC_P2WPKH_DUST_AMOUNT2 ? [
-    {
-      value: changeAmount
-    }
-  ] : [];
-  const outputs = [
-    ...recipients.map(({ address: address2, amount: amount2 }) => ({
-      value: BigInt(amount2.amount.toNumber()),
-      address: address2
-    })),
-    ...changeUtxos
-  ];
-  return {
-    filteredUtxos,
-    inputs: neededUtxos,
-    outputs,
-    size: estimateTransactionSize().txVBytes,
-    fee: createMoney2(new BigNumber4(fee), "BTC"),
-    ...estimateTransactionSize()
-  };
+//#endregion
+//#region src/coin-selection/coin-selection.ts
+function determineUtxosForSpendAll({ feeRate, recipients, utxos }) {
+	recipients.forEach((recipient) => {
+		if (!validate(recipient.address)) throw new BitcoinError("InvalidAddress");
+	});
+	const filteredUtxos = filterUneconomicalUtxos({
+		utxos,
+		feeRate,
+		recipients
+	});
+	const sizeInfo = getSizeInfo({
+		inputLength: filteredUtxos.length,
+		isSendMax: true,
+		recipients
+	});
+	const outputs = recipients.map(({ address, amount }) => ({
+		value: BigInt(amount.amount.toNumber()),
+		address
+	}));
+	const fee = Math.ceil(sizeInfo.txVBytes * feeRate);
+	return {
+		inputs: filteredUtxos,
+		outputs,
+		size: sizeInfo.txVBytes,
+		fee: createMoney(new BigNumber(fee), "BTC")
+	};
+}
+function determineUtxosForSpend({ feeRate, recipients, utxos }) {
+	recipients.forEach((recipient) => {
+		if (!validate(recipient.address)) throw new BitcoinError("InvalidAddress");
+	});
+	const filteredUtxos = filterUneconomicalUtxos({
+		utxos: utxos.sort((a, b) => b.value - a.value),
+		feeRate,
+		recipients
+	});
+	if (!filteredUtxos.length) throw new BitcoinError("InsufficientFunds");
+	const amount = sumMoney(recipients.map((recipient) => recipient.amount));
+	const neededUtxos = [filteredUtxos[0]];
+	function estimateTransactionSize() {
+		return getSizeInfo({
+			inputLength: neededUtxos.length,
+			recipients
+		});
+	}
+	function hasSufficientUtxosForTx() {
+		const neededAmount = new BigNumber(estimateTransactionSize().txVBytes * feeRate).plus(amount.amount);
+		return getUtxoTotal(neededUtxos).isGreaterThanOrEqualTo(neededAmount);
+	}
+	function getRemainingUnspentUtxos() {
+		return filteredUtxos.filter((utxo) => !neededUtxos.includes(utxo));
+	}
+	while (!hasSufficientUtxosForTx()) {
+		const [nextUtxo] = getRemainingUnspentUtxos();
+		if (!nextUtxo) throw new BitcoinError("InsufficientFunds");
+		neededUtxos.push(nextUtxo);
+	}
+	const fee = Math.ceil(new BigNumber(estimateTransactionSize().txVBytes).multipliedBy(feeRate).toNumber());
+	const changeAmount = BigInt(getUtxoTotal(neededUtxos).toString()) - BigInt(amount.amount.toNumber()) - BigInt(fee);
+	const changeUtxos = changeAmount > BTC_P2WPKH_DUST_AMOUNT ? [{ value: changeAmount }] : [];
+	return {
+		filteredUtxos,
+		inputs: neededUtxos,
+		outputs: [...recipients.map(({ address, amount: amount$1 }) => ({
+			value: BigInt(amount$1.amount.toNumber()),
+			address
+		})), ...changeUtxos],
+		size: estimateTransactionSize().txVBytes,
+		fee: createMoney(new BigNumber(fee), "BTC"),
+		...estimateTransactionSize()
+	};
 }
 
-// src/fees/bitcoin-fees.ts
+//#endregion
+//#region src/fees/bitcoin-fees.ts
 function getBitcoinTransactionFee({ isSendingMax, ...props }) {
-  try {
-    const { fee } = isSendingMax ? determineUtxosForSpendAll({ ...props }) : determineUtxosForSpend({ ...props });
-    return fee;
-  } catch {
-    return null;
-  }
+	try {
+		const { fee } = isSendingMax ? determineUtxosForSpendAll({ ...props }) : determineUtxosForSpend({ ...props });
+		return fee;
+	} catch {
+		return null;
+	}
 }
 function getBitcoinFees({ feeRates, isSendingMax, recipients, utxos }) {
-  const defaultArgs = {
-    isSendingMax,
-    recipients,
-    utxos
-  };
-  const highFeeRate = feeRates.fastestFee.toNumber();
-  const standardFeeRate = feeRates.halfHourFee.toNumber();
-  const lowFeeRate = feeRates.hourFee.toNumber();
-  const highFeeValue = getBitcoinTransactionFee({
-    ...defaultArgs,
-    feeRate: highFeeRate
-  });
-  const standardFeeValue = getBitcoinTransactionFee({
-    ...defaultArgs,
-    feeRate: standardFeeRate
-  });
-  const lowFeeValue = getBitcoinTransactionFee({
-    ...defaultArgs,
-    feeRate: lowFeeRate
-  });
-  return {
-    high: { feeRate: highFeeRate, fee: highFeeValue },
-    standard: { feeRate: standardFeeRate, fee: standardFeeValue },
-    low: { feeRate: lowFeeRate, fee: lowFeeValue }
-  };
+	const defaultArgs = {
+		isSendingMax,
+		recipients,
+		utxos
+	};
+	const highFeeRate = feeRates.fastestFee.toNumber();
+	const standardFeeRate = feeRates.halfHourFee.toNumber();
+	const lowFeeRate = feeRates.hourFee.toNumber();
+	const highFeeValue = getBitcoinTransactionFee({
+		...defaultArgs,
+		feeRate: highFeeRate
+	});
+	const standardFeeValue = getBitcoinTransactionFee({
+		...defaultArgs,
+		feeRate: standardFeeRate
+	});
+	const lowFeeValue = getBitcoinTransactionFee({
+		...defaultArgs,
+		feeRate: lowFeeRate
+	});
+	return {
+		high: {
+			feeRate: highFeeRate,
+			fee: highFeeValue
+		},
+		standard: {
+			feeRate: standardFeeRate,
+			fee: standardFeeValue
+		},
+		low: {
+			feeRate: lowFeeRate,
+			fee: lowFeeValue
+		}
+	};
 }
 
-// src/mocks/mocks.ts
-var TEST_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS = createBitcoinAddress(
-  "bc1q530dz4h80kwlzywlhx2qn0k6vdtftd93c499yq"
-);
-var TEST_ACCOUNT_1_TAPROOT_ADDRESS = createBitcoinAddress(
-  "bc1putuzj9lyfcm8fef9jpy85nmh33cxuq9u6wyuk536t9kemdk37yjqmkc0pg"
-);
-var TEST_ACCOUNT_2_TAPROOT_ADDRESS = createBitcoinAddress(
-  "bc1pmk2sacpfyy4v5phl8tq6eggu4e8laztep7fsgkkx0nc6m9vydjesaw0g2r"
-);
-var TEST_TESNET_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS = createBitcoinAddress(
-  "tb1q4qgnjewwun2llgken94zqjrx5kpqqycaz5522d"
-);
-var TEST_TESTNET_ACCOUNT_2_BTC_ADDRESS = createBitcoinAddress(
-  "tb1qr8me8t9gu9g6fu926ry5v44yp0wyljrespjtnz"
-);
-var TEST_TESTNET_ACCOUNT_2_TAPROOT_ADDRESS = createBitcoinAddress(
-  "tb1pve00jmp43whpqj2wpcxtc7m8wqhz0azq689y4r7h8tmj8ltaj87qj2nj6w"
-);
-var recipientAddress = createBitcoinAddress("tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m");
-var legacyAddress = createBitcoinAddress("15PyZveQd28E2SHZu2ugkWZBp6iER41vXj");
-var segwitAddress = createBitcoinAddress("33SVjoCHJovrXxjDKLFSXo1h3t5KgkPzfH");
-var taprootAddress = createBitcoinAddress(
-  "tb1parwmj7533de3k2fw2kntyqacspvhm67qnjcmpqnnpfvzu05l69nsczdywd"
-);
-var invalidAddress = "whoop-de-da-boop-da-de-not-a-bitcoin-address";
-var inValidCharactersAddress = createBitcoinAddress(
-  "tb1&*%wmj7533de3k2fw2kntyqacspvhm67qnjcmpqnnpfvzu05l69nsczdywd"
-);
-var inValidLengthAddress = createBitcoinAddress("tb1parwmj7533de3k2fw2kntyqacspvhm67wd");
+//#endregion
+//#region src/mocks/mocks.ts
+const TEST_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS = createBitcoinAddress("bc1q530dz4h80kwlzywlhx2qn0k6vdtftd93c499yq");
+const TEST_ACCOUNT_1_TAPROOT_ADDRESS = createBitcoinAddress("bc1putuzj9lyfcm8fef9jpy85nmh33cxuq9u6wyuk536t9kemdk37yjqmkc0pg");
+const TEST_ACCOUNT_2_TAPROOT_ADDRESS = createBitcoinAddress("bc1pmk2sacpfyy4v5phl8tq6eggu4e8laztep7fsgkkx0nc6m9vydjesaw0g2r");
+const TEST_TESNET_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS = createBitcoinAddress("tb1q4qgnjewwun2llgken94zqjrx5kpqqycaz5522d");
+const TEST_TESTNET_ACCOUNT_2_BTC_ADDRESS = createBitcoinAddress("tb1qr8me8t9gu9g6fu926ry5v44yp0wyljrespjtnz");
+const TEST_TESTNET_ACCOUNT_2_TAPROOT_ADDRESS = createBitcoinAddress("tb1pve00jmp43whpqj2wpcxtc7m8wqhz0azq689y4r7h8tmj8ltaj87qj2nj6w");
+const recipientAddress = createBitcoinAddress("tb1qt28eagxcl9gvhq2rpj5slg7dwgxae2dn2hk93m");
+const legacyAddress = createBitcoinAddress("15PyZveQd28E2SHZu2ugkWZBp6iER41vXj");
+const segwitAddress = createBitcoinAddress("33SVjoCHJovrXxjDKLFSXo1h3t5KgkPzfH");
+const taprootAddress = createBitcoinAddress("tb1parwmj7533de3k2fw2kntyqacspvhm67qnjcmpqnnpfvzu05l69nsczdywd");
+const invalidAddress = "whoop-de-da-boop-da-de-not-a-bitcoin-address";
+const inValidCharactersAddress = createBitcoinAddress("tb1&*%wmj7533de3k2fw2kntyqacspvhm67qnjcmpqnnpfvzu05l69nsczdywd");
+const inValidLengthAddress = createBitcoinAddress("tb1parwmj7533de3k2fw2kntyqacspvhm67wd");
 
-// src/schemas/address-schema.ts
-import { Network as Network2, getAddressInfo as getAddressInfo2, validate as validate4 } from "bitcoin-address-validation";
-import { z } from "zod";
-import { isEmptyString as isEmptyString2, isUndefined as isUndefined2 } from "@leather.io/utils";
+//#endregion
+//#region src/schemas/address-schema.ts
 function nonEmptyStringValidator(message = "") {
-  return z.string().refine((value) => value !== void 0 && value.trim() !== "", { message });
+	return z.string().refine((value) => value !== void 0 && value.trim() !== "", { message });
 }
 function btcAddressValidator() {
-  return z.string().refine(
-    (value) => {
-      if (isUndefined2(value) || isEmptyString2(value)) return true;
-      return validate4(value);
-    },
-    { message: "Bitcoin address is not valid" }
-  );
+	return z.string().refine((value) => {
+		if (isUndefined(value) || isEmptyString(value)) return true;
+		return validate(value);
+	}, { message: "Bitcoin address is not valid" });
 }
-function getNetworkTypeFromAddress(address2) {
-  return getAddressInfo2(address2).network;
+function getNetworkTypeFromAddress(address) {
+	return getAddressInfo(address).network;
 }
 function btcAddressNetworkValidatorFactory(network) {
-  function getAddressNetworkType(network2) {
-    if (network2 === "signet") return Network2.testnet;
-    return network2;
-  }
-  return (value) => {
-    if (isUndefined2(value) || isEmptyString2(value)) return true;
-    return validate4(value, getAddressNetworkType(network));
-  };
+	function getAddressNetworkType(network$1) {
+		if (network$1 === "signet") return Network.testnet;
+		return network$1;
+	}
+	return (value) => {
+		if (isUndefined(value) || isEmptyString(value)) return true;
+		return validate(value, getAddressNetworkType(network));
+	};
 }
 function btcAddressNetworkValidator(network) {
-  return z.string().refine(btcAddressNetworkValidatorFactory(network), {
-    message: "Address is for incorrect network"
-  });
+	return z.string().refine(btcAddressNetworkValidatorFactory(network), { message: "Address is for incorrect network" });
 }
 
-// src/payments/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 { deriveBip39SeedFromMnemonic, deriveRootBip32Keychain } from "@leather.io/crypto";
-var deriveBtcBip49SeedFromMnemonic = deriveBip39SeedFromMnemonic;
-var deriveRootBtcKeychain = deriveRootBip32Keychain;
+//#endregion
+//#region src/payments/p2wsh-p2sh-address-gen.ts
+/**
+* @deprecated
+* Use `deriveBip39MnemonicFromSeed` from `@leather.io/crypto`
+*/
+const deriveBtcBip49SeedFromMnemonic = deriveBip39SeedFromMnemonic;
+/**
+* @deprecated
+* Use `deriveRootBip32Keychain` from `@leather.io/crypto`
+*/
+const 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
+	const compressedWifFormatPrivateKey = base58check(sha256).decode(key);
+	return compressedWifFormatPrivateKey.slice(1, compressedWifFormatPrivateKey.length - 1);
+}
+const payToScriptHashMainnetPrefix = 5;
+const payToScriptHashTestnetPrefix = 196;
+const payToScriptHashPrefixMap = {
+	mainnet: payToScriptHashMainnetPrefix,
+	testnet: payToScriptHashTestnetPrefix
 };
 function hash160(input) {
-  return ripemd160(sha2562(input));
+	return ripemd160(sha256(input));
 }
 function makePayToScriptHashKeyHash(publicKey) {
-  return hash160(publicKey);
+	return hash160(publicKey);
 }
 function makePayToScriptHashAddressBytes(keyHash) {
-  const redeemScript = Uint8Array.from([
-    ...Uint8Array.of(0),
-    ...Uint8Array.of(keyHash.length),
-    ...keyHash
-  ]);
-  return hash160(redeemScript);
+	return hash160(Uint8Array.from([
+		...Uint8Array.of(0),
+		...Uint8Array.of(keyHash.length),
+		...keyHash
+	]));
 }
 function makePayToScriptHashAddress(addressBytes, network) {
-  const networkByte = payToScriptHashPrefixMap[network];
-  const addressWithPrefix = Uint8Array.from([networkByte, ...addressBytes]);
-  return base58check(sha2562).encode(addressWithPrefix);
+	const networkByte = payToScriptHashPrefixMap[network];
+	const addressWithPrefix = Uint8Array.from([networkByte, ...addressBytes]);
+	return base58check(sha256).encode(addressWithPrefix);
 }
 function publicKeyToPayToScriptHashAddress(publicKey, network) {
-  const hash = makePayToScriptHashKeyHash(publicKey);
-  const addrBytes = makePayToScriptHashAddressBytes(hash);
-  return makePayToScriptHashAddress(addrBytes, network);
+	return makePayToScriptHashAddress(makePayToScriptHashAddressBytes(makePayToScriptHashKeyHash(publicKey)), network);
 }
 
-// src/psbt/psbt-totals.ts
-import { createMoney as createMoney3, sumNumbers as sumNumbers2 } from "@leather.io/utils";
+//#endregion
+//#region src/psbt/psbt-totals.ts
 function calculateAddressInputsTotal(addresses, inputs) {
-  const sumsByAddress = addresses.map(
-    (address2) => inputs.filter((input) => input.address === address2).map((input) => input.value).reduce((acc, curVal) => acc + curVal, 0)
-  );
-  return createMoney3(sumNumbers2(sumsByAddress), "BTC");
+	return createMoney(sumNumbers(addresses.map((address) => inputs.filter((input) => input.address === address).map((input) => input.value).reduce((acc, curVal) => acc + curVal, 0))), "BTC");
 }
 function calculateAddressOutputsTotal(addresses, outputs) {
-  const sumsByAddress = addresses.map(
-    (address2) => outputs.filter((output) => output.address === address2).map((output) => Number(output.value)).reduce((acc, curVal) => acc + curVal, 0)
-  );
-  return createMoney3(sumNumbers2(sumsByAddress), "BTC");
+	return createMoney(sumNumbers(addresses.map((address) => outputs.filter((output) => output.address === address).map((output) => Number(output.value)).reduce((acc, curVal) => acc + curVal, 0))), "BTC");
 }
 function calculatePsbtInputsTotal(inputs) {
-  return createMoney3(sumNumbers2(inputs.map((input) => input.value)), "BTC");
+	return createMoney(sumNumbers(inputs.map((input) => input.value)), "BTC");
 }
 function calculatePsbtOutputsTotal(outputs) {
-  return createMoney3(sumNumbers2(outputs.map((output) => output.value)), "BTC");
+	return createMoney(sumNumbers(outputs.map((output) => output.value)), "BTC");
 }
 function getPsbtTotals({ psbtAddresses, parsedInputs, parsedOutputs }) {
-  const nativeSegwitAddresses = psbtAddresses.filter(
-    (addr) => inferPaymentTypeFromAddress(addr) === "p2wpkh"
-  );
-  const taprootAddresses = psbtAddresses.filter(
-    (addr) => inferPaymentTypeFromAddress(addr) === "p2tr"
-  );
-  return {
-    inputsTotalNativeSegwit: calculateAddressInputsTotal(nativeSegwitAddresses, parsedInputs),
-    inputsTotalTaproot: calculateAddressInputsTotal(taprootAddresses, parsedInputs),
-    outputsTotalNativeSegwit: calculateAddressOutputsTotal(nativeSegwitAddresses, parsedOutputs),
-    outputsTotalTaproot: calculateAddressOutputsTotal(taprootAddresses, parsedOutputs),
-    psbtInputsTotal: calculatePsbtInputsTotal(parsedInputs),
-    psbtOutputsTotal: calculatePsbtOutputsTotal(parsedOutputs)
-  };
+	const nativeSegwitAddresses = psbtAddresses.filter((addr) => inferPaymentTypeFromAddress(addr) === "p2wpkh");
+	const taprootAddresses = psbtAddresses.filter((addr) => inferPaymentTypeFromAddress(addr) === "p2tr");
+	return {
+		inputsTotalNativeSegwit: calculateAddressInputsTotal(nativeSegwitAddresses, parsedInputs),
+		inputsTotalTaproot: calculateAddressInputsTotal(taprootAddresses, parsedInputs),
+		outputsTotalNativeSegwit: calculateAddressOutputsTotal(nativeSegwitAddresses, parsedOutputs),
+		outputsTotalTaproot: calculateAddressOutputsTotal(taprootAddresses, parsedOutputs),
+		psbtInputsTotal: calculatePsbtInputsTotal(parsedInputs),
+		psbtOutputsTotal: calculatePsbtOutputsTotal(parsedOutputs)
+	};
 }
 
-// src/psbt/psbt-inputs.ts
-import { bytesToHex } from "@noble/hashes/utils";
-import { isDefined as isDefined2, isUndefined as isUndefined3 } from "@leather.io/utils";
-function getParsedInputs({
-  inputs,
-  indexesToSign,
-  networkMode,
-  psbtAddresses
-}) {
-  const bitcoinNetwork = getBtcSignerLibNetworkConfigByMode(networkMode);
-  const signAll = isUndefined3(indexesToSign);
-  const psbtInputs = inputs.map((input, i) => {
-    const bitcoinAddress = isDefined2(input.index) ? getBitcoinInputAddress(input, bitcoinNetwork) : null;
-    if (bitcoinAddress === null) {
-      throw new Error("PSBT input has unsupported bitcoin address");
-    }
-    const isCurrentAddress = psbtAddresses.includes(bitcoinAddress);
-    const canChange = isCurrentAddress && !(!input.sighashType || input.sighashType === 0 || input.sighashType === 1);
-    const toSignAll = isCurrentAddress && signAll;
-    const toSignIndex = isCurrentAddress && !signAll && indexesToSign.includes(i);
-    return {
-      address: bitcoinAddress,
-      index: input.index,
-      bip32Derivation: input.bip32Derivation,
-      tapBip32Derivation: input.tapBip32Derivation,
-      // inscription: inscriptions[i],
-      isMutable: canChange,
-      toSign: toSignAll || toSignIndex,
-      txid: input.txid ? bytesToHex(input.txid) : "",
-      value: isDefined2(input.index) ? getBitcoinInputValue(input) : 0
-    };
-  });
-  const isPsbtMutable = psbtInputs.some((input) => input.isMutable);
-  return { isPsbtMutable, parsedInputs: psbtInputs };
+//#endregion
+//#region src/psbt/psbt-inputs.ts
+function getParsedInputs({ inputs, indexesToSign, networkMode, psbtAddresses }) {
+	const bitcoinNetwork = getBtcSignerLibNetworkConfigByMode(networkMode);
+	const signAll = isUndefined(indexesToSign);
+	const psbtInputs = inputs.map((input, i) => {
+		const bitcoinAddress = isDefined(input.index) ? getBitcoinInputAddress(input, bitcoinNetwork) : null;
+		if (bitcoinAddress === null) throw new Error("PSBT input has unsupported bitcoin address");
+		const isCurrentAddress = psbtAddresses.includes(bitcoinAddress);
+		const canChange = isCurrentAddress && !(!input.sighashType || input.sighashType === 0 || input.sighashType === 1);
+		const toSignAll = isCurrentAddress && signAll;
+		const toSignIndex = isCurrentAddress && !signAll && indexesToSign.includes(i);
+		return {
+			address: bitcoinAddress,
+			index: input.index,
+			bip32Derivation: input.bip32Derivation,
+			tapBip32Derivation: input.tapBip32Derivation,
+			isMutable: canChange,
+			toSign: toSignAll || toSignIndex,
+			txid: input.txid ? bytesToHex(input.txid) : "",
+			value: isDefined(input.index) ? getBitcoinInputValue(input) : 0
+		};
+	});
+	return {
+		isPsbtMutable: psbtInputs.some((input) => input.isMutable),
+		parsedInputs: psbtInputs
+	};
 }
 
-// src/psbt/psbt-outputs.ts
-import { isDefined as isDefined3, isUndefined as isUndefined4 } from "@leather.io/utils";
-function getParsedOutputs({
-  isPsbtMutable,
-  outputs,
-  networkMode,
-  psbtAddresses
-}) {
-  const bitcoinNetwork = getBtcSignerLibNetworkConfigByMode(networkMode);
-  return outputs.map((output) => {
-    if (isUndefined4(output.script)) {
-      return;
-    }
-    const outputAddress = getAddressFromOutScript(output.script, bitcoinNetwork);
-    const isCurrentAddress = !!outputAddress && psbtAddresses.includes(outputAddress);
-    return {
-      address: outputAddress,
-      isMutable: isPsbtMutable,
-      toSign: isCurrentAddress,
-      value: Number(output.amount)
-    };
-  }).filter(isDefined3);
+//#endregion
+//#region src/psbt/psbt-outputs.ts
+function getParsedOutputs({ isPsbtMutable, outputs, networkMode, psbtAddresses }) {
+	const bitcoinNetwork = getBtcSignerLibNetworkConfigByMode(networkMode);
+	return outputs.map((output) => {
+		if (isUndefined(output.script)) return;
+		const outputAddress = getAddressFromOutScript(output.script, bitcoinNetwork);
+		return {
+			address: outputAddress,
+			isMutable: isPsbtMutable,
+			toSign: !!outputAddress && psbtAddresses.includes(outputAddress),
+			value: Number(output.amount)
+		};
+	}).filter(isDefined);
 }
 
-// src/psbt/psbt-details.ts
-import { createMoney as createMoney4, subtractMoney } from "@leather.io/utils";
-
-// src/psbt/utils.ts
-import { hexToBytes as hexToBytes3 } from "@noble/hashes/utils";
-import * as btc4 from "@scure/btc-signer";
-import { RawPSBTV0, RawPSBTV2 } from "@scure/btc-signer/psbt";
-import { isString as isString2 } from "@leather.io/utils";
+//#endregion
+//#region src/psbt/utils.ts
 function getPsbtAsTransaction(psbt) {
-  const bytes = isString2(psbt) ? hexToBytes3(psbt) : psbt;
-  return btc4.Transaction.fromPSBT(bytes);
+	const bytes = isString(psbt) ? hexToBytes(psbt) : psbt;
+	return btc.Transaction.fromPSBT(bytes);
 }
 function getRawPsbt(psbt) {
-  const bytes = isString2(psbt) ? hexToBytes3(psbt) : psbt;
-  try {
-    return RawPSBTV0.decode(bytes);
-  } catch (e1) {
-    try {
-      return RawPSBTV2.decode(bytes);
-    } catch (e2) {
-      throw new Error(`Unable to decode PSBT, ${e1 ?? e2}`);
-    }
-  }
+	const bytes = isString(psbt) ? hexToBytes(psbt) : psbt;
+	try {
+		return RawPSBTV0.decode(bytes);
+	} catch (e1) {
+		try {
+			return RawPSBTV2.decode(bytes);
+		} catch (e2) {
+			throw new Error(`Unable to decode PSBT, ${e1 ?? e2}`);
+		}
+	}
 }
 
-// src/psbt/psbt-details.ts
-function getPsbtDetails({
-  psbtHex,
-  networkMode,
-  indexesToSign,
-  psbtAddresses
-}) {
-  const tx = getPsbtAsTransaction(psbtHex);
-  const inputs = getPsbtTxInputs(tx);
-  const outputs = getPsbtTxOutputs(tx);
-  const { isPsbtMutable, parsedInputs } = getParsedInputs({
-    inputs,
-    indexesToSign,
-    networkMode,
-    psbtAddresses
-  });
-  const parsedOutputs = getParsedOutputs({ isPsbtMutable, outputs, networkMode, psbtAddresses });
-  const {
-    inputsTotalNativeSegwit,
-    inputsTotalTaproot,
-    outputsTotalNativeSegwit,
-    outputsTotalTaproot,
-    psbtInputsTotal,
-    psbtOutputsTotal
-  } = getPsbtTotals({
-    psbtAddresses,
-    parsedInputs,
-    parsedOutputs
-  });
-  function getFee() {
-    if (psbtInputsTotal.amount.isGreaterThan(psbtOutputsTotal.amount))
-      return subtractMoney(psbtInputsTotal, psbtOutputsTotal);
-    return createMoney4(0, "BTC");
-  }
-  return {
-    addressNativeSegwitTotal: subtractMoney(inputsTotalNativeSegwit, outputsTotalNativeSegwit),
-    addressTaprootTotal: subtractMoney(inputsTotalTaproot, outputsTotalTaproot),
-    fee: getFee(),
-    isPsbtMutable,
-    psbtInputs: parsedInputs,
-    psbtOutputs: parsedOutputs
-  };
+//#endregion
+//#region src/psbt/psbt-details.ts
+function getPsbtDetails({ psbtHex, networkMode, indexesToSign, psbtAddresses }) {
+	const tx = getPsbtAsTransaction(psbtHex);
+	const inputs = getPsbtTxInputs(tx);
+	const outputs = getPsbtTxOutputs(tx);
+	const { isPsbtMutable, parsedInputs } = getParsedInputs({
+		inputs,
+		indexesToSign,
+		networkMode,
+		psbtAddresses
+	});
+	const parsedOutputs = getParsedOutputs({
+		isPsbtMutable,
+		outputs,
+		networkMode,
+		psbtAddresses
+	});
+	const { inputsTotalNativeSegwit, inputsTotalTaproot, outputsTotalNativeSegwit, outputsTotalTaproot, psbtInputsTotal, psbtOutputsTotal } = getPsbtTotals({
+		psbtAddresses,
+		parsedInputs,
+		parsedOutputs
+	});
+	function getFee() {
+		if (psbtInputsTotal.amount.isGreaterThan(psbtOutputsTotal.amount)) return subtractMoney(psbtInputsTotal, psbtOutputsTotal);
+		return createMoney(0, "BTC");
+	}
+	return {
+		addressNativeSegwitTotal: subtractMoney(inputsTotalNativeSegwit, outputsTotalNativeSegwit),
+		addressTaprootTotal: subtractMoney(inputsTotalTaproot, outputsTotalTaproot),
+		fee: getFee(),
+		isPsbtMutable,
+		psbtInputs: parsedInputs,
+		psbtOutputs: parsedOutputs
+	};
 }
 
-// src/signer/bitcoin-signer.ts
-import { HARDENED_OFFSET } from "@scure/bip32";
-import * as btc5 from "@scure/btc-signer";
-import {
-  DerivationPathDepth as DerivationPathDepth4,
-  appendAddressIndexToPath,
-  decomposeDescriptor,
-  deriveKeychainFromXpub,
-  extractAddressIndexFromPath,
-  extractChangeIndexFromPath,
-  keyOriginToDerivationPath
-} from "@leather.io/crypto";
-import { hexToNumber, toHexString } from "@leather.io/utils";
+//#endregion
+//#region src/signer/bitcoin-signer.ts
 function initializeBitcoinAccountKeychainFromDescriptor(descriptor) {
-  const { fingerprint, keyOrigin } = decomposeDescriptor(descriptor);
-  return {
-    descriptor,
-    xpub: extractExtendedPublicKeyFromPolicy(descriptor),
-    keyOrigin,
-    masterKeyFingerprint: fingerprint,
-    keychain: deriveKeychainFromXpub(extractExtendedPublicKeyFromPolicy(descriptor))
-  };
+	const { fingerprint, keyOrigin } = decomposeDescriptor(descriptor);
+	return {
+		descriptor,
+		xpub: extractExtendedPublicKeyFromPolicy(descriptor),
+		keyOrigin,
+		masterKeyFingerprint: fingerprint,
+		keychain: deriveKeychainFromXpub(extractExtendedPublicKeyFromPolicy(descriptor))
+	};
 }
 function deriveBitcoinPayerFromAccount(descriptor, network) {
-  const { fingerprint, keyOrigin } = decomposeDescriptor(descriptor);
-  const accountKeychain = deriveKeychainFromXpub(extractExtendedPublicKeyFromPolicy(descriptor));
-  const paymentType = inferPaymentTypeFromPath(keyOrigin);
-  if (accountKeychain.depth !== DerivationPathDepth4.Account)
-    throw new Error("Keychain passed is not an account");
-  return ({ change, addressIndex }) => {
-    const childKeychain = accountKeychain.deriveChild(change).deriveChild(addressIndex);
-    const derivePayerFromAccount = whenSupportedPaymentType(paymentType)({
-      p2tr: getTaprootPaymentFromAddressIndex,
-      p2wpkh: getNativeSegwitPaymentFromAddressIndex
-    });
-    const payment = derivePayerFromAccount(childKeychain, network);
-    return {
-      keyOrigin: appendAddressIndexToPath(keyOrigin, change, addressIndex),
-      masterKeyFingerprint: fingerprint,
-      paymentType,
-      network,
-      payment,
-      get address() {
-        if (!payment.address) throw new Error("Payment address could not be derived");
-        return payment.address;
-      },
-      get publicKey() {
-        if (!childKeychain.publicKey) throw new Error("Public key could not be derived");
-        return childKeychain.publicKey;
-      }
-    };
-  };
-}
+	const { fingerprint, keyOrigin } = decomposeDescriptor(descriptor);
+	const accountKeychain = deriveKeychainFromXpub(extractExtendedPublicKeyFromPolicy(descriptor));
+	const paymentType = inferPaymentTypeFromPath(keyOrigin);
+	if (accountKeychain.depth !== DerivationPathDepth.Account) throw new Error("Keychain passed is not an account");
+	return ({ change, addressIndex }) => {
+		const childKeychain = accountKeychain.deriveChild(change).deriveChild(addressIndex);
+		const payment = whenSupportedPaymentType(paymentType)({
+			p2tr: getTaprootPaymentFromAddressIndex,
+			p2wpkh: getNativeSegwitPaymentFromAddressIndex
+		})(childKeychain, network);
+		return {
+			keyOrigin: appendAddressIndexToPath(keyOrigin, change, addressIndex),
+			masterKeyFingerprint: fingerprint,
+			paymentType,
+			network,
+			payment,
+			get address() {
+				if (!payment.address) throw new Error("Payment address could not be derived");
+				return payment.address;
+			},
+			get publicKey() {
+				if (!childKeychain.publicKey) throw new Error("Public key could not be derived");
+				return childKeychain.publicKey;
+			}
+		};
+	};
+}
+/**
+* @example
+* ```ts
+* tx.addInput({
+*   ...input,
+*   bip32Derivation: [payerToBip32Derivation(payer)],
+* })
+* ```
+*/
 function payerToBip32Derivation(args) {
-  return [
-    args.publicKey,
-    {
-      fingerprint: hexToNumber(args.masterKeyFingerprint),
-      path: btc5.bip32Path(keyOriginToDerivationPath(args.keyOrigin))
-    }
-  ];
-}
+	return [args.publicKey, {
+		fingerprint: hexToNumber(args.masterKeyFingerprint),
+		path: btc.bip32Path(keyOriginToDerivationPath(args.keyOrigin))
+	}];
+}
+/**
+* @example
+* ```ts
+* tx.addInput({
+*   ...input,
+*   tapBip32Derivation: [payerToTapBip32Derivation(payer)],
+* })
+* ```
+*/
 function payerToTapBip32Derivation(args) {
-  return [
-    // TODO: @kyranjamie to default to schnoor when TR so conversion isn't
-    // necessary here?
-    ecdsaPublicKeyToSchnorr(args.publicKey),
-    {
-      hashes: [],
-      der: {
-        fingerprint: hexToNumber(args.masterKeyFingerprint),
-        path: btc5.bip32Path(keyOriginToDerivationPath(args.keyOrigin))
-      }
-    }
-  ];
+	return [ecdsaPublicKeyToSchnorr(args.publicKey), {
+		hashes: [],
+		der: {
+			fingerprint: hexToNumber(args.masterKeyFingerprint),
+			path: btc.bip32Path(keyOriginToDerivationPath(args.keyOrigin))
+		}
+	}];
 }
 function payerToTapBip32DerivationBitcoinJsLib(args) {
-  return {
-    masterFingerprint: Buffer.from(args.masterKeyFingerprint, "hex"),
-    path: keyOriginToDerivationPath(args.keyOrigin),
-    leafHashes: [],
-    pubkey: Buffer.from(ecdsaPublicKeyToSchnorr(args.publicKey))
-  };
+	return {
+		masterFingerprint: Buffer.from(args.masterKeyFingerprint, "hex"),
+		path: keyOriginToDerivationPath(args.keyOrigin),
+		leafHashes: [],
+		pubkey: Buffer.from(ecdsaPublicKeyToSchnorr(args.publicKey))
+	};
 }
 function payerToBip32DerivationBitcoinJsLib(args) {
-  return {
-    masterFingerprint: Buffer.from(args.masterKeyFingerprint, "hex"),
-    path: keyOriginToDerivationPath(args.keyOrigin),
-    pubkey: Buffer.from(args.publicKey)
-  };
+	return {
+		masterFingerprint: Buffer.from(args.masterKeyFingerprint, "hex"),
+		path: keyOriginToDerivationPath(args.keyOrigin),
+		pubkey: Buffer.from(args.publicKey)
+	};
 }
 function extractPayerInfoFromDerivationPath(path) {
-  return {
-    change: extractChangeIndexFromPath(path),
-    addressIndex: extractAddressIndexFromPath(path)
-  };
-}
+	return {
+		change: extractChangeIndexFromPath(path),
+		addressIndex: extractAddressIndexFromPath(path)
+	};
+}
+/**
+* @description
+* Turns key format from @scure/btc-signer lib back into key origin string
+* @example
+* ```ts
+* const [inputOne] = getPsbtTxInputs(tx);
+* const keyOrigin = serializeKeyOrigin(inputOne.bip32Derivation[0][1]);
+* ```
+*/
 function serializeKeyOrigin({ fingerprint, path }) {
-  const values = path.map((num) => num >= HARDENED_OFFSET ? num - HARDENED_OFFSET + "'" : num);
-  return `${toHexString(fingerprint)}/${values.join("/")}`;
-}
+	const values = path.map((num) => num >= HARDENED_OFFSET ? num - HARDENED_OFFSET + "'" : num);
+	return `${toHexString(fingerprint)}/${values.join("/")}`;
+}
+/**
+* @description
+* Of a given set of a `tx.input`s bip32 derivation paths from
+* `@scure/btc-signer`, serialize the paths back to the string format used
+* internally
+*/
 function extractRequiredKeyOrigins(derivation) {
-  return derivation.map(
-    ([_pubkey, path]) => serializeKeyOrigin("hashes" in path ? path.der : path)
-  );
+	return derivation.map(([_pubkey, path]) => serializeKeyOrigin("hashes" in path ? path.der : path));
 }
 
-// src/transactions/generate-unsigned-transaction.ts
-import * as btc6 from "@scure/btc-signer";
-function generateBitcoinUnsignedTransaction({
-  feeRate,
-  isSendingMax,
-  network,
-  recipients,
-  changeAddress,
-  utxos,
-  payerLookup
-}) {
-  const determineUtxosArgs = { feeRate, recipients, utxos };
-  const { inputs, outputs, fee } = isSendingMax ? determineUtxosForSpendAll(determineUtxosArgs) : determineUtxosForSpend(determineUtxosArgs);
-  if (!inputs.length) throw new BitcoinError("NoInputsToSign");
-  if (!outputs.length) throw new BitcoinError("NoOutputsToSign");
-  const tx = new btc6.Transaction();
-  for (const input of inputs) {
-    const payer = payerLookup(input.keyOrigin);
-    if (!payer) {
-      console.log(`No payer found for input with keyOrigin ${input.keyOrigin}`);
-      continue;
-    }
-    const bip32Derivation = payer.paymentType === "p2tr" ? { tapBip32Derivation: [payerToTapBip32Derivation(payer)] } : { bip32Derivation: [payerToBip32Derivation(payer)] };
-    const tapInternalKey = payer.paymentType === "p2tr" ? { tapInternalKey: payer.payment.tapInternalKey } : {};
-    tx.addInput({
-      txid: input.txid,
-      index: input.vout,
-      witnessUtxo: {
-        script: payer.payment.script,
-        amount: BigInt(input.value)
-      },
-      ...bip32Derivation,
-      ...tapInternalKey
-    });
-  }
-  outputs.forEach((output) => {
-    if (!output.address) {
-      tx.addOutputAddress(changeAddress, BigInt(output.value), network);
-      return;
-    }
-    tx.addOutputAddress(output.address, BigInt(output.value), network);
-  });
-  return { tx, hex: tx.hex, psbt: tx.toPSBT(), inputs, fee };
+//#endregion
+//#region src/transactions/generate-unsigned-transaction.ts
+function generateBitcoinUnsignedTransaction({ feeRate, isSendingMax, network, recipients, changeAddress, utxos, payerLookup }) {
+	const determineUtxosArgs = {
+		feeRate,
+		recipients,
+		utxos
+	};
+	const { inputs, outputs, fee } = isSendingMax ? determineUtxosForSpendAll(determineUtxosArgs) : determineUtxosForSpend(determineUtxosArgs);
+	if (!inputs.length) throw new BitcoinError("NoInputsToSign");
+	if (!outputs.length) throw new BitcoinError("NoOutputsToSign");
+	const tx = new btc.Transaction();
+	for (const input of inputs) {
+		const payer = payerLookup(input.keyOrigin);
+		if (!payer) {
+			console.log(`No payer found for input with keyOrigin ${input.keyOrigin}`);
+			continue;
+		}
+		const bip32Derivation = payer.paymentType === "p2tr" ? { tapBip32Derivation: [payerToTapBip32Derivation(payer)] } : { bip32Derivation: [payerToBip32Derivation(payer)] };
+		const tapInternalKey = payer.paymentType === "p2tr" ? { tapInternalKey: payer.payment.tapInternalKey } : {};
+		tx.addInput({
+			txid: input.txid,
+			index: input.vout,
+			witnessUtxo: {
+				script: payer.payment.script,
+				amount: BigInt(input.value)
+			},
+			...bip32Derivation,
+			...tapInternalKey
+		});
+	}
+	outputs.forEach((output) => {
+		if (!output.address) {
+			tx.addOutputAddress(changeAddress, BigInt(output.value), network);
+			return;
+		}
+		tx.addOutputAddress(output.address, BigInt(output.value), network);
+	});
+	return {
+		tx,
+		hex: tx.hex,
+		psbt: tx.toPSBT(),
+		inputs,
+		fee
+	};
 }
 
-// src/validation/amount-validation.ts
-import { BITCOIN_MINIMUM_SPEND_IN_SATS } from "@leather.io/constants";
+//#endregion
+//#region src/validation/amount-validation.ts
 function isBtcBalanceSufficient({ desiredSpend, maxSpend }) {
-  return !desiredSpend.amount.isGreaterThan(maxSpend.amount);
+	return !desiredSpend.amount.isGreaterThan(maxSpend.amount);
 }
 function isBtcMinimumSpend(desiredSpend) {
-  return !desiredSpend.amount.isLessThan(BITCOIN_MINIMUM_SPEND_IN_SATS);
+	return !desiredSpend.amount.isLessThan(BITCOIN_MINIMUM_SPEND_IN_SATS);
 }
 
-// src/validation/transaction-validation.ts
-function isValidBitcoinTransaction({
-  amount,
-  payer,
-  recipient,
-  network,
-  utxos,
-  feeRate,
-  feeRates
-}) {
-  if (!isValidBitcoinAddress(payer) || !isValidBitcoinAddress(recipient)) {
-    throw new BitcoinError("InvalidAddress");
-  }
-  if (!isValidBitcoinNetworkAddress(payer, network) || !isValidBitcoinNetworkAddress(recipient, network)) {
-    throw new BitcoinError("InvalidNetworkAddress");
-  }
-  if (!isBtcMinimumSpend(amount)) {
-    throw new BitcoinError("InsufficientAmount");
-  }
-  const maxSpend = calculateMaxSpend({ recipient, utxos, feeRate, feeRates });
-  if (!isBtcBalanceSufficient({ desiredSpend: amount, maxSpend: maxSpend.amount })) {
-    throw new BitcoinError("InsufficientFunds");
-  }
+//#endregion
+//#region src/validation/transaction-validation.ts
+function isValidBitcoinTransaction({ amount, payer, recipient, network, utxos, feeRate, feeRates }) {
+	if (!isValidBitcoinAddress(payer) || !isValidBitcoinAddress(recipient)) throw new BitcoinError("InvalidAddress");
+	if (!isValidBitcoinNetworkAddress(payer, network) || !isValidBitcoinNetworkAddress(recipient, network)) throw new BitcoinError("InvalidNetworkAddress");
+	if (!isBtcMinimumSpend(amount)) throw new BitcoinError("InsufficientAmount");
+	if (!isBtcBalanceSufficient({
+		desiredSpend: amount,
+		maxSpend: calculateMaxSpend({
+			recipient,
+			utxos,
+			feeRate,
+			feeRates
+		}).amount
+	})) throw new BitcoinError("InsufficientFunds");
 }
 
-// src/utils/bitcoin.descriptors.ts
-import { HARDENED_OFFSET as HARDENED_OFFSET2, HDKey as HDKey3 } from "@scure/bip32";
+//#endregion
+//#region src/utils/bitcoin.descriptors.ts
 function getDescriptorFromKeychain(accountKeychain) {
-  switch (inferPaymentTypeFromPath(accountKeychain.keyOrigin)) {
-    case "p2tr":
-      return `tr(${accountKeychain.xpub})`;
-    case "p2wpkh":
-      return `wpkh(${accountKeychain.xpub})`;
-    default:
-      return void 0;
-  }
+	switch (inferPaymentTypeFromPath(accountKeychain.keyOrigin)) {
+		case "p2tr": return `tr(${accountKeychain.xpub})`;
+		case "p2wpkh": return `wpkh(${accountKeychain.xpub})`;
+		default: return;
+	}
 }
 function inferPaymentTypeFromDescriptor(descriptor) {
-  const descriptorPrefix = descriptor.split("(")[0];
-  switch (descriptorPrefix) {
-    case "tr":
-      return "p2tr";
-    case "wpkh":
-      return "p2wpkh";
-    default:
-      throw new Error("Unrecognized descriptor");
-  }
+	switch (descriptor.split("(")[0]) {
+		case "tr": return "p2tr";
+		case "wpkh": return "p2wpkh";
+		default: throw new Error("Unrecognized descriptor");
+	}
 }
 function extractXpubFromDescriptor(descriptor) {
-  const match = descriptor.match(/\((xpub[0-9A-Za-z]+)\)/);
-  if (match && match[1]) {
-    return match[1];
-  }
-  throw new Error("Invalid descriptor format");
-}
-function deriveAddressesFromDescriptor({
-  accountDescriptor,
-  network,
-  limit = 1
-}) {
-  const accountKeychain = HDKey3.fromExtendedKey(extractXpubFromDescriptor(accountDescriptor));
-  const paymentType = inferPaymentTypeFromDescriptor(accountDescriptor);
-  const derivationPathFn = whenSupportedPaymentType(paymentType)({
-    p2tr: makeTaprootAddressIndexDerivationPath,
-    p2wpkh: makeNativeSegwitAddressIndexDerivationPath
-  });
-  const results = [];
-  for (let i = 0; i < limit; i++) {
-    const address2 = whenSupportedPaymentType(paymentType)({
-      p2tr: getTaprootAddress({ index: i, keychain: accountKeychain, network }),
-      p2wpkh: getNativeSegwitAddress({ index: i, keychain: accountKeychain, network })
-    });
-    results.push({
-      address: address2,
-      path: derivationPathFn(network, accountKeychain.index - HARDENED_OFFSET2, i)
-    });
-  }
-  return results;
+	const match = descriptor.match(/\((xpub[0-9A-Za-z]+)\)/);
+	if (match && match[1]) return match[1];
+	throw new Error("Invalid descriptor format");
+}
+function deriveAddressesFromDescriptor({ accountDescriptor, network, limit = 1 }) {
+	const accountKeychain = HDKey.fromExtendedKey(extractXpubFromDescriptor(accountDescriptor));
+	const paymentType = inferPaymentTypeFromDescriptor(accountDescriptor);
+	const derivationPathFn = whenSupportedPaymentType(paymentType)({
+		p2tr: makeTaprootAddressIndexDerivationPath,
+		p2wpkh: makeNativeSegwitAddressIndexDerivationPath
+	});
+	const results = [];
+	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)
+		});
+	}
+	return results;
 }
 
-// src/utils/lookup-derivation-by-address.ts
-import { HARDENED_OFFSET as HARDENED_OFFSET3, HDKey as HDKey4 } from "@scure/bip32";
-import { createCounter } from "@leather.io/utils";
+//#endregion
+//#region src/utils/lookup-derivation-by-address.ts
 function lookupDerivationByAddress(args) {
-  const { taprootXpub, nativeSegwitXpub, iterationLimit } = args;
-  const taprootKeychain = HDKey4.fromExtendedKey(taprootXpub);
-  const nativeSegwitKeychain = HDKey4.fromExtendedKey(nativeSegwitXpub);
-  return (address2) => {
-    const network = inferNetworkFromAddress(address2);
-    const paymentType = inferPaymentTypeFromAddress(address2);
-    const accountIndex = whenSupportedPaymentType(paymentType)({
-      p2tr: taprootKeychain.index - HARDENED_OFFSET3,
-      p2wpkh: nativeSegwitKeychain.index - HARDENED_OFFSET3
-    });
-    function getTaprootAddressAtIndex(index) {
-      return getTaprootAddress({ index, keychain: taprootKeychain, network });
-    }
-    function getNativeSegwitAddressAtIndex(index) {
-      return getNativeSegwitAddress({ index, keychain: nativeSegwitKeychain, network });
-    }
-    const paymentFn = whenSupportedPaymentType(paymentType)({
-      p2tr: getTaprootAddressAtIndex,
-      p2wpkh: getNativeSegwitAddressAtIndex
-    });
-    const derivationPathFn = whenSupportedPaymentType(paymentType)({
-      p2tr: makeTaprootAddressIndexDerivationPath,
-      p2wpkh: makeNativeSegwitAddressIndexDerivationPath
-    });
-    const count = createCounter();
-    const t0 = performance.now();
-    while (count.getValue() <= iterationLimit) {
-      const currentIndex = count.getValue();
-      const addressToCheck = paymentFn(currentIndex);
-      if (addressToCheck !== address2) {
-        count.increment();
-        continue;
-      }
-      const t1 = performance.now();
-      return {
-        status: "success",
-        duration: t1 - t0,
-        path: derivationPathFn(network, accountIndex, currentIndex)
-      };
-    }
-    return { status: "failure" };
-  };
-}
-export {
-  BitcoinError,
-  TEST_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS,
-  TEST_ACCOUNT_1_TAPROOT_ADDRESS,
-  TEST_ACCOUNT_2_TAPROOT_ADDRESS,
-  TEST_TESNET_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS,
-  TEST_TESTNET_ACCOUNT_2_BTC_ADDRESS,
-  TEST_TESTNET_ACCOUNT_2_TAPROOT_ADDRESS,
-  bip21,
-  bip322TransactionToSignValues,
-  bitcoinNetworkModeToCoreNetworkMode,
-  bitcoinNetworkToCoreNetworkMap,
-  btcAddressNetworkValidator,
-  btcAddressValidator,
-  btcSignerLibPaymentTypeToPaymentTypeMap,
-  calculateMaxSpend,
-  coinTypeMap,
-  createBitcoinAddress,
-  createNativeSegwitBitcoinJsSigner,
-  createTaprootBitcoinJsSigner,
-  createToSpendTx,
-  createWalletIdDecoratedPath,
-  decodeBitcoinTx,
-  decodeCompressedWifPrivateKey,
-  deriveAddressIndexKeychainFromAccount,
-  deriveAddressIndexZeroFromAccount,
-  deriveAddressesFromDescriptor,
-  deriveBitcoinPayerFromAccount,
-  deriveBtcBip49SeedFromMnemonic,
-  deriveNativeSegwitAccountFromRootKeychain,
-  deriveNativeSegwitReceiveAddressIndexZero,
-  deriveRootBtcKeychain,
-  deriveTaprootAccount,
-  deriveTaprootReceiveAddressIndexZero,
-  determineUtxosForSpend,
-  determineUtxosForSpendAll,
-  ecPairFromPrivateKey,
-  ecdsaPublicKeyLength,
-  ecdsaPublicKeyToSchnorr,
-  encodeMessageWitnessData,
-  extractExtendedPublicKeyFromPolicy,
-  extractPayerInfoFromDerivationPath,
-  extractRequiredKeyOrigins,
-  extractXpubFromDescriptor,
-  filterUneconomicalUtxos,
-  generateBitcoinUnsignedTransaction,
-  getAddressFromOutScript,
-  getBitcoinAddressNetworkType,
-  getBitcoinCoinTypeIndexByNetwork,
-  getBitcoinFees,
-  getBitcoinInputAddress,
-  getBitcoinInputValue,
-  getBitcoinJsLibNetworkConfigByMode,
-  getBitcoinTransactionFee,
-  getBtcSignerLibNetworkConfigByMode,
-  getDescriptorFromKeychain,
-  getHdKeyVersionsFromNetwork,
-  getInputPaymentType,
-  getNativeSegwitAccountDerivationPath,
-  getNativeSegwitAddress,
-  getNativeSegwitAddressIndexDerivationPath,
-  getNativeSegwitPaymentFromAddressIndex,
-  getNetworkTypeFromAddress,
-  getParsedInputs,
-  getParsedOutputs,
-  getPsbtAsTransaction,
-  getPsbtDetails,
-  getPsbtTotals,
-  getPsbtTxInputs,
-  getPsbtTxOutputs,
-  getRawPsbt,
-  getSizeInfo,
-  getSpendableAmount,
-  getTaprootAccountDerivationPath,
-  getTaprootAddress,
-  getTaprootAddressIndexDerivationPath,
-  getTaprootPayment,
-  getTaprootPaymentFromAddressIndex,
-  getUtxoTotal,
-  hashBip322Message,
-  inValidCharactersAddress,
-  inValidLengthAddress,
-  inferNetworkFromAddress,
-  inferNetworkFromPath,
-  inferPaymentTypeFromAddress,
-  inferPaymentTypeFromDescriptor,
-  inferPaymentTypeFromPath,
-  initBitcoinAccount,
-  initializeBitcoinAccountKeychainFromDescriptor,
-  invalidAddress,
-  isBitcoinAddress,
-  isBtcBalanceSufficient,
-  isBtcMinimumSpend,
-  isBtcSignerLibPaymentType,
-  isSupportedMessageSigningPaymentType,
-  isValidBitcoinAddress,
-  isValidBitcoinNetworkAddress,
-  isValidBitcoinTransaction,
-  legacyAddress,
-  lookUpLedgerKeysByPath,
-  lookupDerivationByAddress,
-  makeNativeSegwitAccountDerivationPath,
-  makeNativeSegwitAddressIndexDerivationPath,
-  makePayToScriptHashAddress,
-  makePayToScriptHashAddressBytes,
-  makePayToScriptHashKeyHash,
-  makeTaprootAccountDerivationPath,
-  makeTaprootAddressIndexDerivationPath,
-  mnemonicToRootNode,
-  nonEmptyStringValidator,
-  parseKnownPaymentType,
-  payToScriptHashTestnetPrefix,
-  payerToBip32Derivation,
-  payerToBip32DerivationBitcoinJsLib,
-  payerToTapBip32Derivation,
-  payerToTapBip32DerivationBitcoinJsLib,
-  paymentTypeMap,
-  publicKeyToPayToScriptHashAddress,
-  recipientAddress,
-  segwitAddress,
-  serializeKeyOrigin,
-  signBip322MessageSimple,
-  taprootAddress,
-  toXOnly,
-  tweakSigner,
-  whenBitcoinNetwork,
-  whenPaymentType,
-  whenSupportedPaymentType
-};
+	const { taprootXpub, nativeSegwitXpub, iterationLimit } = args;
+	const taprootKeychain = HDKey.fromExtendedKey(taprootXpub);
+	const nativeSegwitKeychain = HDKey.fromExtendedKey(nativeSegwitXpub);
+	return (address) => {
+		const network = inferNetworkFromAddress(address);
+		const paymentType = inferPaymentTypeFromAddress(address);
+		const accountIndex = whenSupportedPaymentType(paymentType)({
+			p2tr: taprootKeychain.index - HARDENED_OFFSET,
+			p2wpkh: nativeSegwitKeychain.index - HARDENED_OFFSET
+		});
+		function getTaprootAddressAtIndex(index) {
+			return getTaprootAddress({
+				index,
+				keychain: taprootKeychain,
+				network
+			});
+		}
+		function getNativeSegwitAddressAtIndex(index) {
+			return getNativeSegwitAddress({
+				index,
+				keychain: nativeSegwitKeychain,
+				network
+			});
+		}
+		const paymentFn = whenSupportedPaymentType(paymentType)({
+			p2tr: getTaprootAddressAtIndex,
+			p2wpkh: getNativeSegwitAddressAtIndex
+		});
+		const derivationPathFn = whenSupportedPaymentType(paymentType)({
+			p2tr: makeTaprootAddressIndexDerivationPath,
+			p2wpkh: makeNativeSegwitAddressIndexDerivationPath
+		});
+		const count = createCounter();
+		const t0 = performance.now();
+		while (count.getValue() <= iterationLimit) {
+			const currentIndex = count.getValue();
+			if (paymentFn(currentIndex) !== address) {
+				count.increment();
+				continue;
+			}
+			return {
+				status: "success",
+				duration: performance.now() - t0,
+				path: derivationPathFn(network, accountIndex, currentIndex)
+			};
+		}
+		return { status: "failure" };
+	};
+}
+
+//#endregion
+export { BitcoinError, TEST_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS, TEST_ACCOUNT_1_TAPROOT_ADDRESS, TEST_ACCOUNT_2_TAPROOT_ADDRESS, TEST_TESNET_ACCOUNT_1_NATIVE_SEGWIT_ADDRESS, TEST_TESTNET_ACCOUNT_2_BTC_ADDRESS, TEST_TESTNET_ACCOUNT_2_TAPROOT_ADDRESS, bip21, bip322TransactionToSignValues, bitcoinNetworkModeToCoreNetworkMode, bitcoinNetworkToCoreNetworkMap, btcAddressNetworkValidator, btcAddressValidator, btcSignerLibPaymentTypeToPaymentTypeMap, calculateMaxSpend, coinTypeMap, createBitcoinAddress, createNativeSegwitBitcoinJsSigner, createTaprootBitcoinJsSigner, createToSpendTx, createWalletIdDecoratedPath, decodeBitcoinTx, decodeCompressedWifPrivateKey, deriveAddressIndexKeychainFromAccount, deriveAddressIndexZeroFromAccount, deriveAddressesFromDescriptor, deriveBitcoinPayerFromAccount, deriveBtcBip49SeedFromMnemonic, deriveNativeSegwitAccountFromRootKeychain, deriveNativeSegwitReceiveAddressIndexZero, deriveRootBtcKeychain, deriveTaprootAccount, deriveTaprootReceiveAddressIndexZero, determineUtxosForSpend, determineUtxosForSpendAll, ecPairFromPrivateKey, ecdsaPublicKeyLength, ecdsaPublicKeyToSchnorr, encodeMessageWitnessData, extractExtendedPublicKeyFromPolicy, extractPayerInfoFromDerivationPath, extractRequiredKeyOrigins, extractXpubFromDescriptor, filterUneconomicalUtxos, generateBitcoinUnsignedTransaction, getAddressFromOutScript, getBitcoinAddressNetworkType, getBitcoinCoinTypeIndexByNetwork, getBitcoinFees, getBitcoinInputAddress, getBitcoinInputValue, getBitcoinJsLibNetworkConfigByMode, getBitcoinTransactionFee, getBtcSignerLibNetworkConfigByMode, getDescriptorFromKeychain, getHdKeyVersionsFromNetwork, getInputPaymentType, getNativeSegwitAccountDerivationPath, getNativeSegwitAddress, getNativeSegwitAddressIndexDerivationPath, getNativeSegwitPaymentFromAddressIndex, getNetworkTypeFromAddress, getParsedInputs, getParsedOutputs, getPsbtAsTransaction, getPsbtDetails, getPsbtTotals, getPsbtTxInputs, getPsbtTxOutputs, getRawPsbt, getSizeInfo, getSpendableAmount, getTaprootAccountDerivationPath, getTaprootAddress, getTaprootAddressIndexDerivationPath, getTaprootPayment, getTaprootPaymentFromAddressIndex, getUtxoTotal, hashBip322Message, inValidCharactersAddress, inValidLengthAddress, inferNetworkFromAddress, inferNetworkFromPath, inferPaymentTypeFromAddress, inferPaymentTypeFromDescriptor, inferPaymentTypeFromPath, initBitcoinAccount, initializeBitcoinAccountKeychainFromDescriptor, invalidAddress, isBitcoinAddress, isBtcBalanceSufficient, isBtcMinimumSpend, isBtcSignerLibPaymentType, isSupportedMessageSigningPaymentType, isValidBitcoinAddress, isValidBitcoinNetworkAddress, isValidBitcoinTransaction, legacyAddress, lookUpLedgerKeysByPath, lookupDerivationByAddress, makeNativeSegwitAccountDerivationPath, makeNativeSegwitAddressIndexDerivationPath, makePayToScriptHashAddress, makePayToScriptHashAddressBytes, makePayToScriptHashKeyHash, makeTaprootAccountDerivationPath, makeTaprootAddressIndexDerivationPath, mnemonicToRootNode, nonEmptyStringValidator, parseKnownPaymentType, payToScriptHashTestnetPrefix, payerToBip32Derivation, payerToBip32DerivationBitcoinJsLib, payerToTapBip32Derivation, payerToTapBip32DerivationBitcoinJsLib, paymentTypeMap, publicKeyToPayToScriptHashAddress, recipientAddress, segwitAddress, serializeKeyOrigin, signBip322MessageSimple, taprootAddress, toXOnly, tweakSigner, whenBitcoinNetwork, whenPaymentType, whenSupportedPaymentType };
 //# sourceMappingURL=index.js.map