@babylonlabs-io/ts-sdk 3.2.0 → 3.3.0

package/dist/noPayout-B-vGXJ-V.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"noPayout-B-vGXJ-V.js","sources":["../src/tbv/core/wasm/value-guards.ts","../src/tbv/core/primitives/psbt/refund.ts","../src/tbv/core/primitives/psbt/reclaim.ts","../src/tbv/core/primitives/psbt/finalizeScriptPathWithSignatures.ts","../src/tbv/core/primitives/psbt/noPayout.ts"],"sourcesContent":["/**\n * Runtime guard for satoshi amounts crossing into the WASM FFI boundary.\n *\n * `new BigUint64Array(values)` is the only way satoshi amounts are handed to\n * the constructor, and a runtime cast (`as readonly bigint[]`) lets a caller\n * pass a non-bigint or non-positive element that `BigUint64Array` would either\n * reject cryptically or, in its length-arg form, silently zero-fill. Values\n * above the u64 maximum are worse still: `BigUint64Array` wraps them mod 2^64\n * without complaint, turning an oversized amount into a small one.\n * {@link assertPositiveBigintArray} validates such inputs before the\n * typed-array construction.\n *\n * Mirrors the `assertPositiveBigintArray` half of `value-guards.ts` in\n * `@babylonlabs-io/babylon-tbv-rust-wasm`; that one function is pinned to the\n * engine's source copy by `__tests__/value-guards.test.ts`. The engine's other\n * guard, `assertWasmBigint`, has no counterpart here: the engine applies it to\n * its own WASM return values before they reach this package.\n */\n\n/** Largest value BigUint64Array stores without wrapping mod 2^64 (2^64 − 1). */\nconst U64_MAX = (1n << 64n) - 1n;\n\n/**\n * Assert a value is a non-empty array of strictly-positive `bigint`s and return\n * it narrowed, ready to feed into `new BigUint64Array(...)`.\n *\n * @param values - The candidate array of satoshi amounts.\n * @param label - Human-readable name used in the thrown error.\n * @throws If `values` is not an array, is empty, or contains any element that is\n *   not a `bigint`, is not strictly greater than 0, or exceeds the u64 maximum\n *   (which `BigUint64Array` would otherwise wrap mod 2^64).\n */\nexport function assertPositiveBigintArray(\n  values: unknown,\n  label: string,\n): bigint[] {\n  if (!Array.isArray(values)) {\n    throw new Error(\n      `${label} must be an array of positive bigints (got ${typeof values}).`,\n    );\n  }\n  if (values.length === 0) {\n    throw new Error(`${label} must not be empty.`);\n  }\n  values.forEach((value, index) => {\n    if (typeof value !== \"bigint\") {\n      throw new Error(\n        `${label}[${index}] must be a bigint (got ${typeof value}); ` +\n          `refusing to feed it into satoshi math.`,\n      );\n    }\n    if (value <= 0n) {\n      throw new Error(`${label}[${index}] must be > 0 (got ${value}).`);\n    }\n    if (value > U64_MAX) {\n      throw new Error(\n        `${label}[${index}] must fit in a u64 (got ${value}); ` +\n          `refusing to feed it into satoshi math.`,\n      );\n    }\n  });\n  return values as bigint[];\n}\n","/**\n * Refund PSBT Builder Primitive\n *\n * Builds an unsigned refund PSBT for a depositor to reclaim BTC from\n * a timed-out Pre-PegIn HTLC output via the refund script (leaf 1).\n *\n * The refund script enforces a CSV timelock (timelockRefund blocks) and\n * requires only the depositor's Schnorr signature — no vault provider or\n * keeper involvement.\n *\n * @module primitives/psbt/refund\n */\n\nimport { Psbt, Transaction } from \"bitcoinjs-lib\";\nimport { Buffer } from \"buffer\";\nimport { loadTbvWasm, tapInternalPubkey } from \"../../wasm\";\nimport { assertPositiveBigintArray } from \"../../wasm/value-guards\";\n\nimport {\n  TAPSCRIPT_LEAF_VERSION,\n  deriveBip86ScriptPubKeyHex,\n  stripHexPrefix,\n  uint8ArrayToHex,\n} from \"../utils/bitcoin\";\nimport { deriveExpectedPrePeginHtlc } from \"./assertWasmPeginSizing\";\nimport { REFUND_TX_LOCKTIME, REFUND_TX_VERSION } from \"./constants\";\nimport { normalizeAuthAnchorHash, type PrePeginParams } from \"./pegin\";\n\n/**\n * Parameters for building a refund PSBT\n */\nexport interface BuildRefundPsbtParams {\n  /** Same PrePeginParams used when the original Pre-PegIn tx was created */\n  prePeginParams: PrePeginParams;\n  /** Funded Pre-PegIn transaction hex (the tx whose HTLC output is being refunded) */\n  fundedPrePeginTxHex: string;\n  /** Index of the HTLC output in the Pre-PegIn transaction */\n  htlcVout: number;\n  /** Transaction fee in satoshis for the refund transaction */\n  refundFee: bigint;\n  /** SHA256 hash commitment for the HTLC (64 hex chars, no 0x prefix) */\n  hashlock: string;\n}\n\n/**\n * Result of building a refund PSBT\n */\nexport interface BuildRefundPsbtResult {\n  /** PSBT hex ready for depositor signing */\n  psbtHex: string;\n}\n\n/**\n * Build a PSBT for signing the refund transaction.\n *\n * The refund transaction spends the Pre-PegIn HTLC output via leaf 1\n * (the refund script: `<depositorPubkey> OP_CHECKSIGVERIFY <timelockRefund>\n * OP_CHECKSEQUENCEVERIFY` — btc-vault `connectors/prepegin_htlc.rs`\n * `generate_refund_script`).\n * The PSBT includes the tapLeafScript entry so the depositor's wallet can\n * sign using Taproot script-path spending.\n *\n * The input's sequence is set to `timelockRefund` by the WASM, enforcing\n * the Bitcoin CSV timelock. The refund broadcast will be rejected by the\n * network if the timelock has not yet expired.\n *\n * @param params - Refund PSBT parameters\n * @returns PSBT hex for depositor signing\n * @throws If the HTLC output at htlcVout is not found\n * @throws If the refund transaction does not have exactly 1 input\n */\nexport async function buildRefundPsbt(\n  params: BuildRefundPsbtParams,\n): Promise<BuildRefundPsbtResult> {\n  const { WasmPrePeginTx } = await loadTbvWasm();\n\n  const { prePeginParams, fundedPrePeginTxHex, htlcVout, refundFee, hashlock } =\n    params;\n\n  // The 14th positional arg `auth_anchor_hash` is `Option<String>` in\n  // the Rust WASM constructor (the 9th arg `min_pegin_fee_rate` requires\n  // the two-rate constructor from btc-vault #1930). Production peg-ins\n  // (PeginManager) always commit an OP_RETURN <PUSH32 SHA256(authAnchor)>\n  // output at `vout = hashlocks.length`; the unfunded template must\n  // include it so `fromFundedTransaction` aligns with the funded tx.\n  // Normalize identically to the peg-in primitives (`0x` strip,\n  // lowercase, length/charset validation) so a direct primitive caller\n  // reusing successful peg-in params doesn't hand unnormalized bytes to\n  // WASM. Pass `undefined` for legacy non-auth-anchored Pre-PegIns.\n  const normalizedAuthAnchorHash = normalizeAuthAnchorHash(\n    prePeginParams.authAnchorHash,\n  );\n  // Reconstruct the template under the same graph version the Pre-PegIn\n  // was originally built with (the vault's stamped vaultCoreVersion).\n  const unfundedTx = new WasmPrePeginTx(\n    prePeginParams.vaultCoreVersion,\n    prePeginParams.depositorPubkey,\n    prePeginParams.vaultProviderPubkey,\n    prePeginParams.vaultKeeperPubkeys,\n    prePeginParams.universalChallengerPubkeys,\n    [...prePeginParams.hashlocks],\n    new BigUint64Array(\n      assertPositiveBigintArray(prePeginParams.pegInAmounts, \"pegInAmounts\"),\n    ),\n    prePeginParams.timelockRefund,\n    prePeginParams.feeRate,\n    prePeginParams.minPeginFeeRate,\n    prePeginParams.numLocalChallengers,\n    prePeginParams.councilQuorum,\n    prePeginParams.councilSize,\n    prePeginParams.network,\n    normalizedAuthAnchorHash,\n  );\n\n  let fundedTx: typeof unfundedTx | null = null;\n  try {\n    // Cross-check the reconstructed unfunded template against an independent\n    // TypeScript derivation and the funded transaction bytes.\n    // If they disagree, the template was reconstructed from the wrong\n    // (hashlocks, amounts) vector — signing it would produce a refund\n    // that does not spend the on-chain HTLC the depositor expects.\n    // This is the explicit invariant the audit recommends: never sign a\n    // refund whose template doesn't match the on-chain output bytes.\n    const wasmHtlcScriptPubKey = unfundedTx\n      .getHtlcScriptPubKey(htlcVout)\n      .toLowerCase();\n    const expectedHtlc = deriveExpectedPrePeginHtlc(prePeginParams, hashlock);\n    const expectedHtlcScriptPubKey = expectedHtlc.scriptPubKey.toString(\"hex\");\n    if (wasmHtlcScriptPubKey !== expectedHtlcScriptPubKey) {\n      throw new Error(\n        `WASM HTLC scriptPubKey ${wasmHtlcScriptPubKey} does not match the ` +\n          `independently derived scriptPubKey ${expectedHtlcScriptPubKey}.`,\n      );\n    }\n    // The reconstructed template's HTLC output value at `htlcVout`,\n    // sized by WASM from the supplied `pegInAmounts` via the protocol\n    // formula `htlcValue = peginAmount + depositorClaimValue + p2aAnchorValue + minPeginFee`.\n    // Captured before `fromFundedTransaction` to bind it to the value the\n    // funded tx actually carries (see the cross-check below).\n    const expectedHtlcValue = unfundedTx.getHtlcValue(htlcVout);\n\n    fundedTx = unfundedTx.fromFundedTransaction(fundedPrePeginTxHex);\n\n    const refundTxHex = fundedTx.buildRefundTx(refundFee, htlcVout);\n\n    const cleanPrePeginHex = fundedPrePeginTxHex.startsWith(\"0x\")\n      ? fundedPrePeginTxHex.slice(2)\n      : fundedPrePeginTxHex;\n    const prePeginTx = Transaction.fromHex(cleanPrePeginHex);\n\n    const htlcOutput = prePeginTx.outs[htlcVout];\n    if (!htlcOutput) {\n      throw new Error(\n        `HTLC output at vout ${htlcVout} not found in funded Pre-PegIn tx ` +\n          `(tx has ${prePeginTx.outs.length} outputs)`,\n      );\n    }\n\n    const actualHtlcScriptPubKey = uint8ArrayToHex(\n      new Uint8Array(htlcOutput.script),\n    ).toLowerCase();\n    if (actualHtlcScriptPubKey !== expectedHtlcScriptPubKey) {\n      throw new Error(\n        `HTLC scriptPubKey mismatch at vout ${htlcVout}: reconstructed ` +\n          `template expects ${expectedHtlcScriptPubKey}, funded tx carries ` +\n          `${actualHtlcScriptPubKey}. Refund refused — the (hashlocks, ` +\n          `pegInAmounts) vector does not match the on-chain commitment.`,\n      );\n    }\n\n    // Value cross-check (mirrors the script check above): the template's\n    // HTLC value — derived by WASM from `pegInAmounts` via the protocol\n    // formula — must equal the value the funded tx pays at this output.\n    // A caller that hands the full HTLC output value (or any wrong amount)\n    // as `pegInAmounts` would inflate the template value and trip this\n    // guard, rather than silently signing a refund built from a template\n    // that disagrees with the on-chain commitment.\n    const actualHtlcValue = BigInt(htlcOutput.value);\n    if (actualHtlcValue !== expectedHtlcValue) {\n      throw new Error(\n        `HTLC value mismatch at vout ${htlcVout}: reconstructed template ` +\n          `expects ${expectedHtlcValue} sat, funded tx carries ` +\n          `${actualHtlcValue} sat. Refund refused — the pegInAmounts vector ` +\n          `does not match the on-chain commitment.`,\n      );\n    }\n\n    const refundTx = Transaction.fromHex(refundTxHex);\n\n    if (refundTx.version !== REFUND_TX_VERSION) {\n      throw new Error(\n        `Refund transaction version ${refundTx.version} does not match ` +\n          `protocol version ${REFUND_TX_VERSION}.`,\n      );\n    }\n    if (refundTx.locktime !== REFUND_TX_LOCKTIME) {\n      throw new Error(\n        `Refund transaction locktime ${refundTx.locktime} does not match ` +\n          `protocol locktime ${REFUND_TX_LOCKTIME}.`,\n      );\n    }\n\n    if (refundTx.ins.length !== 1) {\n      throw new Error(\n        `Refund transaction must have exactly 1 input, got ${refundTx.ins.length}`,\n      );\n    }\n\n    const refundInput = refundTx.ins[0];\n\n    // Verify the refund input spends the correct Pre-PegIn HTLC output\n    const prePeginTxid = prePeginTx.getId();\n    const refundInputTxid = uint8ArrayToHex(\n      new Uint8Array(refundInput.hash).slice().reverse(),\n    );\n    if (refundInputTxid !== prePeginTxid) {\n      throw new Error(\n        `Refund input does not reference the Pre-PegIn transaction. ` +\n          `Expected ${prePeginTxid}, got ${refundInputTxid}`,\n      );\n    }\n    if (refundInput.index !== htlcVout) {\n      throw new Error(\n        `Refund input index ${refundInput.index} does not match expected htlcVout ${htlcVout}`,\n      );\n    }\n    if (refundInput.sequence !== prePeginParams.timelockRefund) {\n      throw new Error(\n        `Refund input sequence ${refundInput.sequence} does not match ` +\n          `timelockRefund ${prePeginParams.timelockRefund}.`,\n      );\n    }\n\n    const psbt = new Psbt();\n    psbt.setVersion(refundTx.version);\n    psbt.setLocktime(refundTx.locktime);\n\n    psbt.addInput({\n      hash: refundInput.hash,\n      index: refundInput.index,\n      sequence: refundInput.sequence,\n      witnessUtxo: {\n        script: htlcOutput.script,\n        value: htlcOutput.value,\n      },\n      tapLeafScript: [\n        {\n          leafVersion: TAPSCRIPT_LEAF_VERSION,\n          script: expectedHtlc.refundScript,\n          controlBlock: expectedHtlc.refundControlBlock,\n        },\n      ],\n      tapInternalKey: Buffer.from(tapInternalPubkey),\n      tapMerkleRoot: expectedHtlc.tapMerkleRoot,\n    });\n\n    // Output side: pin the single refund output to the depositor's own\n    // BIP-86 P2TR address, mirroring the input-side pinning above. WASM\n    // builds the refund output from the refund leaf's depositor key, so a\n    // correct template always pays exactly one output back to the depositor.\n    // Asserting it here means a malformed template (or a tampered WASM)\n    // cannot redirect the reclaimed funds to a script the depositor does\n    // not control.\n    if (refundTx.outs.length !== 1) {\n      throw new Error(\n        `Refund transaction must have exactly 1 output, got ${refundTx.outs.length}`,\n      );\n    }\n    const refundOutput = refundTx.outs[0];\n    const expectedDepositorScriptPubKey = stripHexPrefix(\n      deriveBip86ScriptPubKeyHex(prePeginParams.depositorPubkey),\n    ).toLowerCase();\n    const actualRefundOutputScriptPubKey = uint8ArrayToHex(\n      new Uint8Array(refundOutput.script),\n    ).toLowerCase();\n    if (actualRefundOutputScriptPubKey !== expectedDepositorScriptPubKey) {\n      throw new Error(\n        `Refund output scriptPubKey ${actualRefundOutputScriptPubKey} does not ` +\n          `match the depositor's BIP-86 address ${expectedDepositorScriptPubKey}. ` +\n          `Refund refused — the reclaimed funds would not return to the depositor.`,\n      );\n    }\n\n    // Value: the single refund output must return the full HTLC value minus\n    // exactly the requested fee. The refund is 1-in/1-out (asserted above), so\n    // a value below `htlcValue - refundFee` means WASM applied a larger fee\n    // than requested — the difference would be burned as miner fee. Pin it so\n    // the depositor reclaims the expected amount, not a silently reduced one.\n    const expectedRefundOutputValue = actualHtlcValue - refundFee;\n    if (BigInt(refundOutput.value) !== expectedRefundOutputValue) {\n      throw new Error(\n        `Refund output value ${BigInt(refundOutput.value)} sat does not equal ` +\n          `the HTLC value ${actualHtlcValue} sat minus the requested fee ` +\n          `${refundFee} sat (expected ${expectedRefundOutputValue} sat). ` +\n          `Refund refused — the reclaimed amount would be burned as excess fee.`,\n      );\n    }\n\n    psbt.addOutput({\n      script: refundOutput.script,\n      value: refundOutput.value,\n    });\n\n    return { psbtHex: psbt.toHex() };\n  } finally {\n    fundedTx?.free();\n    unfundedTx.free();\n  }\n}\n","/**\n * Reclaim PSBT Builder Primitive\n *\n * Builds an unsigned PSBT that sweeps the depositor-claim reserve — PegIn\n * vout 1 — back to the depositor's own BIP-86 address.\n *\n * The reserve funds the depositor's `claim_tx`, their recourse if the vault\n * provider fails during peg-out. When the vault provider claims instead and\n * the depositor withdraws normally, nothing ever spends it. This primitive is\n * the only thing in the repository that can.\n *\n * Spend path: the single `<depositor> OP_CHECKSIG` tapleaf (see\n * ./depositorClaim). No timelock, no counterparty signature — the depositor's\n * Schnorr signature alone. That is also why the *caller* must gate: this\n * builder will happily sweep a reserve whose vault is still live, which would\n * permanently void the depositor's pre-signed recourse graph. Eligibility is\n * enforced upstream, in the service.\n *\n * @module primitives/psbt/reclaim\n */\n\nimport { Buffer } from \"buffer\";\nimport { Psbt, Transaction } from \"bitcoinjs-lib\";\n\nimport { DUST_THRESHOLD } from \"../../utils/fee/constants\";\nimport {\n  TAPSCRIPT_LEAF_VERSION,\n  deriveBip86ScriptPubKeyHex,\n  hexToUint8Array,\n  stripHexPrefix,\n  uint8ArrayToHex,\n} from \"../utils/bitcoin\";\nimport {\n  PEGIN_DEPOSITOR_CLAIM_VOUT,\n  deriveDepositorClaimDescriptor,\n} from \"./depositorClaim\";\n\n/**\n * nVersion for the reclaim transaction. Plain v2, not TRUC: the reserve is only\n * offered once its PegIn is deeply confirmed, so the v2/v3 PegIn's nVersion-3\n * topology limits no longer constrain its children.\n */\nconst RECLAIM_TX_VERSION = 2;\n\n/**\n * nSequence for every reclaim input: RBF-enabled, no relative timelock. The\n * claim leaf carries no CSV, so this is a fee-bumping signal only.\n */\nconst RECLAIM_INPUT_SEQUENCE = 0xfffffffd;\n\n/**\n * Weight units of the reclaim transaction's skeleton — everything except the\n * inputs. Non-witness `version(4) + inCount(1) + outCount(1) + locktime(4) +\n * output(8 + 1 + 34)` = 53 B × 4, plus the 2 WU SegWit marker and flag.\n */\nconst RECLAIM_SKELETON_WEIGHT_UNITS = 214;\n\n/**\n * Weight units each script-path input adds. Non-witness `outpoint(36) +\n * scriptSigLen(1) + sequence(4)` = 41 B × 4 = 164, plus a witness of\n * `stackCount(1) + sig(1 + 64) + leafScript(1 + 34) + controlBlock(1 + 33)` =\n * 135 WU.\n *\n * Exact rather than conservative: every element is fixed-length here — a\n * 64-byte BIP-340 signature under SIGHASH_DEFAULT, the 34-byte leaf, and a\n * 33-byte control block with no merkle path.\n */\nconst RECLAIM_INPUT_WEIGHT_UNITS = 299;\n\n/** Weight units per virtual byte. */\nconst WEIGHT_UNITS_PER_VBYTE = 4;\n\n/**\n * Virtual size of an N-in/1-out reclaim transaction.\n *\n * `REFUND_VSIZE = 160` does not generalise to N inputs, and\n * `computePeginBaseFeeSats` is wrong for this shape entirely — its\n * `P2TR_INPUT_SIZE = 58` is a *key-path* input and under-fees a script-path\n * spend by roughly a quarter.\n *\n * N=1 → 129 vB; each additional input adds 75 vB.\n */\nexport function reclaimVsize(numInputs: number): number {\n  if (!Number.isInteger(numInputs) || numInputs < 1) {\n    throw new Error(\n      `Reclaim input count must be a positive integer, got ${numInputs}.`,\n    );\n  }\n  return Math.ceil(\n    (RECLAIM_SKELETON_WEIGHT_UNITS +\n      RECLAIM_INPUT_WEIGHT_UNITS * numInputs) /\n      WEIGHT_UNITS_PER_VBYTE,\n  );\n}\n\n/** Absolute fee in satoshis for an N-in/1-out reclaim at a given rate. */\nexport function estimateReclaimFeeSats(\n  feeRateSatsVb: number,\n  numInputs: number,\n): bigint {\n  if (!Number.isFinite(feeRateSatsVb) || feeRateSatsVb <= 0) {\n    throw new Error(\n      `Reclaim fee rate must be a positive number, got ${feeRateSatsVb}.`,\n    );\n  }\n  return BigInt(Math.ceil(feeRateSatsVb * reclaimVsize(numInputs)));\n}\n\n/** One depositor-claim reserve to sweep, with the material to bind it. */\nexport interface ReclaimReserve {\n  /**\n   * The contract's own copy of the depositor-signed PegIn transaction\n   * (`VaultProtocolInfo.depositorSignedPeginTx`). Authoritative: its SegWit\n   * txid equals the broadcast PegIn's, and its `outs[1]` carries the reserve's\n   * script and value at no extra RPC cost.\n   */\n  depositorSignedPeginTxHex: string;\n  /** Independent chain observation of `peginTxid:1` (esplora UTXO lookup). */\n  observed: {\n    /**\n     * The outpoint the caller actually issued its chain lookup against, so the\n     * observation below can be tied to the input this builder adds.\n     *\n     * Without it the script and value binds prove only that *some* UTXO has\n     * this shape — the claim script is a pure function of the depositor key and\n     * so is byte-identical across every vault they own, and the value is a pure\n     * function of protocol parameters. Neither distinguishes one of the\n     * depositor's vaults from another.\n     *\n     * Txid in display order, 64 hex chars, with or without `0x` prefix.\n     */\n    txid: string;\n    /** Vout the lookup was issued against. Must be the claim vout. */\n    vout: number;\n    /** scriptPubKey hex, with or without `0x` prefix. */\n    scriptPubKey: string;\n    /** Output value in satoshis. */\n    value: bigint;\n  };\n  /**\n   * The reserve value recomputed from this vault's protocol parameters via\n   * `computeMinClaimValue`. Bound so a doctored PegIn that agrees with itself\n   * and with a compromised indexer still fails.\n   */\n  expectedValue: bigint;\n}\n\nexport interface BuildReclaimPsbtParams {\n  /**\n   * The **connected wallet's live** x-only pubkey, 64-char hex. Never the\n   * indexer's `depositorBtcPubkey`: re-deriving from the live key is what\n   * proves the wallet about to sign is the wallet that can spend, and rejects\n   * the wrong-wallet case with an error instead of an unspendable broadcast.\n   */\n  depositorPubkey: string;\n  /**\n   * Reserves to sweep. An array so batching several vaults into one\n   * transaction is a later change rather than a rewrite; today the app passes\n   * exactly one.\n   */\n  inputs: ReclaimReserve[];\n  /** Absolute fee in satoshis. The caller sizes it; see `reclaimVsize`. */\n  feeSats: bigint;\n}\n\nexport interface BuildReclaimPsbtResult {\n  /** PSBT hex ready for depositor signing. */\n  psbtHex: string;\n  /** Value of the single output — what the depositor actually receives. */\n  outputValue: bigint;\n  /** Sum of the swept reserves, before fee. */\n  totalInputValue: bigint;\n}\n\n/**\n * Build the N-in/1-out reclaim PSBT.\n *\n * Every input is bound three ways before it reaches the PSBT: the contract's\n * PegIn bytes, the chain observation, and a JS re-derivation from the live\n * wallet key must agree on both script and value. Any disagreement throws.\n * The observation must also name the outpoint it was taken from, since script\n * and value alone repeat across all of a depositor's vaults.\n *\n * Binding the input to the *vault* that was asked for is a further step, and\n * it belongs to the service: it needs the vault id derivation, which is async.\n * See `services/reclaim/buildAndBroadcastReclaim`.\n *\n * @throws If `inputs` is empty, the fee is non-positive, any input fails its\n *   outpoint, script or value bind, or the resulting output would be at or\n *   below dust.\n */\nexport function buildReclaimPsbt(\n  params: BuildReclaimPsbtParams,\n): BuildReclaimPsbtResult {\n  const { depositorPubkey, inputs, feeSats } = params;\n\n  if (inputs.length === 0) {\n    throw new Error(\"Reclaim requires at least one input; got none.\");\n  }\n  if (feeSats <= 0n) {\n    throw new Error(\n      `Reclaim fee must be positive, got ${feeSats} sat. Refusing to build a ` +\n        `transaction that would not relay.`,\n    );\n  }\n\n  // One derivation, reused for every input's bind and for the destination.\n  const descriptor = deriveDepositorClaimDescriptor(depositorPubkey);\n  const expectedScriptPubKey = uint8ArrayToHex(\n    new Uint8Array(descriptor.scriptPubKey),\n  ).toLowerCase();\n\n  const psbt = new Psbt();\n  psbt.setVersion(RECLAIM_TX_VERSION);\n  psbt.setLocktime(0);\n\n  let totalInputValue = 0n;\n  const seenOutpoints = new Set<string>();\n\n  inputs.forEach((input, i) => {\n    const peginTx = Transaction.fromHex(\n      stripHexPrefix(input.depositorSignedPeginTxHex),\n    );\n    const peginTxid = peginTx.getId();\n\n    const claimOut = peginTx.outs[PEGIN_DEPOSITOR_CLAIM_VOUT];\n    if (!claimOut) {\n      throw new Error(\n        `PegIn ${peginTxid} has no output at vout ` +\n          `${PEGIN_DEPOSITOR_CLAIM_VOUT} (tx has ${peginTx.outs.length}); ` +\n          `there is no depositor-claim reserve to reclaim.`,\n      );\n    }\n\n    // Bind 0: the observation is of *this* outpoint. Everything below compares\n    // a script and a value, both of which repeat across every vault this\n    // depositor owns under the same protocol parameters — so without this the\n    // remaining binds cannot tell one of their vaults from another, and a\n    // caller that resolved the wrong vault would sweep it with every check\n    // passing. The independent source is the PegIn the PSBT is built from; the\n    // esplora response cannot serve here because `getUtxoInfo` echoes back the\n    // txid and vout it was called with rather than reading them from the body.\n    const observedTxid = stripHexPrefix(input.observed.txid).toLowerCase();\n    if (observedTxid !== peginTxid) {\n      throw new Error(\n        `Input ${i}: the observation is of ${observedTxid}, but this input ` +\n          `spends PegIn ${peginTxid}. Reclaim refused — the reserve that was ` +\n          `looked up is not the one being swept.`,\n      );\n    }\n    if (input.observed.vout !== PEGIN_DEPOSITOR_CLAIM_VOUT) {\n      throw new Error(\n        `Input ${i}: the observation is of vout ${input.observed.vout}, but ` +\n          `the depositor-claim reserve is at vout ` +\n          `${PEGIN_DEPOSITOR_CLAIM_VOUT}. Reclaim refused.`,\n      );\n    }\n\n    // Bind 1: the contract's PegIn bytes against the JS re-derivation from the\n    // live wallet key. This is the assertion that proves the connected wallet\n    // can actually spend the output we are about to sign for.\n    const contractScriptPubKey = uint8ArrayToHex(\n      new Uint8Array(claimOut.script),\n    ).toLowerCase();\n    if (contractScriptPubKey !== expectedScriptPubKey) {\n      throw new Error(\n        `Input ${i}: PegIn ${peginTxid} vout ${PEGIN_DEPOSITOR_CLAIM_VOUT} pays ` +\n          `${contractScriptPubKey}, but the connected wallet's depositor-claim ` +\n          `script is ${expectedScriptPubKey}. Reclaim refused — this reserve ` +\n          `belongs to a different wallet.`,\n      );\n    }\n\n    // Bind 2: the independent chain observation must agree with both.\n    const observedScriptPubKey = stripHexPrefix(\n      input.observed.scriptPubKey,\n    ).toLowerCase();\n    if (observedScriptPubKey !== expectedScriptPubKey) {\n      throw new Error(\n        `Input ${i}: the observed UTXO ${peginTxid}:${PEGIN_DEPOSITOR_CLAIM_VOUT} ` +\n          `pays ${observedScriptPubKey}, expected ${expectedScriptPubKey}. ` +\n          `Reclaim refused — chain state disagrees with the contract's PegIn.`,\n      );\n    }\n\n    // Value bind, same three ways.\n    const contractValue = BigInt(claimOut.value);\n    if (contractValue !== input.observed.value) {\n      throw new Error(\n        `Input ${i}: PegIn ${peginTxid} vout ${PEGIN_DEPOSITOR_CLAIM_VOUT} ` +\n          `carries ${contractValue} sat, but the observed UTXO carries ` +\n          `${input.observed.value} sat. Reclaim refused.`,\n      );\n    }\n    if (contractValue !== input.expectedValue) {\n      throw new Error(\n        `Input ${i}: PegIn ${peginTxid} vout ${PEGIN_DEPOSITOR_CLAIM_VOUT} ` +\n          `carries ${contractValue} sat, but this vault's parameters compute a ` +\n          `depositor-claim value of ${input.expectedValue} sat. Reclaim refused.`,\n      );\n    }\n\n    // A batch that names the same vault twice would otherwise double-count the\n    // swept total and then fail deep inside bitcoinjs. Reject it here, where\n    // the message can say which input is the duplicate.\n    const outpoint = `${peginTxid}:${PEGIN_DEPOSITOR_CLAIM_VOUT}`;\n    if (seenOutpoints.has(outpoint)) {\n      throw new Error(\n        `Input ${i} repeats outpoint ${outpoint}, which is already being ` +\n          `swept by an earlier input. Reclaim refused.`,\n      );\n    }\n    seenOutpoints.add(outpoint);\n\n    totalInputValue += contractValue;\n\n    psbt.addInput({\n      hash: peginTxid,\n      index: PEGIN_DEPOSITOR_CLAIM_VOUT,\n      sequence: RECLAIM_INPUT_SEQUENCE,\n      witnessUtxo: { script: claimOut.script, value: claimOut.value },\n      tapLeafScript: [\n        {\n          leafVersion: TAPSCRIPT_LEAF_VERSION,\n          script: descriptor.leafScript,\n          controlBlock: descriptor.controlBlock,\n        },\n      ],\n      tapInternalKey: descriptor.internalKey,\n    });\n  });\n\n  if (feeSats >= totalInputValue) {\n    throw new Error(\n      `Reclaim fee ${feeSats} sat is not less than the swept total ` +\n        `${totalInputValue} sat. Refusing to build a transaction with no output.`,\n    );\n  }\n\n  const outputValue = totalInputValue - feeSats;\n  if (outputValue <= DUST_THRESHOLD) {\n    throw new Error(\n      `Reclaim output ${outputValue} sat is at or below the dust threshold ` +\n        `${DUST_THRESHOLD} sat. The reserve is not at risk — it stays where it ` +\n        `is until fee rates fall.`,\n    );\n  }\n\n  const destination = stripHexPrefix(\n    deriveBip86ScriptPubKeyHex(depositorPubkey),\n  );\n  psbt.addOutput({\n    script: Buffer.from(hexToUint8Array(destination)),\n    value: Number(outputValue),\n  });\n\n  return { psbtHex: psbt.toHex(), outputValue, totalInputValue };\n}\n","/**\n * Finalize a Taproot script-path spend from the PSBT *we* built, using only the\n * verified signatures the wallet returned.\n *\n * Why this exists. The obvious shape — hand the wallet's PSBT to\n * `finalizeAllInputs()` — puts wallet-controlled bytes on the trust path even\n * when the signature itself has been verified.\n * `assertPsbtUnsignedTxMatches` deliberately pins only the unsigned\n * transaction and skips per-input metadata, so `tapLeafScript`, `controlBlock`\n * and `tapKeySig` all survive from the wallet's response untouched. And\n * bitcoinjs-lib checks key-spend first (`src/psbt.js`, `_finalizeTaprootInput`:\n * \"Check key spend first. Increased privacy and reduced block space.\"), so a\n * returned `tapKeySig` wins outright and `tapScriptSig` is never consulted.\n * Every output the depositor-claim reserve and the HTLC refund spend from uses\n * a NUMS internal key, so the resulting key-path witness cannot satisfy the\n * script — the transaction is rejected at broadcast, after a wallet prompt the\n * depositor cannot make sense of.\n *\n * Verifying and then discarding the wallet's PSBT closes that off structurally\n * rather than detecting it afterwards, and it makes the code match what\n * `verifyScriptPathSchnorrSignature` already documents: \"only the 64-byte\n * signature comes from the wallet\".\n *\n * @module tbv/core/primitives/psbt/finalizeScriptPathWithSignatures\n */\n\nimport { Psbt } from \"bitcoinjs-lib\";\nimport { Buffer } from \"buffer\";\n\nimport { X_ONLY_PUBKEY_HEX_LEN } from \"../../utils/validation\";\nimport {\n  SCHNORR_SIG_HEX_LEN,\n  TAPSCRIPT_LEAF_VERSION,\n  hexToUint8Array,\n  stripHexPrefix,\n} from \"../utils/bitcoin\";\nimport { computeTapLeafHash } from \"../utils/taproot\";\n\nexport interface FinalizeScriptPathWithSignaturesParams {\n  /**\n   * Hex of the PSBT built locally and sent to the wallet — the sole source of\n   * every per-input field. NOT the wallet-returned PSBT.\n   */\n  requestedPsbtHex: string;\n  /**\n   * Verified 64-byte Schnorr signatures, one per input, index-aligned with the\n   * PSBT's inputs. Each must already have passed\n   * `assertScriptPathSchnorrSignature` — this function does not re-verify them,\n   * it only decides which bytes are allowed to reach the witness.\n   */\n  signaturesHex: readonly string[];\n  /** X-only pubkey (64 hex chars) the signatures are attributed to. */\n  signerXOnlyPubkeyHex: string;\n}\n\n/**\n * Attach `signaturesHex` to the locally built PSBT's script-path inputs,\n * finalize, and return the extracted transaction hex.\n *\n * @throws If the signature count does not match the input count, any signature\n *   or the signer key is malformed, any input does not carry exactly one\n *   tapscript leaf at the expected leaf version, any input already carries a\n *   key-path signature, or bitcoinjs-lib cannot finalize.\n */\nexport function finalizeScriptPathWithSignatures(\n  params: FinalizeScriptPathWithSignaturesParams,\n): string {\n  const { requestedPsbtHex, signaturesHex, signerXOnlyPubkeyHex } = params;\n\n  const signerXOnly = stripHexPrefix(signerXOnlyPubkeyHex);\n  if (signerXOnly.length !== X_ONLY_PUBKEY_HEX_LEN) {\n    throw new Error(\n      `Signer x-only pubkey must be ${X_ONLY_PUBKEY_HEX_LEN} hex chars ` +\n        `(32 bytes), got ${signerXOnly.length}.`,\n    );\n  }\n  const signerPubkey = Buffer.from(hexToUint8Array(signerXOnly));\n\n  const psbt = Psbt.fromHex(requestedPsbtHex);\n\n  if (signaturesHex.length !== psbt.data.inputs.length) {\n    throw new Error(\n      `Cannot finalize: got ${signaturesHex.length} signature(s) for ` +\n        `${psbt.data.inputs.length} input(s). Every input must be signed — ` +\n        `refusing to broadcast a partially signed transaction.`,\n    );\n  }\n\n  psbt.data.inputs.forEach((input, inputIndex) => {\n    // Our own builders never produce a key-path signature for these spends.\n    // If one is present the PSBT is not the one we built, which would defeat\n    // the whole point of finalizing locally.\n    if (input.tapKeySig) {\n      throw new Error(\n        `Cannot finalize: input ${inputIndex} of the locally built PSBT ` +\n          `carries a key-path signature. These outputs are script-path only.`,\n      );\n    }\n\n    const tapLeafScripts = input.tapLeafScript;\n    if (!tapLeafScripts || tapLeafScripts.length !== 1) {\n      throw new Error(\n        `Cannot finalize: input ${inputIndex} must have exactly one ` +\n          `tapLeafScript, got ${tapLeafScripts?.length ?? 0}.`,\n      );\n    }\n    const leaf = tapLeafScripts[0];\n    if (leaf.leafVersion !== TAPSCRIPT_LEAF_VERSION) {\n      throw new Error(\n        `Cannot finalize: input ${inputIndex} tapLeafScript has leaf version ` +\n          `0x${leaf.leafVersion.toString(16)}, expected ` +\n          `0x${TAPSCRIPT_LEAF_VERSION.toString(16)}.`,\n      );\n    }\n\n    const signatureRaw = stripHexPrefix(signaturesHex[inputIndex]);\n    if (signatureRaw.length !== SCHNORR_SIG_HEX_LEN) {\n      throw new Error(\n        `Signature for input ${inputIndex} must be ${SCHNORR_SIG_HEX_LEN} hex ` +\n          `chars (64 bytes), got ${signatureRaw.length}.`,\n      );\n    }\n\n    psbt.updateInput(inputIndex, {\n      tapScriptSig: [\n        {\n          pubkey: signerPubkey,\n          leafHash: computeTapLeafHash(leaf.leafVersion, leaf.script),\n          signature: Buffer.from(hexToUint8Array(signatureRaw)),\n        },\n      ],\n    });\n  });\n\n  // With no tapKeySig anywhere, bitcoinjs takes the script-path branch for\n  // every input and builds `[signature, leafScript, controlBlock]` from the\n  // leaf we supplied.\n  psbt.finalizeAllInputs();\n\n  return psbt.extractTransaction().toHex();\n}\n","/**\n * NoPayout PSBT Builder\n *\n * Builds unsigned PSBTs for the depositor's NoPayout transaction\n * (depositor-as-claimer path, per challenger). The depositor signs input 0\n * using the NoPayout taproot script from WasmAssertPayoutNoPayoutConnector.\n *\n * @module primitives/psbt/noPayout\n * @see btc-vault crates/vault/docs/btc-transactions-spec.md — Assert output 0 NoPayout connector\n */\n\nimport {\n  type AssertPayoutNoPayoutConnectorParams,\n  type Network,\n  getAssertNoPayoutScriptInfo,\n  tapInternalPubkey,\n} from \"../../wasm\";\nimport { Buffer } from \"buffer\";\nimport { Psbt, Transaction, payments } from \"bitcoinjs-lib\";\n\nimport {\n  TAPSCRIPT_LEAF_VERSION,\n  getNetwork,\n  hexToUint8Array,\n  processPublicKeyToXOnly,\n  stripHexPrefix,\n} from \"../utils/bitcoin\";\n\n/**\n * Parameters for building a NoPayout PSBT\n */\nexport interface NoPayoutParams {\n  /** NoPayout transaction hex (unsigned) from VP */\n  noPayoutTxHex: string;\n  /** Challenger's x-only public key (hex encoded) */\n  challengerPubkey: string;\n  /** Prevouts for all inputs [{script_pubkey, value}], used verbatim — derive them from the parent txs */\n  prevouts: Array<{ script_pubkey: string; value: number }>;\n  /** Parameters for the Assert Payout/NoPayout connector */\n  connectorParams: AssertPayoutNoPayoutConnectorParams;\n}\n\n/**\n * Build unsigned NoPayout PSBT.\n *\n * The NoPayout transaction is specific to each challenger.\n * Input 0 is the one the depositor signs using the NoPayout taproot script path.\n *\n * @param params - NoPayout parameters\n * @returns Unsigned PSBT hex ready for signing\n */\nexport async function buildNoPayoutPsbt(\n  params: NoPayoutParams,\n): Promise<string> {\n  const noPayoutTxHex = stripHexPrefix(params.noPayoutTxHex);\n  const noPayoutTx = Transaction.fromHex(noPayoutTxHex);\n\n  // Get NoPayout script and control block for this challenger\n  const { noPayoutScript, noPayoutControlBlock } =\n    await getAssertNoPayoutScriptInfo(\n      params.connectorParams,\n      params.challengerPubkey,\n    );\n\n  const scriptBytes = hexToUint8Array(noPayoutScript);\n  const controlBlockBytes = hexToUint8Array(noPayoutControlBlock);\n\n  const psbt = new Psbt();\n  psbt.setVersion(noPayoutTx.version);\n  psbt.setLocktime(noPayoutTx.locktime);\n\n  // Add all inputs - depositor signs input 0 only\n  for (let i = 0; i < noPayoutTx.ins.length; i++) {\n    const input = noPayoutTx.ins[i];\n    const prevout = params.prevouts[i];\n\n    if (!prevout) {\n      throw new Error(`Missing prevout data for input ${i}`);\n    }\n\n    const inputData: Parameters<typeof psbt.addInput>[0] = {\n      hash: input.hash,\n      index: input.index,\n      sequence: input.sequence,\n      witnessUtxo: {\n        script: Buffer.from(hexToUint8Array(stripHexPrefix(prevout.script_pubkey))),\n        value: prevout.value,\n      },\n    };\n\n    // Input 0: depositor signs using taproot script path\n    if (i === 0) {\n      inputData.tapLeafScript = [\n        {\n          leafVersion: TAPSCRIPT_LEAF_VERSION,\n          script: Buffer.from(scriptBytes),\n          controlBlock: Buffer.from(controlBlockBytes),\n        },\n      ];\n      inputData.tapInternalKey = Buffer.from(tapInternalPubkey);\n    }\n\n    psbt.addInput(inputData);\n  }\n\n  // Add outputs\n  for (const output of noPayoutTx.outs) {\n    psbt.addOutput({\n      script: output.script,\n      value: output.value,\n    });\n  }\n\n  return psbt.toHex();\n}\n\n/**\n * Validate that a NoPayout transaction pays to the challenger via the\n * protocol-defined output structure: a single BIP-86 P2TR output derived from\n * the challenger's x-only pubkey.\n *\n * Mirrors the per-role payout output validation now inlined in\n * `buildPayoutPsbt` for the NoPayout path, where the sink is fixed by the\n * protocol rather than read from on-chain registration\n * (see `crates/vault/src/transactions/nopayout.rs::NoPayoutTx::new`).\n *\n * @param noPayoutTxHex - Raw NoPayout transaction hex\n * @param challengerPubkey - Challenger's x-only public key (hex)\n * @param network - Bitcoin network used to derive the P2TR scriptPubKey\n * @throws If the transaction does not have exactly one output\n * @throws If the single output's scriptPubKey does not equal the BIP-86 P2TR\n *         scriptPubKey for the challenger\n */\nexport function assertNoPayoutOutputMatchesChallenger(\n  noPayoutTxHex: string,\n  challengerPubkey: string,\n  network: Network,\n): void {\n  const tx = Transaction.fromHex(stripHexPrefix(noPayoutTxHex));\n\n  if (tx.outs.length !== 1) {\n    throw new Error(\n      `NoPayout transaction must have exactly 1 output, got ${tx.outs.length}`,\n    );\n  }\n\n  const xOnly = hexToUint8Array(processPublicKeyToXOnly(challengerPubkey));\n  const { output: expectedScript } = payments.p2tr({\n    internalPubkey: Buffer.from(xOnly),\n    network: getNetwork(network),\n  });\n  if (!expectedScript) {\n    throw new Error(\n      \"Failed to derive challenger BIP-86 P2TR scriptPubKey for NoPayout output validation\",\n    );\n  }\n\n  if (!tx.outs[0].script.equals(expectedScript)) {\n    throw new Error(\n      \"NoPayout transaction does not pay to the expected challenger BIP-86 P2TR address\",\n    );\n  }\n}\n"],"names":["U64_MAX","assertPositiveBigintArray","values","label","value","index","buildRefundPsbt","params","WasmPrePeginTx","loadTbvWasm","prePeginParams","fundedPrePeginTxHex","htlcVout","refundFee","hashlock","normalizedAuthAnchorHash","normalizeAuthAnchorHash","unfundedTx","fundedTx","wasmHtlcScriptPubKey","expectedHtlc","deriveExpectedPrePeginHtlc","expectedHtlcScriptPubKey","expectedHtlcValue","refundTxHex","cleanPrePeginHex","prePeginTx","Transaction","htlcOutput","actualHtlcScriptPubKey","uint8ArrayToHex","actualHtlcValue","refundTx","REFUND_TX_VERSION","REFUND_TX_LOCKTIME","refundInput","prePeginTxid","refundInputTxid","psbt","Psbt","TAPSCRIPT_LEAF_VERSION","Buffer","tapInternalPubkey","refundOutput","expectedDepositorScriptPubKey","stripHexPrefix","deriveBip86ScriptPubKeyHex","actualRefundOutputScriptPubKey","expectedRefundOutputValue","RECLAIM_TX_VERSION","RECLAIM_INPUT_SEQUENCE","RECLAIM_SKELETON_WEIGHT_UNITS","RECLAIM_INPUT_WEIGHT_UNITS","WEIGHT_UNITS_PER_VBYTE","reclaimVsize","numInputs","estimateReclaimFeeSats","feeRateSatsVb","buildReclaimPsbt","depositorPubkey","inputs","feeSats","descriptor","deriveDepositorClaimDescriptor","expectedScriptPubKey","totalInputValue","seenOutpoints","input","i","peginTx","peginTxid","claimOut","PEGIN_DEPOSITOR_CLAIM_VOUT","observedTxid","contractScriptPubKey","observedScriptPubKey","contractValue","outpoint","outputValue","DUST_THRESHOLD","destination","hexToUint8Array","finalizeScriptPathWithSignatures","requestedPsbtHex","signaturesHex","signerXOnlyPubkeyHex","signerXOnly","X_ONLY_PUBKEY_HEX_LEN","signerPubkey","inputIndex","tapLeafScripts","leaf","signatureRaw","SCHNORR_SIG_HEX_LEN","computeTapLeafHash","buildNoPayoutPsbt","noPayoutTxHex","noPayoutTx","noPayoutScript","noPayoutControlBlock","getAssertNoPayoutScriptInfo","scriptBytes","controlBlockBytes","prevout","inputData","output","assertNoPayoutOutputMatchesChallenger","challengerPubkey","network","tx","xOnly","processPublicKeyToXOnly","expectedScript","payments","getNetwork"],"mappings":"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"}

package/dist/noPayout-DOHak0ui.cjs

@@ -1,2 +0,0 @@
-"use strict";const m=require("bitcoinjs-lib"),x=require("buffer"),S=require("./tbv/core/wasm/index.cjs"),t=require("./bitcoin-D-O2GjbC.cjs"),h=require("./verifyScriptPathSchnorrSignature-D2t1yACC.cjs"),v=require("./constants-BwCg5K6R.cjs"),N=require("./fundPeginTransaction-54-Rwb2k.cjs"),k=require("./validation-C6XTfZak.cjs"),V=(1n<<64n)-1n;function B(r,u){if(!Array.isArray(r))throw new Error(`${u} must be an array of positive bigints (got ${typeof r}).`);if(r.length===0)throw new Error(`${u} must not be empty.`);return r.forEach((e,n)=>{if(typeof e!="bigint")throw new Error(`${u}[${n}] must be a bigint (got ${typeof e}); refusing to feed it into satoshi math.`);if(e<=0n)throw new Error(`${u}[${n}] must be > 0 (got ${e}).`);if(e>V)throw new Error(`${u}[${n}] must fit in a u64 (got ${e}); refusing to feed it into satoshi math.`)}),r}async function K(r){const{WasmPrePeginTx:u}=await S.loadTbvWasm(),{prePeginParams:e,fundedPrePeginTxHex:n,htlcVout:s,refundFee:f,hashlock:c}=r,l=h.normalizeAuthAnchorHash(e.authAnchorHash),o=new u(e.vaultCoreVersion,e.depositorPubkey,e.vaultProviderPubkey,e.vaultKeeperPubkeys,e.universalChallengerPubkeys,[...e.hashlocks],new BigUint64Array(B(e.pegInAmounts,"pegInAmounts")),e.timelockRefund,e.feeRate,e.minPeginFeeRate,e.numLocalChallengers,e.councilQuorum,e.councilSize,e.network,l);let a=null;try{const d=o.getHtlcScriptPubKey(s).toLowerCase(),i=h.deriveExpectedPrePeginHtlc(e,c),P=i.scriptPubKey.toString("hex");if(d!==P)throw new Error(`WASM HTLC scriptPubKey ${d} does not match the independently derived scriptPubKey ${P}.`);const T=o.getHtlcValue(s);a=o.fromFundedTransaction(n);const w=a.buildRefundTx(f,s),b=n.startsWith("0x")?n.slice(2):n,$=m.Transaction.fromHex(b),E=$.outs[s];if(!E)throw new Error(`HTLC output at vout ${s} not found in funded Pre-PegIn tx (tx has ${$.outs.length} outputs)`);const I=t.uint8ArrayToHex(new Uint8Array(E.script)).toLowerCase();if(I!==P)throw new Error(`HTLC scriptPubKey mismatch at vout ${s}: reconstructed template expects ${P}, funded tx carries ${I}. Refund refused — the (hashlocks, pegInAmounts) vector does not match the on-chain commitment.`);const g=BigInt(E.value);if(g!==T)throw new Error(`HTLC value mismatch at vout ${s}: reconstructed template expects ${T} sat, funded tx carries ${g} sat. Refund refused — the pegInAmounts vector does not match the on-chain commitment.`);const p=m.Transaction.fromHex(w);if(p.version!==v.REFUND_TX_VERSION)throw new Error(`Refund transaction version ${p.version} does not match protocol version ${v.REFUND_TX_VERSION}.`);if(p.locktime!==v.REFUND_TX_LOCKTIME)throw new Error(`Refund transaction locktime ${p.locktime} does not match protocol locktime ${v.REFUND_TX_LOCKTIME}.`);if(p.ins.length!==1)throw new Error(`Refund transaction must have exactly 1 input, got ${p.ins.length}`);const y=p.ins[0],H=$.getId(),O=t.uint8ArrayToHex(new Uint8Array(y.hash).slice().reverse());if(O!==H)throw new Error(`Refund input does not reference the Pre-PegIn transaction. Expected ${H}, got ${O}`);if(y.index!==s)throw new Error(`Refund input index ${y.index} does not match expected htlcVout ${s}`);if(y.sequence!==e.timelockRefund)throw new Error(`Refund input sequence ${y.sequence} does not match timelockRefund ${e.timelockRefund}.`);const R=new m.Psbt;if(R.setVersion(p.version),R.setLocktime(p.locktime),R.addInput({hash:y.hash,index:y.index,sequence:y.sequence,witnessUtxo:{script:E.script,value:E.value},tapLeafScript:[{leafVersion:t.TAPSCRIPT_LEAF_VERSION,script:i.refundScript,controlBlock:i.refundControlBlock}],tapInternalKey:x.Buffer.from(S.tapInternalPubkey),tapMerkleRoot:i.tapMerkleRoot}),p.outs.length!==1)throw new Error(`Refund transaction must have exactly 1 output, got ${p.outs.length}`);const _=p.outs[0],A=t.stripHexPrefix(t.deriveBip86ScriptPubKeyHex(e.depositorPubkey)).toLowerCase(),L=t.uint8ArrayToHex(new Uint8Array(_.script)).toLowerCase();if(L!==A)throw new Error(`Refund output scriptPubKey ${L} does not match the depositor's BIP-86 address ${A}. Refund refused — the reclaimed funds would not return to the depositor.`);const C=g-f;if(BigInt(_.value)!==C)throw new Error(`Refund output value ${BigInt(_.value)} sat does not equal the HTLC value ${g} sat minus the requested fee ${f} sat (expected ${C} sat). Refund refused — the reclaimed amount would be burned as excess fee.`);return R.addOutput({script:_.script,value:_.value}),{psbtHex:R.toHex()}}finally{a==null||a.free(),o.free()}}const M=2,D=4294967293,q=214,X=299,F=4;function U(r){if(!Number.isInteger(r)||r<1)throw new Error(`Reclaim input count must be a positive integer, got ${r}.`);return Math.ceil((q+X*r)/F)}function G(r,u){if(!Number.isFinite(r)||r<=0)throw new Error(`Reclaim fee rate must be a positive number, got ${r}.`);return BigInt(Math.ceil(r*U(u)))}function z(r){const{depositorPubkey:u,inputs:e,feeSats:n}=r;if(e.length===0)throw new Error("Reclaim requires at least one input; got none.");if(n<=0n)throw new Error(`Reclaim fee must be positive, got ${n} sat. Refusing to build a transaction that would not relay.`);const s=h.deriveDepositorClaimDescriptor(u),f=t.uint8ArrayToHex(new Uint8Array(s.scriptPubKey)).toLowerCase(),c=new m.Psbt;c.setVersion(M),c.setLocktime(0);let l=0n;const o=new Set;if(e.forEach((i,P)=>{const T=m.Transaction.fromHex(t.stripHexPrefix(i.depositorSignedPeginTxHex)),w=T.getId(),b=T.outs[h.PEGIN_DEPOSITOR_CLAIM_VOUT];if(!b)throw new Error(`PegIn ${w} has no output at vout ${h.PEGIN_DEPOSITOR_CLAIM_VOUT} (tx has ${T.outs.length}); there is no depositor-claim reserve to reclaim.`);const $=t.stripHexPrefix(i.observed.txid).toLowerCase();if($!==w)throw new Error(`Input ${P}: the observation is of ${$}, but this input spends PegIn ${w}. Reclaim refused — the reserve that was looked up is not the one being swept.`);if(i.observed.vout!==h.PEGIN_DEPOSITOR_CLAIM_VOUT)throw new Error(`Input ${P}: the observation is of vout ${i.observed.vout}, but the depositor-claim reserve is at vout ${h.PEGIN_DEPOSITOR_CLAIM_VOUT}. Reclaim refused.`);const E=t.uint8ArrayToHex(new Uint8Array(b.script)).toLowerCase();if(E!==f)throw new Error(`Input ${P}: PegIn ${w} vout ${h.PEGIN_DEPOSITOR_CLAIM_VOUT} pays ${E}, but the connected wallet's depositor-claim script is ${f}. Reclaim refused — this reserve belongs to a different wallet.`);const I=t.stripHexPrefix(i.observed.scriptPubKey).toLowerCase();if(I!==f)throw new Error(`Input ${P}: the observed UTXO ${w}:${h.PEGIN_DEPOSITOR_CLAIM_VOUT} pays ${I}, expected ${f}. Reclaim refused — chain state disagrees with the contract's PegIn.`);const g=BigInt(b.value);if(g!==i.observed.value)throw new Error(`Input ${P}: PegIn ${w} vout ${h.PEGIN_DEPOSITOR_CLAIM_VOUT} carries ${g} sat, but the observed UTXO carries ${i.observed.value} sat. Reclaim refused.`);if(g!==i.expectedValue)throw new Error(`Input ${P}: PegIn ${w} vout ${h.PEGIN_DEPOSITOR_CLAIM_VOUT} carries ${g} sat, but this vault's parameters compute a depositor-claim value of ${i.expectedValue} sat. Reclaim refused.`);const p=`${w}:${h.PEGIN_DEPOSITOR_CLAIM_VOUT}`;if(o.has(p))throw new Error(`Input ${P} repeats outpoint ${p}, which is already being swept by an earlier input. Reclaim refused.`);o.add(p),l+=g,c.addInput({hash:w,index:h.PEGIN_DEPOSITOR_CLAIM_VOUT,sequence:D,witnessUtxo:{script:b.script,value:b.value},tapLeafScript:[{leafVersion:t.TAPSCRIPT_LEAF_VERSION,script:s.leafScript,controlBlock:s.controlBlock}],tapInternalKey:s.internalKey})}),n>=l)throw new Error(`Reclaim fee ${n} sat is not less than the swept total ${l} sat. Refusing to build a transaction with no output.`);const a=l-n;if(a<=N.DUST_THRESHOLD)throw new Error(`Reclaim output ${a} sat is at or below the dust threshold ${N.DUST_THRESHOLD} sat. The reserve is not at risk — it stays where it is until fee rates fall.`);const d=t.stripHexPrefix(t.deriveBip86ScriptPubKeyHex(u));return c.addOutput({script:x.Buffer.from(t.hexToUint8Array(d)),value:Number(a)}),{psbtHex:c.toHex(),outputValue:a,totalInputValue:l}}function W(r){const{requestedPsbtHex:u,signaturesHex:e,signerXOnlyPubkeyHex:n}=r,s=t.stripHexPrefix(n);if(s.length!==k.X_ONLY_PUBKEY_HEX_LEN)throw new Error(`Signer x-only pubkey must be ${k.X_ONLY_PUBKEY_HEX_LEN} hex chars (32 bytes), got ${s.length}.`);const f=x.Buffer.from(t.hexToUint8Array(s)),c=m.Psbt.fromHex(u);if(e.length!==c.data.inputs.length)throw new Error(`Cannot finalize: got ${e.length} signature(s) for ${c.data.inputs.length} input(s). Every input must be signed — refusing to broadcast a partially signed transaction.`);return c.data.inputs.forEach((l,o)=>{if(l.tapKeySig)throw new Error(`Cannot finalize: input ${o} of the locally built PSBT carries a key-path signature. These outputs are script-path only.`);const a=l.tapLeafScript;if(!a||a.length!==1)throw new Error(`Cannot finalize: input ${o} must have exactly one tapLeafScript, got ${(a==null?void 0:a.length)??0}.`);const d=a[0];if(d.leafVersion!==t.TAPSCRIPT_LEAF_VERSION)throw new Error(`Cannot finalize: input ${o} tapLeafScript has leaf version 0x${d.leafVersion.toString(16)}, expected 0x${t.TAPSCRIPT_LEAF_VERSION.toString(16)}.`);const i=t.stripHexPrefix(e[o]);if(i.length!==t.SCHNORR_SIG_HEX_LEN)throw new Error(`Signature for input ${o} must be ${t.SCHNORR_SIG_HEX_LEN} hex chars (64 bytes), got ${i.length}.`);c.updateInput(o,{tapScriptSig:[{pubkey:f,leafHash:h.computeTapLeafHash(d.leafVersion,d.script),signature:x.Buffer.from(t.hexToUint8Array(i))}]})}),c.finalizeAllInputs(),c.extractTransaction().toHex()}async function Y(r){const u=t.stripHexPrefix(r.noPayoutTxHex),e=m.Transaction.fromHex(u),{noPayoutScript:n,noPayoutControlBlock:s}=await S.getAssertNoPayoutScriptInfo(r.connectorParams,r.challengerPubkey),f=t.hexToUint8Array(n),c=t.hexToUint8Array(s),l=new m.Psbt;l.setVersion(e.version),l.setLocktime(e.locktime);for(let o=0;o<e.ins.length;o++){const a=e.ins[o],d=r.prevouts[o];if(!d)throw new Error(`Missing prevout data for input ${o}`);const i={hash:a.hash,index:a.index,sequence:a.sequence,witnessUtxo:{script:x.Buffer.from(t.hexToUint8Array(t.stripHexPrefix(d.script_pubkey))),value:d.value}};o===0&&(i.tapLeafScript=[{leafVersion:t.TAPSCRIPT_LEAF_VERSION,script:x.Buffer.from(f),controlBlock:x.Buffer.from(c)}],i.tapInternalKey=x.Buffer.from(S.tapInternalPubkey)),l.addInput(i)}for(const o of e.outs)l.addOutput({script:o.script,value:o.value});return l.toHex()}function Q(r,u,e){const n=m.Transaction.fromHex(t.stripHexPrefix(r));if(n.outs.length!==1)throw new Error(`NoPayout transaction must have exactly 1 output, got ${n.outs.length}`);const s=t.hexToUint8Array(t.processPublicKeyToXOnly(u)),{output:f}=m.payments.p2tr({internalPubkey:x.Buffer.from(s),network:t.getNetwork(e)});if(!f)throw new Error("Failed to derive challenger BIP-86 P2TR scriptPubKey for NoPayout output validation");if(!n.outs[0].script.equals(f))throw new Error("NoPayout transaction does not pay to the expected challenger BIP-86 P2TR address")}exports.assertNoPayoutOutputMatchesChallenger=Q;exports.buildNoPayoutPsbt=Y;exports.buildReclaimPsbt=z;exports.buildRefundPsbt=K;exports.estimateReclaimFeeSats=G;exports.finalizeScriptPathWithSignatures=W;exports.reclaimVsize=U;
-//# sourceMappingURL=noPayout-DOHak0ui.cjs.map

package/dist/noPayout-DOHak0ui.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"noPayout-DOHak0ui.cjs","sources":["../src/tbv/core/wasm/value-guards.ts","../src/tbv/core/primitives/psbt/refund.ts","../src/tbv/core/primitives/psbt/reclaim.ts","../src/tbv/core/primitives/psbt/finalizeScriptPathWithSignatures.ts","../src/tbv/core/primitives/psbt/noPayout.ts"],"sourcesContent":["/**\n * Runtime guard for satoshi amounts crossing into the WASM FFI boundary.\n *\n * `new BigUint64Array(values)` is the only way satoshi amounts are handed to\n * the constructor, and a runtime cast (`as readonly bigint[]`) lets a caller\n * pass a non-bigint or non-positive element that `BigUint64Array` would either\n * reject cryptically or, in its length-arg form, silently zero-fill. Values\n * above the u64 maximum are worse still: `BigUint64Array` wraps them mod 2^64\n * without complaint, turning an oversized amount into a small one.\n * {@link assertPositiveBigintArray} validates such inputs before the\n * typed-array construction.\n *\n * Mirrors the `assertPositiveBigintArray` half of `value-guards.ts` in\n * `@babylonlabs-io/babylon-tbv-rust-wasm`; that one function is pinned to the\n * engine's source copy by `__tests__/value-guards.test.ts`. The engine's other\n * guard, `assertWasmBigint`, has no counterpart here: the engine applies it to\n * its own WASM return values before they reach this package.\n */\n\n/** Largest value BigUint64Array stores without wrapping mod 2^64 (2^64 − 1). */\nconst U64_MAX = (1n << 64n) - 1n;\n\n/**\n * Assert a value is a non-empty array of strictly-positive `bigint`s and return\n * it narrowed, ready to feed into `new BigUint64Array(...)`.\n *\n * @param values - The candidate array of satoshi amounts.\n * @param label - Human-readable name used in the thrown error.\n * @throws If `values` is not an array, is empty, or contains any element that is\n *   not a `bigint`, is not strictly greater than 0, or exceeds the u64 maximum\n *   (which `BigUint64Array` would otherwise wrap mod 2^64).\n */\nexport function assertPositiveBigintArray(\n  values: unknown,\n  label: string,\n): bigint[] {\n  if (!Array.isArray(values)) {\n    throw new Error(\n      `${label} must be an array of positive bigints (got ${typeof values}).`,\n    );\n  }\n  if (values.length === 0) {\n    throw new Error(`${label} must not be empty.`);\n  }\n  values.forEach((value, index) => {\n    if (typeof value !== \"bigint\") {\n      throw new Error(\n        `${label}[${index}] must be a bigint (got ${typeof value}); ` +\n          `refusing to feed it into satoshi math.`,\n      );\n    }\n    if (value <= 0n) {\n      throw new Error(`${label}[${index}] must be > 0 (got ${value}).`);\n    }\n    if (value > U64_MAX) {\n      throw new Error(\n        `${label}[${index}] must fit in a u64 (got ${value}); ` +\n          `refusing to feed it into satoshi math.`,\n      );\n    }\n  });\n  return values as bigint[];\n}\n","/**\n * Refund PSBT Builder Primitive\n *\n * Builds an unsigned refund PSBT for a depositor to reclaim BTC from\n * a timed-out Pre-PegIn HTLC output via the refund script (leaf 1).\n *\n * The refund script enforces a CSV timelock (timelockRefund blocks) and\n * requires only the depositor's Schnorr signature — no vault provider or\n * keeper involvement.\n *\n * @module primitives/psbt/refund\n */\n\nimport { Psbt, Transaction } from \"bitcoinjs-lib\";\nimport { Buffer } from \"buffer\";\nimport { loadTbvWasm, tapInternalPubkey } from \"../../wasm\";\nimport { assertPositiveBigintArray } from \"../../wasm/value-guards\";\n\nimport {\n  TAPSCRIPT_LEAF_VERSION,\n  deriveBip86ScriptPubKeyHex,\n  stripHexPrefix,\n  uint8ArrayToHex,\n} from \"../utils/bitcoin\";\nimport { deriveExpectedPrePeginHtlc } from \"./assertWasmPeginSizing\";\nimport { REFUND_TX_LOCKTIME, REFUND_TX_VERSION } from \"./constants\";\nimport { normalizeAuthAnchorHash, type PrePeginParams } from \"./pegin\";\n\n/**\n * Parameters for building a refund PSBT\n */\nexport interface BuildRefundPsbtParams {\n  /** Same PrePeginParams used when the original Pre-PegIn tx was created */\n  prePeginParams: PrePeginParams;\n  /** Funded Pre-PegIn transaction hex (the tx whose HTLC output is being refunded) */\n  fundedPrePeginTxHex: string;\n  /** Index of the HTLC output in the Pre-PegIn transaction */\n  htlcVout: number;\n  /** Transaction fee in satoshis for the refund transaction */\n  refundFee: bigint;\n  /** SHA256 hash commitment for the HTLC (64 hex chars, no 0x prefix) */\n  hashlock: string;\n}\n\n/**\n * Result of building a refund PSBT\n */\nexport interface BuildRefundPsbtResult {\n  /** PSBT hex ready for depositor signing */\n  psbtHex: string;\n}\n\n/**\n * Build a PSBT for signing the refund transaction.\n *\n * The refund transaction spends the Pre-PegIn HTLC output via leaf 1\n * (the refund script: `<depositorPubkey> OP_CHECKSIGVERIFY <timelockRefund>\n * OP_CHECKSEQUENCEVERIFY` — btc-vault `connectors/prepegin_htlc.rs`\n * `generate_refund_script`).\n * The PSBT includes the tapLeafScript entry so the depositor's wallet can\n * sign using Taproot script-path spending.\n *\n * The input's sequence is set to `timelockRefund` by the WASM, enforcing\n * the Bitcoin CSV timelock. The refund broadcast will be rejected by the\n * network if the timelock has not yet expired.\n *\n * @param params - Refund PSBT parameters\n * @returns PSBT hex for depositor signing\n * @throws If the HTLC output at htlcVout is not found\n * @throws If the refund transaction does not have exactly 1 input\n */\nexport async function buildRefundPsbt(\n  params: BuildRefundPsbtParams,\n): Promise<BuildRefundPsbtResult> {\n  const { WasmPrePeginTx } = await loadTbvWasm();\n\n  const { prePeginParams, fundedPrePeginTxHex, htlcVout, refundFee, hashlock } =\n    params;\n\n  // The 14th positional arg `auth_anchor_hash` is `Option<String>` in\n  // the Rust WASM constructor (the 9th arg `min_pegin_fee_rate` requires\n  // the two-rate constructor from btc-vault #1930). Production peg-ins\n  // (PeginManager) always commit an OP_RETURN <PUSH32 SHA256(authAnchor)>\n  // output at `vout = hashlocks.length`; the unfunded template must\n  // include it so `fromFundedTransaction` aligns with the funded tx.\n  // Normalize identically to the peg-in primitives (`0x` strip,\n  // lowercase, length/charset validation) so a direct primitive caller\n  // reusing successful peg-in params doesn't hand unnormalized bytes to\n  // WASM. Pass `undefined` for legacy non-auth-anchored Pre-PegIns.\n  const normalizedAuthAnchorHash = normalizeAuthAnchorHash(\n    prePeginParams.authAnchorHash,\n  );\n  // Reconstruct the template under the same graph version the Pre-PegIn\n  // was originally built with (the vault's stamped vaultCoreVersion).\n  const unfundedTx = new WasmPrePeginTx(\n    prePeginParams.vaultCoreVersion,\n    prePeginParams.depositorPubkey,\n    prePeginParams.vaultProviderPubkey,\n    prePeginParams.vaultKeeperPubkeys,\n    prePeginParams.universalChallengerPubkeys,\n    [...prePeginParams.hashlocks],\n    new BigUint64Array(\n      assertPositiveBigintArray(prePeginParams.pegInAmounts, \"pegInAmounts\"),\n    ),\n    prePeginParams.timelockRefund,\n    prePeginParams.feeRate,\n    prePeginParams.minPeginFeeRate,\n    prePeginParams.numLocalChallengers,\n    prePeginParams.councilQuorum,\n    prePeginParams.councilSize,\n    prePeginParams.network,\n    normalizedAuthAnchorHash,\n  );\n\n  let fundedTx: typeof unfundedTx | null = null;\n  try {\n    // Cross-check the reconstructed unfunded template against an independent\n    // TypeScript derivation and the funded transaction bytes.\n    // If they disagree, the template was reconstructed from the wrong\n    // (hashlocks, amounts) vector — signing it would produce a refund\n    // that does not spend the on-chain HTLC the depositor expects.\n    // This is the explicit invariant the audit recommends: never sign a\n    // refund whose template doesn't match the on-chain output bytes.\n    const wasmHtlcScriptPubKey = unfundedTx\n      .getHtlcScriptPubKey(htlcVout)\n      .toLowerCase();\n    const expectedHtlc = deriveExpectedPrePeginHtlc(prePeginParams, hashlock);\n    const expectedHtlcScriptPubKey = expectedHtlc.scriptPubKey.toString(\"hex\");\n    if (wasmHtlcScriptPubKey !== expectedHtlcScriptPubKey) {\n      throw new Error(\n        `WASM HTLC scriptPubKey ${wasmHtlcScriptPubKey} does not match the ` +\n          `independently derived scriptPubKey ${expectedHtlcScriptPubKey}.`,\n      );\n    }\n    // The reconstructed template's HTLC output value at `htlcVout`,\n    // sized by WASM from the supplied `pegInAmounts` via the protocol\n    // formula `htlcValue = peginAmount + depositorClaimValue + p2aAnchorValue + minPeginFee`.\n    // Captured before `fromFundedTransaction` to bind it to the value the\n    // funded tx actually carries (see the cross-check below).\n    const expectedHtlcValue = unfundedTx.getHtlcValue(htlcVout);\n\n    fundedTx = unfundedTx.fromFundedTransaction(fundedPrePeginTxHex);\n\n    const refundTxHex = fundedTx.buildRefundTx(refundFee, htlcVout);\n\n    const cleanPrePeginHex = fundedPrePeginTxHex.startsWith(\"0x\")\n      ? fundedPrePeginTxHex.slice(2)\n      : fundedPrePeginTxHex;\n    const prePeginTx = Transaction.fromHex(cleanPrePeginHex);\n\n    const htlcOutput = prePeginTx.outs[htlcVout];\n    if (!htlcOutput) {\n      throw new Error(\n        `HTLC output at vout ${htlcVout} not found in funded Pre-PegIn tx ` +\n          `(tx has ${prePeginTx.outs.length} outputs)`,\n      );\n    }\n\n    const actualHtlcScriptPubKey = uint8ArrayToHex(\n      new Uint8Array(htlcOutput.script),\n    ).toLowerCase();\n    if (actualHtlcScriptPubKey !== expectedHtlcScriptPubKey) {\n      throw new Error(\n        `HTLC scriptPubKey mismatch at vout ${htlcVout}: reconstructed ` +\n          `template expects ${expectedHtlcScriptPubKey}, funded tx carries ` +\n          `${actualHtlcScriptPubKey}. Refund refused — the (hashlocks, ` +\n          `pegInAmounts) vector does not match the on-chain commitment.`,\n      );\n    }\n\n    // Value cross-check (mirrors the script check above): the template's\n    // HTLC value — derived by WASM from `pegInAmounts` via the protocol\n    // formula — must equal the value the funded tx pays at this output.\n    // A caller that hands the full HTLC output value (or any wrong amount)\n    // as `pegInAmounts` would inflate the template value and trip this\n    // guard, rather than silently signing a refund built from a template\n    // that disagrees with the on-chain commitment.\n    const actualHtlcValue = BigInt(htlcOutput.value);\n    if (actualHtlcValue !== expectedHtlcValue) {\n      throw new Error(\n        `HTLC value mismatch at vout ${htlcVout}: reconstructed template ` +\n          `expects ${expectedHtlcValue} sat, funded tx carries ` +\n          `${actualHtlcValue} sat. Refund refused — the pegInAmounts vector ` +\n          `does not match the on-chain commitment.`,\n      );\n    }\n\n    const refundTx = Transaction.fromHex(refundTxHex);\n\n    if (refundTx.version !== REFUND_TX_VERSION) {\n      throw new Error(\n        `Refund transaction version ${refundTx.version} does not match ` +\n          `protocol version ${REFUND_TX_VERSION}.`,\n      );\n    }\n    if (refundTx.locktime !== REFUND_TX_LOCKTIME) {\n      throw new Error(\n        `Refund transaction locktime ${refundTx.locktime} does not match ` +\n          `protocol locktime ${REFUND_TX_LOCKTIME}.`,\n      );\n    }\n\n    if (refundTx.ins.length !== 1) {\n      throw new Error(\n        `Refund transaction must have exactly 1 input, got ${refundTx.ins.length}`,\n      );\n    }\n\n    const refundInput = refundTx.ins[0];\n\n    // Verify the refund input spends the correct Pre-PegIn HTLC output\n    const prePeginTxid = prePeginTx.getId();\n    const refundInputTxid = uint8ArrayToHex(\n      new Uint8Array(refundInput.hash).slice().reverse(),\n    );\n    if (refundInputTxid !== prePeginTxid) {\n      throw new Error(\n        `Refund input does not reference the Pre-PegIn transaction. ` +\n          `Expected ${prePeginTxid}, got ${refundInputTxid}`,\n      );\n    }\n    if (refundInput.index !== htlcVout) {\n      throw new Error(\n        `Refund input index ${refundInput.index} does not match expected htlcVout ${htlcVout}`,\n      );\n    }\n    if (refundInput.sequence !== prePeginParams.timelockRefund) {\n      throw new Error(\n        `Refund input sequence ${refundInput.sequence} does not match ` +\n          `timelockRefund ${prePeginParams.timelockRefund}.`,\n      );\n    }\n\n    const psbt = new Psbt();\n    psbt.setVersion(refundTx.version);\n    psbt.setLocktime(refundTx.locktime);\n\n    psbt.addInput({\n      hash: refundInput.hash,\n      index: refundInput.index,\n      sequence: refundInput.sequence,\n      witnessUtxo: {\n        script: htlcOutput.script,\n        value: htlcOutput.value,\n      },\n      tapLeafScript: [\n        {\n          leafVersion: TAPSCRIPT_LEAF_VERSION,\n          script: expectedHtlc.refundScript,\n          controlBlock: expectedHtlc.refundControlBlock,\n        },\n      ],\n      tapInternalKey: Buffer.from(tapInternalPubkey),\n      tapMerkleRoot: expectedHtlc.tapMerkleRoot,\n    });\n\n    // Output side: pin the single refund output to the depositor's own\n    // BIP-86 P2TR address, mirroring the input-side pinning above. WASM\n    // builds the refund output from the refund leaf's depositor key, so a\n    // correct template always pays exactly one output back to the depositor.\n    // Asserting it here means a malformed template (or a tampered WASM)\n    // cannot redirect the reclaimed funds to a script the depositor does\n    // not control.\n    if (refundTx.outs.length !== 1) {\n      throw new Error(\n        `Refund transaction must have exactly 1 output, got ${refundTx.outs.length}`,\n      );\n    }\n    const refundOutput = refundTx.outs[0];\n    const expectedDepositorScriptPubKey = stripHexPrefix(\n      deriveBip86ScriptPubKeyHex(prePeginParams.depositorPubkey),\n    ).toLowerCase();\n    const actualRefundOutputScriptPubKey = uint8ArrayToHex(\n      new Uint8Array(refundOutput.script),\n    ).toLowerCase();\n    if (actualRefundOutputScriptPubKey !== expectedDepositorScriptPubKey) {\n      throw new Error(\n        `Refund output scriptPubKey ${actualRefundOutputScriptPubKey} does not ` +\n          `match the depositor's BIP-86 address ${expectedDepositorScriptPubKey}. ` +\n          `Refund refused — the reclaimed funds would not return to the depositor.`,\n      );\n    }\n\n    // Value: the single refund output must return the full HTLC value minus\n    // exactly the requested fee. The refund is 1-in/1-out (asserted above), so\n    // a value below `htlcValue - refundFee` means WASM applied a larger fee\n    // than requested — the difference would be burned as miner fee. Pin it so\n    // the depositor reclaims the expected amount, not a silently reduced one.\n    const expectedRefundOutputValue = actualHtlcValue - refundFee;\n    if (BigInt(refundOutput.value) !== expectedRefundOutputValue) {\n      throw new Error(\n        `Refund output value ${BigInt(refundOutput.value)} sat does not equal ` +\n          `the HTLC value ${actualHtlcValue} sat minus the requested fee ` +\n          `${refundFee} sat (expected ${expectedRefundOutputValue} sat). ` +\n          `Refund refused — the reclaimed amount would be burned as excess fee.`,\n      );\n    }\n\n    psbt.addOutput({\n      script: refundOutput.script,\n      value: refundOutput.value,\n    });\n\n    return { psbtHex: psbt.toHex() };\n  } finally {\n    fundedTx?.free();\n    unfundedTx.free();\n  }\n}\n","/**\n * Reclaim PSBT Builder Primitive\n *\n * Builds an unsigned PSBT that sweeps the depositor-claim reserve — PegIn\n * vout 1 — back to the depositor's own BIP-86 address.\n *\n * The reserve funds the depositor's `claim_tx`, their recourse if the vault\n * provider fails during peg-out. When the vault provider claims instead and\n * the depositor withdraws normally, nothing ever spends it. This primitive is\n * the only thing in the repository that can.\n *\n * Spend path: the single `<depositor> OP_CHECKSIG` tapleaf (see\n * ./depositorClaim). No timelock, no counterparty signature — the depositor's\n * Schnorr signature alone. That is also why the *caller* must gate: this\n * builder will happily sweep a reserve whose vault is still live, which would\n * permanently void the depositor's pre-signed recourse graph. Eligibility is\n * enforced upstream, in the service.\n *\n * @module primitives/psbt/reclaim\n */\n\nimport { Buffer } from \"buffer\";\nimport { Psbt, Transaction } from \"bitcoinjs-lib\";\n\nimport { DUST_THRESHOLD } from \"../../utils/fee/constants\";\nimport {\n  TAPSCRIPT_LEAF_VERSION,\n  deriveBip86ScriptPubKeyHex,\n  hexToUint8Array,\n  stripHexPrefix,\n  uint8ArrayToHex,\n} from \"../utils/bitcoin\";\nimport {\n  PEGIN_DEPOSITOR_CLAIM_VOUT,\n  deriveDepositorClaimDescriptor,\n} from \"./depositorClaim\";\n\n/**\n * nVersion for the reclaim transaction. Plain v2, not TRUC: the reserve is only\n * offered once its PegIn is deeply confirmed, so the v2/v3 PegIn's nVersion-3\n * topology limits no longer constrain its children.\n */\nconst RECLAIM_TX_VERSION = 2;\n\n/**\n * nSequence for every reclaim input: RBF-enabled, no relative timelock. The\n * claim leaf carries no CSV, so this is a fee-bumping signal only.\n */\nconst RECLAIM_INPUT_SEQUENCE = 0xfffffffd;\n\n/**\n * Weight units of the reclaim transaction's skeleton — everything except the\n * inputs. Non-witness `version(4) + inCount(1) + outCount(1) + locktime(4) +\n * output(8 + 1 + 34)` = 53 B × 4, plus the 2 WU SegWit marker and flag.\n */\nconst RECLAIM_SKELETON_WEIGHT_UNITS = 214;\n\n/**\n * Weight units each script-path input adds. Non-witness `outpoint(36) +\n * scriptSigLen(1) + sequence(4)` = 41 B × 4 = 164, plus a witness of\n * `stackCount(1) + sig(1 + 64) + leafScript(1 + 34) + controlBlock(1 + 33)` =\n * 135 WU.\n *\n * Exact rather than conservative: every element is fixed-length here — a\n * 64-byte BIP-340 signature under SIGHASH_DEFAULT, the 34-byte leaf, and a\n * 33-byte control block with no merkle path.\n */\nconst RECLAIM_INPUT_WEIGHT_UNITS = 299;\n\n/** Weight units per virtual byte. */\nconst WEIGHT_UNITS_PER_VBYTE = 4;\n\n/**\n * Virtual size of an N-in/1-out reclaim transaction.\n *\n * `REFUND_VSIZE = 160` does not generalise to N inputs, and\n * `computePeginBaseFeeSats` is wrong for this shape entirely — its\n * `P2TR_INPUT_SIZE = 58` is a *key-path* input and under-fees a script-path\n * spend by roughly a quarter.\n *\n * N=1 → 129 vB; each additional input adds 75 vB.\n */\nexport function reclaimVsize(numInputs: number): number {\n  if (!Number.isInteger(numInputs) || numInputs < 1) {\n    throw new Error(\n      `Reclaim input count must be a positive integer, got ${numInputs}.`,\n    );\n  }\n  return Math.ceil(\n    (RECLAIM_SKELETON_WEIGHT_UNITS +\n      RECLAIM_INPUT_WEIGHT_UNITS * numInputs) /\n      WEIGHT_UNITS_PER_VBYTE,\n  );\n}\n\n/** Absolute fee in satoshis for an N-in/1-out reclaim at a given rate. */\nexport function estimateReclaimFeeSats(\n  feeRateSatsVb: number,\n  numInputs: number,\n): bigint {\n  if (!Number.isFinite(feeRateSatsVb) || feeRateSatsVb <= 0) {\n    throw new Error(\n      `Reclaim fee rate must be a positive number, got ${feeRateSatsVb}.`,\n    );\n  }\n  return BigInt(Math.ceil(feeRateSatsVb * reclaimVsize(numInputs)));\n}\n\n/** One depositor-claim reserve to sweep, with the material to bind it. */\nexport interface ReclaimReserve {\n  /**\n   * The contract's own copy of the depositor-signed PegIn transaction\n   * (`VaultProtocolInfo.depositorSignedPeginTx`). Authoritative: its SegWit\n   * txid equals the broadcast PegIn's, and its `outs[1]` carries the reserve's\n   * script and value at no extra RPC cost.\n   */\n  depositorSignedPeginTxHex: string;\n  /** Independent chain observation of `peginTxid:1` (esplora UTXO lookup). */\n  observed: {\n    /**\n     * The outpoint the caller actually issued its chain lookup against, so the\n     * observation below can be tied to the input this builder adds.\n     *\n     * Without it the script and value binds prove only that *some* UTXO has\n     * this shape — the claim script is a pure function of the depositor key and\n     * so is byte-identical across every vault they own, and the value is a pure\n     * function of protocol parameters. Neither distinguishes one of the\n     * depositor's vaults from another.\n     *\n     * Txid in display order, 64 hex chars, with or without `0x` prefix.\n     */\n    txid: string;\n    /** Vout the lookup was issued against. Must be the claim vout. */\n    vout: number;\n    /** scriptPubKey hex, with or without `0x` prefix. */\n    scriptPubKey: string;\n    /** Output value in satoshis. */\n    value: bigint;\n  };\n  /**\n   * The reserve value recomputed from this vault's protocol parameters via\n   * `computeMinClaimValue`. Bound so a doctored PegIn that agrees with itself\n   * and with a compromised indexer still fails.\n   */\n  expectedValue: bigint;\n}\n\nexport interface BuildReclaimPsbtParams {\n  /**\n   * The **connected wallet's live** x-only pubkey, 64-char hex. Never the\n   * indexer's `depositorBtcPubkey`: re-deriving from the live key is what\n   * proves the wallet about to sign is the wallet that can spend, and rejects\n   * the wrong-wallet case with an error instead of an unspendable broadcast.\n   */\n  depositorPubkey: string;\n  /**\n   * Reserves to sweep. An array so batching several vaults into one\n   * transaction is a later change rather than a rewrite; today the app passes\n   * exactly one.\n   */\n  inputs: ReclaimReserve[];\n  /** Absolute fee in satoshis. The caller sizes it; see `reclaimVsize`. */\n  feeSats: bigint;\n}\n\nexport interface BuildReclaimPsbtResult {\n  /** PSBT hex ready for depositor signing. */\n  psbtHex: string;\n  /** Value of the single output — what the depositor actually receives. */\n  outputValue: bigint;\n  /** Sum of the swept reserves, before fee. */\n  totalInputValue: bigint;\n}\n\n/**\n * Build the N-in/1-out reclaim PSBT.\n *\n * Every input is bound three ways before it reaches the PSBT: the contract's\n * PegIn bytes, the chain observation, and a JS re-derivation from the live\n * wallet key must agree on both script and value. Any disagreement throws.\n * The observation must also name the outpoint it was taken from, since script\n * and value alone repeat across all of a depositor's vaults.\n *\n * Binding the input to the *vault* that was asked for is a further step, and\n * it belongs to the service: it needs the vault id derivation, which is async.\n * See `services/reclaim/buildAndBroadcastReclaim`.\n *\n * @throws If `inputs` is empty, the fee is non-positive, any input fails its\n *   outpoint, script or value bind, or the resulting output would be at or\n *   below dust.\n */\nexport function buildReclaimPsbt(\n  params: BuildReclaimPsbtParams,\n): BuildReclaimPsbtResult {\n  const { depositorPubkey, inputs, feeSats } = params;\n\n  if (inputs.length === 0) {\n    throw new Error(\"Reclaim requires at least one input; got none.\");\n  }\n  if (feeSats <= 0n) {\n    throw new Error(\n      `Reclaim fee must be positive, got ${feeSats} sat. Refusing to build a ` +\n        `transaction that would not relay.`,\n    );\n  }\n\n  // One derivation, reused for every input's bind and for the destination.\n  const descriptor = deriveDepositorClaimDescriptor(depositorPubkey);\n  const expectedScriptPubKey = uint8ArrayToHex(\n    new Uint8Array(descriptor.scriptPubKey),\n  ).toLowerCase();\n\n  const psbt = new Psbt();\n  psbt.setVersion(RECLAIM_TX_VERSION);\n  psbt.setLocktime(0);\n\n  let totalInputValue = 0n;\n  const seenOutpoints = new Set<string>();\n\n  inputs.forEach((input, i) => {\n    const peginTx = Transaction.fromHex(\n      stripHexPrefix(input.depositorSignedPeginTxHex),\n    );\n    const peginTxid = peginTx.getId();\n\n    const claimOut = peginTx.outs[PEGIN_DEPOSITOR_CLAIM_VOUT];\n    if (!claimOut) {\n      throw new Error(\n        `PegIn ${peginTxid} has no output at vout ` +\n          `${PEGIN_DEPOSITOR_CLAIM_VOUT} (tx has ${peginTx.outs.length}); ` +\n          `there is no depositor-claim reserve to reclaim.`,\n      );\n    }\n\n    // Bind 0: the observation is of *this* outpoint. Everything below compares\n    // a script and a value, both of which repeat across every vault this\n    // depositor owns under the same protocol parameters — so without this the\n    // remaining binds cannot tell one of their vaults from another, and a\n    // caller that resolved the wrong vault would sweep it with every check\n    // passing. The independent source is the PegIn the PSBT is built from; the\n    // esplora response cannot serve here because `getUtxoInfo` echoes back the\n    // txid and vout it was called with rather than reading them from the body.\n    const observedTxid = stripHexPrefix(input.observed.txid).toLowerCase();\n    if (observedTxid !== peginTxid) {\n      throw new Error(\n        `Input ${i}: the observation is of ${observedTxid}, but this input ` +\n          `spends PegIn ${peginTxid}. Reclaim refused — the reserve that was ` +\n          `looked up is not the one being swept.`,\n      );\n    }\n    if (input.observed.vout !== PEGIN_DEPOSITOR_CLAIM_VOUT) {\n      throw new Error(\n        `Input ${i}: the observation is of vout ${input.observed.vout}, but ` +\n          `the depositor-claim reserve is at vout ` +\n          `${PEGIN_DEPOSITOR_CLAIM_VOUT}. Reclaim refused.`,\n      );\n    }\n\n    // Bind 1: the contract's PegIn bytes against the JS re-derivation from the\n    // live wallet key. This is the assertion that proves the connected wallet\n    // can actually spend the output we are about to sign for.\n    const contractScriptPubKey = uint8ArrayToHex(\n      new Uint8Array(claimOut.script),\n    ).toLowerCase();\n    if (contractScriptPubKey !== expectedScriptPubKey) {\n      throw new Error(\n        `Input ${i}: PegIn ${peginTxid} vout ${PEGIN_DEPOSITOR_CLAIM_VOUT} pays ` +\n          `${contractScriptPubKey}, but the connected wallet's depositor-claim ` +\n          `script is ${expectedScriptPubKey}. Reclaim refused — this reserve ` +\n          `belongs to a different wallet.`,\n      );\n    }\n\n    // Bind 2: the independent chain observation must agree with both.\n    const observedScriptPubKey = stripHexPrefix(\n      input.observed.scriptPubKey,\n    ).toLowerCase();\n    if (observedScriptPubKey !== expectedScriptPubKey) {\n      throw new Error(\n        `Input ${i}: the observed UTXO ${peginTxid}:${PEGIN_DEPOSITOR_CLAIM_VOUT} ` +\n          `pays ${observedScriptPubKey}, expected ${expectedScriptPubKey}. ` +\n          `Reclaim refused — chain state disagrees with the contract's PegIn.`,\n      );\n    }\n\n    // Value bind, same three ways.\n    const contractValue = BigInt(claimOut.value);\n    if (contractValue !== input.observed.value) {\n      throw new Error(\n        `Input ${i}: PegIn ${peginTxid} vout ${PEGIN_DEPOSITOR_CLAIM_VOUT} ` +\n          `carries ${contractValue} sat, but the observed UTXO carries ` +\n          `${input.observed.value} sat. Reclaim refused.`,\n      );\n    }\n    if (contractValue !== input.expectedValue) {\n      throw new Error(\n        `Input ${i}: PegIn ${peginTxid} vout ${PEGIN_DEPOSITOR_CLAIM_VOUT} ` +\n          `carries ${contractValue} sat, but this vault's parameters compute a ` +\n          `depositor-claim value of ${input.expectedValue} sat. Reclaim refused.`,\n      );\n    }\n\n    // A batch that names the same vault twice would otherwise double-count the\n    // swept total and then fail deep inside bitcoinjs. Reject it here, where\n    // the message can say which input is the duplicate.\n    const outpoint = `${peginTxid}:${PEGIN_DEPOSITOR_CLAIM_VOUT}`;\n    if (seenOutpoints.has(outpoint)) {\n      throw new Error(\n        `Input ${i} repeats outpoint ${outpoint}, which is already being ` +\n          `swept by an earlier input. Reclaim refused.`,\n      );\n    }\n    seenOutpoints.add(outpoint);\n\n    totalInputValue += contractValue;\n\n    psbt.addInput({\n      hash: peginTxid,\n      index: PEGIN_DEPOSITOR_CLAIM_VOUT,\n      sequence: RECLAIM_INPUT_SEQUENCE,\n      witnessUtxo: { script: claimOut.script, value: claimOut.value },\n      tapLeafScript: [\n        {\n          leafVersion: TAPSCRIPT_LEAF_VERSION,\n          script: descriptor.leafScript,\n          controlBlock: descriptor.controlBlock,\n        },\n      ],\n      tapInternalKey: descriptor.internalKey,\n    });\n  });\n\n  if (feeSats >= totalInputValue) {\n    throw new Error(\n      `Reclaim fee ${feeSats} sat is not less than the swept total ` +\n        `${totalInputValue} sat. Refusing to build a transaction with no output.`,\n    );\n  }\n\n  const outputValue = totalInputValue - feeSats;\n  if (outputValue <= DUST_THRESHOLD) {\n    throw new Error(\n      `Reclaim output ${outputValue} sat is at or below the dust threshold ` +\n        `${DUST_THRESHOLD} sat. The reserve is not at risk — it stays where it ` +\n        `is until fee rates fall.`,\n    );\n  }\n\n  const destination = stripHexPrefix(\n    deriveBip86ScriptPubKeyHex(depositorPubkey),\n  );\n  psbt.addOutput({\n    script: Buffer.from(hexToUint8Array(destination)),\n    value: Number(outputValue),\n  });\n\n  return { psbtHex: psbt.toHex(), outputValue, totalInputValue };\n}\n","/**\n * Finalize a Taproot script-path spend from the PSBT *we* built, using only the\n * verified signatures the wallet returned.\n *\n * Why this exists. The obvious shape — hand the wallet's PSBT to\n * `finalizeAllInputs()` — puts wallet-controlled bytes on the trust path even\n * when the signature itself has been verified.\n * `assertPsbtUnsignedTxMatches` deliberately pins only the unsigned\n * transaction and skips per-input metadata, so `tapLeafScript`, `controlBlock`\n * and `tapKeySig` all survive from the wallet's response untouched. And\n * bitcoinjs-lib checks key-spend first (`src/psbt.js`, `_finalizeTaprootInput`:\n * \"Check key spend first. Increased privacy and reduced block space.\"), so a\n * returned `tapKeySig` wins outright and `tapScriptSig` is never consulted.\n * Every output the depositor-claim reserve and the HTLC refund spend from uses\n * a NUMS internal key, so the resulting key-path witness cannot satisfy the\n * script — the transaction is rejected at broadcast, after a wallet prompt the\n * depositor cannot make sense of.\n *\n * Verifying and then discarding the wallet's PSBT closes that off structurally\n * rather than detecting it afterwards, and it makes the code match what\n * `verifyScriptPathSchnorrSignature` already documents: \"only the 64-byte\n * signature comes from the wallet\".\n *\n * @module tbv/core/primitives/psbt/finalizeScriptPathWithSignatures\n */\n\nimport { Psbt } from \"bitcoinjs-lib\";\nimport { Buffer } from \"buffer\";\n\nimport { X_ONLY_PUBKEY_HEX_LEN } from \"../../utils/validation\";\nimport {\n  SCHNORR_SIG_HEX_LEN,\n  TAPSCRIPT_LEAF_VERSION,\n  hexToUint8Array,\n  stripHexPrefix,\n} from \"../utils/bitcoin\";\nimport { computeTapLeafHash } from \"../utils/taproot\";\n\nexport interface FinalizeScriptPathWithSignaturesParams {\n  /**\n   * Hex of the PSBT built locally and sent to the wallet — the sole source of\n   * every per-input field. NOT the wallet-returned PSBT.\n   */\n  requestedPsbtHex: string;\n  /**\n   * Verified 64-byte Schnorr signatures, one per input, index-aligned with the\n   * PSBT's inputs. Each must already have passed\n   * `assertScriptPathSchnorrSignature` — this function does not re-verify them,\n   * it only decides which bytes are allowed to reach the witness.\n   */\n  signaturesHex: readonly string[];\n  /** X-only pubkey (64 hex chars) the signatures are attributed to. */\n  signerXOnlyPubkeyHex: string;\n}\n\n/**\n * Attach `signaturesHex` to the locally built PSBT's script-path inputs,\n * finalize, and return the extracted transaction hex.\n *\n * @throws If the signature count does not match the input count, any signature\n *   or the signer key is malformed, any input does not carry exactly one\n *   tapscript leaf at the expected leaf version, any input already carries a\n *   key-path signature, or bitcoinjs-lib cannot finalize.\n */\nexport function finalizeScriptPathWithSignatures(\n  params: FinalizeScriptPathWithSignaturesParams,\n): string {\n  const { requestedPsbtHex, signaturesHex, signerXOnlyPubkeyHex } = params;\n\n  const signerXOnly = stripHexPrefix(signerXOnlyPubkeyHex);\n  if (signerXOnly.length !== X_ONLY_PUBKEY_HEX_LEN) {\n    throw new Error(\n      `Signer x-only pubkey must be ${X_ONLY_PUBKEY_HEX_LEN} hex chars ` +\n        `(32 bytes), got ${signerXOnly.length}.`,\n    );\n  }\n  const signerPubkey = Buffer.from(hexToUint8Array(signerXOnly));\n\n  const psbt = Psbt.fromHex(requestedPsbtHex);\n\n  if (signaturesHex.length !== psbt.data.inputs.length) {\n    throw new Error(\n      `Cannot finalize: got ${signaturesHex.length} signature(s) for ` +\n        `${psbt.data.inputs.length} input(s). Every input must be signed — ` +\n        `refusing to broadcast a partially signed transaction.`,\n    );\n  }\n\n  psbt.data.inputs.forEach((input, inputIndex) => {\n    // Our own builders never produce a key-path signature for these spends.\n    // If one is present the PSBT is not the one we built, which would defeat\n    // the whole point of finalizing locally.\n    if (input.tapKeySig) {\n      throw new Error(\n        `Cannot finalize: input ${inputIndex} of the locally built PSBT ` +\n          `carries a key-path signature. These outputs are script-path only.`,\n      );\n    }\n\n    const tapLeafScripts = input.tapLeafScript;\n    if (!tapLeafScripts || tapLeafScripts.length !== 1) {\n      throw new Error(\n        `Cannot finalize: input ${inputIndex} must have exactly one ` +\n          `tapLeafScript, got ${tapLeafScripts?.length ?? 0}.`,\n      );\n    }\n    const leaf = tapLeafScripts[0];\n    if (leaf.leafVersion !== TAPSCRIPT_LEAF_VERSION) {\n      throw new Error(\n        `Cannot finalize: input ${inputIndex} tapLeafScript has leaf version ` +\n          `0x${leaf.leafVersion.toString(16)}, expected ` +\n          `0x${TAPSCRIPT_LEAF_VERSION.toString(16)}.`,\n      );\n    }\n\n    const signatureRaw = stripHexPrefix(signaturesHex[inputIndex]);\n    if (signatureRaw.length !== SCHNORR_SIG_HEX_LEN) {\n      throw new Error(\n        `Signature for input ${inputIndex} must be ${SCHNORR_SIG_HEX_LEN} hex ` +\n          `chars (64 bytes), got ${signatureRaw.length}.`,\n      );\n    }\n\n    psbt.updateInput(inputIndex, {\n      tapScriptSig: [\n        {\n          pubkey: signerPubkey,\n          leafHash: computeTapLeafHash(leaf.leafVersion, leaf.script),\n          signature: Buffer.from(hexToUint8Array(signatureRaw)),\n        },\n      ],\n    });\n  });\n\n  // With no tapKeySig anywhere, bitcoinjs takes the script-path branch for\n  // every input and builds `[signature, leafScript, controlBlock]` from the\n  // leaf we supplied.\n  psbt.finalizeAllInputs();\n\n  return psbt.extractTransaction().toHex();\n}\n","/**\n * NoPayout PSBT Builder\n *\n * Builds unsigned PSBTs for the depositor's NoPayout transaction\n * (depositor-as-claimer path, per challenger). The depositor signs input 0\n * using the NoPayout taproot script from WasmAssertPayoutNoPayoutConnector.\n *\n * @module primitives/psbt/noPayout\n * @see btc-vault crates/vault/docs/btc-transactions-spec.md — Assert output 0 NoPayout connector\n */\n\nimport {\n  type AssertPayoutNoPayoutConnectorParams,\n  type Network,\n  getAssertNoPayoutScriptInfo,\n  tapInternalPubkey,\n} from \"../../wasm\";\nimport { Buffer } from \"buffer\";\nimport { Psbt, Transaction, payments } from \"bitcoinjs-lib\";\n\nimport {\n  TAPSCRIPT_LEAF_VERSION,\n  getNetwork,\n  hexToUint8Array,\n  processPublicKeyToXOnly,\n  stripHexPrefix,\n} from \"../utils/bitcoin\";\n\n/**\n * Parameters for building a NoPayout PSBT\n */\nexport interface NoPayoutParams {\n  /** NoPayout transaction hex (unsigned) from VP */\n  noPayoutTxHex: string;\n  /** Challenger's x-only public key (hex encoded) */\n  challengerPubkey: string;\n  /** Prevouts for all inputs [{script_pubkey, value}], used verbatim — derive them from the parent txs */\n  prevouts: Array<{ script_pubkey: string; value: number }>;\n  /** Parameters for the Assert Payout/NoPayout connector */\n  connectorParams: AssertPayoutNoPayoutConnectorParams;\n}\n\n/**\n * Build unsigned NoPayout PSBT.\n *\n * The NoPayout transaction is specific to each challenger.\n * Input 0 is the one the depositor signs using the NoPayout taproot script path.\n *\n * @param params - NoPayout parameters\n * @returns Unsigned PSBT hex ready for signing\n */\nexport async function buildNoPayoutPsbt(\n  params: NoPayoutParams,\n): Promise<string> {\n  const noPayoutTxHex = stripHexPrefix(params.noPayoutTxHex);\n  const noPayoutTx = Transaction.fromHex(noPayoutTxHex);\n\n  // Get NoPayout script and control block for this challenger\n  const { noPayoutScript, noPayoutControlBlock } =\n    await getAssertNoPayoutScriptInfo(\n      params.connectorParams,\n      params.challengerPubkey,\n    );\n\n  const scriptBytes = hexToUint8Array(noPayoutScript);\n  const controlBlockBytes = hexToUint8Array(noPayoutControlBlock);\n\n  const psbt = new Psbt();\n  psbt.setVersion(noPayoutTx.version);\n  psbt.setLocktime(noPayoutTx.locktime);\n\n  // Add all inputs - depositor signs input 0 only\n  for (let i = 0; i < noPayoutTx.ins.length; i++) {\n    const input = noPayoutTx.ins[i];\n    const prevout = params.prevouts[i];\n\n    if (!prevout) {\n      throw new Error(`Missing prevout data for input ${i}`);\n    }\n\n    const inputData: Parameters<typeof psbt.addInput>[0] = {\n      hash: input.hash,\n      index: input.index,\n      sequence: input.sequence,\n      witnessUtxo: {\n        script: Buffer.from(hexToUint8Array(stripHexPrefix(prevout.script_pubkey))),\n        value: prevout.value,\n      },\n    };\n\n    // Input 0: depositor signs using taproot script path\n    if (i === 0) {\n      inputData.tapLeafScript = [\n        {\n          leafVersion: TAPSCRIPT_LEAF_VERSION,\n          script: Buffer.from(scriptBytes),\n          controlBlock: Buffer.from(controlBlockBytes),\n        },\n      ];\n      inputData.tapInternalKey = Buffer.from(tapInternalPubkey);\n    }\n\n    psbt.addInput(inputData);\n  }\n\n  // Add outputs\n  for (const output of noPayoutTx.outs) {\n    psbt.addOutput({\n      script: output.script,\n      value: output.value,\n    });\n  }\n\n  return psbt.toHex();\n}\n\n/**\n * Validate that a NoPayout transaction pays to the challenger via the\n * protocol-defined output structure: a single BIP-86 P2TR output derived from\n * the challenger's x-only pubkey.\n *\n * Mirrors the per-role payout output validation now inlined in\n * `buildPayoutPsbt` for the NoPayout path, where the sink is fixed by the\n * protocol rather than read from on-chain registration\n * (see `crates/vault/src/transactions/nopayout.rs::NoPayoutTx::new`).\n *\n * @param noPayoutTxHex - Raw NoPayout transaction hex\n * @param challengerPubkey - Challenger's x-only public key (hex)\n * @param network - Bitcoin network used to derive the P2TR scriptPubKey\n * @throws If the transaction does not have exactly one output\n * @throws If the single output's scriptPubKey does not equal the BIP-86 P2TR\n *         scriptPubKey for the challenger\n */\nexport function assertNoPayoutOutputMatchesChallenger(\n  noPayoutTxHex: string,\n  challengerPubkey: string,\n  network: Network,\n): void {\n  const tx = Transaction.fromHex(stripHexPrefix(noPayoutTxHex));\n\n  if (tx.outs.length !== 1) {\n    throw new Error(\n      `NoPayout transaction must have exactly 1 output, got ${tx.outs.length}`,\n    );\n  }\n\n  const xOnly = hexToUint8Array(processPublicKeyToXOnly(challengerPubkey));\n  const { output: expectedScript } = payments.p2tr({\n    internalPubkey: Buffer.from(xOnly),\n    network: getNetwork(network),\n  });\n  if (!expectedScript) {\n    throw new Error(\n      \"Failed to derive challenger BIP-86 P2TR scriptPubKey for NoPayout output validation\",\n    );\n  }\n\n  if (!tx.outs[0].script.equals(expectedScript)) {\n    throw new Error(\n      \"NoPayout transaction does not pay to the expected challenger BIP-86 P2TR address\",\n    );\n  }\n}\n"],"names":["U64_MAX","assertPositiveBigintArray","values","label","value","index","buildRefundPsbt","params","WasmPrePeginTx","loadTbvWasm","prePeginParams","fundedPrePeginTxHex","htlcVout","refundFee","hashlock","normalizedAuthAnchorHash","normalizeAuthAnchorHash","unfundedTx","fundedTx","wasmHtlcScriptPubKey","expectedHtlc","deriveExpectedPrePeginHtlc","expectedHtlcScriptPubKey","expectedHtlcValue","refundTxHex","cleanPrePeginHex","prePeginTx","Transaction","htlcOutput","actualHtlcScriptPubKey","uint8ArrayToHex","actualHtlcValue","refundTx","REFUND_TX_VERSION","REFUND_TX_LOCKTIME","refundInput","prePeginTxid","refundInputTxid","psbt","Psbt","TAPSCRIPT_LEAF_VERSION","Buffer","tapInternalPubkey","refundOutput","expectedDepositorScriptPubKey","stripHexPrefix","deriveBip86ScriptPubKeyHex","actualRefundOutputScriptPubKey","expectedRefundOutputValue","RECLAIM_TX_VERSION","RECLAIM_INPUT_SEQUENCE","RECLAIM_SKELETON_WEIGHT_UNITS","RECLAIM_INPUT_WEIGHT_UNITS","WEIGHT_UNITS_PER_VBYTE","reclaimVsize","numInputs","estimateReclaimFeeSats","feeRateSatsVb","buildReclaimPsbt","depositorPubkey","inputs","feeSats","descriptor","deriveDepositorClaimDescriptor","expectedScriptPubKey","totalInputValue","seenOutpoints","input","i","peginTx","peginTxid","claimOut","PEGIN_DEPOSITOR_CLAIM_VOUT","observedTxid","contractScriptPubKey","observedScriptPubKey","contractValue","outpoint","outputValue","DUST_THRESHOLD","destination","hexToUint8Array","finalizeScriptPathWithSignatures","requestedPsbtHex","signaturesHex","signerXOnlyPubkeyHex","signerXOnly","X_ONLY_PUBKEY_HEX_LEN","signerPubkey","inputIndex","tapLeafScripts","leaf","signatureRaw","SCHNORR_SIG_HEX_LEN","computeTapLeafHash","buildNoPayoutPsbt","noPayoutTxHex","noPayoutTx","noPayoutScript","noPayoutControlBlock","getAssertNoPayoutScriptInfo","scriptBytes","controlBlockBytes","prevout","inputData","output","assertNoPayoutOutputMatchesChallenger","challengerPubkey","network","tx","xOnly","processPublicKeyToXOnly","expectedScript","payments","getNetwork"],"mappings":"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"}

package/dist/types-Bda75Od0.cjs

@@ -1,2 +0,0 @@
-"use strict";const r=require("./ProtocolParams.abi-CjrT0545.cjs"),s=require("./registration-records-DFQgBaYi.cjs"),d=65535;function l(a){return{timelockAssert:a.timelockAssert,timelockChallengeAssert:a.timelockChallengeAssert,securityCouncilKeys:[...a.securityCouncilKeys],councilQuorum:a.councilQuorum,feeRate:a.feeRate,babeTotalInstances:a.babeTotalInstances,babeInstancesToFinalize:a.babeInstancesToFinalize,minVpCommissionBps:a.minVpCommissionBps,tRefund:a.tRefund,tStale:a.tStale,minPeginFeeRate:a.minPeginFeeRate,proverCircuitVersion:a.proverCircuitVersion,minPrepeginDepth:a.minPrepeginDepth}}function g(a){return{minimumPegInAmount:a.minimumPegInAmount,maxPegInAmount:a.maxPegInAmount,pegInAckTimeout:a.pegInAckTimeout,pegInActivationTimeout:a.pegInActivationTimeout,maxHtlcOutputCount:a.maxHtlcOutputCount,expiredPegInGraceBlocks:a.expiredPegInGraceBlocks}}function f(a){if(a>BigInt(d))throw new Error(`timelockAssert value ${a} exceeds uint16 max (${d})`);return Number(a)}class I{constructor(e,t){this.publicClient=e,this.contractAddress=t}async getTBVProtocolParams(){const e=await this.publicClient.readContract({address:this.contractAddress,abi:r.ProtocolParamsABI,functionName:"getTBVProtocolParams"}),t=g(e);return s.validateTBVProtocolParams(t),t}async getLatestOffchainParams(){const e=await this.publicClient.readContract({address:this.contractAddress,abi:r.ProtocolParamsABI,functionName:"getLatestOffchainParams"}),t=l(e);return s.validateOffchainParams(t),t}async getOffchainParamsByVersion(e){const t=await this.publicClient.readContract({address:this.contractAddress,abi:r.ProtocolParamsABI,functionName:"getOffchainParamsByVersion",args:[e]}),n=l(t);return s.validateOffchainParams(n),n}async getLatestOffchainParamsVersion(){const e=await this.publicClient.readContract({address:this.contractAddress,abi:r.ProtocolParamsABI,functionName:"latestOffchainParamsVersion"}),t=Number(e);return s.assertValidOffchainParamsVersion(t),t}async getTimelockPeginByVersion(e){const t=await this.getOffchainParamsByVersion(e);return f(t.timelockAssert)}async getPeginActivationDelay(){const e=await this.publicClient.readContract({address:this.contractAddress,abi:r.ProtocolParamsABI,functionName:"peginActivationDelay"});if(typeof e!="bigint")throw new Error(`Invalid peginActivationDelay from contract: must be a bigint, got ${typeof e}`);return e}async getPegInConfiguration(e){const t=await this.publicClient.multicall({blockNumber:e,contracts:[{address:this.contractAddress,abi:r.ProtocolParamsABI,functionName:"getTBVProtocolParams"},{address:this.contractAddress,abi:r.ProtocolParamsABI,functionName:"getLatestOffchainParams"},{address:this.contractAddress,abi:r.ProtocolParamsABI,functionName:"latestOffchainParamsVersion"},{address:this.contractAddress,abi:r.ProtocolParamsABI,functionName:"activeVaultCoreVersion"}],allowFailure:!1}),n=g(t[0]),o=l(t[1]),P=Number(t[2]),c=Number(t[3]),i={minimumPegInAmount:n.minimumPegInAmount,maxPegInAmount:n.maxPegInAmount,pegInAckTimeout:n.pegInAckTimeout,pegInActivationTimeout:n.pegInActivationTimeout,maxHtlcOutputCount:n.maxHtlcOutputCount,expiredPegInGraceBlocks:n.expiredPegInGraceBlocks,timelockPegin:f(o.timelockAssert),timelockRefund:o.tRefund,minVpCommissionBps:o.minVpCommissionBps,offchainParams:o,offchainParamsVersion:P,activeVaultCoreVersion:c};return s.validatePegInConfiguration(i),i}async fetchAllOffchainParams(e){const t=await this.getLatestOffchainParamsVersion();if(t===0)return{byVersion:new Map,latestVersion:0};const n=Array.from({length:t},(i,m)=>m+1),o=n.map(i=>({address:this.contractAddress,abi:r.ProtocolParamsABI,functionName:"getOffchainParamsByVersion",args:[i]})),P=await this.publicClient.multicall({contracts:o,allowFailure:!1}),c=new Map;for(let i=0;i<n.length;i++){const m=l(P[i]);try{s.validateOffchainParams(m),c.set(n[i],m)}catch(u){e==null||e(n[i],u instanceof Error?u:new Error(String(u)))}}return{byVersion:c,latestVersion:t}}}var A=(a=>(a[a.PENDING=0]="PENDING",a[a.VERIFIED=1]="VERIFIED",a[a.ACTIVE=2]="ACTIVE",a[a.REDEEMED=3]="REDEEMED",a[a.EXPIRED=4]="EXPIRED",a))(A||{});exports.OnChainBtcVaultStatus=A;exports.ViemProtocolParamsReader=I;exports.deriveTimelockPegin=f;
-//# sourceMappingURL=types-Bda75Od0.cjs.map

package/dist/types-Bda75Od0.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-Bda75Od0.cjs","sources":["../src/tbv/core/clients/eth/protocol-params-reader.ts","../src/tbv/core/clients/eth/types.ts"],"sourcesContent":["/**\n * Concrete ProtocolParams reader using viem's readContract and multicall.\n *\n * This is an optional utility — callers can use their own implementation\n * of the ProtocolParamsReader interface.\n */\n\nimport type { Abi, Address, Hex, PublicClient } from \"viem\";\n\nimport { ProtocolParamsABI } from \"../../contracts/abis/ProtocolParams.abi\";\nimport {\n  assertValidOffchainParamsVersion,\n  validateOffchainParams,\n  validatePegInConfiguration,\n  validateTBVProtocolParams,\n} from \"./protocol-params-validation\";\nimport type {\n  AllOffchainParamsData,\n  OnSkippedOffchainParamsVersion,\n  PegInConfiguration,\n  ProtocolParamsReader,\n  TBVProtocolParams,\n  VersionedOffchainParams,\n} from \"./types\";\n\n/**\n * Maximum value for a Solidity uint16. btc-vault carries the PegIn timelock as\n * a `NonZeroU16` (`transactions/pegin.rs:33` @ ac4954e7), so a larger\n * `timelockAssert` has no protocol-side representation.\n */\nconst UINT16_MAX = 65535;\n\n/**\n * Raw shape viem returns for VersionedOffchainParams struct.\n * viem resolves ABI struct outputs to named objects (not tuples).\n */\ninterface RawOffchainParams {\n  timelockAssert: bigint;\n  timelockChallengeAssert: bigint;\n  securityCouncilKeys: readonly Hex[];\n  councilQuorum: number;\n  feeRate: bigint;\n  babeTotalInstances: number;\n  babeInstancesToFinalize: number;\n  minVpCommissionBps: number;\n  tRefund: number;\n  tStale: number;\n  minPeginFeeRate: bigint;\n  proverCircuitVersion: number;\n  minPrepeginDepth: number;\n}\n\n/** Raw shape viem returns for TBVProtocolParams struct. */\ninterface RawTBVParams {\n  minimumPegInAmount: bigint;\n  maxPegInAmount: bigint;\n  pegInAckTimeout: bigint;\n  pegInActivationTimeout: bigint;\n  maxHtlcOutputCount: number;\n  expiredPegInGraceBlocks: bigint;\n}\n\n/** Map viem struct result to VersionedOffchainParams. */\nfunction mapOffchainParams(result: RawOffchainParams): VersionedOffchainParams {\n  return {\n    timelockAssert: result.timelockAssert,\n    timelockChallengeAssert: result.timelockChallengeAssert,\n    securityCouncilKeys: [...result.securityCouncilKeys],\n    councilQuorum: result.councilQuorum,\n    feeRate: result.feeRate,\n    babeTotalInstances: result.babeTotalInstances,\n    babeInstancesToFinalize: result.babeInstancesToFinalize,\n    minVpCommissionBps: result.minVpCommissionBps,\n    tRefund: result.tRefund,\n    tStale: result.tStale,\n    minPeginFeeRate: result.minPeginFeeRate,\n    proverCircuitVersion: result.proverCircuitVersion,\n    minPrepeginDepth: result.minPrepeginDepth,\n  };\n}\n\n/** Map viem struct result to TBVProtocolParams. */\nfunction mapTBVParams(result: RawTBVParams): TBVProtocolParams {\n  return {\n    minimumPegInAmount: result.minimumPegInAmount,\n    maxPegInAmount: result.maxPegInAmount,\n    pegInAckTimeout: result.pegInAckTimeout,\n    pegInActivationTimeout: result.pegInActivationTimeout,\n    maxHtlcOutputCount: result.maxHtlcOutputCount,\n    expiredPegInGraceBlocks: result.expiredPegInGraceBlocks,\n  };\n}\n\n/**\n * Derive timelockPegin from timelockAssert.\n *\n * btc-vault uses `timelock_assert` as the PegIn timelock (vaultd\n * `pegin_babe_setup.rs:794` @ ac4954e7) and carries it as a `NonZeroU16`\n * (`transactions/pegin.rs:33`).\n * `ProtocolParams.sol:510-512` @ c559f5c2 rejects a zero or above-uint16\n * `timelockAssert` on write; the upper bound is enforced again here so a bad\n * read fails early instead of truncating.\n *\n * @throws if timelockAssert exceeds uint16 max (65535)\n */\nexport function deriveTimelockPegin(timelockAssert: bigint): number {\n  if (timelockAssert > BigInt(UINT16_MAX)) {\n    throw new Error(\n      `timelockAssert value ${timelockAssert} exceeds uint16 max (${UINT16_MAX})`,\n    );\n  }\n  return Number(timelockAssert);\n}\n\n/**\n * Concrete protocol params reader using viem.\n *\n * Every read method runs the matching validator from\n * `protocol-params-validation` before returning, so callers don't have to\n * remember to validate.\n *\n * Usage:\n * ```ts\n * const reader = new ViemProtocolParamsReader(publicClient, protocolParamsAddress);\n * const config = await reader.getPegInConfiguration();\n * ```\n */\nexport class ViemProtocolParamsReader implements ProtocolParamsReader {\n  constructor(\n    private publicClient: PublicClient,\n    private contractAddress: Address,\n  ) {}\n\n  async getTBVProtocolParams(): Promise<TBVProtocolParams> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI,\n      functionName: \"getTBVProtocolParams\",\n    })) as RawTBVParams;\n\n    const params = mapTBVParams(result);\n    validateTBVProtocolParams(params);\n    return params;\n  }\n\n  async getLatestOffchainParams(): Promise<VersionedOffchainParams> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI,\n      functionName: \"getLatestOffchainParams\",\n    })) as RawOffchainParams;\n\n    const params = mapOffchainParams(result);\n    validateOffchainParams(params);\n    return params;\n  }\n\n  async getOffchainParamsByVersion(\n    version: number,\n  ): Promise<VersionedOffchainParams> {\n    const result = (await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI,\n      functionName: \"getOffchainParamsByVersion\",\n      args: [version],\n    })) as RawOffchainParams;\n\n    const params = mapOffchainParams(result);\n    validateOffchainParams(params);\n    return params;\n  }\n\n  async getLatestOffchainParamsVersion(): Promise<number> {\n    const raw = await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI,\n      functionName: \"latestOffchainParamsVersion\",\n    });\n    const version = Number(raw);\n    assertValidOffchainParamsVersion(version);\n    return version;\n  }\n\n  async getTimelockPeginByVersion(version: number): Promise<number> {\n    const params = await this.getOffchainParamsByVersion(version);\n    return deriveTimelockPegin(params.timelockAssert);\n  }\n\n  /**\n   * Returned as `bigint` with no `Number` narrowing: the registry compares it\n   * against `block.number`, so callers must do the same arithmetic the\n   * contract does. `0` is the documented \"disabled\" case and is returned as\n   * `0n`. A missing getter or a non-bigint payload throws — never coerced to\n   * `0`, which would fail open and skip the observation window.\n   *\n   * @throws If the deployment does not expose `peginActivationDelay()`, or\n   *   the decoded payload is not a `bigint`.\n   */\n  async getPeginActivationDelay(): Promise<bigint> {\n    const raw: unknown = await this.publicClient.readContract({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI,\n      functionName: \"peginActivationDelay\",\n    });\n    if (typeof raw !== \"bigint\") {\n      throw new Error(\n        `Invalid peginActivationDelay from contract: must be a bigint, got ${typeof raw}`,\n      );\n    }\n    return raw;\n  }\n\n  /**\n   * Read TBV protocol params, latest offchain params, and the latest version\n   * label atomically via multicall. The version is paired with the params so\n   * that a governance update between separate reads cannot let JS build BTC\n   * scripts with version N params while the contract registers the vault\n   * under version N+1.\n   *\n   * That guarantee holds only within this multicall. A caller that also reads\n   * participant keys — every fresh peg-in build does — must pass the same\n   * `blockNumber` here and to those reads, or the two describe different\n   * blocks and the pairing above buys nothing across the seam.\n   */\n  async getPegInConfiguration(\n    blockNumber?: bigint,\n  ): Promise<PegInConfiguration> {\n    const results = await this.publicClient.multicall({\n      blockNumber,\n      contracts: [\n        {\n          address: this.contractAddress,\n          abi: ProtocolParamsABI,\n          functionName: \"getTBVProtocolParams\",\n        },\n        {\n          address: this.contractAddress,\n          abi: ProtocolParamsABI,\n          functionName: \"getLatestOffchainParams\",\n        },\n        {\n          address: this.contractAddress,\n          abi: ProtocolParamsABI,\n          functionName: \"latestOffchainParamsVersion\",\n        },\n        {\n          address: this.contractAddress,\n          abi: ProtocolParamsABI,\n          functionName: \"activeVaultCoreVersion\",\n        },\n      ],\n      allowFailure: false,\n    });\n\n    const tbvParams = mapTBVParams(results[0] as RawTBVParams);\n    const offchainParams = mapOffchainParams(results[1] as RawOffchainParams);\n    const offchainParamsVersion = Number(results[2]);\n    const activeVaultCoreVersion = Number(results[3]);\n\n    const config: PegInConfiguration = {\n      minimumPegInAmount: tbvParams.minimumPegInAmount,\n      maxPegInAmount: tbvParams.maxPegInAmount,\n      pegInAckTimeout: tbvParams.pegInAckTimeout,\n      pegInActivationTimeout: tbvParams.pegInActivationTimeout,\n      maxHtlcOutputCount: tbvParams.maxHtlcOutputCount,\n      expiredPegInGraceBlocks: tbvParams.expiredPegInGraceBlocks,\n      timelockPegin: deriveTimelockPegin(offchainParams.timelockAssert),\n      timelockRefund: offchainParams.tRefund,\n      minVpCommissionBps: offchainParams.minVpCommissionBps,\n      offchainParams,\n      offchainParamsVersion,\n      activeVaultCoreVersion,\n    };\n\n    validatePegInConfiguration(config);\n    return config;\n  }\n\n  /**\n   * Fetch every historical offchain params version in a single multicall.\n   * Iterates 1..latestVersion and calls `getOffchainParamsByVersion` for each.\n   * Versions whose payload fails validation are skipped (not included in the\n   * returned map) so a single bad historical version doesn't block the\n   * lookup of the rest.\n   *\n   * @param onSkippedVersion - optional observer invoked once per skipped\n   *   version. Use to log/telemeter without coupling the SDK to a logger.\n   */\n  async fetchAllOffchainParams(\n    onSkippedVersion?: OnSkippedOffchainParamsVersion,\n  ): Promise<AllOffchainParamsData> {\n    const latestVersion = await this.getLatestOffchainParamsVersion();\n    if (latestVersion === 0) {\n      return { byVersion: new Map(), latestVersion: 0 };\n    }\n\n    const versions = Array.from({ length: latestVersion }, (_, i) => i + 1);\n    const contracts = versions.map((v) => ({\n      address: this.contractAddress,\n      abi: ProtocolParamsABI as Abi,\n      functionName: \"getOffchainParamsByVersion\" as const,\n      args: [v] as const,\n    }));\n\n    const results = await this.publicClient.multicall({\n      contracts,\n      allowFailure: false,\n    });\n\n    const byVersion = new Map<number, VersionedOffchainParams>();\n    for (let i = 0; i < versions.length; i++) {\n      const params = mapOffchainParams(results[i] as RawOffchainParams);\n      try {\n        validateOffchainParams(params);\n        byVersion.set(versions[i], params);\n      } catch (error) {\n        // A malformed historical version mustn't block lookup of the rest.\n        // Surface the skip to the caller's observer if one was supplied.\n        onSkippedVersion?.(\n          versions[i],\n          error instanceof Error ? error : new Error(String(error)),\n        );\n      }\n    }\n\n    return { byVersion, latestVersion };\n  }\n}\n","/**\n * Types and interfaces for ETH contract readers.\n *\n * These are optional utilities — callers can use them or build their own.\n * Core service functions never import from this module.\n */\n\nimport type { Address, Hex } from \"viem\";\n\n// ============================================================================\n// Vault Registry Types\n// ============================================================================\n\ndeclare const onChainBtcPubkeyBrand: unique symbol;\n\n/**\n * 64-char lowercase hex (no `0x`) x-only BTC pubkey sourced from an on-chain\n * registry. Minted only by `assertOnChainBtcPubkey`, which is the shared\n * validator behind both producers:\n * {@link VaultRegistryReader.getVaultProviderGenesisBtcPubKey} (the fixed\n * registration key) and {@link OperationKeyReader} (RFC-006 operation keys,\n * resolved current or at a vault's frozen epoch).\n *\n * @stability frozen\n */\nexport type OnChainBtcPubkey = string & {\n  readonly [onChainBtcPubkeyBrand]: true;\n};\n\n/**\n * Mirrors `IBTCVaultRegistry.BTCVaultStatus` in BTCVaultRegistry.sol exactly.\n * Use this when consuming `status` from `getVaultBasicInfo` /\n * `getBtcVaultBasicInfo`.\n *\n * Do NOT confuse with the app-side `ContractStatus` enum\n * (`services/deposit/peginState.ts`) — that one is for the indexer and\n * extends this with values 5-7, reassigning 4 to LIQUIDATED. Reading an\n * on-chain status through `ContractStatus[n]` for labels will mislabel\n * Expired(4) as LIQUIDATED.\n */\nexport enum OnChainBtcVaultStatus {\n  PENDING = 0,\n  VERIFIED = 1,\n  ACTIVE = 2,\n  REDEEMED = 3,\n  EXPIRED = 4,\n}\n\n/** Basic vault info from BTCVaultRegistry.getBtcVaultBasicInfo */\nexport interface VaultBasicInfo {\n  depositor: Address;\n  depositorBtcPubKey: Hex;\n  amount: bigint;\n  vaultProvider: Address;\n  status: number;\n  applicationEntryPoint: Address;\n  createdAt: bigint;\n}\n\n/** Protocol info from BTCVaultRegistry.getBtcVaultProtocolInfo */\nexport interface VaultProtocolInfo {\n  depositorSignedPeginTx: Hex;\n  universalChallengersVersion: number;\n  appVaultKeepersVersion: number;\n  offchainParamsVersion: number;\n  /**\n   * ETH block number stamped at the Pending→Verified transition.\n   * Compared against `block.number` (inclusive:\n   * `block.number >= verifiedAt + peginActivationDelay`), never a unix timestamp.\n   */\n  verifiedAt: bigint;\n  depositorWotsPkHash: Hex;\n  hashlock: Hex;\n  htlcVout: number;\n  depositorPopSignature: Hex;\n  prePeginTxHash: Hex;\n  vaultProviderCommissionBps: number;\n  /**\n   * Last ETH block (inclusive) at which `claimExpiredVault` is accepted for\n   * this vault. Frozen when the vault is reported expired, as that block plus\n   * `expiredPegInGraceBlocks`; zero until then. Only meaningful for a vault\n   * that expired after reaching Verified (`verifiedAt > 0`) — the contract\n   * rejects the claim for any other.\n   */\n  claimExpiredUntil: bigint;\n  /** Vault core version (uint16) stamped at registration. VP-side gating only — see #1690. */\n  vaultCoreVersion: number;\n}\n\n/** Combined vault data (basic + protocol) */\nexport interface VaultData {\n  basic: VaultBasicInfo;\n  protocol: VaultProtocolInfo;\n}\n\n/**\n * One vault's `PegInSubmittedV2` registration log, decoded.\n *\n * The registry discards several of these values after using them\n * (`maxAcceptableCommissionBps` is bound-checked and dropped), so the log is\n * their only on-chain source. Decoded leniently — no transaction is parsed and\n * no script is bound-checked here, so one malformed registration elsewhere in\n * the block cannot fail an unrelated caller's read; the strict per-record\n * checks live in `registration-records.ts` and run on selected records only.\n * That leniency stops at duplicates: a vault registers once, so two logs for\n * any vault id are an inconsistent node and fail the whole block's read\n * closed.\n *\n * @experimental\n */\nexport interface PeginRegistrationRecord {\n  /** Lowercase, `0x`-prefixed. */\n  vaultId: Hex;\n  depositor: Address;\n  vaultProvider: Address;\n  /** btc-vault `pegin_amount`, satoshis. */\n  amount: bigint;\n  vaultCoreVersion: number;\n  universalChallengersVersion: number;\n  appVaultKeepersVersion: number;\n  proverCircuitVersion: number;\n  offchainParamsVersion: number;\n  /**\n   * The event's own `peginTxHash`: the txid of this vault's depositor-signed\n   * PegIn, which with `depositor` re-derives the vault id. Per-vault, unlike\n   * {@link PeginRegistrationRecord.unsignedPrePeginTx}, which siblings share.\n   */\n  peginTxHash: Hex;\n  /**\n   * The event's `depositorPayoutBtcAddress` bytes: the depositor's payout\n   * scriptPubKey as `submitPeginRequest` received it (BTCVaultRegistry.sol\n   * documents the parameter as \"BTC payout address (scriptPubKey)\"; the SDK\n   * registers the validated scriptPubKey there). Lowercase, `0x`-prefixed.\n   */\n  depositorPayoutScriptPubKey: Hex;\n  /**\n   * The log's `unsignedPrePeginTx`, verbatim. Its txid\n   * (`registrationPrePeginTxHash`) equals\n   * {@link VaultProtocolInfo.prePeginTxHash}; siblings of one batch share it,\n   * while the event's own `peginTxHash` is the per-vault PegIn id.\n   */\n  unsignedPrePeginTx: Hex;\n  maxAcceptableCommissionBps: number;\n  blockNumber: bigint;\n}\n\n/**\n * A vault's finalized `VaultClaimableBy` log for one claimer key.\n *\n * `blockNumber` is what the artifacts file records as\n * `claimable_event_block_number`, the block the prover proves against.\n *\n * @experimental\n */\nexport interface VaultClaimableByEvent {\n  blockNumber: bigint;\n  /** The `claimerPK` topic, validated as an x-only key. */\n  claimerPk: OnChainBtcPubkey;\n  peginTxHash: Hex;\n  vaultCoreVersion: number;\n  proverCircuitVersion: number;\n  offchainParamsVersion: number;\n  universalChallengersVersion: number;\n  appVaultKeepersVersion: number;\n}\n\n/**\n * RFC-006 operation-key epochs a vault froze at `submitPeginRequest`.\n *\n * Each registry keeps a monotonic epoch counter that every key/payout setter\n * pre-increments. A vault stamps the counters live at its creation, and every\n * participant resolves \"which key did this vault bond?\" by asking the registry\n * for the key whose appended version is the latest stamped `<=` this epoch. A\n * rotation after the vault was created therefore never moves its keys.\n *\n * `uint64` — kept as `bigint` end-to-end and passed straight back to the\n * `...AtEpoch` getters, never narrowed through `Number`.\n *\n * Only ever read through {@link VaultRegistryReader.getVaultKeyEpochs}, which\n * uses the extended ABI. See `BTCVaultRegistryKeyEpochs.abi.ts` for why that\n * read is quarantined to its own ABI.\n */\nexport interface KeyEpochs {\n  vpKeyEpoch: bigint;\n  appKeeperKeyEpoch: bigint;\n  ucKeyEpoch: bigint;\n}\n\n/** Interface for reading vault data from the BTCVaultRegistry contract. */\nexport interface VaultRegistryReader {\n  getVaultBasicInfo(vaultId: Hex): Promise<VaultBasicInfo>;\n  getVaultProtocolInfo(vaultId: Hex): Promise<VaultProtocolInfo>;\n  getProtocolInfoBatch(vaultIds: readonly Hex[]): Promise<VaultProtocolInfo[]>;\n  getVaultData(vaultId: Hex): Promise<VaultData>;\n  /**\n   * Read a vault provider's *genesis* (registration) BTC key — the key bonded\n   * at version 0, which never moves when the operator rotates.\n   *\n   * Used only as the genesis fallback for epoch-based resolution and as a\n   * candidate when cross-checking an indexer hint. Never the key to build a\n   * Bitcoin lock with; that comes from `OperationKeyReader`.\n   *\n   * Resolves via `getOperationBtcKeyAtEpoch` at epoch 0, so it requires an\n   * RFC-006 registry — as does every caller.\n   */\n  getVaultProviderGenesisBtcPubKey(\n    vpAddress: Address,\n    blockNumber?: bigint,\n  ): Promise<OnChainBtcPubkey>;\n  /**\n   * Read the vault provider operation key selected by an RFC-006 epoch.\n   * Existing-vault consumers pass the vault's frozen `vpKeyEpoch` here so a\n   * later rotation cannot move the result.\n   */\n  getVaultProviderOperationBtcKeyAtEpoch(\n    vpAddress: Address,\n    epoch: bigint,\n    blockNumber?: bigint,\n  ): Promise<OnChainBtcPubkey>;\n  /** Read the protocol pegin fee (in wei) for a given vault provider. */\n  getPegInFee(vaultProvider: Address): Promise<bigint>;\n  /**\n   * Read a vault provider's current commission in basis points.\n   *\n   * Validates the contract-enforced `[0, 9999]` range — an out-of-range\n   * value signals a wrong contract address or ABI drift, not a real rate.\n   */\n  getVaultProviderCommission(vaultProvider: Address): Promise<number>;\n  /**\n   * Read a vault's frozen RFC-006 key epochs.\n   *\n   * Uses the extended `getBtcVaultProtocolInfo` ABI. Against a registry whose\n   * `BTCVaultProtocolInfo` struct is not extended this returns silent garbage\n   * for a populated vault rather than throwing, so it must only be called\n   * against an RFC-006 registry — a deployment invariant, not something this\n   * call can detect. A registry missing the operation-key getters altogether is\n   * the safer case: key resolution reverts downstream and these epochs are never\n   * used. See `BTCVaultRegistryKeyEpochs.abi.ts`.\n   */\n  getVaultKeyEpochs(vaultId: Hex): Promise<KeyEpochs>;\n  /** {@link getVaultKeyEpochs} for many vaults in one multicall. */\n  getVaultKeyEpochsBatch(vaultIds: readonly Hex[]): Promise<KeyEpochs[]>;\n  /**\n   * Read a vault provider's *current* RFC-006 operation BTC key — the key its\n   * server uses for the JSON-RPC token subject. Falls back to the registration\n   * key when the provider has never rotated.\n   */\n  getCurrentVaultProviderOperationBtcKey(\n    vpAddress: Address,\n  ): Promise<OnChainBtcPubkey>;\n  /**\n   * Read the depositor's commission ceiling (`maxAcceptableCommissionBps`)\n   * for vaults registered in the same block `createdAt`, from their\n   * `PegInSubmittedV2` logs, in `vaultIds` order. The contract discards the\n   * ceiling after bound-checking it, so the log is its only on-chain source.\n   *\n   * @throws {RegistrationLogsUnavailableError} (transient, retry) when the\n   * node answers with no registration logs for the block at all, with none\n   * for a vault asked for, or with V1 logs only — the registry emits both\n   * shapes together, so every one of those can be a partial answer.\n   * @throws when a vault has more than one V2 log.\n   */\n  getMaxAcceptableCommissionBpsBatch(\n    vaultIds: readonly Hex[],\n    createdAt: bigint,\n  ): Promise<number[]>;\n  /**\n   * Decode every `PegInSubmittedV2` registration in block `createdAt`, the\n   * `block.number` stamped on the vault at registration. One query at exactly\n   * that block, so no range scan is needed and public-RPC range caps do not\n   * apply. Records are keyed by lowercase vault id; use\n   * `findRegistrationRecord` to pick one.\n   *\n   * @throws {RegistrationLogsUnavailableError} (transient, retry) when the\n   * node answers with no registration logs for the block at all, or with V1\n   * registrations only — the registry emits both shapes together, so either\n   * can be a partial answer.\n   * @throws when a vault has more than one V2 log. Records are decoded\n   * leniently: no transaction is parsed and no script is bound-checked here\n   * (see `registration-records.ts`).\n   */\n  getRegistrationRecordsAtBlock(\n    createdAt: bigint,\n  ): Promise<PeginRegistrationRecord[]>;\n  /**\n   * The vault's finalized `VaultClaimableBy` log for `claimerPk` — the\n   * redemption that authorized that key to claim, and the block the prover\n   * proves against.\n   *\n   * The event's block is not stored in contract state, so it is found by\n   * scanning `eth_getLogs` newest-first from the finalized block\n   * (`eth_getBlockByNumber(\"finalized\")`) down to the vault's `createdAt`, in\n   * chunks of `VAULT_CLAIMABLE_BY_QUERY_CHUNK_BLOCKS`, filtered on the indexed\n   * `vaultId` and `claimerPK` topics. A redeem in the last chunk costs one\n   * request; an older one costs one request per chunk. The bound is\n   * finalized, not latest, because the block returned is what the prover\n   * proves against (`claimable_event_block_number`) and an unfinalized redeem\n   * can reorg away — the same bound btc-vault's reader uses\n   * (`eth-client/src/client.rs:5989-6040`, `FinalityLevel::Finalized` default\n   * `config.rs:11-21`).\n   *\n   * A REDEEMED vault can legitimately have no log for the depositor:\n   * `redeemForAVK` (RedeemLogic.sol) authorizes the vault keeper alone.\n   *\n   * @throws {VaultClaimableByNotFoundError} (typed) when no log exists in\n   * `createdAt..finalized` — the vault is not redeemed for that key, the\n   * redeem is not finalized yet, or the node did not serve the block. The\n   * last case is indistinguishable here, so a caller that knows the vault is\n   * redeemed for this key owns the retry (as\n   * `getMaxAcceptableCommissionBpsFromChainWithGrace` does in the vault app);\n   * point the read at a node that serves whole blocks, not a load balancer.\n   * @throws when matching logs span more than one transaction (a vault is\n   * redeemed once), or `claimerPk` is not an x-only key on the curve.\n   */\n  getVaultClaimableBy(\n    vaultId: Hex,\n    claimerPk: Hex,\n    createdAt: bigint,\n  ): Promise<VaultClaimableByEvent>;\n  /**\n   * Read the application entry point a vault provider is registered for.\n   *\n   * The peg-in submit path resolves this internally and uses it to pick the\n   * keeper roster, the roster version and the keeper key epoch a deposit is\n   * bonded to. Pass `blockNumber` when the result will shape a Bitcoin lock,\n   * so it describes the same block as the roster reads that follow it.\n   */\n  getVaultProviderApplication(\n    vpAddress: Address,\n    blockNumber?: bigint,\n  ): Promise<Address>;\n}\n\n// ============================================================================\n// Protocol Params Types (from IProtocolParams.sol)\n// ============================================================================\n\n/**\n * TBV protocol parameters from the ProtocolParams contract.\n * Matches Solidity struct `IProtocolParams.TBVProtocolParams` exactly.\n *\n * All uint64 amounts use bigint (satoshi values can exceed 2^53).\n * uint8 uses number (bounded, max 255).\n */\nexport interface TBVProtocolParams {\n  minimumPegInAmount: bigint;\n  maxPegInAmount: bigint;\n  pegInAckTimeout: bigint;\n  pegInActivationTimeout: bigint;\n  maxHtlcOutputCount: number;\n  /**\n   * Number of blocks added to the activation deadline as a grace window\n   * during which a depositor may still reclaim an expired pegin via the\n   * HTLC preimage. Source: `IProtocolParams.TBVProtocolParams.expiredPegInGraceBlocks`.\n   */\n  expiredPegInGraceBlocks: bigint;\n}\n\n/**\n * Versioned offchain parameters from the ProtocolParams contract.\n * Matches Solidity struct `IProtocolParams.VersionedOffchainParams` exactly.\n *\n * bigint for: uint256 timelocks, uint64 fee rates/amounts.\n * number for: uint8/uint16/uint32 fields (bounded, safe for JS arithmetic).\n */\nexport interface VersionedOffchainParams {\n  timelockAssert: bigint;\n  timelockChallengeAssert: bigint;\n  securityCouncilKeys: Hex[];\n  councilQuorum: number;\n  feeRate: bigint;\n  babeTotalInstances: number;\n  babeInstancesToFinalize: number;\n  minVpCommissionBps: number;\n  tRefund: number;\n  tStale: number;\n  minPeginFeeRate: bigint;\n  proverCircuitVersion: number;\n  minPrepeginDepth: number;\n}\n\n/**\n * Combined peg-in configuration read atomically via multicall.\n * Prevents TOCTOU inconsistency if governance updates params between reads.\n */\nexport interface PegInConfiguration {\n  minimumPegInAmount: bigint;\n  maxPegInAmount: bigint;\n  pegInAckTimeout: bigint;\n  pegInActivationTimeout: bigint;\n  maxHtlcOutputCount: number;\n  expiredPegInGraceBlocks: bigint;\n  timelockPegin: number;\n  timelockRefund: number;\n  minVpCommissionBps: number;\n  offchainParams: VersionedOffchainParams;\n  /**\n   * Version label paired atomically with `offchainParams`.\n   * Read in the same multicall as the params struct so that, if a parameter\n   * update lands between separate reads, the script-construction code and\n   * the version label stay consistent.\n   */\n  offchainParamsVersion: number;\n  /**\n   * Currently-active vault core (tx-graph) version\n   * (`ProtocolParams.activeVaultCoreVersion()`, uint16 ≥ 1). Stamped onto\n   * every new vault at peg-in submission; fresh deposits must build this\n   * graph version. Read in the same multicall so a governance version bump\n   * can't land between reading the params and reading the version.\n   */\n  activeVaultCoreVersion: number;\n}\n\n/**\n * All offchain params snapshots indexed by version, plus the latest version\n * number known when the snapshot was taken. Used by consumers that need to\n * resolve any historical version (e.g. signing for an existing vault locked\n * to an older version).\n */\nexport interface AllOffchainParamsData {\n  byVersion: Map<number, VersionedOffchainParams>;\n  latestVersion: number;\n}\n\n/**\n * Optional observer invoked by `fetchAllOffchainParams` when a historical\n * version fails validation. Called once per skipped version so callers can\n * log/telemeter without coupling the SDK to a specific logger.\n */\nexport type OnSkippedOffchainParamsVersion = (\n  version: number,\n  error: Error,\n) => void;\n\n/** Interface for reading protocol parameters from the ProtocolParams contract. */\nexport interface ProtocolParamsReader {\n  getTBVProtocolParams(): Promise<TBVProtocolParams>;\n  getOffchainParamsByVersion(version: number): Promise<VersionedOffchainParams>;\n  getLatestOffchainParams(): Promise<VersionedOffchainParams>;\n  getLatestOffchainParamsVersion(): Promise<number>;\n  getTimelockPeginByVersion(version: number): Promise<number>;\n  /**\n   * Pass `blockNumber` when the result will shape a Bitcoin lock, so this\n   * multicall and the participant-key reads describe the same block. Omit it\n   * for display-only reads, where a slightly stale value is harmless.\n   */\n  getPegInConfiguration(blockNumber?: bigint): Promise<PegInConfiguration>;\n  /**\n   * Observation window enforced between a vault's final ACK and its\n   * activation, in ETH blocks measured from `verifiedAt`. `0` disables it.\n   *\n   * Deliberately its own read rather than a field on\n   * {@link PegInConfiguration}: the parameter is absent from deployments that\n   * predate it, so folding it into the shared multicall would make every\n   * protocol-param read fail wherever it is missing.\n   *\n   * @throws If the deployment does not expose `peginActivationDelay()`, or\n   *   the decoded payload is not a `bigint`.\n   */\n  getPeginActivationDelay(): Promise<bigint>;\n  fetchAllOffchainParams(\n    onSkippedVersion?: OnSkippedOffchainParamsVersion,\n  ): Promise<AllOffchainParamsData>;\n}\n\n// ============================================================================\n// Signer-Set Types (from BTCVaultTypes.sol)\n// ============================================================================\n\n/**\n * Matches Solidity struct `BTCVaultTypes.AddressBTCKeyPair` exactly.\n * Used for vault keepers and universal challengers.\n */\nexport interface AddressBTCKeyPair {\n  ethAddress: Address;\n  btcPubKey: Hex;\n}\n\n/**\n * Interface for reading vault keepers from the ApplicationRegistry contract.\n *\n * The reads used to build a peg-in — here and on the sibling reader interfaces\n * — take an optional `blockNumber` that pins them to one block instead of\n * `latest`. Omitting it, the historical behaviour, is correct for every read\n * that resolves against a vault's already-frozen epochs, because those are\n * immutable once stamped. It is NOT correct for a fresh peg-in build: the\n * participant keys, roster versions and protocol params that shape the Bitcoin\n * lock must all describe the same block, or the lock commits to a mixture of\n * chain states that never existed at once. See\n * `services/deposit/validateOnChainParticipantKeys`.\n *\n * The `getCurrent*` roster reads are the exception and take no block. Nothing\n * on the build path uses them — it resolves rosters by version instead — so\n * they were left alone rather than given a pin no caller would pass.\n */\nexport interface VaultKeeperReader {\n  getVaultKeepersByVersion(\n    appEntryPoint: Address,\n    version: number,\n    blockNumber?: bigint,\n  ): Promise<AddressBTCKeyPair[]>;\n  getCurrentVaultKeepers(appEntryPoint: Address): Promise<AddressBTCKeyPair[]>;\n  getCurrentVaultKeepersVersion(\n    appEntryPoint: Address,\n    blockNumber?: bigint,\n  ): Promise<number>;\n  /**\n   * Read the application's current vault-keeper operation-key epoch.\n   *\n   * One counter for the whole application, bumped by any keeper's\n   * operation-key or payout-script append. The peg-in config fingerprint\n   * commits to it in place of the N resolved keeper keys, so it must be read\n   * at the same block as the roster it labels. Returned as `bigint`; the\n   * contract encodes it as `uint64` and a `Number` would truncate.\n   */\n  getCurrentAppKeeperKeyEpoch(\n    appEntryPoint: Address,\n    blockNumber?: bigint,\n  ): Promise<bigint>;\n}\n\n/** Interface for reading universal challengers from the ProtocolParams contract. */\nexport interface UniversalChallengerReader {\n  getUniversalChallengersByVersion(\n    version: number,\n    blockNumber?: bigint,\n  ): Promise<AddressBTCKeyPair[]>;\n  getCurrentUniversalChallengers(): Promise<AddressBTCKeyPair[]>;\n  getLatestUniversalChallengersVersion(blockNumber?: bigint): Promise<number>;\n  /**\n   * Read the protocol's current universal-challenger operation-key epoch.\n   *\n   * The challenger-axis counterpart to\n   * {@link VaultKeeperReader.getCurrentAppKeeperKeyEpoch}: one protocol-wide\n   * counter the fingerprint commits to in place of the M resolved challenger\n   * keys. Returned as `bigint` for the same `uint64` reason.\n   */\n  getCurrentUcKeyEpoch(blockNumber?: bigint): Promise<bigint>;\n}\n\n// ============================================================================\n// RFC-006 Operation-Key Types\n// ============================================================================\n\n/**\n * The participants whose operation keys are being resolved, and the roster\n * they are resolved against.\n *\n * A roster entry's `ethAddress` is the operator's **admin** address — the\n * lookup key for its key history — and its `btcPubKey` is the operator's\n * **genesis** key. Both are needed: the `...AtEpochOrGenesis` getters take the\n * roster key explicitly because the correct genesis for a keeper/challenger is\n * its key in the vault's *frozen membership version*, which an operator that\n * was later dropped from the roster no longer has a current entry for.\n */\nexport interface OperationKeyQuery {\n  vaultProviderEthAddress: Address;\n  /**\n   * The VP's genesis (registration) key, from\n   * {@link VaultRegistryReader.getVaultProviderGenesisBtcPubKey}.\n   *\n   * The VP has no roster entry to carry a genesis key the way keepers and\n   * challengers do, so it is supplied here. Every call site already reads it:\n   * it is what the indexer hint is compared against, and what makes the VP's\n   * `rotated` flag mean the same thing as everyone else's.\n   */\n  vaultProviderGenesisBtcPubkey: Hex;\n  applicationEntryPoint: Address;\n  /** Keeper roster at the membership version being resolved against. */\n  vaultKeepers: readonly AddressBTCKeyPair[];\n  /** Challenger roster at the membership version being resolved against. */\n  universalChallengers: readonly AddressBTCKeyPair[];\n}\n\n/** Raw registry-returned operation keys, index-aligned with the query rosters. */\nexport interface RawOperationKeys {\n  vaultProvider: Hex;\n  vaultKeepers: Hex[];\n  universalChallengers: Hex[];\n}\n\n/**\n * Registry-returned payout scriptPubKeys, index-aligned with the query\n * rosters. `universalChallengers` has no counterpart: a UC is never a claimer,\n * so it has no payout script.\n */\nexport interface RawPayoutScripts {\n  vaultProvider: Hex;\n  vaultKeepers: Hex[];\n}\n\n/**\n * Reads RFC-006 operation keys and payout scripts across all three registries\n * (BTCVaultRegistry, ApplicationRegistry, ProtocolParams).\n *\n * Every method resolves the whole participant set in a **single** multicall so\n * the keys are pinned to one block. That atomicity is load-bearing: a rotation\n * landing between two `eth_call`s would yield a self-inconsistent key set that\n * builds a lock no counterparty agrees with.\n */\nexport interface OperationKeyReader {\n  /**\n   * Resolve every participant's *current* operation key.\n   *\n   * Used for new peg-ins. The VP-only current getter separately supplies the\n   * JSON-RPC auth pin. Needs no epoch read at all — each registry's\n   * `getCurrentOperationBtcKey` resolves its own genesis fallback, so an\n   * operator that never rotated yields its registration key.\n   */\n  getCurrentOperationKeys(\n    query: OperationKeyQuery,\n    blockNumber?: bigint,\n  ): Promise<RawOperationKeys>;\n  /**\n   * Resolve every participant's operation key bonded at a vault's frozen\n   * epochs. Used for every existing-vault path (resume, payout, refund).\n   */\n  getOperationKeysAtEpochs(\n    query: OperationKeyQuery,\n    epochs: KeyEpochs,\n  ): Promise<RawOperationKeys>;\n  /**\n   * Resolve the VP's commission payout script and each keeper's payout script\n   * at a vault's frozen epochs.\n   *\n   * The registry backfills BIP-86 P2TR of the epoch's operation key for any\n   * operator that never called `setPayoutScript`, so this returns byte-identical\n   * results to local BIP-86 derivation until an operator registers a custom\n   * script.\n   */\n  getPayoutScriptsAtEpochs(\n    query: OperationKeyQuery,\n    epochs: KeyEpochs,\n  ): Promise<RawPayoutScripts>;\n}\n"],"names":["UINT16_MAX","mapOffchainParams","result","mapTBVParams","deriveTimelockPegin","timelockAssert","ViemProtocolParamsReader","publicClient","contractAddress","ProtocolParamsABI","params","validateTBVProtocolParams","validateOffchainParams","version","raw","assertValidOffchainParamsVersion","blockNumber","results","tbvParams","offchainParams","offchainParamsVersion","activeVaultCoreVersion","config","validatePegInConfiguration","onSkippedVersion","latestVersion","versions","_","i","contracts","v","byVersion","error","OnChainBtcVaultStatus"],"mappings":"mHA8BMA,EAAa,MAiCnB,SAASC,EAAkBC,EAAoD,CAC7E,MAAO,CACL,eAAgBA,EAAO,eACvB,wBAAyBA,EAAO,wBAChC,oBAAqB,CAAC,GAAGA,EAAO,mBAAmB,EACnD,cAAeA,EAAO,cACtB,QAASA,EAAO,QAChB,mBAAoBA,EAAO,mBAC3B,wBAAyBA,EAAO,wBAChC,mBAAoBA,EAAO,mBAC3B,QAASA,EAAO,QAChB,OAAQA,EAAO,OACf,gBAAiBA,EAAO,gBACxB,qBAAsBA,EAAO,qBAC7B,iBAAkBA,EAAO,gBAAA,CAE7B,CAGA,SAASC,EAAaD,EAAyC,CAC7D,MAAO,CACL,mBAAoBA,EAAO,mBAC3B,eAAgBA,EAAO,eACvB,gBAAiBA,EAAO,gBACxB,uBAAwBA,EAAO,uBAC/B,mBAAoBA,EAAO,mBAC3B,wBAAyBA,EAAO,uBAAA,CAEpC,CAcO,SAASE,EAAoBC,EAAgC,CAClE,GAAIA,EAAiB,OAAOL,CAAU,EACpC,MAAM,IAAI,MACR,wBAAwBK,CAAc,wBAAwBL,CAAU,GAAA,EAG5E,OAAO,OAAOK,CAAc,CAC9B,CAeO,MAAMC,CAAyD,CACpE,YACUC,EACAC,EACR,CAFQ,KAAA,aAAAD,EACA,KAAA,gBAAAC,CACP,CAEH,MAAM,sBAAmD,CACvD,MAAMN,EAAU,MAAM,KAAK,aAAa,aAAa,CACnD,QAAS,KAAK,gBACd,IAAKO,EAAAA,kBACL,aAAc,sBAAA,CACf,EAEKC,EAASP,EAAaD,CAAM,EAClCS,OAAAA,EAAAA,0BAA0BD,CAAM,EACzBA,CACT,CAEA,MAAM,yBAA4D,CAChE,MAAMR,EAAU,MAAM,KAAK,aAAa,aAAa,CACnD,QAAS,KAAK,gBACd,IAAKO,EAAAA,kBACL,aAAc,yBAAA,CACf,EAEKC,EAAST,EAAkBC,CAAM,EACvCU,OAAAA,EAAAA,uBAAuBF,CAAM,EACtBA,CACT,CAEA,MAAM,2BACJG,EACkC,CAClC,MAAMX,EAAU,MAAM,KAAK,aAAa,aAAa,CACnD,QAAS,KAAK,gBACd,IAAKO,EAAAA,kBACL,aAAc,6BACd,KAAM,CAACI,CAAO,CAAA,CACf,EAEKH,EAAST,EAAkBC,CAAM,EACvCU,OAAAA,EAAAA,uBAAuBF,CAAM,EACtBA,CACT,CAEA,MAAM,gCAAkD,CACtD,MAAMI,EAAM,MAAM,KAAK,aAAa,aAAa,CAC/C,QAAS,KAAK,gBACd,IAAKL,EAAAA,kBACL,aAAc,6BAAA,CACf,EACKI,EAAU,OAAOC,CAAG,EAC1BC,OAAAA,EAAAA,iCAAiCF,CAAO,EACjCA,CACT,CAEA,MAAM,0BAA0BA,EAAkC,CAChE,MAAMH,EAAS,MAAM,KAAK,2BAA2BG,CAAO,EAC5D,OAAOT,EAAoBM,EAAO,cAAc,CAClD,CAYA,MAAM,yBAA2C,CAC/C,MAAMI,EAAe,MAAM,KAAK,aAAa,aAAa,CACxD,QAAS,KAAK,gBACd,IAAKL,EAAAA,kBACL,aAAc,sBAAA,CACf,EACD,GAAI,OAAOK,GAAQ,SACjB,MAAM,IAAI,MACR,qEAAqE,OAAOA,CAAG,EAAA,EAGnF,OAAOA,CACT,CAcA,MAAM,sBACJE,EAC6B,CAC7B,MAAMC,EAAU,MAAM,KAAK,aAAa,UAAU,CAChD,YAAAD,EACA,UAAW,CACT,CACE,QAAS,KAAK,gBACd,IAAKP,EAAAA,kBACL,aAAc,sBAAA,EAEhB,CACE,QAAS,KAAK,gBACd,IAAKA,EAAAA,kBACL,aAAc,yBAAA,EAEhB,CACE,QAAS,KAAK,gBACd,IAAKA,EAAAA,kBACL,aAAc,6BAAA,EAEhB,CACE,QAAS,KAAK,gBACd,IAAKA,EAAAA,kBACL,aAAc,wBAAA,CAChB,EAEF,aAAc,EAAA,CACf,EAEKS,EAAYf,EAAac,EAAQ,CAAC,CAAiB,EACnDE,EAAiBlB,EAAkBgB,EAAQ,CAAC,CAAsB,EAClEG,EAAwB,OAAOH,EAAQ,CAAC,CAAC,EACzCI,EAAyB,OAAOJ,EAAQ,CAAC,CAAC,EAE1CK,EAA6B,CACjC,mBAAoBJ,EAAU,mBAC9B,eAAgBA,EAAU,eAC1B,gBAAiBA,EAAU,gBAC3B,uBAAwBA,EAAU,uBAClC,mBAAoBA,EAAU,mBAC9B,wBAAyBA,EAAU,wBACnC,cAAed,EAAoBe,EAAe,cAAc,EAChE,eAAgBA,EAAe,QAC/B,mBAAoBA,EAAe,mBACnC,eAAAA,EACA,sBAAAC,EACA,uBAAAC,CAAA,EAGFE,OAAAA,EAAAA,2BAA2BD,CAAM,EAC1BA,CACT,CAYA,MAAM,uBACJE,EACgC,CAChC,MAAMC,EAAgB,MAAM,KAAK,+BAAA,EACjC,GAAIA,IAAkB,EACpB,MAAO,CAAE,UAAW,IAAI,IAAO,cAAe,CAAA,EAGhD,MAAMC,EAAW,MAAM,KAAK,CAAE,OAAQD,CAAA,EAAiB,CAACE,EAAGC,IAAMA,EAAI,CAAC,EAChEC,EAAYH,EAAS,IAAKI,IAAO,CACrC,QAAS,KAAK,gBACd,IAAKrB,EAAAA,kBACL,aAAc,6BACd,KAAM,CAACqB,CAAC,CAAA,EACR,EAEIb,EAAU,MAAM,KAAK,aAAa,UAAU,CAChD,UAAAY,EACA,aAAc,EAAA,CACf,EAEKE,MAAgB,IACtB,QAAS,EAAI,EAAG,EAAIL,EAAS,OAAQ,IAAK,CACxC,MAAMhB,EAAST,EAAkBgB,EAAQ,CAAC,CAAsB,EAChE,GAAI,CACFL,EAAAA,uBAAuBF,CAAM,EAC7BqB,EAAU,IAAIL,EAAS,CAAC,EAAGhB,CAAM,CACnC,OAASsB,EAAO,CAGdR,GAAA,MAAAA,EACEE,EAAS,CAAC,EACVM,aAAiB,MAAQA,EAAQ,IAAI,MAAM,OAAOA,CAAK,CAAC,EAE5D,CACF,CAEA,MAAO,CAAE,UAAAD,EAAW,cAAAN,CAAA,CACtB,CACF,CC/RO,IAAKQ,GAAAA,IACVA,EAAAA,EAAA,QAAU,CAAA,EAAV,UACAA,EAAAA,EAAA,SAAW,CAAA,EAAX,WACAA,EAAAA,EAAA,OAAS,CAAA,EAAT,SACAA,EAAAA,EAAA,SAAW,CAAA,EAAX,WACAA,EAAAA,EAAA,QAAU,CAAA,EAAV,UALUA,IAAAA,GAAA,CAAA,CAAA"}

package/dist/types-C5jj3Cc-.js

@@ -1,198 +0,0 @@
-import { P as s } from "./ProtocolParams.abi-CKOVqFJP.js";
-import { c as p, v as l, j as A, b as I } from "./registration-records-CKLAv3gw.js";
-const g = 65535;
-function m(e) {
-  return {
-    timelockAssert: e.timelockAssert,
-    timelockChallengeAssert: e.timelockChallengeAssert,
-    securityCouncilKeys: [...e.securityCouncilKeys],
-    councilQuorum: e.councilQuorum,
-    feeRate: e.feeRate,
-    babeTotalInstances: e.babeTotalInstances,
-    babeInstancesToFinalize: e.babeInstancesToFinalize,
-    minVpCommissionBps: e.minVpCommissionBps,
-    tRefund: e.tRefund,
-    tStale: e.tStale,
-    minPeginFeeRate: e.minPeginFeeRate,
-    proverCircuitVersion: e.proverCircuitVersion,
-    minPrepeginDepth: e.minPrepeginDepth
-  };
-}
-function d(e) {
-  return {
-    minimumPegInAmount: e.minimumPegInAmount,
-    maxPegInAmount: e.maxPegInAmount,
-    pegInAckTimeout: e.pegInAckTimeout,
-    pegInActivationTimeout: e.pegInActivationTimeout,
-    maxHtlcOutputCount: e.maxHtlcOutputCount,
-    expiredPegInGraceBlocks: e.expiredPegInGraceBlocks
-  };
-}
-function P(e) {
-  if (e > BigInt(g))
-    throw new Error(
-      `timelockAssert value ${e} exceeds uint16 max (${g})`
-    );
-  return Number(e);
-}
-class C {
-  constructor(a, t) {
-    this.publicClient = a, this.contractAddress = t;
-  }
-  async getTBVProtocolParams() {
-    const a = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: s,
-      functionName: "getTBVProtocolParams"
-    }), t = d(a);
-    return p(t), t;
-  }
-  async getLatestOffchainParams() {
-    const a = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: s,
-      functionName: "getLatestOffchainParams"
-    }), t = m(a);
-    return l(t), t;
-  }
-  async getOffchainParamsByVersion(a) {
-    const t = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: s,
-      functionName: "getOffchainParamsByVersion",
-      args: [a]
-    }), n = m(t);
-    return l(n), n;
-  }
-  async getLatestOffchainParamsVersion() {
-    const a = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: s,
-      functionName: "latestOffchainParamsVersion"
-    }), t = Number(a);
-    return A(t), t;
-  }
-  async getTimelockPeginByVersion(a) {
-    const t = await this.getOffchainParamsByVersion(a);
-    return P(t.timelockAssert);
-  }
-  /**
-   * Returned as `bigint` with no `Number` narrowing: the registry compares it
-   * against `block.number`, so callers must do the same arithmetic the
-   * contract does. `0` is the documented "disabled" case and is returned as
-   * `0n`. A missing getter or a non-bigint payload throws — never coerced to
-   * `0`, which would fail open and skip the observation window.
-   *
-   * @throws If the deployment does not expose `peginActivationDelay()`, or
-   *   the decoded payload is not a `bigint`.
-   */
-  async getPeginActivationDelay() {
-    const a = await this.publicClient.readContract({
-      address: this.contractAddress,
-      abi: s,
-      functionName: "peginActivationDelay"
-    });
-    if (typeof a != "bigint")
-      throw new Error(
-        `Invalid peginActivationDelay from contract: must be a bigint, got ${typeof a}`
-      );
-    return a;
-  }
-  /**
-   * Read TBV protocol params, latest offchain params, and the latest version
-   * label atomically via multicall. The version is paired with the params so
-   * that a governance update between separate reads cannot let JS build BTC
-   * scripts with version N params while the contract registers the vault
-   * under version N+1.
-   *
-   * That guarantee holds only within this multicall. A caller that also reads
-   * participant keys — every fresh peg-in build does — must pass the same
-   * `blockNumber` here and to those reads, or the two describe different
-   * blocks and the pairing above buys nothing across the seam.
-   */
-  async getPegInConfiguration(a) {
-    const t = await this.publicClient.multicall({
-      blockNumber: a,
-      contracts: [
-        {
-          address: this.contractAddress,
-          abi: s,
-          functionName: "getTBVProtocolParams"
-        },
-        {
-          address: this.contractAddress,
-          abi: s,
-          functionName: "getLatestOffchainParams"
-        },
-        {
-          address: this.contractAddress,
-          abi: s,
-          functionName: "latestOffchainParamsVersion"
-        },
-        {
-          address: this.contractAddress,
-          abi: s,
-          functionName: "activeVaultCoreVersion"
-        }
-      ],
-      allowFailure: !1
-    }), n = d(t[0]), r = m(t[1]), f = Number(t[2]), o = Number(t[3]), i = {
-      minimumPegInAmount: n.minimumPegInAmount,
-      maxPegInAmount: n.maxPegInAmount,
-      pegInAckTimeout: n.pegInAckTimeout,
-      pegInActivationTimeout: n.pegInActivationTimeout,
-      maxHtlcOutputCount: n.maxHtlcOutputCount,
-      expiredPegInGraceBlocks: n.expiredPegInGraceBlocks,
-      timelockPegin: P(r.timelockAssert),
-      timelockRefund: r.tRefund,
-      minVpCommissionBps: r.minVpCommissionBps,
-      offchainParams: r,
-      offchainParamsVersion: f,
-      activeVaultCoreVersion: o
-    };
-    return I(i), i;
-  }
-  /**
-   * Fetch every historical offchain params version in a single multicall.
-   * Iterates 1..latestVersion and calls `getOffchainParamsByVersion` for each.
-   * Versions whose payload fails validation are skipped (not included in the
-   * returned map) so a single bad historical version doesn't block the
-   * lookup of the rest.
-   *
-   * @param onSkippedVersion - optional observer invoked once per skipped
-   *   version. Use to log/telemeter without coupling the SDK to a logger.
-   */
-  async fetchAllOffchainParams(a) {
-    const t = await this.getLatestOffchainParamsVersion();
-    if (t === 0)
-      return { byVersion: /* @__PURE__ */ new Map(), latestVersion: 0 };
-    const n = Array.from({ length: t }, (i, c) => c + 1), r = n.map((i) => ({
-      address: this.contractAddress,
-      abi: s,
-      functionName: "getOffchainParamsByVersion",
-      args: [i]
-    })), f = await this.publicClient.multicall({
-      contracts: r,
-      allowFailure: !1
-    }), o = /* @__PURE__ */ new Map();
-    for (let i = 0; i < n.length; i++) {
-      const c = m(f[i]);
-      try {
-        l(c), o.set(n[i], c);
-      } catch (u) {
-        a == null || a(
-          n[i],
-          u instanceof Error ? u : new Error(String(u))
-        );
-      }
-    }
-    return { byVersion: o, latestVersion: t };
-  }
-}
-var h = /* @__PURE__ */ ((e) => (e[e.PENDING = 0] = "PENDING", e[e.VERIFIED = 1] = "VERIFIED", e[e.ACTIVE = 2] = "ACTIVE", e[e.REDEEMED = 3] = "REDEEMED", e[e.EXPIRED = 4] = "EXPIRED", e))(h || {});
-export {
-  h as O,
-  C as V,
-  P as d
-};
-//# sourceMappingURL=types-C5jj3Cc-.js.map