@leather.io/bitcoin 0.19.29 → 0.19.31

package/dist/index.js

@@ -7,7 +7,7 @@ import { ECPairFactory } from "ecpair";
 import { encode } from "varuint-bitcoin";
 import { isString } from "@leather.io/utils";
 
-// src/bitcoin.utils.ts
+// src/utils/bitcoin.utils.ts
 import { hexToBytes } from "@noble/hashes/utils";
 import { HDKey } from "@scure/bip32";
 import { mnemonicToSeedSync } from "@scure/bip39";
@@ -19,7 +19,11 @@ import {
 } from "@leather.io/crypto";
 import { defaultWalletKeyId, isDefined, whenNetwork } from "@leather.io/utils";
 
-// src/bitcoin.network.ts
+// src/payments/p2tr-address-gen.ts
+import * as btc from "@scure/btc-signer";
+import { DerivationPathDepth } from "@leather.io/crypto";
+
+// src/utils/bitcoin.network.ts
 import * as bitcoinJs from "bitcoinjs-lib";
 var bitcoinMainnet = {
   bech32: "bc",
@@ -60,9 +64,7 @@ function getBitcoinJsLibNetworkConfigByMode(network) {
   return bitcoinJsLibNetworks[network];
 }
 
-// src/p2tr-address-gen.ts
-import * as btc from "@scure/btc-signer";
-import { DerivationPathDepth } from "@leather.io/crypto";
+// src/payments/p2tr-address-gen.ts
 function makeTaprootAccountDerivationPath(network, accountIndex) {
   return `m/86'/${getBitcoinCoinTypeIndexByNetwork(network)}'/${accountIndex}'`;
 }
@@ -108,7 +110,7 @@ function deriveTaprootReceiveAddressIndexZero({
   };
 }
 
-// src/p2wpkh-address-gen.ts
+// src/payments/p2wpkh-address-gen.ts
 import * as btc2 from "@scure/btc-signer";
 import { DerivationPathDepth as DerivationPathDepth2 } from "@leather.io/crypto";
 function makeNativeSegwitAccountDerivationPath(network, accountIndex) {
@@ -146,7 +148,7 @@ function deriveNativeSegwitReceiveAddressIndexZero({
   };
 }
 
-// src/bitcoin.utils.ts
+// src/utils/bitcoin.utils.ts
 function initBitcoinAccount(derivationPath, policy) {
   const xpub = extractExtendedPublicKeyFromPolicy(policy);
   const network = inferNetworkFromPath(derivationPath);
@@ -485,7 +487,7 @@ import validate, { AddressType, getAddressInfo } from "bitcoin-address-validatio
 import { BTC_P2WPKH_DUST_AMOUNT } from "@leather.io/constants";
 import { sumNumbers } from "@leather.io/utils";
 
-// src/btc-size-fee-estimator.ts
+// src/fees/btc-size-fee-estimator.ts
 import BigNumber from "bignumber.js";
 import { assertUnreachable } from "@leather.io/utils";
 var BtcSizeFeeEstimator = class {
@@ -757,11 +759,7 @@ function getSizeInfo(payload) {
   });
   return sizeInfo;
 }
-function getSpendableAmount({
-  utxos,
-  feeRate,
-  recipients
-}) {
+function getSpendableAmount({ utxos, feeRate, recipients }) {
   const balance = utxos.map((utxo) => Number(utxo.value)).reduce((prevVal, curVal) => prevVal + curVal, 0);
   const size = getSizeInfo({
     inputLength: utxos.length,
@@ -796,33 +794,34 @@ function filterUneconomicalUtxos({
 }
 
 // src/coin-selection/calculate-max-spend.ts
-function calculateMaxBitcoinSpend({
-  address: address2,
+function calculateMaxSpend({
+  recipient,
   utxos,
   feeRate,
-  fetchedFeeRates
+  feeRates
 }) {
-  if (!utxos.length || !fetchedFeeRates)
+  if (!utxos.length || !feeRates)
     return {
       spendAllFee: 0,
       amount: createMoney(0, "BTC"),
-      spendableBitcoin: new BigNumber3(0)
+      spendableBtc: new BigNumber3(0)
     };
-  const currentFeeRate = feeRate ?? fetchedFeeRates.halfHourFee.toNumber();
+  const currentFeeRate = feeRate ?? feeRates.halfHourFee.toNumber();
   const filteredUtxos = filterUneconomicalUtxos({
     utxos,
     feeRate: currentFeeRate,
-    recipients: [{ address: address2, amount: createMoney(0, "BTC") }]
+    recipients: [{ address: recipient, amount: createMoney(0, "BTC") }]
   });
   const { spendableAmount, fee } = getSpendableAmount({
     utxos: filteredUtxos,
     feeRate: currentFeeRate,
-    recipients: [{ address: address2, amount: createMoney(0, "BTC") }]
+    recipients: [{ address: recipient, amount: createMoney(0, "BTC") }],
+    isSendMax: true
   });
   return {
     spendAllFee: fee,
     amount: createMoney(spendableAmount, "BTC"),
-    spendableBitcoin: satToBtc(spendableAmount)
+    spendableBtc: satToBtc(spendableAmount)
   };
 }
 
@@ -832,7 +831,7 @@ import { validate as validate2 } 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";
 
-// src/bitcoin-error.ts
+// src/validation/bitcoin-error.ts
 var BitcoinError = class extends Error {
   message;
   constructor(message) {
@@ -964,133 +963,74 @@ function getBitcoinFees({ feeRates, isSendingMax, recipients, utxos }) {
   };
 }
 
-// src/transactions/generate-unsigned-transaction.ts
-import { hexToBytes as hexToBytes3 } from "@noble/hashes/utils";
-import * as btc4 from "@scure/btc-signer";
-function generateBitcoinUnsignedTransactionNativeSegwit({
-  feeRate,
-  isSendingMax,
-  payerAddress,
-  payerPublicKey,
-  bip32Derivation,
-  network,
-  recipients,
-  utxos
-}) {
-  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 btc4.Transaction();
-  const p2wpkh3 = btc4.p2wpkh(hexToBytes3(payerPublicKey), network);
-  for (const input of inputs) {
-    tx.addInput({
-      txid: input.txid,
-      index: input.vout,
-      sequence: 0,
-      bip32Derivation,
-      witnessUtxo: {
-        // script = 0014 + pubKeyHash
-        script: p2wpkh3.script,
-        amount: BigInt(input.value)
-      }
-    });
+// src/validation/address-validation.ts
+import { Network, validate as validate3 } from "bitcoin-address-validation";
+import { isEmptyString, isUndefined } from "@leather.io/utils";
+function getBitcoinAddressNetworkType(network) {
+  if (network === "signet") return Network.testnet;
+  return network;
+}
+function isValidBitcoinAddress(address2) {
+  if (isUndefined(address2) || isEmptyString(address2)) {
+    return false;
   }
-  outputs.forEach((output) => {
-    if (!output.address) {
-      tx.addOutputAddress(payerAddress, BigInt(output.value), network);
-      return;
-    }
-    tx.addOutputAddress(output.address, BigInt(output.value), network);
-  });
-  return { tx, hex: tx.hex, psbt: tx.toPSBT(), inputs, fee };
+  return validate3(address2);
 }
-
-// src/bitcoin-signer.ts
-import { HARDENED_OFFSET } from "@scure/bip32";
-import * as btc5 from "@scure/btc-signer";
-import {
-  DerivationPathDepth as DerivationPathDepth4,
-  appendAddressIndexToPath,
-  decomposeDescriptor,
-  deriveKeychainFromXpub,
-  keyOriginToDerivationPath
-} from "@leather.io/crypto";
-import { hexToNumber, toHexString } from "@leather.io/utils";
-function initializeBitcoinAccountKeychainFromDescriptor(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 ({ receive = 0, addressIndex }) => {
-    const childKeychain = accountKeychain.deriveChild(receive).deriveChild(addressIndex);
-    const derivePayerFromAccount = whenSupportedPaymentType(paymentType)({
-      p2tr: getTaprootPaymentFromAddressIndex,
-      p2wpkh: getNativeSegwitPaymentFromAddressIndex
-    });
-    const payment = derivePayerFromAccount(childKeychain, network);
-    return {
-      keyOrigin: appendAddressIndexToPath(keyOrigin, 0),
-      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;
-      }
-    };
-  };
-}
-function payerToBip32Derivation(args) {
-  return [
-    args.publicKey,
-    {
-      fingerprint: hexToNumber(args.masterKeyFingerprint),
-      path: btc5.bip32Path(keyOriginToDerivationPath(args.keyOrigin))
-    }
-  ];
-}
-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))
-      }
-    }
-  ];
+function isValidBitcoinNetworkAddress(address2, network) {
+  if (!isValidBitcoinAddress(address2) || !network) {
+    return false;
+  }
+  return validate3(address2, getBitcoinAddressNetworkType(network));
 }
-function serializeKeyOrigin({ fingerprint, path }) {
-  const values = path.map((num) => num >= HARDENED_OFFSET ? num - HARDENED_OFFSET + "'" : num);
-  return `${toHexString(fingerprint)}/${values.join("/")}`;
+
+// src/validation/bitcoin-address.ts
+function isBitcoinAddress(value) {
+  try {
+    isValidBitcoinAddress(value);
+    return true;
+  } catch {
+    return false;
+  }
 }
-function extractRequiredKeyOrigins(derivation) {
-  return derivation.map(
-    ([_pubkey, path]) => serializeKeyOrigin("hashes" in path ? path.der : path)
-  );
+function createBitcoinAddress(value) {
+  if (!isBitcoinAddress(value)) {
+    throw new BitcoinError("InvalidAddress");
+  }
+  return value;
 }
 
-// src/p2wsh-p2sh-address-gen.ts
+// 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");
+
+// 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";
@@ -1132,54 +1072,6 @@ function publicKeyToPayToScriptHashAddress(publicKey, network) {
   return makePayToScriptHashAddress(addrBytes, network);
 }
 
-// src/lookup-derivation-by-address.ts
-import { HARDENED_OFFSET as HARDENED_OFFSET2, HDKey as HDKey3 } from "@scure/bip32";
-import { createCounter } from "@leather.io/utils";
-function lookupDerivationByAddress(args) {
-  const { taprootXpub, nativeSegwitXpub, iterationLimit } = args;
-  const taprootKeychain = HDKey3.fromExtendedKey(taprootXpub);
-  const nativeSegwitKeychain = HDKey3.fromExtendedKey(nativeSegwitXpub);
-  return (address2) => {
-    const network = inferNetworkFromAddress(address2);
-    const paymentType = inferPaymentTypeFromAddress(address2);
-    const accountIndex = whenSupportedPaymentType(paymentType)({
-      p2tr: taprootKeychain.index - HARDENED_OFFSET2,
-      p2wpkh: nativeSegwitKeychain.index - HARDENED_OFFSET2
-    });
-    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" };
-  };
-}
-
 // src/psbt/psbt-totals.ts
 import { createMoney as createMoney3, sumNumbers as sumNumbers2 } from "@leather.io/utils";
 function calculateAddressInputsTotal(addresses, inputs) {
@@ -1219,7 +1111,7 @@ function getPsbtTotals({ psbtAddresses, parsedInputs, parsedOutputs }) {
 
 // src/psbt/psbt-inputs.ts
 import { bytesToHex } from "@noble/hashes/utils";
-import { isDefined as isDefined2, isUndefined } from "@leather.io/utils";
+import { isDefined as isDefined2, isUndefined as isUndefined2 } from "@leather.io/utils";
 function getParsedInputs({
   inputs,
   indexesToSign,
@@ -1227,15 +1119,16 @@ function getParsedInputs({
   psbtAddresses
 }) {
   const bitcoinNetwork = getBtcSignerLibNetworkConfigByMode(networkMode);
-  const signAll = isUndefined(indexesToSign);
+  const signAll = isUndefined2(indexesToSign);
   const psbtInputs = inputs.map((input, i) => {
     const inputAddress = isDefined2(input.index) ? getBitcoinInputAddress(input, bitcoinNetwork) : "";
-    const isCurrentAddress = psbtAddresses.includes(inputAddress);
+    const bitcoinAddress = createBitcoinAddress(inputAddress);
+    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: inputAddress,
+      address: bitcoinAddress,
       index: input.index,
       bip32Derivation: input.bip32Derivation,
       tapBip32Derivation: input.tapBip32Derivation,
@@ -1251,7 +1144,7 @@ function getParsedInputs({
 }
 
 // src/psbt/psbt-outputs.ts
-import { isDefined as isDefined3, isUndefined as isUndefined2 } from "@leather.io/utils";
+import { isDefined as isDefined3, isUndefined as isUndefined3 } from "@leather.io/utils";
 function getParsedOutputs({
   isPsbtMutable,
   outputs,
@@ -1260,10 +1153,12 @@ function getParsedOutputs({
 }) {
   const bitcoinNetwork = getBtcSignerLibNetworkConfigByMode(networkMode);
   return outputs.map((output) => {
-    if (isUndefined2(output.script)) {
+    if (isUndefined3(output.script)) {
       return;
     }
-    const outputAddress = getAddressFromOutScript(output.script, bitcoinNetwork);
+    const outputAddress = createBitcoinAddress(
+      getAddressFromOutScript(output.script, bitcoinNetwork)
+    );
     const isCurrentAddress = psbtAddresses.includes(outputAddress);
     return {
       address: outputAddress,
@@ -1278,16 +1173,16 @@ function getParsedOutputs({
 import { createMoney as createMoney4, subtractMoney } from "@leather.io/utils";
 
 // src/psbt/utils.ts
-import { hexToBytes as hexToBytes4 } from "@noble/hashes/utils";
-import * as btc6 from "@scure/btc-signer";
+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";
 function getPsbtAsTransaction(psbt) {
-  const bytes = isString2(psbt) ? hexToBytes4(psbt) : psbt;
-  return btc6.Transaction.fromPSBT(bytes);
+  const bytes = isString2(psbt) ? hexToBytes3(psbt) : psbt;
+  return btc4.Transaction.fromPSBT(bytes);
 }
 function getRawPsbt(psbt) {
-  const bytes = isString2(psbt) ? hexToBytes4(psbt) : psbt;
+  const bytes = isString2(psbt) ? hexToBytes3(psbt) : psbt;
   try {
     return RawPSBTV0.decode(bytes);
   } catch (e1) {
@@ -1342,14 +1237,240 @@ function getPsbtDetails({
     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,
+  keyOriginToDerivationPath
+} from "@leather.io/crypto";
+import { hexToNumber, toHexString } from "@leather.io/utils";
+function initializeBitcoinAccountKeychainFromDescriptor(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 ({ receive = 0, addressIndex }) => {
+    const childKeychain = accountKeychain.deriveChild(receive).deriveChild(addressIndex);
+    const derivePayerFromAccount = whenSupportedPaymentType(paymentType)({
+      p2tr: getTaprootPaymentFromAddressIndex,
+      p2wpkh: getNativeSegwitPaymentFromAddressIndex
+    });
+    const payment = derivePayerFromAccount(childKeychain, network);
+    return {
+      keyOrigin: appendAddressIndexToPath(keyOrigin, 0),
+      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;
+      }
+    };
+  };
+}
+function payerToBip32Derivation(args) {
+  return [
+    args.publicKey,
+    {
+      fingerprint: hexToNumber(args.masterKeyFingerprint),
+      path: btc5.bip32Path(keyOriginToDerivationPath(args.keyOrigin))
+    }
+  ];
+}
+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))
+      }
+    }
+  ];
+}
+function serializeKeyOrigin({ fingerprint, path }) {
+  const values = path.map((num) => num >= HARDENED_OFFSET ? num - HARDENED_OFFSET + "'" : num);
+  return `${toHexString(fingerprint)}/${values.join("/")}`;
+}
+function extractRequiredKeyOrigins(derivation) {
+  return derivation.map(
+    ([_pubkey, path]) => serializeKeyOrigin("hashes" in path ? path.der : path)
+  );
+}
+
+// src/transactions/generate-unsigned-transaction.ts
+import { hexToBytes as hexToBytes4 } from "@noble/hashes/utils";
+import * as btc6 from "@scure/btc-signer";
+function generateBitcoinUnsignedTransactionNativeSegwit({
+  feeRate,
+  isSendingMax,
+  payerAddress,
+  payerPublicKey,
+  bip32Derivation,
+  network,
+  recipients,
+  utxos
+}) {
+  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();
+  const p2wpkh3 = btc6.p2wpkh(hexToBytes4(payerPublicKey), network);
+  for (const input of inputs) {
+    tx.addInput({
+      txid: input.txid,
+      index: input.vout,
+      sequence: 0,
+      bip32Derivation,
+      witnessUtxo: {
+        // script = 0014 + pubKeyHash
+        script: p2wpkh3.script,
+        amount: BigInt(input.value)
+      }
+    });
+  }
+  outputs.forEach((output) => {
+    if (!output.address) {
+      tx.addOutputAddress(payerAddress, 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 BigNumber5 from "bignumber.js";
+import { btcToSat } from "@leather.io/utils";
+var minSpendAmountInSats = 546;
+function isBtcBalanceSufficient({
+  amount: { amount },
+  spendableBtc
+}) {
+  if (!spendableBtc) return false;
+  const desiredSpend = new BigNumber5(amount);
+  if (desiredSpend.isGreaterThan(spendableBtc)) return false;
+  return true;
+}
+function isBtcMinimumSpend({ amount: { amount } }) {
+  if (!amount) return false;
+  const desiredSpend = btcToSat(amount);
+  if (desiredSpend.isLessThan(minSpendAmountInSats)) return false;
+  return true;
+}
+
+// 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 { spendableBtc } = calculateMaxSpend({ recipient, utxos, feeRate, feeRates });
+  if (!isBtcBalanceSufficient({ amount, spendableBtc })) {
+    throw new BitcoinError("InsufficientFunds");
+  }
+}
+
+// src/utils/lookup-derivation-by-address.ts
+import { HARDENED_OFFSET as HARDENED_OFFSET2, HDKey as HDKey3 } from "@scure/bip32";
+import { createCounter } from "@leather.io/utils";
+function lookupDerivationByAddress(args) {
+  const { taprootXpub, nativeSegwitXpub, iterationLimit } = args;
+  const taprootKeychain = HDKey3.fromExtendedKey(taprootXpub);
+  const nativeSegwitKeychain = HDKey3.fromExtendedKey(nativeSegwitXpub);
+  return (address2) => {
+    const network = inferNetworkFromAddress(address2);
+    const paymentType = inferPaymentTypeFromAddress(address2);
+    const accountIndex = whenSupportedPaymentType(paymentType)({
+      p2tr: taprootKeychain.index - HARDENED_OFFSET2,
+      p2wpkh: nativeSegwitKeychain.index - HARDENED_OFFSET2
+    });
+    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,
   bip322TransactionToSignValues,
   bitcoinNetworkModeToCoreNetworkMode,
   bitcoinNetworkToCoreNetworkMap,
   btcSignerLibPaymentTypeToPaymentTypeMap,
-  calculateMaxBitcoinSpend,
+  calculateMaxSpend,
   coinTypeMap,
+  createBitcoinAddress,
   createNativeSegwitBitcoinJsSigner,
   createTaprootBitcoinJsSigner,
   createToSpendTx,
@@ -1376,6 +1497,7 @@ export {
   filterUneconomicalUtxos,
   generateBitcoinUnsignedTransactionNativeSegwit,
   getAddressFromOutScript,
+  getBitcoinAddressNetworkType,
   getBitcoinCoinTypeIndexByNetwork,
   getBitcoinFees,
   getBitcoinInputAddress,
@@ -1406,14 +1528,24 @@ export {
   getTaprootPaymentFromAddressIndex,
   getUtxoTotal,
   hashBip322Message,
+  inValidCharactersAddress,
+  inValidLengthAddress,
   inferNetworkFromAddress,
   inferNetworkFromPath,
   inferPaymentTypeFromAddress,
   inferPaymentTypeFromPath,
   initBitcoinAccount,
   initializeBitcoinAccountKeychainFromDescriptor,
+  invalidAddress,
+  isBitcoinAddress,
+  isBtcBalanceSufficient,
+  isBtcMinimumSpend,
   isBtcSignerLibPaymentType,
   isSupportedMessageSigningPaymentType,
+  isValidBitcoinAddress,
+  isValidBitcoinNetworkAddress,
+  isValidBitcoinTransaction,
+  legacyAddress,
   lookUpLedgerKeysByPath,
   lookupDerivationByAddress,
   makeNativeSegwitAccountDerivationPath,
@@ -1423,6 +1555,7 @@ export {
   makePayToScriptHashKeyHash,
   makeTaprootAccountDerivationPath,
   makeTaprootAddressIndexDerivationPath,
+  minSpendAmountInSats,
   mnemonicToRootNode,
   parseKnownPaymentType,
   payToScriptHashTestnetPrefix,
@@ -1430,8 +1563,11 @@ export {
   payerToTapBip32Derivation,
   paymentTypeMap,
   publicKeyToPayToScriptHashAddress,
+  recipientAddress,
+  segwitAddress,
   serializeKeyOrigin,
   signBip322MessageSimple,
+  taprootAddress,
   toXOnly,
   tweakSigner,
   whenBitcoinNetwork,