@babylonlabs-io/ts-sdk 0.67.0 → 0.68.1

package/dist/verifyScriptPathSchnorrSignature-Dy9gF5RF.js

@@ -0,0 +1,931 @@
+import { computeMinClaimValue as se, peginP2aAnchorOutput as ue, computeMinPeginFee as pe, buildPeginTxFromPrePegin as Pe, createPrePeginTransaction as fe, validatePeginP2aAnchor as ge, tapInternalPubkey as V, createPayoutConnector as we, computePayoutFeeFloor as ve, getAssertPayoutScriptInfo as $e } from "@babylonlabs-io/babylon-tbv-rust-wasm";
+import { Buffer as a } from "buffer";
+import { Transaction as E, script as ye, opcodes as me, payments as Se, crypto as L, Psbt as _ } from "bitcoinjs-lib";
+import { c as K, d as xe } from "./fundPeginTransaction-B2wyjqp0.js";
+import { p as Ee, s as p, u as H, h as S, j as Ce, T as C, d as be, S as B, X as N } from "./bitcoin-Ch_jxnDa.js";
+import { D as U, P as M, b as F, c as q, M as W, d as X, e as Ae, A as ce, B as ke, V as _e, N as z } from "./constants-GjWXdaqV.js";
+import * as ae from "@bitcoin-js/tiny-secp256k1-asmjs";
+function x(e) {
+  return Ee(e).toLowerCase();
+}
+function Et(e, t, o) {
+  const n = /* @__PURE__ */ new Set();
+  n.add(x(e));
+  for (const i of t)
+    n.add(x(i));
+  return n.delete(x(o)), n.size;
+}
+function Te(e) {
+  const t = x(e.claimerBtcPubkey), o = x(e.depositorBtcPubkey), n = e.vaultKeeperBtcPubkeys.map(x);
+  if (t === o) {
+    const s = n.filter((u) => u !== o);
+    if (s.length === 0)
+      throw new Error(
+        "Cannot derive localChallengers: vault keeper set is empty (or contains only the depositor)"
+      );
+    if (new Set(s).size !== s.length)
+      throw new Error(
+        "Cannot derive localChallengers: duplicate vaultKeeper key — signing context is misconfigured"
+      );
+    return s;
+  }
+  const r = [
+    .../* @__PURE__ */ new Set([x(e.vaultProviderBtcPubkey), ...n])
+  ].sort().filter((s) => s !== t);
+  if (r.length === 0)
+    throw new Error(
+      `Cannot derive localChallengers: no vault provider or vault keeper remains after excluding claimer ${t}`
+    );
+  return r;
+}
+async function Ie(e, t) {
+  const o = t.pegInAmounts.length;
+  if (e.htlcValues.length !== o)
+    throw new Error(
+      `WASM Pre-PegIn returned ${e.htlcValues.length} HTLC value(s), expected ${o} (one per requested deposit).`
+    );
+  if (e.peginAmounts.length !== o || e.htlcScriptPubKeys.length !== o || e.htlcAddresses.length !== o)
+    throw new Error(
+      `WASM Pre-PegIn returned mismatched array lengths (htlcValues=${e.htlcValues.length}, peginAmounts=${e.peginAmounts.length}, htlcScriptPubKeys=${e.htlcScriptPubKeys.length}, htlcAddresses=${e.htlcAddresses.length}); expected ${o} each.`
+    );
+  if (e.depositorClaimValue <= 0n)
+    throw new Error(
+      `WASM Pre-PegIn returned non-positive depositorClaimValue ${e.depositorClaimValue}; expected > 0.`
+    );
+  const n = await se(
+    // Must price the same graph version the builder constructed.
+    t.vaultCoreVersion,
+    t.numLocalChallengers,
+    t.universalChallengerPubkeys.length,
+    t.councilQuorum,
+    t.councilSize,
+    t.feeRate
+  );
+  if (e.depositorClaimValue !== n)
+    throw new Error(
+      `WASM Pre-PegIn depositorClaimValue ${e.depositorClaimValue} does not match the independently computed minimum claim value ${n} (vaultCoreVersion=${t.vaultCoreVersion}, numLocalChallengers=${t.numLocalChallengers}, numUniversalChallengers=${t.universalChallengerPubkeys.length}, councilQuorum=${t.councilQuorum}, councilSize=${t.councilSize}, feeRate=${t.feeRate}).`
+    );
+  const i = await ue(t.vaultCoreVersion), r = (i == null ? void 0 : i.value) ?? 0n, s = await pe(
+    t.vaultCoreVersion,
+    t.vaultKeeperPubkeys.length,
+    t.universalChallengerPubkeys.length,
+    t.minPeginFeeRate
+  ), u = s + r, h = t.minPeginFeeRate * K;
+  for (let c = 0; c < o; c++) {
+    const d = t.pegInAmounts[c], l = e.peginAmounts[c], P = e.htlcValues[c];
+    if (l !== d)
+      throw new Error(
+        `WASM Pre-PegIn peginAmount[${c}] ${l} does not match the requested amount ${d}; refusing to build a tx whose recorded amount differs from the depositor's request.`
+      );
+    if (l <= 0n)
+      throw new Error(
+        `WASM Pre-PegIn peginAmount[${c}] is non-positive (${l}); expected > 0.`
+      );
+    if (P <= 0n)
+      throw new Error(
+        `WASM Pre-PegIn htlcValue[${c}] is non-positive (${P}); expected > 0.`
+      );
+    const f = P - l - e.depositorClaimValue;
+    if (f <= 0n)
+      throw new Error(
+        `WASM Pre-PegIn htlcValue[${c}] ${P} does not strictly cover peginAmount ${l} + depositorClaimValue ${e.depositorClaimValue} + a PegIn reserve (implied reserve ${f}).`
+      );
+    if (f > h)
+      throw new Error(
+        `WASM Pre-PegIn implied reserve for HTLC[${c}] (${f} sat) exceeds the plausibility cap ${h} sat (minPeginFeeRate=${t.minPeginFeeRate} × ${K} vbytes); htlcValue ${P} appears grossly inflated.`
+      );
+    if (f !== u)
+      throw new Error(
+        `WASM Pre-PegIn htlcValue[${c}] ${P} implies a PegIn fee+anchor reserve of ${f} sat, expected exactly ${u} sat (minPeginFee ${s} + p2aAnchor ${r} for vaultCoreVersion ${t.vaultCoreVersion}, vaultKeepers=${t.vaultKeeperPubkeys.length}, universalChallengers=${t.universalChallengerPubkeys.length}, minPeginFeeRate=${t.minPeginFeeRate}).`
+      );
+  }
+  return s;
+}
+class I extends Error {
+  constructor(t) {
+    super(t), this.name = "HtlcOutputMismatchError";
+  }
+}
+function Ve(e, t, o) {
+  if (e.length < t.length)
+    throw new I(
+      `Encoded Pre-PegIn tx has ${e.length} output(s), fewer than the ${t.length} HTLC output(s) the cross-check validated.`
+    );
+  for (let n = 0; n < t.length; n++) {
+    const i = BigInt(e[n].value);
+    if (i !== t[n])
+      throw new I(
+        `Encoded Pre-PegIn HTLC output[${n}] value ${i} does not match the cross-checked htlcValue ${t[n]}; the funded/signed tx would not pay the validated amount.`
+      );
+    const r = e[n].script.toString("hex").toLowerCase(), s = o[n].toLowerCase();
+    if (r !== s)
+      throw new I(
+        `Encoded Pre-PegIn HTLC output[${n}] scriptPubKey ${r} does not match the cross-checked htlcScriptPubKey ${s}.`
+      );
+  }
+}
+const D = 64, Le = /^[0-9a-fA-F]+$/;
+async function Ct(e) {
+  const t = le(e.authAnchorHash), o = await fe({
+    txGraphVersion: e.vaultCoreVersion,
+    depositorPubkey: e.depositorPubkey,
+    vaultProviderPubkey: e.vaultProviderPubkey,
+    vaultKeeperPubkeys: e.vaultKeeperPubkeys,
+    universalChallengerPubkeys: e.universalChallengerPubkeys,
+    hashlocks: [...e.hashlocks],
+    timelockRefund: e.timelockRefund,
+    pegInAmounts: [...e.pegInAmounts],
+    feeRate: e.feeRate,
+    minPeginFeeRate: e.minPeginFeeRate,
+    numLocalChallengers: e.numLocalChallengers,
+    councilQuorum: e.councilQuorum,
+    councilSize: e.councilSize,
+    network: e.network,
+    authAnchorHash: t
+  }), n = await Ie(o, e), i = xe(o.txHex);
+  Ve(
+    i.outputs,
+    o.htlcValues,
+    o.htlcScriptPubKeys
+  );
+  const r = i.outputs.reduce(
+    (u, h) => u + BigInt(h.value),
+    0n
+  ), s = t !== void 0 ? o.htlcValues.length : null;
+  return {
+    psbtHex: o.txHex,
+    totalOutputValue: r,
+    htlcValues: o.htlcValues,
+    htlcScriptPubKeys: o.htlcScriptPubKeys,
+    htlcAddresses: o.htlcAddresses,
+    peginAmounts: o.peginAmounts,
+    depositorClaimValue: o.depositorClaimValue,
+    authAnchorVout: s,
+    minPeginFee: n
+  };
+}
+function le(e) {
+  if (e === void 0) return;
+  const t = e.startsWith("0x") || e.startsWith("0X") ? e.slice(2) : e;
+  if (t.length !== D || !Le.test(t))
+    throw new Error(
+      `authAnchorHash must be 32-byte hex (${D} chars, no 0x prefix); got length ${t.length}`
+    );
+  return t.toLowerCase();
+}
+async function bt(e) {
+  const t = await Pe(
+    {
+      txGraphVersion: e.prePeginParams.vaultCoreVersion,
+      depositorPubkey: e.prePeginParams.depositorPubkey,
+      vaultProviderPubkey: e.prePeginParams.vaultProviderPubkey,
+      vaultKeeperPubkeys: e.prePeginParams.vaultKeeperPubkeys,
+      universalChallengerPubkeys: e.prePeginParams.universalChallengerPubkeys,
+      hashlocks: [...e.prePeginParams.hashlocks],
+      timelockRefund: e.prePeginParams.timelockRefund,
+      pegInAmounts: [...e.prePeginParams.pegInAmounts],
+      feeRate: e.prePeginParams.feeRate,
+      minPeginFeeRate: e.prePeginParams.minPeginFeeRate,
+      numLocalChallengers: e.prePeginParams.numLocalChallengers,
+      councilQuorum: e.prePeginParams.councilQuorum,
+      councilSize: e.prePeginParams.councilSize,
+      network: e.prePeginParams.network,
+      authAnchorHash: le(
+        e.prePeginParams.authAnchorHash
+      )
+    },
+    e.timelockPegin,
+    e.fundedPrePeginTxHex,
+    e.htlcVout
+  );
+  return await Re(t, e), {
+    txHex: t.txHex,
+    txid: t.txid,
+    vaultScriptPubKey: t.vaultScriptPubKey,
+    vaultValue: t.vaultValue
+  };
+}
+const Oe = 2, He = 1;
+async function Re(e, t) {
+  const o = t.prePeginParams.vaultCoreVersion;
+  await ge(o, e.txHex);
+  const n = await ue(o), i = Oe + (n ? 1 : 0), r = E.fromHex(p(e.txHex));
+  if (r.ins.length !== 1)
+    throw new Error(
+      `PegIn tx has ${r.ins.length} input(s), expected exactly 1 (the Pre-PegIn HTLC outpoint).`
+    );
+  const s = E.fromHex(
+    p(t.fundedPrePeginTxHex)
+  ).getId(), u = H(
+    new Uint8Array(r.ins[0].hash).slice().reverse()
+  );
+  if (u !== s)
+    throw new Error(
+      `PegIn input spends txid ${u}, expected the funded Pre-PegIn ${s}.`
+    );
+  if (r.ins[0].index !== t.htlcVout)
+    throw new Error(
+      `PegIn input spends Pre-PegIn output ${r.ins[0].index}, expected the requested HTLC vout ${t.htlcVout}.`
+    );
+  if (r.outs.length !== i)
+    throw new Error(
+      `PegIn tx has ${r.outs.length} output(s), expected exactly ${i} for vaultCoreVersion ${o} (vault + depositor claim${n ? " + P2A anchor" : ""}).`
+    );
+  const h = t.prePeginParams.pegInAmounts[t.htlcVout];
+  if (e.vaultValue !== h)
+    throw new Error(
+      `PegIn vault output value ${e.vaultValue} does not match the requested peg-in amount ${h} for HTLC ${t.htlcVout}; refusing to sign a vault that locks a different amount than requested.`
+    );
+  const c = r.outs[0];
+  if (BigInt(c.value) !== e.vaultValue)
+    throw new Error(
+      `Encoded PegIn vault output value ${c.value} does not match the WASM-reported vaultValue ${e.vaultValue}.`
+    );
+  const d = c.script.toString("hex"), l = p(
+    e.vaultScriptPubKey
+  ).toLowerCase();
+  if (d.toLowerCase() !== l)
+    throw new Error(
+      `Encoded PegIn vault output scriptPubKey ${d} does not match the WASM-reported vaultScriptPubKey ${e.vaultScriptPubKey}.`
+    );
+  const P = r.getId();
+  if (P !== p(e.txid).toLowerCase())
+    throw new Error(
+      `Encoded PegIn txid ${P} does not match the WASM-reported txid ${e.txid}.`
+    );
+  const f = await se(
+    o,
+    t.prePeginParams.numLocalChallengers,
+    t.prePeginParams.universalChallengerPubkeys.length,
+    t.prePeginParams.councilQuorum,
+    t.prePeginParams.councilSize,
+    t.prePeginParams.feeRate
+  ), v = r.outs[He];
+  if (BigInt(v.value) !== f)
+    throw new Error(
+      `Encoded PegIn depositor-claim output value ${v.value} does not match the independently computed claim value ${f} for vaultCoreVersion ${o}.`
+    );
+  const w = Ke(
+    t.prePeginParams.depositorPubkey
+  );
+  if (!v.script.equals(w))
+    throw new Error(
+      `Encoded PegIn depositor-claim output scriptPubKey ${v.script.toString("hex")} does not pay to the depositor's claim script (expected ${w.toString("hex")}).`
+    );
+}
+function Ke(e) {
+  const t = ye.compile([
+    a.from(S(e)),
+    me.OP_CHECKSIG
+  ]), { output: o } = Se.p2tr({
+    internalPubkey: a.from(V),
+    scriptTree: { output: t }
+  });
+  if (!o)
+    throw new Error(
+      "Failed to derive the depositor-claim P2TR scriptPubKey for PegIn output validation"
+    );
+  return o;
+}
+async function Be(e) {
+  const t = await we(
+    {
+      txGraphVersion: e.vaultCoreVersion,
+      depositor: e.depositor,
+      vaultProvider: e.vaultProvider,
+      vaultKeepers: e.vaultKeepers,
+      universalChallengers: e.universalChallengers,
+      timelockPegin: e.timelockPegin
+    },
+    e.network
+  );
+  return {
+    payoutScript: t.payoutScript,
+    taprootScriptHash: t.taprootScriptHash,
+    scriptPubKey: t.scriptPubKey,
+    address: t.address,
+    payoutControlBlock: t.payoutControlBlock
+  };
+}
+const G = 253, Ne = 254, Ue = 65535, Me = 4294967295, Fe = "TapLeaf", qe = "TapBranch", We = "TapTweak", A = 33, k = 32, Y = 128, Xe = 1, ze = 254, De = a.from([81, 32]);
+function Ge(e) {
+  if (e < G)
+    return a.from([e]);
+  if (e <= Ue) {
+    const t = a.alloc(2);
+    return t.writeUInt16LE(e), a.concat([a.from([G]), t]);
+  }
+  if (e <= Me) {
+    const t = a.alloc(4);
+    return t.writeUInt32LE(e), a.concat([a.from([Ne]), t]);
+  }
+  throw new Error(`Script too large to encode as CompactSize: ${e} bytes`);
+}
+function he(e, t) {
+  const o = a.concat([
+    a.from([e]),
+    Ge(t.length),
+    a.from(t)
+  ]);
+  return L.taggedHash(Fe, o);
+}
+function Ye(e) {
+  const { leafVersion: t, script: o, controlBlock: n } = e, i = n.length - A;
+  if (i < 0 || i % k !== 0 || i / k > Y)
+    throw new Error(
+      `Malformed Taproot control block: length ${n.length} must be ${A} + 32*m with 0 <= m <= ${Y}`
+    );
+  const r = n[0] & ze;
+  if (r !== t)
+    throw new Error(
+      `Taproot control block leaf version 0x${r.toString(16)} does not match the tapLeafScript leaf version 0x${t.toString(16)}`
+    );
+  const s = a.from(
+    n.subarray(1, A)
+  );
+  let u = he(t, o);
+  for (let l = A; l < n.length; l += k) {
+    const P = a.from(
+      n.subarray(l, l + k)
+    );
+    u = L.taggedHash(
+      qe,
+      a.compare(u, P) <= 0 ? a.concat([u, P]) : a.concat([P, u])
+    );
+  }
+  const h = L.taggedHash(
+    We,
+    a.concat([s, u])
+  ), c = ae.xOnlyPointAddTweak(s, h);
+  if (c === null)
+    throw new Error(
+      "Taproot control block does not yield a valid output key (tweak is off-curve)"
+    );
+  const d = n[0] & Xe;
+  if (c.parity !== d)
+    throw new Error(
+      `Taproot output key parity ${c.parity} contradicts the control block's parity bit ${d}`
+    );
+  return a.concat([
+    De,
+    a.from(c.xOnlyPubkey)
+  ]);
+}
+const Qe = 256, Ze = 1500, Q = 256, Z = 0xffffffffn, je = 500, Je = 55, et = 34;
+function tt(e) {
+  if (typeof e.protocolFeeRate != "bigint" || e.protocolFeeRate <= 0n || e.protocolFeeRate > Z)
+    throw new Error(
+      `protocolFeeRate must be in [1, ${Z}] sat/vB, got ${e.protocolFeeRate}`
+    );
+  for (const [t, o, n, i] of [
+    [
+      "keepers",
+      e.numVaultKeepers,
+      Qe,
+      "fee-floor model limit"
+    ],
+    [
+      "challengers",
+      e.numUniversalChallengers,
+      Ze,
+      "protocol maximum"
+    ]
+  ])
+    if (!Number.isInteger(o) || o < 1 || o > n)
+      throw new Error(
+        `Participant count for ${t} (${o}) is outside the supported range [1, ${n}]${o > n ? ` (${i})` : ""}.`
+      );
+  if (!Number.isInteger(e.councilSize) || e.councilSize < 1 || e.councilSize > Q)
+    throw new Error(
+      `councilSize must be an integer in [1, ${Q}], got ${e.councilSize}`
+    );
+}
+async function ot(e, t) {
+  const { implicitFeeSats: o, out0Len: n, out1Len: i } = t, r = e.numVaultKeepers + e.numUniversalChallengers, s = BigInt(o), u = Math.max(0, n - et), h = je + Je * r + u, c = e.protocolFeeRate * BigInt(h);
+  if (s > c)
+    throw new Error(
+      `Payout implicit fee ${o} sats exceeds the safety cap of ${c} sats (${e.protocolFeeRate} sat/vB x ${h} vB for ${r} participants); refusing to sign payout.`
+    );
+  const d = await ve(
+    e.vaultCoreVersion,
+    e.numVaultKeepers,
+    e.numUniversalChallengers,
+    e.numVaultKeepers,
+    e.councilSize,
+    n,
+    i,
+    e.protocolFeeRate
+  );
+  if (s < d)
+    throw new Error(
+      `Payout implicit fee ${o} sats is below the floor of ${d} sats (the smallest fee any known vault-provider build produces for this shape); refusing to sign payout.`
+    );
+}
+const nt = 22, rt = 34, it = 34, st = 25, ut = 23;
+function ct(e) {
+  return e.length === nt * 2 && e.startsWith("0014");
+}
+function at(e) {
+  return e.length === rt * 2 && e.startsWith("0020");
+}
+function lt(e) {
+  return e.length === it * 2 && e.startsWith("5120");
+}
+function ht(e) {
+  return e.length === st * 2 && e.startsWith("76a914") && e.endsWith("88ac");
+}
+function dt(e) {
+  return e.length === ut * 2 && e.startsWith("a914") && e.endsWith("87");
+}
+function j(e, t) {
+  const o = p(e).toLowerCase();
+  if (o.length === 0)
+    throw new Error(`${t} is empty`);
+  if (!/^[0-9a-f]+$/.test(o) || o.length % 2 !== 0)
+    throw new Error(`${t} is not valid hex`);
+  if (o.startsWith("6a"))
+    throw new Error(
+      `${t} is an OP_RETURN output, which is provably unspendable`
+    );
+  if (!lt(o) && !ct(o) && !at(o) && !ht(o) && !dt(o))
+    throw new Error(
+      `${t} is not a standard scriptPubKey (expected P2TR, P2WPKH, P2WSH, P2PKH, or P2SH; got ${o.length / 2} bytes: ${o})`
+    );
+}
+const J = 3;
+async function At(e) {
+  const t = {
+    vaultCoreVersion: e.vaultCoreVersion,
+    numVaultKeepers: e.vaultKeeperBtcPubkeys.length,
+    numUniversalChallengers: e.universalChallengerBtcPubkeys.length,
+    councilSize: e.councilMembers.length,
+    protocolFeeRate: e.protocolFeeRate
+  };
+  tt(t);
+  const o = E.fromHex(p(e.payoutTxHex)), n = E.fromHex(p(e.peginTxHex)), i = E.fromHex(p(e.assertTxHex));
+  if (o.ins.length !== U)
+    throw new Error(
+      `Payout transaction must have exactly ${U} inputs, got ${o.ins.length}`
+    );
+  if (o.version !== M)
+    throw new Error(
+      `Payout transaction version ${o.version} must be ${M}; refusing to sign payout.`
+    );
+  if (o.locktime !== F)
+    throw new Error(
+      `Payout transaction locktime ${o.locktime} must be ${F}; refusing to sign payout.`
+    );
+  const r = ee(
+    o.ins[0],
+    0,
+    n,
+    "PegIn",
+    Ae
+  );
+  if (o.ins[0].sequence !== e.timelockPegin)
+    throw new Error(
+      `Payout input 0 sequence ${o.ins[0].sequence} must equal the PegIn CSV timelock ${e.timelockPegin}; refusing to sign payout.`
+    );
+  const s = ee(
+    o.ins[1],
+    1,
+    i,
+    "Assert",
+    ce
+  );
+  if (o.ins[1].sequence !== e.timelockAssert)
+    throw new Error(
+      `Payout input 1 sequence ${o.ins[1].sequence} must equal the Assert CSV timelock ${e.timelockAssert}; refusing to sign payout.`
+    );
+  const { out0Len: u, out1Len: h } = ft(
+    o,
+    r.value,
+    e
+  ), c = r.value + s.value;
+  let d = 0;
+  for (const v of o.outs) d += v.value;
+  if (d > c)
+    throw new Error(
+      `Payout outputs (${d} sats) exceed inputs (${c} sats); invalid transaction.`
+    );
+  const l = c - d;
+  await ot(t, {
+    implicitFeeSats: l,
+    out0Len: u,
+    out1Len: h
+  });
+  const P = await Be({
+    vaultCoreVersion: e.vaultCoreVersion,
+    depositor: e.depositorBtcPubkey,
+    vaultProvider: e.vaultProviderBtcPubkey,
+    vaultKeepers: e.vaultKeeperBtcPubkeys,
+    universalChallengers: e.universalChallengerBtcPubkeys,
+    timelockPegin: e.timelockPegin,
+    network: e.network
+  }), f = await pt(e, s);
+  return {
+    psbtHex: Pt(
+      o,
+      r,
+      s,
+      P,
+      f
+    )
+  };
+}
+async function pt(e, t) {
+  const { payoutScript: o, payoutControlBlock: n } = await $e({
+    txGraphVersion: e.vaultCoreVersion,
+    claimer: p(e.claimerBtcPubkey).toLowerCase(),
+    localChallengers: Te({
+      claimerBtcPubkey: e.claimerBtcPubkey,
+      depositorBtcPubkey: e.depositorBtcPubkey,
+      vaultProviderBtcPubkey: e.vaultProviderBtcPubkey,
+      vaultKeeperBtcPubkeys: e.vaultKeeperBtcPubkeys
+    }),
+    universalChallengers: e.universalChallengerBtcPubkeys.map(
+      (u) => p(u).toLowerCase()
+    ),
+    timelockAssert: e.timelockAssert,
+    councilMembers: e.councilMembers.map(
+      (u) => p(u).toLowerCase()
+    ),
+    councilQuorum: e.councilQuorum
+  }), i = S(o), r = S(n), s = Ye({
+    leafVersion: C,
+    script: i,
+    controlBlock: r
+  });
+  if (!t.script.equals(s))
+    throw new Error(
+      `Rebuilt Assert:0 payout leaf does not spend the Assert output being referenced: leaf binds to ${s.toString("hex")}, Assert:${ce} pays ${t.script.toString("hex")}; refusing to sign payout.`
+    );
+  return { script: i, controlBlock: r };
+}
+function ee(e, t, o, n, i) {
+  const r = H(
+    new Uint8Array(e.hash).slice().reverse()
+  ), s = o.getId();
+  if (r !== s || e.index !== i)
+    throw new Error(
+      `Input ${t} must spend ${n}:${i}. Expected ${s}:${i}, got ${r}:${e.index}`
+    );
+  const u = o.outs[e.index];
+  if (!u)
+    throw new Error(
+      `Previous output not found for input ${t} (txid: ${r}, index: ${e.index})`
+    );
+  return u;
+}
+function Pt(e, t, o, n, i) {
+  const r = new _();
+  r.setVersion(e.version), r.setLocktime(e.locktime);
+  const [s, u] = e.ins;
+  r.addInput({
+    hash: s.hash,
+    index: s.index,
+    sequence: s.sequence,
+    witnessUtxo: {
+      script: t.script,
+      value: t.value
+    },
+    tapLeafScript: [
+      {
+        leafVersion: C,
+        script: a.from(S(n.payoutScript)),
+        controlBlock: a.from(
+          S(n.payoutControlBlock)
+        )
+      }
+    ],
+    tapInternalKey: a.from(V)
+    // sighashType omitted - defaults to SIGHASH_DEFAULT (0x00) for Taproot
+  }), r.addInput({
+    hash: u.hash,
+    index: u.index,
+    sequence: u.sequence,
+    witnessUtxo: {
+      script: o.script,
+      value: o.value
+    },
+    tapLeafScript: [
+      {
+        leafVersion: C,
+        script: a.from(i.script),
+        controlBlock: a.from(i.controlBlock)
+      }
+    ],
+    tapInternalKey: a.from(V)
+  });
+  for (const h of e.outs)
+    r.addOutput({
+      script: h.script,
+      value: h.value
+    });
+  return r.toHex();
+}
+function te(e, t) {
+  const o = p(e).toLowerCase(), n = p(
+    be(t)
+  ).toLowerCase();
+  return o === n ? [o] : [o, n];
+}
+function oe(e, t) {
+  return t.some((o) => e.equals(a.from(o, "hex")));
+}
+function ft(e, t, o) {
+  const {
+    claimerBtcPubkey: n,
+    vaultProviderBtcPubkey: i,
+    depositorBtcPubkey: r,
+    vaultKeeperBtcPubkeys: s,
+    registeredPayoutScriptPubKey: u,
+    commissionBps: h,
+    vkClaimerPayoutScriptPubKeys: c,
+    vpCommissionScriptPubKey: d
+  } = o;
+  if (!Ce(u))
+    throw new Error("Invalid registeredPayoutScriptPubKey: not valid hex");
+  const l = p(n).toLowerCase(), P = p(i).toLowerCase(), f = p(r).toLowerCase(), v = s.map(
+    (m) => p(m).toLowerCase()
+  );
+  let w, g, $;
+  if (l === P)
+    w = "vp-claimer", g = _e, $ = [p(u)];
+  else if (l === f)
+    w = "depositor-as-claimer", g = z, $ = [p(u)];
+  else if (v.includes(l)) {
+    w = "vk-claimer", g = z;
+    const m = c[l];
+    if (m === void 0)
+      throw new Error(
+        `No registered payout script resolved for vault keeper claimer ${l}`
+      );
+    j(
+      m,
+      `Vault keeper payout script for claimer ${l}`
+    ), $ = te(m, l);
+  } else
+    throw new Error(
+      `Unknown claimer pubkey ${l}: not VP, depositor, or a registered vault keeper`
+    );
+  if (e.outs.length !== g)
+    throw new Error(
+      `Payout transaction has ${e.outs.length} output(s), expected exactly ${g} for role ${w}.`
+    );
+  if (!oe(e.outs[0].script, $))
+    throw new Error(
+      `Payout transaction output 0 does not pay the expected scriptPubKey for role ${w}. Accepted: ${$.join(" or ")}; got ${e.outs[0].script.toString("hex")}`
+    );
+  const T = g - 1;
+  if (e.outs[T].value !== q)
+    throw new Error(
+      `Payout CPFP anchor (out ${T}) value ${e.outs[T].value} sats must equal ${q} sats`
+    );
+  if (w === "vp-claimer") {
+    j(
+      d,
+      "Vault provider commission payout script"
+    );
+    const m = te(
+      d,
+      P
+    );
+    if (!oe(e.outs[1].script, m))
+      throw new Error(
+        `Payout transaction output 1 does not pay the vault provider's commission scriptPubKey. Accepted: ${m.join(" or ")}; got ${e.outs[1].script.toString("hex")}`
+      );
+    if (!Number.isInteger(h) || h < 0 || h >= W)
+      throw new Error(
+        `commissionBps must be an integer in [0, ${W}), got ${h}`
+      );
+    const R = Math.floor(
+      t * h / ke
+    );
+    if (e.outs[1].value > R)
+      throw new Error(
+        `Payout VP commission (out 1) value ${e.outs[1].value} sats exceeds cap ${R} sats (${h} bps of peginValue=${t})`
+      );
+  }
+  const b = e.outs[0].script.length;
+  if (b === 0 || b > X)
+    throw new Error(
+      `Payout receiver scriptPubKey length ${b} is outside the contract's registration cap [1, ${X}]; refusing to sign payout.`
+    );
+  const de = w === "vp-claimer" ? e.outs[1].script.length : void 0;
+  return { out0Len: b, out1Len: de };
+}
+function kt(e, t, o = 0) {
+  const n = _.fromHex(e);
+  if (o >= n.data.inputs.length)
+    throw new Error(
+      `Input index ${o} out of range (${n.data.inputs.length} inputs)`
+    );
+  const i = n.data.inputs[o];
+  if (i.tapScriptSig && i.tapScriptSig.length > 0) {
+    const r = S(t);
+    for (const s of i.tapScriptSig)
+      if (s.pubkey.equals(a.from(r)))
+        return ne(s.signature, o);
+    throw new Error(
+      `No signature found for depositor pubkey: ${t} at input ${o}`
+    );
+  }
+  if (i.finalScriptWitness && i.finalScriptWitness.length > 0) {
+    const r = gt(i.finalScriptWitness);
+    if (r.length !== J)
+      throw new Error(
+        `Unexpected finalized witness stack size at input ${o}: expected ${J} items (signature, script, controlBlock), got ${r.length}`
+      );
+    return ne(r[0], o);
+  }
+  throw new Error(
+    `No tapScriptSig or finalScriptWitness found in signed PSBT at input ${o}`
+  );
+}
+function ne(e, t) {
+  if (e.length === 64)
+    return H(new Uint8Array(e));
+  throw e.length === 65 ? new Error(
+    `Unexpected sighash byte 0x${e[64].toString(16).padStart(2, "0")} at input ${t}. Expected implicit SIGHASH_DEFAULT as a 64-byte signature.`
+  ) : new Error(
+    `Unexpected signature length at input ${t}: ${e.length}`
+  );
+}
+function gt(e) {
+  const t = [];
+  let o = 0;
+  const n = (s) => {
+    if (o + s > e.length)
+      throw new Error(
+        `Malformed witness data: need ${s} byte(s) at offset ${o}, only ${e.length - o} remaining`
+      );
+  }, i = () => {
+    n(1);
+    const s = e[o++];
+    if (s < 253) return s;
+    if (s === 253) {
+      n(2);
+      const u = (e[o] | e[o + 1] << 8) >>> 0;
+      return o += 2, u;
+    }
+    if (s === 254) {
+      n(4);
+      const u = (e[o] | e[o + 1] << 8 | e[o + 2] << 16 | e[o + 3] << 24) >>> 0;
+      return o += 4, u;
+    }
+    throw new Error(
+      `Malformed witness data: 8-byte varint (0xff) not supported at offset ${o - 1}`
+    );
+  }, r = i();
+  for (let s = 0; s < r; s++) {
+    const u = i();
+    n(u), t.push(a.from(e.subarray(o, o + u))), o += u;
+  }
+  if (o !== e.length)
+    throw new Error(
+      `Malformed witness data: ${e.length - o} trailing byte(s) after parsing ${r} item(s)`
+    );
+  return t;
+}
+class y extends Error {
+  constructor(t) {
+    super(
+      `Wallet returned a PSBT for a different transaction: ${t}`
+    ), this.name = "PsbtSubstitutionError";
+  }
+}
+function re(e, t) {
+  try {
+    return _.fromHex(t);
+  } catch (o) {
+    const n = o instanceof Error ? o.message : String(o);
+    throw new Error(`Failed to parse ${e} PSBT: ${n}`);
+  }
+}
+const wt = 8;
+function O(e) {
+  return `${e.toString("hex").slice(0, wt)}…`;
+}
+function ie(e) {
+  const t = a.from(e).reverse();
+  return O(t);
+}
+function _t(e) {
+  const t = re("requested", e.requestedPsbtHex), o = re("returned", e.returnedPsbtHex);
+  if (t.version !== o.version)
+    throw new y(
+      `tx version differs (requested=${t.version}, returned=${o.version})`
+    );
+  if (t.locktime !== o.locktime)
+    throw new y(
+      `tx locktime differs (requested=${t.locktime}, returned=${o.locktime})`
+    );
+  if (t.txInputs.length !== o.txInputs.length)
+    throw new y(
+      `input count differs (requested=${t.txInputs.length}, returned=${o.txInputs.length})`
+    );
+  if (t.txOutputs.length !== o.txOutputs.length)
+    throw new y(
+      `output count differs (requested=${t.txOutputs.length}, returned=${o.txOutputs.length})`
+    );
+  for (let n = 0; n < t.txInputs.length; n++) {
+    const i = t.txInputs[n], r = o.txInputs[n];
+    if (!i.hash.equals(r.hash))
+      throw new y(
+        `input ${n} prevout txid differs (requested=${ie(i.hash)}, returned=${ie(r.hash)})`
+      );
+    if (i.index !== r.index)
+      throw new y(
+        `input ${n} prevout vout differs (requested=${i.index}, returned=${r.index})`
+      );
+    if (i.sequence !== r.sequence)
+      throw new y(
+        `input ${n} sequence differs (requested=${i.sequence}, returned=${r.sequence})`
+      );
+  }
+  for (let n = 0; n < t.txOutputs.length; n++) {
+    const i = t.txOutputs[n], r = o.txOutputs[n];
+    if (!i.script.equals(r.script))
+      throw new y(
+        `output ${n} scriptPubKey differs (requested=${O(i.script)}, returned=${O(r.script)})`
+      );
+    if (i.value !== r.value)
+      throw new y(
+        `output ${n} value differs (requested=${i.value}, returned=${r.value})`
+      );
+  }
+}
+function Tt(e) {
+  const { requestedPsbtHex: t, signatureHex: o, signerXOnlyPubkeyHex: n, inputIndex: i } = e, r = p(o);
+  if (r.length !== B)
+    throw new Error(
+      `Schnorr signature for input ${i} must be ${B} hex chars (64 bytes), got ${r.length}.`
+    );
+  const s = p(n);
+  if (s.length !== N)
+    throw new Error(
+      `Signer x-only pubkey for input ${i} must be ${N} hex chars (32 bytes), got ${s.length}.`
+    );
+  const u = _.fromHex(t);
+  if (i < 0 || i >= u.data.inputs.length)
+    throw new Error(
+      `Input index ${i} out of range (${u.data.inputs.length} inputs).`
+    );
+  const h = [], c = [];
+  for (let g = 0; g < u.data.inputs.length; g++) {
+    const $ = u.data.inputs[g].witnessUtxo;
+    if (!$)
+      throw new Error(
+        `Cannot verify signature: input ${g} of the requested PSBT has no witnessUtxo (required to recompute the Taproot sighash).`
+      );
+    h.push($.script), c.push($.value);
+  }
+  const d = u.data.inputs[i].tapLeafScript;
+  if (!d || d.length !== 1)
+    throw new Error(
+      `Cannot verify signature: input ${i} of the requested PSBT must have exactly one tapLeafScript, got ${(d == null ? void 0 : d.length) ?? 0}.`
+    );
+  const l = d[0];
+  if (l.leafVersion !== C)
+    throw new Error(
+      `Cannot verify signature: input ${i} tapLeafScript has leaf version 0x${l.leafVersion.toString(16)}, expected 0x${C.toString(16)}.`
+    );
+  const P = he(l.leafVersion, l.script), f = new E();
+  f.version = u.version, f.locktime = u.locktime;
+  for (const g of u.txInputs)
+    f.addInput(g.hash, g.index, g.sequence);
+  for (const g of u.txOutputs)
+    f.addOutput(g.script, g.value);
+  const v = f.hashForWitnessV1(
+    i,
+    h,
+    c,
+    E.SIGHASH_DEFAULT,
+    P
+  );
+  if (!ae.verifySchnorr(
+    v,
+    S(s),
+    S(r)
+  ))
+    throw new Error(
+      `Schnorr signature for input ${i} (signer ${s}) does not verify against the expected Taproot script-path sighash. The wallet may have signed with the tweaked key, signed a different transaction, or returned an invalid signature.`
+    );
+}
+export {
+  I as H,
+  y as P,
+  Ct as a,
+  bt as b,
+  Et as c,
+  At as d,
+  kt as e,
+  _t as f,
+  Tt as g,
+  Be as h,
+  Ve as i,
+  Te as j,
+  le as n
+};
+//# sourceMappingURL=verifyScriptPathSchnorrSignature-Dy9gF5RF.js.map