@babylonlabs-io/ts-sdk 0.21.0 → 0.23.0

package/dist/buildAndBroadcastRefund-DWEQvj9T.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildAndBroadcastRefund-DWEQvj9T.cjs","sources":["../src/tbv/core/managers/PayoutManager.ts","../../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/utils.js","../../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/_md.js","../../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/_u64.js","../../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/sha2.js","../src/tbv/core/services/htlc/index.ts","../src/tbv/core/services/activation/activateVault.ts","../src/tbv/core/services/deposit/waitForPeginStatus.ts","../src/tbv/core/services/deposit/submitWotsPublicKey.ts","../src/tbv/core/services/deposit/signDepositorGraph.ts","../src/tbv/core/services/deposit/signAndSubmitPayouts.ts","../src/tbv/core/services/deposit/validation.ts","../src/tbv/core/services/pegout/state.ts","../src/tbv/core/services/refund/errors.ts","../src/tbv/core/services/refund/buildAndBroadcastRefund.ts"],"sourcesContent":["/**\n * Payout Manager\n *\n * High-level manager that orchestrates the payout signing flow by coordinating\n * SDK primitives ({@link buildPayoutPsbt}, {@link extractPayoutSignature})\n * with a user-provided Bitcoin wallet.\n *\n * The Payout transaction references the Assert transaction (input 1).\n *\n * @see {@link PeginManager} - For Steps 1, 2, and 4 of peg-in flow\n * @see {@link buildPayoutPsbt} - Lower-level primitive for custom implementations\n * @see {@link extractPayoutSignature} - Extract signatures from signed PSBTs\n *\n * @module managers/PayoutManager\n */\n\nimport { Buffer } from \"buffer\";\n\nimport { Transaction } from \"bitcoinjs-lib\";\n\nimport type {\n  BitcoinWallet,\n  SignPsbtOptions,\n} from \"../../../shared/wallets\";\nimport { createTaprootScriptPathSignOptions } from \"../utils/signing\";\nimport {\n  buildPayoutPsbt,\n  extractPayoutSignature,\n  isValidHex,\n  stripHexPrefix,\n  validateWalletPubkey,\n  type Network,\n} from \"../primitives\";\n\n/**\n * Configuration for the PayoutManager.\n */\nexport interface PayoutManagerConfig {\n  /**\n   * Bitcoin network to use for transactions.\n   */\n  network: Network;\n\n  /**\n   * Bitcoin wallet for signing payout transactions.\n   */\n  btcWallet: BitcoinWallet;\n}\n\n/**\n * Base parameters shared by both payout transaction types.\n */\ninterface SignPayoutBaseParams {\n  /**\n   * Peg-in transaction hex.\n   * The original transaction that created the vault output being spent.\n   */\n  peginTxHex: string;\n\n  /**\n   * Vault provider's BTC public key (x-only, 64-char hex).\n   */\n  vaultProviderBtcPubkey: string;\n\n  /**\n   * Vault keeper BTC public keys (x-only, 64-char hex).\n   */\n  vaultKeeperBtcPubkeys: string[];\n\n  /**\n   * Universal challenger BTC public keys (x-only, 64-char hex).\n   */\n  universalChallengerBtcPubkeys: string[];\n\n  /**\n   * CSV timelock in blocks for the PegIn output.\n   */\n  timelockPegin: number;\n\n  /**\n   * Depositor's BTC public key (x-only, 64-char hex).\n   * This should be the public key that was used when creating the vault,\n   * as stored on-chain. If not provided, will be fetched from the wallet.\n   */\n  depositorBtcPubkey?: string;\n\n  /**\n   * The on-chain registered depositor payout scriptPubKey (hex, with or without 0x prefix).\n   * Used to validate that the VP-provided payout transaction actually pays to the\n   * correct depositor payout address before signing.\n   */\n  registeredPayoutScriptPubKey: string;\n}\n\n/**\n * Parameters for signing a Payout transaction.\n *\n * Payout is used in the challenge path after Assert, when the claimer proves validity.\n * Input 1 references the Assert transaction.\n */\nexport interface SignPayoutParams extends SignPayoutBaseParams {\n  /**\n   * Payout transaction hex (unsigned).\n   * This is the transaction from the vault provider that needs depositor signature.\n   */\n  payoutTxHex: string;\n\n  /**\n   * Assert transaction hex.\n   * Payout input 1 references Assert output 0.\n   */\n  assertTxHex: string;\n}\n\n/**\n * Result of signing a payout transaction.\n */\nexport interface PayoutSignatureResult {\n  /**\n   * 64-byte Schnorr signature (128 hex characters).\n   */\n  signature: string;\n\n  /**\n   * Depositor's BTC public key used for signing.\n   */\n  depositorBtcPubkey: string;\n}\n\n/**\n * High-level manager for payout transaction signing.\n *\n * @remarks\n * After registering your peg-in on Ethereum (Step 2), the vault provider prepares\n * claim/payout transaction pairs. You must sign each payout transaction using this\n * manager and submit the signatures to the vault provider's RPC API.\n *\n * **What happens internally:**\n * 1. Validates your wallet's public key matches the vault's depositor\n * 2. Builds an unsigned PSBT with taproot script path spend info\n * 3. Signs input 0 (the vault UTXO) with your wallet\n * 4. Extracts the 64-byte Schnorr signature\n *\n * **Note:** The payout transaction has 2 inputs. PayoutManager only signs input 0\n * (from the peg-in tx). Input 1 (from the assert tx) is signed by the vault provider.\n *\n * @see {@link PeginManager} - For the complete peg-in flow context\n * @see {@link buildPayoutPsbt} - Lower-level primitive used internally\n * @see {@link extractPayoutSignature} - Signature extraction primitive\n */\nexport class PayoutManager {\n  private readonly config: PayoutManagerConfig;\n\n  /**\n   * Creates a new PayoutManager instance.\n   *\n   * @param config - Manager configuration including wallet\n   */\n  constructor(config: PayoutManagerConfig) {\n    this.config = config;\n  }\n\n  /**\n   * Signs a Payout transaction and extracts the Schnorr signature.\n   *\n   * Flow:\n   * 1. Vault provider submits Claim transaction\n   * 2. Claimer submits Assert transaction to prove validity\n   * 3. Payout can be executed (references Assert tx)\n   *\n   * This method orchestrates the following steps:\n   * 1. Get wallet's public key and convert to x-only format\n   * 2. Validate wallet pubkey matches on-chain depositor pubkey (if provided)\n   * 3. Build unsigned PSBT using primitives\n   * 4. Sign PSBT via btcWallet.signPsbt()\n   * 5. Extract 64-byte Schnorr signature using primitives\n   *\n   * The returned signature can be submitted to the vault provider API.\n   *\n   * @param params - Payout signing parameters\n   * @returns Signature result with 64-byte Schnorr signature and depositor pubkey\n   * @throws Error if wallet pubkey doesn't match depositor pubkey\n   * @throws Error if wallet operations fail or signature extraction fails\n   */\n  async signPayoutTransaction(\n    params: SignPayoutParams,\n  ): Promise<PayoutSignatureResult> {\n    // Validate payout TX outputs pay to the registered depositor payout address\n    this.validatePayoutOutputs(\n      params.payoutTxHex,\n      params.registeredPayoutScriptPubKey,\n    );\n\n    // Validate wallet pubkey matches depositor and get both formats\n    const walletPubkeyRaw = await this.config.btcWallet.getPublicKeyHex();\n    const { depositorPubkey } = validateWalletPubkey(\n      walletPubkeyRaw,\n      params.depositorBtcPubkey,\n    );\n\n    // Build unsigned PSBT for Payout (uses Assert tx)\n    const payoutPsbt = await buildPayoutPsbt({\n      payoutTxHex: params.payoutTxHex,\n      peginTxHex: params.peginTxHex,\n      assertTxHex: params.assertTxHex,\n      depositorBtcPubkey: depositorPubkey,\n      vaultProviderBtcPubkey: params.vaultProviderBtcPubkey,\n      vaultKeeperBtcPubkeys: params.vaultKeeperBtcPubkeys,\n      universalChallengerBtcPubkeys: params.universalChallengerBtcPubkeys,\n      timelockPegin: params.timelockPegin,\n      network: this.config.network,\n    });\n\n    // Sign PSBT via wallet (Taproot script-path spend, input 0 only)\n    const signedPsbtHex = await this.config.btcWallet.signPsbt(\n      payoutPsbt.psbtHex,\n      createTaprootScriptPathSignOptions(walletPubkeyRaw, 1),\n    );\n\n    // Extract Schnorr signature\n    const signature = extractPayoutSignature(signedPsbtHex, depositorPubkey);\n\n    return {\n      signature,\n      depositorBtcPubkey: depositorPubkey,\n    };\n  }\n\n  /**\n   * Gets the configured Bitcoin network.\n   *\n   * @returns The Bitcoin network (mainnet, testnet, signet, regtest)\n   */\n  getNetwork(): Network {\n    return this.config.network;\n  }\n\n  /**\n   * Checks if the wallet supports batch signing (signPsbts).\n   *\n   * @returns true if batch signing is supported\n   */\n  supportsBatchSigning(): boolean {\n    return typeof this.config.btcWallet.signPsbts === \"function\";\n  }\n\n  /**\n   * Batch signs multiple payout transactions (1 per claimer).\n   * This allows signing all transactions with a single wallet interaction.\n   *\n   * @param transactions - Array of payout params to sign\n   * @returns Array of signature results matching input order\n   * @throws Error if wallet doesn't support batch signing\n   * @throws Error if any signing operation fails\n   */\n  async signPayoutTransactionsBatch(\n    transactions: SignPayoutParams[],\n  ): Promise<\n    Array<{\n      payoutSignature: string;\n      depositorBtcPubkey: string;\n    }>\n  > {\n    if (!this.supportsBatchSigning()) {\n      throw new Error(\n        \"Wallet does not support batch signing (signPsbts method not available)\",\n      );\n    }\n\n    // Get wallet pubkey once\n    const walletPubkeyRaw = await this.config.btcWallet.getPublicKeyHex();\n\n    // Build all PSBTs (1 per claimer)\n    const psbtsToSign: string[] = [];\n    const signOptions: SignPsbtOptions[] = [];\n    const depositorPubkeys: string[] = [];\n\n    for (const tx of transactions) {\n      // Validate payout TX outputs pay to the registered depositor payout address\n      this.validatePayoutOutputs(\n        tx.payoutTxHex,\n        tx.registeredPayoutScriptPubKey,\n      );\n\n      // Validate wallet pubkey matches depositor\n      const { depositorPubkey } = validateWalletPubkey(\n        walletPubkeyRaw,\n        tx.depositorBtcPubkey,\n      );\n      depositorPubkeys.push(depositorPubkey);\n\n      // Build Payout PSBT\n      const payoutPsbt = await buildPayoutPsbt({\n        payoutTxHex: tx.payoutTxHex,\n        peginTxHex: tx.peginTxHex,\n        assertTxHex: tx.assertTxHex,\n        depositorBtcPubkey: depositorPubkey,\n        vaultProviderBtcPubkey: tx.vaultProviderBtcPubkey,\n        vaultKeeperBtcPubkeys: tx.vaultKeeperBtcPubkeys,\n        universalChallengerBtcPubkeys: tx.universalChallengerBtcPubkeys,\n        timelockPegin: tx.timelockPegin,\n        network: this.config.network,\n      });\n      psbtsToSign.push(payoutPsbt.psbtHex);\n      signOptions.push(createTaprootScriptPathSignOptions(walletPubkeyRaw, 1));\n    }\n\n    // Batch sign all PSBTs with single wallet interaction\n    const signedPsbts = await this.config.btcWallet.signPsbts!(\n      psbtsToSign,\n      signOptions,\n    );\n\n    // Validate that wallet returned the expected number of signed PSBTs\n    if (signedPsbts.length !== transactions.length) {\n      throw new Error(\n        `Expected ${transactions.length} signed PSBTs but received ${signedPsbts.length}`,\n      );\n    }\n\n    // Extract signatures from signed PSBTs\n    const results: Array<{\n      payoutSignature: string;\n      depositorBtcPubkey: string;\n    }> = [];\n\n    for (let i = 0; i < transactions.length; i++) {\n      const depositorPubkey = depositorPubkeys[i];\n      const payoutSignature = extractPayoutSignature(\n        signedPsbts[i],\n        depositorPubkey,\n      );\n\n      results.push({\n        payoutSignature,\n        depositorBtcPubkey: depositorPubkey,\n      });\n    }\n\n    return results;\n  }\n\n  /**\n   * Validates that the payout transaction's largest output pays to the\n   * registered depositor payout address (scriptPubKey).\n   *\n   * This prevents two attack vectors from a malicious vault provider:\n   * 1. Substituting a completely different payout address\n   * 2. Including a dust output to the correct address while routing\n   *    the actual funds to an attacker-controlled address\n   *\n   * @param payoutTxHex - Raw payout transaction hex\n   * @param registeredPayoutScriptPubKey - On-chain registered scriptPubKey (hex, with or without 0x prefix)\n   * @throws Error if scriptPubKey is invalid hex\n   * @throws Error if the largest output does not pay to the registered address\n   */\n  private validatePayoutOutputs(\n    payoutTxHex: string,\n    registeredPayoutScriptPubKey: string,\n  ): void {\n    if (!isValidHex(registeredPayoutScriptPubKey)) {\n      throw new Error(\n        \"Invalid registeredPayoutScriptPubKey: not valid hex\",\n      );\n    }\n\n    const expectedScript = Buffer.from(\n      stripHexPrefix(registeredPayoutScriptPubKey),\n      \"hex\",\n    );\n    const payoutTx = Transaction.fromHex(stripHexPrefix(payoutTxHex));\n\n    if (payoutTx.outs.length === 0) {\n      throw new Error(\"Payout transaction has no outputs\");\n    }\n\n    // Find the largest output by value — this must pay to the registered address.\n    // A dust output to the correct address with funds routed elsewhere is rejected.\n    const largestOutput = payoutTx.outs.reduce((max, output) =>\n      output.value > max.value ? output : max,\n    );\n\n    if (!largestOutput.script.equals(expectedScript)) {\n      throw new Error(\n        \"Payout transaction does not pay to the registered depositor payout address\",\n      );\n    }\n  }\n}\n","/**\n * Utilities for hex, bytes, CSPRNG.\n * @module\n */\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */\nexport function isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n/** Asserts something is positive integer. */\nexport function anumber(n, title = '') {\n    if (!Number.isSafeInteger(n) || n < 0) {\n        const prefix = title && `\"${title}\" `;\n        throw new Error(`${prefix}expected integer >= 0, got ${n}`);\n    }\n}\n/** Asserts something is Uint8Array. */\nexport function abytes(value, length, title = '') {\n    const bytes = isBytes(value);\n    const len = value?.length;\n    const needsLen = length !== undefined;\n    if (!bytes || (needsLen && len !== length)) {\n        const prefix = title && `\"${title}\" `;\n        const ofLen = needsLen ? ` of length ${length}` : '';\n        const got = bytes ? `length=${len}` : `type=${typeof value}`;\n        throw new Error(prefix + 'expected Uint8Array' + ofLen + ', got ' + got);\n    }\n    return value;\n}\n/** Asserts something is hash */\nexport function ahash(h) {\n    if (typeof h !== 'function' || typeof h.create !== 'function')\n        throw new Error('Hash must wrapped by utils.createHasher');\n    anumber(h.outputLen);\n    anumber(h.blockLen);\n}\n/** Asserts a hash instance has not been destroyed / finished */\nexport function aexists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\n/** Asserts output is properly-sized byte array */\nexport function aoutput(out, instance) {\n    abytes(out, undefined, 'digestInto() output');\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error('\"digestInto() output\" expected to be of length >=' + min);\n    }\n}\n/** Cast u8 / u16 / u32 to u8. */\nexport function u8(arr) {\n    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** Cast u8 / u16 / u32 to u32. */\nexport function u32(arr) {\n    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n/** Zeroize a byte array. Warning: JS provides no guarantees. */\nexport function clean(...arrays) {\n    for (let i = 0; i < arrays.length; i++) {\n        arrays[i].fill(0);\n    }\n}\n/** Create DataView of an array for easy byte-level manipulation. */\nexport function createView(arr) {\n    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** The rotate right (circular right shift) operation for uint32 */\nexport function rotr(word, shift) {\n    return (word << (32 - shift)) | (word >>> shift);\n}\n/** The rotate left (circular left shift) operation for uint32 */\nexport function rotl(word, shift) {\n    return (word << shift) | ((word >>> (32 - shift)) >>> 0);\n}\n/** Is current platform little-endian? Most are. Big-Endian platform: IBM */\nexport const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n/** The byte swap operation for uint32 */\nexport function byteSwap(word) {\n    return (((word << 24) & 0xff000000) |\n        ((word << 8) & 0xff0000) |\n        ((word >>> 8) & 0xff00) |\n        ((word >>> 24) & 0xff));\n}\n/** Conditionally byte swap if on a big-endian platform */\nexport const swap8IfBE = isLE\n    ? (n) => n\n    : (n) => byteSwap(n);\n/** In place byte swap for Uint32Array */\nexport function byteSwap32(arr) {\n    for (let i = 0; i < arr.length; i++) {\n        arr[i] = byteSwap(arr[i]);\n    }\n    return arr;\n}\nexport const swap32IfBE = isLE\n    ? (u) => u\n    : byteSwap32;\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\nconst hasHexBuiltin = /* @__PURE__ */ (() => \n// @ts-ignore\ntypeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * Convert byte array to hex string. Uses built-in function, when available.\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return bytes.toHex();\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };\nfunction asciiToBase16(ch) {\n    if (ch >= asciis._0 && ch <= asciis._9)\n        return ch - asciis._0; // '2' => 50-48\n    if (ch >= asciis.A && ch <= asciis.F)\n        return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n    if (ch >= asciis.a && ch <= asciis.f)\n        return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n    return;\n}\n/**\n * Convert hex string to byte array. Uses built-in function, when available.\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return Uint8Array.fromHex(hex);\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new Error('hex string expected, got unpadded hex of length ' + hl);\n    const array = new Uint8Array(al);\n    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n        const n1 = asciiToBase16(hex.charCodeAt(hi));\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n    }\n    return array;\n}\n/**\n * There is no setImmediate in browser and setTimeout is slow.\n * Call of async fn will return Promise, which will be fullfiled only on\n * next scheduler queue processing step and this is exactly what we need.\n */\nexport const nextTick = async () => { };\n/** Returns control to thread each 'tick' ms to avoid blocking. */\nexport async function asyncLoop(iters, tick, cb) {\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n}\n/**\n * Converts string to bytes using UTF8 encoding.\n * Built-in doesn't validate input to be string: we do the check.\n * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error('string expected');\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Helper for KDFs: consumes uint8array or string.\n * When string is passed, does utf8 decoding, using TextDecoder.\n */\nexport function kdfInputToBytes(data, errorTitle = '') {\n    if (typeof data === 'string')\n        return utf8ToBytes(data);\n    return abytes(data, undefined, errorTitle);\n}\n/** Copies several Uint8Arrays into one. */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\n/** Merges default options and passed options. */\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')\n        throw new Error('options must be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\n/** Creates function with outputLen, blockLen, create properties from a class constructor. */\nexport function createHasher(hashCons, info = {}) {\n    const hashC = (msg, opts) => hashCons(opts).update(msg).digest();\n    const tmp = hashCons(undefined);\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    Object.assign(hashC, info);\n    return Object.freeze(hashC);\n}\n/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */\nexport function randomBytes(bytesLength = 32) {\n    const cr = typeof globalThis === 'object' ? globalThis.crypto : null;\n    if (typeof cr?.getRandomValues !== 'function')\n        throw new Error('crypto.getRandomValues must be defined');\n    return cr.getRandomValues(new Uint8Array(bytesLength));\n}\n/** Creates OID opts for NIST hashes, with prefix 06 09 60 86 48 01 65 03 04 02. */\nexport const oidNist = (suffix) => ({\n    oid: Uint8Array.from([0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, suffix]),\n});\n//# sourceMappingURL=utils.js.map","/**\n * Internal Merkle-Damgard hash utils.\n * @module\n */\nimport { abytes, aexists, aoutput, clean, createView } from \"./utils.js\";\n/** Choice: a ? b : c */\nexport function Chi(a, b, c) {\n    return (a & b) ^ (~a & c);\n}\n/** Majority function, true if any two inputs is true. */\nexport function Maj(a, b, c) {\n    return (a & b) ^ (a & c) ^ (b & c);\n}\n/**\n * Merkle-Damgard hash construction base class.\n * Could be used to create MD5, RIPEMD, SHA1, SHA2.\n */\nexport class HashMD {\n    blockLen;\n    outputLen;\n    padOffset;\n    isLE;\n    // For partial updates less than block size\n    buffer;\n    view;\n    finished = false;\n    length = 0;\n    pos = 0;\n    destroyed = false;\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.padOffset = padOffset;\n        this.isLE = isLE;\n        this.buffer = new Uint8Array(blockLen);\n        this.view = createView(this.buffer);\n    }\n    update(data) {\n        aexists(this);\n        abytes(data);\n        const { view, buffer, blockLen } = this;\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            // Fast path: we have at least one block in input, cast it to view and process\n            if (take === blockLen) {\n                const dataView = createView(data);\n                for (; blockLen <= len - pos; pos += blockLen)\n                    this.process(dataView, pos);\n                continue;\n            }\n            buffer.set(data.subarray(pos, pos + take), this.pos);\n            this.pos += take;\n            pos += take;\n            if (this.pos === blockLen) {\n                this.process(view, 0);\n                this.pos = 0;\n            }\n        }\n        this.length += data.length;\n        this.roundClean();\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        aoutput(out, this);\n        this.finished = true;\n        // Padding\n        // We can avoid allocation of buffer for padding completely if it\n        // was previously not allocated here. But it won't change performance.\n        const { buffer, view, blockLen, isLE } = this;\n        let { pos } = this;\n        // append the bit '1' to the message\n        buffer[pos++] = 0b10000000;\n        clean(this.buffer.subarray(pos));\n        // we have less than padOffset left in buffer, so we cannot put length in\n        // current block, need process it and pad again\n        if (this.padOffset > blockLen - pos) {\n            this.process(view, 0);\n            pos = 0;\n        }\n        // Pad until full block byte with zeros\n        for (let i = pos; i < blockLen; i++)\n            buffer[i] = 0;\n        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.\n        // So we just write lowest 64 bits of that value.\n        view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);\n        this.process(view, 0);\n        const oview = createView(out);\n        const len = this.outputLen;\n        // NOTE: we do division by 4 later, which must be fused in single op with modulo by JIT\n        if (len % 4)\n            throw new Error('_sha2: outputLen must be aligned to 32bit');\n        const outLen = len / 4;\n        const state = this.get();\n        if (outLen > state.length)\n            throw new Error('_sha2: outputLen bigger than state');\n        for (let i = 0; i < outLen; i++)\n            oview.setUint32(4 * i, state[i], isLE);\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    _cloneInto(to) {\n        to ||= new this.constructor();\n        to.set(...this.get());\n        const { blockLen, buffer, length, finished, destroyed, pos } = this;\n        to.destroyed = destroyed;\n        to.finished = finished;\n        to.length = length;\n        to.pos = pos;\n        if (length % blockLen)\n            to.buffer.set(buffer);\n        return to;\n    }\n    clone() {\n        return this._cloneInto();\n    }\n}\n/**\n * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.\n * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.\n */\n/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */\nexport const SHA256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,\n]);\n/** Initial SHA224 state. Bits 32..64 of frac part of sqrt of primes 23..53 */\nexport const SHA224_IV = /* @__PURE__ */ Uint32Array.from([\n    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,\n]);\n/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */\nexport const SHA384_IV = /* @__PURE__ */ Uint32Array.from([\n    0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,\n    0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,\n]);\n/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */\nexport const SHA512_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,\n    0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,\n]);\n//# sourceMappingURL=_md.js.map","/**\n * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.\n * @todo re-check https://issues.chromium.org/issues/42212588\n * @module\n */\nconst U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);\nconst _32n = /* @__PURE__ */ BigInt(32);\nfunction fromBig(n, le = false) {\n    if (le)\n        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };\n    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };\n}\nfunction split(lst, le = false) {\n    const len = lst.length;\n    let Ah = new Uint32Array(len);\n    let Al = new Uint32Array(len);\n    for (let i = 0; i < len; i++) {\n        const { h, l } = fromBig(lst[i], le);\n        [Ah[i], Al[i]] = [h, l];\n    }\n    return [Ah, Al];\n}\nconst toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);\n// for Shift in [0, 32)\nconst shrSH = (h, _l, s) => h >>> s;\nconst shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in [1, 32)\nconst rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));\nconst rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));\nconst rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));\n// Right rotate for shift===32 (just swaps l&h)\nconst rotr32H = (_h, l) => l;\nconst rotr32L = (h, _l) => h;\n// Left rotate for Shift in [1, 32)\nconst rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));\nconst rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));\n// Left rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));\nconst rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));\n// JS uses 32-bit signed integers for bitwise operations which means we cannot\n// simple take carry out of low bit sum by shift, we need to use division.\nfunction add(Ah, Al, Bh, Bl) {\n    const l = (Al >>> 0) + (Bl >>> 0);\n    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };\n}\n// Addition with more than 2 elements\nconst add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\nconst add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;\nconst add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\nconst add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;\nconst add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\nconst add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;\n// prettier-ignore\nexport { add, add3H, add3L, add4H, add4L, add5H, add5L, fromBig, rotlBH, rotlBL, rotlSH, rotlSL, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL, shrSH, shrSL, split, toBig };\n// prettier-ignore\nconst u64 = {\n    fromBig, split, toBig,\n    shrSH, shrSL,\n    rotrSH, rotrSL, rotrBH, rotrBL,\n    rotr32H, rotr32L,\n    rotlSH, rotlSL, rotlBH, rotlBL,\n    add, add3L, add3H, add4L, add4H, add5H, add5L,\n};\nexport default u64;\n//# sourceMappingURL=_u64.js.map","/**\n * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.\n * SHA256 is the fastest hash implementable in JS, even faster than Blake3.\n * Check out [RFC 4634](https://www.rfc-editor.org/rfc/rfc4634) and\n * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).\n * @module\n */\nimport { Chi, HashMD, Maj, SHA224_IV, SHA256_IV, SHA384_IV, SHA512_IV } from \"./_md.js\";\nimport * as u64 from \"./_u64.js\";\nimport { clean, createHasher, oidNist, rotr } from \"./utils.js\";\n/**\n * Round constants:\n * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)\n */\n// prettier-ignore\nconst SHA256_K = /* @__PURE__ */ Uint32Array.from([\n    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n/** Reusable temporary buffer. \"W\" comes straight from spec. */\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\n/** Internal 32-byte base SHA2 hash class. */\nclass SHA2_32B extends HashMD {\n    constructor(outputLen) {\n        super(64, outputLen, 8, false);\n    }\n    get() {\n        const { A, B, C, D, E, F, G, H } = this;\n        return [A, B, C, D, E, F, G, H];\n    }\n    // prettier-ignore\n    set(A, B, C, D, E, F, G, H) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n        this.E = E | 0;\n        this.F = F | 0;\n        this.G = G | 0;\n        this.H = H | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4)\n            SHA256_W[i] = view.getUint32(offset, false);\n        for (let i = 16; i < 64; i++) {\n            const W15 = SHA256_W[i - 15];\n            const W2 = SHA256_W[i - 2];\n            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);\n            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;\n        }\n        // Compression function main loop, 64 rounds\n        let { A, B, C, D, E, F, G, H } = this;\n        for (let i = 0; i < 64; i++) {\n            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);\n            const T2 = (sigma0 + Maj(A, B, C)) | 0;\n            H = G;\n            G = F;\n            F = E;\n            E = (D + T1) | 0;\n            D = C;\n            C = B;\n            B = A;\n            A = (T1 + T2) | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        A = (A + this.A) | 0;\n        B = (B + this.B) | 0;\n        C = (C + this.C) | 0;\n        D = (D + this.D) | 0;\n        E = (E + this.E) | 0;\n        F = (F + this.F) | 0;\n        G = (G + this.G) | 0;\n        H = (H + this.H) | 0;\n        this.set(A, B, C, D, E, F, G, H);\n    }\n    roundClean() {\n        clean(SHA256_W);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        clean(this.buffer);\n    }\n}\n/** Internal SHA2-256 hash class. */\nexport class _SHA256 extends SHA2_32B {\n    // We cannot use array here since array allows indexing by variable\n    // which means optimizer/compiler cannot use registers.\n    A = SHA256_IV[0] | 0;\n    B = SHA256_IV[1] | 0;\n    C = SHA256_IV[2] | 0;\n    D = SHA256_IV[3] | 0;\n    E = SHA256_IV[4] | 0;\n    F = SHA256_IV[5] | 0;\n    G = SHA256_IV[6] | 0;\n    H = SHA256_IV[7] | 0;\n    constructor() {\n        super(32);\n    }\n}\n/** Internal SHA2-224 hash class. */\nexport class _SHA224 extends SHA2_32B {\n    A = SHA224_IV[0] | 0;\n    B = SHA224_IV[1] | 0;\n    C = SHA224_IV[2] | 0;\n    D = SHA224_IV[3] | 0;\n    E = SHA224_IV[4] | 0;\n    F = SHA224_IV[5] | 0;\n    G = SHA224_IV[6] | 0;\n    H = SHA224_IV[7] | 0;\n    constructor() {\n        super(28);\n    }\n}\n// SHA2-512 is slower than sha256 in js because u64 operations are slow.\n// Round contants\n// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409\n// prettier-ignore\nconst K512 = /* @__PURE__ */ (() => u64.split([\n    '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',\n    '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',\n    '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',\n    '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',\n    '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',\n    '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',\n    '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',\n    '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',\n    '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',\n    '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',\n    '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',\n    '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',\n    '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',\n    '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',\n    '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',\n    '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',\n    '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',\n    '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',\n    '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',\n    '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'\n].map(n => BigInt(n))))();\nconst SHA512_Kh = /* @__PURE__ */ (() => K512[0])();\nconst SHA512_Kl = /* @__PURE__ */ (() => K512[1])();\n// Reusable temporary buffers\nconst SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);\nconst SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);\n/** Internal 64-byte base SHA2 hash class. */\nclass SHA2_64B extends HashMD {\n    constructor(outputLen) {\n        super(128, outputLen, 16, false);\n    }\n    // prettier-ignore\n    get() {\n        const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n    }\n    // prettier-ignore\n    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {\n        this.Ah = Ah | 0;\n        this.Al = Al | 0;\n        this.Bh = Bh | 0;\n        this.Bl = Bl | 0;\n        this.Ch = Ch | 0;\n        this.Cl = Cl | 0;\n        this.Dh = Dh | 0;\n        this.Dl = Dl | 0;\n        this.Eh = Eh | 0;\n        this.El = El | 0;\n        this.Fh = Fh | 0;\n        this.Fl = Fl | 0;\n        this.Gh = Gh | 0;\n        this.Gl = Gl | 0;\n        this.Hh = Hh | 0;\n        this.Hl = Hl | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4) {\n            SHA512_W_H[i] = view.getUint32(offset);\n            SHA512_W_L[i] = view.getUint32((offset += 4));\n        }\n        for (let i = 16; i < 80; i++) {\n            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n            const W15h = SHA512_W_H[i - 15] | 0;\n            const W15l = SHA512_W_L[i - 15] | 0;\n            const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n            const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);\n            // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\n            const W2h = SHA512_W_H[i - 2] | 0;\n            const W2l = SHA512_W_L[i - 2] | 0;\n            const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n            const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n            const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n            const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\n            SHA512_W_H[i] = SUMh | 0;\n            SHA512_W_L[i] = SUMl | 0;\n        }\n        let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        // Compression function main loop, 80 rounds\n        for (let i = 0; i < 80; i++) {\n            // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\n            const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n            const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);\n            //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const CHIh = (Eh & Fh) ^ (~Eh & Gh);\n            const CHIl = (El & Fl) ^ (~El & Gl);\n            // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\n            // prettier-ignore\n            const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n            const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\n            const T1l = T1ll | 0;\n            // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\n            const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n            const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);\n            const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\n            const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\n            Hh = Gh | 0;\n            Hl = Gl | 0;\n            Gh = Fh | 0;\n            Gl = Fl | 0;\n            Fh = Eh | 0;\n            Fl = El | 0;\n            ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));\n            Dh = Ch | 0;\n            Dl = Cl | 0;\n            Ch = Bh | 0;\n            Cl = Bl | 0;\n            Bh = Ah | 0;\n            Bl = Al | 0;\n            const All = u64.add3L(T1l, sigma0l, MAJl);\n            Ah = u64.add3H(All, T1h, sigma0h, MAJh);\n            Al = All | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\n        ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\n        ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\n        ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\n        ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\n        ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\n        ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\n        ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));\n        this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\n    }\n    roundClean() {\n        clean(SHA512_W_H, SHA512_W_L);\n    }\n    destroy() {\n        clean(this.buffer);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\n/** Internal SHA2-512 hash class. */\nexport class _SHA512 extends SHA2_64B {\n    Ah = SHA512_IV[0] | 0;\n    Al = SHA512_IV[1] | 0;\n    Bh = SHA512_IV[2] | 0;\n    Bl = SHA512_IV[3] | 0;\n    Ch = SHA512_IV[4] | 0;\n    Cl = SHA512_IV[5] | 0;\n    Dh = SHA512_IV[6] | 0;\n    Dl = SHA512_IV[7] | 0;\n    Eh = SHA512_IV[8] | 0;\n    El = SHA512_IV[9] | 0;\n    Fh = SHA512_IV[10] | 0;\n    Fl = SHA512_IV[11] | 0;\n    Gh = SHA512_IV[12] | 0;\n    Gl = SHA512_IV[13] | 0;\n    Hh = SHA512_IV[14] | 0;\n    Hl = SHA512_IV[15] | 0;\n    constructor() {\n        super(64);\n    }\n}\n/** Internal SHA2-384 hash class. */\nexport class _SHA384 extends SHA2_64B {\n    Ah = SHA384_IV[0] | 0;\n    Al = SHA384_IV[1] | 0;\n    Bh = SHA384_IV[2] | 0;\n    Bl = SHA384_IV[3] | 0;\n    Ch = SHA384_IV[4] | 0;\n    Cl = SHA384_IV[5] | 0;\n    Dh = SHA384_IV[6] | 0;\n    Dl = SHA384_IV[7] | 0;\n    Eh = SHA384_IV[8] | 0;\n    El = SHA384_IV[9] | 0;\n    Fh = SHA384_IV[10] | 0;\n    Fl = SHA384_IV[11] | 0;\n    Gh = SHA384_IV[12] | 0;\n    Gl = SHA384_IV[13] | 0;\n    Hh = SHA384_IV[14] | 0;\n    Hl = SHA384_IV[15] | 0;\n    constructor() {\n        super(48);\n    }\n}\n/**\n * Truncated SHA512/256 and SHA512/224.\n * SHA512_IV is XORed with 0xa5a5a5a5a5a5a5a5, then used as \"intermediary\" IV of SHA512/t.\n * Then t hashes string to produce result IV.\n * See `test/misc/sha2-gen-iv.js`.\n */\n/** SHA512/224 IV */\nconst T224_IV = /* @__PURE__ */ Uint32Array.from([\n    0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf,\n    0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1,\n]);\n/** SHA512/256 IV */\nconst T256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd,\n    0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2,\n]);\n/** Internal SHA2-512/224 hash class. */\nexport class _SHA512_224 extends SHA2_64B {\n    Ah = T224_IV[0] | 0;\n    Al = T224_IV[1] | 0;\n    Bh = T224_IV[2] | 0;\n    Bl = T224_IV[3] | 0;\n    Ch = T224_IV[4] | 0;\n    Cl = T224_IV[5] | 0;\n    Dh = T224_IV[6] | 0;\n    Dl = T224_IV[7] | 0;\n    Eh = T224_IV[8] | 0;\n    El = T224_IV[9] | 0;\n    Fh = T224_IV[10] | 0;\n    Fl = T224_IV[11] | 0;\n    Gh = T224_IV[12] | 0;\n    Gl = T224_IV[13] | 0;\n    Hh = T224_IV[14] | 0;\n    Hl = T224_IV[15] | 0;\n    constructor() {\n        super(28);\n    }\n}\n/** Internal SHA2-512/256 hash class. */\nexport class _SHA512_256 extends SHA2_64B {\n    Ah = T256_IV[0] | 0;\n    Al = T256_IV[1] | 0;\n    Bh = T256_IV[2] | 0;\n    Bl = T256_IV[3] | 0;\n    Ch = T256_IV[4] | 0;\n    Cl = T256_IV[5] | 0;\n    Dh = T256_IV[6] | 0;\n    Dl = T256_IV[7] | 0;\n    Eh = T256_IV[8] | 0;\n    El = T256_IV[9] | 0;\n    Fh = T256_IV[10] | 0;\n    Fl = T256_IV[11] | 0;\n    Gh = T256_IV[12] | 0;\n    Gl = T256_IV[13] | 0;\n    Hh = T256_IV[14] | 0;\n    Hl = T256_IV[15] | 0;\n    constructor() {\n        super(32);\n    }\n}\n/**\n * SHA2-256 hash function from RFC 4634. In JS it's the fastest: even faster than Blake3. Some info:\n *\n * - Trying 2^128 hashes would get 50% chance of collision, using birthday attack.\n * - BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n * - Each sha256 hash is executing 2^18 bit operations.\n * - Good 2024 ASICs can do 200Th/sec with 3500 watts of power, corresponding to 2^36 hashes/joule.\n */\nexport const sha256 = /* @__PURE__ */ createHasher(() => new _SHA256(), \n/* @__PURE__ */ oidNist(0x01));\n/** SHA2-224 hash function from RFC 4634 */\nexport const sha224 = /* @__PURE__ */ createHasher(() => new _SHA224(), \n/* @__PURE__ */ oidNist(0x04));\n/** SHA2-512 hash function from RFC 4634. */\nexport const sha512 = /* @__PURE__ */ createHasher(() => new _SHA512(), \n/* @__PURE__ */ oidNist(0x03));\n/** SHA2-384 hash function from RFC 4634. */\nexport const sha384 = /* @__PURE__ */ createHasher(() => new _SHA384(), \n/* @__PURE__ */ oidNist(0x02));\n/**\n * SHA2-512/256 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_256 = /* @__PURE__ */ createHasher(() => new _SHA512_256(), \n/* @__PURE__ */ oidNist(0x06));\n/**\n * SHA2-512/224 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_224 = /* @__PURE__ */ createHasher(() => new _SHA512_224(), \n/* @__PURE__ */ oidNist(0x05));\n//# sourceMappingURL=sha2.js.map","/**\n * HTLC Secret / Hashlock Utilities\n *\n * Pure functions for computing and validating SHA-256 hashlocks used in the\n * vault deposit protocol's HTLC (Hash Time Lock Contract).\n *\n * The SDK does NOT generate secrets — that is the caller's responsibility.\n * Today callers use `crypto.getRandomValues(32)`; when the `deriveContextHash`\n * wallet API ships, callers will use `wallet.deriveContextHash(\"babylon-vault\", ctx)`.\n * These utilities work identically regardless of how the secret was produced.\n *\n * On-chain contract validation (BTCVaultRegistry.activateVaultWithSecret):\n *   if (sha256(abi.encodePacked(s)) != hashlock) revert InvalidSecret();\n *\n * @module htlc\n */\n\nimport { sha256 } from \"@noble/hashes/sha2.js\";\nimport type { Hex } from \"viem\";\n\n/** Expected hex length for a 0x-prefixed bytes32 value. */\nconst HEX_BYTES32_LENGTH = 66; // \"0x\" + 64 hex chars\n\n/**\n * Decode a 0x-prefixed hex string to bytes, with strict validation.\n * @throws if the input is not a valid 0x-prefixed hex string\n */\nfunction hexToBytes(hex: Hex): Uint8Array {\n  if (!hex.startsWith(\"0x\") && !hex.startsWith(\"0X\")) {\n    throw new Error(\"Expected 0x-prefixed hex string\");\n  }\n  const clean = hex.slice(2);\n  if (clean.length % 2 !== 0) {\n    throw new Error(`Hex string has odd length: ${clean.length}`);\n  }\n  if (!/^[0-9a-fA-F]*$/.test(clean)) {\n    throw new Error(\"Hex string contains non-hex characters\");\n  }\n  const bytes = new Uint8Array(clean.length / 2);\n  for (let i = 0; i < bytes.length; i++) {\n    bytes[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);\n  }\n  return bytes;\n}\n\n/**\n * Encode a Uint8Array as a 0x-prefixed lowercase hex string.\n */\nfunction bytesToHex(bytes: Uint8Array): Hex {\n  return `0x${Array.from(bytes)\n    .map((b) => b.toString(16).padStart(2, \"0\"))\n    .join(\"\")}`;\n}\n\n/**\n * Validate that a value is a 0x-prefixed bytes32 (exactly 32 bytes).\n * @throws if the value is not exactly 32 bytes\n */\nfunction assertBytes32(value: Hex, label: string): void {\n  if (value.length !== HEX_BYTES32_LENGTH) {\n    throw new Error(\n      `${label} must be exactly 32 bytes (${HEX_BYTES32_LENGTH} hex chars with 0x prefix), got ${value.length}`,\n    );\n  }\n}\n\n/**\n * Compute the SHA-256 hashlock from a secret preimage.\n *\n * Matches the on-chain validation: `sha256(abi.encodePacked(s))` where `s` is a `bytes32`.\n * `abi.encodePacked(bytes32)` is just the raw 32 bytes — no ABI padding.\n *\n * @param secret - 0x-prefixed bytes32 secret (66 hex chars)\n * @returns 0x-prefixed bytes32 SHA-256 hash\n * @throws if secret is not exactly 32 bytes\n */\nexport function computeHashlock(secret: Hex): Hex {\n  assertBytes32(secret, \"Secret\");\n  const secretBytes = hexToBytes(secret);\n  const hash = sha256(secretBytes);\n  return bytesToHex(hash);\n}\n\n/**\n * Validate that a secret's SHA-256 hash matches the expected hashlock.\n *\n * Use this for client-side pre-validation before sending the activation\n * transaction to avoid wasting gas on a contract revert.\n *\n * @param secret - 0x-prefixed bytes32 secret (66 hex chars)\n * @param hashlock - 0x-prefixed bytes32 expected hashlock from the vault\n * @returns true if SHA-256(secret) matches the hashlock\n * @throws if secret or hashlock is not exactly 32 bytes\n */\nexport function validateSecretAgainstHashlock(\n  secret: Hex,\n  hashlock: Hex,\n): boolean {\n  assertBytes32(secret, \"Secret\");\n  assertBytes32(hashlock, \"Hashlock\");\n  // Validate hashlock is valid hex (secret is validated inside computeHashlock)\n  hexToBytes(hashlock);\n\n  const computed = computeHashlock(secret);\n  return computed.toLowerCase() === hashlock.toLowerCase();\n}\n","/**\n * Vault activation — reveal HTLC secret on Ethereum to move the vault from\n * Verified to Active. The on-chain contract validates `sha256(s) == hashlock`\n * and the activation deadline; this function pre-validates inputs (including\n * an optional hashlock check) and delegates the actual contract write to an\n * injected callback so the SDK stays transport-agnostic.\n *\n * @module services/activation\n */\n\nimport type { Abi, Address, Hash, Hex } from \"viem\";\n\nimport { BTCVaultRegistryABI } from \"../../contracts/abis/BTCVaultRegistry.abi\";\nimport { ensureHexPrefix } from \"../../primitives/utils/bitcoin\";\nimport { validateSecretAgainstHashlock } from \"../htlc\";\n\nconst BYTES32_HEX_RE = /^0x[0-9a-fA-F]{64}$/;\nconst ADDRESS_HEX_RE = /^0x[0-9a-fA-F]{40}$/;\n// ETH calldata convention: 0x prefix REQUIRED, even number of hex chars, may\n// be empty (\"0x\"). Named distinctly from the BTC-hex regex in\n// buildAndBroadcastRefund.ts (which allows an optional prefix and requires\n// non-empty) to make the convention explicit at the call site.\nconst ETH_HEX_BYTES_RE = /^0x([0-9a-fA-F]{2})*$/;\n\nfunction assertBytes32(value: string, label: string): void {\n  if (value.length !== 66) {\n    throw new Error(\n      `${label} must be 32 bytes (66 hex chars with 0x prefix), got length ${value.length}`,\n    );\n  }\n  if (!BYTES32_HEX_RE.test(value)) {\n    throw new Error(\n      `${label} must contain only hex characters after the 0x prefix`,\n    );\n  }\n}\n\nfunction assertAddress(value: string, label: string): void {\n  if (!ADDRESS_HEX_RE.test(value)) {\n    throw new Error(\n      `${label} must be a 20-byte 0x-prefixed hex address (42 chars)`,\n    );\n  }\n}\n\nfunction assertHexBytes(value: string, label: string): void {\n  if (!ETH_HEX_BYTES_RE.test(value)) {\n    throw new Error(\n      `${label} must be a 0x-prefixed hex string with an even number of hex chars`,\n    );\n  }\n}\n\n/**\n * A single ETH contract-write call. The SDK assembles these; the caller\n * executes them via viem, wagmi, a wallet provider, or any other transport.\n */\nexport interface EthContractWriteCall {\n  address: Address;\n  abi: Abi;\n  functionName: string;\n  args: readonly unknown[];\n}\n\n/**\n * Minimum shape the SDK requires from any contract-write result. Callers may\n * return richer objects (e.g. including the receipt) — the SDK propagates\n * them unchanged via the generic parameter on {@link EthContractWriter}.\n */\nexport interface EthContractWriteResult {\n  transactionHash: Hash;\n}\n\n/**\n * Caller-provided contract writer. The generic `R` lets callers return any\n * transport-specific result shape (e.g. `{ transactionHash, receipt }`);\n * the SDK forwards that shape back through `activateVault`.\n */\nexport type EthContractWriter<R extends EthContractWriteResult = EthContractWriteResult> = (\n  call: EthContractWriteCall,\n) => Promise<R>;\n\nexport interface ActivateVaultInput<\n  R extends EthContractWriteResult = EthContractWriteResult,\n> {\n  /** BTCVaultRegistry contract address (env-specific). */\n  btcVaultRegistryAddress: Address;\n  /** Vault ID (bytes32, 0x-prefixed). */\n  vaultId: Hex;\n  /**\n   * HTLC secret preimage (bytes32). A missing `0x` prefix or an uppercase\n   * `0X` prefix is normalised before validation.\n   */\n  secret: string;\n  /**\n   * Optional hashlock for client-side pre-validation. When provided, the SDK\n   * rejects before calling `writeContract` if `sha256(secret) != hashlock`.\n   */\n  hashlock?: Hex;\n  /**\n   * Activation metadata passed through to the contract. Required to keep\n   * the \"empty metadata\" convention explicit at the call site — pass `\"0x\"`\n   * (empty bytes) when no metadata is needed. Must be a 0x-prefixed hex\n   * string with an even number of hex chars.\n   */\n  activationMetadata: Hex;\n  /** Caller-provided write callback — see {@link EthContractWriter}. */\n  writeContract: EthContractWriter<R>;\n  /**\n   * Optional abort signal. Checked before validation runs; since validation\n   * is fully synchronous, cancellation between validation and the write is\n   * not observable and callers should rely on the transport's own\n   * cancellation support for that window.\n   */\n  signal?: AbortSignal;\n}\n\n/**\n * Reveal the HTLC secret on Ethereum and activate the vault.\n *\n * Validates inputs, optionally pre-checks the secret against the expected\n * hashlock, and delegates the contract write to `writeContract`. Returns\n * whatever the writer returns so callers can keep richer transport-specific\n * metadata (e.g. viem receipts) end-to-end.\n *\n * @throws `Error` if `btcVaultRegistryAddress` is not a valid 20-byte address\n * @throws `Error` if `vaultId` or `secret` is not a valid 32-byte hex\n * @throws `Error` if `hashlock` is provided and is not a valid 32-byte hex,\n *         or if `sha256(secret) != hashlock`\n * @throws `Error` if `activationMetadata` is not a 0x-prefixed hex byte\n *         string (must have an even number of hex chars). Pass `\"0x\"` for\n *         empty metadata.\n * @throws whatever the injected `writeContract` throws\n * @throws `AbortError` / caller-provided abort reason if `signal` aborts\n */\nexport async function activateVault<\n  R extends EthContractWriteResult = EthContractWriteResult,\n>(input: ActivateVaultInput<R>): Promise<R> {\n  const {\n    btcVaultRegistryAddress,\n    vaultId,\n    hashlock,\n    activationMetadata,\n    writeContract,\n    signal,\n  } = input;\n\n  signal?.throwIfAborted();\n\n  assertAddress(btcVaultRegistryAddress, \"btcVaultRegistryAddress\");\n  assertBytes32(vaultId, \"vaultId\");\n\n  const normalizedSecret = ensureHexPrefix(input.secret);\n  assertBytes32(normalizedSecret, \"secret\");\n\n  if (hashlock !== undefined) {\n    assertBytes32(hashlock, \"hashlock\");\n    if (!validateSecretAgainstHashlock(normalizedSecret, hashlock)) {\n      throw new Error(\n        \"Invalid secret: SHA256(secret) does not match the provided hashlock\",\n      );\n    }\n  }\n\n  assertHexBytes(activationMetadata, \"activationMetadata\");\n\n  return writeContract({\n    address: btcVaultRegistryAddress,\n    abi: BTCVaultRegistryABI,\n    functionName: \"activateVaultWithSecret\",\n    args: [vaultId, normalizedSecret, activationMetadata],\n  });\n}\n","/**\n * Poll `getPeginStatus` until the VP reaches one of the target statuses.\n *\n * Pure polling utility with no framework dependencies (no localStorage, no React).\n * Handles \"PegIn not found\" as transient (VP hasn't ingested yet).\n */\n\nimport { JsonRpcError } from \"../../clients/vault-provider/json-rpc-client\";\nimport {\n  RpcErrorCode,\n  VP_TERMINAL_STATUSES,\n  type DaemonStatus,\n} from \"../../clients/vault-provider/types\";\nimport type { PeginStatusReader } from \"./interfaces\";\n\n/** Default polling interval (10 seconds). */\nconst DEFAULT_POLL_INTERVAL_MS = 10_000;\n\nexport interface WaitForPeginStatusParams {\n  /** VP client implementing the status reader interface */\n  statusReader: PeginStatusReader;\n  /** BTC pegin transaction ID (unprefixed hex, 64 chars) */\n  peginTxid: string;\n  /** Set of acceptable statuses — polling stops when the VP reports one of these */\n  targetStatuses: ReadonlySet<DaemonStatus>;\n  /** Maximum time to wait in milliseconds */\n  timeoutMs: number;\n  /** Polling interval in milliseconds (default: 10s) */\n  pollIntervalMs?: number;\n  /** AbortSignal for cancellation */\n  signal?: AbortSignal;\n}\n\n/**\n * Poll `getPeginStatus` until the VP reaches one of the target statuses.\n *\n * @returns The DaemonStatus string that matched one of the targets\n * @throws Error on timeout, abort, or non-transient RPC error\n */\nexport async function waitForPeginStatus(\n  params: WaitForPeginStatusParams,\n): Promise<DaemonStatus> {\n  const {\n    statusReader,\n    peginTxid,\n    targetStatuses,\n    timeoutMs,\n    pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,\n    signal,\n  } = params;\n\n  const startTime = Date.now();\n\n  while (true) {\n    if (signal?.aborted) {\n      throw new Error(\n        `Polling aborted for pegin ${peginTxid.slice(0, 8)}… (target: ${[...targetStatuses].join(\", \")})`,\n      );\n    }\n\n    if (Date.now() - startTime >= timeoutMs) {\n      throw new Error(\n        `Polling timeout after ${timeoutMs}ms for pegin ${peginTxid.slice(0, 8)}… (target: ${[...targetStatuses].join(\", \")})`,\n      );\n    }\n\n    try {\n      const response = await statusReader.getPeginStatus(\n        { pegin_txid: peginTxid },\n        signal,\n      );\n\n      const status = response.status as DaemonStatus;\n      if (targetStatuses.has(status)) {\n        return status;\n      }\n      // Fail fast on terminal statuses to avoid waiting for timeout\n      if (VP_TERMINAL_STATUSES.has(status) && !targetStatuses.has(status)) {\n        throw new Error(\n          `Pegin ${peginTxid.slice(0, 8)}… reached terminal status \"${status}\" while waiting for ${[...targetStatuses].join(\", \")}`,\n        );\n      }\n    } catch (error) {\n      // \"PegIn not found\" is transient — VP hasn't ingested the pegin yet.\n      // Check structured error code first, fall back to message matching.\n      const isNotFound =\n        (error instanceof JsonRpcError &&\n          error.code === RpcErrorCode.NOT_FOUND) ||\n        (error instanceof Error && error.message.includes(\"PegIn not found\"));\n      if (!isNotFound) {\n        throw error;\n      }\n    }\n\n    // Wait before next poll, with abort support\n    await new Promise<void>((resolve, reject) => {\n      const onAbort = () => {\n        clearTimeout(timeoutId);\n        reject(\n          new Error(\n            `Polling aborted for pegin ${peginTxid.slice(0, 8)}… (target: ${[...targetStatuses].join(\", \")})`,\n          ),\n        );\n      };\n      const timeoutId = setTimeout(() => {\n        signal?.removeEventListener(\"abort\", onAbort);\n        resolve();\n      }, pollIntervalMs);\n      signal?.addEventListener(\"abort\", onAbort, { once: true });\n    });\n  }\n}\n","/**\n * Submit pre-derived WOTS public keys to the vault provider.\n *\n * Polls `getPeginStatus` until the VP reaches `PendingDepositorWotsPK`,\n * then submits the keys. If the VP has already moved past WOTS step\n * (e.g., resume flow), submission is skipped.\n *\n * The caller is responsible for deriving WOTS keys externally using\n * `mnemonicToWotsSeed` + `deriveWotsBlockPublicKeys` from the SDK's\n * `tbv/core/wots` module.\n */\n\nimport {\n  DaemonStatus,\n  POST_WOTS_STATUSES,\n  type WotsBlockPublicKey,\n} from \"../../clients/vault-provider/types\";\nimport type { PeginStatusReader, WotsKeySubmitter } from \"./interfaces\";\nimport { waitForPeginStatus } from \"./waitForPeginStatus\";\n\n/** Maximum time to wait for VP to reach PendingDepositorWotsPK (5 min). */\nconst STATUS_POLL_TIMEOUT_MS = 5 * 60 * 1000;\n\n/** All statuses we accept — either ready for submission or already past it. */\nconst TARGET_STATUSES: ReadonlySet<DaemonStatus> = new Set([\n  DaemonStatus.PENDING_DEPOSITOR_WOTS_PK,\n  ...POST_WOTS_STATUSES,\n]);\n\nexport interface SubmitWotsPublicKeyParams {\n  /** VP client implementing the status reader interface */\n  statusReader: PeginStatusReader;\n  /** VP client implementing the WOTS key submission interface */\n  wotsSubmitter: WotsKeySubmitter;\n  /** BTC pegin transaction ID (unprefixed hex, 64 chars) */\n  peginTxid: string;\n  /** Depositor's x-only BTC public key (unprefixed hex, 64 chars) */\n  depositorPk: string;\n  /** Pre-derived WOTS block public keys (one per assert block) */\n  wotsPublicKeys: WotsBlockPublicKey[];\n  /** Maximum time to wait for VP to be ready (default: 5 min) */\n  timeoutMs?: number;\n  /** AbortSignal for cancellation */\n  signal?: AbortSignal;\n}\n\n/**\n * Submit WOTS public keys to the vault provider.\n *\n * @throws Error on timeout, abort, or RPC error\n */\nexport async function submitWotsPublicKey(\n  params: SubmitWotsPublicKeyParams,\n): Promise<void> {\n  const {\n    statusReader,\n    wotsSubmitter,\n    peginTxid,\n    depositorPk,\n    wotsPublicKeys,\n    timeoutMs = STATUS_POLL_TIMEOUT_MS,\n    signal,\n  } = params;\n\n  signal?.throwIfAborted();\n\n  // Wait until VP has ingested the pegin and is ready for the WOTS key.\n  const status = await waitForPeginStatus({\n    statusReader,\n    peginTxid,\n    targetStatuses: TARGET_STATUSES,\n    timeoutMs,\n    signal,\n  });\n\n  // Key was already submitted in a previous session (e.g. resume flow)\n  if (POST_WOTS_STATUSES.has(status)) {\n    return;\n  }\n\n  signal?.throwIfAborted();\n\n  await wotsSubmitter.submitDepositorWotsKey(\n    {\n      pegin_txid: peginTxid,\n      depositor_pk: depositorPk,\n      wots_public_keys: wotsPublicKeys,\n    },\n    signal,\n  );\n}\n","/**\n * Depositor Graph Signing Service\n *\n * Signs the depositor's own graph transactions (Payout, NoPayout per challenger)\n * using pre-built PSBTs from the vault provider.\n *\n * The VP returns unsigned PSBTs with prevouts, scripts, and taproot metadata\n * already embedded (BIP 174), so any standard PSBT-compatible signer can\n * produce signatures without extra context.\n *\n * Transaction counts: 1 Payout + N NoPayout = 1 + N total PSBTs\n *\n * @see btc-vault docs/pegin.md — \"Automatic Graph Creation & Presigning\"\n */\n\nimport { Psbt } from \"bitcoinjs-lib\";\n\nimport type { BitcoinWallet, SignPsbtOptions } from \"../../../../shared/wallets/interfaces\";\nimport type {\n  DepositorAsClaimerPresignatures,\n  DepositorGraphTransactions,\n  DepositorPreSigsPerChallenger,\n} from \"../../clients/vault-provider/types\";\nimport { extractPayoutSignature } from \"../../primitives/psbt/payout\";\nimport { stripHexPrefix } from \"../../primitives/utils/bitcoin\";\nimport { createTaprootScriptPathSignOptions } from \"../../utils/signing\";\n\n/**\n * Each payout/nopayout PSBT has exactly one input that needs signing.\n * Used to construct SignPsbtOptions for wallet.signPsbt().\n */\nconst SINGLE_PSBT_INPUT_COUNT = 1;\n\n/** Tracks which indices in the flat PSBT array belong to which challenger */\ninterface ChallengerEntry {\n  challengerPubkey: string;\n  noPayoutIdx: number;\n}\n\n/** Result of the collect phase — flat PSBT array with index mapping */\ninterface CollectedDepositorGraphPsbts {\n  psbtHexes: string[];\n  signOptions: SignPsbtOptions[];\n  challengerEntries: ChallengerEntry[];\n}\n\n// ============================================================================\n// PSBT verification — ensure pre-built PSBTs match advertised tx_hex\n// ============================================================================\n\n/**\n * Parse a base64-encoded PSBT and verify its unsigned transaction matches\n * the expected transaction hex. Catches VP serialization bugs.\n */\nfunction verifyAndParsePsbt(\n  psbtBase64: string,\n  expectedTxHex: string,\n  label: string,\n): Psbt {\n  const psbt = Psbt.fromBase64(psbtBase64);\n  const unsignedTxHex = psbt.data\n    .getTransaction()\n    .toString(\"hex\")\n    .toLowerCase();\n  const normalizedExpected = stripHexPrefix(expectedTxHex).toLowerCase();\n  if (unsignedTxHex !== normalizedExpected) {\n    throw new Error(\n      `PSBT integrity check failed for ${label}: unsigned transaction does not match tx_hex`,\n    );\n  }\n  return psbt;\n}\n\n/**\n * Sanitize a parsed PSBT for Taproot script-path signing.\n *\n * VP-provided PSBTs include tapBip32Derivation and tapMerkleRoot metadata\n * that causes some wallets (notably OKX) to ignore disableTweakSigner and\n * sign with a tweaked key. Stripping these fields forces the wallet to\n * rely solely on tapLeafScript for script-path signing.\n */\nfunction sanitizePsbtForScriptPathSigning(psbt: Psbt): Psbt {\n  const clone = Psbt.fromHex(psbt.toHex());\n  for (const input of clone.data.inputs) {\n    delete input.tapBip32Derivation;\n    delete input.tapMerkleRoot;\n  }\n  return clone;\n}\n\n/**\n * Validate, verify integrity, sanitize, and convert a PSBT to hex.\n */\nfunction validateAndConvertPsbt(\n  psbtBase64: string | undefined,\n  expectedTxHex: string,\n  label: string,\n): string {\n  if (!psbtBase64) {\n    throw new Error(`Missing ${label} PSBT`);\n  }\n  const psbt = verifyAndParsePsbt(psbtBase64, expectedTxHex, label);\n  const sanitized = sanitizePsbtForScriptPathSigning(psbt);\n  return sanitized.toHex();\n}\n\n// ============================================================================\n// Collect phase — decode pre-built PSBTs from VP response\n// ============================================================================\n\n/**\n * Collect all pre-built PSBTs from the depositor graph and track their indices.\n * Layout: [Payout, NoPayout_0, NoPayout_1, ...]\n */\nfunction collectDepositorGraphPsbts(\n  depositorGraph: DepositorGraphTransactions,\n  walletPublicKey: string,\n): CollectedDepositorGraphPsbts {\n  const psbtHexes: string[] = [];\n  const signOptions: SignPsbtOptions[] = [];\n  const challengerEntries: ChallengerEntry[] = [];\n\n  const singleInputOpts = createTaprootScriptPathSignOptions(\n    walletPublicKey,\n    SINGLE_PSBT_INPUT_COUNT,\n  );\n\n  // Index 0: Payout PSBT\n  const payoutHex = validateAndConvertPsbt(\n    depositorGraph.payout_psbt,\n    depositorGraph.payout_tx.tx_hex,\n    \"depositor payout\",\n  );\n  psbtHexes.push(payoutHex);\n  signOptions.push(singleInputOpts);\n\n  // Per-challenger: 1 NoPayout\n  for (const challenger of depositorGraph.challenger_presign_data) {\n    const challengerPubkey = stripHexPrefix(challenger.challenger_pubkey);\n\n    const noPayoutIdx = psbtHexes.length;\n    const noPayoutHex = validateAndConvertPsbt(\n      challenger.nopayout_psbt,\n      challenger.nopayout_tx.tx_hex,\n      `nopayout (challenger ${challengerPubkey})`,\n    );\n    psbtHexes.push(noPayoutHex);\n    signOptions.push(singleInputOpts);\n\n    challengerEntries.push({\n      challengerPubkey,\n      noPayoutIdx,\n    });\n  }\n\n  return { psbtHexes, signOptions, challengerEntries };\n}\n\n// ============================================================================\n// Extract phase\n// ============================================================================\n\n/**\n * Extract all signatures from signed PSBTs and assemble into presignatures.\n */\nfunction extractDepositorGraphSignatures(\n  signedPsbtHexes: string[],\n  challengerEntries: ChallengerEntry[],\n  depositorPubkey: string,\n): DepositorAsClaimerPresignatures {\n  const payoutSignature = extractPayoutSignature(\n    signedPsbtHexes[0],\n    depositorPubkey,\n  );\n\n  const perChallenger: Record<string, DepositorPreSigsPerChallenger> = {};\n  for (const entry of challengerEntries) {\n    perChallenger[entry.challengerPubkey] = {\n      nopayout_signature: extractPayoutSignature(\n        signedPsbtHexes[entry.noPayoutIdx],\n        depositorPubkey,\n      ),\n    };\n  }\n\n  return {\n    payout_signatures: {\n      payout_signature: payoutSignature,\n    },\n    per_challenger: perChallenger,\n  };\n}\n\n/**\n * Sign multiple PSBTs, using batch signing when the wallet supports it.\n * Falls back to sequential `signPsbt` calls for wallets without `signPsbts`.\n */\nasync function signPsbtsWithFallback(\n  wallet: BitcoinWallet,\n  psbtHexes: string[],\n  options?: SignPsbtOptions[],\n): Promise<string[]> {\n  if (typeof wallet.signPsbts === \"function\") {\n    return wallet.signPsbts(psbtHexes, options);\n  }\n\n  const signed: string[] = [];\n  for (let i = 0; i < psbtHexes.length; i++) {\n    signed.push(await wallet.signPsbt(psbtHexes[i], options?.[i]));\n  }\n  return signed;\n}\n\n// ============================================================================\n// Main entry point\n// ============================================================================\n\nexport interface SignDepositorGraphParams {\n  /** The depositor graph from VP response (contains pre-built PSBTs) */\n  depositorGraph: DepositorGraphTransactions;\n  /** Depositor's BTC public key (x-only, 64-char hex, no 0x prefix) */\n  depositorBtcPubkey: string;\n  /** Bitcoin wallet for signing */\n  btcWallet: BitcoinWallet;\n}\n\n/**\n * Sign all depositor graph transactions and assemble into presignatures.\n *\n * Flow:\n * 1. Collect pre-built PSBTs from VP response (base64 -> hex)\n * 2. Batch sign via wallet.signPsbts() if available, else sequential signPsbt()\n * 3. Extract Schnorr signatures from each signed PSBT\n * 4. Assemble into DepositorAsClaimerPresignatures\n */\nexport async function signDepositorGraph(\n  params: SignDepositorGraphParams,\n): Promise<DepositorAsClaimerPresignatures> {\n  const { depositorGraph, depositorBtcPubkey, btcWallet } = params;\n\n  const depositorPubkey = stripHexPrefix(depositorBtcPubkey);\n  const walletPublicKey = await btcWallet.getPublicKeyHex();\n\n  // 1. Collect pre-built PSBTs from VP response\n  const { psbtHexes, signOptions, challengerEntries } =\n    collectDepositorGraphPsbts(depositorGraph, walletPublicKey);\n\n  // 2. Sign all PSBTs (batch when supported, sequential fallback for mobile)\n  const signedPsbtHexes = await signPsbtsWithFallback(\n    btcWallet,\n    psbtHexes,\n    signOptions,\n  );\n\n  if (signedPsbtHexes.length !== psbtHexes.length) {\n    throw new Error(\n      `Wallet returned ${signedPsbtHexes.length} signed PSBTs, expected ${psbtHexes.length}`,\n    );\n  }\n\n  // 3. Extract signatures and assemble presignatures\n  return extractDepositorGraphSignatures(\n    signedPsbtHexes,\n    challengerEntries,\n    depositorPubkey,\n  );\n}\n","/**\n * Payout Signing Orchestration\n *\n * Polls VP for `PendingDepositorSignatures`, fetches presign transactions,\n * signs payouts via PayoutManager, signs the depositor graph, and submits\n * all signatures back to the VP.\n *\n * This is the main deposit protocol step between registration and activation.\n */\n\nimport type { Network } from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\nimport * as bitcoin from \"bitcoinjs-lib\";\nimport { Buffer } from \"buffer\";\n\nimport type { BitcoinWallet } from \"../../../../shared/wallets/interfaces\";\nimport { DaemonStatus } from \"../../clients/vault-provider/types\";\nimport type {\n  ClaimerSignatures,\n  ClaimerTransactions,\n} from \"../../clients/vault-provider/types\";\nimport { PayoutManager } from \"../../managers/PayoutManager\";\nimport {\n  processPublicKeyToXOnly,\n  stripHexPrefix,\n} from \"../../primitives/utils/bitcoin\";\nimport type { PeginStatusReader, PresignClient } from \"./interfaces\";\nimport { signDepositorGraph } from \"./signDepositorGraph\";\nimport { waitForPeginStatus } from \"./waitForPeginStatus\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * Context required for signing payout transactions.\n * Caller builds this from on-chain data (contract queries, GraphQL, config).\n */\nexport interface PayoutSigningContext {\n  /** Raw pegin BTC transaction hex (for PSBT construction) */\n  peginTxHex: string;\n  /** Vault provider's BTC public key (x-only hex, no prefix) */\n  vaultProviderBtcPubkey: string;\n  /** Sorted vault keeper BTC public keys (x-only hex, no prefix) */\n  vaultKeeperBtcPubkeys: string[];\n  /** Sorted universal challenger BTC public keys (x-only hex, no prefix) */\n  universalChallengerBtcPubkeys: string[];\n  /** Depositor's BTC public key (x-only hex, no prefix) */\n  depositorBtcPubkey: string;\n  /** Pegin timelock from the locked offchain params version */\n  timelockPegin: number;\n  /** BTC network (Mainnet, Testnet, etc.) */\n  network: Network;\n  /** On-chain registered depositor payout scriptPubKey (hex) */\n  registeredPayoutScriptPubKey: string;\n}\n\nexport interface PollAndSignPayoutsParams {\n  /** VP client implementing the status reader interface */\n  statusReader: PeginStatusReader;\n  /** VP client implementing the presign transaction flow interface */\n  presignClient: PresignClient;\n  /** Bitcoin wallet for signing */\n  btcWallet: BitcoinWallet;\n  /** BTC pegin transaction ID (unprefixed hex, 64 chars) */\n  peginTxid: string;\n  /** Depositor's x-only BTC public key (unprefixed hex, 64 chars) */\n  depositorPk: string;\n  /** Signing context built from on-chain data */\n  signingContext: PayoutSigningContext;\n  /** Maximum polling timeout in milliseconds (default: 20 min) */\n  timeoutMs?: number;\n  /** AbortSignal for cancellation */\n  signal?: AbortSignal;\n  /** Optional progress callback (completed claimers, total claimers) */\n  onProgress?: (completed: number, total: number) => void;\n}\n\n// ============================================================================\n// Constants\n// ============================================================================\n\n/** Maximum polling timeout (20 minutes) — VP may take 15-20 min to prepare. */\nconst MAX_POLLING_TIMEOUT_MS = 20 * 60 * 1000;\n\n/** Statuses after payout signatures are submitted — if VP is already here, skip. */\nconst POST_PAYOUT_STATUSES: ReadonlySet<DaemonStatus> = new Set([\n  DaemonStatus.PENDING_ACKS,\n  DaemonStatus.PENDING_ACTIVATION,\n  DaemonStatus.ACTIVATED,\n]);\n\nconst TARGET_STATUS: ReadonlySet<DaemonStatus> = new Set([\n  DaemonStatus.PENDING_DEPOSITOR_SIGNATURES,\n  ...POST_PAYOUT_STATUSES,\n]);\n\n// ============================================================================\n// Internal helpers\n// ============================================================================\n\ninterface PreparedTransaction {\n  claimerPubkeyXOnly: string;\n  payoutTxHex: string;\n  assertTxHex: string;\n}\n\nfunction prepareTransactionsForSigning(\n  claimerTransactions: ClaimerTransactions[],\n): PreparedTransaction[] {\n  return claimerTransactions.map((tx) => ({\n    claimerPubkeyXOnly: processPublicKeyToXOnly(tx.claimer_pubkey),\n    payoutTxHex: tx.payout_tx.tx_hex,\n    assertTxHex: tx.assert_tx.tx_hex,\n  }));\n}\n\n/**\n * Derive BIP-86 P2TR scriptPubKey hex from an x-only public key.\n * Requires bitcoinjs-lib ECC to be initialized by the caller.\n */\nfunction deriveBip86ScriptPubKey(xOnlyPubkeyHex: string): string {\n  const { output } = bitcoin.payments.p2tr({\n    internalPubkey: Buffer.from(xOnlyPubkeyHex, \"hex\"),\n  });\n  if (!output) {\n    throw new Error(\"Failed to derive BIP-86 P2TR scriptPubKey\");\n  }\n  return output.toString(\"hex\");\n}\n\n/**\n * Resolve the expected payout scriptPubKey for a given claimer.\n *\n * - VP/Depositor claimer: payout goes to the depositor's registered payout address\n * - VK claimer: payout goes to a BIP-86 P2TR address derived from the VK's pubkey\n *\n * Note: BIP-86 derivation for VK claimers requires bitcoinjs-lib's ECC to be initialized.\n */\nfunction resolvePayoutScriptPubKey(\n  claimerPubkeyXOnly: string,\n  context: PayoutSigningContext,\n): string {\n  const claimer = stripHexPrefix(claimerPubkeyXOnly).toLowerCase();\n  const vpPubkey = stripHexPrefix(\n    context.vaultProviderBtcPubkey,\n  ).toLowerCase();\n  const depositorPubkey = stripHexPrefix(\n    context.depositorBtcPubkey,\n  ).toLowerCase();\n\n  if (claimer === vpPubkey || claimer === depositorPubkey) {\n    return context.registeredPayoutScriptPubKey;\n  }\n\n  // Verify claimer is a known vault keeper\n  const isVaultKeeper = context.vaultKeeperBtcPubkeys.some(\n    (vk) => stripHexPrefix(vk).toLowerCase() === claimer,\n  );\n  if (!isVaultKeeper) {\n    throw new Error(\n      `Unknown claimer pubkey ${claimer}: not VP, depositor, or a registered vault keeper`,\n    );\n  }\n\n  // VK claimer: derive BIP-86 P2TR scriptPubKey from the VK's x-only pubkey\n  const scriptPubKey = deriveBip86ScriptPubKey(claimer);\n  return `0x${scriptPubKey}`;\n}\n\nfunction buildPayoutSigningInput(\n  tx: PreparedTransaction,\n  context: PayoutSigningContext,\n) {\n  return {\n    payoutTxHex: tx.payoutTxHex,\n    peginTxHex: context.peginTxHex,\n    assertTxHex: tx.assertTxHex,\n    vaultProviderBtcPubkey: context.vaultProviderBtcPubkey,\n    vaultKeeperBtcPubkeys: context.vaultKeeperBtcPubkeys,\n    universalChallengerBtcPubkeys: context.universalChallengerBtcPubkeys,\n    depositorBtcPubkey: context.depositorBtcPubkey,\n    timelockPegin: context.timelockPegin,\n    registeredPayoutScriptPubKey: resolvePayoutScriptPubKey(\n      tx.claimerPubkeyXOnly,\n      context,\n    ),\n  };\n}\n\n/**\n * Sign all payout transactions using PayoutManager.\n * Uses batch signing when wallet supports it, sequential otherwise.\n */\nasync function signPayoutTransactions(\n  btcWallet: BitcoinWallet,\n  context: PayoutSigningContext,\n  transactions: PreparedTransaction[],\n  onProgress?: (completed: number, total: number) => void,\n): Promise<Record<string, ClaimerSignatures>> {\n  const payoutManager = new PayoutManager({\n    network: context.network,\n    btcWallet,\n  });\n\n  const totalClaimers = transactions.length;\n  onProgress?.(0, totalClaimers);\n\n  let payoutSignatures: string[];\n\n  if (payoutManager.supportsBatchSigning()) {\n    const results = await payoutManager.signPayoutTransactionsBatch(\n      transactions.map((tx) => buildPayoutSigningInput(tx, context)),\n    );\n    payoutSignatures = results.map((r) => r.payoutSignature);\n  } else {\n    payoutSignatures = [];\n    for (let i = 0; i < transactions.length; i++) {\n      onProgress?.(i, totalClaimers);\n      const result = await payoutManager.signPayoutTransaction(\n        buildPayoutSigningInput(transactions[i], context),\n      );\n      payoutSignatures.push(result.signature);\n    }\n  }\n\n  const signatures: Record<string, ClaimerSignatures> = {};\n  for (let i = 0; i < transactions.length; i++) {\n    signatures[transactions[i].claimerPubkeyXOnly] = {\n      payout_signature: payoutSignatures[i],\n    };\n  }\n\n  onProgress?.(totalClaimers, totalClaimers);\n  return signatures;\n}\n\n// ============================================================================\n// Main entry point\n// ============================================================================\n\n/**\n * Poll for payout transactions, sign them, sign the depositor graph,\n * and submit all signatures to the vault provider.\n *\n * This is the main deposit protocol step between registration and activation.\n *\n * @throws Error on timeout, abort, signing failure, or RPC error\n */\nexport async function pollAndSignPayouts(\n  params: PollAndSignPayoutsParams,\n): Promise<void> {\n  const {\n    statusReader,\n    presignClient,\n    btcWallet,\n    peginTxid,\n    depositorPk,\n    signingContext,\n    timeoutMs = MAX_POLLING_TIMEOUT_MS,\n    signal,\n    onProgress,\n  } = params;\n\n  // Phase 1: Poll until VP is ready for depositor signatures (or already past)\n  const status = await waitForPeginStatus({\n    statusReader,\n    peginTxid,\n    targetStatuses: TARGET_STATUS,\n    timeoutMs,\n    signal,\n  });\n\n  // Resume-safe: if VP already moved past payout signing, nothing to do\n  if (POST_PAYOUT_STATUSES.has(status)) {\n    return;\n  }\n\n  signal?.throwIfAborted();\n\n  // Phase 2: Fetch presign transactions\n  const response = await presignClient.requestDepositorPresignTransactions(\n    {\n      pegin_txid: peginTxid,\n      depositor_pk: depositorPk,\n    },\n    signal,\n  );\n\n  signal?.throwIfAborted();\n\n  // Phase 3: Sign VP/VK claimer payout transactions\n  // Filter out the depositor's own claimer entry — its payout is signed\n  // separately via signDepositorGraph (Phase 4) using VP-provided PSBTs.\n  // Including it here would cause a redundant wallet signing prompt whose\n  // result is discarded when the depositor graph signature overwrites it.\n  const depositorPkNormalized = processPublicKeyToXOnly(depositorPk);\n  const nonDepositorTxs = response.txs.filter(\n    (tx) => processPublicKeyToXOnly(tx.claimer_pubkey) !== depositorPkNormalized,\n  );\n  const preparedTransactions = prepareTransactionsForSigning(nonDepositorTxs);\n  const claimerSignatures = await signPayoutTransactions(\n    btcWallet,\n    signingContext,\n    preparedTransactions,\n    onProgress,\n  );\n\n  signal?.throwIfAborted();\n\n  // Phase 4: Sign depositor-as-claimer graph\n  const depositorClaimerPresignatures = await signDepositorGraph({\n    depositorGraph: response.depositor_graph,\n    depositorBtcPubkey: depositorPk,\n    btcWallet,\n  });\n\n  signal?.throwIfAborted();\n\n  // Phase 5: Submit all signatures to VP\n  // Include depositor's own payout signature in the signatures map\n  const allSignatures = { ...claimerSignatures };\n  allSignatures[stripHexPrefix(depositorPk)] =\n    depositorClaimerPresignatures.payout_signatures;\n\n  await presignClient.submitDepositorPresignatures(\n    {\n      pegin_txid: peginTxid,\n      depositor_pk: depositorPk,\n      signatures: allSignatures,\n      depositor_claimer_presignatures: depositorClaimerPresignatures,\n    },\n    signal,\n  );\n}\n","/**\n * Pure validation functions for deposit operations.\n *\n * All validations return a consistent {@link ValidationResult} format or throw\n * on critical failures (e.g. missing protocol participants).\n *\n * Business rules (single-provider limit, max vault count) and form-flow\n * checks (wallet connected) belong in the consumer layer.\n *\n * @module tbv/core/services/deposit/validation\n */\n\nimport {\n  formatSatoshisToBtc,\n  stripHexPrefix,\n} from \"../../primitives/utils/bitcoin\";\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport interface ValidationResult {\n  valid: boolean;\n  error?: string;\n  warnings?: string[];\n}\n\n/**\n * Parameters for checking if a deposit form is valid.\n */\nexport interface DepositFormValidityParams {\n  /** Deposit amount in satoshis */\n  amountSats: bigint;\n  /** Minimum deposit from protocol params */\n  minDeposit: bigint;\n  /** Maximum deposit from protocol params (optional) */\n  maxDeposit?: bigint;\n  /** User's available BTC balance in satoshis */\n  btcBalance: bigint;\n  /** Estimated transaction fee in satoshis */\n  estimatedFeeSats?: bigint;\n  /** Depositor claim value in satoshis (required output for challenge transactions) */\n  depositorClaimValue?: bigint;\n}\n\nexport interface RemainingCapacityParams {\n  /** Requested deposit amount in satoshis */\n  amount: bigint;\n  /**\n   * Effective remaining capacity in satoshis (min of protocol-total and\n   * per-address remaining). `null` means no cap applies.\n   */\n  effectiveRemaining: bigint | null;\n}\n\n/** Narrow structural type for UTXO — avoids importing vault-specific types. */\ninterface UtxoLike {\n  txid: string;\n  vout: number;\n  value: number;\n}\n\n/**\n * Parameters for validating multi-vault deposit flow inputs.\n *\n * Callers must resolve any async loading states before calling — the SDK\n * validates resolved data, not React hook state.\n *\n * Form-flow checks (wallet connected, provider selected) are the caller's\n * responsibility and are NOT performed here.\n */\nexport interface MultiVaultDepositFlowInputs {\n  vaultAmounts: bigint[];\n  confirmedUTXOs: UtxoLike[];\n  vaultProviderBtcPubkey: string;\n  vaultKeeperBtcPubkeys: string[];\n  universalChallengerBtcPubkeys: string[];\n  /** Protocol minimum deposit per vault (satoshis) */\n  minDeposit: bigint;\n  /** Protocol maximum deposit per vault (satoshis) */\n  maxDeposit?: bigint;\n  /** Number of HTLC secret hexes — must match vaultAmounts.length */\n  htlcSecretHexesLength: number;\n  /** Number of depositor secret hashes — must match vaultAmounts.length */\n  depositorSecretHashesLength: number;\n}\n\n// ---------------------------------------------------------------------------\n// Private helpers\n// ---------------------------------------------------------------------------\n\nfunction isValidXOnlyHex(hex: string): boolean {\n  return /^[0-9a-fA-F]{64}$/.test(hex);\n}\n\n// ---------------------------------------------------------------------------\n// Validation functions\n// ---------------------------------------------------------------------------\n\n/**\n * Check if deposit amount is within valid range and affordable.\n *\n * Returns false when fees/claim value are not yet known (still loading),\n * and includes them in the balance check once available.\n */\nexport function isDepositAmountValid(\n  params: DepositFormValidityParams,\n): boolean {\n  const {\n    amountSats,\n    minDeposit,\n    maxDeposit,\n    btcBalance,\n    estimatedFeeSats,\n    depositorClaimValue,\n  } = params;\n\n  if (amountSats <= 0n) return false;\n  if (amountSats < minDeposit) return false;\n  if (maxDeposit && maxDeposit > 0n && amountSats > maxDeposit) return false;\n\n  if (estimatedFeeSats == null || depositorClaimValue == null) return false;\n\n  const totalRequired = amountSats + estimatedFeeSats + depositorClaimValue;\n  if (totalRequired > btcBalance) return false;\n\n  return true;\n}\n\n/**\n * Validate deposit amount against minimum and maximum constraints.\n */\nexport function validateDepositAmount(\n  amount: bigint,\n  minDeposit: bigint,\n  maxDeposit?: bigint,\n): ValidationResult {\n  if (amount <= 0n) {\n    return {\n      valid: false,\n      error: \"Deposit amount must be greater than zero\",\n    };\n  }\n\n  if (amount < minDeposit) {\n    return {\n      valid: false,\n      error: `Minimum deposit is ${formatSatoshisToBtc(minDeposit)} BTC`,\n    };\n  }\n\n  if (maxDeposit && maxDeposit > 0n && amount > maxDeposit) {\n    return {\n      valid: false,\n      error: `Maximum deposit is ${formatSatoshisToBtc(maxDeposit)} BTC`,\n    };\n  }\n\n  return { valid: true };\n}\n\n/**\n * Validate that the requested deposit fits within the effective remaining cap.\n */\nexport function validateRemainingCapacity(\n  params: RemainingCapacityParams,\n): ValidationResult {\n  const { amount, effectiveRemaining } = params;\n  if (effectiveRemaining === null) return { valid: true };\n\n  if (effectiveRemaining === 0n) {\n    return {\n      valid: false,\n      error: \"Supply cap reached — deposits temporarily paused\",\n    };\n  }\n\n  if (amount > effectiveRemaining) {\n    return {\n      valid: false,\n      error: `Vault size exceeds remaining capacity (${formatSatoshisToBtc(effectiveRemaining)} BTC)`,\n    };\n  }\n\n  return { valid: true };\n}\n\n/**\n * Validate that selected providers exist in the available set.\n *\n * Business rules (e.g. single-provider limit) are the caller's responsibility.\n */\nexport function validateProviderSelection(\n  selectedProviders: string[],\n  availableProviders: string[],\n): ValidationResult {\n  if (!selectedProviders || selectedProviders.length === 0) {\n    return {\n      valid: false,\n      error: \"At least one vault provider must be selected\",\n    };\n  }\n\n  const availableProvidersLower = availableProviders.map((p) =>\n    p.toLowerCase(),\n  );\n  const invalidProviders = selectedProviders.filter(\n    (p) => !availableProvidersLower.includes(p.toLowerCase()),\n  );\n\n  if (invalidProviders.length > 0) {\n    return {\n      valid: false,\n      error: \"Invalid vault provider selected\",\n    };\n  }\n\n  return { valid: true };\n}\n\n/**\n * Validate vault amounts array for multi-vault deposits.\n * Checks count, positivity, and per-vault min/max protocol limits.\n *\n * Max vault count limits are the caller's responsibility.\n */\nexport function validateVaultAmounts(\n  amounts: bigint[],\n  minDeposit?: bigint,\n  maxDeposit?: bigint,\n): ValidationResult {\n  if (!amounts || amounts.length === 0) {\n    return {\n      valid: false,\n      error: \"At least one vault amount required\",\n    };\n  }\n\n  for (let i = 0; i < amounts.length; i++) {\n    const amount = amounts[i];\n    if (amount <= 0n) {\n      return {\n        valid: false,\n        error: `Vault ${i + 1} amount must be positive`,\n      };\n    }\n    if (minDeposit && amount < minDeposit) {\n      return {\n        valid: false,\n        error: `Vault ${i + 1} amount ${formatSatoshisToBtc(amount)} BTC is below minimum deposit ${formatSatoshisToBtc(minDeposit)} BTC`,\n      };\n    }\n    if (maxDeposit && amount > maxDeposit) {\n      return {\n        valid: false,\n        error: `Vault ${i + 1} amount ${formatSatoshisToBtc(amount)} BTC exceeds maximum deposit ${formatSatoshisToBtc(maxDeposit)} BTC`,\n      };\n    }\n  }\n\n  return { valid: true };\n}\n\n/**\n * Validate vault provider BTC public key format.\n */\nexport function validateVaultProviderPubkey(pubkey: string): ValidationResult {\n  const stripped = stripHexPrefix(pubkey);\n  if (!isValidXOnlyHex(stripped)) {\n    return {\n      valid: false,\n      error:\n        \"Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)\",\n    };\n  }\n  return { valid: true };\n}\n\n// ---------------------------------------------------------------------------\n// Private helpers for multi-vault validation\n// ---------------------------------------------------------------------------\n\nfunction validateVaultKeepers(vaultKeeperBtcPubkeys: string[]): void {\n  if (!vaultKeeperBtcPubkeys || vaultKeeperBtcPubkeys.length === 0) {\n    throw new Error(\n      \"No vault keepers available. The system requires at least one vault keeper to create a deposit.\",\n    );\n  }\n}\n\nfunction validateUniversalChallengers(\n  universalChallengerBtcPubkeys: string[],\n): void {\n  if (\n    !universalChallengerBtcPubkeys ||\n    universalChallengerBtcPubkeys.length === 0\n  ) {\n    throw new Error(\n      \"No universal challengers available. The system requires at least one universal challenger to create a deposit.\",\n    );\n  }\n}\n\nfunction validateUTXOState(confirmedUTXOs: UtxoLike[]): void {\n  if (confirmedUTXOs.length === 0) {\n    throw new Error(\"No spendable UTXOs available\");\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Multi-vault composite validation\n// ---------------------------------------------------------------------------\n\n/**\n * Validate protocol-level multi-vault deposit inputs.\n * Throws an error if any validation fails.\n *\n * Form-flow checks (wallet connections, provider selection) must be\n * performed by the caller before invoking this function.\n */\nexport function validateMultiVaultDepositInputs(\n  params: MultiVaultDepositFlowInputs,\n): void {\n  const {\n    vaultAmounts,\n    confirmedUTXOs,\n    vaultProviderBtcPubkey,\n    vaultKeeperBtcPubkeys,\n    universalChallengerBtcPubkeys,\n    minDeposit,\n    maxDeposit,\n    htlcSecretHexesLength,\n    depositorSecretHashesLength,\n  } = params;\n\n  // Array alignment: all per-vault arrays must have the same length\n  const vaultCount = vaultAmounts.length;\n  if (htlcSecretHexesLength !== vaultCount) {\n    throw new Error(\n      `htlcSecretHexes length (${htlcSecretHexesLength}) must match vaultAmounts length (${vaultCount})`,\n    );\n  }\n  if (depositorSecretHashesLength !== vaultCount) {\n    throw new Error(\n      `depositorSecretHashes length (${depositorSecretHashesLength}) must match vaultAmounts length (${vaultCount})`,\n    );\n  }\n\n  const amountsValidation = validateVaultAmounts(\n    vaultAmounts,\n    minDeposit,\n    maxDeposit,\n  );\n  if (!amountsValidation.valid) {\n    throw new Error(amountsValidation.error);\n  }\n\n  // Vault provider pubkey\n  const pubkeyValidation = validateVaultProviderPubkey(vaultProviderBtcPubkey);\n  if (!pubkeyValidation.valid) {\n    throw new Error(pubkeyValidation.error);\n  }\n\n  validateVaultKeepers(vaultKeeperBtcPubkeys);\n  validateUniversalChallengers(universalChallengerBtcPubkeys);\n  validateUTXOState(confirmedUTXOs);\n}\n","/**\n * Pegout state definitions and protocol-level terminal checks.\n *\n * Maps VP-reported pegout statuses from `vaultProvider_getPegoutStatus`\n * to protocol lifecycle states.\n *\n * Lifecycle:\n *   ClaimEventReceived -> ClaimBroadcast -> AssertBroadcast -> PayoutBroadcast (success)\n *                                                             > ChallengeAssertObserved -> WronglyChallengedBroadcast -> PayoutBroadcast\n *                                                             > ChallengeAssertObserved -> Failed (challenger won)\n */\n\n/** Claimer-side pegout statuses reported by the VP. */\nexport enum ClaimerPegoutStatusValue {\n  CLAIM_EVENT_RECEIVED = \"ClaimEventReceived\",\n  CLAIM_BROADCAST = \"ClaimBroadcast\",\n  ASSERT_BROADCAST = \"AssertBroadcast\",\n  CHALLENGE_ASSERT_OBSERVED = \"ChallengeAssertObserved\",\n  WRONGLY_CHALLENGED_BROADCAST = \"WronglyChallengedBroadcast\",\n  PAYOUT_BROADCAST = \"PayoutBroadcast\",\n  FAILED = \"Failed\",\n}\n\nconst PEGOUT_TERMINAL_STATUSES = new Set<string>([\n  ClaimerPegoutStatusValue.PAYOUT_BROADCAST,\n  ClaimerPegoutStatusValue.FAILED,\n]);\n\n/** Whether a claimer status string maps to a known pegout state. */\nexport function isRecognizedPegoutStatus(status: string): boolean {\n  return Object.values(ClaimerPegoutStatusValue).includes(\n    status as ClaimerPegoutStatusValue,\n  );\n}\n\n/**\n * Whether a claimer status is a hard-terminal pegout status\n * (PayoutBroadcast or Failed). Soft-terminal conditions (polling\n * thresholds) are a consumer-side concern.\n */\nexport function isPegoutTerminalStatus(\n  claimerStatus: string | undefined,\n): boolean {\n  return !!claimerStatus && PEGOUT_TERMINAL_STATUSES.has(claimerStatus);\n}\n","/**\n * Domain errors thrown by the refund service.\n *\n * @module services/refund/errors\n */\n\nimport type { Hex } from \"viem\";\n\n/**\n * Thrown when the broadcast transport rejects the refund tx because the CSV\n * timelock has not yet matured (BIP68 non-final). Callers can surface a\n * friendly \"wait until block N\" message; the original transport error is\n * available via {@link cause}.\n */\nexport class BIP68NotMatureError extends Error {\n  public readonly vaultId: Hex;\n  public override readonly cause: Error;\n\n  constructor(vaultId: Hex, cause: Error) {\n    super(`Refund not yet mature (BIP68 not final): ${cause.message}`);\n    this.name = \"BIP68NotMatureError\";\n    this.vaultId = vaultId;\n    this.cause = cause;\n  }\n}\n","/**\n * Vault refund orchestration — reclaim BTC from an expired Pre-PegIn HTLC via\n * the CSV-timelocked refund script (leaf 1). SDK owns the sequence of:\n * fetch → fee calc → PSBT build → sign → finalize → broadcast. Pre-fetched\n * data (fee rate) is passed by value; the data-flow-dependent reads\n * (`readVault`, `readPrePeginContext(vault)`) and the interactive transports\n * (`signPsbt`, `broadcastTx`) stay as injected callbacks so the caller keeps\n * its transport choice (viem, wagmi, mempool client, etc.) and error decoding.\n *\n * @module services/refund\n */\n\nimport type { Network } from \"@babylonlabs-io/babylon-tbv-rust-wasm\";\nimport { Psbt } from \"bitcoinjs-lib\";\nimport type { Address, Hex } from \"viem\";\n\nimport type { SignPsbtOptions } from \"../../../../shared/wallets/interfaces/BitcoinWallet\";\nimport { buildRefundPsbt } from \"../../primitives/psbt/refund\";\nimport { stripHexPrefix } from \"../../primitives/utils/bitcoin\";\nimport { createTaprootScriptPathSignOptions } from \"../../utils/signing\";\n\nimport { BIP68NotMatureError } from \"./errors\";\n\nconst BYTES32_HEX_RE = /^0x[0-9a-fA-F]{64}$/;\n// BTC raw-hex convention: 0x prefix optional, even number of hex chars, must\n// be non-empty. Named distinctly from the ETH-hex regex in activateVault.ts\n// (which requires a 0x prefix and allows empty \"0x\") to make the convention\n// explicit at the call site.\nconst BTC_HEX_BYTES_RE = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/;\n// Pubkeys are either 32 bytes (x-only, 64 hex chars) or 33 bytes (compressed,\n// 66 hex chars). 65 hex chars is not a valid byte length — reject it here\n// rather than letting the malformed value surface as an opaque PSBT/signing\n// failure later.\nconst PUBKEY_HEX_RE = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/;\n// Conservative upper bound for the fixed-shape refund tx (1 P2TR script-path\n// input spending the HTLC refund leaf → 1 P2TR/P2WPKH output). Taproot\n// script-path witness: 64-byte Schnorr sig + refund script + control block.\n// This is protocol-owned knowledge; callers don't parameterise it.\nconst REFUND_VSIZE = 160;\n// Refund tx has exactly one input — the HTLC output at htlcVout from the\n// Pre-PegIn tx. Used to tell the signer how many sign entries to generate.\n// (Not the taproot leaf index; the leaf is encoded into the PSBT by the\n// WASM PSBT builder based on the refund script path.)\nconst REFUND_INPUT_COUNT = 1;\nconst MAX_VOUT = 0xffff;\nconst BIP68_ERROR_RE = /non-BIP68-final/i;\n\nfunction assertBytes32(value: string, label: string): void {\n  if (value.length !== 66) {\n    throw new Error(\n      `${label} must be 32 bytes (66 hex chars with 0x prefix), got length ${value.length}`,\n    );\n  }\n  if (!BYTES32_HEX_RE.test(value)) {\n    throw new Error(\n      `${label} must contain only hex characters after the 0x prefix`,\n    );\n  }\n}\n\n/**\n * Authoritative vault fields needed to build a refund. Versioning fields,\n * the hashlock, and htlcVout must come from the on-chain contract (never the\n * indexer). The amount + `unsignedPrePeginTxHex` + `depositorBtcPubkey` can\n * come from the indexer since they are not security-critical for signing\n * (the PSBT builder re-derives the HTLC script from on-chain params).\n */\nexport interface VaultRefundData {\n  hashlock: Hex;\n  htlcVout: number;\n  offchainParamsVersion: number;\n  appVaultKeepersVersion: number;\n  universalChallengersVersion: number;\n  vaultProvider: Address;\n  applicationEntryPoint: Address;\n  /** Pre-PegIn HTLC output value in satoshis. */\n  amount: bigint;\n  /** Funded (but pre-witness) Pre-PegIn transaction hex. 0x prefix optional. */\n  unsignedPrePeginTxHex: string;\n  /** Depositor's BTC public key (x-only or compressed hex; 0x prefix optional). */\n  depositorBtcPubkey: string;\n}\n\n/**\n * Version-resolved protocol context that parameterises the HTLC's taproot\n * scripts. The *signer-set* fields (`vaultKeeperPubkeys`,\n * `universalChallengerPubkeys`) and the version-locked numeric protocol\n * params **must** be sourced from the on-chain contract at the version\n * pinned in {@link VaultRefundData} — this is the trust boundary.\n * `vaultProviderPubkey` today is sourced from the GraphQL indexer via\n * `fetchVaultProviderById`; the caller is responsible for any additional\n * cross-check it requires. Keeper and challenger pubkey arrays must be\n * pre-sorted the same way the Rust protocol sorts them (canonical for\n * script derivation).\n */\nexport interface RefundPrePeginContext {\n  vaultProviderPubkey: string;\n  vaultKeeperPubkeys: readonly string[];\n  universalChallengerPubkeys: readonly string[];\n  timelockRefund: number;\n  feeRate: bigint;\n  numLocalChallengers: number;\n  councilQuorum: number;\n  councilSize: number;\n  network: Network;\n}\n\n/** Minimum shape required from a broadcast result. */\nexport interface BtcBroadcastResult {\n  txId: string;\n}\n\nexport type BtcBroadcaster<\n  R extends BtcBroadcastResult = BtcBroadcastResult,\n> = (signedTxHex: string) => Promise<R>;\n\nexport type RefundPsbtSigner = (\n  psbtHex: string,\n  opts: SignPsbtOptions,\n) => Promise<string>;\n\nexport interface RefundInput<\n  R extends BtcBroadcastResult = BtcBroadcastResult,\n> {\n  vaultId: Hex;\n  /**\n   * Fetch authoritative on-chain + indexer vault data. The SDK passes no\n   * arguments — the caller closes over `vaultId` (or any other context it\n   * needs).\n   */\n  readVault: () => Promise<VaultRefundData>;\n  /**\n   * Fetch the version-pinned refund context (sorted pubkeys, timelock, etc.)\n   * derived from the vault's locked versions.\n   */\n  readPrePeginContext: (\n    vault: VaultRefundData,\n  ) => Promise<RefundPrePeginContext>;\n  /**\n   * Mempool-derived sat/vB fee rate to use for the refund tx (positive\n   * number). Caller fetches this before invoking — it does not depend on\n   * any value the SDK computes, and folding it into the call keeps the\n   * orchestration honest.\n   */\n  feeRate: number;\n  /** BTC wallet signer; receives a PSBT hex + taproot script-path options. */\n  signPsbt: RefundPsbtSigner;\n  /** Broadcast callback — returns whatever shape the caller needs. */\n  broadcastTx: BtcBroadcaster<R>;\n  /** Checked at every async boundary. */\n  signal?: AbortSignal;\n}\n\nfunction assertNonNegativeInteger(value: number, label: string): void {\n  if (!Number.isInteger(value) || value < 0) {\n    throw new Error(`${label} must be a non-negative integer, got ${value}`);\n  }\n}\n\nfunction validateVaultRefundData(v: VaultRefundData): void {\n  assertBytes32(v.hashlock, \"hashlock\");\n  if (\n    !Number.isInteger(v.htlcVout) ||\n    v.htlcVout < 0 ||\n    v.htlcVout > MAX_VOUT\n  ) {\n    throw new Error(\n      `htlcVout must be an integer 0-${MAX_VOUT}, got ${v.htlcVout}`,\n    );\n  }\n  // Version fields flow directly into on-chain script derivation via\n  // `readPrePeginContext` — NaN, negative, or non-integer values would\n  // silently produce wrong scripts. Guard here as defence in depth even\n  // though the caller sources these from bigint on-chain reads.\n  assertNonNegativeInteger(v.offchainParamsVersion, \"offchainParamsVersion\");\n  assertNonNegativeInteger(v.appVaultKeepersVersion, \"appVaultKeepersVersion\");\n  assertNonNegativeInteger(\n    v.universalChallengersVersion,\n    \"universalChallengersVersion\",\n  );\n  if (typeof v.unsignedPrePeginTxHex !== \"string\" || v.unsignedPrePeginTxHex.length === 0) {\n    throw new Error(\"unsignedPrePeginTxHex must be a non-empty hex string\");\n  }\n  if (!BTC_HEX_BYTES_RE.test(v.unsignedPrePeginTxHex)) {\n    throw new Error(\n      \"unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)\",\n    );\n  }\n  if (!v.depositorBtcPubkey || !PUBKEY_HEX_RE.test(v.depositorBtcPubkey)) {\n    throw new Error(\n      \"depositorBtcPubkey must be 32 or 33 bytes of hex (optional 0x prefix)\",\n    );\n  }\n  if (typeof v.amount !== \"bigint\" || v.amount <= 0n) {\n    throw new Error(`amount must be a positive bigint, got ${v.amount}`);\n  }\n}\n\nfunction validateRefundPrePeginContext(c: RefundPrePeginContext): void {\n  if (!c.vaultProviderPubkey || !PUBKEY_HEX_RE.test(c.vaultProviderPubkey)) {\n    throw new Error(\"vaultProviderPubkey must be 32 or 33 bytes of hex\");\n  }\n  if (c.vaultKeeperPubkeys.length === 0) {\n    throw new Error(\"vaultKeeperPubkeys must be non-empty\");\n  }\n  if (c.universalChallengerPubkeys.length === 0) {\n    throw new Error(\"universalChallengerPubkeys must be non-empty\");\n  }\n  if (!Number.isInteger(c.timelockRefund) || c.timelockRefund <= 0) {\n    throw new Error(\n      `timelockRefund must be a positive integer, got ${c.timelockRefund}`,\n    );\n  }\n  if (typeof c.feeRate !== \"bigint\" || c.feeRate <= 0n) {\n    throw new Error(\n      `protocol feeRate must be a positive bigint, got ${c.feeRate}`,\n    );\n  }\n  if (\n    !Number.isInteger(c.numLocalChallengers) ||\n    c.numLocalChallengers < 0\n  ) {\n    throw new Error(\"numLocalChallengers must be a non-negative integer\");\n  }\n  if (\n    !Number.isInteger(c.councilQuorum) ||\n    !Number.isInteger(c.councilSize) ||\n    c.councilQuorum <= 0 ||\n    c.councilSize <= 0 ||\n    c.councilQuorum > c.councilSize\n  ) {\n    throw new Error(\n      `councilQuorum (${c.councilQuorum}) must be in [1, councilSize=${c.councilSize}]`,\n    );\n  }\n}\n\nfunction finalizeAndExtract(signedPsbtHex: string): string {\n  const psbt = Psbt.fromHex(signedPsbtHex);\n  try {\n    psbt.finalizeAllInputs();\n  } catch (e: unknown) {\n    // Some wallets (e.g. Keystone) finalize during signPsbt; bitcoinjs then\n    // throws \"Input is already finalized\". Treat that case as a no-op.\n    const message = e instanceof Error ? e.message : String(e);\n    if (!message.includes(\"already finalized\")) {\n      throw new Error(`Failed to finalize refund PSBT: ${message}`);\n    }\n  }\n  return psbt.extractTransaction().toHex();\n}\n\n/**\n * Build, sign, and broadcast a refund transaction for an expired vault.\n *\n * Trust boundary: `readVault` must source the hashlock, htlcVout, and\n * versioning fields from the on-chain contract — an indexer-only path\n * leaves the refund flow open to signer-set substitution. The SDK does\n * not enforce this; it is the caller's responsibility.\n *\n * The broadcast transport is expected to surface Bitcoin's `non-BIP68-final`\n * policy rejection as an `Error` whose message contains that string; when\n * it does, the SDK wraps it in {@link BIP68NotMatureError}. All other\n * transport errors propagate unchanged.\n *\n * @returns whatever the injected `broadcastTx` returns (generic pass-through)\n * @throws `Error` if any validation fails\n * @throws {@link BIP68NotMatureError} if the broadcast is rejected because\n *         the refund CSV timelock has not yet matured\n * @throws anything `readVault`, `readPrePeginContext`,\n *         `signPsbt`, or `broadcastTx` throws\n */\nexport async function buildAndBroadcastRefund<\n  R extends BtcBroadcastResult = BtcBroadcastResult,\n>(input: RefundInput<R>): Promise<R> {\n  const {\n    vaultId,\n    readVault,\n    readPrePeginContext,\n    feeRate,\n    signPsbt,\n    broadcastTx,\n    signal,\n  } = input;\n\n  signal?.throwIfAborted();\n  assertBytes32(vaultId, \"vaultId\");\n\n  const vault = await readVault();\n  validateVaultRefundData(vault);\n  signal?.throwIfAborted();\n\n  const ctx = await readPrePeginContext(vault);\n  validateRefundPrePeginContext(ctx);\n  signal?.throwIfAborted();\n\n  if (!Number.isFinite(feeRate) || feeRate <= 0) {\n    throw new Error(`feeRate must be a positive number, got ${feeRate}`);\n  }\n  const refundFee = BigInt(Math.ceil(feeRate * REFUND_VSIZE));\n  signal?.throwIfAborted();\n\n  const { psbtHex } = await buildRefundPsbt({\n    prePeginParams: {\n      depositorPubkey: stripHexPrefix(vault.depositorBtcPubkey),\n      vaultProviderPubkey: stripHexPrefix(ctx.vaultProviderPubkey),\n      vaultKeeperPubkeys: ctx.vaultKeeperPubkeys.map(stripHexPrefix),\n      universalChallengerPubkeys:\n        ctx.universalChallengerPubkeys.map(stripHexPrefix),\n      hashlocks: [stripHexPrefix(vault.hashlock)],\n      timelockRefund: ctx.timelockRefund,\n      pegInAmounts: [vault.amount],\n      feeRate: ctx.feeRate,\n      numLocalChallengers: ctx.numLocalChallengers,\n      councilQuorum: ctx.councilQuorum,\n      councilSize: ctx.councilSize,\n      network: ctx.network,\n    },\n    fundedPrePeginTxHex: stripHexPrefix(vault.unsignedPrePeginTxHex),\n    htlcVout: vault.htlcVout,\n    refundFee,\n    // buildRefundPsbt's top-level `hashlock` param is documented as \"no 0x\n    // prefix\" and flows into the WASM HTLC connector derivation; a prefixed\n    // value would derive the wrong refund script leaf and yield an\n    // unspendable PSBT. Match the `hashlocks` array handling above.\n    hashlock: stripHexPrefix(vault.hashlock),\n  });\n  signal?.throwIfAborted();\n\n  const signOptions = createTaprootScriptPathSignOptions(\n    vault.depositorBtcPubkey,\n    REFUND_INPUT_COUNT,\n  );\n  const signedPsbtHex = await signPsbt(psbtHex, signOptions);\n  const signedTxHex = finalizeAndExtract(signedPsbtHex);\n  signal?.throwIfAborted();\n\n  try {\n    return await broadcastTx(signedTxHex);\n  } catch (error) {\n    if (error instanceof Error && BIP68_ERROR_RE.test(error.message)) {\n      throw new BIP68NotMatureError(vaultId, error);\n    }\n    throw error;\n  }\n}\n"],"names":["PayoutManager","config","__publicField","params","walletPubkeyRaw","depositorPubkey","validateWalletPubkey","payoutPsbt","buildPayoutPsbt","signedPsbtHex","createTaprootScriptPathSignOptions","extractPayoutSignature","transactions","psbtsToSign","signOptions","depositorPubkeys","tx","signedPsbts","results","i","payoutSignature","payoutTxHex","registeredPayoutScriptPubKey","isValidHex","expectedScript","Buffer","stripHexPrefix","payoutTx","Transaction","max","output","isBytes","a","anumber","n","title","prefix","abytes","value","length","bytes","len","needsLen","ofLen","got","ahash","h","aexists","instance","checkFinished","aoutput","out","min","u32","arr","clean","arrays","createView","rotr","word","shift","rotl","isLE","byteSwap","byteSwap32","swap32IfBE","u","utf8ToBytes","str","kdfInputToBytes","data","errorTitle","checkOpts","defaults","opts","createHasher","hashCons","info","hashC","msg","tmp","oidNist","suffix","Chi","b","c","Maj","HashMD","blockLen","outputLen","padOffset","view","buffer","pos","take","dataView","oview","outLen","state","res","to","finished","destroyed","SHA256_IV","SHA512_IV","U32_MASK64","_32n","fromBig","le","split","lst","Ah","Al","l","shrSH","_l","s","shrSL","rotrSH","rotrSL","rotrBH","rotrBL","rotlSH","rotlSL","rotlBH","rotlBL","add","Bh","Bl","add3L","Cl","add3H","low","Ch","add4L","Dl","add4H","Dh","add5L","El","add5H","Eh","SHA256_K","SHA256_W","SHA2_32B","A","B","C","D","E","F","G","H","offset","W15","W2","s0","s1","sigma1","T1","T2","_SHA256","K512","u64.split","SHA512_Kh","SHA512_Kl","SHA512_W_H","SHA512_W_L","SHA2_64B","Fh","Fl","Gh","Gl","Hh","Hl","W15h","W15l","s0h","u64.rotrSH","u64.shrSH","s0l","u64.rotrSL","u64.shrSL","W2h","W2l","s1h","u64.rotrBH","s1l","u64.rotrBL","SUMl","u64.add4L","SUMh","u64.add4H","sigma1h","sigma1l","CHIh","CHIl","T1ll","u64.add5L","T1h","u64.add5H","T1l","sigma0h","sigma0l","MAJh","MAJl","u64.add","All","u64.add3L","u64.add3H","_SHA512","sha256","sha512","HEX_BYTES32_LENGTH","hexToBytes","hex","bytesToHex","assertBytes32","label","computeHashlock","secret","secretBytes","hash","validateSecretAgainstHashlock","hashlock","BYTES32_HEX_RE","ADDRESS_HEX_RE","ETH_HEX_BYTES_RE","assertAddress","assertHexBytes","activateVault","input","btcVaultRegistryAddress","vaultId","activationMetadata","writeContract","signal","normalizedSecret","ensureHexPrefix","BTCVaultRegistryABI","DEFAULT_POLL_INTERVAL_MS","waitForPeginStatus","statusReader","peginTxid","targetStatuses","timeoutMs","pollIntervalMs","startTime","status","VP_TERMINAL_STATUSES","error","JsonRpcError","RpcErrorCode","resolve","reject","onAbort","timeoutId","STATUS_POLL_TIMEOUT_MS","TARGET_STATUSES","DaemonStatus","POST_WOTS_STATUSES","submitWotsPublicKey","wotsSubmitter","depositorPk","wotsPublicKeys","SINGLE_PSBT_INPUT_COUNT","verifyAndParsePsbt","psbtBase64","expectedTxHex","psbt","Psbt","unsignedTxHex","normalizedExpected","sanitizePsbtForScriptPathSigning","clone","validateAndConvertPsbt","collectDepositorGraphPsbts","depositorGraph","walletPublicKey","psbtHexes","challengerEntries","singleInputOpts","payoutHex","challenger","challengerPubkey","noPayoutIdx","noPayoutHex","extractDepositorGraphSignatures","signedPsbtHexes","perChallenger","entry","signPsbtsWithFallback","wallet","options","signed","signDepositorGraph","depositorBtcPubkey","btcWallet","MAX_POLLING_TIMEOUT_MS","POST_PAYOUT_STATUSES","TARGET_STATUS","prepareTransactionsForSigning","claimerTransactions","processPublicKeyToXOnly","deriveBip86ScriptPubKey","xOnlyPubkeyHex","bitcoin","resolvePayoutScriptPubKey","claimerPubkeyXOnly","context","claimer","vpPubkey","vk","buildPayoutSigningInput","signPayoutTransactions","onProgress","payoutManager","totalClaimers","payoutSignatures","r","result","signatures","pollAndSignPayouts","presignClient","signingContext","response","depositorPkNormalized","nonDepositorTxs","preparedTransactions","claimerSignatures","depositorClaimerPresignatures","allSignatures","isValidXOnlyHex","isDepositAmountValid","amountSats","minDeposit","maxDeposit","btcBalance","estimatedFeeSats","depositorClaimValue","validateDepositAmount","amount","formatSatoshisToBtc","validateRemainingCapacity","effectiveRemaining","validateProviderSelection","selectedProviders","availableProviders","availableProvidersLower","p","validateVaultAmounts","amounts","validateVaultProviderPubkey","pubkey","stripped","validateVaultKeepers","vaultKeeperBtcPubkeys","validateUniversalChallengers","universalChallengerBtcPubkeys","validateUTXOState","confirmedUTXOs","validateMultiVaultDepositInputs","vaultAmounts","vaultProviderBtcPubkey","htlcSecretHexesLength","depositorSecretHashesLength","vaultCount","amountsValidation","pubkeyValidation","ClaimerPegoutStatusValue","PEGOUT_TERMINAL_STATUSES","isRecognizedPegoutStatus","isPegoutTerminalStatus","claimerStatus","BIP68NotMatureError","cause","BTC_HEX_BYTES_RE","PUBKEY_HEX_RE","REFUND_VSIZE","REFUND_INPUT_COUNT","MAX_VOUT","BIP68_ERROR_RE","assertNonNegativeInteger","validateVaultRefundData","v","validateRefundPrePeginContext","finalizeAndExtract","e","message","buildAndBroadcastRefund","readVault","readPrePeginContext","feeRate","signPsbt","broadcastTx","vault","ctx","refundFee","psbtHex","buildRefundPsbt","signedTxHex"],"mappings":"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","x_google_ignoreList":[1,2,3,4]}