@babylonlabs-io/ts-sdk 0.19.0 → 0.20.1

package/README.md

@@ -30,11 +30,30 @@ This SDK handles the complex Bitcoin and Ethereum interactions needed to create
 - **🧩 Modular Design** - Use only what you need via subpath exports
 - **🔧 Extensible** - Easy to build custom integrations
 
+## Platforms
+
+This SDK runs on **both Node.js backends and browser/React frontends** — the
+entire library is framework-agnostic. The *only* difference between the two
+environments is how you supply two things: a Bitcoin wallet and an Ethereum
+wallet. The SDK provides interfaces (`BitcoinWallet`, viem's `WalletClient`)
+and you adapt whichever wallet is available on your platform.
+
+| Concern | Node.js backend | Browser / React |
+|---------|-----------------|-----------------|
+| `BitcoinWallet` | Build from a seed via `bitcoinjs-lib` + `bip32` (or call KMS/HSM) | Adapt an injected wallet (Unisat, OKX, Xverse, Leather) |
+| viem `WalletClient` | `createWalletClient({ account: privateKeyToAccount(pk), chain, transport: http(RPC_URL) })` | `createWalletClient({ account, chain, transport: custom(window.ethereum) })` via wagmi |
+| Secret storage | Your DB / KMS (required for activation later) | Session/local storage or user-supplied |
+| WASM loading | Automatic (SDK reads `.wasm` off disk with `node:fs`) | Automatic (SDK fetches `.wasm` via bundler) |
+
+If you're using a bundler (Vite, webpack, Next.js), ensure it's configured to
+handle `.wasm` assets and that `Buffer` is available on the global in browser
+targets — see the [Troubleshooting Guide](./docs/get-started/troubleshooting.md).
+
 ## Installation
 
 ### Requirements
 
-- Node.js >= 24.0.0
+- **Node.js ≥ 20.3.0** (for `AbortSignal.any()`). Works on Node 20 LTS, 22 LTS, 24 LTS.
 - Package manager: npm, yarn, or pnpm
 
 ### Install
@@ -50,27 +69,34 @@ yarn add @babylonlabs-io/ts-sdk viem bitcoinjs-lib @bitcoin-js/tiny-secp256k1-as
 pnpm add @babylonlabs-io/ts-sdk viem bitcoinjs-lib @bitcoin-js/tiny-secp256k1-asmjs
 ```
 
-### ECC Library Initialization
+### ECC Library Initialization (required, once at startup)
 
-The SDK uses `bitcoinjs-lib` for Taproot (P2TR) operations, which requires an ECC library to be initialized **before** any SDK function that touches Bitcoin addresses or PSBTs. Your application must call `initEccLib()` once at startup:
+The SDK uses `bitcoinjs-lib` for Taproot operations. Call `initEccLib()` once
+at application startup **before any SDK call that builds a PSBT or derives a
+Bitcoin address**:
 
 ```typescript
 import * as ecc from "@bitcoin-js/tiny-secp256k1-asmjs";
 import { initEccLib } from "bitcoinjs-lib";
 
-// Call once at app startup, before any SDK usage
 initEccLib(ecc);
 ```
 
-For React apps, place this call in your entry point (e.g., `main.tsx`) before `createRoot()`. Failing to initialize will cause a runtime error: `"No ECC Library provided"`.
+- **Node.js**: call this at the top of your entry point (`index.ts` / CLI entry).
+- **React**: call it in `main.tsx` / `app.tsx` before `createRoot()`.
+
+Failing to initialize produces a runtime error: `"No ECC Library provided"`.
+
+The WASM package used internally (`@babylonlabs-io/babylon-tbv-rust-wasm`)
+initializes itself lazily — no extra call needed.
 
 ### Verify Installation
 
 ```typescript
-import { buildPeginPsbt } from "@babylonlabs-io/ts-sdk/tbv/core/primitives";
+import { buildPrePeginPsbt } from "@babylonlabs-io/ts-sdk/tbv/core/primitives";
 
 console.log("✅ SDK installed successfully!");
-console.log("buildPeginPsbt type:", typeof buildPeginPsbt);
+console.log("buildPrePeginPsbt type:", typeof buildPrePeginPsbt);
 ```
 
 Run with: `npx tsx verify-install.ts`
@@ -87,26 +113,44 @@ import { PeginManager, PayoutManager } from "@babylonlabs-io/ts-sdk/tbv/core";
 
 // Low-level primitives (advanced use cases)
 import {
-  buildPeginPsbt,
+  buildPrePeginPsbt,
+  buildPeginTxFromFundedPrePegin,
   buildPayoutPsbt,
   buildDepositorPayoutPsbt,
   buildNoPayoutPsbt,
   buildChallengeAssertPsbt,
+  buildRefundPsbt,
+  formatSatoshisToBtc,
 } from "@babylonlabs-io/ts-sdk/tbv/core/primitives";
 
+// Services (activation, deposit validation, protocol state)
+import {
+  activateVault,
+  getPeginProtocolState,
+  ContractStatus,
+  validateDepositAmount,
+  isPegoutTerminalStatus,
+} from "@babylonlabs-io/ts-sdk/tbv/core/services";
+
 // Utilities
-import { selectUtxosForPegin } from "@babylonlabs-io/ts-sdk/tbv/core";
+import {
+  selectUtxosForPegin,
+  collectReservedUtxoRefs,
+  validateUtxosAvailable,
+} from "@babylonlabs-io/ts-sdk/tbv/core";
 
-// Shared types and wallet interfaces
-import { BitcoinWallet, UTXO } from "@babylonlabs-io/ts-sdk/shared";
+// Shared wallet interfaces
+import { BitcoinWallet } from "@babylonlabs-io/ts-sdk/shared";
+// UTXO type lives in the core utils module
+import { UTXO } from "@babylonlabs-io/ts-sdk/tbv/core";
 
 // Contract ABIs
 import { BTCVaultRegistryABI } from "@babylonlabs-io/ts-sdk/tbv/core";
 
 // Protocol integrations (Aave)
 import {
-  buildAddCollateralTx,
   buildBorrowTx,
+  buildRepayTx,
   getUserAccountData,
   calculateHealthFactor,
 } from "@babylonlabs-io/ts-sdk/tbv/integrations/aave";

package/dist/bitcoin-CNnPFU6Y.cjs

@@ -0,0 +1,2 @@
+"use strict";const a=require("buffer"),i=require("bitcoinjs-lib"),k=192;function o(e){return e.startsWith("0x")||e.startsWith("0X")?e.slice(2):e}function E(e){return e.startsWith("0x")?e:e.startsWith("0X")?`0x${e.slice(2)}`:`0x${e}`}function s(e){const t=o(e);if(!l(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 h(e){return Array.from(e).map(t=>t.toString(16).padStart(2,"0")).join("")}function y(e){return e.length===32?e:e.slice(1,33)}function l(e){return/^[0-9a-fA-F]*$/.test(e)&&e.length%2===0}function u(e){const t=o(e);if(!l(t))throw new Error(`Invalid hex characters in public key: ${e}`);if(t.length===64)return t;if(t.length!==66&&t.length!==130)throw new Error(`Invalid public key length: ${t.length} (expected 64, 66, or 130 hex chars)`);const n=s(t);return h(y(n))}function x(e){const t=o(e);return l(t)}function S(e,t){const n=u(e),r=t??n;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 d=100000000n;function w(e){if(e<0n)return`-${w(-e)}`;const t=e/d;let r=(e%d).toString().padStart(8,"0");return r=r.replace(/0+$/,""),r.length>0?`${t}.${r}`:t.toString()}function m(){try{i.payments.p2tr({internalPubkey:a.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 f(e){switch(e){case"bitcoin":return i.networks.bitcoin;case"testnet":case"signet":return i.networks.testnet;case"regtest":return i.networks.regtest;default:throw new Error(`Unknown network: ${e}`)}}function p(e,t){m();const n=s(u(e)),{address:r}=i.payments.p2tr({internalPubkey:a.Buffer.from(n),network:f(t)});if(!r)throw new Error("Failed to derive taproot address from public key");return r}function g(e,t){const n=o(e);if(n.length!==66)throw new Error(`Native SegWit requires a compressed public key (66 hex chars), got ${n.length}`);const{address:r}=i.payments.p2wpkh({pubkey:a.Buffer.from(s(n)),network:f(t)});if(!r)throw new Error("Failed to derive native segwit address from public key");return r}function A(e,t,n){const r=o(t);try{if(e===p(r,n))return!0}catch{}const c=[];r.length===66?c.push(r):r.length===64&&c.push(`02${r}`,`03${r}`);for(const b of c)try{if(e===g(b,n))return!0}catch{}return!1}exports.TAPSCRIPT_LEAF_VERSION=k;exports.deriveNativeSegwitAddress=g;exports.deriveTaprootAddress=p;exports.ensureHexPrefix=E;exports.formatSatoshisToBtc=w;exports.getNetwork=f;exports.hexToUint8Array=s;exports.isAddressFromPublicKey=A;exports.isValidHex=x;exports.processPublicKeyToXOnly=u;exports.stripHexPrefix=o;exports.toXOnly=y;exports.uint8ArrayToHex=h;exports.validateWalletPubkey=S;
+//# sourceMappingURL=bitcoin-CNnPFU6Y.cjs.map

package/dist/bitcoin-CNnPFU6Y.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitcoin-CNnPFU6Y.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 { Buffer } from \"buffer\";\nimport { networks, payments } from \"bitcoinjs-lib\";\n\nimport type { Network } from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\nimport type { Hex } from \"viem\";\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 * 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 * 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 === 64) {\n    return cleanHex;\n  }\n\n  // Validate public key length (should be 66 chars for compressed or 130 for uncompressed)\n  if (cleanHex.length !== 66 && cleanHex.length !== 130) {\n    throw new Error(\n      `Invalid public key length: ${cleanHex.length} (expected 64, 66, or 130 hex chars)`,\n    );\n  }\n\n  const pubkeyBytes = hexToUint8Array(cleanHex);\n  return uint8ArrayToHex(toXOnly(pubkeyBytes));\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. Uses the expected depositor pubkey if provided, otherwise falls back to wallet pubkey\n * 3. Validates they match (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, optional)\n * @returns Validation result with both pubkey formats\n * @throws If wallet pubkey doesn't match expected depositor pubkey\n */\nexport function validateWalletPubkey(\n  walletPubkeyRaw: string,\n  expectedDepositorPubkey?: string,\n): WalletPubkeyValidationResult {\n  const walletPubkeyXOnly = processPublicKeyToXOnly(walletPubkeyRaw);\n  const depositorPubkey = expectedDepositorPubkey ?? walletPubkeyXOnly;\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 */\nfunction 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 * 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(\n      \"Failed to derive native segwit address from public key\",\n    );\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 * When the input is an x-only key (64 hex chars), both possible compressed\n * keys (`02` + x and `03` + x) are tried for Native SegWit derivation,\n * since the y-parity is unknown.\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  // Build the list of compressed keys to try for P2WPKH\n  const compressedKeys: string[] = [];\n  if (cleanHex.length === 66) {\n    compressedKeys.push(cleanHex);\n  } else if (cleanHex.length === 64) {\n    // x-only key — try both even (02) and odd (03) y-parity\n    compressedKeys.push(`02${cleanHex}`, `03${cleanHex}`);\n  }\n\n  for (const key of compressedKeys) {\n    try {\n      if (address === deriveNativeSegwitAddress(key, network)) {\n        return true;\n      }\n    } catch {\n      // derivation failed, continue\n    }\n  }\n\n  return false;\n}\n"],"names":["TAPSCRIPT_LEAF_VERSION","stripHexPrefix","hex","ensureHexPrefix","hexToUint8Array","cleanHex","isValidHexRaw","bytes","i","uint8ArrayToHex","b","toXOnly","pubKey","processPublicKeyToXOnly","publicKeyHex","pubkeyBytes","isValidHex","validateWalletPubkey","walletPubkeyRaw","expectedDepositorPubkey","walletPubkeyXOnly","depositorPubkey","SATOSHIS_PER_BTC","formatSatoshisToBtc","satoshis","whole","fractionStr","assertEccInitialized","payments","Buffer","getNetwork","network","networks","deriveTaprootAddress","xOnly","address","deriveNativeSegwitAddress","isAddressFromPublicKey","compressedKeys","key"],"mappings":"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"}

package/dist/{constants-Q7v2O7Ps.js → bitcoin-nOOgeRyl.js}

@@ -1,33 +1,33 @@
 import { Buffer as a } from "buffer";
-import { payments as c, networks as i } from "bitcoinjs-lib";
-const k = 192;
-function s(t) {
+import { payments as c, networks as s } from "bitcoinjs-lib";
+const $ = 192;
+function o(t) {
   return t.startsWith("0x") || t.startsWith("0X") ? t.slice(2) : t;
 }
-function P(t) {
-  return t.startsWith("0x") ? t : `0x${t}`;
+function v(t) {
+  return t.startsWith("0x") ? t : t.startsWith("0X") ? `0x${t.slice(2)}` : `0x${t}`;
 }
-function u(t) {
-  const e = s(t);
-  if (!l(e))
+function l(t) {
+  const e = o(t);
+  if (!u(e))
     throw new Error(`Invalid hex string: ${t}`);
   const n = new Uint8Array(e.length / 2);
   for (let r = 0; r < e.length; r += 2)
     n[r / 2] = parseInt(e.slice(r, r + 2), 16);
   return n;
 }
-function h(t) {
+function w(t) {
   return Array.from(t).map((e) => e.toString(16).padStart(2, "0")).join("");
 }
-function p(t) {
+function g(t) {
   return t.length === 32 ? t : t.slice(1, 33);
 }
-function l(t) {
+function u(t) {
   return /^[0-9a-fA-F]*$/.test(t) && t.length % 2 === 0;
 }
-function f(t) {
-  const e = s(t);
-  if (!l(e))
+function d(t) {
+  const e = o(t);
+  if (!u(e))
     throw new Error(`Invalid hex characters in public key: ${t}`);
   if (e.length === 64)
     return e;
@@ -35,22 +35,30 @@ function f(t) {
     throw new Error(
       `Invalid public key length: ${e.length} (expected 64, 66, or 130 hex chars)`
     );
-  const n = u(e);
-  return h(p(n));
+  const n = l(e);
+  return w(g(n));
 }
-function m(t) {
-  const e = s(t);
-  return l(e);
+function x(t) {
+  const e = o(t);
+  return u(e);
 }
-function x(t, e) {
-  const n = f(t), r = e ?? n;
+function A(t, e) {
+  const n = d(t), r = e ?? n;
   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: t, walletPubkeyXOnly: n, depositorPubkey: r };
 }
-function w() {
+const f = 100000000n;
+function y(t) {
+  if (t < 0n)
+    return `-${y(-t)}`;
+  const e = t / f;
+  let r = (t % f).toString().padStart(8, "0");
+  return r = r.replace(/0+$/, ""), r.length > 0 ? `${e}.${r}` : e.toString();
+}
+function b() {
   try {
     c.p2tr({ internalPubkey: a.alloc(32, 1) });
   } catch (t) {
@@ -60,38 +68,38 @@ function w() {
       );
   }
 }
-function E(t) {
+function h(t) {
   switch (t) {
     case "bitcoin":
-      return i.bitcoin;
+      return s.bitcoin;
     case "testnet":
     case "signet":
-      return i.testnet;
+      return s.testnet;
     case "regtest":
-      return i.regtest;
+      return s.regtest;
     default:
       throw new Error(`Unknown network: ${t}`);
   }
 }
-function T(t, e) {
-  w();
-  const n = u(f(t)), { address: r } = c.p2tr({
+function E(t, e) {
+  b();
+  const n = l(d(t)), { address: r } = c.p2tr({
     internalPubkey: a.from(n),
-    network: E(e)
+    network: h(e)
   });
   if (!r)
     throw new Error("Failed to derive taproot address from public key");
   return r;
 }
-function _(t, e) {
-  const n = s(t);
+function k(t, e) {
+  const n = o(t);
   if (n.length !== 66)
     throw new Error(
       `Native SegWit requires a compressed public key (66 hex chars), got ${n.length}`
     );
   const { address: r } = c.p2wpkh({
-    pubkey: a.from(u(n)),
-    network: E(e)
+    pubkey: a.from(l(n)),
+    network: h(e)
   });
   if (!r)
     throw new Error(
@@ -99,57 +107,37 @@ function _(t, e) {
     );
   return r;
 }
-function F(t, e, n) {
-  const r = s(e);
+function P(t, e, n) {
+  const r = o(e);
   try {
-    if (t === T(r, n))
+    if (t === E(r, n))
       return !0;
   } catch {
   }
-  const o = [];
-  r.length === 66 ? o.push(r) : r.length === 64 && o.push(`02${r}`, `03${r}`);
-  for (const d of o)
+  const i = [];
+  r.length === 66 ? i.push(r) : r.length === 64 && i.push(`02${r}`, `03${r}`);
+  for (const p of i)
     try {
-      if (t === _(d, n))
+      if (t === k(p, n))
         return !0;
     } catch {
     }
   return !1;
 }
-const L = 58, v = 43, R = 11, y = 546, H = BigInt(y), g = 30, A = 2, O = 1.1;
-function U(t) {
-  return t <= A ? g : 0;
-}
-const S = 1;
-function C(t) {
-  return t + S;
-}
-const N = 5;
 export {
-  y as B,
-  H as D,
-  O as F,
-  g as L,
-  v as M,
-  L as P,
-  N as S,
-  R as T,
-  A as W,
-  T as a,
-  m as b,
-  S as c,
-  _ as d,
-  P as e,
-  C as f,
-  E as g,
-  u as h,
-  F as i,
-  k as j,
-  f as p,
-  U as r,
-  s,
-  p as t,
-  h as u,
-  x as v
+  $ as T,
+  E as a,
+  x as b,
+  k as d,
+  v as e,
+  y as f,
+  h as g,
+  l as h,
+  P as i,
+  d as p,
+  o as s,
+  g as t,
+  w as u,
+  A as v
 };
-//# sourceMappingURL=constants-Q7v2O7Ps.js.map
+//# sourceMappingURL=bitcoin-nOOgeRyl.js.map

package/dist/bitcoin-nOOgeRyl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitcoin-nOOgeRyl.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 { Buffer } from \"buffer\";\nimport { networks, payments } from \"bitcoinjs-lib\";\n\nimport type { Network } from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\nimport type { Hex } from \"viem\";\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 * 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 * 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 === 64) {\n    return cleanHex;\n  }\n\n  // Validate public key length (should be 66 chars for compressed or 130 for uncompressed)\n  if (cleanHex.length !== 66 && cleanHex.length !== 130) {\n    throw new Error(\n      `Invalid public key length: ${cleanHex.length} (expected 64, 66, or 130 hex chars)`,\n    );\n  }\n\n  const pubkeyBytes = hexToUint8Array(cleanHex);\n  return uint8ArrayToHex(toXOnly(pubkeyBytes));\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. Uses the expected depositor pubkey if provided, otherwise falls back to wallet pubkey\n * 3. Validates they match (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, optional)\n * @returns Validation result with both pubkey formats\n * @throws If wallet pubkey doesn't match expected depositor pubkey\n */\nexport function validateWalletPubkey(\n  walletPubkeyRaw: string,\n  expectedDepositorPubkey?: string,\n): WalletPubkeyValidationResult {\n  const walletPubkeyXOnly = processPublicKeyToXOnly(walletPubkeyRaw);\n  const depositorPubkey = expectedDepositorPubkey ?? walletPubkeyXOnly;\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 */\nfunction 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 * 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(\n      \"Failed to derive native segwit address from public key\",\n    );\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 * When the input is an x-only key (64 hex chars), both possible compressed\n * keys (`02` + x and `03` + x) are tried for Native SegWit derivation,\n * since the y-parity is unknown.\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  // Build the list of compressed keys to try for P2WPKH\n  const compressedKeys: string[] = [];\n  if (cleanHex.length === 66) {\n    compressedKeys.push(cleanHex);\n  } else if (cleanHex.length === 64) {\n    // x-only key — try both even (02) and odd (03) y-parity\n    compressedKeys.push(`02${cleanHex}`, `03${cleanHex}`);\n  }\n\n  for (const key of compressedKeys) {\n    try {\n      if (address === deriveNativeSegwitAddress(key, network)) {\n        return true;\n      }\n    } catch {\n      // derivation failed, continue\n    }\n  }\n\n  return false;\n}\n"],"names":["TAPSCRIPT_LEAF_VERSION","stripHexPrefix","hex","ensureHexPrefix","hexToUint8Array","cleanHex","isValidHexRaw","bytes","i","uint8ArrayToHex","b","toXOnly","pubKey","processPublicKeyToXOnly","publicKeyHex","pubkeyBytes","isValidHex","validateWalletPubkey","walletPubkeyRaw","expectedDepositorPubkey","walletPubkeyXOnly","depositorPubkey","SATOSHIS_PER_BTC","formatSatoshisToBtc","satoshis","whole","fractionStr","assertEccInitialized","payments","Buffer","e","getNetwork","network","networks","deriveTaprootAddress","xOnly","address","deriveNativeSegwitAddress","isAddressFromPublicKey","compressedKeys","key"],"mappings":"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"}

package/dist/buildAndBroadcastRefund-DWEQvj9T.cjs

@@ -0,0 +1,2 @@
+"use strict";var Ct=Object.defineProperty;var Lt=(t,e,r)=>e in t?Ct(t,e,{enumerable:!0,configurable:!0,writable:!0,value:r}):t[e]=r;var f=(t,e,r)=>Lt(t,typeof e!="symbol"?e+"":e,r);const m=require("./types-B-p4dhEH.cjs"),d=require("./bitcoin-CNnPFU6Y.cjs"),N=require("bitcoinjs-lib"),bt=require("buffer"),W=require("./signing-cl-lowxV.cjs");require("@babylonlabs-io/babylon-tbv-rust-wasm");const $=require("./payout-RFIh7GLN.cjs");function $t(t){const e=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(t){for(const r in t)if(r!=="default"){const n=Object.getOwnPropertyDescriptor(t,r);Object.defineProperty(e,r,n.get?n:{enumerable:!0,get:()=>t[r]})}}return e.default=t,Object.freeze(e)}const Ot=$t(N);class xt{constructor(e){f(this,"config");this.config=e}async signPayoutTransaction(e){this.validatePayoutOutputs(e.payoutTxHex,e.registeredPayoutScriptPubKey);const r=await this.config.btcWallet.getPublicKeyHex(),{depositorPubkey:n}=d.validateWalletPubkey(r,e.depositorBtcPubkey),o=await $.buildPayoutPsbt({payoutTxHex:e.payoutTxHex,peginTxHex:e.peginTxHex,assertTxHex:e.assertTxHex,depositorBtcPubkey:n,vaultProviderBtcPubkey:e.vaultProviderBtcPubkey,vaultKeeperBtcPubkeys:e.vaultKeeperBtcPubkeys,universalChallengerBtcPubkeys:e.universalChallengerBtcPubkeys,timelockPegin:e.timelockPegin,network:this.config.network}),c=await this.config.btcWallet.signPsbt(o.psbtHex,W.createTaprootScriptPathSignOptions(r,1));return{signature:$.extractPayoutSignature(c,n),depositorBtcPubkey:n}}getNetwork(){return this.config.network}supportsBatchSigning(){return typeof this.config.btcWallet.signPsbts=="function"}async signPayoutTransactionsBatch(e){if(!this.supportsBatchSigning())throw new Error("Wallet does not support batch signing (signPsbts method not available)");const r=await this.config.btcWallet.getPublicKeyHex(),n=[],o=[],c=[];for(const s of e){this.validatePayoutOutputs(s.payoutTxHex,s.registeredPayoutScriptPubKey);const{depositorPubkey:u}=d.validateWalletPubkey(r,s.depositorBtcPubkey);c.push(u);const h=await $.buildPayoutPsbt({payoutTxHex:s.payoutTxHex,peginTxHex:s.peginTxHex,assertTxHex:s.assertTxHex,depositorBtcPubkey:u,vaultProviderBtcPubkey:s.vaultProviderBtcPubkey,vaultKeeperBtcPubkeys:s.vaultKeeperBtcPubkeys,universalChallengerBtcPubkeys:s.universalChallengerBtcPubkeys,timelockPegin:s.timelockPegin,network:this.config.network});n.push(h.psbtHex),o.push(W.createTaprootScriptPathSignOptions(r,1))}const a=await this.config.btcWallet.signPsbts(n,o);if(a.length!==e.length)throw new Error(`Expected ${e.length} signed PSBTs but received ${a.length}`);const i=[];for(let s=0;s<e.length;s++){const u=c[s],h=$.extractPayoutSignature(a[s],u);i.push({payoutSignature:h,depositorBtcPubkey:u})}return i}validatePayoutOutputs(e,r){if(!d.isValidHex(r))throw new Error("Invalid registeredPayoutScriptPubKey: not valid hex");const n=bt.Buffer.from(d.stripHexPrefix(r),"hex"),o=N.Transaction.fromHex(d.stripHexPrefix(e));if(o.outs.length===0)throw new Error("Payout transaction has no outputs");if(!o.outs.reduce((a,i)=>i.value>a.value?i:a).script.equals(n))throw new Error("Payout transaction does not pay to the registered depositor payout address")}}function Rt(t){return t instanceof Uint8Array||ArrayBuffer.isView(t)&&t.constructor.name==="Uint8Array"}function Z(t,e=""){if(!Number.isSafeInteger(t)||t<0){const r=e&&`"${e}" `;throw new Error(`${r}expected integer >= 0, got ${t}`)}}function z(t,e,r=""){const n=Rt(t),o=t==null?void 0:t.length,c=e!==void 0;if(!n||c&&o!==e){const a=r&&`"${r}" `,i=c?` of length ${e}`:"",s=n?`length=${o}`:`type=${typeof t}`;throw new Error(a+"expected Uint8Array"+i+", got "+s)}return t}function Dt(t){if(typeof t!="function"||typeof t.create!="function")throw new Error("Hash must wrapped by utils.createHasher");Z(t.outputLen),Z(t.blockLen)}function tt(t,e=!0){if(t.destroyed)throw new Error("Hash instance has been destroyed");if(e&&t.finished)throw new Error("Hash#digest() has already been called")}function pt(t,e){z(t,void 0,"digestInto() output");const r=e.outputLen;if(t.length<r)throw new Error('"digestInto() output" expected to be of length >='+r)}function Nt(t){return new Uint32Array(t.buffer,t.byteOffset,Math.floor(t.byteLength/4))}function D(...t){for(let e=0;e<t.length;e++)t[e].fill(0)}function G(t){return new DataView(t.buffer,t.byteOffset,t.byteLength)}function S(t,e){return t<<32-e|t>>>e}function Ut(t,e){return t<<e|t>>>32-e>>>0}const Vt=new Uint8Array(new Uint32Array([287454020]).buffer)[0]===68;function Kt(t){return t<<24&4278190080|t<<8&16711680|t>>>8&65280|t>>>24&255}function Ft(t){for(let e=0;e<t.length;e++)t[e]=Kt(t[e]);return t}const Mt=Vt?t=>t:Ft;function Gt(t){if(typeof t!="string")throw new Error("string expected");return new Uint8Array(new TextEncoder().encode(t))}function Wt(t,e=""){return typeof t=="string"?Gt(t):z(t,void 0,e)}function zt(t,e){if(e!==void 0&&{}.toString.call(e)!=="[object Object]")throw new Error("options must be object or undefined");return Object.assign(t,e)}function rt(t,e={}){const r=(o,c)=>t(c).update(o).digest(),n=t(void 0);return r.outputLen=n.outputLen,r.blockLen=n.blockLen,r.create=o=>t(o),Object.assign(r,e),Object.freeze(r)}const gt=t=>({oid:Uint8Array.from([6,9,96,134,72,1,101,3,4,2,t])});function Xt(t,e,r){return t&e^~t&r}function jt(t,e,r){return t&e^t&r^e&r}class nt{constructor(e,r,n,o){f(this,"blockLen");f(this,"outputLen");f(this,"padOffset");f(this,"isLE");f(this,"buffer");f(this,"view");f(this,"finished",!1);f(this,"length",0);f(this,"pos",0);f(this,"destroyed",!1);this.blockLen=e,this.outputLen=r,this.padOffset=n,this.isLE=o,this.buffer=new Uint8Array(e),this.view=G(this.buffer)}update(e){tt(this),z(e);const{view:r,buffer:n,blockLen:o}=this,c=e.length;for(let a=0;a<c;){const i=Math.min(o-this.pos,c-a);if(i===o){const s=G(e);for(;o<=c-a;a+=o)this.process(s,a);continue}n.set(e.subarray(a,a+i),this.pos),this.pos+=i,a+=i,this.pos===o&&(this.process(r,0),this.pos=0)}return this.length+=e.length,this.roundClean(),this}digestInto(e){tt(this),pt(e,this),this.finished=!0;const{buffer:r,view:n,blockLen:o,isLE:c}=this;let{pos:a}=this;r[a++]=128,D(this.buffer.subarray(a)),this.padOffset>o-a&&(this.process(n,0),a=0);for(let l=a;l<o;l++)r[l]=0;n.setBigUint64(o-8,BigInt(this.length*8),c),this.process(n,0);const i=G(e),s=this.outputLen;if(s%4)throw new Error("_sha2: outputLen must be aligned to 32bit");const u=s/4,h=this.get();if(u>h.length)throw new Error("_sha2: outputLen bigger than state");for(let l=0;l<u;l++)i.setUint32(4*l,h[l],c)}digest(){const{buffer:e,outputLen:r}=this;this.digestInto(e);const n=e.slice(0,r);return this.destroy(),n}_cloneInto(e){e||(e=new this.constructor),e.set(...this.get());const{blockLen:r,buffer:n,length:o,finished:c,destroyed:a,pos:i}=this;return e.destroyed=a,e.finished=c,e.length=o,e.pos=i,o%r&&e.buffer.set(n),e}clone(){return this._cloneInto()}}const k=Uint32Array.from([1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225]),P=Uint32Array.from([1779033703,4089235720,3144134277,2227873595,1013904242,4271175723,2773480762,1595750129,1359893119,2917565137,2600822924,725511199,528734635,4215389547,1541459225,327033209]),K=BigInt(2**32-1),at=BigInt(32);function qt(t,e=!1){return e?{h:Number(t&K),l:Number(t>>at&K)}:{h:Number(t>>at&K)|0,l:Number(t&K)|0}}function yt(t,e=!1){const r=t.length;let n=new Uint32Array(r),o=new Uint32Array(r);for(let c=0;c<r;c++){const{h:a,l:i}=qt(t[c],e);[n[c],o[c]]=[a,i]}return[n,o]}const ct=(t,e,r)=>t>>>r,ut=(t,e,r)=>t<<32-r|e>>>r,O=(t,e,r)=>t>>>r|e<<32-r,R=(t,e,r)=>t<<32-r|e>>>r,F=(t,e,r)=>t<<64-r|e>>>r-32,M=(t,e,r)=>t>>>r-32|e<<64-r,Yt=(t,e,r)=>t<<r|e>>>32-r,Qt=(t,e,r)=>e<<r|t>>>32-r,Jt=(t,e,r)=>e<<r-32|t>>>64-r,Zt=(t,e,r)=>t<<r-32|e>>>64-r;function v(t,e,r,n){const o=(e>>>0)+(n>>>0);return{h:t+r+(o/2**32|0)|0,l:o|0}}const te=(t,e,r)=>(t>>>0)+(e>>>0)+(r>>>0),ee=(t,e,r,n)=>e+r+n+(t/2**32|0)|0,re=(t,e,r,n)=>(t>>>0)+(e>>>0)+(r>>>0)+(n>>>0),ne=(t,e,r,n,o)=>e+r+n+o+(t/2**32|0)|0,oe=(t,e,r,n,o)=>(t>>>0)+(e>>>0)+(r>>>0)+(n>>>0)+(o>>>0),se=(t,e,r,n,o,c)=>e+r+n+o+c+(t/2**32|0)|0,ie=Uint32Array.from([1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298]),_=new Uint32Array(64);class ae extends nt{constructor(e){super(64,e,8,!1)}get(){const{A:e,B:r,C:n,D:o,E:c,F:a,G:i,H:s}=this;return[e,r,n,o,c,a,i,s]}set(e,r,n,o,c,a,i,s){this.A=e|0,this.B=r|0,this.C=n|0,this.D=o|0,this.E=c|0,this.F=a|0,this.G=i|0,this.H=s|0}process(e,r){for(let l=0;l<16;l++,r+=4)_[l]=e.getUint32(r,!1);for(let l=16;l<64;l++){const b=_[l-15],p=_[l-2],y=S(b,7)^S(b,18)^b>>>3,g=S(p,17)^S(p,19)^p>>>10;_[l]=g+_[l-7]+y+_[l-16]|0}let{A:n,B:o,C:c,D:a,E:i,F:s,G:u,H:h}=this;for(let l=0;l<64;l++){const b=S(i,6)^S(i,11)^S(i,25),p=h+b+Xt(i,s,u)+ie[l]+_[l]|0,g=(S(n,2)^S(n,13)^S(n,22))+jt(n,o,c)|0;h=u,u=s,s=i,i=a+p|0,a=c,c=o,o=n,n=p+g|0}n=n+this.A|0,o=o+this.B|0,c=c+this.C|0,a=a+this.D|0,i=i+this.E|0,s=s+this.F|0,u=u+this.G|0,h=h+this.H|0,this.set(n,o,c,a,i,s,u,h)}roundClean(){D(_)}destroy(){this.set(0,0,0,0,0,0,0,0),D(this.buffer)}}class ce extends ae{constructor(){super(32);f(this,"A",k[0]|0);f(this,"B",k[1]|0);f(this,"C",k[2]|0);f(this,"D",k[3]|0);f(this,"E",k[4]|0);f(this,"F",k[5]|0);f(this,"G",k[6]|0);f(this,"H",k[7]|0)}}const Pt=yt(["0x428a2f98d728ae22","0x7137449123ef65cd","0xb5c0fbcfec4d3b2f","0xe9b5dba58189dbbc","0x3956c25bf348b538","0x59f111f1b605d019","0x923f82a4af194f9b","0xab1c5ed5da6d8118","0xd807aa98a3030242","0x12835b0145706fbe","0x243185be4ee4b28c","0x550c7dc3d5ffb4e2","0x72be5d74f27b896f","0x80deb1fe3b1696b1","0x9bdc06a725c71235","0xc19bf174cf692694","0xe49b69c19ef14ad2","0xefbe4786384f25e3","0x0fc19dc68b8cd5b5","0x240ca1cc77ac9c65","0x2de92c6f592b0275","0x4a7484aa6ea6e483","0x5cb0a9dcbd41fbd4","0x76f988da831153b5","0x983e5152ee66dfab","0xa831c66d2db43210","0xb00327c898fb213f","0xbf597fc7beef0ee4","0xc6e00bf33da88fc2","0xd5a79147930aa725","0x06ca6351e003826f","0x142929670a0e6e70","0x27b70a8546d22ffc","0x2e1b21385c26c926","0x4d2c6dfc5ac42aed","0x53380d139d95b3df","0x650a73548baf63de","0x766a0abb3c77b2a8","0x81c2c92e47edaee6","0x92722c851482353b","0xa2bfe8a14cf10364","0xa81a664bbc423001","0xc24b8b70d0f89791","0xc76c51a30654be30","0xd192e819d6ef5218","0xd69906245565a910","0xf40e35855771202a","0x106aa07032bbd1b8","0x19a4c116b8d2d0c8","0x1e376c085141ab53","0x2748774cdf8eeb99","0x34b0bcb5e19b48a8","0x391c0cb3c5c95a63","0x4ed8aa4ae3418acb","0x5b9cca4f7763e373","0x682e6ff3d6b2b8a3","0x748f82ee5defb2fc","0x78a5636f43172f60","0x84c87814a1f0ab72","0x8cc702081a6439ec","0x90befffa23631e28","0xa4506cebde82bde9","0xbef9a3f7b2c67915","0xc67178f2e372532b","0xca273eceea26619c","0xd186b8c721c0c207","0xeada7dd6cde0eb1e","0xf57d4f7fee6ed178","0x06f067aa72176fba","0x0a637dc5a2c898a6","0x113f9804bef90dae","0x1b710b35131c471b","0x28db77f523047d84","0x32caab7b40c72493","0x3c9ebe0a15c9bebc","0x431d67c49c100d4c","0x4cc5d4becb3e42b6","0x597f299cfc657e2a","0x5fcb6fab3ad6faec","0x6c44198c4a475817"].map(t=>BigInt(t))),ue=Pt[0],le=Pt[1],I=new Uint32Array(80),C=new Uint32Array(80);class fe extends nt{constructor(e){super(128,e,16,!1)}get(){const{Ah:e,Al:r,Bh:n,Bl:o,Ch:c,Cl:a,Dh:i,Dl:s,Eh:u,El:h,Fh:l,Fl:b,Gh:p,Gl:y,Hh:g,Hl:w}=this;return[e,r,n,o,c,a,i,s,u,h,l,b,p,y,g,w]}set(e,r,n,o,c,a,i,s,u,h,l,b,p,y,g,w){this.Ah=e|0,this.Al=r|0,this.Bh=n|0,this.Bl=o|0,this.Ch=c|0,this.Cl=a|0,this.Dh=i|0,this.Dl=s|0,this.Eh=u|0,this.El=h|0,this.Fh=l|0,this.Fl=b|0,this.Gh=p|0,this.Gl=y|0,this.Hh=g|0,this.Hl=w|0}process(e,r){for(let x=0;x<16;x++,r+=4)I[x]=e.getUint32(r),C[x]=e.getUint32(r+=4);for(let x=16;x<80;x++){const H=I[x-15]|0,B=C[x-15]|0,X=O(H,B,1)^O(H,B,8)^ct(H,B,7),j=R(H,B,1)^R(H,B,8)^ut(H,B,7),T=I[x-2]|0,E=C[x-2]|0,U=O(T,E,19)^F(T,E,61)^ct(T,E,6),q=R(T,E,19)^M(T,E,61)^ut(T,E,6),V=re(j,q,C[x-7],C[x-16]),Y=ne(V,X,U,I[x-7],I[x-16]);I[x]=Y|0,C[x]=V|0}let{Ah:n,Al:o,Bh:c,Bl:a,Ch:i,Cl:s,Dh:u,Dl:h,Eh:l,El:b,Fh:p,Fl:y,Gh:g,Gl:w,Hh:A,Hl:L}=this;for(let x=0;x<80;x++){const H=O(l,b,14)^O(l,b,18)^F(l,b,41),B=R(l,b,14)^R(l,b,18)^M(l,b,41),X=l&p^~l&g,j=b&y^~b&w,T=oe(L,B,j,le[x],C[x]),E=se(T,A,H,X,ue[x],I[x]),U=T|0,q=O(n,o,28)^F(n,o,34)^F(n,o,39),V=R(n,o,28)^M(n,o,34)^M(n,o,39),Y=n&c^n&i^c&i,It=o&a^o&s^a&s;A=g|0,L=w|0,g=p|0,w=y|0,p=l|0,y=b|0,{h:l,l:b}=v(u|0,h|0,E|0,U|0),u=i|0,h=s|0,i=c|0,s=a|0,c=n|0,a=o|0;const it=te(U,V,It);n=ee(it,E,q,Y),o=it|0}({h:n,l:o}=v(this.Ah|0,this.Al|0,n|0,o|0)),{h:c,l:a}=v(this.Bh|0,this.Bl|0,c|0,a|0),{h:i,l:s}=v(this.Ch|0,this.Cl|0,i|0,s|0),{h:u,l:h}=v(this.Dh|0,this.Dl|0,u|0,h|0),{h:l,l:b}=v(this.Eh|0,this.El|0,l|0,b|0),{h:p,l:y}=v(this.Fh|0,this.Fl|0,p|0,y|0),{h:g,l:w}=v(this.Gh|0,this.Gl|0,g|0,w|0),{h:A,l:L}=v(this.Hh|0,this.Hl|0,A|0,L|0),this.set(n,o,c,a,i,s,u,h,l,b,p,y,g,w,A,L)}roundClean(){D(I,C)}destroy(){D(this.buffer),this.set(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)}}class he extends fe{constructor(){super(64);f(this,"Ah",P[0]|0);f(this,"Al",P[1]|0);f(this,"Bh",P[2]|0);f(this,"Bl",P[3]|0);f(this,"Ch",P[4]|0);f(this,"Cl",P[5]|0);f(this,"Dh",P[6]|0);f(this,"Dl",P[7]|0);f(this,"Eh",P[8]|0);f(this,"El",P[9]|0);f(this,"Fh",P[10]|0);f(this,"Fl",P[11]|0);f(this,"Gh",P[12]|0);f(this,"Gl",P[13]|0);f(this,"Hh",P[14]|0);f(this,"Hl",P[15]|0)}}const wt=rt(()=>new ce,gt(1)),de=rt(()=>new he,gt(3)),lt=66;function mt(t){if(!t.startsWith("0x")&&!t.startsWith("0X"))throw new Error("Expected 0x-prefixed hex string");const e=t.slice(2);if(e.length%2!==0)throw new Error(`Hex string has odd length: ${e.length}`);if(!/^[0-9a-fA-F]*$/.test(e))throw new Error("Hex string contains non-hex characters");const r=new Uint8Array(e.length/2);for(let n=0;n<r.length;n++)r[n]=parseInt(e.slice(n*2,n*2+2),16);return r}function be(t){return`0x${Array.from(t).map(e=>e.toString(16).padStart(2,"0")).join("")}`}function et(t,e){if(t.length!==lt)throw new Error(`${e} must be exactly 32 bytes (${lt} hex chars with 0x prefix), got ${t.length}`)}function St(t){et(t,"Secret");const e=mt(t),r=wt(e);return be(r)}function Tt(t,e){return et(t,"Secret"),et(e,"Hashlock"),mt(e),St(t).toLowerCase()===e.toLowerCase()}const xe=/^0x[0-9a-fA-F]{64}$/,pe=/^0x[0-9a-fA-F]{40}$/,ge=/^0x([0-9a-fA-F]{2})*$/;function Q(t,e){if(t.length!==66)throw new Error(`${e} must be 32 bytes (66 hex chars with 0x prefix), got length ${t.length}`);if(!xe.test(t))throw new Error(`${e} must contain only hex characters after the 0x prefix`)}function ye(t,e){if(!pe.test(t))throw new Error(`${e} must be a 20-byte 0x-prefixed hex address (42 chars)`)}function Pe(t,e){if(!ge.test(t))throw new Error(`${e} must be a 0x-prefixed hex string with an even number of hex chars`)}async function we(t){const{btcVaultRegistryAddress:e,vaultId:r,hashlock:n,activationMetadata:o,writeContract:c,signal:a}=t;a==null||a.throwIfAborted(),ye(e,"btcVaultRegistryAddress"),Q(r,"vaultId");const i=d.ensureHexPrefix(t.secret);if(Q(i,"secret"),n!==void 0&&(Q(n,"hashlock"),!Tt(i,n)))throw new Error("Invalid secret: SHA256(secret) does not match the provided hashlock");return Pe(o,"activationMetadata"),c({address:e,abi:m.BTCVaultRegistryABI,functionName:"activateVaultWithSecret",args:[r,i,o]})}const me=1e4;async function ot(t){const{statusReader:e,peginTxid:r,targetStatuses:n,timeoutMs:o,pollIntervalMs:c=me,signal:a}=t,i=Date.now();for(;;){if(a!=null&&a.aborted)throw new Error(`Polling aborted for pegin ${r.slice(0,8)}… (target: ${[...n].join(", ")})`);if(Date.now()-i>=o)throw new Error(`Polling timeout after ${o}ms for pegin ${r.slice(0,8)}… (target: ${[...n].join(", ")})`);try{const u=(await e.getPeginStatus({pegin_txid:r},a)).status;if(n.has(u))return u;if(m.VP_TERMINAL_STATUSES.has(u)&&!n.has(u))throw new Error(`Pegin ${r.slice(0,8)}… reached terminal status "${u}" while waiting for ${[...n].join(", ")}`)}catch(s){if(!(s instanceof m.JsonRpcError&&s.code===m.RpcErrorCode.NOT_FOUND||s instanceof Error&&s.message.includes("PegIn not found")))throw s}await new Promise((s,u)=>{const h=()=>{clearTimeout(l),u(new Error(`Polling aborted for pegin ${r.slice(0,8)}… (target: ${[...n].join(", ")})`))},l=setTimeout(()=>{a==null||a.removeEventListener("abort",h),s()},c);a==null||a.addEventListener("abort",h,{once:!0})})}}const Se=300*1e3,Te=new Set([m.DaemonStatus.PENDING_DEPOSITOR_WOTS_PK,...m.POST_WOTS_STATUSES]);async function Ee(t){const{statusReader:e,wotsSubmitter:r,peginTxid:n,depositorPk:o,wotsPublicKeys:c,timeoutMs:a=Se,signal:i}=t;i==null||i.throwIfAborted();const s=await ot({statusReader:e,peginTxid:n,targetStatuses:Te,timeoutMs:a,signal:i});m.POST_WOTS_STATUSES.has(s)||(i==null||i.throwIfAborted(),await r.submitDepositorWotsKey({pegin_txid:n,depositor_pk:o,wots_public_keys:c},i))}const ve=1;function Ae(t,e,r){const n=N.Psbt.fromBase64(t),o=n.data.getTransaction().toString("hex").toLowerCase(),c=d.stripHexPrefix(e).toLowerCase();if(o!==c)throw new Error(`PSBT integrity check failed for ${r}: unsigned transaction does not match tx_hex`);return n}function He(t){const e=N.Psbt.fromHex(t.toHex());for(const r of e.data.inputs)delete r.tapBip32Derivation,delete r.tapMerkleRoot;return e}function ft(t,e,r){if(!t)throw new Error(`Missing ${r} PSBT`);const n=Ae(t,e,r);return He(n).toHex()}function Be(t,e){const r=[],n=[],o=[],c=W.createTaprootScriptPathSignOptions(e,ve),a=ft(t.payout_psbt,t.payout_tx.tx_hex,"depositor payout");r.push(a),n.push(c);for(const i of t.challenger_presign_data){const s=d.stripHexPrefix(i.challenger_pubkey),u=r.length,h=ft(i.nopayout_psbt,i.nopayout_tx.tx_hex,`nopayout (challenger ${s})`);r.push(h),n.push(c),o.push({challengerPubkey:s,noPayoutIdx:u})}return{psbtHexes:r,signOptions:n,challengerEntries:o}}function ke(t,e,r){const n=$.extractPayoutSignature(t[0],r),o={};for(const c of e)o[c.challengerPubkey]={nopayout_signature:$.extractPayoutSignature(t[c.noPayoutIdx],r)};return{payout_signatures:{payout_signature:n},per_challenger:o}}async function _e(t,e,r){if(typeof t.signPsbts=="function")return t.signPsbts(e,r);const n=[];for(let o=0;o<e.length;o++)n.push(await t.signPsbt(e[o],r==null?void 0:r[o]));return n}async function Et(t){const{depositorGraph:e,depositorBtcPubkey:r,btcWallet:n}=t,o=d.stripHexPrefix(r),c=await n.getPublicKeyHex(),{psbtHexes:a,signOptions:i,challengerEntries:s}=Be(e,c),u=await _e(n,a,i);if(u.length!==a.length)throw new Error(`Wallet returned ${u.length} signed PSBTs, expected ${a.length}`);return ke(u,s,o)}const Ie=1200*1e3,vt=new Set([m.DaemonStatus.PENDING_ACKS,m.DaemonStatus.PENDING_ACTIVATION,m.DaemonStatus.ACTIVATED]),Ce=new Set([m.DaemonStatus.PENDING_DEPOSITOR_SIGNATURES,...vt]);function Le(t){return t.map(e=>({claimerPubkeyXOnly:d.processPublicKeyToXOnly(e.claimer_pubkey),payoutTxHex:e.payout_tx.tx_hex,assertTxHex:e.assert_tx.tx_hex}))}function $e(t){const{output:e}=Ot.payments.p2tr({internalPubkey:bt.Buffer.from(t,"hex")});if(!e)throw new Error("Failed to derive BIP-86 P2TR scriptPubKey");return e.toString("hex")}function Oe(t,e){const r=d.stripHexPrefix(t).toLowerCase(),n=d.stripHexPrefix(e.vaultProviderBtcPubkey).toLowerCase(),o=d.stripHexPrefix(e.depositorBtcPubkey).toLowerCase();if(r===n||r===o)return e.registeredPayoutScriptPubKey;if(!e.vaultKeeperBtcPubkeys.some(i=>d.stripHexPrefix(i).toLowerCase()===r))throw new Error(`Unknown claimer pubkey ${r}: not VP, depositor, or a registered vault keeper`);return`0x${$e(r)}`}function ht(t,e){return{payoutTxHex:t.payoutTxHex,peginTxHex:e.peginTxHex,assertTxHex:t.assertTxHex,vaultProviderBtcPubkey:e.vaultProviderBtcPubkey,vaultKeeperBtcPubkeys:e.vaultKeeperBtcPubkeys,universalChallengerBtcPubkeys:e.universalChallengerBtcPubkeys,depositorBtcPubkey:e.depositorBtcPubkey,timelockPegin:e.timelockPegin,registeredPayoutScriptPubKey:Oe(t.claimerPubkeyXOnly,e)}}async function Re(t,e,r,n){const o=new xt({network:e.network,btcWallet:t}),c=r.length;n==null||n(0,c);let a;if(o.supportsBatchSigning())a=(await o.signPayoutTransactionsBatch(r.map(u=>ht(u,e)))).map(u=>u.payoutSignature);else{a=[];for(let s=0;s<r.length;s++){n==null||n(s,c);const u=await o.signPayoutTransaction(ht(r[s],e));a.push(u.signature)}}const i={};for(let s=0;s<r.length;s++)i[r[s].claimerPubkeyXOnly]={payout_signature:a[s]};return n==null||n(c,c),i}async function De(t){const{statusReader:e,presignClient:r,btcWallet:n,peginTxid:o,depositorPk:c,signingContext:a,timeoutMs:i=Ie,signal:s,onProgress:u}=t,h=await ot({statusReader:e,peginTxid:o,targetStatuses:Ce,timeoutMs:i,signal:s});if(vt.has(h))return;s==null||s.throwIfAborted();const l=await r.requestDepositorPresignTransactions({pegin_txid:o,depositor_pk:c},s);s==null||s.throwIfAborted();const b=d.processPublicKeyToXOnly(c),p=l.txs.filter(L=>d.processPublicKeyToXOnly(L.claimer_pubkey)!==b),y=Le(p),g=await Re(n,a,y,u);s==null||s.throwIfAborted();const w=await Et({depositorGraph:l.depositor_graph,depositorBtcPubkey:c,btcWallet:n});s==null||s.throwIfAborted();const A={...g};A[d.stripHexPrefix(c)]=w.payout_signatures,await r.submitDepositorPresignatures({pegin_txid:o,depositor_pk:c,signatures:A,depositor_claimer_presignatures:w},s)}function Ne(t){return/^[0-9a-fA-F]{64}$/.test(t)}function Ue(t){const{amountSats:e,minDeposit:r,maxDeposit:n,btcBalance:o,estimatedFeeSats:c,depositorClaimValue:a}=t;return!(e<=0n||e<r||n&&n>0n&&e>n||c==null||a==null||e+c+a>o)}function Ve(t,e,r){return t<=0n?{valid:!1,error:"Deposit amount must be greater than zero"}:t<e?{valid:!1,error:`Minimum deposit is ${d.formatSatoshisToBtc(e)} BTC`}:r&&r>0n&&t>r?{valid:!1,error:`Maximum deposit is ${d.formatSatoshisToBtc(r)} BTC`}:{valid:!0}}function Ke(t){const{amount:e,effectiveRemaining:r}=t;return r===null?{valid:!0}:r===0n?{valid:!1,error:"Supply cap reached — deposits temporarily paused"}:e>r?{valid:!1,error:`Vault size exceeds remaining capacity (${d.formatSatoshisToBtc(r)} BTC)`}:{valid:!0}}function Fe(t,e){if(!t||t.length===0)return{valid:!1,error:"At least one vault provider must be selected"};const r=e.map(o=>o.toLowerCase());return t.filter(o=>!r.includes(o.toLowerCase())).length>0?{valid:!1,error:"Invalid vault provider selected"}:{valid:!0}}function At(t,e,r){if(!t||t.length===0)return{valid:!1,error:"At least one vault amount required"};for(let n=0;n<t.length;n++){const o=t[n];if(o<=0n)return{valid:!1,error:`Vault ${n+1} amount must be positive`};if(e&&o<e)return{valid:!1,error:`Vault ${n+1} amount ${d.formatSatoshisToBtc(o)} BTC is below minimum deposit ${d.formatSatoshisToBtc(e)} BTC`};if(r&&o>r)return{valid:!1,error:`Vault ${n+1} amount ${d.formatSatoshisToBtc(o)} BTC exceeds maximum deposit ${d.formatSatoshisToBtc(r)} BTC`}}return{valid:!0}}function Ht(t){const e=d.stripHexPrefix(t);return Ne(e)?{valid:!0}:{valid:!1,error:"Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"}}function Me(t){if(!t||t.length===0)throw new Error("No vault keepers available. The system requires at least one vault keeper to create a deposit.")}function Ge(t){if(!t||t.length===0)throw new Error("No universal challengers available. The system requires at least one universal challenger to create a deposit.")}function We(t){if(t.length===0)throw new Error("No spendable UTXOs available")}function ze(t){const{vaultAmounts:e,confirmedUTXOs:r,vaultProviderBtcPubkey:n,vaultKeeperBtcPubkeys:o,universalChallengerBtcPubkeys:c,minDeposit:a,maxDeposit:i,htlcSecretHexesLength:s,depositorSecretHashesLength:u}=t,h=e.length;if(s!==h)throw new Error(`htlcSecretHexes length (${s}) must match vaultAmounts length (${h})`);if(u!==h)throw new Error(`depositorSecretHashes length (${u}) must match vaultAmounts length (${h})`);const l=At(e,a,i);if(!l.valid)throw new Error(l.error);const b=Ht(n);if(!b.valid)throw new Error(b.error);Me(o),Ge(c),We(r)}var st=(t=>(t.CLAIM_EVENT_RECEIVED="ClaimEventReceived",t.CLAIM_BROADCAST="ClaimBroadcast",t.ASSERT_BROADCAST="AssertBroadcast",t.CHALLENGE_ASSERT_OBSERVED="ChallengeAssertObserved",t.WRONGLY_CHALLENGED_BROADCAST="WronglyChallengedBroadcast",t.PAYOUT_BROADCAST="PayoutBroadcast",t.FAILED="Failed",t))(st||{});const Xe=new Set(["PayoutBroadcast","Failed"]);function je(t){return Object.values(st).includes(t)}function qe(t){return!!t&&Xe.has(t)}class Bt extends Error{constructor(r,n){super(`Refund not yet mature (BIP68 not final): ${n.message}`);f(this,"vaultId");f(this,"cause");this.name="BIP68NotMatureError",this.vaultId=r,this.cause=n}}const Ye=/^0x[0-9a-fA-F]{64}$/,Qe=/^(?:0x)?(?:[0-9a-fA-F]{2})+$/,kt=/^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/,Je=160,Ze=1,dt=65535,tr=/non-BIP68-final/i;function _t(t,e){if(t.length!==66)throw new Error(`${e} must be 32 bytes (66 hex chars with 0x prefix), got length ${t.length}`);if(!Ye.test(t))throw new Error(`${e} must contain only hex characters after the 0x prefix`)}function J(t,e){if(!Number.isInteger(t)||t<0)throw new Error(`${e} must be a non-negative integer, got ${t}`)}function er(t){if(_t(t.hashlock,"hashlock"),!Number.isInteger(t.htlcVout)||t.htlcVout<0||t.htlcVout>dt)throw new Error(`htlcVout must be an integer 0-${dt}, got ${t.htlcVout}`);if(J(t.offchainParamsVersion,"offchainParamsVersion"),J(t.appVaultKeepersVersion,"appVaultKeepersVersion"),J(t.universalChallengersVersion,"universalChallengersVersion"),typeof t.unsignedPrePeginTxHex!="string"||t.unsignedPrePeginTxHex.length===0)throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");if(!Qe.test(t.unsignedPrePeginTxHex))throw new Error("unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)");if(!t.depositorBtcPubkey||!kt.test(t.depositorBtcPubkey))throw new Error("depositorBtcPubkey must be 32 or 33 bytes of hex (optional 0x prefix)");if(typeof t.amount!="bigint"||t.amount<=0n)throw new Error(`amount must be a positive bigint, got ${t.amount}`)}function rr(t){if(!t.vaultProviderPubkey||!kt.test(t.vaultProviderPubkey))throw new Error("vaultProviderPubkey must be 32 or 33 bytes of hex");if(t.vaultKeeperPubkeys.length===0)throw new Error("vaultKeeperPubkeys must be non-empty");if(t.universalChallengerPubkeys.length===0)throw new Error("universalChallengerPubkeys must be non-empty");if(!Number.isInteger(t.timelockRefund)||t.timelockRefund<=0)throw new Error(`timelockRefund must be a positive integer, got ${t.timelockRefund}`);if(typeof t.feeRate!="bigint"||t.feeRate<=0n)throw new Error(`protocol feeRate must be a positive bigint, got ${t.feeRate}`);if(!Number.isInteger(t.numLocalChallengers)||t.numLocalChallengers<0)throw new Error("numLocalChallengers must be a non-negative integer");if(!Number.isInteger(t.councilQuorum)||!Number.isInteger(t.councilSize)||t.councilQuorum<=0||t.councilSize<=0||t.councilQuorum>t.councilSize)throw new Error(`councilQuorum (${t.councilQuorum}) must be in [1, councilSize=${t.councilSize}]`)}function nr(t){const e=N.Psbt.fromHex(t);try{e.finalizeAllInputs()}catch(r){const n=r instanceof Error?r.message:String(r);if(!n.includes("already finalized"))throw new Error(`Failed to finalize refund PSBT: ${n}`)}return e.extractTransaction().toHex()}async function or(t){const{vaultId:e,readVault:r,readPrePeginContext:n,feeRate:o,signPsbt:c,broadcastTx:a,signal:i}=t;i==null||i.throwIfAborted(),_t(e,"vaultId");const s=await r();er(s),i==null||i.throwIfAborted();const u=await n(s);if(rr(u),i==null||i.throwIfAborted(),!Number.isFinite(o)||o<=0)throw new Error(`feeRate must be a positive number, got ${o}`);const h=BigInt(Math.ceil(o*Je));i==null||i.throwIfAborted();const{psbtHex:l}=await $.buildRefundPsbt({prePeginParams:{depositorPubkey:d.stripHexPrefix(s.depositorBtcPubkey),vaultProviderPubkey:d.stripHexPrefix(u.vaultProviderPubkey),vaultKeeperPubkeys:u.vaultKeeperPubkeys.map(d.stripHexPrefix),universalChallengerPubkeys:u.universalChallengerPubkeys.map(d.stripHexPrefix),hashlocks:[d.stripHexPrefix(s.hashlock)],timelockRefund:u.timelockRefund,pegInAmounts:[s.amount],feeRate:u.feeRate,numLocalChallengers:u.numLocalChallengers,councilQuorum:u.councilQuorum,councilSize:u.councilSize,network:u.network},fundedPrePeginTxHex:d.stripHexPrefix(s.unsignedPrePeginTxHex),htlcVout:s.htlcVout,refundFee:h,hashlock:d.stripHexPrefix(s.hashlock)});i==null||i.throwIfAborted();const b=W.createTaprootScriptPathSignOptions(s.depositorBtcPubkey,Ze),p=await c(l,b),y=nr(p);i==null||i.throwIfAborted();try{return await a(y)}catch(g){throw g instanceof Error&&tr.test(g.message)?new Bt(e,g):g}}exports.BIP68NotMatureError=Bt;exports.ClaimerPegoutStatusValue=st;exports.HashMD=nt;exports.PayoutManager=xt;exports.abytes=z;exports.activateVault=we;exports.aexists=tt;exports.ahash=Dt;exports.anumber=Z;exports.aoutput=pt;exports.buildAndBroadcastRefund=or;exports.checkOpts=zt;exports.clean=D;exports.computeHashlock=St;exports.createHasher=rt;exports.createView=G;exports.isDepositAmountValid=Ue;exports.isPegoutTerminalStatus=qe;exports.isRecognizedPegoutStatus=je;exports.kdfInputToBytes=Wt;exports.pollAndSignPayouts=De;exports.rotl=Ut;exports.rotlBH=Jt;exports.rotlBL=Zt;exports.rotlSH=Yt;exports.rotlSL=Qt;exports.sha256=wt;exports.sha512=de;exports.signDepositorGraph=Et;exports.split=yt;exports.submitWotsPublicKey=Ee;exports.swap32IfBE=Mt;exports.u32=Nt;exports.validateDepositAmount=Ve;exports.validateMultiVaultDepositInputs=ze;exports.validateProviderSelection=Fe;exports.validateRemainingCapacity=Ke;exports.validateSecretAgainstHashlock=Tt;exports.validateVaultAmounts=At;exports.validateVaultProviderPubkey=Ht;exports.waitForPeginStatus=ot;
+//# sourceMappingURL=buildAndBroadcastRefund-DWEQvj9T.cjs.map