@babylonlabs-io/ts-sdk 3.3.0 → 4.0.0

package/dist/{verifyScriptPathSchnorrSignature-owu3BfyT.js → verifyScriptPathSchnorrSignature-D-fdi-sG.js}

@@ -1,55 +1,55 @@
-import { script as x, opcodes as E, payments as L, Transaction as k, crypto as U, Psbt as H } from "bitcoinjs-lib";
-import { computeMinClaimValue as ye, peginP2aAnchorOutput as me, computeMinPeginFee as Ie, tapInternalPubkey as _, buildPeginTxFromPrePegin as Ae, createPrePeginTransaction as Te, validatePeginP2aAnchor as Oe, createPayoutConnector as Ve, computePayoutFeeFloor as Le, getAssertPayoutScriptInfo as Re } from "./tbv/core/wasm/index.js";
-import { c as q, p as Ke, d as He } from "./fundPeginTransaction-CwhRbCQC.js";
-import { p as Ne, s as f, d as $e, m as Se, T as y, h as C, u as M, j as Ue, S as W } from "./bitcoin-C-TuHb-v.js";
-import { b as Be } from "./secp256k1-BuxBFUHm.js";
-import { Buffer as c } from "buffer";
-import { P as X, k as G, l as z, m as Y, n as Me, o as D, p as Fe, q as qe, r as Q, s as Z, t as j, u as J, v as ee, w as te, M as oe, j as ne, x as We, A as xe, B as Xe, V as Ge, y as re } from "./constants-CvQZuxKv.js";
-import * as Ce from "@bitcoin-js/tiny-secp256k1-asmjs";
-import { X as ie } from "./validation-OSC0xTHB.js";
+import { script as x, opcodes as w, payments as L, Transaction as k, crypto as U, Psbt as H } from "bitcoinjs-lib";
+import { computeMinClaimValue as Se, peginP2aAnchorOutput as Te, computeMinPeginFee as Oe, tapInternalPubkey as I, buildPeginTxFromPrePegin as Ve, createPrePeginTransaction as Le, validatePeginP2aAnchor as Re, createPayoutConnector as Ke, computePayoutFeeFloor as He, getAssertPayoutScriptInfo as Ne } from "./tbv/core/wasm/index.js";
+import { c as q, p as Ue, d as Be } from "./fundPeginTransaction-CwhRbCQC.js";
+import { p as Me, s as f, d as xe, m as Ce, T as y, h as C, u as M, j as Fe, S as W } from "./bitcoin-C-TuHb-v.js";
+import { b as qe } from "./secp256k1-BuxBFUHm.js";
+import { Buffer as a } from "buffer";
+import { P as X, l as G, m as z, n as Y, o as We, p as D, q as Q, r as Z, s as j, t as J, u as ee, v as te, w as oe, x as ne, y as re, M as ie, j as se, z as Xe, A as be, B as Ge, V as ze, E as ue } from "./constants-CmDDuM3L.js";
+import * as ke from "@bitcoin-js/tiny-secp256k1-asmjs";
+import { X as ce } from "./validation-OSC0xTHB.js";
 function b(e) {
-  return Ne(e).toLowerCase();
+  return Me(e).toLowerCase();
 }
 function Qt(e, t, o) {
   const n = /* @__PURE__ */ new Set();
   n.add(b(e));
-  for (const i of t)
-    n.add(b(i));
+  for (const r of t)
+    n.add(b(r));
   return n.delete(b(o)), n.size;
 }
-function ze(e) {
+function Ye(e) {
   const t = b(e.claimerBtcPubkey), o = b(e.depositorBtcPubkey), n = e.vaultKeeperBtcPubkeys.map(b);
   if (t === o) {
-    const r = n.filter((u) => u !== o);
-    if (r.length === 0)
+    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(r).size !== r.length)
+    if (new Set(s).size !== s.length)
       throw new Error(
         "Cannot derive localChallengers: duplicate vaultKeeper key — signing context is misconfigured"
       );
-    return r;
+    return s;
   }
-  const s = [
+  const i = [
     .../* @__PURE__ */ new Set([b(e.vaultProviderBtcPubkey), ...n])
-  ].sort().filter((r) => r !== t);
-  if (s.length === 0)
+  ].sort().filter((s) => s !== t);
+  if (i.length === 0)
     throw new Error(
       `Cannot derive localChallengers: no vault provider or vault keeper remains after excluding claimer ${t}`
     );
-  return s;
+  return i;
 }
-const Ye = 32, De = 65535, Qe = 2;
-function I(e, t) {
+const De = 32, Qe = 65535, Ze = 2;
+function _(e, t) {
   const o = f(e).toLowerCase();
   if (!/^[0-9a-f]{64}$/.test(o))
     throw new Error(`${t} must be a 32-byte x-only public key.`);
   try {
-    Be.Point.fromBytes(
-      c.concat([
-        c.from([Qe]),
-        c.from(o, "hex")
+    qe.Point.fromBytes(
+      a.concat([
+        a.from([Ze]),
+        a.from(o, "hex")
       ])
     );
   } catch {
@@ -60,122 +60,122 @@ function I(e, t) {
 function R(e, t) {
   if (e.length === 0)
     throw new Error(`${t} must not be empty.`);
-  const o = e.map((n, i) => I(n, `${t}[${i}]`)).sort();
+  const o = e.map((n, r) => _(n, `${t}[${r}]`)).sort();
   if (new Set(o).size !== o.length)
     throw new Error(`${t} must not contain duplicate keys.`);
   return o;
 }
 function K(e, t) {
   const o = [];
-  return e.forEach((n, i) => {
+  return e.forEach((n, r) => {
     o.push(
-      c.from(n, "hex"),
-      i === 0 ? E.OP_CHECKSIG : E.OP_CHECKSIGADD
+      a.from(n, "hex"),
+      r === 0 ? w.OP_CHECKSIG : w.OP_CHECKSIGADD
     );
   }), o.push(
     x.number.encode(e.length),
-    t ? E.OP_NUMEQUALVERIFY : E.OP_NUMEQUAL
+    t ? w.OP_NUMEQUALVERIFY : w.OP_NUMEQUAL
   ), o;
 }
-function Ze(e, t) {
+function je(e, t) {
   var g;
-  Se();
-  const o = I(
+  Ce();
+  const o = _(
     e.depositorPubkey,
     "depositorPubkey"
-  ), n = I(
+  ), n = _(
     e.vaultProviderPubkey,
     "vaultProviderPubkey"
-  ), i = R(
+  ), r = R(
     e.vaultKeeperPubkeys,
     "vaultKeeperPubkeys"
-  ), s = R(
+  ), i = R(
     e.universalChallengerPubkeys,
     "universalChallengerPubkeys"
-  ), r = f(t).toLowerCase();
-  if (!/^[0-9a-f]{64}$/.test(r))
+  ), s = f(t).toLowerCase();
+  if (!/^[0-9a-f]{64}$/.test(s))
     throw new Error("hashlock must be 32 bytes.");
-  if (!Number.isInteger(e.timelockRefund) || e.timelockRefund < 1 || e.timelockRefund > De)
+  if (!Number.isInteger(e.timelockRefund) || e.timelockRefund < 1 || e.timelockRefund > Qe)
     throw new Error("timelockRefund must be an integer from 1 to 65535.");
   const u = x.compile([
-    E.OP_SIZE,
-    x.number.encode(Ye),
-    E.OP_EQUALVERIFY,
-    E.OP_SHA256,
-    c.from(r, "hex"),
-    E.OP_EQUALVERIFY,
-    c.from(o, "hex"),
-    E.OP_CHECKSIGVERIFY,
-    c.from(n, "hex"),
-    E.OP_CHECKSIGVERIFY,
-    ...K(i, !0),
-    ...K(s, !1)
-  ]), h = x.compile([
-    c.from(o, "hex"),
-    E.OP_CHECKSIGVERIFY,
+    w.OP_SIZE,
+    x.number.encode(De),
+    w.OP_EQUALVERIFY,
+    w.OP_SHA256,
+    a.from(s, "hex"),
+    w.OP_EQUALVERIFY,
+    a.from(o, "hex"),
+    w.OP_CHECKSIGVERIFY,
+    a.from(n, "hex"),
+    w.OP_CHECKSIGVERIFY,
+    ...K(r, !0),
+    ...K(i, !1)
+  ]), c = x.compile([
+    a.from(o, "hex"),
+    w.OP_CHECKSIGVERIFY,
     x.number.encode(e.timelockRefund),
-    E.OP_CHECKSEQUENCEVERIFY
-  ]), l = [
+    w.OP_CHECKSEQUENCEVERIFY
+  ]), p = [
     { output: u, version: y },
-    { output: h, version: y }
-  ], { hash: d, output: a, witness: P } = L.p2tr({
-    internalPubkey: c.from(_),
-    scriptTree: l,
+    { output: c, version: y }
+  ], { hash: l, output: h, witness: d } = L.p2tr({
+    internalPubkey: a.from(I),
+    scriptTree: p,
     redeem: {
       output: u,
       redeemVersion: y
     }
-  }), p = P == null ? void 0 : P[P.length - 1], v = L.p2tr({
-    internalPubkey: c.from(_),
-    scriptTree: l,
+  }), P = d == null ? void 0 : d[d.length - 1], E = L.p2tr({
+    internalPubkey: a.from(I),
+    scriptTree: p,
     redeem: {
-      output: h,
+      output: c,
       redeemVersion: y
     }
-  }), w = (g = v.witness) == null ? void 0 : g[v.witness.length - 1];
-  if (!d || !a || !p || !w)
+  }), v = (g = E.witness) == null ? void 0 : g[E.witness.length - 1];
+  if (!l || !h || !P || !v)
     throw new Error("Failed to derive the expected Pre-PegIn HTLC output.");
   return {
     hashlockScript: u,
-    hashlockControlBlock: p,
-    refundScript: h,
-    refundControlBlock: w,
-    scriptPubKey: a,
-    tapMerkleRoot: d
+    hashlockControlBlock: P,
+    refundScript: c,
+    refundControlBlock: v,
+    scriptPubKey: h,
+    tapMerkleRoot: l
   };
 }
-function je(e, t) {
-  Se();
-  const o = I(
+function Je(e, t) {
+  Ce();
+  const o = _(
     e.depositorPubkey,
     "depositorPubkey"
-  ), n = I(
+  ), n = _(
     e.vaultProviderPubkey,
     "vaultProviderPubkey"
-  ), i = R(
+  ), r = R(
     e.vaultKeeperPubkeys,
     "vaultKeeperPubkeys"
-  ), s = R(
+  ), i = R(
     e.universalChallengerPubkeys,
     "universalChallengerPubkeys"
-  ), r = x.compile([
-    c.from(o, "hex"),
-    E.OP_CHECKSIGVERIFY,
-    c.from(n, "hex"),
-    E.OP_CHECKSIGVERIFY,
+  ), s = x.compile([
+    a.from(o, "hex"),
+    w.OP_CHECKSIGVERIFY,
+    a.from(n, "hex"),
+    w.OP_CHECKSIGVERIFY,
+    ...K(r, !0),
     ...K(i, !0),
-    ...K(s, !0),
     x.number.encode(t),
-    E.OP_CHECKSEQUENCEVERIFY
+    w.OP_CHECKSEQUENCEVERIFY
   ]), { output: u } = L.p2tr({
-    internalPubkey: c.from(_),
-    scriptTree: { output: r, version: y }
+    internalPubkey: a.from(I),
+    scriptTree: { output: s, version: y }
   });
   if (!u)
     throw new Error("Failed to derive the expected PegIn payout output.");
   return u;
 }
-async function Je(e, t) {
+async function et(e, t) {
   const o = t.pegInAmounts.length;
   if (t.hashlocks.length !== o)
     throw new Error(
@@ -193,7 +193,7 @@ async function Je(e, t) {
     throw new Error(
       `WASM Pre-PegIn returned non-positive depositorClaimValue ${e.depositorClaimValue}; expected > 0.`
     );
-  const n = await ye(
+  const n = await Se(
     // Must price the same graph version the builder constructed.
     t.vaultCoreVersion,
     t.numLocalChallengers,
@@ -206,154 +206,156 @@ async function Je(e, t) {
     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 me(t.vaultCoreVersion), s = (i == null ? void 0 : i.value) ?? 0n, r = await Ie(
+  const { value: r } = await Te(
+    t.vaultCoreVersion
+  ), i = await Oe(
     t.vaultCoreVersion,
     t.vaultKeeperPubkeys.length,
     t.universalChallengerPubkeys.length,
     t.minPeginFeeRate
-  ), u = r + s, h = t.minPeginFeeRate * q;
-  for (let l = 0; l < o; l++) {
-    const d = t.pegInAmounts[l], a = e.peginAmounts[l], P = e.htlcValues[l];
-    if (a !== d)
+  ), s = i + r, u = t.minPeginFeeRate * q;
+  for (let c = 0; c < o; c++) {
+    const p = t.pegInAmounts[c], l = e.peginAmounts[c], h = e.htlcValues[c];
+    if (l !== p)
       throw new Error(
-        `WASM Pre-PegIn peginAmount[${l}] ${a} does not match the requested amount ${d}; refusing to build a tx whose recorded amount differs from the depositor's request.`
+        `WASM Pre-PegIn peginAmount[${c}] ${l} does not match the requested amount ${p}; refusing to build a tx whose recorded amount differs from the depositor's request.`
       );
-    if (a <= 0n)
+    if (l <= 0n)
       throw new Error(
-        `WASM Pre-PegIn peginAmount[${l}] is non-positive (${a}); expected > 0.`
+        `WASM Pre-PegIn peginAmount[${c}] is non-positive (${l}); expected > 0.`
       );
-    if (P <= 0n)
+    if (h <= 0n)
       throw new Error(
-        `WASM Pre-PegIn htlcValue[${l}] is non-positive (${P}); expected > 0.`
+        `WASM Pre-PegIn htlcValue[${c}] is non-positive (${h}); expected > 0.`
       );
-    const p = P - a - e.depositorClaimValue;
-    if (p <= 0n)
+    const d = h - l - e.depositorClaimValue;
+    if (d <= 0n)
       throw new Error(
-        `WASM Pre-PegIn htlcValue[${l}] ${P} does not strictly cover peginAmount ${a} + depositorClaimValue ${e.depositorClaimValue} + a PegIn reserve (implied reserve ${p}).`
+        `WASM Pre-PegIn htlcValue[${c}] ${h} does not strictly cover peginAmount ${l} + depositorClaimValue ${e.depositorClaimValue} + a PegIn reserve (implied reserve ${d}).`
       );
-    if (p > h)
+    if (d > u)
       throw new Error(
-        `WASM Pre-PegIn implied reserve for HTLC[${l}] (${p} sat) exceeds the plausibility cap ${h} sat (minPeginFeeRate=${t.minPeginFeeRate} × ${q} vbytes); htlcValue ${P} appears grossly inflated.`
+        `WASM Pre-PegIn implied reserve for HTLC[${c}] (${d} sat) exceeds the plausibility cap ${u} sat (minPeginFeeRate=${t.minPeginFeeRate} × ${q} vbytes); htlcValue ${h} appears grossly inflated.`
       );
-    if (p !== u)
+    if (d !== s)
       throw new Error(
-        `WASM Pre-PegIn htlcValue[${l}] ${P} implies a PegIn fee+anchor reserve of ${p} sat, expected exactly ${u} sat (minPeginFee ${r} + p2aAnchor ${s} for vaultCoreVersion ${t.vaultCoreVersion}, vaultKeepers=${t.vaultKeeperPubkeys.length}, universalChallengers=${t.universalChallengerPubkeys.length}, minPeginFeeRate=${t.minPeginFeeRate}).`
+        `WASM Pre-PegIn htlcValue[${c}] ${h} implies a PegIn fee+anchor reserve of ${d} sat, expected exactly ${s} sat (minPeginFee ${i} + p2aAnchor ${r} for vaultCoreVersion ${t.vaultCoreVersion}, vaultKeepers=${t.vaultKeeperPubkeys.length}, universalChallengers=${t.universalChallengerPubkeys.length}, minPeginFeeRate=${t.minPeginFeeRate}).`
       );
   }
-  return r;
+  return i;
 }
 class V extends Error {
   constructor(t) {
     super(t), this.name = "HtlcOutputMismatchError";
   }
 }
-function et(e, t, o) {
+function tt(e, t, o) {
   if (e.length < t.length)
     throw new V(
       `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])
+    const r = BigInt(e[n].value);
+    if (r !== t[n])
       throw new V(
-        `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.`
+        `Encoded Pre-PegIn HTLC output[${n}] value ${r} does not match the cross-checked htlcValue ${t[n]}; the funded/signed tx would not pay the validated amount.`
       );
-    const s = e[n].script.toString("hex").toLowerCase(), r = o[n].toLowerCase();
-    if (s !== r)
+    const i = e[n].script.toString("hex").toLowerCase(), s = o[n].toLowerCase();
+    if (i !== s)
       throw new V(
-        `Encoded Pre-PegIn HTLC output[${n}] scriptPubKey ${s} does not match the cross-checked htlcScriptPubKey ${r}.`
+        `Encoded Pre-PegIn HTLC output[${n}] scriptPubKey ${i} does not match the cross-checked htlcScriptPubKey ${s}.`
       );
   }
 }
-function tt(e, t, o, n, i, s, r) {
-  if (s !== X)
+function ot(e, t, o, n, r, i, s) {
+  if (i !== X)
     throw new Error(
-      `WASM Pre-PegIn transaction version ${s}; expected ${X}.`
+      `WASM Pre-PegIn transaction version ${i}; expected ${X}.`
     );
-  if (r !== G)
+  if (s !== G)
     throw new Error(
-      `WASM Pre-PegIn transaction locktime ${r}; expected ${G}.`
+      `WASM Pre-PegIn transaction locktime ${s}; expected ${G}.`
     );
   if (t.length < z)
     throw new Error(
       `WASM Pre-PegIn output layout has ${t.length} HTLC output(s); expected at least ${z}.`
     );
-  const u = t.length, h = u + +(i !== void 0), l = Ke(
+  const u = t.length, c = u + +(r !== void 0), p = Ue(
     t.length,
-    i !== void 0
+    r !== void 0
   );
-  if (e.length !== l)
+  if (e.length !== p)
     throw new Error(
-      `WASM Pre-PegIn output layout has ${e.length} output(s); expected exactly ${l}.`
+      `WASM Pre-PegIn output layout has ${e.length} output(s); expected exactly ${p}.`
     );
-  et(e, t, o);
-  for (let p = 0; p < t.length; p++) {
-    const v = Ze(
+  tt(e, t, o);
+  for (let P = 0; P < t.length; P++) {
+    const E = je(
       n,
-      n.hashlocks[p]
+      n.hashlocks[P]
     ).scriptPubKey;
-    if (!e[p].script.equals(v))
+    if (!e[P].script.equals(E))
       throw new V(
-        `Pre-PegIn HTLC output[${p}] does not match the independently derived scriptPubKey.`
+        `Pre-PegIn HTLC output[${P}] does not match the independently derived scriptPubKey.`
       );
   }
-  if (i !== void 0) {
-    const p = e[u];
-    if (p.value !== Y)
+  if (r !== void 0) {
+    const P = e[u];
+    if (P.value !== Y)
       throw new Error(
-        `WASM Pre-PegIn auth output[${u}] value ${p.value} sat; expected exactly ${Y} sat.`
+        `WASM Pre-PegIn auth output[${u}] value ${P.value} sat; expected exactly ${Y} sat.`
       );
-    const v = p.script.toString("hex").toLowerCase(), w = Me + i.toLowerCase();
-    if (v !== w)
+    const E = P.script.toString("hex").toLowerCase(), v = We + r.toLowerCase();
+    if (E !== v)
       throw new Error(
-        `WASM Pre-PegIn auth output[${u}] scriptPubKey ${v}; expected ${w}.`
+        `WASM Pre-PegIn auth output[${u}] scriptPubKey ${E}; expected ${v}.`
       );
   }
-  const d = e[h];
-  if (d.value !== D)
+  const l = e[c];
+  if (l.value !== D)
     throw new Error(
-      `WASM Pre-PegIn CPFP output[${h}] value ${d.value} sat; expected exactly ${D} sat.`
+      `WASM Pre-PegIn CPFP output[${c}] value ${l.value} sat; expected exactly ${D} sat.`
     );
-  const a = d.script.toString("hex").toLowerCase(), P = f(
-    $e(n.depositorPubkey)
+  const h = l.script.toString("hex").toLowerCase(), d = f(
+    xe(n.depositorPubkey)
   ).toLowerCase();
-  if (a !== P)
+  if (h !== d)
     throw new Error(
-      `WASM Pre-PegIn CPFP output[${h}] scriptPubKey ${a}; expected depositor BIP-86 script ${P}.`
+      `WASM Pre-PegIn CPFP output[${c}] scriptPubKey ${h}; expected depositor BIP-86 script ${d}.`
     );
 }
-const ot = 1;
-function nt(e) {
+const nt = 1;
+function rt(e) {
   const t = f(e);
   if (!/^[0-9a-fA-F]{64}$/.test(t))
     throw new Error(
       "Invalid depositor pubkey for the depositor-claim script: must be an x-only key of 64 hex characters (32 bytes)."
     );
   const o = x.compile([
-    c.from(C(t)),
-    E.OP_CHECKSIG
-  ]), n = c.from(_), i = { output: o, redeemVersion: y }, { output: s, witness: r } = L.p2tr({
+    a.from(C(t)),
+    w.OP_CHECKSIG
+  ]), n = a.from(I), r = { output: o, redeemVersion: y }, { output: i, witness: s } = L.p2tr({
     internalPubkey: n,
     scriptTree: { output: o },
-    redeem: i
+    redeem: r
   });
-  if (!s)
+  if (!i)
     throw new Error(
       "Failed to derive the depositor-claim P2TR scriptPubKey for PegIn output validation"
     );
-  const u = r == null ? void 0 : r[r.length - 1];
+  const u = s == null ? void 0 : s[s.length - 1];
   if (!u)
     throw new Error(
       "Failed to derive the depositor-claim tapleaf control block; refusing to build an unspendable input"
     );
-  return { scriptPubKey: s, leafScript: o, controlBlock: u, internalKey: n };
+  return { scriptPubKey: i, leafScript: o, controlBlock: u, internalKey: n };
 }
-function rt(e) {
-  return nt(e).scriptPubKey;
+function it(e) {
+  return rt(e).scriptPubKey;
 }
-const se = 64, it = /^[0-9a-fA-F]+$/, ue = 65535;
+const ae = 64, st = /^[0-9a-fA-F]+$/, le = 65535;
 async function Zt(e) {
-  const t = be(e.authAnchorHash), o = await Te({
+  const t = Ie(e.authAnchorHash), o = await Le({
     txGraphVersion: e.vaultCoreVersion,
     depositorPubkey: e.depositorPubkey,
     vaultProviderPubkey: e.vaultProviderPubkey,
@@ -369,47 +371,47 @@ async function Zt(e) {
     councilSize: e.councilSize,
     network: e.network,
     authAnchorHash: t
-  }), n = await Je(o, e), i = He(o.txHex);
-  tt(
-    i.outputs,
+  }), n = await et(o, e), r = Be(o.txHex);
+  ot(
+    r.outputs,
     o.htlcValues,
     o.htlcScriptPubKeys,
     e,
     t,
-    i.version,
-    i.locktime
+    r.version,
+    r.locktime
   );
-  const s = i.outputs.reduce(
-    (u, h) => u + BigInt(h.value),
+  const i = r.outputs.reduce(
+    (u, c) => u + BigInt(c.value),
     0n
-  ), r = t !== void 0 ? o.htlcValues.length : null;
+  ), s = t !== void 0 ? o.htlcValues.length : null;
   return {
     psbtHex: o.txHex,
-    totalOutputValue: s,
+    totalOutputValue: i,
     htlcValues: o.htlcValues,
     htlcScriptPubKeys: o.htlcScriptPubKeys,
     htlcAddresses: o.htlcAddresses,
     peginAmounts: o.peginAmounts,
     depositorClaimValue: o.depositorClaimValue,
-    authAnchorVout: r,
+    authAnchorVout: s,
     minPeginFee: n
   };
 }
-function be(e) {
+function Ie(e) {
   if (e === void 0) return;
   const t = e.startsWith("0x") || e.startsWith("0X") ? e.slice(2) : e;
-  if (t.length !== se || !it.test(t))
+  if (t.length !== ae || !st.test(t))
     throw new Error(
-      `authAnchorHash must be 32-byte hex (${se} chars, no 0x prefix); got length ${t.length}`
+      `authAnchorHash must be 32-byte hex (${ae} chars, no 0x prefix); got length ${t.length}`
     );
   return t.toLowerCase();
 }
 async function jt(e) {
-  if (!Number.isInteger(e.timelockPegin) || e.timelockPegin < 1 || e.timelockPegin > ue)
+  if (!Number.isInteger(e.timelockPegin) || e.timelockPegin < 1 || e.timelockPegin > le)
     throw new Error(
-      `PegIn timelock ${e.timelockPegin} must be a whole number of blocks from 1 to ${ue}.`
+      `PegIn timelock ${e.timelockPegin} must be a whole number of blocks from 1 to ${le}.`
     );
-  const t = await Ae(
+  const t = await Ve(
     {
       txGraphVersion: e.prePeginParams.vaultCoreVersion,
       depositorPubkey: e.prePeginParams.depositorPubkey,
@@ -425,7 +427,7 @@ async function jt(e) {
       councilQuorum: e.prePeginParams.councilQuorum,
       councilSize: e.prePeginParams.councilSize,
       network: e.prePeginParams.network,
-      authAnchorHash: be(
+      authAnchorHash: Ie(
         e.prePeginParams.authAnchorHash
       )
     },
@@ -440,100 +442,101 @@ async function jt(e) {
     vaultValue: t.vaultValue
   };
 }
-const st = 2;
 async function ut(e, t) {
-  const o = t.prePeginParams.vaultCoreVersion, n = o === 1 ? Fe : o === 2 || o === 3 ? qe : void 0;
-  if (n === void 0)
-    throw new Error(`Unsupported vaultCoreVersion ${o} for PegIn tx.`);
-  await Oe(o, e.txHex);
-  const i = await me(o), s = st + (i ? 1 : 0), r = k.fromHex(f(e.txHex));
-  if (r.version !== n)
+  const o = t.prePeginParams.vaultCoreVersion;
+  if (o !== Q)
+    throw new Error(
+      `Unsupported vaultCoreVersion ${o} for PegIn tx; only ${Q} has a PegIn shape.`
+    );
+  await Re(o, e.txHex);
+  const n = k.fromHex(f(e.txHex));
+  if (n.version !== Z)
     throw new Error(
-      `PegIn tx version ${r.version} does not match vaultCoreVersion ${o}; expected ${n}.`
+      `PegIn tx version ${n.version} does not match vaultCoreVersion ${o}; expected ${Z}.`
     );
-  if (r.locktime !== Q)
+  if (n.locktime !== j)
     throw new Error(
-      `PegIn tx locktime ${r.locktime} does not match the canonical locktime ${Q}.`
+      `PegIn tx locktime ${n.locktime} does not match the canonical locktime ${j}.`
     );
-  if (r.ins.length !== 1)
+  if (n.ins.length !== 1)
     throw new Error(
-      `PegIn tx has ${r.ins.length} input(s), expected exactly 1 (the Pre-PegIn HTLC outpoint).`
+      `PegIn tx has ${n.ins.length} input(s), expected exactly 1 (the Pre-PegIn HTLC outpoint).`
     );
-  const u = k.fromHex(
+  const r = k.fromHex(
     f(t.fundedPrePeginTxHex)
-  ).getId(), h = M(
-    new Uint8Array(r.ins[0].hash).slice().reverse()
+  ).getId(), i = M(
+    new Uint8Array(n.ins[0].hash).slice().reverse()
   );
-  if (h !== u)
+  if (i !== r)
     throw new Error(
-      `PegIn input spends txid ${h}, expected the funded Pre-PegIn ${u}.`
+      `PegIn input spends txid ${i}, expected the funded Pre-PegIn ${r}.`
     );
-  if (r.ins[0].index !== t.htlcVout)
+  if (n.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}.`
+      `PegIn input spends Pre-PegIn output ${n.ins[0].index}, expected the requested HTLC vout ${t.htlcVout}.`
     );
-  if (r.ins[0].sequence !== Z)
+  if (n.ins[0].sequence !== J)
     throw new Error(
-      `PegIn input sequence ${r.ins[0].sequence} does not match the canonical sequence ${Z}.`
+      `PegIn input sequence ${n.ins[0].sequence} does not match the canonical sequence ${J}.`
     );
-  if (r.ins[0].script.length !== 0)
+  if (n.ins[0].script.length !== 0)
     throw new Error("PegIn input scriptSig must be empty.");
-  if (r.ins[0].witness.length !== 0)
+  if (n.ins[0].witness.length !== 0)
     throw new Error("PegIn input witness must be empty before signing.");
-  if (r.outs.length !== s)
+  if (n.outs.length !== ee)
     throw new Error(
-      `PegIn tx has ${r.outs.length} output(s), expected exactly ${s} for vaultCoreVersion ${o} (vault + depositor claim${i ? " + P2A anchor" : ""}).`
+      `PegIn tx has ${n.outs.length} output(s), expected exactly ${ee} for vaultCoreVersion ${o} (vault + depositor claim + P2A anchor).`
     );
-  const l = t.prePeginParams.pegInAmounts[t.htlcVout];
-  if (e.vaultValue !== l)
+  const s = t.prePeginParams.pegInAmounts[t.htlcVout];
+  if (e.vaultValue !== s)
     throw new Error(
-      `PegIn vault output value ${e.vaultValue} does not match the requested peg-in amount ${l} for HTLC ${t.htlcVout}; refusing to sign a vault that locks a different amount than requested.`
+      `PegIn vault output value ${e.vaultValue} does not match the requested peg-in amount ${s} for HTLC ${t.htlcVout}; refusing to sign a vault that locks a different amount than requested.`
     );
-  const d = r.outs[0];
-  if (BigInt(d.value) !== e.vaultValue)
+  const u = n.outs[0];
+  if (BigInt(u.value) !== e.vaultValue)
     throw new Error(
-      `Encoded PegIn vault output value ${d.value} does not match the WASM-reported vaultValue ${e.vaultValue}.`
+      `Encoded PegIn vault output value ${u.value} does not match the WASM-reported vaultValue ${e.vaultValue}.`
     );
-  const a = je(
+  const c = Je(
     t.prePeginParams,
     t.timelockPegin
   ).toString("hex");
-  if (f(e.vaultScriptPubKey).toLowerCase() !== a)
+  if (f(e.vaultScriptPubKey).toLowerCase() !== c)
     throw new Error(
-      `WASM-reported PegIn vaultScriptPubKey ${e.vaultScriptPubKey} does not match the independently derived payout scriptPubKey ${a}.`
+      `WASM-reported PegIn vaultScriptPubKey ${e.vaultScriptPubKey} does not match the independently derived payout scriptPubKey ${c}.`
     );
-  const P = d.script.toString("hex");
-  if (P !== a)
+  const p = u.script.toString("hex");
+  if (p !== c)
     throw new Error(
-      `Encoded PegIn vault output scriptPubKey ${P} does not match the independently derived payout scriptPubKey ${a}.`
+      `Encoded PegIn vault output scriptPubKey ${p} does not match the independently derived payout scriptPubKey ${c}.`
     );
-  const p = r.getId();
-  if (p !== f(e.txid).toLowerCase())
+  const l = n.getId();
+  if (l !== f(e.txid).toLowerCase())
     throw new Error(
-      `Encoded PegIn txid ${p} does not match the WASM-reported txid ${e.txid}.`
+      `Encoded PegIn txid ${l} does not match the WASM-reported txid ${e.txid}.`
     );
-  const v = await ye(
+  const h = await Se(
     o,
     t.prePeginParams.numLocalChallengers,
     t.prePeginParams.universalChallengerPubkeys.length,
     t.prePeginParams.councilQuorum,
     t.prePeginParams.councilSize,
     t.prePeginParams.feeRate
-  ), w = r.outs[ot];
-  if (BigInt(w.value) !== v)
+  ), d = n.outs[nt];
+  if (BigInt(d.value) !== h)
     throw new Error(
-      `Encoded PegIn depositor-claim output value ${w.value} does not match the independently computed claim value ${v} for vaultCoreVersion ${o}.`
+      `Encoded PegIn depositor-claim output value ${d.value} does not match the independently computed claim value ${h} for vaultCoreVersion ${o}.`
     );
-  const g = rt(
+  const P = it(
     t.prePeginParams.depositorPubkey
   );
-  if (!w.script.equals(g))
+  if (!d.script.equals(P))
     throw new Error(
-      `Encoded PegIn depositor-claim output scriptPubKey ${w.script.toString("hex")} does not pay to the depositor's claim script (expected ${g.toString("hex")}).`
+      `Encoded PegIn depositor-claim output scriptPubKey ${d.script.toString("hex")} does not pay to the depositor's claim script (expected ${P.toString("hex")}).`
     );
 }
 async function ct(e) {
-  const t = await Ve(
+  const t = await Ke(
     {
       txGraphVersion: e.vaultCoreVersion,
       depositor: e.depositor,
@@ -552,77 +555,77 @@ async function ct(e) {
     payoutControlBlock: t.payoutControlBlock
   };
 }
-const ce = 253, at = 254, lt = 65535, ht = 4294967295, dt = "TapLeaf", pt = "TapBranch", Pt = "TapTweak", T = 33, O = 32, ae = 128, ft = 1, gt = 254, wt = c.from([81, 32]);
+const he = 253, at = 254, lt = 65535, ht = 4294967295, dt = "TapLeaf", pt = "TapBranch", Pt = "TapTweak", T = 33, O = 32, de = 128, ft = 1, gt = 254, wt = a.from([81, 32]);
 function vt(e) {
-  if (e < ce)
-    return c.from([e]);
+  if (e < he)
+    return a.from([e]);
   if (e <= lt) {
-    const t = c.alloc(2);
-    return t.writeUInt16LE(e), c.concat([c.from([ce]), t]);
+    const t = a.alloc(2);
+    return t.writeUInt16LE(e), a.concat([a.from([he]), t]);
   }
   if (e <= ht) {
-    const t = c.alloc(4);
-    return t.writeUInt32LE(e), c.concat([c.from([at]), t]);
+    const t = a.alloc(4);
+    return t.writeUInt32LE(e), a.concat([a.from([at]), t]);
   }
   throw new Error(`Script too large to encode as CompactSize: ${e} bytes`);
 }
-function ke(e, t) {
-  const o = c.concat([
-    c.from([e]),
+function _e(e, t) {
+  const o = a.concat([
+    a.from([e]),
     vt(t.length),
-    c.from(t)
+    a.from(t)
   ]);
   return U.taggedHash(dt, o);
 }
 function Et(e) {
-  const { leafVersion: t, script: o, controlBlock: n } = e, i = n.length - T;
-  if (i < 0 || i % O !== 0 || i / O > ae)
+  const { leafVersion: t, script: o, controlBlock: n } = e, r = n.length - T;
+  if (r < 0 || r % O !== 0 || r / O > de)
     throw new Error(
-      `Malformed Taproot control block: length ${n.length} must be ${T} + 32*m with 0 <= m <= ${ae}`
+      `Malformed Taproot control block: length ${n.length} must be ${T} + 32*m with 0 <= m <= ${de}`
     );
-  const s = n[0] & gt;
-  if (s !== t)
+  const i = n[0] & gt;
+  if (i !== t)
     throw new Error(
-      `Taproot control block leaf version 0x${s.toString(16)} does not match the tapLeafScript leaf version 0x${t.toString(16)}`
+      `Taproot control block leaf version 0x${i.toString(16)} does not match the tapLeafScript leaf version 0x${t.toString(16)}`
     );
-  const r = c.from(
+  const s = a.from(
     n.subarray(1, T)
   );
-  let u = ke(t, o);
-  for (let a = T; a < n.length; a += O) {
-    const P = c.from(
-      n.subarray(a, a + O)
+  let u = _e(t, o);
+  for (let h = T; h < n.length; h += O) {
+    const d = a.from(
+      n.subarray(h, h + O)
     );
     u = U.taggedHash(
       pt,
-      c.compare(u, P) <= 0 ? c.concat([u, P]) : c.concat([P, u])
+      a.compare(u, d) <= 0 ? a.concat([u, d]) : a.concat([d, u])
     );
   }
-  const h = U.taggedHash(
+  const c = U.taggedHash(
     Pt,
-    c.concat([r, u])
-  ), l = Ce.xOnlyPointAddTweak(r, h);
-  if (l === null)
+    a.concat([s, u])
+  ), p = ke.xOnlyPointAddTweak(s, c);
+  if (p === null)
     throw new Error(
       "Taproot control block does not yield a valid output key (tweak is off-curve)"
     );
-  const d = n[0] & ft;
-  if (l.parity !== d)
+  const l = n[0] & ft;
+  if (p.parity !== l)
     throw new Error(
-      `Taproot output key parity ${l.parity} contradicts the control block's parity bit ${d}`
+      `Taproot output key parity ${p.parity} contradicts the control block's parity bit ${l}`
     );
-  return c.concat([
+  return a.concat([
     wt,
-    c.from(l.xOnlyPubkey)
+    a.from(p.xOnlyPubkey)
   ]);
 }
-const yt = 256, mt = 1500, le = 256, he = 0xffffffffn, $t = 500, St = 55, xt = 34;
+const yt = 256, mt = 1500, pe = 256, Pe = 0xffffffffn, $t = 500, St = 55, xt = 34;
 function Ct(e) {
-  if (typeof e.protocolFeeRate != "bigint" || e.protocolFeeRate <= 0n || e.protocolFeeRate > he)
+  if (typeof e.protocolFeeRate != "bigint" || e.protocolFeeRate <= 0n || e.protocolFeeRate > Pe)
     throw new Error(
-      `protocolFeeRate must be in [1, ${he}] sat/vB, got ${e.protocolFeeRate}`
+      `protocolFeeRate must be in [1, ${Pe}] sat/vB, got ${e.protocolFeeRate}`
     );
-  for (const [t, o, n, i] of [
+  for (const [t, o, n, r] of [
     [
       "keepers",
       e.numVaultKeepers,
@@ -638,43 +641,43 @@ function Ct(e) {
   ])
     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})` : ""}.`
+        `Participant count for ${t} (${o}) is outside the supported range [1, ${n}]${o > n ? ` (${r})` : ""}.`
       );
-  if (!Number.isInteger(e.councilSize) || e.councilSize < 1 || e.councilSize > le)
+  if (!Number.isInteger(e.councilSize) || e.councilSize < 1 || e.councilSize > pe)
     throw new Error(
-      `councilSize must be an integer in [1, ${le}], got ${e.councilSize}`
+      `councilSize must be an integer in [1, ${pe}], got ${e.councilSize}`
     );
 }
 async function bt(e, t) {
-  const { implicitFeeSats: o, out0Len: n, out1Len: i } = t, s = e.numVaultKeepers + e.numUniversalChallengers, r = BigInt(o), u = Math.max(0, n - xt), h = $t + St * s + u, l = e.protocolFeeRate * BigInt(h);
-  if (r > l)
+  const { implicitFeeSats: o, out0Len: n, out1Len: r } = t, i = e.numVaultKeepers + e.numUniversalChallengers, s = BigInt(o), u = Math.max(0, n - xt), c = $t + St * i + u, p = e.protocolFeeRate * BigInt(c);
+  if (s > p)
     throw new Error(
-      `Payout implicit fee ${o} sats exceeds the safety cap of ${l} sats (${e.protocolFeeRate} sat/vB x ${h} vB for ${s} participants); refusing to sign payout.`
+      `Payout implicit fee ${o} sats exceeds the safety cap of ${p} sats (${e.protocolFeeRate} sat/vB x ${c} vB for ${i} participants); refusing to sign payout.`
     );
-  const d = await Le(
+  const l = await He(
     e.vaultCoreVersion,
     e.numVaultKeepers,
     e.numUniversalChallengers,
     e.numVaultKeepers,
     e.councilSize,
     n,
-    i,
+    r,
     e.protocolFeeRate
   );
-  if (r < d)
+  if (s < l)
     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.`
+      `Payout implicit fee ${o} sats is below the floor of ${l} sats (the smallest fee any known vault-provider build produces for this shape); refusing to sign payout.`
     );
 }
-const kt = 22, _t = 34, It = 34, At = 25, Tt = 23;
+const kt = 22, It = 34, _t = 34, At = 25, Tt = 23;
 function Ot(e) {
   return e.length === kt * 2 && e.startsWith("0014");
 }
 function Vt(e) {
-  return e.length === _t * 2 && e.startsWith("0020");
+  return e.length === It * 2 && e.startsWith("0020");
 }
 function Lt(e) {
-  return e.length === It * 2 && e.startsWith("5120");
+  return e.length === _t * 2 && e.startsWith("5120");
 }
 function Rt(e) {
   return e.length === At * 2 && e.startsWith("76a914") && e.endsWith("88ac");
@@ -682,7 +685,7 @@ function Rt(e) {
 function Kt(e) {
   return e.length === Tt * 2 && e.startsWith("a914") && e.endsWith("87");
 }
-function de(e, t) {
+function fe(e, t) {
   const o = f(e).toLowerCase();
   if (o.length === 0)
     throw new Error(`${t} is empty`);
@@ -697,7 +700,7 @@ function de(e, t) {
       `${t} is not a standard scriptPubKey (expected P2TR, P2WPKH, P2WSH, P2PKH, or P2SH; got ${o.length / 2} bytes: ${o})`
     );
 }
-const pe = 3;
+const ge = 3;
 async function Jt(e) {
   const t = {
     vaultCoreVersion: e.vaultCoreVersion,
@@ -707,59 +710,59 @@ async function Jt(e) {
     protocolFeeRate: e.protocolFeeRate
   };
   Ct(t);
-  const o = k.fromHex(f(e.payoutTxHex)), n = k.fromHex(f(e.peginTxHex)), i = k.fromHex(f(e.assertTxHex));
-  if (o.ins.length !== j)
+  const o = k.fromHex(f(e.payoutTxHex)), n = k.fromHex(f(e.peginTxHex)), r = k.fromHex(f(e.assertTxHex));
+  if (o.ins.length !== te)
     throw new Error(
-      `Payout transaction must have exactly ${j} inputs, got ${o.ins.length}`
+      `Payout transaction must have exactly ${te} inputs, got ${o.ins.length}`
     );
-  if (o.version !== J)
+  if (o.version !== oe)
     throw new Error(
-      `Payout transaction version ${o.version} must be ${J}; refusing to sign payout.`
+      `Payout transaction version ${o.version} must be ${oe}; refusing to sign payout.`
     );
-  if (o.locktime !== ee)
+  if (o.locktime !== ne)
     throw new Error(
-      `Payout transaction locktime ${o.locktime} must be ${ee}; refusing to sign payout.`
+      `Payout transaction locktime ${o.locktime} must be ${ne}; refusing to sign payout.`
     );
-  const s = Pe(
+  const i = we(
     o.ins[0],
     0,
     n,
     "PegIn",
-    We
+    Xe
   );
   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 r = Pe(
+  const s = we(
     o.ins[1],
     1,
-    i,
+    r,
     "Assert",
-    xe
+    be
   );
   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 } = Ut(
+  const { out0Len: u, out1Len: c } = Ut(
     o,
-    s.value,
+    i.value,
     e
-  ), l = s.value + r.value;
-  let d = 0;
-  for (const v of o.outs) d += v.value;
-  if (d > l)
+  ), p = i.value + s.value;
+  let l = 0;
+  for (const E of o.outs) l += E.value;
+  if (l > p)
     throw new Error(
-      `Payout outputs (${d} sats) exceed inputs (${l} sats); invalid transaction.`
+      `Payout outputs (${l} sats) exceed inputs (${p} sats); invalid transaction.`
     );
-  const a = l - d;
+  const h = p - l;
   await bt(t, {
-    implicitFeeSats: a,
+    implicitFeeSats: h,
     out0Len: u,
-    out1Len: h
+    out1Len: c
   });
-  const P = await ct({
+  const d = await ct({
     vaultCoreVersion: e.vaultCoreVersion,
     depositor: e.depositorBtcPubkey,
     vaultProvider: e.vaultProviderBtcPubkey,
@@ -767,22 +770,22 @@ async function Jt(e) {
     universalChallengers: e.universalChallengerBtcPubkeys,
     timelockPegin: e.timelockPegin,
     network: e.network
-  }), p = await Ht(e, r);
+  }), P = await Ht(e, s);
   return {
     psbtHex: Nt(
       o,
+      i,
       s,
-      r,
-      P,
-      p
+      d,
+      P
     )
   };
 }
 async function Ht(e, t) {
-  const { payoutScript: o, payoutControlBlock: n } = await Re({
+  const { payoutScript: o, payoutControlBlock: n } = await Ne({
     txGraphVersion: e.vaultCoreVersion,
     claimer: f(e.claimerBtcPubkey).toLowerCase(),
-    localChallengers: ze({
+    localChallengers: Ye({
       claimerBtcPubkey: e.claimerBtcPubkey,
       depositorBtcPubkey: e.depositorBtcPubkey,
       vaultProviderBtcPubkey: e.vaultProviderBtcPubkey,
@@ -796,40 +799,40 @@ async function Ht(e, t) {
       (u) => f(u).toLowerCase()
     ),
     councilQuorum: e.councilQuorum
-  }), i = C(o), s = C(n), r = Et({
+  }), r = C(o), i = C(n), s = Et({
     leafVersion: y,
-    script: i,
-    controlBlock: s
+    script: r,
+    controlBlock: i
   });
-  if (!t.script.equals(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 ${r.toString("hex")}, Assert:${xe} pays ${t.script.toString("hex")}; refusing to sign payout.`
+      `Rebuilt Assert:0 payout leaf does not spend the Assert output being referenced: leaf binds to ${s.toString("hex")}, Assert:${be} pays ${t.script.toString("hex")}; refusing to sign payout.`
     );
-  return { script: i, controlBlock: s };
+  return { script: r, controlBlock: i };
 }
-function Pe(e, t, o, n, i) {
-  const s = M(
+function we(e, t, o, n, r) {
+  const i = M(
     new Uint8Array(e.hash).slice().reverse()
-  ), r = o.getId();
-  if (s !== r || e.index !== i)
+  ), s = o.getId();
+  if (i !== s || e.index !== r)
     throw new Error(
-      `Input ${t} must spend ${n}:${i}. Expected ${r}:${i}, got ${s}:${e.index}`
+      `Input ${t} must spend ${n}:${r}. Expected ${s}:${r}, got ${i}:${e.index}`
     );
   const u = o.outs[e.index];
   if (!u)
     throw new Error(
-      `Previous output not found for input ${t} (txid: ${s}, index: ${e.index})`
+      `Previous output not found for input ${t} (txid: ${i}, index: ${e.index})`
     );
   return u;
 }
-function Nt(e, t, o, n, i) {
-  const s = new H();
-  s.setVersion(e.version), s.setLocktime(e.locktime);
-  const [r, u] = e.ins;
-  s.addInput({
-    hash: r.hash,
-    index: r.index,
-    sequence: r.sequence,
+function Nt(e, t, o, n, r) {
+  const i = new H();
+  i.setVersion(e.version), i.setLocktime(e.locktime);
+  const [s, u] = e.ins;
+  i.addInput({
+    hash: s.hash,
+    index: s.index,
+    sequence: s.sequence,
     witnessUtxo: {
       script: t.script,
       value: t.value
@@ -837,15 +840,15 @@ function Nt(e, t, o, n, i) {
     tapLeafScript: [
       {
         leafVersion: y,
-        script: c.from(C(n.payoutScript)),
-        controlBlock: c.from(
+        script: a.from(C(n.payoutScript)),
+        controlBlock: a.from(
           C(n.payoutControlBlock)
         )
       }
     ],
-    tapInternalKey: c.from(_)
+    tapInternalKey: a.from(I)
     // sighashType omitted - defaults to SIGHASH_DEFAULT (0x00) for Taproot
-  }), s.addInput({
+  }), i.addInput({
     hash: u.hash,
     index: u.index,
     sequence: u.sequence,
@@ -856,109 +859,109 @@ function Nt(e, t, o, n, i) {
     tapLeafScript: [
       {
         leafVersion: y,
-        script: c.from(i.script),
-        controlBlock: c.from(i.controlBlock)
+        script: a.from(r.script),
+        controlBlock: a.from(r.controlBlock)
       }
     ],
-    tapInternalKey: c.from(_)
+    tapInternalKey: a.from(I)
   });
-  for (const h of e.outs)
-    s.addOutput({
-      script: h.script,
-      value: h.value
+  for (const c of e.outs)
+    i.addOutput({
+      script: c.script,
+      value: c.value
     });
-  return s.toHex();
+  return i.toHex();
 }
-function fe(e, t) {
+function ve(e, t) {
   const o = f(e).toLowerCase(), n = f(
-    $e(t)
+    xe(t)
   ).toLowerCase();
   return o === n ? [o] : [o, n];
 }
-function ge(e, t) {
-  return t.some((o) => e.equals(c.from(o, "hex")));
+function Ee(e, t) {
+  return t.some((o) => e.equals(a.from(o, "hex")));
 }
 function Ut(e, t, o) {
   const {
     claimerBtcPubkey: n,
-    vaultProviderBtcPubkey: i,
-    depositorBtcPubkey: s,
-    vaultKeeperBtcPubkeys: r,
+    vaultProviderBtcPubkey: r,
+    depositorBtcPubkey: i,
+    vaultKeeperBtcPubkeys: s,
     registeredPayoutScriptPubKey: u,
-    commissionBps: h,
-    vkClaimerPayoutScriptPubKeys: l,
-    vpCommissionScriptPubKey: d
+    commissionBps: c,
+    vkClaimerPayoutScriptPubKeys: p,
+    vpCommissionScriptPubKey: l
   } = o;
-  if (!Ue(u))
+  if (!Fe(u))
     throw new Error("Invalid registeredPayoutScriptPubKey: not valid hex");
-  const a = f(n).toLowerCase(), P = f(i).toLowerCase(), p = f(s).toLowerCase(), v = r.map(
+  const h = f(n).toLowerCase(), d = f(r).toLowerCase(), P = f(i).toLowerCase(), E = s.map(
     (S) => f(S).toLowerCase()
   );
-  let w, g, m;
-  if (a === P)
-    w = "vp-claimer", g = Ge, m = [f(u)];
-  else if (a === p)
-    w = "depositor-as-claimer", g = re, m = [f(u)];
-  else if (v.includes(a)) {
-    w = "vk-claimer", g = re;
-    const S = l[a];
+  let v, g, m;
+  if (h === d)
+    v = "vp-claimer", g = ze, m = [f(u)];
+  else if (h === P)
+    v = "depositor-as-claimer", g = ue, m = [f(u)];
+  else if (E.includes(h)) {
+    v = "vk-claimer", g = ue;
+    const S = p[h];
     if (S === void 0)
       throw new Error(
-        `No registered payout script resolved for vault keeper claimer ${a}`
+        `No registered payout script resolved for vault keeper claimer ${h}`
       );
-    de(
+    fe(
       S,
-      `Vault keeper payout script for claimer ${a}`
-    ), m = fe(S, a);
+      `Vault keeper payout script for claimer ${h}`
+    ), m = ve(S, h);
   } else
     throw new Error(
-      `Unknown claimer pubkey ${a}: not VP, depositor, or a registered vault keeper`
+      `Unknown claimer pubkey ${h}: 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}.`
+      `Payout transaction has ${e.outs.length} output(s), expected exactly ${g} for role ${v}.`
     );
-  if (!ge(e.outs[0].script, m))
+  if (!Ee(e.outs[0].script, m))
     throw new Error(
-      `Payout transaction output 0 does not pay the expected scriptPubKey for role ${w}. Accepted: ${m.join(" or ")}; got ${e.outs[0].script.toString("hex")}`
+      `Payout transaction output 0 does not pay the expected scriptPubKey for role ${v}. Accepted: ${m.join(" or ")}; got ${e.outs[0].script.toString("hex")}`
     );
   const N = g - 1;
-  if (e.outs[N].value !== te)
+  if (e.outs[N].value !== re)
     throw new Error(
-      `Payout CPFP anchor (out ${N}) value ${e.outs[N].value} sats must equal ${te} sats`
+      `Payout CPFP anchor (out ${N}) value ${e.outs[N].value} sats must equal ${re} sats`
     );
-  if (w === "vp-claimer") {
-    de(
-      d,
+  if (v === "vp-claimer") {
+    fe(
+      l,
       "Vault provider commission payout script"
     );
-    const S = fe(
-      d,
-      P
+    const S = ve(
+      l,
+      d
     );
-    if (!ge(e.outs[1].script, S))
+    if (!Ee(e.outs[1].script, S))
       throw new Error(
         `Payout transaction output 1 does not pay the vault provider's commission scriptPubKey. Accepted: ${S.join(" or ")}; got ${e.outs[1].script.toString("hex")}`
       );
-    if (!Number.isInteger(h) || h < 0 || h >= oe)
+    if (!Number.isInteger(c) || c < 0 || c >= ie)
       throw new Error(
-        `commissionBps must be an integer in [0, ${oe}), got ${h}`
+        `commissionBps must be an integer in [0, ${ie}), got ${c}`
       );
     const F = Math.floor(
-      t * h / Xe
+      t * c / Ge
     );
     if (e.outs[1].value > F)
       throw new Error(
-        `Payout VP commission (out 1) value ${e.outs[1].value} sats exceeds cap ${F} sats (${h} bps of peginValue=${t})`
+        `Payout VP commission (out 1) value ${e.outs[1].value} sats exceeds cap ${F} sats (${c} bps of peginValue=${t})`
       );
   }
   const A = e.outs[0].script.length;
-  if (A === 0 || A > ne)
+  if (A === 0 || A > se)
     throw new Error(
-      `Payout receiver scriptPubKey length ${A} is outside the contract's registration cap [1, ${ne}]; refusing to sign payout.`
+      `Payout receiver scriptPubKey length ${A} is outside the contract's registration cap [1, ${se}]; refusing to sign payout.`
     );
-  const _e = w === "vp-claimer" ? e.outs[1].script.length : void 0;
-  return { out0Len: A, out1Len: _e };
+  const Ae = v === "vp-claimer" ? e.outs[1].script.length : void 0;
+  return { out0Len: A, out1Len: Ae };
 }
 function eo(e, t, o = 0) {
   const n = H.fromHex(e);
@@ -966,29 +969,29 @@ function eo(e, t, o = 0) {
     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 s = C(t);
-    for (const r of i.tapScriptSig)
-      if (r.pubkey.equals(c.from(s)))
-        return we(r.signature, o);
+  const r = n.data.inputs[o];
+  if (r.tapScriptSig && r.tapScriptSig.length > 0) {
+    const i = C(t);
+    for (const s of r.tapScriptSig)
+      if (s.pubkey.equals(a.from(i)))
+        return ye(s.signature, o);
     throw new Error(
       `No signature found for depositor pubkey: ${t} at input ${o}`
     );
   }
-  if (i.finalScriptWitness && i.finalScriptWitness.length > 0) {
-    const s = Bt(i.finalScriptWitness);
-    if (s.length !== pe)
+  if (r.finalScriptWitness && r.finalScriptWitness.length > 0) {
+    const i = Bt(r.finalScriptWitness);
+    if (i.length !== ge)
       throw new Error(
-        `Unexpected finalized witness stack size at input ${o}: expected ${pe} items (signature, script, controlBlock), got ${s.length}`
+        `Unexpected finalized witness stack size at input ${o}: expected ${ge} items (signature, script, controlBlock), got ${i.length}`
       );
-    return we(s[0], o);
+    return ye(i[0], o);
   }
   throw new Error(
     `No tapScriptSig or finalScriptWitness found in signed PSBT at input ${o}`
   );
 }
-function we(e, t) {
+function ye(e, t) {
   if (e.length === 64)
     return M(new Uint8Array(e));
   throw e.length === 65 ? new Error(
@@ -1000,21 +1003,21 @@ function we(e, t) {
 function Bt(e) {
   const t = [];
   let o = 0;
-  const n = (r) => {
-    if (o + r > e.length)
+  const n = (s) => {
+    if (o + s > e.length)
       throw new Error(
-        `Malformed witness data: need ${r} byte(s) at offset ${o}, only ${e.length - o} remaining`
+        `Malformed witness data: need ${s} byte(s) at offset ${o}, only ${e.length - o} remaining`
       );
-  }, i = () => {
+  }, r = () => {
     n(1);
-    const r = e[o++];
-    if (r < 253) return r;
-    if (r === 253) {
+    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 (r === 254) {
+    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;
@@ -1022,14 +1025,14 @@ function Bt(e) {
     throw new Error(
       `Malformed witness data: 8-byte varint (0xff) not supported at offset ${o - 1}`
     );
-  }, s = i();
-  for (let r = 0; r < s; r++) {
-    const u = i();
-    n(u), t.push(c.from(e.subarray(o, o + u))), o += u;
+  }, i = r();
+  for (let s = 0; s < i; s++) {
+    const u = r();
+    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 ${s} item(s)`
+      `Malformed witness data: ${e.length - o} trailing byte(s) after parsing ${i} item(s)`
     );
   return t;
 }
@@ -1040,7 +1043,7 @@ class $ extends Error {
     ), this.name = "PsbtSubstitutionError";
   }
 }
-function ve(e, t) {
+function me(e, t) {
   try {
     return H.fromHex(t);
   } catch (o) {
@@ -1052,12 +1055,12 @@ const Mt = 8;
 function B(e) {
   return `${e.toString("hex").slice(0, Mt)}…`;
 }
-function Ee(e) {
-  const t = c.from(e).reverse();
+function $e(e) {
+  const t = a.from(e).reverse();
   return B(t);
 }
 function to(e) {
-  const t = ve("requested", e.requestedPsbtHex), o = ve("returned", e.returnedPsbtHex);
+  const t = me("requested", e.requestedPsbtHex), o = me("returned", e.returnedPsbtHex);
   if (t.version !== o.version)
     throw new $(
       `tx version differs (requested=${t.version}, returned=${o.version})`
@@ -1075,109 +1078,109 @@ function to(e) {
       `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], s = o.txInputs[n];
-    if (!i.hash.equals(s.hash))
+    const r = t.txInputs[n], i = o.txInputs[n];
+    if (!r.hash.equals(i.hash))
       throw new $(
-        `input ${n} prevout txid differs (requested=${Ee(i.hash)}, returned=${Ee(s.hash)})`
+        `input ${n} prevout txid differs (requested=${$e(r.hash)}, returned=${$e(i.hash)})`
       );
-    if (i.index !== s.index)
+    if (r.index !== i.index)
       throw new $(
-        `input ${n} prevout vout differs (requested=${i.index}, returned=${s.index})`
+        `input ${n} prevout vout differs (requested=${r.index}, returned=${i.index})`
       );
-    if (i.sequence !== s.sequence)
+    if (r.sequence !== i.sequence)
       throw new $(
-        `input ${n} sequence differs (requested=${i.sequence}, returned=${s.sequence})`
+        `input ${n} sequence differs (requested=${r.sequence}, returned=${i.sequence})`
       );
   }
   for (let n = 0; n < t.txOutputs.length; n++) {
-    const i = t.txOutputs[n], s = o.txOutputs[n];
-    if (!i.script.equals(s.script))
+    const r = t.txOutputs[n], i = o.txOutputs[n];
+    if (!r.script.equals(i.script))
       throw new $(
-        `output ${n} scriptPubKey differs (requested=${B(i.script)}, returned=${B(s.script)})`
+        `output ${n} scriptPubKey differs (requested=${B(r.script)}, returned=${B(i.script)})`
       );
-    if (i.value !== s.value)
+    if (r.value !== i.value)
       throw new $(
-        `output ${n} value differs (requested=${i.value}, returned=${s.value})`
+        `output ${n} value differs (requested=${r.value}, returned=${i.value})`
       );
   }
 }
 function oo(e) {
-  const { requestedPsbtHex: t, signatureHex: o, signerXOnlyPubkeyHex: n, inputIndex: i } = e, s = f(o);
-  if (s.length !== W)
+  const { requestedPsbtHex: t, signatureHex: o, signerXOnlyPubkeyHex: n, inputIndex: r } = e, i = f(o);
+  if (i.length !== W)
     throw new Error(
-      `Schnorr signature for input ${i} must be ${W} hex chars (64 bytes), got ${s.length}.`
+      `Schnorr signature for input ${r} must be ${W} hex chars (64 bytes), got ${i.length}.`
     );
-  const r = f(n);
-  if (r.length !== ie)
+  const s = f(n);
+  if (s.length !== ce)
     throw new Error(
-      `Signer x-only pubkey for input ${i} must be ${ie} hex chars (32 bytes), got ${r.length}.`
+      `Signer x-only pubkey for input ${r} must be ${ce} hex chars (32 bytes), got ${s.length}.`
     );
   const u = H.fromHex(t);
-  if (i < 0 || i >= u.data.inputs.length)
+  if (r < 0 || r >= u.data.inputs.length)
     throw new Error(
-      `Input index ${i} out of range (${u.data.inputs.length} inputs).`
+      `Input index ${r} out of range (${u.data.inputs.length} inputs).`
     );
-  const h = [], l = [];
+  const c = [], p = [];
   for (let g = 0; g < u.data.inputs.length; g++) {
     const m = u.data.inputs[g].witnessUtxo;
     if (!m)
       throw new Error(
         `Cannot verify signature: input ${g} of the requested PSBT has no witnessUtxo (required to recompute the Taproot sighash).`
       );
-    h.push(m.script), l.push(m.value);
+    c.push(m.script), p.push(m.value);
   }
-  const d = u.data.inputs[i].tapLeafScript;
-  if (!d || d.length !== 1)
+  const l = u.data.inputs[r].tapLeafScript;
+  if (!l || l.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}.`
+      `Cannot verify signature: input ${r} of the requested PSBT must have exactly one tapLeafScript, got ${(l == null ? void 0 : l.length) ?? 0}.`
     );
-  const a = d[0];
-  if (a.leafVersion !== y)
+  const h = l[0];
+  if (h.leafVersion !== y)
     throw new Error(
-      `Cannot verify signature: input ${i} tapLeafScript has leaf version 0x${a.leafVersion.toString(16)}, expected 0x${y.toString(16)}.`
+      `Cannot verify signature: input ${r} tapLeafScript has leaf version 0x${h.leafVersion.toString(16)}, expected 0x${y.toString(16)}.`
     );
-  const P = ke(a.leafVersion, a.script), p = new k();
-  p.version = u.version, p.locktime = u.locktime;
+  const d = _e(h.leafVersion, h.script), P = new k();
+  P.version = u.version, P.locktime = u.locktime;
   for (const g of u.txInputs)
-    p.addInput(g.hash, g.index, g.sequence);
+    P.addInput(g.hash, g.index, g.sequence);
   for (const g of u.txOutputs)
-    p.addOutput(g.script, g.value);
-  const v = p.hashForWitnessV1(
-    i,
-    h,
-    l,
+    P.addOutput(g.script, g.value);
+  const E = P.hashForWitnessV1(
+    r,
+    c,
+    p,
     k.SIGHASH_DEFAULT,
-    P
+    d
   );
-  if (!Ce.verifySchnorr(
-    v,
-    C(r),
-    C(s)
+  if (!ke.verifySchnorr(
+    E,
+    C(s),
+    C(i)
   ))
     throw new Error(
-      `Schnorr signature for input ${i} (signer ${r}) 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.`
+      `Schnorr signature for input ${r} (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 {
   V as H,
-  ot as P,
+  nt as P,
   Zt as a,
   jt as b,
   Qt as c,
-  nt as d,
-  rt as e,
+  rt as d,
+  it as e,
   Jt as f,
   eo as g,
   $ as h,
   to as i,
   oo as j,
   ct as k,
-  Ze as l,
-  ke as m,
-  be as n,
-  et as o,
+  je as l,
+  _e as m,
+  Ie as n,
+  tt as o,
   Ct as p,
   bt as q,
-  ze as r
+  Ye as r
 };
-//# sourceMappingURL=verifyScriptPathSchnorrSignature-owu3BfyT.js.map
+//# sourceMappingURL=verifyScriptPathSchnorrSignature-D-fdi-sG.js.map