@babylonlabs-io/ts-sdk 0.79.1 → 1.1.0

package/dist/{verifyScriptPathSchnorrSignature-D_epga4j.js → verifyScriptPathSchnorrSignature-CpjSTfMj.js}

@@ -1,24 +1,24 @@
-import { script as _, opcodes as E, payments as R, Transaction as b, crypto as H, Psbt as V } from "bitcoinjs-lib";
-import { computeMinClaimValue as Ee, peginP2aAnchorOutput as ye, computeMinPeginFee as _e, tapInternalPubkey as k, buildPeginTxFromPrePegin as ke, createPrePeginTransaction as Ie, validatePeginP2aAnchor as Ae, createPayoutConnector as Te, computePayoutFeeFloor as Oe, getAssertPayoutScriptInfo as Ve } from "./tbv/core/wasm/index.js";
-import { c as M, p as Le, d as Re } from "./fundPeginTransaction-CwhRbCQC.js";
-import { p as He, s as f, d as $e, m as Ke, T as y, h as x, u as U, j as Ne, S as F } from "./bitcoin-C-TuHb-v.js";
-import { s as Ue } from "./secp256k1-D-H9jmd7.js";
+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 { s as Be } from "./secp256k1-D-H9jmd7.js";
 import { Buffer as c } from "buffer";
-import { P as q, c as W, d as X, e as G, f as Be, g as z, h as Me, i as Fe, j as Y, k as D, l as Q, m as Z, n as j, o as J, M as ee, b as te, p as qe, A as me, B as We, V as Xe, N as oe } from "./constants-D5vORbQE.js";
-import * as Se from "@bitcoin-js/tiny-secp256k1-asmjs";
-import { X as ne } from "./validation-OSC0xTHB.js";
-function C(e) {
-  return He(e).toLowerCase();
+import { P as X, c as G, d as z, e as Y, f as Me, g as D, h as Fe, i as qe, j as Q, k as Z, l as j, m as J, n as ee, o as te, M as oe, b as ne, p as We, A as xe, B as Xe, V as Ge, N as re } from "./constants-D5vORbQE.js";
+import * as Ce from "@bitcoin-js/tiny-secp256k1-asmjs";
+import { X as ie } from "./validation-OSC0xTHB.js";
+function b(e) {
+  return Ne(e).toLowerCase();
 }
-function Yt(e, t, o) {
+function Qt(e, t, o) {
   const n = /* @__PURE__ */ new Set();
-  n.add(C(e));
+  n.add(b(e));
   for (const i of t)
-    n.add(C(i));
-  return n.delete(C(o)), n.size;
+    n.add(b(i));
+  return n.delete(b(o)), n.size;
 }
-function Ge(e) {
-  const t = C(e.claimerBtcPubkey), o = C(e.depositorBtcPubkey), n = e.vaultKeeperBtcPubkeys.map(C);
+function ze(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)
@@ -32,7 +32,7 @@ function Ge(e) {
     return r;
   }
   const s = [
-    .../* @__PURE__ */ new Set([C(e.vaultProviderBtcPubkey), ...n])
+    .../* @__PURE__ */ new Set([b(e.vaultProviderBtcPubkey), ...n])
   ].sort().filter((r) => r !== t);
   if (s.length === 0)
     throw new Error(
@@ -40,15 +40,15 @@ function Ge(e) {
     );
   return s;
 }
-const ze = 32, Ye = 65535, De = 2;
-function K(e, t) {
+const Ye = 32, De = 65535, Qe = 2;
+function I(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 {
-    Ue.Point.fromBytes(
+    Be.Point.fromBytes(
       c.concat([
-        c.from([De]),
+        c.from([Qe]),
         c.from(o, "hex")
       ])
     );
@@ -57,15 +57,15 @@ function K(e, t) {
   }
   return o;
 }
-function re(e, t) {
+function R(e, t) {
   if (e.length === 0)
     throw new Error(`${t} must not be empty.`);
-  const o = e.map((n, i) => K(n, `${t}[${i}]`)).sort();
+  const o = e.map((n, i) => I(n, `${t}[${i}]`)).sort();
   if (new Set(o).size !== o.length)
     throw new Error(`${t} must not contain duplicate keys.`);
   return o;
 }
-function ie(e, t) {
+function K(e, t) {
   const o = [];
   return e.forEach((n, i) => {
     o.push(
@@ -73,33 +73,33 @@ function ie(e, t) {
       i === 0 ? E.OP_CHECKSIG : E.OP_CHECKSIGADD
     );
   }), o.push(
-    _.number.encode(e.length),
+    x.number.encode(e.length),
     t ? E.OP_NUMEQUALVERIFY : E.OP_NUMEQUAL
   ), o;
 }
-function Qe(e, t) {
+function Ze(e, t) {
   var g;
-  Ke();
-  const o = K(
+  Se();
+  const o = I(
     e.depositorPubkey,
     "depositorPubkey"
-  ), n = K(
+  ), n = I(
     e.vaultProviderPubkey,
     "vaultProviderPubkey"
-  ), i = re(
+  ), i = R(
     e.vaultKeeperPubkeys,
     "vaultKeeperPubkeys"
-  ), s = re(
+  ), s = R(
     e.universalChallengerPubkeys,
     "universalChallengerPubkeys"
   ), r = f(t).toLowerCase();
   if (!/^[0-9a-f]{64}$/.test(r))
     throw new Error("hashlock must be 32 bytes.");
-  if (!Number.isInteger(e.timelockRefund) || e.timelockRefund < 1 || e.timelockRefund > Ye)
+  if (!Number.isInteger(e.timelockRefund) || e.timelockRefund < 1 || e.timelockRefund > De)
     throw new Error("timelockRefund must be an integer from 1 to 65535.");
-  const u = _.compile([
+  const u = x.compile([
     E.OP_SIZE,
-    _.number.encode(ze),
+    x.number.encode(Ye),
     E.OP_EQUALVERIFY,
     E.OP_SHA256,
     c.from(r, "hex"),
@@ -108,43 +108,74 @@ function Qe(e, t) {
     E.OP_CHECKSIGVERIFY,
     c.from(n, "hex"),
     E.OP_CHECKSIGVERIFY,
-    ...ie(i, !0),
-    ...ie(s, !1)
-  ]), h = _.compile([
+    ...K(i, !0),
+    ...K(s, !1)
+  ]), h = x.compile([
     c.from(o, "hex"),
     E.OP_CHECKSIGVERIFY,
-    _.number.encode(e.timelockRefund),
+    x.number.encode(e.timelockRefund),
     E.OP_CHECKSEQUENCEVERIFY
-  ]), a = [
+  ]), l = [
     { output: u, version: y },
     { output: h, version: y }
-  ], { hash: d, output: l, witness: P } = R.p2tr({
-    internalPubkey: c.from(k),
-    scriptTree: a,
+  ], { hash: d, output: a, witness: P } = L.p2tr({
+    internalPubkey: c.from(_),
+    scriptTree: l,
     redeem: {
       output: u,
       redeemVersion: y
     }
-  }), p = P == null ? void 0 : P[P.length - 1], v = R.p2tr({
-    internalPubkey: c.from(k),
-    scriptTree: a,
+  }), p = P == null ? void 0 : P[P.length - 1], v = L.p2tr({
+    internalPubkey: c.from(_),
+    scriptTree: l,
     redeem: {
       output: h,
       redeemVersion: y
     }
   }), w = (g = v.witness) == null ? void 0 : g[v.witness.length - 1];
-  if (!d || !l || !p || !w)
+  if (!d || !a || !p || !w)
     throw new Error("Failed to derive the expected Pre-PegIn HTLC output.");
   return {
     hashlockScript: u,
     hashlockControlBlock: p,
     refundScript: h,
     refundControlBlock: w,
-    scriptPubKey: l,
+    scriptPubKey: a,
     tapMerkleRoot: d
   };
 }
-async function Ze(e, t) {
+function je(e, t) {
+  Se();
+  const o = I(
+    e.depositorPubkey,
+    "depositorPubkey"
+  ), n = I(
+    e.vaultProviderPubkey,
+    "vaultProviderPubkey"
+  ), i = R(
+    e.vaultKeeperPubkeys,
+    "vaultKeeperPubkeys"
+  ), s = R(
+    e.universalChallengerPubkeys,
+    "universalChallengerPubkeys"
+  ), r = x.compile([
+    c.from(o, "hex"),
+    E.OP_CHECKSIGVERIFY,
+    c.from(n, "hex"),
+    E.OP_CHECKSIGVERIFY,
+    ...K(i, !0),
+    ...K(s, !0),
+    x.number.encode(t),
+    E.OP_CHECKSEQUENCEVERIFY
+  ]), { output: u } = L.p2tr({
+    internalPubkey: c.from(_),
+    scriptTree: { output: r, version: y }
+  });
+  if (!u)
+    throw new Error("Failed to derive the expected PegIn payout output.");
+  return u;
+}
+async function Je(e, t) {
   const o = t.pegInAmounts.length;
   if (t.hashlocks.length !== o)
     throw new Error(
@@ -162,7 +193,7 @@ async function Ze(e, t) {
     throw new Error(
       `WASM Pre-PegIn returned non-positive depositorClaimValue ${e.depositorClaimValue}; expected > 0.`
     );
-  const n = await Ee(
+  const n = await ye(
     // Must price the same graph version the builder constructed.
     t.vaultCoreVersion,
     t.numLocalChallengers,
@@ -175,133 +206,133 @@ async function Ze(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 ye(t.vaultCoreVersion), s = (i == null ? void 0 : i.value) ?? 0n, r = await _e(
+  const i = await me(t.vaultCoreVersion), s = (i == null ? void 0 : i.value) ?? 0n, r = await Ie(
     t.vaultCoreVersion,
     t.vaultKeeperPubkeys.length,
     t.universalChallengerPubkeys.length,
     t.minPeginFeeRate
-  ), u = r + s, h = t.minPeginFeeRate * M;
-  for (let a = 0; a < o; a++) {
-    const d = t.pegInAmounts[a], l = e.peginAmounts[a], P = e.htlcValues[a];
-    if (l !== d)
+  ), 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)
       throw new Error(
-        `WASM Pre-PegIn peginAmount[${a}] ${l} 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[${l}] ${a} does not match the requested amount ${d}; refusing to build a tx whose recorded amount differs from the depositor's request.`
       );
-    if (l <= 0n)
+    if (a <= 0n)
       throw new Error(
-        `WASM Pre-PegIn peginAmount[${a}] is non-positive (${l}); expected > 0.`
+        `WASM Pre-PegIn peginAmount[${l}] is non-positive (${a}); expected > 0.`
       );
     if (P <= 0n)
       throw new Error(
-        `WASM Pre-PegIn htlcValue[${a}] is non-positive (${P}); expected > 0.`
+        `WASM Pre-PegIn htlcValue[${l}] is non-positive (${P}); expected > 0.`
       );
-    const p = P - l - e.depositorClaimValue;
+    const p = P - a - e.depositorClaimValue;
     if (p <= 0n)
       throw new Error(
-        `WASM Pre-PegIn htlcValue[${a}] ${P} does not strictly cover peginAmount ${l} + depositorClaimValue ${e.depositorClaimValue} + a PegIn reserve (implied reserve ${p}).`
+        `WASM Pre-PegIn htlcValue[${l}] ${P} does not strictly cover peginAmount ${a} + depositorClaimValue ${e.depositorClaimValue} + a PegIn reserve (implied reserve ${p}).`
       );
     if (p > h)
       throw new Error(
-        `WASM Pre-PegIn implied reserve for HTLC[${a}] (${p} sat) exceeds the plausibility cap ${h} sat (minPeginFeeRate=${t.minPeginFeeRate} × ${M} vbytes); htlcValue ${P} appears grossly inflated.`
+        `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.`
       );
     if (p !== u)
       throw new Error(
-        `WASM Pre-PegIn htlcValue[${a}] ${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[${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}).`
       );
   }
   return r;
 }
-class O extends Error {
+class V extends Error {
   constructor(t) {
     super(t), this.name = "HtlcOutputMismatchError";
   }
 }
-function je(e, t, o) {
+function et(e, t, o) {
   if (e.length < t.length)
-    throw new O(
+    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])
-      throw new O(
+      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.`
       );
     const s = e[n].script.toString("hex").toLowerCase(), r = o[n].toLowerCase();
     if (s !== r)
-      throw new O(
+      throw new V(
         `Encoded Pre-PegIn HTLC output[${n}] scriptPubKey ${s} does not match the cross-checked htlcScriptPubKey ${r}.`
       );
   }
 }
-function Je(e, t, o, n, i, s, r) {
-  if (s !== q)
+function tt(e, t, o, n, i, s, r) {
+  if (s !== X)
     throw new Error(
-      `WASM Pre-PegIn transaction version ${s}; expected ${q}.`
+      `WASM Pre-PegIn transaction version ${s}; expected ${X}.`
     );
-  if (r !== W)
+  if (r !== G)
     throw new Error(
-      `WASM Pre-PegIn transaction locktime ${r}; expected ${W}.`
+      `WASM Pre-PegIn transaction locktime ${r}; expected ${G}.`
     );
-  if (t.length < X)
+  if (t.length < z)
     throw new Error(
-      `WASM Pre-PegIn output layout has ${t.length} HTLC output(s); expected at least ${X}.`
+      `WASM Pre-PegIn output layout has ${t.length} HTLC output(s); expected at least ${z}.`
     );
-  const u = t.length, h = u + +(i !== void 0), a = Le(
+  const u = t.length, h = u + +(i !== void 0), l = Ke(
     t.length,
     i !== void 0
   );
-  if (e.length !== a)
+  if (e.length !== l)
     throw new Error(
-      `WASM Pre-PegIn output layout has ${e.length} output(s); expected exactly ${a}.`
+      `WASM Pre-PegIn output layout has ${e.length} output(s); expected exactly ${l}.`
     );
-  je(e, t, o);
+  et(e, t, o);
   for (let p = 0; p < t.length; p++) {
-    const v = Qe(
+    const v = Ze(
       n,
       n.hashlocks[p]
     ).scriptPubKey;
     if (!e[p].script.equals(v))
-      throw new O(
+      throw new V(
         `Pre-PegIn HTLC output[${p}] does not match the independently derived scriptPubKey.`
       );
   }
   if (i !== void 0) {
     const p = e[u];
-    if (p.value !== G)
+    if (p.value !== Y)
       throw new Error(
-        `WASM Pre-PegIn auth output[${u}] value ${p.value} sat; expected exactly ${G} sat.`
+        `WASM Pre-PegIn auth output[${u}] value ${p.value} sat; expected exactly ${Y} sat.`
       );
-    const v = p.script.toString("hex").toLowerCase(), w = Be + i.toLowerCase();
+    const v = p.script.toString("hex").toLowerCase(), w = Me + i.toLowerCase();
     if (v !== w)
       throw new Error(
         `WASM Pre-PegIn auth output[${u}] scriptPubKey ${v}; expected ${w}.`
       );
   }
   const d = e[h];
-  if (d.value !== z)
+  if (d.value !== D)
     throw new Error(
-      `WASM Pre-PegIn CPFP output[${h}] value ${d.value} sat; expected exactly ${z} sat.`
+      `WASM Pre-PegIn CPFP output[${h}] value ${d.value} sat; expected exactly ${D} sat.`
     );
-  const l = d.script.toString("hex").toLowerCase(), P = f(
+  const a = d.script.toString("hex").toLowerCase(), P = f(
     $e(n.depositorPubkey)
   ).toLowerCase();
-  if (l !== P)
+  if (a !== P)
     throw new Error(
-      `WASM Pre-PegIn CPFP output[${h}] scriptPubKey ${l}; expected depositor BIP-86 script ${P}.`
+      `WASM Pre-PegIn CPFP output[${h}] scriptPubKey ${a}; expected depositor BIP-86 script ${P}.`
     );
 }
-const et = 1;
-function tt(e) {
+const ot = 1;
+function nt(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 = _.compile([
-    c.from(x(t)),
+  const o = x.compile([
+    c.from(C(t)),
     E.OP_CHECKSIG
-  ]), n = c.from(k), i = { output: o, redeemVersion: y }, { output: s, witness: r } = R.p2tr({
+  ]), n = c.from(_), i = { output: o, redeemVersion: y }, { output: s, witness: r } = L.p2tr({
     internalPubkey: n,
     scriptTree: { output: o },
     redeem: i
@@ -317,12 +348,12 @@ function tt(e) {
     );
   return { scriptPubKey: s, leafScript: o, controlBlock: u, internalKey: n };
 }
-function ot(e) {
-  return tt(e).scriptPubKey;
+function rt(e) {
+  return nt(e).scriptPubKey;
 }
-const se = 64, nt = /^[0-9a-fA-F]+$/;
-async function Dt(e) {
-  const t = xe(e.authAnchorHash), o = await Ie({
+const se = 64, it = /^[0-9a-fA-F]+$/, ue = 65535;
+async function Zt(e) {
+  const t = be(e.authAnchorHash), o = await Te({
     txGraphVersion: e.vaultCoreVersion,
     depositorPubkey: e.depositorPubkey,
     vaultProviderPubkey: e.vaultProviderPubkey,
@@ -338,8 +369,8 @@ async function Dt(e) {
     councilSize: e.councilSize,
     network: e.network,
     authAnchorHash: t
-  }), n = await Ze(o, e), i = Re(o.txHex);
-  Je(
+  }), n = await Je(o, e), i = He(o.txHex);
+  tt(
     i.outputs,
     o.htlcValues,
     o.htlcScriptPubKeys,
@@ -364,17 +395,21 @@ async function Dt(e) {
     minPeginFee: n
   };
 }
-function xe(e) {
+function be(e) {
   if (e === void 0) return;
   const t = e.startsWith("0x") || e.startsWith("0X") ? e.slice(2) : e;
-  if (t.length !== se || !nt.test(t))
+  if (t.length !== se || !it.test(t))
     throw new Error(
       `authAnchorHash must be 32-byte hex (${se} chars, no 0x prefix); got length ${t.length}`
     );
   return t.toLowerCase();
 }
-async function Qt(e) {
-  const t = await ke(
+async function jt(e) {
+  if (!Number.isInteger(e.timelockPegin) || e.timelockPegin < 1 || e.timelockPegin > ue)
+    throw new Error(
+      `PegIn timelock ${e.timelockPegin} must be a whole number of blocks from 1 to ${ue}.`
+    );
+  const t = await Ae(
     {
       txGraphVersion: e.prePeginParams.vaultCoreVersion,
       depositorPubkey: e.prePeginParams.depositorPubkey,
@@ -390,7 +425,7 @@ async function Qt(e) {
       councilQuorum: e.prePeginParams.councilQuorum,
       councilSize: e.prePeginParams.councilSize,
       network: e.prePeginParams.network,
-      authAnchorHash: xe(
+      authAnchorHash: be(
         e.prePeginParams.authAnchorHash
       )
     },
@@ -398,35 +433,35 @@ async function Qt(e) {
     e.fundedPrePeginTxHex,
     e.htlcVout
   );
-  return await it(t, e), {
+  return await ut(t, e), {
     txHex: t.txHex,
     txid: t.txid,
     vaultScriptPubKey: t.vaultScriptPubKey,
     vaultValue: t.vaultValue
   };
 }
-const rt = 2;
-async function it(e, t) {
-  const o = t.prePeginParams.vaultCoreVersion, n = o === 1 ? Me : o === 2 || o === 3 ? Fe : void 0;
+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 Ae(o, e.txHex);
-  const i = await ye(o), s = rt + (i ? 1 : 0), r = b.fromHex(f(e.txHex));
+  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)
     throw new Error(
       `PegIn tx version ${r.version} does not match vaultCoreVersion ${o}; expected ${n}.`
     );
-  if (r.locktime !== Y)
+  if (r.locktime !== Q)
     throw new Error(
-      `PegIn tx locktime ${r.locktime} does not match the canonical locktime ${Y}.`
+      `PegIn tx locktime ${r.locktime} does not match the canonical locktime ${Q}.`
     );
   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 u = b.fromHex(
+  const u = k.fromHex(
     f(t.fundedPrePeginTxHex)
-  ).getId(), h = U(
+  ).getId(), h = M(
     new Uint8Array(r.ins[0].hash).slice().reverse()
   );
   if (h !== u)
@@ -437,9 +472,9 @@ async function it(e, t) {
     throw new Error(
       `PegIn input spends Pre-PegIn output ${r.ins[0].index}, expected the requested HTLC vout ${t.htlcVout}.`
     );
-  if (r.ins[0].sequence !== D)
+  if (r.ins[0].sequence !== Z)
     throw new Error(
-      `PegIn input sequence ${r.ins[0].sequence} does not match the canonical sequence ${D}.`
+      `PegIn input sequence ${r.ins[0].sequence} does not match the canonical sequence ${Z}.`
     );
   if (r.ins[0].script.length !== 0)
     throw new Error("PegIn input scriptSig must be empty.");
@@ -449,41 +484,47 @@ async function it(e, t) {
     throw new Error(
       `PegIn tx has ${r.outs.length} output(s), expected exactly ${s} for vaultCoreVersion ${o} (vault + depositor claim${i ? " + P2A anchor" : ""}).`
     );
-  const a = t.prePeginParams.pegInAmounts[t.htlcVout];
-  if (e.vaultValue !== a)
+  const l = t.prePeginParams.pegInAmounts[t.htlcVout];
+  if (e.vaultValue !== l)
     throw new Error(
-      `PegIn vault output value ${e.vaultValue} does not match the requested peg-in amount ${a} 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 ${l} 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)
     throw new Error(
       `Encoded PegIn vault output value ${d.value} does not match the WASM-reported vaultValue ${e.vaultValue}.`
     );
-  const l = d.script.toString("hex"), P = f(
-    e.vaultScriptPubKey
-  ).toLowerCase();
-  if (l.toLowerCase() !== P)
+  const a = je(
+    t.prePeginParams,
+    t.timelockPegin
+  ).toString("hex");
+  if (f(e.vaultScriptPubKey).toLowerCase() !== a)
     throw new Error(
-      `Encoded PegIn vault output scriptPubKey ${l} does not match the WASM-reported vaultScriptPubKey ${e.vaultScriptPubKey}.`
+      `WASM-reported PegIn vaultScriptPubKey ${e.vaultScriptPubKey} does not match the independently derived payout scriptPubKey ${a}.`
+    );
+  const P = d.script.toString("hex");
+  if (P !== a)
+    throw new Error(
+      `Encoded PegIn vault output scriptPubKey ${P} does not match the independently derived payout scriptPubKey ${a}.`
     );
   const p = r.getId();
   if (p !== f(e.txid).toLowerCase())
     throw new Error(
       `Encoded PegIn txid ${p} does not match the WASM-reported txid ${e.txid}.`
     );
-  const v = await Ee(
+  const v = await ye(
     o,
     t.prePeginParams.numLocalChallengers,
     t.prePeginParams.universalChallengerPubkeys.length,
     t.prePeginParams.councilQuorum,
     t.prePeginParams.councilSize,
     t.prePeginParams.feeRate
-  ), w = r.outs[et];
+  ), w = r.outs[ot];
   if (BigInt(w.value) !== v)
     throw new Error(
       `Encoded PegIn depositor-claim output value ${w.value} does not match the independently computed claim value ${v} for vaultCoreVersion ${o}.`
     );
-  const g = ot(
+  const g = rt(
     t.prePeginParams.depositorPubkey
   );
   if (!w.script.equals(g))
@@ -491,8 +532,8 @@ async function it(e, t) {
       `Encoded PegIn depositor-claim output scriptPubKey ${w.script.toString("hex")} does not pay to the depositor's claim script (expected ${g.toString("hex")}).`
     );
 }
-async function st(e) {
-  const t = await Te(
+async function ct(e) {
+  const t = await Ve(
     {
       txGraphVersion: e.vaultCoreVersion,
       depositor: e.depositor,
@@ -511,87 +552,87 @@ async function st(e) {
     payoutControlBlock: t.payoutControlBlock
   };
 }
-const ue = 253, ut = 254, ct = 65535, at = 4294967295, lt = "TapLeaf", ht = "TapBranch", dt = "TapTweak", A = 33, T = 32, ce = 128, pt = 1, Pt = 254, ft = c.from([81, 32]);
-function gt(e) {
-  if (e < ue)
+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]);
+function vt(e) {
+  if (e < ce)
     return c.from([e]);
-  if (e <= ct) {
+  if (e <= lt) {
     const t = c.alloc(2);
-    return t.writeUInt16LE(e), c.concat([c.from([ue]), t]);
+    return t.writeUInt16LE(e), c.concat([c.from([ce]), t]);
   }
-  if (e <= at) {
+  if (e <= ht) {
     const t = c.alloc(4);
-    return t.writeUInt32LE(e), c.concat([c.from([ut]), t]);
+    return t.writeUInt32LE(e), c.concat([c.from([at]), t]);
   }
   throw new Error(`Script too large to encode as CompactSize: ${e} bytes`);
 }
-function Ce(e, t) {
+function ke(e, t) {
   const o = c.concat([
     c.from([e]),
-    gt(t.length),
+    vt(t.length),
     c.from(t)
   ]);
-  return H.taggedHash(lt, o);
+  return U.taggedHash(dt, o);
 }
-function wt(e) {
-  const { leafVersion: t, script: o, controlBlock: n } = e, i = n.length - A;
-  if (i < 0 || i % T !== 0 || i / T > ce)
+function Et(e) {
+  const { leafVersion: t, script: o, controlBlock: n } = e, i = n.length - T;
+  if (i < 0 || i % O !== 0 || i / O > ae)
     throw new Error(
-      `Malformed Taproot control block: length ${n.length} must be ${A} + 32*m with 0 <= m <= ${ce}`
+      `Malformed Taproot control block: length ${n.length} must be ${T} + 32*m with 0 <= m <= ${ae}`
     );
-  const s = n[0] & Pt;
+  const s = n[0] & gt;
   if (s !== t)
     throw new Error(
       `Taproot control block leaf version 0x${s.toString(16)} does not match the tapLeafScript leaf version 0x${t.toString(16)}`
     );
   const r = c.from(
-    n.subarray(1, A)
+    n.subarray(1, T)
   );
-  let u = Ce(t, o);
-  for (let l = A; l < n.length; l += T) {
+  let u = ke(t, o);
+  for (let a = T; a < n.length; a += O) {
     const P = c.from(
-      n.subarray(l, l + T)
+      n.subarray(a, a + O)
     );
-    u = H.taggedHash(
-      ht,
+    u = U.taggedHash(
+      pt,
       c.compare(u, P) <= 0 ? c.concat([u, P]) : c.concat([P, u])
     );
   }
-  const h = H.taggedHash(
-    dt,
+  const h = U.taggedHash(
+    Pt,
     c.concat([r, u])
-  ), a = Se.xOnlyPointAddTweak(r, h);
-  if (a === null)
+  ), l = Ce.xOnlyPointAddTweak(r, h);
+  if (l === null)
     throw new Error(
       "Taproot control block does not yield a valid output key (tweak is off-curve)"
     );
-  const d = n[0] & pt;
-  if (a.parity !== d)
+  const d = n[0] & ft;
+  if (l.parity !== d)
     throw new Error(
-      `Taproot output key parity ${a.parity} contradicts the control block's parity bit ${d}`
+      `Taproot output key parity ${l.parity} contradicts the control block's parity bit ${d}`
     );
   return c.concat([
-    ft,
-    c.from(a.xOnlyPubkey)
+    wt,
+    c.from(l.xOnlyPubkey)
   ]);
 }
-const vt = 256, Et = 1500, ae = 256, le = 0xffffffffn, yt = 500, $t = 55, mt = 34;
-function St(e) {
-  if (typeof e.protocolFeeRate != "bigint" || e.protocolFeeRate <= 0n || e.protocolFeeRate > le)
+const yt = 256, mt = 1500, le = 256, he = 0xffffffffn, $t = 500, St = 55, xt = 34;
+function Ct(e) {
+  if (typeof e.protocolFeeRate != "bigint" || e.protocolFeeRate <= 0n || e.protocolFeeRate > he)
     throw new Error(
-      `protocolFeeRate must be in [1, ${le}] sat/vB, got ${e.protocolFeeRate}`
+      `protocolFeeRate must be in [1, ${he}] sat/vB, got ${e.protocolFeeRate}`
     );
   for (const [t, o, n, i] of [
     [
       "keepers",
       e.numVaultKeepers,
-      vt,
+      yt,
       "fee-floor model limit"
     ],
     [
       "challengers",
       e.numUniversalChallengers,
-      Et,
+      mt,
       "protocol maximum"
     ]
   ])
@@ -599,18 +640,18 @@ function St(e) {
       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 > ae)
+  if (!Number.isInteger(e.councilSize) || e.councilSize < 1 || e.councilSize > le)
     throw new Error(
-      `councilSize must be an integer in [1, ${ae}], got ${e.councilSize}`
+      `councilSize must be an integer in [1, ${le}], got ${e.councilSize}`
     );
 }
-async function xt(e, t) {
-  const { implicitFeeSats: o, out0Len: n, out1Len: i } = t, s = e.numVaultKeepers + e.numUniversalChallengers, r = BigInt(o), u = Math.max(0, n - mt), h = yt + $t * s + u, a = e.protocolFeeRate * BigInt(h);
-  if (r > a)
+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)
     throw new Error(
-      `Payout implicit fee ${o} sats exceeds the safety cap of ${a} 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 ${l} sats (${e.protocolFeeRate} sat/vB x ${h} vB for ${s} participants); refusing to sign payout.`
     );
-  const d = await Oe(
+  const d = await Le(
     e.vaultCoreVersion,
     e.numVaultKeepers,
     e.numUniversalChallengers,
@@ -625,23 +666,23 @@ async function xt(e, t) {
       `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 Ct = 22, bt = 34, _t = 34, kt = 25, It = 23;
-function At(e) {
-  return e.length === Ct * 2 && e.startsWith("0014");
-}
-function Tt(e) {
-  return e.length === bt * 2 && e.startsWith("0020");
-}
+const kt = 22, _t = 34, It = 34, At = 25, Tt = 23;
 function Ot(e) {
-  return e.length === _t * 2 && e.startsWith("5120");
+  return e.length === kt * 2 && e.startsWith("0014");
 }
 function Vt(e) {
-  return e.length === kt * 2 && e.startsWith("76a914") && e.endsWith("88ac");
+  return e.length === _t * 2 && e.startsWith("0020");
 }
 function Lt(e) {
-  return e.length === It * 2 && e.startsWith("a914") && e.endsWith("87");
+  return e.length === It * 2 && e.startsWith("5120");
 }
-function he(e, t) {
+function Rt(e) {
+  return e.length === At * 2 && e.startsWith("76a914") && e.endsWith("88ac");
+}
+function Kt(e) {
+  return e.length === Tt * 2 && e.startsWith("a914") && e.endsWith("87");
+}
+function de(e, t) {
   const o = f(e).toLowerCase();
   if (o.length === 0)
     throw new Error(`${t} is empty`);
@@ -651,13 +692,13 @@ function he(e, t) {
     throw new Error(
       `${t} is an OP_RETURN output, which is provably unspendable`
     );
-  if (!Ot(o) && !At(o) && !Tt(o) && !Vt(o) && !Lt(o))
+  if (!Lt(o) && !Ot(o) && !Vt(o) && !Rt(o) && !Kt(o))
     throw new Error(
       `${t} is not a standard scriptPubKey (expected P2TR, P2WPKH, P2WSH, P2PKH, or P2SH; got ${o.length / 2} bytes: ${o})`
     );
 }
-const de = 3;
-async function Zt(e) {
+const pe = 3;
+async function Jt(e) {
   const t = {
     vaultCoreVersion: e.vaultCoreVersion,
     numVaultKeepers: e.vaultKeeperBtcPubkeys.length,
@@ -665,60 +706,60 @@ async function Zt(e) {
     councilSize: e.councilMembers.length,
     protocolFeeRate: e.protocolFeeRate
   };
-  St(t);
-  const o = b.fromHex(f(e.payoutTxHex)), n = b.fromHex(f(e.peginTxHex)), i = b.fromHex(f(e.assertTxHex));
-  if (o.ins.length !== Q)
+  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)
     throw new Error(
-      `Payout transaction must have exactly ${Q} inputs, got ${o.ins.length}`
+      `Payout transaction must have exactly ${j} inputs, got ${o.ins.length}`
     );
-  if (o.version !== Z)
+  if (o.version !== J)
     throw new Error(
-      `Payout transaction version ${o.version} must be ${Z}; refusing to sign payout.`
+      `Payout transaction version ${o.version} must be ${J}; refusing to sign payout.`
     );
-  if (o.locktime !== j)
+  if (o.locktime !== ee)
     throw new Error(
-      `Payout transaction locktime ${o.locktime} must be ${j}; refusing to sign payout.`
+      `Payout transaction locktime ${o.locktime} must be ${ee}; refusing to sign payout.`
     );
-  const s = pe(
+  const s = Pe(
     o.ins[0],
     0,
     n,
     "PegIn",
-    qe
+    We
   );
   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 r = Pe(
     o.ins[1],
     1,
     i,
     "Assert",
-    me
+    xe
   );
   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 } = Kt(
+  const { out0Len: u, out1Len: h } = Ut(
     o,
     s.value,
     e
-  ), a = s.value + r.value;
+  ), l = s.value + r.value;
   let d = 0;
   for (const v of o.outs) d += v.value;
-  if (d > a)
+  if (d > l)
     throw new Error(
-      `Payout outputs (${d} sats) exceed inputs (${a} sats); invalid transaction.`
+      `Payout outputs (${d} sats) exceed inputs (${l} sats); invalid transaction.`
     );
-  const l = a - d;
-  await xt(t, {
-    implicitFeeSats: l,
+  const a = l - d;
+  await bt(t, {
+    implicitFeeSats: a,
     out0Len: u,
     out1Len: h
   });
-  const P = await st({
+  const P = await ct({
     vaultCoreVersion: e.vaultCoreVersion,
     depositor: e.depositorBtcPubkey,
     vaultProvider: e.vaultProviderBtcPubkey,
@@ -726,9 +767,9 @@ async function Zt(e) {
     universalChallengers: e.universalChallengerBtcPubkeys,
     timelockPegin: e.timelockPegin,
     network: e.network
-  }), p = await Rt(e, r);
+  }), p = await Ht(e, r);
   return {
-    psbtHex: Ht(
+    psbtHex: Nt(
       o,
       s,
       r,
@@ -737,11 +778,11 @@ async function Zt(e) {
     )
   };
 }
-async function Rt(e, t) {
-  const { payoutScript: o, payoutControlBlock: n } = await Ve({
+async function Ht(e, t) {
+  const { payoutScript: o, payoutControlBlock: n } = await Re({
     txGraphVersion: e.vaultCoreVersion,
     claimer: f(e.claimerBtcPubkey).toLowerCase(),
-    localChallengers: Ge({
+    localChallengers: ze({
       claimerBtcPubkey: e.claimerBtcPubkey,
       depositorBtcPubkey: e.depositorBtcPubkey,
       vaultProviderBtcPubkey: e.vaultProviderBtcPubkey,
@@ -755,19 +796,19 @@ async function Rt(e, t) {
       (u) => f(u).toLowerCase()
     ),
     councilQuorum: e.councilQuorum
-  }), i = x(o), s = x(n), r = wt({
+  }), i = C(o), s = C(n), r = Et({
     leafVersion: y,
     script: i,
     controlBlock: s
   });
   if (!t.script.equals(r))
     throw new Error(
-      `Rebuilt Assert:0 payout leaf does not spend the Assert output being referenced: leaf binds to ${r.toString("hex")}, Assert:${me} 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 ${r.toString("hex")}, Assert:${xe} pays ${t.script.toString("hex")}; refusing to sign payout.`
     );
   return { script: i, controlBlock: s };
 }
-function pe(e, t, o, n, i) {
-  const s = U(
+function Pe(e, t, o, n, i) {
+  const s = M(
     new Uint8Array(e.hash).slice().reverse()
   ), r = o.getId();
   if (s !== r || e.index !== i)
@@ -781,8 +822,8 @@ function pe(e, t, o, n, i) {
     );
   return u;
 }
-function Ht(e, t, o, n, i) {
-  const s = new V();
+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({
@@ -796,13 +837,13 @@ function Ht(e, t, o, n, i) {
     tapLeafScript: [
       {
         leafVersion: y,
-        script: c.from(x(n.payoutScript)),
+        script: c.from(C(n.payoutScript)),
         controlBlock: c.from(
-          x(n.payoutControlBlock)
+          C(n.payoutControlBlock)
         )
       }
     ],
-    tapInternalKey: c.from(k)
+    tapInternalKey: c.from(_)
     // sighashType omitted - defaults to SIGHASH_DEFAULT (0x00) for Taproot
   }), s.addInput({
     hash: u.hash,
@@ -819,7 +860,7 @@ function Ht(e, t, o, n, i) {
         controlBlock: c.from(i.controlBlock)
       }
     ],
-    tapInternalKey: c.from(k)
+    tapInternalKey: c.from(_)
   });
   for (const h of e.outs)
     s.addOutput({
@@ -828,16 +869,16 @@ function Ht(e, t, o, n, i) {
     });
   return s.toHex();
 }
-function Pe(e, t) {
+function fe(e, t) {
   const o = f(e).toLowerCase(), n = f(
     $e(t)
   ).toLowerCase();
   return o === n ? [o] : [o, n];
 }
-function fe(e, t) {
+function ge(e, t) {
   return t.some((o) => e.equals(c.from(o, "hex")));
 }
-function Kt(e, t, o) {
+function Ut(e, t, o) {
   const {
     claimerBtcPubkey: n,
     vaultProviderBtcPubkey: i,
@@ -845,118 +886,118 @@ function Kt(e, t, o) {
     vaultKeeperBtcPubkeys: r,
     registeredPayoutScriptPubKey: u,
     commissionBps: h,
-    vkClaimerPayoutScriptPubKeys: a,
+    vkClaimerPayoutScriptPubKeys: l,
     vpCommissionScriptPubKey: d
   } = o;
-  if (!Ne(u))
+  if (!Ue(u))
     throw new Error("Invalid registeredPayoutScriptPubKey: not valid hex");
-  const l = f(n).toLowerCase(), P = f(i).toLowerCase(), p = f(s).toLowerCase(), v = r.map(
+  const a = f(n).toLowerCase(), P = f(i).toLowerCase(), p = f(s).toLowerCase(), v = r.map(
     (S) => f(S).toLowerCase()
   );
-  let w, g, $;
-  if (l === P)
-    w = "vp-claimer", g = Xe, $ = [f(u)];
-  else if (l === p)
-    w = "depositor-as-claimer", g = oe, $ = [f(u)];
-  else if (v.includes(l)) {
-    w = "vk-claimer", g = oe;
-    const S = a[l];
+  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];
     if (S === void 0)
       throw new Error(
-        `No registered payout script resolved for vault keeper claimer ${l}`
+        `No registered payout script resolved for vault keeper claimer ${a}`
       );
-    he(
+    de(
       S,
-      `Vault keeper payout script for claimer ${l}`
-    ), $ = Pe(S, l);
+      `Vault keeper payout script for claimer ${a}`
+    ), m = fe(S, a);
   } else
     throw new Error(
-      `Unknown claimer pubkey ${l}: not VP, depositor, or a registered vault keeper`
+      `Unknown claimer pubkey ${a}: 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 (!fe(e.outs[0].script, $))
+  if (!ge(e.outs[0].script, m))
     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")}`
+      `Payout transaction output 0 does not pay the expected scriptPubKey for role ${w}. Accepted: ${m.join(" or ")}; got ${e.outs[0].script.toString("hex")}`
     );
-  const L = g - 1;
-  if (e.outs[L].value !== J)
+  const N = g - 1;
+  if (e.outs[N].value !== te)
     throw new Error(
-      `Payout CPFP anchor (out ${L}) value ${e.outs[L].value} sats must equal ${J} sats`
+      `Payout CPFP anchor (out ${N}) value ${e.outs[N].value} sats must equal ${te} sats`
     );
   if (w === "vp-claimer") {
-    he(
+    de(
       d,
       "Vault provider commission payout script"
     );
-    const S = Pe(
+    const S = fe(
       d,
       P
     );
-    if (!fe(e.outs[1].script, S))
+    if (!ge(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 >= ee)
+    if (!Number.isInteger(h) || h < 0 || h >= oe)
       throw new Error(
-        `commissionBps must be an integer in [0, ${ee}), got ${h}`
+        `commissionBps must be an integer in [0, ${oe}), got ${h}`
       );
-    const B = Math.floor(
-      t * h / We
+    const F = Math.floor(
+      t * h / Xe
     );
-    if (e.outs[1].value > B)
+    if (e.outs[1].value > F)
       throw new Error(
-        `Payout VP commission (out 1) value ${e.outs[1].value} sats exceeds cap ${B} sats (${h} bps of peginValue=${t})`
+        `Payout VP commission (out 1) value ${e.outs[1].value} sats exceeds cap ${F} sats (${h} bps of peginValue=${t})`
       );
   }
-  const I = e.outs[0].script.length;
-  if (I === 0 || I > te)
+  const A = e.outs[0].script.length;
+  if (A === 0 || A > ne)
     throw new Error(
-      `Payout receiver scriptPubKey length ${I} is outside the contract's registration cap [1, ${te}]; refusing to sign payout.`
+      `Payout receiver scriptPubKey length ${A} is outside the contract's registration cap [1, ${ne}]; refusing to sign payout.`
     );
-  const be = w === "vp-claimer" ? e.outs[1].script.length : void 0;
-  return { out0Len: I, out1Len: be };
+  const _e = w === "vp-claimer" ? e.outs[1].script.length : void 0;
+  return { out0Len: A, out1Len: _e };
 }
-function jt(e, t, o = 0) {
-  const n = V.fromHex(e);
+function eo(e, t, o = 0) {
+  const n = H.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 s = x(t);
+    const s = C(t);
     for (const r of i.tapScriptSig)
       if (r.pubkey.equals(c.from(s)))
-        return ge(r.signature, o);
+        return we(r.signature, o);
     throw new Error(
       `No signature found for depositor pubkey: ${t} at input ${o}`
     );
   }
   if (i.finalScriptWitness && i.finalScriptWitness.length > 0) {
-    const s = Nt(i.finalScriptWitness);
-    if (s.length !== de)
+    const s = Bt(i.finalScriptWitness);
+    if (s.length !== pe)
       throw new Error(
-        `Unexpected finalized witness stack size at input ${o}: expected ${de} items (signature, script, controlBlock), got ${s.length}`
+        `Unexpected finalized witness stack size at input ${o}: expected ${pe} items (signature, script, controlBlock), got ${s.length}`
       );
-    return ge(s[0], o);
+    return we(s[0], o);
   }
   throw new Error(
     `No tapScriptSig or finalScriptWitness found in signed PSBT at input ${o}`
   );
 }
-function ge(e, t) {
+function we(e, t) {
   if (e.length === 64)
-    return U(new Uint8Array(e));
+    return M(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 Nt(e) {
+function Bt(e) {
   const t = [];
   let o = 0;
   const n = (r) => {
@@ -992,110 +1033,110 @@ function Nt(e) {
     );
   return t;
 }
-class m extends Error {
+class $ extends Error {
   constructor(t) {
     super(
       `Wallet returned a PSBT for a different transaction: ${t}`
     ), this.name = "PsbtSubstitutionError";
   }
 }
-function we(e, t) {
+function ve(e, t) {
   try {
-    return V.fromHex(t);
+    return H.fromHex(t);
   } catch (o) {
     const n = o instanceof Error ? o.message : String(o);
     throw new Error(`Failed to parse ${e} PSBT: ${n}`);
   }
 }
-const Ut = 8;
-function N(e) {
-  return `${e.toString("hex").slice(0, Ut)}…`;
+const Mt = 8;
+function B(e) {
+  return `${e.toString("hex").slice(0, Mt)}…`;
 }
-function ve(e) {
+function Ee(e) {
   const t = c.from(e).reverse();
-  return N(t);
+  return B(t);
 }
-function Jt(e) {
-  const t = we("requested", e.requestedPsbtHex), o = we("returned", e.returnedPsbtHex);
+function to(e) {
+  const t = ve("requested", e.requestedPsbtHex), o = ve("returned", e.returnedPsbtHex);
   if (t.version !== o.version)
-    throw new m(
+    throw new $(
       `tx version differs (requested=${t.version}, returned=${o.version})`
     );
   if (t.locktime !== o.locktime)
-    throw new m(
+    throw new $(
       `tx locktime differs (requested=${t.locktime}, returned=${o.locktime})`
     );
   if (t.txInputs.length !== o.txInputs.length)
-    throw new m(
+    throw new $(
       `input count differs (requested=${t.txInputs.length}, returned=${o.txInputs.length})`
     );
   if (t.txOutputs.length !== o.txOutputs.length)
-    throw new m(
+    throw new $(
       `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))
-      throw new m(
-        `input ${n} prevout txid differs (requested=${ve(i.hash)}, returned=${ve(s.hash)})`
+      throw new $(
+        `input ${n} prevout txid differs (requested=${Ee(i.hash)}, returned=${Ee(s.hash)})`
       );
     if (i.index !== s.index)
-      throw new m(
+      throw new $(
         `input ${n} prevout vout differs (requested=${i.index}, returned=${s.index})`
       );
     if (i.sequence !== s.sequence)
-      throw new m(
+      throw new $(
         `input ${n} sequence differs (requested=${i.sequence}, returned=${s.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))
-      throw new m(
-        `output ${n} scriptPubKey differs (requested=${N(i.script)}, returned=${N(s.script)})`
+      throw new $(
+        `output ${n} scriptPubKey differs (requested=${B(i.script)}, returned=${B(s.script)})`
       );
     if (i.value !== s.value)
-      throw new m(
+      throw new $(
         `output ${n} value differs (requested=${i.value}, returned=${s.value})`
       );
   }
 }
-function eo(e) {
+function oo(e) {
   const { requestedPsbtHex: t, signatureHex: o, signerXOnlyPubkeyHex: n, inputIndex: i } = e, s = f(o);
-  if (s.length !== F)
+  if (s.length !== W)
     throw new Error(
-      `Schnorr signature for input ${i} must be ${F} hex chars (64 bytes), got ${s.length}.`
+      `Schnorr signature for input ${i} must be ${W} hex chars (64 bytes), got ${s.length}.`
     );
   const r = f(n);
-  if (r.length !== ne)
+  if (r.length !== ie)
     throw new Error(
-      `Signer x-only pubkey for input ${i} must be ${ne} hex chars (32 bytes), got ${r.length}.`
+      `Signer x-only pubkey for input ${i} must be ${ie} hex chars (32 bytes), got ${r.length}.`
     );
-  const u = V.fromHex(t);
+  const u = H.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 = [], a = [];
+  const h = [], l = [];
   for (let g = 0; g < u.data.inputs.length; g++) {
-    const $ = u.data.inputs[g].witnessUtxo;
-    if (!$)
+    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($.script), a.push($.value);
+    h.push(m.script), l.push(m.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 !== y)
+  const a = d[0];
+  if (a.leafVersion !== y)
     throw new Error(
-      `Cannot verify signature: input ${i} tapLeafScript has leaf version 0x${l.leafVersion.toString(16)}, expected 0x${y.toString(16)}.`
+      `Cannot verify signature: input ${i} tapLeafScript has leaf version 0x${a.leafVersion.toString(16)}, expected 0x${y.toString(16)}.`
     );
-  const P = Ce(l.leafVersion, l.script), p = new b();
+  const P = ke(a.leafVersion, a.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);
@@ -1104,37 +1145,37 @@ function eo(e) {
   const v = p.hashForWitnessV1(
     i,
     h,
-    a,
-    b.SIGHASH_DEFAULT,
+    l,
+    k.SIGHASH_DEFAULT,
     P
   );
-  if (!Se.verifySchnorr(
+  if (!Ce.verifySchnorr(
     v,
-    x(r),
-    x(s)
+    C(r),
+    C(s)
   ))
     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.`
     );
 }
 export {
-  O as H,
-  et as P,
-  Dt as a,
-  Qt as b,
-  Yt as c,
-  tt as d,
-  ot as e,
-  Zt as f,
-  jt as g,
-  m as h,
-  Jt as i,
-  eo as j,
-  st as k,
-  Qe as l,
-  Ce as m,
-  xe as n,
-  je as o,
-  Ge as p
+  V as H,
+  ot as P,
+  Zt as a,
+  jt as b,
+  Qt as c,
+  nt as d,
+  rt 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,
+  ze as p
 };
-//# sourceMappingURL=verifyScriptPathSchnorrSignature-D_epga4j.js.map
+//# sourceMappingURL=verifyScriptPathSchnorrSignature-CpjSTfMj.js.map