@babylonlabs-io/ts-sdk 0.70.1 → 0.71.0

package/dist/bitcoin-C-TuHb-v.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitcoin-C-TuHb-v.js","sources":["../src/tbv/core/primitives/utils/bitcoin.ts"],"sourcesContent":["/**\n * Bitcoin Utilities\n *\n * Common pure utility functions for Bitcoin operations including:\n * - Public key conversions (x-only format)\n * - Hex string manipulation\n * - Uint8Array conversions and validation\n * - Address derivation and validation\n *\n * All functions are pure (no side effects) and work in Node.js, browsers,\n * and serverless environments.\n *\n * @module primitives/utils/bitcoin\n */\n\nimport { networks, payments } from \"bitcoinjs-lib\";\nimport { Buffer } from \"buffer\";\n\nimport type { Network } from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\nimport type { Hex } from \"viem\";\n\nimport {\n  COMPRESSED_PUBKEY_HEX_LEN,\n  X_ONLY_PUBKEY_HEX_LEN,\n} from \"../../utils/validation\";\n\n/**\n * BIP-341 Tapscript leaf version for script-path spends.\n * @see https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki\n * @see Rust: bitcoin::taproot::LeafVersion::TapScript\n */\nexport const TAPSCRIPT_LEAF_VERSION = 0xc0;\n\n/**\n * Hex-string length of a 65-byte SEC1-uncompressed secp256k1 public\n * key (`0x04` prefix + 32-byte x + 32-byte y). `2 * 65 = 130`.\n */\nconst UNCOMPRESSED_PUBKEY_HEX_LEN = 130;\n\n/**\n * Hex-string length of a 64-byte BIP-340 Schnorr signature. `2 * 64 = 128`.\n */\nexport const SCHNORR_SIG_HEX_LEN = 128;\n\n/**\n * Strip \"0x\" prefix from hex string if present.\n *\n * Bitcoin expects plain hex (no \"0x\" prefix), but frontend often uses\n * Ethereum-style \"0x\"-prefixed hex.\n *\n * @param hex - Hex string with or without \"0x\" prefix\n * @returns Hex string without \"0x\" prefix\n */\nexport function stripHexPrefix(hex: string): string {\n  return hex.startsWith(\"0x\") || hex.startsWith(\"0X\") ? hex.slice(2) : hex;\n}\n\n/**\n * Ensure \"0x\" prefix on a hex string, returning viem's Hex type.\n *\n * Ethereum/viem APIs expect `0x`-prefixed hex, but Bitcoin tooling\n * typically omits the prefix. This normalises either form.\n *\n * @param hex - Hex string with or without \"0x\" prefix\n * @returns `0x`-prefixed hex string typed as viem Hex\n */\nexport function ensureHexPrefix(hex: string): Hex {\n  if (hex.startsWith(\"0x\")) return hex as Hex;\n  if (hex.startsWith(\"0X\")) return `0x${hex.slice(2)}` as Hex;\n  return `0x${hex}` as Hex;\n}\n\n/**\n * Convert hex string to Uint8Array.\n *\n * @param hex - Hex string (with or without 0x prefix)\n * @returns Uint8Array\n * @throws If hex is invalid\n */\nexport function hexToUint8Array(hex: string): Uint8Array {\n  const cleanHex = stripHexPrefix(hex);\n  if (!isValidHexRaw(cleanHex)) {\n    throw new Error(`Invalid hex string: ${hex}`);\n  }\n  const bytes = new Uint8Array(cleanHex.length / 2);\n  for (let i = 0; i < cleanHex.length; i += 2) {\n    bytes[i / 2] = parseInt(cleanHex.slice(i, i + 2), 16);\n  }\n  return bytes;\n}\n\n/**\n * Convert Uint8Array to hex string (without 0x prefix).\n *\n * @param bytes - Uint8Array to convert\n * @returns Hex string without 0x prefix\n */\nexport function uint8ArrayToHex(bytes: Uint8Array): string {\n  return Array.from(bytes)\n    .map((b) => b.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n}\n\n/**\n * Read the prevout txid (big-endian hex) from a bitcoinjs-lib transaction input.\n *\n * bitcoinjs-lib stores `hash` in little-endian internal byte order; txids are\n * displayed in big-endian, so the bytes must be reversed before hex-encoding.\n *\n * @param input - Transaction input with a `hash` field (Buffer or Uint8Array)\n * @returns Prevout txid as a hex string (big-endian, no 0x prefix)\n */\nexport function inputTxidHex(input: { hash: Buffer | Uint8Array }): string {\n  return uint8ArrayToHex(new Uint8Array(input.hash).slice().reverse());\n}\n\n/**\n * Convert a 33-byte public key to 32-byte x-only format (removes first byte).\n *\n * Used for Taproot/Schnorr signatures which only need the x-coordinate.\n * If the input is already 32 bytes, returns it unchanged.\n *\n * @param pubKey - 33-byte or 32-byte public key\n * @returns 32-byte x-only public key\n */\nexport function toXOnly(pubKey: Uint8Array): Uint8Array {\n  return pubKey.length === 32 ? pubKey : pubKey.slice(1, 33);\n}\n\n/**\n * Internal helper: Validate hex string format without stripping prefix\n *\n * @internal\n * @param hex - Hex string (must already have prefix stripped)\n * @returns true if valid hex string\n */\nfunction isValidHexRaw(hex: string): boolean {\n  return /^[0-9a-fA-F]*$/.test(hex) && hex.length % 2 === 0;\n}\n\n/**\n * Process and convert a public key to x-only format (32 bytes hex).\n *\n * Handles:\n * - 0x prefix removal\n * - Hex character validation\n * - Length validation\n * - Conversion to x-only format\n *\n * Accepts:\n * - 64 hex chars (32 bytes) - already x-only\n * - 66 hex chars (33 bytes) - compressed pubkey\n * - 130 hex chars (65 bytes) - uncompressed pubkey\n *\n * @param publicKeyHex - Public key in hex format (with or without 0x prefix)\n * @returns X-only public key as 32 bytes hex string (without 0x prefix)\n * @throws If public key format is invalid or contains invalid hex characters\n */\nexport function processPublicKeyToXOnly(publicKeyHex: string): string {\n  // Remove '0x' prefix if present\n  const cleanHex = stripHexPrefix(publicKeyHex);\n\n  // Validate hex characters early to prevent silent failures\n  if (!isValidHexRaw(cleanHex)) {\n    throw new Error(`Invalid hex characters in public key: ${publicKeyHex}`);\n  }\n\n  // If already 64 chars (32 bytes), it's already x-only format\n  if (cleanHex.length === X_ONLY_PUBKEY_HEX_LEN) {\n    return cleanHex;\n  }\n\n  // Validate public key length (compressed SEC1 or uncompressed SEC1)\n  if (\n    cleanHex.length !== COMPRESSED_PUBKEY_HEX_LEN &&\n    cleanHex.length !== UNCOMPRESSED_PUBKEY_HEX_LEN\n  ) {\n    throw new Error(\n      `Invalid public key length: ${cleanHex.length} (expected ${X_ONLY_PUBKEY_HEX_LEN}, ${COMPRESSED_PUBKEY_HEX_LEN}, or ${UNCOMPRESSED_PUBKEY_HEX_LEN} hex chars)`,\n    );\n  }\n\n  const pubkeyBytes = hexToUint8Array(cleanHex);\n  return uint8ArrayToHex(toXOnly(pubkeyBytes));\n}\n\n/**\n * Normalize a public key to the one form two keys can be compared in:\n * lowercase x-only hex, no `0x`.\n *\n * `processPublicKeyToXOnly` returns already-x-only input untouched, so it\n * preserves case on that path — comparing its output directly is a latent\n * false mismatch for any source that serves uppercase hex. Every comparison\n * site therefore has to pair it with `.toLowerCase()`, and that pairing is\n * what this function exists to stop people re-deriving by hand.\n *\n * @param publicKeyHex - x-only, compressed, or uncompressed key, `0x` optional\n * @throws If the key is not valid hex or has an unexpected length\n */\nexport function canonicalizeBtcPubkey(publicKeyHex: string): string {\n  return processPublicKeyToXOnly(publicKeyHex).toLowerCase();\n}\n\n/**\n * Validate hex string format.\n *\n * Checks that the string contains only valid hexadecimal characters (0-9, a-f, A-F)\n * and has an even length (since each byte is represented by 2 hex characters).\n *\n * @param hex - String to validate (with or without 0x prefix)\n * @returns true if valid hex string\n */\nexport function isValidHex(hex: string): boolean {\n  const cleanHex = stripHexPrefix(hex);\n  return isValidHexRaw(cleanHex);\n}\n\n/**\n * Result of validating a wallet public key against an expected depositor public key.\n */\nexport interface WalletPubkeyValidationResult {\n  /** Wallet's raw public key (as returned by wallet, may be compressed) */\n  walletPubkeyRaw: string;\n  /** Wallet's public key in x-only format (32 bytes, 64 hex chars) */\n  walletPubkeyXOnly: string;\n  /** The validated depositor public key (x-only format) */\n  depositorPubkey: string;\n}\n\n/**\n * Validate that a wallet's public key matches the expected depositor public key.\n *\n * This function:\n * 1. Converts the wallet pubkey to x-only format\n * 2. Validates the wallet x-only pubkey matches the expected depositor pubkey\n *    (case-insensitive)\n *\n * @param walletPubkeyRaw - Raw public key from wallet (may be compressed 66 chars or x-only 64 chars)\n * @param expectedDepositorPubkey - Expected depositor public key (x-only).\n *   Required: omitting it would degrade this check to a self-comparison.\n * @returns Validation result with both pubkey formats\n * @throws If `expectedDepositorPubkey` is missing/empty\n * @throws If wallet pubkey doesn't match expected depositor pubkey\n */\nexport function validateWalletPubkey(\n  walletPubkeyRaw: string,\n  expectedDepositorPubkey: string,\n): WalletPubkeyValidationResult {\n  if (!expectedDepositorPubkey) {\n    throw new Error(\n      \"validateWalletPubkey requires expectedDepositorPubkey. Pass the on-chain registered depositor pubkey to avoid a self-comparison.\",\n    );\n  }\n\n  const walletPubkeyXOnly = processPublicKeyToXOnly(walletPubkeyRaw);\n  const depositorPubkey = expectedDepositorPubkey;\n\n  if (walletPubkeyXOnly.toLowerCase() !== depositorPubkey.toLowerCase()) {\n    throw new Error(\n      `Wallet public key does not match vault depositor. ` +\n        `Expected: ${depositorPubkey}, Got: ${walletPubkeyXOnly}. ` +\n        `Please connect the wallet that was used to create this vault.`,\n    );\n  }\n\n  return { walletPubkeyRaw, walletPubkeyXOnly, depositorPubkey };\n}\n\n// ============================================================================\n// BTC formatting\n// ============================================================================\n\nconst SATOSHIS_PER_BTC = 100_000_000n;\n\n/**\n * Format satoshis as a human-readable BTC string with trailing zeros removed.\n */\nexport function formatSatoshisToBtc(satoshis: bigint): string {\n  if (satoshis < 0n) {\n    return `-${formatSatoshisToBtc(-satoshis)}`;\n  }\n  const whole = satoshis / SATOSHIS_PER_BTC;\n  const fraction = satoshis % SATOSHIS_PER_BTC;\n  let fractionStr = fraction.toString().padStart(8, \"0\");\n  fractionStr = fractionStr.replace(/0+$/, \"\");\n  return fractionStr.length > 0 ? `${whole}.${fractionStr}` : whole.toString();\n}\n\n// ============================================================================\n// Address derivation and validation\n// ============================================================================\n\n/**\n * Assert that the ECC library has been initialized via `initEccLib(ecc)`.\n *\n * The consuming application must call `initEccLib(ecc)` from `bitcoinjs-lib`\n * once at startup before using any SDK function that involves Taproot / P2TR\n * operations. This guard provides a clear error message when that step was\n * missed, instead of letting bitcoinjs-lib throw its generic\n * \"No ECC Library provided\" error deep in a call stack.\n */\nexport function assertEccInitialized(): void {\n  try {\n    payments.p2tr({ internalPubkey: Buffer.alloc(32, 1) });\n  } catch (e) {\n    if (e instanceof Error && e.message.includes(\"No ECC Library provided\")) {\n      throw new Error(\n        \"ECC library not initialized. \" +\n          'You must call initEccLib(ecc) from \"bitcoinjs-lib\" before using the SDK. ' +\n          \"See the ts-sdk README for setup instructions.\",\n      );\n    }\n    // Any other error means ECC is loaded (e.g. invalid key is fine — ECC worked).\n  }\n}\n\n/**\n * Map SDK network type to bitcoinjs-lib Network object.\n *\n * @param network - Network type (\"bitcoin\", \"testnet\", \"signet\", \"regtest\")\n * @returns bitcoinjs-lib Network object\n */\nexport function getNetwork(network: Network): networks.Network {\n  switch (network) {\n    case \"bitcoin\":\n      return networks.bitcoin;\n    case \"testnet\":\n    case \"signet\":\n      return networks.testnet;\n    case \"regtest\":\n      return networks.regtest;\n    default:\n      throw new Error(`Unknown network: ${network}`);\n  }\n}\n\n/**\n * Derive a Taproot (P2TR) address from a public key.\n *\n * @param publicKeyHex - Compressed (66 hex) or x-only (64 hex) public key\n * @param network - Bitcoin network\n * @returns Taproot address (bc1p... / tb1p... / bcrt1p...)\n */\nexport function deriveTaprootAddress(\n  publicKeyHex: string,\n  network: Network,\n): string {\n  assertEccInitialized();\n  const xOnly = hexToUint8Array(processPublicKeyToXOnly(publicKeyHex));\n  const { address } = payments.p2tr({\n    internalPubkey: Buffer.from(xOnly),\n    network: getNetwork(network),\n  });\n  if (!address) {\n    throw new Error(\"Failed to derive taproot address from public key\");\n  }\n  return address;\n}\n\n/**\n * Strip `0x` prefixes and lex-sort an array of x-only public keys.\n *\n * Used to produce the canonical (Rust-parity) keeper / challenger ordering\n * the protocol expects in payout and refund signing contexts.\n *\n * @param pubkeys - Array of x-only public keys (with or without `0x` prefix)\n * @returns Lex-sorted array of pubkeys with `0x` prefix stripped\n */\nexport function getSortedXOnlyPubkeys(pubkeys: string[]): string[] {\n  return pubkeys.map(stripHexPrefix).sort();\n}\n\n/**\n * Derive the BIP-86 P2TR scriptPubKey (`0x`-prefixed hex) from an x-only\n * public key.\n *\n * Matches Rust `Bip86KeyConnector::generate_taproot_script_pubkey`: a\n * keypath-only P2TR output with no script tree. Used to compute the expected\n * payout address for vault keeper claimers, whose payout goes to their own\n * BIP-86 address rather than the depositor's registered payout address.\n *\n * Network-agnostic: P2TR scriptPubKey bytes are `OP_1 <32-byte tweaked-key>`\n * regardless of network.\n *\n * @param xOnlyPubkeyHex - X-only public key (64 hex chars, with or without `0x` prefix)\n * @returns `0x`-prefixed P2TR scriptPubKey hex\n * @throws If `xOnlyPubkeyHex` is not exactly 64 hex chars after prefix stripping\n */\nexport function deriveBip86ScriptPubKeyHex(xOnlyPubkeyHex: string): string {\n  assertEccInitialized();\n  const cleanHex = stripHexPrefix(xOnlyPubkeyHex);\n  if (!/^[0-9a-fA-F]{64}$/.test(cleanHex)) {\n    throw new Error(\n      \"Invalid x-only pubkey: must be 64 hex characters (32 bytes, no 0x prefix)\",\n    );\n  }\n  const { output } = payments.p2tr({\n    internalPubkey: Buffer.from(cleanHex, \"hex\"),\n  });\n  if (!output) {\n    throw new Error(\"Failed to derive BIP-86 P2TR scriptPubKey\");\n  }\n  return `0x${output.toString(\"hex\")}`;\n}\n\n/**\n * Derive a Native SegWit (P2WPKH) address from a compressed public key.\n *\n * @param publicKeyHex - Compressed public key (66 hex chars, with or without 0x prefix)\n * @param network - Bitcoin network\n * @returns Native SegWit address (bc1q... / tb1q... / bcrt1q...)\n * @throws If publicKeyHex is not a compressed public key (66 hex chars)\n */\nexport function deriveNativeSegwitAddress(\n  publicKeyHex: string,\n  network: Network,\n): string {\n  const cleanHex = stripHexPrefix(publicKeyHex);\n  if (cleanHex.length !== 66) {\n    throw new Error(\n      `Native SegWit requires a compressed public key (66 hex chars), got ${cleanHex.length}`,\n    );\n  }\n  const { address } = payments.p2wpkh({\n    pubkey: Buffer.from(hexToUint8Array(cleanHex)),\n    network: getNetwork(network),\n  });\n  if (!address) {\n    throw new Error(\"Failed to derive native segwit address from public key\");\n  }\n  return address;\n}\n\n/**\n * Validate that a BTC address was derived from the given public key.\n *\n * Derives Taproot (P2TR) and Native SegWit (P2WPKH) addresses from the\n * public key and checks if the provided address matches any of them.\n *\n * P2WPKH derivation requires the full compressed key with explicit y-parity.\n * When only an x-only key is supplied, the y-parity is unknown and trying\n * both `02|x` and `03|x` would let an opposite-parity P2WPKH address — a\n * script the caller does NOT control — pass validation. We fail closed for\n * P2WPKH in that case; P2TR (which depends only on the x-coordinate) is\n * still validated and remains the supported path for Taproot wallets.\n *\n * @param address - BTC address to validate\n * @param publicKeyHex - Public key from the wallet (x-only 64 or compressed 66 hex chars)\n * @param network - Bitcoin network\n * @returns true if the address matches the public key\n */\nexport function isAddressFromPublicKey(\n  address: string,\n  publicKeyHex: string,\n  network: Network,\n): boolean {\n  const cleanHex = stripHexPrefix(publicKeyHex);\n\n  // P2TR — works with both x-only and compressed keys\n  try {\n    if (address === deriveTaprootAddress(cleanHex, network)) {\n      return true;\n    }\n  } catch {\n    // derivation failed, continue\n  }\n\n  // P2WPKH — only attempt when the caller supplied a parity-bearing\n  // compressed key. An x-only input is fail-closed here on purpose.\n  if (cleanHex.length === COMPRESSED_PUBKEY_HEX_LEN) {\n    try {\n      if (address === deriveNativeSegwitAddress(cleanHex, network)) {\n        return true;\n      }\n    } catch {\n      // derivation failed, continue\n    }\n  }\n\n  return false;\n}\n"],"names":["TAPSCRIPT_LEAF_VERSION","UNCOMPRESSED_PUBKEY_HEX_LEN","SCHNORR_SIG_HEX_LEN","stripHexPrefix","hex","ensureHexPrefix","hexToUint8Array","cleanHex","isValidHexRaw","bytes","i","uint8ArrayToHex","b","inputTxidHex","input","toXOnly","pubKey","processPublicKeyToXOnly","publicKeyHex","X_ONLY_PUBKEY_HEX_LEN","COMPRESSED_PUBKEY_HEX_LEN","pubkeyBytes","canonicalizeBtcPubkey","isValidHex","validateWalletPubkey","walletPubkeyRaw","expectedDepositorPubkey","walletPubkeyXOnly","depositorPubkey","SATOSHIS_PER_BTC","formatSatoshisToBtc","satoshis","whole","fractionStr","assertEccInitialized","payments","Buffer","e","getNetwork","network","networks","deriveTaprootAddress","xOnly","address","getSortedXOnlyPubkeys","pubkeys","deriveBip86ScriptPubKeyHex","xOnlyPubkeyHex","output","deriveNativeSegwitAddress","isAddressFromPublicKey"],"mappings":"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"}

package/dist/bitcoin-D-O2GjbC.cjs

@@ -0,0 +1,2 @@
+"use strict";const o=require("bitcoinjs-lib"),c=require("buffer"),s=require("./validation-C6XTfZak.cjs"),S=192,y=130,x=128;function i(e){return e.startsWith("0x")||e.startsWith("0X")?e.slice(2):e}function g(e){return e.startsWith("0x")?e:e.startsWith("0X")?`0x${e.slice(2)}`:`0x${e}`}function a(e){const t=i(e);if(!f(t))throw new Error(`Invalid hex string: ${e}`);const n=new Uint8Array(t.length/2);for(let r=0;r<t.length;r+=2)n[r/2]=parseInt(t.slice(r,r+2),16);return n}function l(e){return Array.from(e).map(t=>t.toString(16).padStart(2,"0")).join("")}function _(e){return l(new Uint8Array(e.hash).slice().reverse())}function p(e){return e.length===32?e:e.slice(1,33)}function f(e){return/^[0-9a-fA-F]*$/.test(e)&&e.length%2===0}function u(e){const t=i(e);if(!f(t))throw new Error(`Invalid hex characters in public key: ${e}`);if(t.length===s.X_ONLY_PUBKEY_HEX_LEN)return t;if(t.length!==s.COMPRESSED_PUBKEY_HEX_LEN&&t.length!==y)throw new Error(`Invalid public key length: ${t.length} (expected ${s.X_ONLY_PUBKEY_HEX_LEN}, ${s.COMPRESSED_PUBKEY_HEX_LEN}, or ${y} hex chars)`);const n=a(t);return l(p(n))}function k(e){return u(e).toLowerCase()}function H(e){const t=i(e);return f(t)}function v(e,t){if(!t)throw new Error("validateWalletPubkey requires expectedDepositorPubkey. Pass the on-chain registered depositor pubkey to avoid a self-comparison.");const n=u(e),r=t;if(n.toLowerCase()!==r.toLowerCase())throw new Error(`Wallet public key does not match vault depositor. Expected: ${r}, Got: ${n}. Please connect the wallet that was used to create this vault.`);return{walletPubkeyRaw:e,walletPubkeyXOnly:n,depositorPubkey:r}}const h=100000000n;function w(e){if(e<0n)return`-${w(-e)}`;const t=e/h;let r=(e%h).toString().padStart(8,"0");return r=r.replace(/0+$/,""),r.length>0?`${t}.${r}`:t.toString()}function d(){try{o.payments.p2tr({internalPubkey:c.Buffer.alloc(32,1)})}catch(e){if(e instanceof Error&&e.message.includes("No ECC Library provided"))throw new Error('ECC library not initialized. You must call initEccLib(ecc) from "bitcoinjs-lib" before using the SDK. See the ts-sdk README for setup instructions.')}}function E(e){switch(e){case"bitcoin":return o.networks.bitcoin;case"testnet":case"signet":return o.networks.testnet;case"regtest":return o.networks.regtest;default:throw new Error(`Unknown network: ${e}`)}}function P(e,t){d();const n=a(u(e)),{address:r}=o.payments.p2tr({internalPubkey:c.Buffer.from(n),network:E(t)});if(!r)throw new Error("Failed to derive taproot address from public key");return r}function m(e){return e.map(i).sort()}function A(e){d();const t=i(e);if(!/^[0-9a-fA-F]{64}$/.test(t))throw new Error("Invalid x-only pubkey: must be 64 hex characters (32 bytes, no 0x prefix)");const{output:n}=o.payments.p2tr({internalPubkey:c.Buffer.from(t,"hex")});if(!n)throw new Error("Failed to derive BIP-86 P2TR scriptPubKey");return`0x${n.toString("hex")}`}function b(e,t){const n=i(e);if(n.length!==66)throw new Error(`Native SegWit requires a compressed public key (66 hex chars), got ${n.length}`);const{address:r}=o.payments.p2wpkh({pubkey:c.Buffer.from(a(n)),network:E(t)});if(!r)throw new Error("Failed to derive native segwit address from public key");return r}function N(e,t,n){const r=i(t);try{if(e===P(r,n))return!0}catch{}if(r.length===s.COMPRESSED_PUBKEY_HEX_LEN)try{if(e===b(r,n))return!0}catch{}return!1}exports.SCHNORR_SIG_HEX_LEN=x;exports.TAPSCRIPT_LEAF_VERSION=S;exports.assertEccInitialized=d;exports.canonicalizeBtcPubkey=k;exports.deriveBip86ScriptPubKeyHex=A;exports.deriveNativeSegwitAddress=b;exports.deriveTaprootAddress=P;exports.ensureHexPrefix=g;exports.formatSatoshisToBtc=w;exports.getNetwork=E;exports.getSortedXOnlyPubkeys=m;exports.hexToUint8Array=a;exports.inputTxidHex=_;exports.isAddressFromPublicKey=N;exports.isValidHex=H;exports.processPublicKeyToXOnly=u;exports.stripHexPrefix=i;exports.toXOnly=p;exports.uint8ArrayToHex=l;exports.validateWalletPubkey=v;
+//# sourceMappingURL=bitcoin-D-O2GjbC.cjs.map

package/dist/bitcoin-D-O2GjbC.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitcoin-D-O2GjbC.cjs","sources":["../src/tbv/core/primitives/utils/bitcoin.ts"],"sourcesContent":["/**\n * Bitcoin Utilities\n *\n * Common pure utility functions for Bitcoin operations including:\n * - Public key conversions (x-only format)\n * - Hex string manipulation\n * - Uint8Array conversions and validation\n * - Address derivation and validation\n *\n * All functions are pure (no side effects) and work in Node.js, browsers,\n * and serverless environments.\n *\n * @module primitives/utils/bitcoin\n */\n\nimport { networks, payments } from \"bitcoinjs-lib\";\nimport { Buffer } from \"buffer\";\n\nimport type { Network } from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\nimport type { Hex } from \"viem\";\n\nimport {\n  COMPRESSED_PUBKEY_HEX_LEN,\n  X_ONLY_PUBKEY_HEX_LEN,\n} from \"../../utils/validation\";\n\n/**\n * BIP-341 Tapscript leaf version for script-path spends.\n * @see https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki\n * @see Rust: bitcoin::taproot::LeafVersion::TapScript\n */\nexport const TAPSCRIPT_LEAF_VERSION = 0xc0;\n\n/**\n * Hex-string length of a 65-byte SEC1-uncompressed secp256k1 public\n * key (`0x04` prefix + 32-byte x + 32-byte y). `2 * 65 = 130`.\n */\nconst UNCOMPRESSED_PUBKEY_HEX_LEN = 130;\n\n/**\n * Hex-string length of a 64-byte BIP-340 Schnorr signature. `2 * 64 = 128`.\n */\nexport const SCHNORR_SIG_HEX_LEN = 128;\n\n/**\n * Strip \"0x\" prefix from hex string if present.\n *\n * Bitcoin expects plain hex (no \"0x\" prefix), but frontend often uses\n * Ethereum-style \"0x\"-prefixed hex.\n *\n * @param hex - Hex string with or without \"0x\" prefix\n * @returns Hex string without \"0x\" prefix\n */\nexport function stripHexPrefix(hex: string): string {\n  return hex.startsWith(\"0x\") || hex.startsWith(\"0X\") ? hex.slice(2) : hex;\n}\n\n/**\n * Ensure \"0x\" prefix on a hex string, returning viem's Hex type.\n *\n * Ethereum/viem APIs expect `0x`-prefixed hex, but Bitcoin tooling\n * typically omits the prefix. This normalises either form.\n *\n * @param hex - Hex string with or without \"0x\" prefix\n * @returns `0x`-prefixed hex string typed as viem Hex\n */\nexport function ensureHexPrefix(hex: string): Hex {\n  if (hex.startsWith(\"0x\")) return hex as Hex;\n  if (hex.startsWith(\"0X\")) return `0x${hex.slice(2)}` as Hex;\n  return `0x${hex}` as Hex;\n}\n\n/**\n * Convert hex string to Uint8Array.\n *\n * @param hex - Hex string (with or without 0x prefix)\n * @returns Uint8Array\n * @throws If hex is invalid\n */\nexport function hexToUint8Array(hex: string): Uint8Array {\n  const cleanHex = stripHexPrefix(hex);\n  if (!isValidHexRaw(cleanHex)) {\n    throw new Error(`Invalid hex string: ${hex}`);\n  }\n  const bytes = new Uint8Array(cleanHex.length / 2);\n  for (let i = 0; i < cleanHex.length; i += 2) {\n    bytes[i / 2] = parseInt(cleanHex.slice(i, i + 2), 16);\n  }\n  return bytes;\n}\n\n/**\n * Convert Uint8Array to hex string (without 0x prefix).\n *\n * @param bytes - Uint8Array to convert\n * @returns Hex string without 0x prefix\n */\nexport function uint8ArrayToHex(bytes: Uint8Array): string {\n  return Array.from(bytes)\n    .map((b) => b.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n}\n\n/**\n * Read the prevout txid (big-endian hex) from a bitcoinjs-lib transaction input.\n *\n * bitcoinjs-lib stores `hash` in little-endian internal byte order; txids are\n * displayed in big-endian, so the bytes must be reversed before hex-encoding.\n *\n * @param input - Transaction input with a `hash` field (Buffer or Uint8Array)\n * @returns Prevout txid as a hex string (big-endian, no 0x prefix)\n */\nexport function inputTxidHex(input: { hash: Buffer | Uint8Array }): string {\n  return uint8ArrayToHex(new Uint8Array(input.hash).slice().reverse());\n}\n\n/**\n * Convert a 33-byte public key to 32-byte x-only format (removes first byte).\n *\n * Used for Taproot/Schnorr signatures which only need the x-coordinate.\n * If the input is already 32 bytes, returns it unchanged.\n *\n * @param pubKey - 33-byte or 32-byte public key\n * @returns 32-byte x-only public key\n */\nexport function toXOnly(pubKey: Uint8Array): Uint8Array {\n  return pubKey.length === 32 ? pubKey : pubKey.slice(1, 33);\n}\n\n/**\n * Internal helper: Validate hex string format without stripping prefix\n *\n * @internal\n * @param hex - Hex string (must already have prefix stripped)\n * @returns true if valid hex string\n */\nfunction isValidHexRaw(hex: string): boolean {\n  return /^[0-9a-fA-F]*$/.test(hex) && hex.length % 2 === 0;\n}\n\n/**\n * Process and convert a public key to x-only format (32 bytes hex).\n *\n * Handles:\n * - 0x prefix removal\n * - Hex character validation\n * - Length validation\n * - Conversion to x-only format\n *\n * Accepts:\n * - 64 hex chars (32 bytes) - already x-only\n * - 66 hex chars (33 bytes) - compressed pubkey\n * - 130 hex chars (65 bytes) - uncompressed pubkey\n *\n * @param publicKeyHex - Public key in hex format (with or without 0x prefix)\n * @returns X-only public key as 32 bytes hex string (without 0x prefix)\n * @throws If public key format is invalid or contains invalid hex characters\n */\nexport function processPublicKeyToXOnly(publicKeyHex: string): string {\n  // Remove '0x' prefix if present\n  const cleanHex = stripHexPrefix(publicKeyHex);\n\n  // Validate hex characters early to prevent silent failures\n  if (!isValidHexRaw(cleanHex)) {\n    throw new Error(`Invalid hex characters in public key: ${publicKeyHex}`);\n  }\n\n  // If already 64 chars (32 bytes), it's already x-only format\n  if (cleanHex.length === X_ONLY_PUBKEY_HEX_LEN) {\n    return cleanHex;\n  }\n\n  // Validate public key length (compressed SEC1 or uncompressed SEC1)\n  if (\n    cleanHex.length !== COMPRESSED_PUBKEY_HEX_LEN &&\n    cleanHex.length !== UNCOMPRESSED_PUBKEY_HEX_LEN\n  ) {\n    throw new Error(\n      `Invalid public key length: ${cleanHex.length} (expected ${X_ONLY_PUBKEY_HEX_LEN}, ${COMPRESSED_PUBKEY_HEX_LEN}, or ${UNCOMPRESSED_PUBKEY_HEX_LEN} hex chars)`,\n    );\n  }\n\n  const pubkeyBytes = hexToUint8Array(cleanHex);\n  return uint8ArrayToHex(toXOnly(pubkeyBytes));\n}\n\n/**\n * Normalize a public key to the one form two keys can be compared in:\n * lowercase x-only hex, no `0x`.\n *\n * `processPublicKeyToXOnly` returns already-x-only input untouched, so it\n * preserves case on that path — comparing its output directly is a latent\n * false mismatch for any source that serves uppercase hex. Every comparison\n * site therefore has to pair it with `.toLowerCase()`, and that pairing is\n * what this function exists to stop people re-deriving by hand.\n *\n * @param publicKeyHex - x-only, compressed, or uncompressed key, `0x` optional\n * @throws If the key is not valid hex or has an unexpected length\n */\nexport function canonicalizeBtcPubkey(publicKeyHex: string): string {\n  return processPublicKeyToXOnly(publicKeyHex).toLowerCase();\n}\n\n/**\n * Validate hex string format.\n *\n * Checks that the string contains only valid hexadecimal characters (0-9, a-f, A-F)\n * and has an even length (since each byte is represented by 2 hex characters).\n *\n * @param hex - String to validate (with or without 0x prefix)\n * @returns true if valid hex string\n */\nexport function isValidHex(hex: string): boolean {\n  const cleanHex = stripHexPrefix(hex);\n  return isValidHexRaw(cleanHex);\n}\n\n/**\n * Result of validating a wallet public key against an expected depositor public key.\n */\nexport interface WalletPubkeyValidationResult {\n  /** Wallet's raw public key (as returned by wallet, may be compressed) */\n  walletPubkeyRaw: string;\n  /** Wallet's public key in x-only format (32 bytes, 64 hex chars) */\n  walletPubkeyXOnly: string;\n  /** The validated depositor public key (x-only format) */\n  depositorPubkey: string;\n}\n\n/**\n * Validate that a wallet's public key matches the expected depositor public key.\n *\n * This function:\n * 1. Converts the wallet pubkey to x-only format\n * 2. Validates the wallet x-only pubkey matches the expected depositor pubkey\n *    (case-insensitive)\n *\n * @param walletPubkeyRaw - Raw public key from wallet (may be compressed 66 chars or x-only 64 chars)\n * @param expectedDepositorPubkey - Expected depositor public key (x-only).\n *   Required: omitting it would degrade this check to a self-comparison.\n * @returns Validation result with both pubkey formats\n * @throws If `expectedDepositorPubkey` is missing/empty\n * @throws If wallet pubkey doesn't match expected depositor pubkey\n */\nexport function validateWalletPubkey(\n  walletPubkeyRaw: string,\n  expectedDepositorPubkey: string,\n): WalletPubkeyValidationResult {\n  if (!expectedDepositorPubkey) {\n    throw new Error(\n      \"validateWalletPubkey requires expectedDepositorPubkey. Pass the on-chain registered depositor pubkey to avoid a self-comparison.\",\n    );\n  }\n\n  const walletPubkeyXOnly = processPublicKeyToXOnly(walletPubkeyRaw);\n  const depositorPubkey = expectedDepositorPubkey;\n\n  if (walletPubkeyXOnly.toLowerCase() !== depositorPubkey.toLowerCase()) {\n    throw new Error(\n      `Wallet public key does not match vault depositor. ` +\n        `Expected: ${depositorPubkey}, Got: ${walletPubkeyXOnly}. ` +\n        `Please connect the wallet that was used to create this vault.`,\n    );\n  }\n\n  return { walletPubkeyRaw, walletPubkeyXOnly, depositorPubkey };\n}\n\n// ============================================================================\n// BTC formatting\n// ============================================================================\n\nconst SATOSHIS_PER_BTC = 100_000_000n;\n\n/**\n * Format satoshis as a human-readable BTC string with trailing zeros removed.\n */\nexport function formatSatoshisToBtc(satoshis: bigint): string {\n  if (satoshis < 0n) {\n    return `-${formatSatoshisToBtc(-satoshis)}`;\n  }\n  const whole = satoshis / SATOSHIS_PER_BTC;\n  const fraction = satoshis % SATOSHIS_PER_BTC;\n  let fractionStr = fraction.toString().padStart(8, \"0\");\n  fractionStr = fractionStr.replace(/0+$/, \"\");\n  return fractionStr.length > 0 ? `${whole}.${fractionStr}` : whole.toString();\n}\n\n// ============================================================================\n// Address derivation and validation\n// ============================================================================\n\n/**\n * Assert that the ECC library has been initialized via `initEccLib(ecc)`.\n *\n * The consuming application must call `initEccLib(ecc)` from `bitcoinjs-lib`\n * once at startup before using any SDK function that involves Taproot / P2TR\n * operations. This guard provides a clear error message when that step was\n * missed, instead of letting bitcoinjs-lib throw its generic\n * \"No ECC Library provided\" error deep in a call stack.\n */\nexport function assertEccInitialized(): void {\n  try {\n    payments.p2tr({ internalPubkey: Buffer.alloc(32, 1) });\n  } catch (e) {\n    if (e instanceof Error && e.message.includes(\"No ECC Library provided\")) {\n      throw new Error(\n        \"ECC library not initialized. \" +\n          'You must call initEccLib(ecc) from \"bitcoinjs-lib\" before using the SDK. ' +\n          \"See the ts-sdk README for setup instructions.\",\n      );\n    }\n    // Any other error means ECC is loaded (e.g. invalid key is fine — ECC worked).\n  }\n}\n\n/**\n * Map SDK network type to bitcoinjs-lib Network object.\n *\n * @param network - Network type (\"bitcoin\", \"testnet\", \"signet\", \"regtest\")\n * @returns bitcoinjs-lib Network object\n */\nexport function getNetwork(network: Network): networks.Network {\n  switch (network) {\n    case \"bitcoin\":\n      return networks.bitcoin;\n    case \"testnet\":\n    case \"signet\":\n      return networks.testnet;\n    case \"regtest\":\n      return networks.regtest;\n    default:\n      throw new Error(`Unknown network: ${network}`);\n  }\n}\n\n/**\n * Derive a Taproot (P2TR) address from a public key.\n *\n * @param publicKeyHex - Compressed (66 hex) or x-only (64 hex) public key\n * @param network - Bitcoin network\n * @returns Taproot address (bc1p... / tb1p... / bcrt1p...)\n */\nexport function deriveTaprootAddress(\n  publicKeyHex: string,\n  network: Network,\n): string {\n  assertEccInitialized();\n  const xOnly = hexToUint8Array(processPublicKeyToXOnly(publicKeyHex));\n  const { address } = payments.p2tr({\n    internalPubkey: Buffer.from(xOnly),\n    network: getNetwork(network),\n  });\n  if (!address) {\n    throw new Error(\"Failed to derive taproot address from public key\");\n  }\n  return address;\n}\n\n/**\n * Strip `0x` prefixes and lex-sort an array of x-only public keys.\n *\n * Used to produce the canonical (Rust-parity) keeper / challenger ordering\n * the protocol expects in payout and refund signing contexts.\n *\n * @param pubkeys - Array of x-only public keys (with or without `0x` prefix)\n * @returns Lex-sorted array of pubkeys with `0x` prefix stripped\n */\nexport function getSortedXOnlyPubkeys(pubkeys: string[]): string[] {\n  return pubkeys.map(stripHexPrefix).sort();\n}\n\n/**\n * Derive the BIP-86 P2TR scriptPubKey (`0x`-prefixed hex) from an x-only\n * public key.\n *\n * Matches Rust `Bip86KeyConnector::generate_taproot_script_pubkey`: a\n * keypath-only P2TR output with no script tree. Used to compute the expected\n * payout address for vault keeper claimers, whose payout goes to their own\n * BIP-86 address rather than the depositor's registered payout address.\n *\n * Network-agnostic: P2TR scriptPubKey bytes are `OP_1 <32-byte tweaked-key>`\n * regardless of network.\n *\n * @param xOnlyPubkeyHex - X-only public key (64 hex chars, with or without `0x` prefix)\n * @returns `0x`-prefixed P2TR scriptPubKey hex\n * @throws If `xOnlyPubkeyHex` is not exactly 64 hex chars after prefix stripping\n */\nexport function deriveBip86ScriptPubKeyHex(xOnlyPubkeyHex: string): string {\n  assertEccInitialized();\n  const cleanHex = stripHexPrefix(xOnlyPubkeyHex);\n  if (!/^[0-9a-fA-F]{64}$/.test(cleanHex)) {\n    throw new Error(\n      \"Invalid x-only pubkey: must be 64 hex characters (32 bytes, no 0x prefix)\",\n    );\n  }\n  const { output } = payments.p2tr({\n    internalPubkey: Buffer.from(cleanHex, \"hex\"),\n  });\n  if (!output) {\n    throw new Error(\"Failed to derive BIP-86 P2TR scriptPubKey\");\n  }\n  return `0x${output.toString(\"hex\")}`;\n}\n\n/**\n * Derive a Native SegWit (P2WPKH) address from a compressed public key.\n *\n * @param publicKeyHex - Compressed public key (66 hex chars, with or without 0x prefix)\n * @param network - Bitcoin network\n * @returns Native SegWit address (bc1q... / tb1q... / bcrt1q...)\n * @throws If publicKeyHex is not a compressed public key (66 hex chars)\n */\nexport function deriveNativeSegwitAddress(\n  publicKeyHex: string,\n  network: Network,\n): string {\n  const cleanHex = stripHexPrefix(publicKeyHex);\n  if (cleanHex.length !== 66) {\n    throw new Error(\n      `Native SegWit requires a compressed public key (66 hex chars), got ${cleanHex.length}`,\n    );\n  }\n  const { address } = payments.p2wpkh({\n    pubkey: Buffer.from(hexToUint8Array(cleanHex)),\n    network: getNetwork(network),\n  });\n  if (!address) {\n    throw new Error(\"Failed to derive native segwit address from public key\");\n  }\n  return address;\n}\n\n/**\n * Validate that a BTC address was derived from the given public key.\n *\n * Derives Taproot (P2TR) and Native SegWit (P2WPKH) addresses from the\n * public key and checks if the provided address matches any of them.\n *\n * P2WPKH derivation requires the full compressed key with explicit y-parity.\n * When only an x-only key is supplied, the y-parity is unknown and trying\n * both `02|x` and `03|x` would let an opposite-parity P2WPKH address — a\n * script the caller does NOT control — pass validation. We fail closed for\n * P2WPKH in that case; P2TR (which depends only on the x-coordinate) is\n * still validated and remains the supported path for Taproot wallets.\n *\n * @param address - BTC address to validate\n * @param publicKeyHex - Public key from the wallet (x-only 64 or compressed 66 hex chars)\n * @param network - Bitcoin network\n * @returns true if the address matches the public key\n */\nexport function isAddressFromPublicKey(\n  address: string,\n  publicKeyHex: string,\n  network: Network,\n): boolean {\n  const cleanHex = stripHexPrefix(publicKeyHex);\n\n  // P2TR — works with both x-only and compressed keys\n  try {\n    if (address === deriveTaprootAddress(cleanHex, network)) {\n      return true;\n    }\n  } catch {\n    // derivation failed, continue\n  }\n\n  // P2WPKH — only attempt when the caller supplied a parity-bearing\n  // compressed key. An x-only input is fail-closed here on purpose.\n  if (cleanHex.length === COMPRESSED_PUBKEY_HEX_LEN) {\n    try {\n      if (address === deriveNativeSegwitAddress(cleanHex, network)) {\n        return true;\n      }\n    } catch {\n      // derivation failed, continue\n    }\n  }\n\n  return false;\n}\n"],"names":["TAPSCRIPT_LEAF_VERSION","UNCOMPRESSED_PUBKEY_HEX_LEN","SCHNORR_SIG_HEX_LEN","stripHexPrefix","hex","ensureHexPrefix","hexToUint8Array","cleanHex","isValidHexRaw","bytes","i","uint8ArrayToHex","b","inputTxidHex","input","toXOnly","pubKey","processPublicKeyToXOnly","publicKeyHex","X_ONLY_PUBKEY_HEX_LEN","COMPRESSED_PUBKEY_HEX_LEN","pubkeyBytes","canonicalizeBtcPubkey","isValidHex","validateWalletPubkey","walletPubkeyRaw","expectedDepositorPubkey","walletPubkeyXOnly","depositorPubkey","SATOSHIS_PER_BTC","formatSatoshisToBtc","satoshis","whole","fractionStr","assertEccInitialized","payments","Buffer","getNetwork","network","networks","deriveTaprootAddress","xOnly","address","getSortedXOnlyPubkeys","pubkeys","deriveBip86ScriptPubKeyHex","xOnlyPubkeyHex","output","deriveNativeSegwitAddress","isAddressFromPublicKey"],"mappings":"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"}

package/dist/{buildAndBroadcastReclaim-kBHwOL02.js → buildAndBroadcastReclaim-C0TdwO2M.js}

@@ -2,16 +2,17 @@ var Ee = Object.defineProperty;
 var ke = (e, t, r) => t in e ? Ee(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
 var C = (e, t, r) => ke(e, typeof t != "symbol" ? t + "" : t, r);
 import { B as ae } from "./BTCVaultRegistry.abi-CJwWI2EO.js";
-import { e as xe, v as Te, s as y, u as ie, p as O, c as x, f as R } from "./bitcoin-Ch_jxnDa.js";
-import { v as Ae, d as Re, s as Ce, P as _e, a as Se } from "./signPsbtsWithFallback-X6ivsbh7.js";
+import { e as xe, v as Te, s as y, u as ie, p as O, c as x, f as R } from "./bitcoin-C-TuHb-v.js";
+import { v as Ae, d as Re, s as Ce, P as _e, a as Se } from "./signPsbtsWithFallback-BjXdnI0X.js";
 import { zeroAddress as $e } from "viem";
 import { D as T, c as Be, b as Ie, R as Ve, d as ue } from "./json-rpc-client-DuUARJvV.js";
 import { Transaction as _, Psbt as le } from "bitcoinjs-lib";
-import { m as Ke, f as Oe, i as B, g as I, j as V } from "./verifyScriptPathSchnorrSignature-CQYucnJA.js";
-import { D as X, a as Ne } from "./constants-DRiWbItj.js";
-import { d as He, c as De, b as Fe, e as Me, a as Ue } from "./noPayout-BdATUPjF.js";
+import { m as Ke, f as Oe, i as B, g as I, j as V } from "./verifyScriptPathSchnorrSignature-ZAZfFJ6S.js";
+import { D as X } from "./constants-CPzppOdq.js";
+import { d as Ne, c as He, b as De, e as Fe, a as Me } from "./noPayout--lxo7qe4.js";
 import { c as K } from "./signing-DaLvGwQe.js";
-import { a as G } from "./onChainBtcPubkey-BAHZyKQL.js";
+import { a as G } from "./onChainBtcPubkey-DATNfAAl.js";
+import { a as Ue } from "./vaultCoreVersion-D_fP9P3C.js";
 const Le = /^0x[0-9a-fA-F]{64}$/, ze = /^0x[0-9a-fA-F]{40}$/, Xe = /^0x([0-9a-fA-F]{2})*$/;
 function N(e, t) {
   if (e.length !== 66)
@@ -44,7 +45,7 @@ function ce(e) {
     );
   return t;
 }
-async function qt(e) {
+async function jt(e) {
   const {
     btcVaultRegistryAddress: t,
     vaultId: r,
@@ -67,7 +68,7 @@ async function qt(e) {
     args: [r, n, a]
   });
 }
-async function jt(e) {
+async function Qt(e) {
   const { btcVaultRegistryAddress: t, vaultId: r, hashlock: o, writeContract: a, signal: l } = e;
   l == null || l.throwIfAborted();
   const s = ce({
@@ -97,14 +98,14 @@ class de extends Error {
 function Je(e) {
   return e instanceof he || e instanceof Error && e.name === "PeginRegistrationMissingError";
 }
-function Qt(e) {
+function Wt(e) {
   return e instanceof de || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
 }
 function q(e) {
   const { currentBlock: t, createdAtBlock: r } = e, o = t - r + 1n;
   return o < 0n ? 0 : Number(o);
 }
-async function Wt(e) {
+async function Yt(e) {
   const {
     vaultRegistryReader: t,
     getBlockNumber: r,
@@ -291,7 +292,7 @@ async function ot(e) {
     assertTxParsed: l,
     ctx: s
   } = e;
-  He(
+  Ne(
     t.nopayout_tx.tx_hex,
     r,
     s.network
@@ -334,7 +335,7 @@ async function ot(e) {
     script_pubkey: ie(new Uint8Array(c.script)),
     value: c.value
   }));
-  return De({
+  return He({
     noPayoutTxHex: t.nopayout_tx.tx_hex,
     challengerPubkey: r,
     prevouts: h,
@@ -590,7 +591,7 @@ async function dt(e, t, r, o) {
     };
   return o == null || o(l, l), n;
 }
-async function Yt(e) {
+async function Jt(e) {
   const {
     statusReader: t,
     presignClient: r,
@@ -679,7 +680,7 @@ const pt = 300 * 1e3, gt = /* @__PURE__ */ new Set([
   T.PENDING_DEPOSITOR_WOTS_PK,
   ...ue
 ]);
-async function Jt(e) {
+async function Zt(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
@@ -729,7 +730,7 @@ function F(e) {
 function W(e, t) {
   return e.length === t.length && e.every((r, o) => r === t[o]);
 }
-async function Zt(e) {
+async function er(e) {
   const {
     vaultProviderEthAddress: t,
     hintBtcPubkey: r,
@@ -820,7 +821,7 @@ async function vt(e) {
   });
 }
 const Y = (e) => e.map(x).sort();
-async function er(e) {
+async function tr(e) {
   const {
     vaultRegistryReader: t,
     vaultKeeperReader: r,
@@ -915,7 +916,7 @@ async function er(e) {
 function yt(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function tr(e) {
+function rr(e) {
   const {
     amountSats: t,
     minDeposit: r,
@@ -926,7 +927,7 @@ function tr(e) {
   } = e;
   return !(t <= 0n || t < r || o && o > 0n && t > o || l == null || s == null || t + l + s > a);
 }
-function rr(e, t, r) {
+function or(e, t, r) {
   return e <= 0n ? {
     valid: !1,
     error: "Deposit amount must be greater than zero"
@@ -938,7 +939,7 @@ function rr(e, t, r) {
     error: `Maximum deposit is ${R(r)} BTC`
   } : { valid: !0 };
 }
-function or(e) {
+function nr(e) {
   const { amount: t, effectiveRemaining: r } = e;
   return r === null ? { valid: !0 } : r === 0n ? {
     valid: !1,
@@ -948,7 +949,7 @@ function or(e) {
     error: `Vault size exceeds remaining capacity (${R(r)} BTC)`
   } : { valid: !0 };
 }
-function nr(e, t) {
+function sr(e, t) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -1013,7 +1014,7 @@ function xt(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function sr(e) {
+function ar(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
@@ -1039,13 +1040,13 @@ class me extends Error {
     super(t), this.name = "ParticipantKeyDriftError";
   }
 }
-function ar(e) {
+function ir(e) {
   return e instanceof me || e instanceof Error && e.name === "ParticipantKeyDriftError";
 }
 function J(e, t, r) {
   return t.length === r.length && t.every((o, a) => o === r[a]) ? null : `${e} expected [${t.join(", ")}], got [${r.join(", ")}]`;
 }
-async function ir(e) {
+async function ur(e) {
   const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: o, expected: a } = e, l = a.query;
   if (o.length === 0) return;
   const s = await t.getVaultKeyEpochsBatch(o), n = [];
@@ -1090,10 +1091,10 @@ class Pe extends Error {
     super(t), this.name = "RegisteredVaultVersionMismatchError";
   }
 }
-function ur(e) {
+function lr(e) {
   return e instanceof Pe || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function lr(e) {
+async function cr(e) {
   const {
     vaultRegistryReader: t,
     vaultIds: r,
@@ -1124,12 +1125,12 @@ const Tt = /* @__PURE__ */ new Set([
   "PayoutBlocked"
   /* PAYOUT_BLOCKED */
 ]);
-function cr(e) {
+function hr(e) {
   return Object.values(ve).includes(
     e
   );
 }
-function hr(e) {
+function dr(e) {
   return !!e && Tt.has(e);
 }
 class At extends Error {
@@ -1141,7 +1142,7 @@ class At extends Error {
   }
 }
 const Rt = /^0x[0-9a-fA-F]{64}$/, Ct = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, ye = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, be = 160, Z = 2e3, ee = 10n, te = 100n;
-function dr(e) {
+function pr(e) {
   if (!Number.isFinite(e) || e <= 0)
     throw new Error(
       `feeRateSatsVb must be a positive finite number, got ${e}`
@@ -1197,7 +1198,7 @@ function $t(e) {
   if (U(e.offchainParamsVersion, "offchainParamsVersion"), U(e.appVaultKeepersVersion, "appVaultKeepersVersion"), U(
     e.universalChallengersVersion,
     "universalChallengersVersion"
-  ), Ne(
+  ), Ue(
     e.vaultCoreVersion,
     "VaultRefundData.vaultCoreVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
@@ -1250,7 +1251,7 @@ function It(e) {
   }
   return t.extractTransaction().toHex();
 }
-async function pr(e) {
+async function gr(e) {
   const {
     vaultId: t,
     readVault: r,
@@ -1296,7 +1297,7 @@ async function pr(e) {
     throw new Error(
       `Funded Pre-PegIn tx has ${f.outs.length} outputs but batch requires at least ${i.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
     );
-  const { psbtHex: P } = await Fe({
+  const { psbtHex: P } = await De({
     prePeginParams: {
       vaultCoreVersion: i.vaultCoreVersion,
       depositorPubkey: d,
@@ -1367,7 +1368,7 @@ class re extends Error {
     this.name = "ReclaimUneconomicalError", this.feeSats = o, this.sweptTotalSats = a;
   }
 }
-const oe = 2e3, ne = 25n, se = 100n, gr = 10n;
+const oe = 2e3, ne = 25n, se = 100n, fr = 10n;
 function Vt(e) {
   const t = le.fromHex(e);
   try {
@@ -1379,7 +1380,7 @@ function Vt(e) {
   }
   return t.extractTransaction().toHex();
 }
-async function fr(e) {
+async function mr(e) {
   const {
     vaultIds: t,
     depositorBtcPubkey: r,
@@ -1408,7 +1409,7 @@ async function fr(e) {
     depositorSignedPeginTxHex: v.depositorSignedPeginTxHex,
     observed: v.observed,
     expectedValue: v.expectedClaimValue
-  })), c = Me(a, h.length), d = h.reduce((v, m) => v + m.expectedValue, 0n), p = d * ne / se;
+  })), c = Fe(a, h.length), d = h.reduce((v, m) => v + m.expectedValue, 0n), p = d * ne / se;
   if (c > p)
     throw new re(
       `Reclaim fee ${c} sats exceeds ${ne}/${se} of the swept total (${d} sats, cap ${p} sats). The reserve is not at risk — it stays where it is until fee rates fall.`,
@@ -1416,7 +1417,7 @@ async function fr(e) {
       d
     );
   n == null || n.throwIfAborted();
-  const { psbtHex: g } = Ue({
+  const { psbtHex: g } = Me({
     depositorPubkey: u,
     inputs: h,
     feeSats: c
@@ -1451,48 +1452,48 @@ export {
   Pt as C,
   vt as D,
   ve as E,
-  cr as F,
-  hr as G,
+  hr as F,
+  dr as G,
   At as H,
-  pr as I,
-  dr as J,
+  gr as I,
+  pr as J,
   te as K,
   ee as L,
   Z as M,
   be as N,
   re as O,
   je as P,
-  fr as Q,
+  mr as Q,
   Pe as R,
   se as S,
   ne as T,
   oe as U,
-  gr as V,
-  qt as a,
-  jt as b,
+  fr as V,
+  jt as a,
+  Qt as b,
   he as c,
   de as d,
-  Qt as e,
-  Jt as f,
-  tr as g,
-  rr as h,
+  Wt as e,
+  Zt as f,
+  rr as g,
+  or as h,
   Je as i,
-  sr as j,
-  nr as k,
-  or as l,
+  ar as j,
+  sr as k,
+  nr as l,
   bt as m,
   wt as n,
   me as o,
-  ar as p,
-  ir as q,
-  Yt as r,
+  ir as p,
+  ur as q,
+  Jt as r,
   st as s,
-  ur as t,
-  lr as u,
-  er as v,
-  Wt as w,
+  lr as t,
+  cr as u,
+  tr as v,
+  Yt as w,
   pe as x,
-  Zt as y,
+  er as y,
   D as z
 };
-//# sourceMappingURL=buildAndBroadcastReclaim-kBHwOL02.js.map
+//# sourceMappingURL=buildAndBroadcastReclaim-C0TdwO2M.js.map