@babylonlabs-io/ts-sdk 3.2.0 → 3.3.0

package/dist/{buildAndBroadcastReclaim-CcQ0b1be.js → buildAndBroadcastReclaim-CQANDXVJ.js}

@@ -1,58 +1,58 @@
-var Qt = Object.defineProperty;
-var Zt = (e, t, r) => t in e ? Qt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var z = (e, t, r) => Zt(e, typeof t != "symbol" ? t + "" : t, r);
+var Zt = Object.defineProperty;
+var er = (e, t, r) => t in e ? Zt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var W = (e, t, r) => er(e, typeof t != "symbol" ? t + "" : t, r);
 import { B as Be } from "./BTCVaultRegistry.abi-BzNTa_EU.js";
-import { e as Ie, s as b, i as er, u as Ve, c as _, v as tr, p as he, f as O } from "./bitcoin-C-TuHb-v.js";
-import { v as rr, s as vt, b as bt, P as or, d as sr } from "./PayoutManager-BZ212yml.js";
-import { verifyWatchtowerArtifacts as nr, buildClaimPsbt as ir, buildAssertClaimerPsbt as ar, buildPayoutClaimerPsbt as ur, buildWronglyChallengedPsbts as cr, buildPayoutDepositorPsbt as lr, finalizeClaimTx as dr, buildWatchtowerArtifacts as hr, extractTapScriptSig as mt, expandWotsSeed as pr, wotsKeypairFromSeed as gr, validateWotsKeypairAgainstGraph as fr, deriveVaultId as yr } from "./tbv/core/wasm/index.js";
-import { m as vr, d as Pt, k as br, a as _e, V as Fe, i as mr, g as Pr, f as wr, r as xr, h as Er } from "./registration-records-CKLAv3gw.js";
+import { e as Ie, s as b, i as tr, u as yt, c as _, v as rr, g as or, p as pe, f as N } from "./bitcoin-C-TuHb-v.js";
+import { v as sr, s as vt, b as bt, P as nr, d as ir } from "./PayoutManager-xEGvTbhL.js";
+import { verifyWatchtowerArtifacts as ar, buildClaimPsbt as ur, buildAssertClaimerPsbt as cr, buildPayoutClaimerPsbt as lr, buildWronglyChallengedPsbts as dr, buildPayoutDepositorPsbt as hr, finalizeClaimTx as pr, buildWatchtowerArtifacts as gr, extractTapScriptSig as mt, expandWotsSeed as fr, wotsKeypairFromSeed as yr, validateWotsKeypairAgainstGraph as vr, getChallengeAssertOutputScriptPubKey as br, deriveVaultId as mr } from "./tbv/core/wasm/index.js";
+import { m as Pr, d as Pt, k as wr, a as _e, V as Le, i as xr, g as Er, f as kr, r as $r, h as Cr } from "./registration-records-DJJC2NiO.js";
 import { Psbt as q, Transaction as S } from "bitcoinjs-lib";
-import { q as F, r as A, s as ee, C as Y, A as te, p as J, t as pe, l as Ue, N as Q, u as Re, m as qe, n as Xe, o as Ge, W as $r, D as ze } from "./constants-BeYquVd-.js";
-import { p as kr, q as Tr, r as wt, P as X, j as re, f as Cr, i as ie, g as ae } from "./verifyScriptPathSchnorrSignature-B3-VkvnK.js";
+import { z as F, E as A, F as re, G as Q, A as G, x as Z, H as ge, t as Me, y as ee, I as Ve, u as Fe, v as Ue, w as qe, W as Tr, D as Ge, C as Xe, J as _r, K as Sr, L as Ar } from "./constants-CvQZuxKv.js";
+import { p as Br, q as Ir, r as wt, P as X, j as oe, f as Vr, i as ae, g as ue } from "./verifyScriptPathSchnorrSignature-owu3BfyT.js";
 import { Buffer as H } from "buffer";
 import { C as xt, X as Et } from "./validation-OSC0xTHB.js";
-import { a as $t, c as ue } from "./signing-C1rR4tqs.js";
-import { d as kt } from "./deriveVaultRoot-BcvmER1E.js";
-import { O as je, d as _r } from "./types-C5jj3Cc-.js";
-import { zeroAddress as Sr, isAddress as Ar, isAddressEqual as Br } from "viem";
-import { v as We, D as R, c as Ir, b as Vr, R as Rr, d as Tt } from "./state-CFn1rT74.js";
-import { h as Ye, b as Kr, s as Hr, j as Nr } from "./sha2-YqVHJiFj.js";
-import { d as Or, c as Dr, b as Mr, f as Ct, e as Lr, a as Fr } from "./noPayout-B-vGXJ-V.js";
-import { a as Ur } from "./secp256k1-BuxBFUHm.js";
-import { c as qr } from "./btcTxHash-BRZ8_EZq.js";
-const Xr = /^0x[0-9a-fA-F]{64}$/, Gr = /^0x[0-9a-fA-F]{40}$/, zr = /^0x([0-9a-fA-F]{2})*$/;
-function fe(e, t) {
+import { a as kt, c as ce } from "./signing-C1rR4tqs.js";
+import { d as $t } from "./deriveVaultRoot-BcvmER1E.js";
+import { O as ze, d as Rr } from "./types-24A9Qoxb.js";
+import { zeroAddress as Kr, isAddress as Hr, isAddressEqual as Or } from "viem";
+import { v as je, D as R, c as Nr, b as Dr, R as Lr, d as Ct } from "./state-CFn1rT74.js";
+import { h as We, b as Mr, s as Fr, j as Ur } from "./sha2-YqVHJiFj.js";
+import { c as qr, g as Gr, h as Xr, i as zr, b as jr, f as Tt, e as Wr, a as Yr } from "./challengeAssert-B2otuf7y.js";
+import { a as Jr } from "./secp256k1-BuxBFUHm.js";
+import { c as Qr } from "./btcTxHash-BRZ8_EZq.js";
+const Zr = /^0x[0-9a-fA-F]{64}$/, eo = /^0x[0-9a-fA-F]{40}$/, to = /^0x([0-9a-fA-F]{2})*$/;
+function ye(e, t) {
   if (e.length !== 66)
     throw new Error(
       `${t} must be 32 bytes (66 hex chars with 0x prefix), got length ${e.length}`
     );
-  if (!Xr.test(e))
+  if (!Zr.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function jr(e, t) {
-  if (!Gr.test(e))
+function ro(e, t) {
+  if (!eo.test(e))
     throw new Error(
       `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
     );
 }
-function Wr(e, t) {
-  if (!zr.test(e))
+function oo(e, t) {
+  if (!to.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
 }
-function Ke(e) {
-  jr(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), fe(e.vaultId, "vaultId");
+function Re(e) {
+  ro(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), ye(e.vaultId, "vaultId");
   const t = Ie(e.secret);
-  if (fe(t, "secret"), e.hashlock !== void 0 && (fe(e.hashlock, "hashlock"), !rr(t, e.hashlock)))
+  if (ye(t, "secret"), e.hashlock !== void 0 && (ye(e.hashlock, "hashlock"), !sr(t, e.hashlock)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
   return t;
 }
-async function Js(e) {
+async function nn(e) {
   const {
     btcVaultRegistryAddress: t,
     vaultId: r,
@@ -62,23 +62,23 @@ async function Js(e) {
     signal: a
   } = e;
   a == null || a.throwIfAborted();
-  const i = Ke({
+  const i = Re({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
     hashlock: o
   });
-  return Wr(s, "activationMetadata"), n({
+  return oo(s, "activationMetadata"), n({
     address: t,
     abi: Be,
     functionName: "activateVaultWithSecret",
     args: [r, i, s]
   });
 }
-async function Qs(e) {
+async function an(e) {
   const { btcVaultRegistryAddress: t, vaultId: r, hashlock: o, writeContract: s, signal: n } = e;
   n == null || n.throwIfAborted();
-  const a = Ke({
+  const a = Re({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
@@ -91,11 +91,11 @@ async function Qs(e) {
     args: [r, a]
   });
 }
-async function Zs(e) {
+async function un(e) {
   const { btcVaultRegistryAddress: t, vaultId: r, hashlock: o, writeContract: s, signal: n } = e;
   if (n == null || n.throwIfAborted(), typeof o != "string")
     throw new Error("hashlock is required to claim an expired vault");
-  const a = Ke({
+  const a = Re({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
@@ -113,25 +113,25 @@ class K extends Error {
     super(t, r), this.name = "AssertBindingError";
   }
 }
-function ye(e, t) {
+function ve(e, t) {
   try {
     return q.fromBase64(t);
   } catch (r) {
     throw new K(`${e} PSBT cannot be parsed.`, { cause: r });
   }
 }
-function Yr(e, t, r) {
+function so(e, t, r) {
   const o = t.txInputs[r];
   if (!o)
     throw new K(`${e} PSBT has no input ${r}.`);
   return o.hash;
 }
-function Je(e) {
+function Ye(e) {
   return S.fromBuffer(
     e.data.globalMap.unsignedTx.toBuffer()
   ).getHash();
 }
-function ve(e, t, r, o, s, n) {
+function be(e, t, r, o, s, n) {
   const a = t.txInputs[r];
   if (!a)
     throw new K(`${e} PSBT has no input ${r}.`);
@@ -140,71 +140,71 @@ function ve(e, t, r, o, s, n) {
       `${e} input ${r} does not spend ${n}: the graph pairs this ${e} with a different transaction.`
     );
 }
-function Jr(e, t) {
+function no(e, t) {
   var s;
   const r = (s = e.data.inputs[F]) == null ? void 0 : s.witnessUtxo;
   if (r === void 0)
     throw new K(
       `Assert input ${F} carries no witnessUtxo, so the amount and script its signature commits to cannot be checked; refusing to sign assert.`
     );
-  const o = t.txOutputs[Y];
+  const o = t.txOutputs[Q];
   if (!o)
     throw new K(
-      `Claim PSBT has no output ${Y} for the Assert to spend; refusing to sign assert.`
+      `Claim PSBT has no output ${Q} for the Assert to spend; refusing to sign assert.`
     );
   if (r.value !== o.value)
     throw new K(
-      `Assert input ${F} declares a prevout of ${r.value} sats but the Claim's output ${Y} is worth ${o.value}; refusing to sign assert.`
+      `Assert input ${F} declares a prevout of ${r.value} sats but the Claim's output ${Q} is worth ${o.value}; refusing to sign assert.`
     );
   if (!r.script.equals(o.script))
     throw new K(
-      `Assert input ${F} declares a prevout script that is not the Claim's output ${Y} script; refusing to sign assert.`
+      `Assert input ${F} declares a prevout script that is not the Claim's output ${Q} script; refusing to sign assert.`
     );
 }
-function Qr(e) {
-  const t = ye("Claim", e.claimPsbtBase64), r = ye("Assert", e.assertPsbtBase64), o = ye("Payout", e.payoutClaimerPsbtBase64);
-  ve(
+function io(e) {
+  const t = ve("Claim", e.claimPsbtBase64), r = ve("Assert", e.assertPsbtBase64), o = ve("Payout", e.payoutClaimerPsbtBase64);
+  be(
     "Assert",
     r,
     F,
-    Je(t),
-    Y,
+    Ye(t),
+    Q,
     "Claim:0"
-  ), Jr(r, t), ve(
+  ), no(r, t), be(
     "Payout",
     o,
     A,
-    Je(r),
-    te,
+    Ye(r),
+    G,
     "Assert:0"
-  ), ve(
+  ), be(
     "Payout",
     o,
-    ee,
-    Yr("Claim", t, pe),
-    J,
+    re,
+    so("Claim", t, ge),
+    Z,
     "this vault's PegIn:0"
   );
 }
-function be(e, t) {
+function me(e, t) {
   try {
     return q.fromBase64(t);
   } catch (r) {
     throw new Error(`${e} PSBT cannot be parsed.`, { cause: r });
   }
 }
-function Qe(e, t, r, o) {
+function Je(e, t, r, o) {
   var a;
   const s = [
     {
-      inputIndex: ee,
+      inputIndex: re,
       expectedSats: r,
-      source: `the vault's PegIn output ${J}`
+      source: `the vault's PegIn output ${Z}`
     },
     {
       inputIndex: A,
       expectedSats: o.value,
-      source: `the Assert's output ${te}`
+      source: `the Assert's output ${G}`
     }
   ];
   for (const { inputIndex: i, expectedSats: u, source: l } of s) {
@@ -221,10 +221,10 @@ function Qe(e, t, r, o) {
   const n = t.data.inputs[A].witnessUtxo;
   if (!(n != null && n.script.equals(o.script)))
     throw new Error(
-      `${e} Payout input ${A} declares a prevout script that is not the Assert's output ${te} script; refusing to sign payout.`
+      `${e} Payout input ${A} declares a prevout script that is not the Assert's output ${G} script; refusing to sign payout.`
     );
 }
-async function Zr(e) {
+async function ao(e) {
   const { vault: t } = e, r = {
     vaultCoreVersion: t.vaultCoreVersion,
     numVaultKeepers: t.vaultKeeperBtcPubkeys.length,
@@ -232,114 +232,114 @@ async function Zr(e) {
     councilSize: t.councilSize,
     protocolFeeRate: t.protocolFeeRate
   };
-  kr(r);
-  const o = be("Claimer Payout", e.payoutClaimerPsbtBase64), s = be(
+  Br(r);
+  const o = me("Claimer Payout", e.payoutClaimerPsbtBase64), s = me(
     "Depositor Payout",
     e.payoutDepositorPsbtBase64
-  ), n = be("Assert", e.assertPsbtBase64);
+  ), n = me("Assert", e.assertPsbtBase64);
   if (!s.data.globalMap.unsignedTx.toBuffer().equals(o.data.globalMap.unsignedTx.toBuffer()))
     throw new Error(
       "Depositor and claimer Payout PSBTs describe different transactions; refusing to sign payout."
     );
-  const a = n.txOutputs[te];
+  const a = n.txOutputs[G];
   if (a === void 0)
     throw new Error(
-      `Assert transaction has no output ${te}; the Payout's implicit fee cannot be measured.`
+      `Assert transaction has no output ${G}; the Payout's implicit fee cannot be measured.`
     );
-  if (o.txInputs.length !== Ue)
+  if (o.txInputs.length !== Me)
     throw new Error(
-      `Payout transaction must have exactly ${Ue} inputs, got ${o.txInputs.length}`
+      `Payout transaction must have exactly ${Me} inputs, got ${o.txInputs.length}`
     );
-  const i = o.txInputs[ee].sequence;
+  const i = o.txInputs[re].sequence;
   if (i !== t.timelockPegin)
     throw new Error(
-      `Payout input ${ee} sequence ${i} must equal the PegIn CSV timelock ${t.timelockPegin}; refusing to sign payout.`
+      `Payout input ${re} sequence ${i} must equal the PegIn CSV timelock ${t.timelockPegin}; refusing to sign payout.`
     );
   const u = o.txInputs[A].sequence;
   if (u !== t.timelockAssert)
     throw new Error(
       `Payout input ${A} sequence ${u} must equal the Assert CSV timelock ${t.timelockAssert}; refusing to sign payout.`
     );
-  Qe(
+  Je(
     "Claimer",
     o,
     t.peginVaultOutputValueSats,
     a
-  ), Qe(
+  ), Je(
     "Depositor",
     s,
     t.peginVaultOutputValueSats,
     a
   );
   const l = t.peginVaultOutputValueSats + a.value, c = o.txOutputs;
-  if (c.length !== Q)
+  if (c.length !== ee)
     throw new Error(
-      `Payout transaction has ${c.length} output(s), expected exactly ${Q} for a depositor-as-claimer payout.`
+      `Payout transaction has ${c.length} output(s), expected exactly ${ee} for a depositor-as-claimer payout.`
     );
-  let d = 0;
-  for (const h of c) d += h.value;
-  if (d > l)
+  let h = 0;
+  for (const d of c) h += d.value;
+  if (h > l)
     throw new Error(
-      `Payout outputs (${d} sats) exceed inputs (${l} sats); invalid transaction.`
+      `Payout outputs (${h} sats) exceed inputs (${l} sats); invalid transaction.`
     );
-  await Tr(r, {
-    implicitFeeSats: l - d,
-    out0Len: c[Re].script.length,
+  await Ir(r, {
+    implicitFeeSats: l - h,
+    out0Len: c[Ve].script.length,
     out1Len: void 0
   });
 }
-class eo extends Error {
+class uo extends Error {
   constructor(t, r) {
     super(
       "Transaction graph's challenger set does not match the vault's (local ∪ universal)" + (t.length > 0 ? ` (missing: ${t.join(", ")})` : "") + (r.length > 0 ? ` (unexpected: ${r.join(", ")})` : "") + ". Refusing to sign an incomplete or padded challenger set."
     ), this.missing = t, this.unexpected = r, this.name = "ChallengerSetMismatchError";
   }
 }
-function to(e) {
+function co(e) {
   const t = wt({
     claimerBtcPubkey: e.depositorBtcPubkey,
     depositorBtcPubkey: e.depositorBtcPubkey,
     vaultProviderBtcPubkey: e.vaultProviderBtcPubkey,
     vaultKeeperBtcPubkeys: e.vaultKeeperBtcPubkeys
-  }), r = e.universalChallengerBtcPubkeys.map(Ze), o = t.filter((c) => r.includes(c));
+  }), r = e.universalChallengerBtcPubkeys.map(Qe), o = t.filter((c) => r.includes(c));
   if (o.length > 0)
     throw new Error(
       `Cannot check the challenger set: vault keepers and universal challengers overlap (${o.join(", ")}).`
     );
-  const s = e.graphChallengerPubkeys.map(Ze), n = new Set(s);
+  const s = e.graphChallengerPubkeys.map(Qe), n = new Set(s);
   if (n.size !== s.length)
     throw new Error(
       "Transaction graph lists the same challenger more than once."
     );
   const a = [...t, ...r], i = new Set(a), u = a.filter((c) => !n.has(c)), l = s.filter((c) => !i.has(c));
   if (u.length > 0 || l.length > 0)
-    throw new eo(u, l);
+    throw new uo(u, l);
 }
-function Ze(e) {
+function Qe(e) {
   return b(e).toLowerCase();
 }
-class ro extends Error {
+class lo extends Error {
   constructor(t, r) {
     super(
-      `Payout transaction output ${Re} pays ${r}, not the vault's registered payout script ${t}. Refusing to sign a payout to another destination.`
+      `Payout transaction output ${Ve} pays ${r}, not the vault's registered payout script ${t}. Refusing to sign a payout to another destination.`
     ), this.expectedScriptHex = t, this.actualScriptHex = r, this.name = "PayoutDestinationError";
   }
 }
-function oo(e) {
+function ho(e) {
   let t;
   try {
     t = q.fromBase64(e.payoutPsbtBase64);
   } catch (c) {
     throw new Error("Payout PSBT cannot be parsed.", { cause: c });
   }
-  const { version: r, locktime: o, outs: s } = so(t);
-  if (r !== qe || o !== Xe)
+  const { version: r, locktime: o, outs: s } = po(t);
+  if (r !== Fe || o !== Ue)
     throw new Error(
-      `Payout transaction has version ${r} and locktime ${o}, expected ${qe} and ${Xe}.`
+      `Payout transaction has version ${r} and locktime ${o}, expected ${Fe} and ${Ue}.`
     );
-  if (s.length !== Q)
+  if (s.length !== ee)
     throw new Error(
-      `Payout transaction has ${s.length} output(s), expected exactly ${Q} for a depositor-as-claimer payout.`
+      `Payout transaction has ${s.length} output(s), expected exactly ${ee} for a depositor-as-claimer payout.`
     );
   const n = b(
     e.registeredPayoutScriptPubKey
@@ -348,23 +348,23 @@ function oo(e) {
     throw new Error(
       "registeredPayoutScriptPubKey is empty; the vault's on-chain payout script is required to check the Payout destination."
     );
-  const a = s[Re].script.toString("hex").toLowerCase();
+  const a = s[Ve].script.toString("hex").toLowerCase();
   if (a !== n)
-    throw new ro(n, a);
-  const i = s[Q - 1];
-  if (i.value !== Ge)
+    throw new lo(n, a);
+  const i = s[ee - 1];
+  if (i.value !== qe)
     throw new Error(
-      `Payout CPFP anchor value ${i.value} sats must equal ${Ge} sats.`
+      `Payout CPFP anchor value ${i.value} sats must equal ${qe} sats.`
     );
   const u = b(
-    vr(b(e.depositorBtcPubkey).toLowerCase())
+    Pr(b(e.depositorBtcPubkey).toLowerCase())
   ), l = i.script.toString("hex").toLowerCase();
   if (l !== u)
     throw new Error(
       `Payout CPFP anchor pays ${l}, not the depositor's BIP-86 P2TR ${u}. Refusing to sign a payout whose fee-bump output is spendable by somebody else.`
     );
 }
-function so(e) {
+function po(e) {
   return {
     version: e.version,
     locktime: e.locktime,
@@ -374,28 +374,28 @@ function so(e) {
     }))
   };
 }
-class se extends Error {
+class ne extends Error {
   constructor(t) {
     super(t), this.name = "PayoutInputLeafError";
   }
 }
-function no(e) {
+function go(e) {
   const t = q.fromBase64(e.payoutDepositorPsbtBase64), r = q.fromBase64(e.payoutClaimerPsbtBase64), o = t.data.globalMap.unsignedTx.toBuffer(), s = r.data.globalMap.unsignedTx.toBuffer();
   if (!o.equals(s))
-    throw new se(
+    throw new ne(
       "Depositor and claimer Payout PSBTs describe different transactions; the graph is inconsistent."
     );
   const n = r.data.inputs[A], a = t.data.inputs[A];
   if (!n || !a)
-    throw new se(
+    throw new ne(
       "Payout PSBT has no Assert-connector input."
     );
   if (!n.tapLeafScript || n.tapLeafScript.length !== 1)
-    throw new se(
+    throw new ne(
       "Claimer Payout PSBT must carry exactly one leaf on the Assert-connector input."
     );
   if (a.tapLeafScript && a.tapLeafScript.length > 0)
-    throw new se(
+    throw new ne(
       "Depositor Payout PSBT already carries an Assert-connector leaf; refusing to overwrite it."
     );
   return t.updateInput(A, {
@@ -404,31 +404,31 @@ function no(e) {
     ...n.tapMerkleRoot ? { tapMerkleRoot: n.tapMerkleRoot } : {}
   }), t.toBase64();
 }
-class io extends Error {
+class fo extends Error {
   constructor(t, r, o) {
     super(
       `Transaction graph does not belong to vault ${t}: its Claim spends PegIn ${o}, which derives vault ${r}. Refusing to sign for a graph served for another vault.`
     ), this.expectedVaultId = t, this.derivedVaultId = r, this.peginTxid = o, this.name = "VaultIdBindingError";
   }
 }
-function ao(e) {
+function yo(e) {
   let t;
   try {
     t = q.fromBase64(e);
   } catch (o) {
     throw new Error("Claim PSBT cannot be parsed.", { cause: o });
   }
-  const r = t.txInputs[pe];
+  const r = t.txInputs[ge];
   if (!r)
     throw new Error("Claim PSBT carries no PegIn input to bind the vault to.");
   return _t(
     "Claim PSBT",
     t.txInputs.length,
     r.index
-  ), He(r.hash);
+  ), Ke(r.hash);
 }
-function uo(e) {
-  const t = e.ins[pe];
+function vo(e) {
+  const t = e.ins[ge];
   if (!t)
     throw new Error(
       "Artifacts file's claim_tx carries no PegIn input to bind the vault to."
@@ -437,7 +437,7 @@ function uo(e) {
     "Artifacts file's claim_tx",
     e.ins.length,
     t.index
-  ), He(t.hash);
+  ), Ke(t.hash);
 }
 function _t(e, t, r) {
   if (t !== 1 || r !== X)
@@ -446,29 +446,29 @@ function _t(e, t, r) {
     );
 }
 function St(e) {
-  const t = G(
+  const t = z(
     Pt(e.peginTxid, e.depositorEthAddress)
-  ), r = G(e.expectedVaultId);
+  ), r = z(e.expectedVaultId);
   if (t !== r)
-    throw new io(r, t, e.peginTxid);
+    throw new fo(r, t, e.peginTxid);
 }
-function G(e) {
+function z(e) {
   return `0x${(e.startsWith("0x") ? e.slice(2) : e).toLowerCase()}`;
 }
-function He(e) {
+function Ke(e) {
   return H.from(e).reverse().toString("hex");
 }
-function ce(e, t) {
+function le(e, t) {
   const r = b(e);
   if (!/^(?:[0-9a-fA-F]{2})+$/.test(r))
     throw new Error(`${t} must be non-empty, even-length hex.`);
   return r.toLowerCase();
 }
 function At(e) {
-  const t = ce(
+  const t = le(
     e.servedVerifyingKeyHex,
     "source.verifyingKeyHex"
-  ), r = ce(
+  ), r = le(
     e.trustedVerifyingKeyHex,
     "trustedVerifyingKeyHex"
   );
@@ -478,61 +478,61 @@ function At(e) {
   );
 }
 const U = 3;
-class co extends Error {
+class bo extends Error {
   constructor(t, r) {
     super(
       `Artifacts belong to vault ${r}, not ${t}. Select the artifacts file saved for this vault.`
     ), this.expectedVaultId = t, this.actualVaultId = r, this.name = "ArtifactsVaultMismatchError";
   }
 }
-const lo = /^(?:[0-9a-fA-F]{2})+$/;
-function ho(e) {
-  const t = fo(e, "babe_sessions"), r = Object.keys(t);
+const mo = /^(?:[0-9a-fA-F]{2})+$/;
+function Po(e) {
+  const t = Eo(e, "babe_sessions"), r = Object.keys(t);
   if (r.length === 0)
     return { joined: !1 };
   for (const [o, s] of Object.entries(t)) {
     const n = typeof s == "object" && s !== null ? s.decryptor_artifacts_hex : void 0;
-    if (typeof n != "string" || !lo.test(n))
+    if (typeof n != "string" || !mo.test(n))
       throw new Error(
         `Artifacts file is missing a usable "babe_sessions": the entry for ${o} carries no non-empty hex "decryptor_artifacts_hex".`
       );
   }
   return { joined: !0, challengerPubkeys: r };
 }
-function po(e) {
+function wo(e) {
   let t;
   try {
     t = JSON.parse(e);
   } catch (a) {
     throw new Error("Artifacts file is not valid JSON.", { cause: a });
   }
-  const r = me(t.vault_id, "vault_id"), o = go(me(t.claim_tx, "claim_tx")), s = Pe(
+  const r = Pe(t.vault_id, "vault_id"), o = xo(Pe(t.claim_tx, "claim_tx")), s = we(
     t.prover_circuit_version,
     "prover_circuit_version"
   ), n = t.claimable_event_block_number === void 0 ? 0n : BigInt(
-    Pe(
+    we(
       t.claimable_event_block_number,
       "claimable_event_block_number"
     )
   );
   return {
-    vaultCoreVersion: t.vault_core_version === void 0 ? void 0 : Pe(t.vault_core_version, "vault_core_version"),
+    vaultCoreVersion: t.vault_core_version === void 0 ? void 0 : we(t.vault_core_version, "vault_core_version"),
     vaultId: r,
     claimTxid: o.getId(),
-    peginTxid: uo(o),
+    peginTxid: vo(o),
     proverCircuitVersion: s,
     claimableEventBlockNumber: n,
     // Required: btc-vault's builder always writes it
     // (`delegated_claim.rs:874` @ b534ff9e), so an absent one is not a file
     // this SDK or the CLI produced.
-    verifyingKeyHex: me(t.verifying_key, "verifying_key"),
-    babeSessions: ho(t.babe_sessions)
+    verifyingKeyHex: Pe(t.verifying_key, "verifying_key"),
+    babeSessions: Po(t.babe_sessions)
   };
 }
-async function en(e) {
-  const t = po(e.artifactsJson), r = G(e.expectedVaultId), o = G(t.vaultId);
+async function cn(e) {
+  const t = wo(e.artifactsJson), r = z(e.expectedVaultId), o = z(t.vaultId);
   if (r !== o)
-    throw new co(r, o);
+    throw new bo(r, o);
   St({
     peginTxid: t.peginTxid,
     depositorEthAddress: e.depositorEthAddress,
@@ -555,10 +555,10 @@ async function en(e) {
     throw new Error(
       `Artifacts record prover circuit version ${t.proverCircuitVersion} but the vault's stamped params say ${e.expectedProverCircuitVersion}; a proof for the wrong circuit fails at start-claim, so refusing the file.`
     );
-  const n = ce(
+  const n = le(
     t.verifyingKeyHex,
     'Artifacts file "verifying_key"'
-  ), a = ce(
+  ), a = le(
     e.trustedVerifyingKeyHex,
     "trustedVerifyingKeyHex"
   );
@@ -566,9 +566,9 @@ async function en(e) {
     throw new Error(
       `Artifacts carry Groth16 verifying key ${n} but the trusted key for prover circuit version ${e.expectedProverCircuitVersion} is ${a}; refusing a file whose proof would verify under a substituted key.`
     );
-  return await nr(s, e.artifactsJson), t;
+  return await ar(s, e.artifactsJson), t;
 }
-function go(e) {
+function xo(e) {
   try {
     return S.fromHex(e);
   } catch (t) {
@@ -577,17 +577,17 @@ function go(e) {
     });
   }
 }
-function me(e, t) {
+function Pe(e, t) {
   if (typeof e != "string" || e.length === 0)
     throw new Error(`Artifacts file is missing a usable "${t}".`);
   return e;
 }
-function Pe(e, t) {
+function we(e, t) {
   if (typeof e != "number" || !Number.isSafeInteger(e) || e < 0)
     throw new Error(`Artifacts file is missing a usable "${t}".`);
   return e;
 }
-function fo(e, t) {
+function Eo(e, t) {
   if (e === void 0) return {};
   if (typeof e != "object" || e === null || Array.isArray(e))
     throw new Error(`Artifacts file is missing a usable "${t}".`);
@@ -602,7 +602,7 @@ function It(e) {
       id: "claim",
       kind: "claim",
       psbtBase64: e.claim,
-      inputIndex: pe
+      inputIndex: ge
     },
     {
       id: "assert",
@@ -620,7 +620,7 @@ function It(e) {
       id: "payoutDepositor",
       kind: "payoutDepositor",
       psbtBase64: e.payoutDepositor,
-      inputIndex: ee
+      inputIndex: re
     }
   ];
   for (const r of Object.keys(e.wronglyChallenged))
@@ -629,29 +629,29 @@ function It(e) {
         id: Bt(r, s),
         kind: "wronglyChallenged",
         psbtBase64: o,
-        inputIndex: $r
+        inputIndex: Tr
       });
     });
   return t;
 }
-const yo = "{}", vo = xt - Et;
+const ko = "{}", $o = xt - Et;
 function V(e) {
   const t = e.replace(/^0x/, "").toLowerCase();
   if (t.length === xt)
-    return t.slice(vo);
+    return t.slice($o);
   if (t.length === Et) return t;
   throw new Error(
     `Public key must be 33-byte compressed or 32-byte x-only hex, got ${t.length / 2} bytes.`
   );
 }
-async function et(e, t, r) {
+async function Ze(e, t, r) {
   const o = await e.getPublicKeyHex();
   if (V(o) !== V(t))
     throw new Error(
       "Connected wallet does not hold the vault's depositor key. Select the account that made the deposit, then try again."
     );
   const s = await e.getAddress();
-  if (!er(s, o, r))
+  if (!tr(s, o, r))
     throw new Error(
       `Connected wallet reports address "${s}", which is not derived from the vault's depositor key. Select the account that made the deposit, then try again.`
     );
@@ -664,15 +664,15 @@ async function Vt(e, t, r, o) {
       `Depositor key ${s} is not the vault's registered depositor key ${r.depositorBtcPubkey}; refusing to plan a claim for another key.`
     );
   try {
-    br(
+    wr(
       Ie(r.registeredPayoutScriptPubKey),
       r.depositorBtcPubkey,
       o
     );
-  } catch (d) {
+  } catch (h) {
     throw new Error(
-      `Registered payout script ${r.registeredPayoutScriptPubKey} failed the depositor-key derivation check: ${d instanceof Error ? d.message : String(d)}. This SDK registers only P2TR of the depositor's x-only key or P2WPKH of the compressed key (the contract bounds the script's length alone, PeginLogic.sol:237-240 @ c559f5c2); refusing to sign a claim that pays it.`,
-      { cause: d }
+      `Registered payout script ${r.registeredPayoutScriptPubKey} failed the depositor-key derivation check: ${h instanceof Error ? h.message : String(h)}. This SDK registers only P2TR of the depositor's x-only key or P2WPKH of the compressed key (the contract bounds the script's length alone, PeginLogic.sol:237-240 @ c559f5c2); refusing to sign a claim that pays it.`,
+      { cause: h }
     );
   }
   if (e !== U)
@@ -684,37 +684,37 @@ async function Vt(e, t, r, o) {
       `Graph version ${e} does not match the vault context's vault core version ${r.vaultCoreVersion}; they are one axis and must agree.`
     );
   const [n, a, i, u, l] = await Promise.all([
-    ir(e, t),
-    ar(e, t),
     ur(e, t),
     cr(e, t),
-    lr(e, t)
+    lr(e, t),
+    dr(e, t),
+    hr(e, t)
   ]);
   St({
-    peginTxid: ao(n),
+    peginTxid: yo(n),
     depositorEthAddress: r.depositorEthAddress,
     expectedVaultId: r.vaultId
-  }), Qr({
+  }), io({
     claimPsbtBase64: n,
     assertPsbtBase64: a,
     payoutClaimerPsbtBase64: i
   });
-  for (const d of [i, l])
-    oo({
-      payoutPsbtBase64: d,
+  for (const h of [i, l])
+    ho({
+      payoutPsbtBase64: h,
       registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
       depositorBtcPubkey: r.depositorBtcPubkey
     });
-  const c = no({
+  const c = go({
     payoutDepositorPsbtBase64: l,
     payoutClaimerPsbtBase64: i
   });
-  return await Zr({
+  return await ao({
     payoutClaimerPsbtBase64: i,
     payoutDepositorPsbtBase64: c,
     assertPsbtBase64: a,
     vault: r
-  }), to({
+  }), co({
     graphChallengerPubkeys: Object.keys(u),
     depositorBtcPubkey: o,
     vaultProviderBtcPubkey: r.vaultProviderBtcPubkey,
@@ -722,7 +722,7 @@ async function Vt(e, t, r, o) {
     universalChallengerBtcPubkeys: r.universalChallengerBtcPubkeys
   }), { claim: n, assert: a, payoutClaimer: i, payoutDepositor: c, wronglyChallenged: u };
 }
-async function bo(e) {
+async function Co(e) {
   At({
     servedVerifyingKeyHex: e.source.verifyingKeyHex,
     trustedVerifyingKeyHex: e.trustedVerifyingKeyHex,
@@ -741,55 +741,55 @@ async function bo(e) {
     source: e.source,
     vault: e.vault,
     // Omitted means unjoined: the browser cannot hold the real sessions.
-    babeSessionsJson: e.babeSessionsJson === void 0 ? yo : e.babeSessionsJson,
+    babeSessionsJson: e.babeSessionsJson === void 0 ? ko : e.babeSessionsJson,
     requests: It(t)
   };
 }
-function ge(e, t, r) {
-  re({
-    requestedPsbtHex: Ne(t.psbtBase64),
+function fe(e, t, r) {
+  oe({
+    requestedPsbtHex: He(t.psbtBase64),
     signatureHex: r,
     signerXOnlyPubkeyHex: V(e.depositorPublicKey),
     inputIndex: t.inputIndex
   });
 }
-function Ne(e) {
+function He(e) {
   return H.from(e, "base64").toString("hex");
 }
 function Rt(e) {
   return H.from(e, "hex").toString("base64");
 }
-class j extends Error {
+class Y extends Error {
   constructor(t) {
     super(t), this.name = "SigningPlanMismatchError";
   }
 }
-function mo(e, t) {
+function To(e, t) {
   if (e.length !== t.length)
-    throw new j(
+    throw new Y(
       `Plan has ${e.length} requests but the graph builds ${t.length}; the plan was altered after planning.`
     );
   for (let r = 0; r < t.length; r++) {
     const o = t[r], s = e[r];
     if (s.id !== o.id)
-      throw new j(
+      throw new Y(
         `Plan request at position ${r} is "${s.id}" but the graph builds "${o.id}" there; the plan was altered after planning.`
       );
     if (s.kind !== o.kind)
-      throw new j(
+      throw new Y(
         `Plan request "${s.id}" has kind "${s.kind}" but the graph builds "${o.kind}"; the plan was altered after planning.`
       );
     if (s.inputIndex !== o.inputIndex)
-      throw new j(
+      throw new Y(
         `Plan request "${s.id}" signs inputIndex ${s.inputIndex} but the graph builds ${o.inputIndex}; the plan was altered after planning.`
       );
     if (s.psbtBase64 !== o.psbtBase64)
-      throw new j(
+      throw new Y(
         `Plan request "${s.id}" carries a psbt that differs from the one the graph builds; the plan was altered after planning.`
       );
   }
 }
-function Po(e, t) {
+function _o(e, t) {
   const r = new Set(e.map((a) => a.id)), o = [...r].filter((a) => !t.has(a)), s = [...t.keys()].filter((a) => !r.has(a));
   if (o.length === 0 && s.length === 0) return;
   const n = (a) => a.map((i) => `"${i}"`).join(", ");
@@ -797,7 +797,7 @@ function Po(e, t) {
     `Signatures do not cover the plan: ${t.size} signatures for ${e.length} requests` + (o.length > 0 ? `; missing ${n(o)}` : "") + (s.length > 0 ? `; extra ${n(s)}` : "") + "."
   );
 }
-function M(e, t) {
+function L(e, t) {
   const r = e.get(t);
   if (r === void 0)
     throw new Error(
@@ -805,7 +805,7 @@ function M(e, t) {
     );
   return r;
 }
-async function wo(e) {
+async function So(e) {
   const { plan: t, signatures: r } = e, { txGraphVersion: o } = t.vault, s = t.source.txGraphJson, n = At({
     servedVerifyingKeyHex: t.source.verifyingKeyHex,
     trustedVerifyingKeyHex: t.trustedVerifyingKeyHex,
@@ -816,34 +816,34 @@ async function wo(e) {
     t.vault,
     t.depositorPublicKey
   ), i = It(a);
-  mo(t.requests, i), Po(i, r);
+  To(t.requests, i), _o(i, r);
   for (const c of i)
-    ge(
+    fe(
       t,
       c,
-      M(r, c.id)
+      L(r, c.id)
     );
   const u = {};
   for (const c of Object.keys(a.wronglyChallenged))
     u[c] = a.wronglyChallenged[c].map(
-      (d, h) => M(
+      (h, d) => L(
         r,
-        Bt(c, h)
+        Bt(c, d)
       )
     );
-  const l = await dr(
+  const l = await pr(
     o,
     s,
-    M(r, "claim")
+    L(r, "claim")
   );
-  return hr({
+  return gr({
     txGraphVersion: o,
     graphJson: s,
     signedClaimTxHex: l,
-    assertClaimerSigHex: M(r, "assert"),
-    payoutClaimerSigHex: M(r, "payoutClaimer"),
+    assertClaimerSigHex: L(r, "assert"),
+    payoutClaimerSigHex: L(r, "payoutClaimer"),
     wronglyChallengedSigs: u,
-    depositorPayoutSigHex: M(r, "payoutDepositor"),
+    depositorPayoutSigHex: L(r, "payoutDepositor"),
     verifyingKeyHex: n,
     claimableEventBlockNumber: t.vault.claimableEventBlockNumber,
     proverCircuitVersion: t.vault.proverCircuitVersion,
@@ -852,10 +852,10 @@ async function wo(e) {
     expectedVaultCoreVersion: t.vault.vaultCoreVersion
   });
 }
-function xo(e) {
+function Ao(e) {
   return typeof e.signDelegatedClaimPsbt == "function";
 }
-class Eo extends Error {
+class Bo extends Error {
   constructor(t, r, o, s) {
     super(t, s), this.signatures = r, this.failedRequestId = o, this.name = "DelegatedClaimSigningIncompleteError";
   }
@@ -866,30 +866,30 @@ const Kt = {
   payoutClaimer: "standalone",
   claim: "standalone",
   wronglyChallenged: "standalone"
-}, $o = [
+}, Io = [
   "payoutClaimer",
   "claim",
   "wronglyChallenged"
 ];
-async function ko(e, t, r = {}) {
+async function Vo(e, t, r = {}) {
   var s;
-  if ((s = r.signal) == null || s.throwIfAborted(), To(e), V(e.depositorPublicKey) !== e.vault.depositorBtcPubkey)
+  if ((s = r.signal) == null || s.throwIfAborted(), Ro(e), V(e.depositorPublicKey) !== e.vault.depositorBtcPubkey)
     throw new Error(
       `Plan depositor key ${V(e.depositorPublicKey)} is not the vault's registered depositor key ${e.vault.depositorBtcPubkey}; the plan was not built for this vault.`
     );
   if (vt(t)) {
-    if (!xo(t))
+    if (!Ao(t))
       throw new Error(
         "Approval wallet does not implement signDelegatedClaimPsbt; the claim ceremony needs it because the device signs some claim PSBTs with no loaded intent and needs its own derivation fields on them."
       );
-    const n = _o(r, e);
-    So(n.depositTerms, e.vault);
-    const a = Co(e), i = await et(
+    const n = Ho(r, e);
+    Oo(n.depositTerms, e.vault);
+    const a = Ko(e), i = await Ze(
       t,
       e.depositorPublicKey,
       e.btcNetwork
     );
-    return Ao(
+    return No(
       e,
       t,
       i,
@@ -898,14 +898,14 @@ async function ko(e, t, r = {}) {
       r
     );
   }
-  const o = await et(
+  const o = await Ze(
     t,
     e.depositorPublicKey,
     e.btcNetwork
   );
-  return Io(e, t, o, r.signal);
+  return Lo(e, t, o, r.signal);
 }
-function To(e) {
+function Ro(e) {
   const t = /* @__PURE__ */ new Set();
   for (const r of e.requests) {
     if (t.has(r.id))
@@ -915,10 +915,10 @@ function To(e) {
     t.add(r.id);
   }
 }
-function Co(e) {
+function Ko(e) {
   const t = e.requests.filter(
     (s) => Kt[s.kind] === "intentBound"
-  ), r = $o.flatMap(
+  ), r = Io.flatMap(
     (s) => e.requests.filter((n) => n.kind === s)
   ), o = t.length + r.length;
   if (o !== e.requests.length)
@@ -933,7 +933,7 @@ function Ht(e, t) {
       `Delegated-claim signing ended with ${t.size} signatures for ${e.requests.length} requests; the set is incomplete and must not be treated as signed.`
     );
 }
-function _o(e, t) {
+function Ho(e, t) {
   if (e.depositTerms === void 0)
     throw new Error(
       "An approval wallet signs Assert and the depositor Payout only under this vault's loaded intent; pass depositTerms (rebuilt from on-chain state) so it can be approved."
@@ -942,14 +942,14 @@ function _o(e, t) {
     throw new Error(
       "An approval wallet releases a loaded intent only through the vault-root derivation; pass vaultContext so that derivation can run before and after the intent-bound signatures."
     );
-  const r = Ve(e.vaultContext.depositorBtcPubkey);
+  const r = yt(e.vaultContext.depositorBtcPubkey);
   if (r !== t.vault.depositorBtcPubkey)
     throw new Error(
       `vaultContext derives from depositor key ${r} but this plan's vault is registered to ${t.vault.depositorBtcPubkey}; the device would derive for another depositor.`
     );
   return { depositTerms: e.depositTerms, vaultContext: e.vaultContext };
 }
-function So(e, t) {
+function Oo(e, t) {
   const r = (s) => s.map((n) => V(n)).sort().join(",");
   if (r(e.vaultKeeperBtcPubkeys) !== r(t.vaultKeeperBtcPubkeys) || r(e.universalChallengerBtcPubkeys) !== r(t.universalChallengerBtcPubkeys))
     throw new Error(
@@ -982,18 +982,18 @@ function So(e, t) {
         `Deposit terms group at htlcVout ${s.htlcVout} names a different vault provider than the vault context this claim signs for; the device would bind the Assert to the wrong intent.`
       );
 }
-async function Ao(e, t, r, o, { intentBound: s, standalone: n }, a) {
+async function No(e, t, r, o, { intentBound: s, standalone: n }, a) {
   var g;
-  const i = Bo(e, a.resume), u = [...s, ...n];
+  const i = Do(e, a.resume), u = [...s, ...n];
   let l = 0;
   const c = {
     phase: "clearing any loaded intent"
-  }, d = async (p) => {
+  }, h = async (p) => {
     var m;
     c.phase = "signing", (m = a.signal) == null || m.throwIfAborted();
     const y = await t.signDelegatedClaimPsbt(
-      Ne(p.psbtBase64),
-      $t(
+      He(p.psbtBase64),
+      kt(
         e.depositorPublicKey,
         p.inputIndex,
         r
@@ -1002,24 +1002,24 @@ async function Ao(e, t, r, o, { intentBound: s, standalone: n }, a) {
       Rt(y),
       p.inputIndex
     );
-    ge(e, p, f), i.set(p.id, f);
-  }, h = async (p) => {
+    fe(e, p, f), i.set(p.id, f);
+  }, d = async (p) => {
     var f;
-    c.phase = p, (f = a.signal) == null || f.throwIfAborted(), (await kt(t, o.vaultContext)).fill(0);
+    c.phase = p, (f = a.signal) == null || f.throwIfAborted(), (await $t(t, o.vaultContext)).fill(0);
   };
   typeof t.validateDepositTerms == "function" && await t.validateDepositTerms(o.depositTerms);
   try {
-    await h("clearing any loaded intent"), c.phase = "approving the deposit terms", (g = a.signal) == null || g.throwIfAborted(), await t.approveDepositTerms(o.depositTerms);
+    await d("clearing any loaded intent"), c.phase = "approving the deposit terms", (g = a.signal) == null || g.throwIfAborted(), await t.approveDepositTerms(o.depositTerms);
     for (const p of s)
-      await d(p), l++;
-    await h("releasing the loaded intent");
+      await h(p), l++;
+    await d("releasing the loaded intent");
     for (const p of n)
-      i.has(p.id) || await d(p), l++;
+      i.has(p.id) || await h(p), l++;
   } catch (p) {
     const y = u[l];
     if (i.size === 0 || y === void 0) throw p;
     const f = c.phase === "signing" ? `stopped at "${y.id}"` : `stopped before "${y.id}" while ${c.phase}`;
-    throw new Eo(
+    throw new Bo(
       `Delegated-claim signing ${f}; ${i.size} of ${e.requests.length} signatures were collected.`,
       i,
       y.id,
@@ -1028,14 +1028,14 @@ async function Ao(e, t, r, o, { intentBound: s, standalone: n }, a) {
   }
   return Ht(e, i), i;
 }
-function Bo(e, t) {
+function Do(e, t) {
   const r = /* @__PURE__ */ new Map();
   if (!t) return r;
   for (const o of e.requests) {
     const s = t.get(o.id);
     if (!(s === void 0 || Kt[o.kind] === "intentBound")) {
       try {
-        ge(e, o, s);
+        fe(e, o, s);
       } catch {
         continue;
       }
@@ -1044,12 +1044,12 @@ function Bo(e, t) {
   }
   return r;
 }
-async function Io(e, t, r, o) {
+async function Lo(e, t, r, o) {
   const s = e.requests, n = await bt(
     t,
-    s.map((i) => Ne(i.psbtBase64)),
+    s.map((i) => He(i.psbtBase64)),
     s.map(
-      (i) => $t(
+      (i) => kt(
         e.depositorPublicKey,
         i.inputIndex,
         r
@@ -1062,39 +1062,39 @@ async function Io(e, t, r, o) {
       Rt(n[i]),
       s[i].inputIndex
     );
-    ge(e, s[i], u), a.set(s[i].id, u);
+    fe(e, s[i], u), a.set(s[i].id, u);
   }
   return Ht(e, a), a;
 }
-async function tn(e) {
-  const t = await bo({
+async function ln(e) {
+  const t = await Co({
     depositorPublicKey: e.depositorPublicKey,
     btcNetwork: e.btcNetwork,
     source: e.source,
     trustedVerifyingKeyHex: e.trustedVerifyingKeyHex,
     vault: e.vault,
     babeSessionsJson: e.babeSessionsJson
-  }), r = await ko(t, e.btcWallet, {
+  }), r = await Vo(t, e.btcWallet, {
     depositTerms: e.depositTerms,
     vaultContext: e.vaultContext
   });
-  return wo({ plan: t, signatures: r });
+  return So({ plan: t, signatures: r });
 }
-async function rn(e) {
-  const t = await kt(e.btcWallet, e.vaultContext);
+async function dn(e) {
+  const t = await $t(e.btcWallet, e.vaultContext);
   let r;
   try {
-    r = await pr(t, e.htlcVout);
+    r = await fr(t, e.htlcVout);
   } finally {
     t.fill(0);
   }
   let o;
   try {
-    o = await gr(r);
+    o = await yr(r);
   } finally {
     r.fill(0);
   }
-  return Vo(o.pk_hash, e.expectedWotsPkHash), await fr(
+  return Mo(o.pk_hash, e.expectedWotsPkHash), await vr(
     e.txGraphVersion,
     o.keypair,
     e.txGraphJson
@@ -1103,16 +1103,16 @@ async function rn(e) {
     pkHash: o.pk_hash
   };
 }
-function Vo(e, t) {
-  if (ne(e) !== ne(t))
+function Mo(e, t) {
+  if (ie(e) !== ie(t))
     throw new Error(
-      `Derived WOTS public-key hash ${ne(e)} does not match the vault's on-chain depositorWotsPkHash ${ne(t)}. The wallet, the HTLC output index, or the derivation itself is not the one this vault was created with.`
+      `Derived WOTS public-key hash ${ie(e)} does not match the vault's on-chain depositorWotsPkHash ${ie(t)}. The wallet, the HTLC output index, or the derivation itself is not the one this vault was created with.`
     );
 }
-function ne(e) {
+function ie(e) {
   return `0x${(e.startsWith("0x") ? e.slice(2) : e).toLowerCase()}`;
 }
-function we(e, t, r) {
+function xe(e, t, r) {
   const o = `${e} operation key (admin=${t.ethAddress})`, s = _e(
     t.btcPubKey,
     `${e} roster key (admin=${t.ethAddress})`
@@ -1124,7 +1124,7 @@ function we(e, t, r) {
     rotated: n !== s
   };
 }
-function Ro(e) {
+function Fo(e) {
   const t = /* @__PURE__ */ new Map();
   for (const r of e) {
     const o = t.get(r.operationBtcPubkey);
@@ -1135,12 +1135,12 @@ function Ro(e) {
     t.set(r.operationBtcPubkey, r.adminAddress);
   }
 }
-function Nt(e, t, r) {
+function Ot(e, t, r) {
   if (t.vaultKeepers.length !== e.vaultKeepers.length || t.universalChallengers.length !== e.universalChallengers.length)
     throw new Error(
       `Operation-key resolution returned ${t.vaultKeepers.length} keeper and ${t.universalChallengers.length} challenger keys for a roster of ${e.vaultKeepers.length} keepers and ${e.universalChallengers.length} challengers`
     );
-  const o = we(
+  const o = xe(
     "vault provider",
     {
       ethAddress: e.vaultProviderEthAddress,
@@ -1148,11 +1148,11 @@ function Nt(e, t, r) {
     },
     t.vaultProvider
   ), s = e.vaultKeepers.map(
-    (a, i) => we("vault keeper", a, t.vaultKeepers[i])
+    (a, i) => xe("vault keeper", a, t.vaultKeepers[i])
   ), n = e.universalChallengers.map(
-    (a, i) => we("universal challenger", a, t.universalChallengers[i])
+    (a, i) => xe("universal challenger", a, t.universalChallengers[i])
   );
-  return Ro([
+  return Fo([
     o,
     ...s,
     ...n
@@ -1167,24 +1167,24 @@ function Nt(e, t, r) {
     query: e
   };
 }
-async function Ko(e) {
+async function Uo(e) {
   const t = await e.operationKeyReader.getCurrentOperationKeys(
     e.query,
     e.blockNumber
   );
-  return Nt(e.query, t, { mode: "current" });
+  return Ot(e.query, t, { mode: "current" });
 }
-async function Ot(e) {
+async function Nt(e) {
   const t = await e.operationKeyReader.getOperationKeysAtEpochs(
     e.query,
     e.epochs
   );
-  return Nt(e.query, t, {
+  return Ot(e.query, t, {
     mode: "epochs",
     epochs: e.epochs
   });
 }
-async function Ho(e) {
+async function qo(e) {
   const { basic: t, protocol: r } = e.vault, {
     registryReader: o,
     vaultKeeperReader: s,
@@ -1214,7 +1214,7 @@ async function Ho(e) {
     throw new Error(
       `No universal challengers for version ${r.universalChallengersVersion}`
     );
-  return Ot({
+  return Nt({
     operationKeyReader: a,
     query: {
       vaultProviderEthAddress: t.vaultProvider,
@@ -1226,7 +1226,7 @@ async function Ho(e) {
     epochs: c
   });
 }
-async function on(e) {
+async function hn(e) {
   const { vaultId: t, readers: r } = e, o = await r.registryReader.getVaultData(t), { basic: s, protocol: n } = o;
   if (n.vaultCoreVersion !== U)
     throw new Error(
@@ -1236,19 +1236,19 @@ async function on(e) {
     s.depositorBtcPubKey,
     `getBtcVaultBasicInfo(${t}).depositorBtcPubKey`
   );
-  if (s.status !== je.REDEEMED)
-    throw new Fe(
+  if (s.status !== ze.REDEEMED)
+    throw new Le(
       t,
       s.depositorBtcPubKey,
       s.createdAt,
       s.createdAt,
-      `the vault's status is ${s.status}, not Redeemed (${je.REDEEMED}); no scan was made`
+      `the vault's status is ${s.status}, not Redeemed (${ze.REDEEMED}); no scan was made`
     );
   const [i, u, l, c] = await Promise.all([
-    Ho({ vaultId: t, vault: o, readers: r }),
+    qo({ vaultId: t, vault: o, readers: r }),
     r.registryReader.getRegistrationRecordsAtBlock(s.createdAt),
     r.registryReader.getVaultClaimableBy(t, s.depositorBtcPubKey, s.createdAt).catch((v) => {
-      throw mr(v) ? new Fe(
+      throw xr(v) ? new Le(
         t,
         s.depositorBtcPubKey,
         v.fromBlock,
@@ -1260,54 +1260,54 @@ async function on(e) {
     r.protocolParamsReader.getOffchainParamsByVersion(
       n.offchainParamsVersion
     )
-  ]), d = _r(c.timelockAssert), h = Pr(u, t, s.createdAt);
-  wr(h);
-  const g = xr(h);
+  ]), h = Rr(c.timelockAssert), d = Er(u, t, s.createdAt);
+  kr(d);
+  const g = $r(d);
   if (g.toLowerCase() !== n.prePeginTxHash.toLowerCase())
     throw new Error(
       `Registration log of vault ${t} records prePeginTxHash ${g} but the vault record says ${n.prePeginTxHash}; refusing an inconsistent node.`
     );
-  if (h.vaultCoreVersion !== n.vaultCoreVersion)
+  if (d.vaultCoreVersion !== n.vaultCoreVersion)
     throw new Error(
-      `Registration log of vault ${t} records vault core version ${h.vaultCoreVersion} but the vault record says ${n.vaultCoreVersion}; refusing an inconsistent node.`
+      `Registration log of vault ${t} records vault core version ${d.vaultCoreVersion} but the vault record says ${n.vaultCoreVersion}; refusing an inconsistent node.`
     );
-  if (h.amount !== s.amount)
+  if (d.amount !== s.amount)
     throw new Error(
-      `Registration log of vault ${t} records amount ${h.amount} sats but the vault record says ${s.amount}; refusing an inconsistent node.`
+      `Registration log of vault ${t} records amount ${d.amount} sats but the vault record says ${s.amount}; refusing an inconsistent node.`
     );
-  if (h.depositor.toLowerCase() !== s.depositor.toLowerCase())
+  if (d.depositor.toLowerCase() !== s.depositor.toLowerCase())
     throw new Error(
-      `Registration log of vault ${t} records depositor ${h.depositor} but the vault record says ${s.depositor}; refusing an inconsistent node.`
+      `Registration log of vault ${t} records depositor ${d.depositor} but the vault record says ${s.depositor}; refusing an inconsistent node.`
     );
-  if (h.vaultProvider.toLowerCase() !== s.vaultProvider.toLowerCase())
+  if (d.vaultProvider.toLowerCase() !== s.vaultProvider.toLowerCase())
     throw new Error(
-      `Registration log of vault ${t} records vaultProvider ${h.vaultProvider} but the vault record says ${s.vaultProvider}; refusing an inconsistent node.`
+      `Registration log of vault ${t} records vaultProvider ${d.vaultProvider} but the vault record says ${s.vaultProvider}; refusing an inconsistent node.`
     );
   if (l.vaultCoreVersion !== n.vaultCoreVersion)
     throw new Error(
       `Redemption log of vault ${t} records vault core version ${l.vaultCoreVersion} but the vault record says ${n.vaultCoreVersion}; refusing an inconsistent node.`
     );
-  if (l.proverCircuitVersion !== h.proverCircuitVersion)
+  if (l.proverCircuitVersion !== d.proverCircuitVersion)
     throw new Error(
-      `Redemption log of vault ${t} records proverCircuitVersion ${l.proverCircuitVersion} but the registration log says ${h.proverCircuitVersion}; refusing an inconsistent node.`
+      `Redemption log of vault ${t} records proverCircuitVersion ${l.proverCircuitVersion} but the registration log says ${d.proverCircuitVersion}; refusing an inconsistent node.`
     );
-  if (h.proverCircuitVersion !== c.proverCircuitVersion)
+  if (d.proverCircuitVersion !== c.proverCircuitVersion)
     throw new Error(
-      `Registration log of vault ${t} records proverCircuitVersion ${h.proverCircuitVersion} but the stamped offchain params say ${c.proverCircuitVersion}; refusing an inconsistent node.`
+      `Registration log of vault ${t} records proverCircuitVersion ${d.proverCircuitVersion} but the stamped offchain params say ${c.proverCircuitVersion}; refusing an inconsistent node.`
     );
-  const p = Er(n.depositorSignedPeginTx);
+  const p = Cr(n.depositorSignedPeginTx);
   for (const [v, E] of [
-    ["Registration", h.peginTxHash],
+    ["Registration", d.peginTxHash],
     ["Redemption", l.peginTxHash]
   ])
     if (E.toLowerCase() !== p.toLowerCase())
       throw new Error(
         `${v} log of vault ${t} records peginTxHash ${E} but the vault's depositor-signed PegIn hashes to ${p}; refusing an inconsistent node.`
       );
-  const y = G(
+  const y = z(
     Pt(p, s.depositor)
   );
-  if (y !== G(t))
+  if (y !== z(t))
     throw new Error(
       `Depositor-signed PegIn of vault ${t} derives vault id ${y} with depositor ${s.depositor}; refusing an inconsistent node.`
     );
@@ -1316,9 +1316,9 @@ async function on(e) {
     "universalChallengersVersion",
     "appVaultKeepersVersion"
   ]) {
-    if (h[v] !== n[v])
+    if (d[v] !== n[v])
       throw new Error(
-        `Registration log of vault ${t} records ${v} ${h[v]} but the vault record says ${n[v]}; refusing an inconsistent node.`
+        `Registration log of vault ${t} records ${v} ${d[v]} but the vault record says ${n[v]}; refusing an inconsistent node.`
       );
     if (l[v] !== n[v])
       throw new Error(
@@ -1332,19 +1332,19 @@ async function on(e) {
     throw new Error(
       `Depositor-signed PegIn of vault ${t} has ${f.ins.length} inputs; it spends Pre-PegIn ${n.prePeginTxHash} output ${n.htlcVout} with exactly one; refusing an inconsistent node.`
     );
-  const m = He(f.ins[0].hash), k = f.ins[0].index;
-  if (m !== b(n.prePeginTxHash).toLowerCase() || k !== n.htlcVout)
+  const m = Ke(f.ins[0].hash), $ = f.ins[0].index;
+  if (m !== b(n.prePeginTxHash).toLowerCase() || $ !== n.htlcVout)
     throw new Error(
-      `Depositor-signed PegIn of vault ${t} spends ${m}:${k} but the vault record says Pre-PegIn ${n.prePeginTxHash} output ${n.htlcVout}; refusing an inconsistent node.`
+      `Depositor-signed PegIn of vault ${t} spends ${m}:${$} but the vault record says Pre-PegIn ${n.prePeginTxHash} output ${n.htlcVout}; refusing an inconsistent node.`
     );
-  const x = f.outs[J];
+  const x = f.outs[Z];
   if (x === void 0)
     throw new Error(
-      `Depositor-signed PegIn of vault ${t} has no output ${J}; the Payout cannot spend the Vault UTXO.`
+      `Depositor-signed PegIn of vault ${t} has no output ${Z}; the Payout cannot spend the Vault UTXO.`
     );
   if (BigInt(x.value) !== s.amount)
     throw new Error(
-      `Depositor-signed PegIn of vault ${t} pays ${x.value} sats to output ${J} but the vault record says ${s.amount}; refusing an inconsistent node.`
+      `Depositor-signed PegIn of vault ${t} pays ${x.value} sats to output ${Z} but the vault record says ${s.amount}; refusing an inconsistent node.`
     );
   return {
     context: {
@@ -1352,7 +1352,7 @@ async function on(e) {
       depositorEthAddress: s.depositor,
       depositorBtcPubkey: a,
       registeredPayoutScriptPubKey: b(
-        h.depositorPayoutScriptPubKey
+        d.depositorPayoutScriptPubKey
       ),
       vaultProviderBtcPubkey: i.vaultProvider.operationBtcPubkey,
       vaultKeeperBtcPubkeys: [
@@ -1368,11 +1368,11 @@ async function on(e) {
       peginVaultOutputValueSats: x.value,
       protocolFeeRate: c.feeRate,
       councilSize: c.securityCouncilKeys.length,
-      timelockPegin: d,
+      timelockPegin: h,
       timelockAssert: Number(c.timelockAssert)
     },
     vault: o,
-    registrationRecord: h,
+    registrationRecord: d,
     registrationRecords: u,
     participantKeys: i,
     offchainParams: c,
@@ -1384,35 +1384,35 @@ async function on(e) {
     htlcVout: n.htlcVout
   };
 }
-const No = 8, Oo = 6e3, Do = 10 * 6e4, Mo = 10;
+const Go = 8, Xo = 6e3, zo = 10 * 6e4, jo = 10;
 class Dt extends Error {
   constructor(t) {
     super(t), this.name = "PeginRegistrationMissingError";
   }
 }
-class Mt extends Error {
+class Lt extends Error {
   constructor(t) {
     super(t), this.name = "PeginRegistrationNotFinalError";
   }
 }
-function Lo(e) {
+function Wo(e) {
   return e instanceof Dt || e instanceof Error && e.name === "PeginRegistrationMissingError";
 }
-function sn(e) {
-  return e instanceof Mt || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
+function pn(e) {
+  return e instanceof Lt || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
 }
-function tt(e) {
+function et(e) {
   const { currentBlock: t, createdAtBlock: r } = e, o = t - r + 1n;
   return o < 0n ? 0 : Number(o);
 }
-async function nn(e) {
+async function gn(e) {
   const {
     vaultRegistryReader: t,
     getBlockNumber: r,
     vaultIds: o,
-    required: s = No,
-    pollIntervalMs: n = Oo,
-    timeoutMs: a = Do,
+    required: s = Go,
+    pollIntervalMs: n = Xo,
+    timeoutMs: a = zo,
     signal: i,
     onProgress: u
   } = e;
@@ -1421,52 +1421,52 @@ async function nn(e) {
       "waitForPeginRegistrationDepth requires at least one vault ID"
     );
   const l = Date.now();
-  let c = !1, d = 0, h;
+  let c = !1, h = 0, d;
   for (; ; ) {
     if (i != null && i.aborted)
       throw new Error(
         `Aborted while waiting for peg-in registration depth (${o.length} vault(s))`
       );
     if (Date.now() - l >= a)
-      throw new Mt(
-        `Peg-in registration did not reach ${s} Ethereum confirmations within ${a}ms. The registration transaction was submitted but is not yet final, so the Pre-PegIn Bitcoin transaction was never sent and no funds are at risk. Resume this deposit from the dashboard once the network settles.` + (h instanceof Error ? ` Last read error: ${h.message}` : "")
+      throw new Lt(
+        `Peg-in registration did not reach ${s} Ethereum confirmations within ${a}ms. The registration transaction was submitted but is not yet final, so the Pre-PegIn Bitcoin transaction was never sent and no funds are at risk. Resume this deposit from the dashboard once the network settles.` + (d instanceof Error ? ` Last read error: ${d.message}` : "")
       );
     try {
       const g = await r(), p = await Promise.all(
         o.map((f) => t.getVaultBasicInfo(f))
       ), y = p.findIndex(
-        (f) => f.depositor === Sr || f.createdAt === 0n
+        (f) => f.depositor === Kr || f.createdAt === 0n
       );
       if (y !== -1) {
-        if (d += 1, !c && d > Mo)
+        if (h += 1, !c && h > jo)
           throw new Dt(
-            `Vault ${o[y]} is still not visible on-chain after ${d} reads — the registration does not exist.`
+            `Vault ${o[y]} is still not visible on-chain after ${h} reads — the registration does not exist.`
           );
         console.warn(
           `Peg-in registration for vault ${o[y]} is not visible in chain state at block ${g} — a lagging RPC backend or an Ethereum reorg. Still polling.`
         ), u == null || u({ confirmations: 0, required: s });
       } else {
-        c = !0, d = 0, h = void 0;
-        let f = p[0], m = tt({
+        c = !0, h = 0, d = void 0;
+        let f = p[0], m = et({
           currentBlock: g,
           createdAtBlock: p[0].createdAt
         });
-        for (const k of p.slice(1)) {
-          const x = tt({
+        for (const $ of p.slice(1)) {
+          const x = et({
             currentBlock: g,
-            createdAtBlock: k.createdAt
+            createdAtBlock: $.createdAt
           });
-          x < m && (m = x, f = k);
+          x < m && (m = x, f = $);
         }
         if (u == null || u({ confirmations: m, required: s }), m >= s)
           return { confirmations: m, basicInfo: f };
       }
     } catch (g) {
-      if (Lo(g))
+      if (Wo(g))
         throw g;
       console.warn(
         `Registration-depth read failed (retrying in ${n}ms): ` + (g instanceof Error ? g.message : String(g))
-      ), h = g;
+      ), d = g;
     }
     await new Promise((g, p) => {
       const y = () => {
@@ -1482,19 +1482,19 @@ async function nn(e) {
     });
   }
 }
-const Fo = /^(?:[0-9a-f]{2})*$/, Uo = /^[0-9a-f]{64}$/, qo = /^([0-9a-f]{64}):(0|[1-9][0-9]*)$/, Xo = -2147483648, Go = 2147483647, xe = 4294967295, rt = 2, ot = 2, le = 0;
+const Yo = /^(?:[0-9a-f]{2})*$/, Jo = /^[0-9a-f]{64}$/, Qo = /^([0-9a-f]{64}):(0|[1-9][0-9]*)$/, Zo = -2147483648, es = 2147483647, Ee = 4294967295, tt = 2, rt = 2, de = 0;
 class P extends Error {
   constructor(t) {
     super(t), this.name = "GraphFingerprintError";
   }
 }
-function $(e, t, r) {
+function k(e, t, r) {
   const o = e[t];
   if (o === void 0)
     throw new P(`Graph tx ${r} is missing "${t}"`);
   return o;
 }
-function Z(e, t) {
+function te(e, t) {
   if (!Array.isArray(e))
     throw new P(`Graph tx ${t} is not an array`);
   return e;
@@ -1504,60 +1504,60 @@ function B(e, t) {
     throw new P(`Graph tx ${t} is not an object`);
   return e;
 }
-function W(e, t, r, o) {
+function J(e, t, r, o) {
   if (typeof e != "number" || !Number.isSafeInteger(e) || e < r || e > o)
     throw new P(
       `Graph tx ${t} is not an integer in [${r}, ${o}]`
     );
   return e;
 }
-function Ee(e, t) {
-  if (typeof e != "string" || !Fo.test(e))
+function ke(e, t) {
+  if (typeof e != "string" || !Yo.test(e))
     throw new P(
       `Graph tx ${t} is not lowercase hex without a prefix`
     );
   return H.from(e, "hex");
 }
-function de(e, t) {
-  if (typeof e != "string" || !Uo.test(e))
+function he(e, t) {
+  if (typeof e != "string" || !Jo.test(e))
     throw new P(
       `Graph ${t} is not 32 bytes of lowercase hex`
     );
   return e;
 }
-function st(e, t) {
+function ot(e, t) {
   const r = B(e, t), o = new S();
-  return o.version = W(
-    $(r, "version", t),
+  return o.version = J(
+    k(r, "version", t),
     `${t}.version`,
-    Xo,
-    Go
-  ), o.locktime = W(
-    $(r, "lock_time", t),
+    Zo,
+    es
+  ), o.locktime = J(
+    k(r, "lock_time", t),
     `${t}.lock_time`,
     0,
-    xe
-  ), Z($(r, "input", t), `${t}.input`).forEach((s, n) => {
-    const a = `${t}.input[${n}]`, i = B(s, a), u = $(i, "previous_output", a), l = typeof u == "string" && qo.exec(u);
+    Ee
+  ), te(k(r, "input", t), `${t}.input`).forEach((s, n) => {
+    const a = `${t}.input[${n}]`, i = B(s, a), u = k(i, "previous_output", a), l = typeof u == "string" && Qo.exec(u);
     if (!l)
       throw new P(
         `Graph tx ${a}.previous_output is not "<txid>:<vout>"`
       );
-    const c = W(Number(l[2]), `${a}.previous_output vout`, 0, xe);
+    const c = J(Number(l[2]), `${a}.previous_output vout`, 0, Ee);
     o.addInput(
       H.from(l[1], "hex").reverse(),
       c,
-      W($(i, "sequence", a), `${a}.sequence`, 0, xe),
-      Ee($(i, "script_sig", a), `${a}.script_sig`)
-    ), o.ins[n].witness = Z(
-      $(i, "witness", a),
+      J(k(i, "sequence", a), `${a}.sequence`, 0, Ee),
+      ke(k(i, "script_sig", a), `${a}.script_sig`)
+    ), o.ins[n].witness = te(
+      k(i, "witness", a),
       `${a}.witness`
-    ).map((d, h) => Ee(d, `${a}.witness[${h}]`));
-  }), Z($(r, "output", t), `${t}.output`).forEach((s, n) => {
+    ).map((h, d) => ke(h, `${a}.witness[${d}]`));
+  }), te(k(r, "output", t), `${t}.output`).forEach((s, n) => {
     const a = `${t}.output[${n}]`, i = B(s, a);
     o.addOutput(
-      Ee($(i, "script_pubkey", a), `${a}.script_pubkey`),
-      W($(i, "value", a), `${a}.value`, 0, Number.MAX_SAFE_INTEGER)
+      ke(k(i, "script_pubkey", a), `${a}.script_pubkey`),
+      J(k(i, "value", a), `${a}.value`, 0, Number.MAX_SAFE_INTEGER)
     );
   }), new Uint8Array(o.toBuffer());
 }
@@ -1577,7 +1577,7 @@ function D(e, t) {
     );
   return o;
 }
-function Lt(e, t) {
+function Mt(e, t) {
   const r = e.ins[t];
   if (r)
     return {
@@ -1586,18 +1586,18 @@ function Lt(e, t) {
     };
 }
 function Ft(e, t) {
-  if (!e.outs[le])
+  if (!e.outs[de])
     throw new P(
-      `Presign ${t}.claim_tx must have output ${le}`
+      `Presign ${t}.claim_tx must have output ${de}`
     );
 }
-function zo(e, t, r) {
+function ts(e, t, r) {
   if (e.ins.length !== 1)
     throw new P(
       `Presign ${r}.claim_tx must have exactly one input, got ${e.ins.length}`
     );
   Ft(e, r);
-  const o = Lt(e, 0);
+  const o = Mt(e, 0);
   if ((o == null ? void 0 : o.txid) !== t || o.vout !== X) {
     const s = o ? `${o.txid}:${o.vout}` : "no input";
     throw new P(
@@ -1606,11 +1606,11 @@ function zo(e, t, r) {
   }
 }
 function Oe(e, t, r) {
-  const o = Lt(e, 0);
-  if ((o == null ? void 0 : o.txid) !== t || o.vout !== le) {
+  const o = Mt(e, 0);
+  if ((o == null ? void 0 : o.txid) !== t || o.vout !== de) {
     const s = o ? `${o.txid}:${o.vout}` : "no input";
     throw new P(
-      `Presign ${r}.assert_tx input 0 must spend ${t}:${le}, got ${s}`
+      `Presign ${r}.assert_tx input 0 must spend ${t}:${de}, got ${s}`
     );
   }
 }
@@ -1618,15 +1618,15 @@ function Ut(e) {
   const t = D(e.peginTxHex, `${e.path}.pegin_tx`), r = D(e.claimTxHex, `${e.path}.claim_tx`), o = D(e.assertTxHex, `${e.path}.assert_tx`);
   return { peginTx: t, claimTx: r, assertTx: o };
 }
-function jo(e) {
+function rs(e) {
   const t = D(e.claimTxHex, `${e.path}.claim_tx`), r = D(e.assertTxHex, `${e.path}.assert_tx`);
   Ft(t, e.path), Oe(r, t.getId(), e.path);
 }
-function Wo(e) {
+function os(e) {
   const { peginTx: t, claimTx: r, assertTx: o } = Ut(e);
-  zo(r, t.getId(), e.path), Oe(o, r.getId(), e.path);
+  ts(r, t.getId(), e.path), Oe(o, r.getId(), e.path);
 }
-function Yo(e, t) {
+function ss(e, t) {
   const [r, ...o] = e.ins;
   if (!r || o.length > 0)
     throw new P(
@@ -1637,17 +1637,17 @@ function Yo(e, t) {
     throw new P(
       `Presign claim_tx must spend ${t}:${X}, got ${s}:${r.index}`
     );
-  if (e.version !== rt)
+  if (e.version !== tt)
     throw new P(
-      `Presign claim_tx version must be ${rt}, got ${e.version}`
+      `Presign claim_tx version must be ${tt}, got ${e.version}`
     );
   if (r.witness.length > 0)
     throw new P(
       `Presign claim_tx input must have an empty witness, got ${r.witness.length} item(s)`
     );
-  if (e.outs.length !== ot)
+  if (e.outs.length !== rt)
     throw new P(
-      `Presign claim_tx must have exactly ${ot} outputs, got ${e.outs.length}`
+      `Presign claim_tx must have exactly ${rt} outputs, got ${e.outs.length}`
     );
 }
 function qt(e) {
@@ -1655,15 +1655,15 @@ function qt(e) {
     (o, s) => o.pubkey < s.pubkey ? -1 : o.pubkey > s.pubkey ? 1 : 0
   ), r = [e.peginTx, e.claimTx, e.assertTx, e.payoutTx];
   return t.forEach((o, s) => {
-    const n = de(o.pubkey, "challenger pubkey");
+    const n = he(o.pubkey, "challenger pubkey");
     if (s > 0 && t[s - 1].pubkey === n)
       throw new P(`Graph lists challenger ${n} twice`);
-    r.push(Ye(n), o.nopayoutTx);
+    r.push(We(n), o.nopayoutTx);
     for (const a of o.outputLabelHashes)
-      r.push(Ye(de(a, "output_label_hashes entry")));
-  }), Kr(Hr(Nr(...r)));
+      r.push(We(he(a, "output_label_hashes entry")));
+  }), Mr(Fr(Ur(...r)));
 }
-function Jo(e) {
+function ns(e) {
   const t = b(e.peginTxid).toLowerCase(), { peginTx: r, claimTx: o, assertTx: s } = Ut({
     peginTxHex: e.peginTxHex,
     claimTxHex: e.claimTxHex,
@@ -1674,7 +1674,7 @@ function Jo(e) {
     throw new P(
       `Presign pegin_tx hashes to ${r.getId()}, expected ${t}`
     );
-  Yo(o, t), Oe(s, o.getId(), "depositor_graph");
+  ss(o, t), Oe(s, o.getId(), "depositor_graph");
   const n = (a) => new Uint8Array(a.toBuffer());
   return qt({
     peginTx: n(r),
@@ -1690,9 +1690,9 @@ function Jo(e) {
     }))
   });
 }
-function Qo(e) {
-  const t = (o) => st(B($(e, o, "graph"), o).tx, o), r = B(
-    $(e, "challenger_subgraphs", "graph"),
+function is(e) {
+  const t = (o) => ot(B(k(e, o, "graph"), o).tx, o), r = B(
+    k(e, "challenger_subgraphs", "graph"),
     "challenger_subgraphs"
   );
   return qt({
@@ -1704,31 +1704,31 @@ function Qo(e) {
       const n = `challenger_subgraphs[${o}]`, a = B(s, n);
       return {
         pubkey: o,
-        nopayoutTx: st(
-          B($(a, "nopayout_tx", n), `${n}.nopayout_tx`).tx,
+        nopayoutTx: ot(
+          B(k(a, "nopayout_tx", n), `${n}.nopayout_tx`).tx,
           `${n}.nopayout_tx`
         ),
-        outputLabelHashes: Z(
-          $(a, "output_label_hashes", n),
+        outputLabelHashes: te(
+          k(a, "output_label_hashes", n),
           `${n}.output_label_hashes`
         ).map(
-          (i, u) => de(i, `${n}.output_label_hashes[${u}]`)
+          (i, u) => he(i, `${n}.output_label_hashes[${u}]`)
         )
       };
     })
   });
 }
-function Zo(e) {
+function as(e) {
   const t = B(
-    $(e, "challenger_pubkeys", "graph"),
+    k(e, "challenger_pubkeys", "graph"),
     "challenger_pubkeys"
   ), r = /* @__PURE__ */ new Set();
   for (const o of ["local", "universal"])
-    Z(
-      $(t, o, "challenger_pubkeys"),
+    te(
+      k(t, o, "challenger_pubkeys"),
       `challenger_pubkeys.${o}`
     ).forEach((s, n) => {
-      const a = de(s, `challenger_pubkeys.${o}[${n}]`);
+      const a = he(s, `challenger_pubkeys.${o}[${n}]`);
       if (r.has(a))
         throw new P(
           `Graph declares challenger ${a} more than once`
@@ -1737,71 +1737,152 @@ function Zo(e) {
     });
   return r;
 }
-function an(e, t) {
-  const r = Qo(e);
+function fn(e, t) {
+  const r = is(e);
   if (r !== t)
     throw new P(
       `Graph fingerprint ${r} does not match the presign fingerprint ${t}`
     );
   const o = Object.keys(
     B(e.challenger_subgraphs, "challenger_subgraphs")
-  ), s = Zo(e);
+  ), s = as(e);
   if (o.length !== s.size || o.some((n) => !s.has(n)))
     throw new P(
       `Graph challenger_subgraphs keys ${o.join(", ")} do not match challenger_pubkeys ${[...s].join(", ")}`
     );
 }
-const es = 1;
-function ts(e, t, r) {
+const us = 1;
+function cs(e, t, r) {
   const o = r.map(
-    (d) => b(d).toLowerCase()
-  ), s = t.filter((d) => o.includes(d));
+    (h) => b(h).toLowerCase()
+  ), s = t.filter((h) => o.includes(h));
   if (s.length > 0)
     throw new Error(
       `Cannot validate challenger set: vault keepers and universal challengers overlap (${s.join(", ")})`
     );
   const n = [...t, ...o], a = e.map(
-    (d) => b(d.challenger_pubkey).toLowerCase()
+    (h) => b(h.challenger_pubkey).toLowerCase()
   ), i = new Set(a);
   if (i.size !== a.length)
     throw new Error(
       "Depositor graph contains duplicate challenger entries in challenger_presign_data"
     );
-  const u = new Set(n), l = n.filter((d) => !i.has(d)), c = a.filter((d) => !u.has(d));
+  const u = new Set(n), l = n.filter((h) => !i.has(h)), c = a.filter((h) => !u.has(h));
   if (l.length > 0 || c.length > 0)
     throw new Error(
       "Depositor graph challenger set does not match expected (local ∪ universal)" + (l.length > 0 ? ` (missing: ${l.join(", ")})` : "") + (c.length > 0 ? ` (unexpected: ${c.join(", ")})` : "")
     );
+  return or(n);
 }
-function rs(e, t) {
-  const r = e.ins[t];
-  return Ve(new Uint8Array(r.hash).slice().reverse());
-}
-function $e(e, t, r, o, s) {
-  const n = e.ins[t];
-  if (n.index !== 0)
+function ls(e, t, r) {
+  const o = r >= Ar ? 1 : 0, s = _r + Sr * t + o;
+  if (e.outs.length !== s)
     throw new Error(
-      `NoPayout (challenger ${s}) input ${t} expected to spend ${o} vout 0, got vout ${n.index}`
-    );
-  const a = r.getId(), i = rs(e, t);
-  if (i !== a)
-    throw new Error(
-      `NoPayout (challenger ${s}) input ${t} does not reference ${o} (expected txid ${a}, got ${i})`
+      `Assert must have ${s} outputs for ${t} challengers (vault core version ${r}), got ${e.outs.length}`
     );
 }
-async function os(e, t, r) {
-  const o = [], s = [], n = [], a = wt({
-    claimerBtcPubkey: r.depositorBtcPubkey,
-    depositorBtcPubkey: r.depositorBtcPubkey,
-    vaultProviderBtcPubkey: r.vaultProviderBtcPubkey,
-    vaultKeeperBtcPubkeys: r.vaultKeeperBtcPubkeys
-  });
-  ts(
+async function Gt(e, t) {
+  const r = wt({
+    claimerBtcPubkey: t.depositorBtcPubkey,
+    depositorBtcPubkey: t.depositorBtcPubkey,
+    vaultProviderBtcPubkey: t.vaultProviderBtcPubkey,
+    vaultKeeperBtcPubkeys: t.vaultKeeperBtcPubkeys
+  }), o = cs(
     e.challenger_presign_data,
-    a,
-    r.universalChallengerBtcPubkeys
+    r,
+    t.universalChallengerBtcPubkeys
+  ), s = b(t.depositorBtcPubkey), n = S.fromHex(
+    b(e.assert_tx.tx_hex)
+  );
+  ls(
+    n,
+    o.length,
+    t.vaultCoreVersion
+  );
+  const a = [];
+  for (const i of e.challenger_presign_data) {
+    const u = b(i.challenger_pubkey), l = o.indexOf(
+      u.toLowerCase()
+    ), c = await ds({
+      challenger: i,
+      challengerPubkey: u,
+      challengerIndex: l,
+      challengerCount: o.length,
+      claimerPubkey: s,
+      assertTx: n,
+      ctx: t
+    });
+    a.push({ challenger: i, challengerPubkey: u, prevouts: c });
+  }
+  return { localChallengers: r, noPayouts: a };
+}
+async function ds(e) {
+  const {
+    challenger: t,
+    challengerPubkey: r,
+    challengerIndex: o,
+    challengerCount: s,
+    claimerPubkey: n,
+    assertTx: a,
+    ctx: i
+  } = e;
+  Gr(
+    t.nopayout_tx.tx_hex,
+    r,
+    i.network
   );
-  const i = await Cr({
+  const u = S.fromHex(
+    b(t.nopayout_tx.tx_hex)
+  ), l = S.fromHex(
+    b(t.challenge_assert_x_tx.tx_hex)
+  ), c = S.fromHex(
+    b(t.challenge_assert_y_tx.tx_hex)
+  ), h = await br({
+    txGraphVersion: i.vaultCoreVersion,
+    claimer: n,
+    challenger: r,
+    timelockChallengeAssert: i.timelockChallengeAssert,
+    outputLabelHashes: t.output_label_hashes.map(
+      (g) => g.toLowerCase()
+    ),
+    network: i.network
+  });
+  for (const [g, p] of [
+    ["X", l],
+    ["Y", c]
+  ])
+    Xr({
+      challengeAssertTx: p,
+      assertTx: a,
+      half: g,
+      challengerIndex: o,
+      challengerCount: s,
+      challengerPubkey: r,
+      outputConnectorScriptPubKey: h
+    });
+  const d = [
+    a.outs[G],
+    l.outs[Xe],
+    c.outs[Xe]
+  ];
+  return zr({
+    noPayoutTx: u,
+    assertTxid: a.getId(),
+    challengeAssertXTxid: l.getId(),
+    challengeAssertYTxid: c.getId(),
+    timelockChallengeAssert: i.timelockChallengeAssert,
+    prevoutValues: [
+      d[0].value,
+      d[1].value,
+      d[2].value
+    ]
+  }), d.map((g) => ({
+    script_pubkey: yt(new Uint8Array(g.script)),
+    value: g.value
+  }));
+}
+async function hs(e, t, r) {
+  const o = [], s = [], n = [], { localChallengers: a, noPayouts: i } = await Gt(e, r), u = await Vr({
     vaultCoreVersion: r.vaultCoreVersion,
     vkClaimerPayoutScriptPubKeys: r.vkClaimerPayoutScriptPubKeys,
     vpCommissionScriptPubKey: r.vpCommissionScriptPubKey,
@@ -1817,115 +1898,52 @@ async function os(e, t, r) {
     network: r.network,
     claimerBtcPubkey: r.depositorBtcPubkey,
     registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
-    commissionBps: es,
+    commissionBps: us,
     protocolFeeRate: r.protocolFeeRate,
     councilMembers: r.councilMembers,
     councilQuorum: r.councilQuorum
   });
-  o.push(i.psbtHex), s.push(
-    ue(
+  o.push(u.psbtHex), s.push(
+    ce(
       t,
-      ze
+      Ge
     )
   );
-  const u = b(r.depositorBtcPubkey), l = S.fromHex(
-    b(e.assert_tx.tx_hex)
-  );
-  for (const c of e.challenger_presign_data) {
-    const d = b(c.challenger_pubkey), h = o.length, g = await ss({
-      challenger: c,
-      challengerPubkey: d,
-      claimerPubkey: u,
-      localChallengers: a,
-      assertTxParsed: l,
-      ctx: r
+  const l = b(r.depositorBtcPubkey);
+  for (const { challenger: c, challengerPubkey: h, prevouts: d } of i) {
+    const g = o.length, p = await qr({
+      noPayoutTxHex: c.nopayout_tx.tx_hex,
+      challengerPubkey: h,
+      prevouts: d,
+      connectorParams: {
+        txGraphVersion: r.vaultCoreVersion,
+        claimer: l,
+        localChallengers: a,
+        universalChallengers: r.universalChallengerBtcPubkeys,
+        timelockAssert: r.timelockAssert,
+        councilMembers: r.councilMembers,
+        councilQuorum: r.councilQuorum
+      }
     });
-    o.push(g), s.push(
-      ue(
+    o.push(p), s.push(
+      ce(
         t,
-        ze
+        Ge
       )
     ), n.push({
-      challengerPubkey: d,
-      noPayoutIdx: h
+      challengerPubkey: h,
+      noPayoutIdx: g
     });
   }
   return { psbtHexes: o, signOptions: s, challengerEntries: n };
 }
-async function ss(e) {
-  const {
-    challenger: t,
-    challengerPubkey: r,
-    claimerPubkey: o,
-    localChallengers: s,
-    assertTxParsed: n,
-    ctx: a
-  } = e;
-  Or(
-    t.nopayout_tx.tx_hex,
-    r,
-    a.network
-  );
-  const i = S.fromHex(
-    b(t.nopayout_tx.tx_hex)
-  ), u = S.fromHex(
-    b(t.challenge_assert_x_tx.tx_hex)
-  ), l = S.fromHex(
-    b(t.challenge_assert_y_tx.tx_hex)
-  );
-  if (i.ins.length !== 3)
-    throw new Error(
-      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${i.ins.length}`
-    );
-  $e(
-    i,
-    0,
-    n,
-    "Assert",
-    r
-  ), $e(
-    i,
-    1,
-    u,
-    "ChallengeAssertX",
-    r
-  ), $e(
-    i,
-    2,
-    l,
-    "ChallengeAssertY",
-    r
-  );
-  const c = [
-    n.outs[0],
-    u.outs[0],
-    l.outs[0]
-  ].map((d) => ({
-    script_pubkey: Ve(new Uint8Array(d.script)),
-    value: d.value
-  }));
-  return Dr({
-    noPayoutTxHex: t.nopayout_tx.tx_hex,
-    challengerPubkey: r,
-    prevouts: c,
-    connectorParams: {
-      txGraphVersion: a.vaultCoreVersion,
-      claimer: o,
-      localChallengers: s,
-      universalChallengers: a.universalChallengerBtcPubkeys,
-      timelockAssert: a.timelockAssert,
-      councilMembers: a.councilMembers,
-      councilQuorum: a.councilQuorum
-    }
-  });
-}
-function ns(e, t, r) {
-  ie(e[0]);
-  const s = ae(
+function ps(e, t, r) {
+  ae(e[0]);
+  const s = ue(
     e[0].returnedPsbtHex,
     r
   );
-  re({
+  oe({
     requestedPsbtHex: e[0].requestedPsbtHex,
     signatureHex: s,
     signerXOnlyPubkeyHex: r,
@@ -1933,12 +1951,12 @@ function ns(e, t, r) {
   });
   const n = {};
   for (const a of t) {
-    ie(e[a.noPayoutIdx]);
-    const i = ae(
+    ae(e[a.noPayoutIdx]);
+    const i = ue(
       e[a.noPayoutIdx].returnedPsbtHex,
       r
     );
-    re({
+    oe({
       requestedPsbtHex: e[a.noPayoutIdx].requestedPsbtHex,
       signatureHex: i,
       signerXOnlyPubkeyHex: r,
@@ -1954,18 +1972,18 @@ function ns(e, t, r) {
     per_challenger: n
   };
 }
-async function is(e) {
+async function gs(e) {
   const { depositorGraph: t, btcWallet: r, signingContext: o } = e;
-  Wo({
+  os({
     peginTxHex: o.peginTxHex,
     claimTxHex: t.claim_tx.tx_hex,
     assertTxHex: t.assert_tx.tx_hex,
     path: "depositor_graph"
   });
-  const s = await r.getPublicKeyHex(), { depositorPubkey: n } = tr(
+  const s = await r.getPublicKeyHex(), { depositorPubkey: n } = rr(
     s,
     b(o.depositorBtcPubkey)
-  ), { psbtHexes: a, signOptions: i, challengerEntries: u } = await os(
+  ), { psbtHexes: a, signOptions: i, challengerEntries: u } = await hs(
     t,
     s,
     o
@@ -1973,17 +1991,17 @@ async function is(e) {
     r,
     a,
     i
-  ), c = a.map((d, h) => ({
-    requestedPsbtHex: d,
-    returnedPsbtHex: l[h]
+  ), c = a.map((h, d) => ({
+    requestedPsbtHex: h,
+    returnedPsbtHex: l[d]
   }));
-  return ns(
+  return ps(
     c,
     u,
     n
   );
 }
-const as = 1e4, L = 10;
+const fs = 1e4, M = 10;
 async function Xt(e) {
   const {
     statusReader: t,
@@ -1991,26 +2009,26 @@ async function Xt(e) {
     peginTxid: o,
     targetStatuses: s,
     timeoutMs: n,
-    pollIntervalMs: a = as,
+    pollIntervalMs: a = fs,
     signal: i
   } = e, u = Date.now();
   for (; ; ) {
     if (i != null && i.aborted)
       throw new Error(
-        `Polling aborted for vault ${r.slice(0, L)}… (target: ${[...s].join(", ")})`
+        `Polling aborted for vault ${r.slice(0, M)}… (target: ${[...s].join(", ")})`
       );
     if (Date.now() - u >= n)
       throw new Error(
-        `Polling timeout after ${n}ms for vault ${r.slice(0, L)}… (target: ${[...s].join(", ")})`
+        `Polling timeout after ${n}ms for vault ${r.slice(0, M)}… (target: ${[...s].join(", ")})`
       );
     try {
       const l = await t.getPeginStatusByVaultId(
         { vault_id: r },
         i
       );
-      if (We(l.vault_id) !== We(r))
+      if (je(l.vault_id) !== je(r))
         throw new Error(
-          `getPeginStatusByVaultId returned status for vault ${l.vault_id.slice(0, L)}…, requested ${r.slice(0, L)}…`
+          `getPeginStatusByVaultId returned status for vault ${l.vault_id.slice(0, M)}…, requested ${r.slice(0, M)}…`
         );
       if (l.pegin_txid.toLowerCase() !== o.toLowerCase())
         throw new Error(
@@ -2019,48 +2037,48 @@ async function Xt(e) {
       const c = l.status;
       if (s.has(c) || c === R.ACTIVATED)
         return c;
-      if (c === R.EXPIRED || Ir.has(c))
+      if (c === R.EXPIRED || Nr.has(c))
         throw new Error(
-          `Vault ${r.slice(0, L)}… reached terminal status "${c}" while waiting for ${[...s].join(", ")}`
+          `Vault ${r.slice(0, M)}… reached terminal status "${c}" while waiting for ${[...s].join(", ")}`
         );
     } catch (l) {
-      if (!(l instanceof Vr && l.code === Rr.PEGIN_NOT_FOUND))
+      if (!(l instanceof Dr && l.code === Lr.PEGIN_NOT_FOUND))
         throw l;
     }
     await new Promise((l, c) => {
-      const d = () => {
-        clearTimeout(h), c(
+      const h = () => {
+        clearTimeout(d), c(
           new Error(
-            `Polling aborted for vault ${r.slice(0, L)}… (target: ${[...s].join(", ")})`
+            `Polling aborted for vault ${r.slice(0, M)}… (target: ${[...s].join(", ")})`
           )
         );
-      }, h = setTimeout(() => {
-        i == null || i.removeEventListener("abort", d), l();
+      }, d = setTimeout(() => {
+        i == null || i.removeEventListener("abort", h), l();
       }, a);
-      i == null || i.addEventListener("abort", d, { once: !0 });
+      i == null || i.addEventListener("abort", h, { once: !0 });
     });
   }
 }
-const us = 1200 * 1e3, Gt = /* @__PURE__ */ new Set([
+const ys = 1200 * 1e3, zt = /* @__PURE__ */ new Set([
   R.PENDING_ACKS,
   R.PENDING_ACTIVATION,
   R.ACTIVATED_PENDING_BROADCAST,
   R.ACTIVATED
-]), cs = /* @__PURE__ */ new Set([
+]), vs = /* @__PURE__ */ new Set([
   R.PENDING_DEPOSITOR_SIGNATURES,
-  ...Gt
+  ...zt
 ]);
-function ls(e) {
+function bs(e) {
   return e.map((t) => ({
-    claimerPubkeyXOnly: he(t.claimer_pubkey),
+    claimerPubkeyXOnly: pe(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
     assertTxHex: t.assert_tx.tx_hex
   }));
 }
 function I(e) {
-  return he(e).toLowerCase();
+  return pe(e).toLowerCase();
 }
-function ds(e, t) {
+function ms(e, t) {
   const r = (u, l, c) => {
     throw new Error(
       `Deposit terms ${u} (${String(l)}) does not match the vault's version-locked signing context (${String(c)}); refusing to sign payouts against terms that describe a different graph.`
@@ -2074,8 +2092,8 @@ function ds(e, t) {
   for (const [u, l, c] of o)
     l !== c && r(u, l, c);
   const s = (u) => u.map(I).sort(), n = (u, l) => {
-    const c = s(u), d = s(l);
-    return c.length === d.length && c.every((h, g) => h === d[g]);
+    const c = s(u), h = s(l);
+    return c.length === h.length && c.every((d, g) => d === h[g]);
   };
   n(e.vaultKeeperBtcPubkeys, t.vaultKeeperBtcPubkeys) || r(
     "vaultKeeperBtcPubkeys",
@@ -2098,7 +2116,7 @@ function ds(e, t) {
     t.vaultProviderBtcPubkey
   );
 }
-function hs(e, t, r, o) {
+function Ps(e, t, r, o) {
   const s = I(o), n = [
     I(t),
     ...r.map(I)
@@ -2112,17 +2130,17 @@ function hs(e, t, r, o) {
       "Cannot validate claimer set: depositor key overlaps with vault provider or vault keeper set"
     );
   const i = e.map(
-    (h) => I(h.claimer_pubkey)
+    (d) => I(d.claimer_pubkey)
   );
   if (new Set(i).size !== i.length)
     throw new Error("Presign response contains duplicate claimer entries");
-  const u = i.filter((h) => h !== s), l = new Set(u), c = n.filter((h) => !l.has(h)), d = u.filter((h) => !a.has(h));
-  if (c.length > 0 || d.length > 0)
+  const u = i.filter((d) => d !== s), l = new Set(u), c = n.filter((d) => !l.has(d)), h = u.filter((d) => !a.has(d));
+  if (c.length > 0 || h.length > 0)
     throw new Error(
-      "Presign response claimer set does not match expected (vault provider ∪ vault keepers)" + (c.length > 0 ? ` (missing: ${c.join(", ")})` : "") + (d.length > 0 ? ` (unexpected: ${d.join(", ")})` : "")
+      "Presign response claimer set does not match expected (vault provider ∪ vault keepers)" + (c.length > 0 ? ` (missing: ${c.join(", ")})` : "") + (h.length > 0 ? ` (unexpected: ${h.join(", ")})` : "")
     );
 }
-function nt(e, t) {
+function st(e, t) {
   return {
     vaultCoreVersion: t.vaultCoreVersion,
     payoutTxHex: e.payoutTxHex,
@@ -2144,8 +2162,8 @@ function nt(e, t) {
     vpCommissionScriptPubKey: t.vpCommissionScriptPubKey
   };
 }
-async function ps(e, t, r, o) {
-  const s = new or({
+async function ws(e, t, r, o) {
+  const s = new nr({
     network: t.network,
     btcWallet: e
   }), n = r.length;
@@ -2153,14 +2171,14 @@ async function ps(e, t, r, o) {
   let a;
   if (s.supportsBatchSigning())
     a = (await s.signPayoutTransactionsBatch(
-      r.map((l) => nt(l, t))
+      r.map((l) => st(l, t))
     )).map((l) => l.payoutSignature);
   else {
     a = [];
     for (let u = 0; u < r.length; u++) {
       o == null || o(u, n);
       const l = await s.signPayoutTransaction(
-        nt(r[u], t)
+        st(r[u], t)
       );
       a.push(l.signature);
     }
@@ -2172,7 +2190,7 @@ async function ps(e, t, r, o) {
     };
   return o == null || o(n, n), i;
 }
-async function un(e) {
+async function yn(e) {
   const {
     statusReader: t,
     presignClient: r,
@@ -2182,21 +2200,21 @@ async function un(e) {
     depositorPk: a,
     signingContext: i,
     depositTerms: u,
-    timeoutMs: l = us,
+    timeoutMs: l = ys,
     signal: c,
-    onProgress: d,
-    recordGraphFingerprint: h
+    onProgress: h,
+    recordGraphFingerprint: d
   } = e, g = await Xt({
     statusReader: t,
     vaultId: s,
     peginTxid: n,
-    targetStatuses: cs,
+    targetStatuses: vs,
     timeoutMs: l,
     signal: c
   });
-  if (Gt.has(g))
+  if (zt.has(g))
     return;
-  c == null || c.throwIfAborted(), u !== void 0 && ds(u, i);
+  c == null || c.throwIfAborted(), u !== void 0 && ms(u, i);
   const p = vt(o) ? o : void 0;
   let y;
   if (p) {
@@ -2213,76 +2231,82 @@ async function un(e) {
     },
     c
   );
-  c == null || c.throwIfAborted(), f.txs.forEach((N, oe) => {
-    jo({
-      claimTxHex: N.claim_tx.tx_hex,
-      assertTxHex: N.assert_tx.tx_hex,
-      path: `txs[${oe}]`
+  c == null || c.throwIfAborted(), f.txs.forEach((O, se) => {
+    rs({
+      claimTxHex: O.claim_tx.tx_hex,
+      assertTxHex: O.assert_tx.tx_hex,
+      path: `txs[${se}]`
     });
   });
-  const m = Jo({
+  const m = ns({
     peginTxid: n,
     peginTxHex: i.peginTxHex,
     claimTxHex: f.depositor_graph.claim_tx.tx_hex,
     assertTxHex: f.depositor_graph.assert_tx.tx_hex,
     payoutTxHex: f.depositor_graph.payout_tx.tx_hex,
     challengers: f.depositor_graph.challenger_presign_data
-  }), k = I(a);
-  hs(
+  }), $ = {
+    vaultCoreVersion: i.vaultCoreVersion,
+    peginTxHex: i.peginTxHex,
+    depositorBtcPubkey: a,
+    vaultProviderBtcPubkey: i.vaultProviderBtcPubkey,
+    vaultKeeperBtcPubkeys: i.vaultKeeperBtcPubkeys,
+    universalChallengerBtcPubkeys: i.universalChallengerBtcPubkeys,
+    timelockPegin: i.timelockPegin,
+    timelockAssert: i.timelockAssert,
+    timelockChallengeAssert: i.timelockChallengeAssert,
+    councilMembers: i.councilMembers,
+    councilQuorum: i.councilQuorum,
+    network: i.network,
+    registeredPayoutScriptPubKey: i.registeredPayoutScriptPubKey,
+    protocolFeeRate: i.protocolFeeRate,
+    vkClaimerPayoutScriptPubKeys: i.vkClaimerPayoutScriptPubKeys,
+    vpCommissionScriptPubKey: i.vpCommissionScriptPubKey
+  };
+  await Gt(
+    f.depositor_graph,
+    $
+  ), c == null || c.throwIfAborted();
+  const x = I(a);
+  Ps(
     f.txs,
     i.vaultProviderBtcPubkey,
     i.vaultKeeperBtcPubkeys,
     a
   );
-  const x = f.txs.filter(
-    (N) => I(N.claimer_pubkey) !== k
-  ), v = ls(x);
+  const v = f.txs.filter(
+    (O) => I(O.claimer_pubkey) !== x
+  ), E = bs(v);
   p && y && (typeof p.validateDepositTerms == "function" && await p.validateDepositTerms(y), await p.approveDepositTerms(y)), c == null || c.throwIfAborted();
-  const E = await ps(
+  const T = await ws(
     o,
     i,
-    v,
-    d
+    E,
+    h
   );
   c == null || c.throwIfAborted();
-  const T = await is({
+  const w = await gs({
     depositorGraph: f.depositor_graph,
     btcWallet: o,
-    signingContext: {
-      vaultCoreVersion: i.vaultCoreVersion,
-      peginTxHex: i.peginTxHex,
-      depositorBtcPubkey: a,
-      vaultProviderBtcPubkey: i.vaultProviderBtcPubkey,
-      vaultKeeperBtcPubkeys: i.vaultKeeperBtcPubkeys,
-      universalChallengerBtcPubkeys: i.universalChallengerBtcPubkeys,
-      timelockPegin: i.timelockPegin,
-      timelockAssert: i.timelockAssert,
-      councilMembers: i.councilMembers,
-      councilQuorum: i.councilQuorum,
-      network: i.network,
-      registeredPayoutScriptPubKey: i.registeredPayoutScriptPubKey,
-      protocolFeeRate: i.protocolFeeRate,
-      vkClaimerPayoutScriptPubKeys: i.vkClaimerPayoutScriptPubKeys,
-      vpCommissionScriptPubKey: i.vpCommissionScriptPubKey
-    }
+    signingContext: $
   });
-  c == null || c.throwIfAborted(), await h(m), c == null || c.throwIfAborted();
-  const w = { ...E };
-  w[b(a)] = T.payout_signatures, await r.submitDepositorPresignatures(
+  c == null || c.throwIfAborted(), await d(m), c == null || c.throwIfAborted();
+  const j = { ...T };
+  j[b(a)] = w.payout_signatures, await r.submitDepositorPresignatures(
     {
       pegin_txid: n,
       depositor_pk: a,
-      signatures: w,
-      depositor_claimer_presignatures: T
+      signatures: j,
+      depositor_claimer_presignatures: w
     },
     c
   );
 }
-const gs = 300 * 1e3, fs = /* @__PURE__ */ new Set([
+const xs = 300 * 1e3, Es = /* @__PURE__ */ new Set([
   R.PENDING_DEPOSITOR_WOTS_PK,
-  ...Tt
+  ...Ct
 ]);
-async function cn(e) {
+async function vn(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
@@ -2290,7 +2314,7 @@ async function cn(e) {
     peginTxid: s,
     depositorPk: n,
     wotsPublicKeys: a,
-    timeoutMs: i = gs,
+    timeoutMs: i = xs,
     signal: u
   } = e;
   u == null || u.throwIfAborted();
@@ -2298,11 +2322,11 @@ async function cn(e) {
     statusReader: t,
     vaultId: o,
     peginTxid: s,
-    targetStatuses: fs,
+    targetStatuses: Es,
     timeoutMs: i,
     signal: u
   });
-  Tt.has(l) || (u == null || u.throwIfAborted(), await r.submitDepositorWotsKey(
+  Ct.has(l) || (u == null || u.throwIfAborted(), await r.submitDepositorWotsKey(
     {
       pegin_txid: s,
       depositor_pk: n,
@@ -2311,30 +2335,30 @@ async function cn(e) {
     u
   ));
 }
-function ke(e) {
+function $e(e) {
   return e.registration || e.operation;
 }
-function ys(e, t, r) {
+function ks(e, t, r) {
   const o = _(e);
   return {
     registration: o === _(t),
     operation: o === _(r)
   };
 }
-function it(e, t, r) {
-  const o = Te(e);
+function nt(e, t, r) {
+  const o = Ce(e);
   return {
-    registration: at(o, Te(t)),
-    operation: at(o, Te(r))
+    registration: it(o, Ce(t)),
+    operation: it(o, Ce(r))
   };
 }
-function Te(e) {
+function Ce(e) {
   return e.map(_).sort();
 }
-function at(e, t) {
+function it(e, t) {
   return e.length === t.length && e.every((r, o) => r === t[o]);
 }
-async function ln(e) {
+async function bn(e) {
   const {
     vaultProviderEthAddress: t,
     hintBtcPubkey: r,
@@ -2358,11 +2382,11 @@ class Se extends Error {
     super(t), this.name = "ApplicationEntryPointMismatchError";
   }
 }
-function dn(e) {
+function mn(e) {
   return e instanceof Se || e instanceof Error && e.name === "ApplicationEntryPointMismatchError";
 }
-const ut = (e) => e.map(_).sort();
-async function hn(e) {
+const at = (e) => e.map(_).sort();
+async function Pn(e) {
   const {
     vaultRegistryReader: t,
     vaultKeeperReader: r,
@@ -2374,8 +2398,8 @@ async function hn(e) {
     expectedUniversalChallengerBtcPubkeys: u,
     operationKeyReader: l,
     onIndexerServingOperationKeys: c,
-    onIndexerHintsInconsistent: d,
-    blockNumber: h
+    onIndexerHintsInconsistent: h,
+    blockNumber: d
   } = e, [
     g,
     p,
@@ -2384,49 +2408,49 @@ async function hn(e) {
   ] = await Promise.all([
     t.getVaultProviderApplication(
       s,
-      h
+      d
     ),
     t.getVaultProviderGenesisBtcPubKey(
       s,
-      h
+      d
     ),
-    o.getLatestUniversalChallengersVersion(h),
-    o.getCurrentUcKeyEpoch(h)
+    o.getLatestUniversalChallengersVersion(d),
+    o.getCurrentUcKeyEpoch(d)
   ]);
-  if (!Ar(n, { strict: !1 }))
+  if (!Hr(n, { strict: !1 }))
     throw new Se(
       `The application entry point this deposit was prepared for is not a valid address: ${n}`
     );
-  if (!Br(g, n))
+  if (!Or(g, n))
     throw new Se(
       `Vault provider ${s} is registered to application ${g}, but this deposit was prepared for ${n}. Refusing to build: the vault keeper roster, its version, and the keeper key epoch would all resolve against a different application than the one selected.`
     );
-  const [m, k] = await Promise.all(
+  const [m, $] = await Promise.all(
     [
       r.getCurrentVaultKeepersVersion(
         g,
-        h
+        d
       ),
       r.getCurrentAppKeeperKeyEpoch(
         g,
-        h
+        d
       )
     ]
   ), [x, v] = await Promise.all([
     r.getVaultKeepersByVersion(
       g,
       m,
-      h
+      d
     ),
     o.getUniversalChallengersByVersion(
       y,
-      h
+      d
     )
   ]), E = {
     vaultProvider: _(p),
-    vaultKeepers: ut(x.map((C) => C.btcPubKey)),
-    universalChallengers: ut(v.map((C) => C.btcPubKey))
-  }, T = await Ko({
+    vaultKeepers: at(x.map((C) => C.btcPubKey)),
+    universalChallengers: at(v.map((C) => C.btcPubKey))
+  }, T = await Uo({
     operationKeyReader: l,
     query: {
       vaultProviderEthAddress: s,
@@ -2435,44 +2459,44 @@ async function hn(e) {
       vaultKeepers: x,
       universalChallengers: v
     },
-    blockNumber: h
+    blockNumber: d
   }), w = {
     vaultProvider: T.vaultProvider.operationBtcPubkey,
     vaultKeepers: [...T.vaultKeeperOperationKeysSorted],
     universalChallengers: [
       ...T.universalChallengerOperationKeysSorted
     ]
-  }, N = ys(
+  }, j = ks(
     a,
     E.vaultProvider,
     w.vaultProvider
-  ), oe = it(
+  ), O = nt(
     i,
     E.vaultKeepers,
     w.vaultKeepers
-  ), De = it(
+  ), se = nt(
     u,
     E.universalChallengers,
     w.universalChallengers
   );
-  if (!ke(N))
+  if (!$e(j))
     throw new Error(
       `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${s}. Refresh and try again.`
     );
-  if (!ke(oe))
+  if (!$e(O))
     throw new Error(
       `Vault keeper BTC pubkeys (v${m}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
     );
-  if (!ke(De))
+  if (!$e(se))
     throw new Error(
       `Universal challenger BTC pubkeys (v${y}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
     );
-  const Me = [N, oe, De], Jt = Me.some((C) => C.registration && !C.operation), Le = Me.some((C) => C.operation && !C.registration);
-  if (Jt && Le) {
+  const Ne = [j, O, se], Qt = Ne.some((C) => C.registration && !C.operation), De = Ne.some((C) => C.operation && !C.registration);
+  if (Qt && De) {
     const C = `Indexer participant hints are internally inconsistent for vault provider ${s}: some roles match the registration keys while others match the rotated operation keys.`;
-    throw d == null || d(C), new Error(`${C} Refresh and try again.`);
+    throw h == null || h(C), new Error(`${C} Refresh and try again.`);
   }
-  return Le && (c == null || c(
+  return De && (c == null || c(
     `Indexer is serving rotated operation keys for vault provider ${s}`
   )), {
     vaultProviderBtcPubkeyXOnly: w.vaultProvider,
@@ -2480,16 +2504,16 @@ async function hn(e) {
     universalChallengerBtcPubkeysSorted: w.universalChallengers,
     expectedAppVaultKeepersVersion: m,
     expectedUniversalChallengersVersion: y,
-    appKeeperKeyEpoch: k,
+    appKeeperKeyEpoch: $,
     ucKeyEpoch: f,
     registrationKeys: E,
     participantKeys: T
   };
 }
-function vs(e) {
+function $s(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function pn(e) {
+function wn(e) {
   const {
     amountSats: t,
     minDeposit: r,
@@ -2500,29 +2524,29 @@ function pn(e) {
   } = e;
   return !(t <= 0n || t < r || o && o > 0n && t > o || n == null || a == null || t + n + a > s);
 }
-function gn(e, t, r) {
+function xn(e, t, r) {
   return e <= 0n ? {
     valid: !1,
     error: "Deposit amount must be greater than zero"
   } : e < t ? {
     valid: !1,
-    error: `Minimum deposit is ${O(t)} BTC`
+    error: `Minimum deposit is ${N(t)} BTC`
   } : r && r > 0n && e > r ? {
     valid: !1,
-    error: `Maximum deposit is ${O(r)} BTC`
+    error: `Maximum deposit is ${N(r)} BTC`
   } : { valid: !0 };
 }
-function fn(e) {
+function En(e) {
   const { amount: t, effectiveRemaining: r } = e;
   return r === null ? { valid: !0 } : r === 0n ? {
     valid: !1,
     error: "Supply cap reached — deposits temporarily paused"
   } : t > r ? {
     valid: !1,
-    error: `Vault size exceeds remaining capacity (${O(r)} BTC)`
+    error: `Vault size exceeds remaining capacity (${N(r)} BTC)`
   } : { valid: !0 };
 }
-function yn(e, t) {
+function kn(e, t) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -2538,7 +2562,7 @@ function yn(e, t) {
     error: "Invalid vault provider selected"
   } : { valid: !0 };
 }
-function bs(e, t, r) {
+function Cs(e, t, r) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -2554,40 +2578,40 @@ function bs(e, t, r) {
     if (t && s < t)
       return {
         valid: !1,
-        error: `Vault ${o + 1} amount ${O(s)} BTC is below minimum deposit ${O(t)} BTC`
+        error: `Vault ${o + 1} amount ${N(s)} BTC is below minimum deposit ${N(t)} BTC`
       };
     if (r && s > r)
       return {
         valid: !1,
-        error: `Vault ${o + 1} amount ${O(s)} BTC exceeds maximum deposit ${O(r)} BTC`
+        error: `Vault ${o + 1} amount ${N(s)} BTC exceeds maximum deposit ${N(r)} BTC`
       };
   }
   return { valid: !0 };
 }
-function ms(e) {
+function Ts(e) {
   const t = b(e);
-  return vs(t) ? { valid: !0 } : {
+  return $s(t) ? { valid: !0 } : {
     valid: !1,
     error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
   };
 }
-function Ps(e) {
+function _s(e) {
   if (!e || e.length === 0)
     throw new Error(
       "No vault keepers available. The system requires at least one vault keeper to create a deposit."
     );
 }
-function ws(e) {
+function Ss(e) {
   if (!e || e.length === 0)
     throw new Error(
       "No universal challengers available. The system requires at least one universal challenger to create a deposit."
     );
 }
-function xs(e) {
+function As(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function vn(e) {
+function $n(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
@@ -2596,38 +2620,38 @@ function vn(e) {
     universalChallengerBtcPubkeys: n,
     minDeposit: a,
     maxDeposit: i
-  } = e, u = bs(
+  } = e, u = Cs(
     t,
     a,
     i
   );
   if (!u.valid)
     throw new Error(u.error);
-  const l = ms(o);
+  const l = Ts(o);
   if (!l.valid)
     throw new Error(l.error);
-  Ps(s), ws(n), xs(r);
+  _s(s), Ss(n), As(r);
 }
-class zt extends Error {
+class jt extends Error {
   constructor(t) {
     super(t), this.name = "ParticipantKeyDriftError";
   }
 }
-function bn(e) {
-  return e instanceof zt || e instanceof Error && e.name === "ParticipantKeyDriftError";
+function Cn(e) {
+  return e instanceof jt || e instanceof Error && e.name === "ParticipantKeyDriftError";
 }
-function ct(e, t, r) {
+function ut(e, t, r) {
   return t.length === r.length && t.every((o, s) => o === r[s]) ? null : `${e} expected [${t.join(", ")}], got [${r.join(", ")}]`;
 }
-async function mn(e) {
+async function Tn(e) {
   const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: o, expected: s } = e, n = s.query;
   if (o.length === 0) return;
   const a = await t.getVaultKeyEpochsBatch(o), i = [];
   for (const [u, l] of a.entries()) {
     const c = o[u];
-    let d;
+    let h;
     try {
-      d = await Ot({
+      h = await Nt({
         operationKeyReader: r,
         query: n,
         epochs: l
@@ -2638,36 +2662,36 @@ async function mn(e) {
       );
       continue;
     }
-    d.vaultProvider.operationBtcPubkey !== s.vaultProvider.operationBtcPubkey && i.push(
-      `vault ${c}: vault provider key expected ${s.vaultProvider.operationBtcPubkey}, got ${d.vaultProvider.operationBtcPubkey}`
+    h.vaultProvider.operationBtcPubkey !== s.vaultProvider.operationBtcPubkey && i.push(
+      `vault ${c}: vault provider key expected ${s.vaultProvider.operationBtcPubkey}, got ${h.vaultProvider.operationBtcPubkey}`
     );
-    const h = ct(
+    const d = ut(
       `vault ${c}: vault keeper keys`,
       s.vaultKeeperOperationKeysSorted,
-      d.vaultKeeperOperationKeysSorted
+      h.vaultKeeperOperationKeysSorted
     );
-    h && i.push(h);
-    const g = ct(
+    d && i.push(d);
+    const g = ut(
       `vault ${c}: universal challenger keys`,
       s.universalChallengerOperationKeysSorted,
-      d.universalChallengerOperationKeysSorted
+      h.universalChallengerOperationKeysSorted
     );
     g && i.push(g);
   }
   if (i.length > 0)
-    throw new zt(
+    throw new jt(
       `Aborting BTC broadcast: participant operation keys changed during registration (${i.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-class jt extends Error {
+class Wt extends Error {
   constructor(t) {
     super(t), this.name = "RegisteredVaultVersionMismatchError";
   }
 }
-function Pn(e) {
-  return e instanceof jt || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
+function _n(e) {
+  return e instanceof Wt || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function wn(e) {
+async function Sn(e) {
   const {
     vaultRegistryReader: t,
     vaultIds: r,
@@ -2677,53 +2701,53 @@ async function wn(e) {
     expectedVaultCoreVersion: a
   } = e, i = await t.getProtocolInfoBatch(r), u = [];
   if (i.forEach((l, c) => {
-    const d = r[c];
+    const h = r[c];
     l.offchainParamsVersion !== o && u.push(
-      `vault ${d}: offchainParams expected v${o}, got v${l.offchainParamsVersion}`
+      `vault ${h}: offchainParams expected v${o}, got v${l.offchainParamsVersion}`
     ), l.appVaultKeepersVersion !== s && u.push(
-      `vault ${d}: appVaultKeepers expected v${s}, got v${l.appVaultKeepersVersion}`
+      `vault ${h}: appVaultKeepers expected v${s}, got v${l.appVaultKeepersVersion}`
     ), l.universalChallengersVersion !== n && u.push(
-      `vault ${d}: universalChallengers expected v${n}, got v${l.universalChallengersVersion}`
+      `vault ${h}: universalChallengers expected v${n}, got v${l.universalChallengersVersion}`
     ), l.vaultCoreVersion !== a && u.push(
-      `vault ${d}: vaultCoreVersion expected v${a} (build-time active), got v${l.vaultCoreVersion}`
+      `vault ${h}: vaultCoreVersion expected v${a} (build-time active), got v${l.vaultCoreVersion}`
     );
   }), u.length > 0)
-    throw new jt(
+    throw new Wt(
       `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${u.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-class Es extends Error {
+class Bs extends Error {
   constructor(r, o) {
     super(`Refund not yet mature (BIP68 not final): ${o.message}`);
-    z(this, "vaultId");
-    z(this, "cause");
+    W(this, "vaultId");
+    W(this, "cause");
     this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = o;
   }
 }
-const $s = /^0x[0-9a-fA-F]{64}$/, ks = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, Wt = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, Yt = 160, lt = 2e3, dt = 10n, ht = 100n;
-function xn(e) {
+const Is = /^0x[0-9a-fA-F]{64}$/, Vs = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, Yt = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, Jt = 160, ct = 2e3, lt = 10n, dt = 100n;
+function An(e) {
   if (!Number.isFinite(e) || e <= 0)
     throw new Error(
       `feeRateSatsVb must be a positive finite number, got ${e}`
     );
-  return BigInt(Math.ceil(e * Yt));
+  return BigInt(Math.ceil(e * Jt));
 }
-const Ts = 1, Cs = /non-BIP68-final/i;
+const Rs = 1, Ks = /non-BIP68-final/i;
 function Ae(e, t) {
   if (e.length !== 66)
     throw new Error(
       `${t} must be 32 bytes (66 hex chars with 0x prefix), got length ${e.length}`
     );
-  if (!$s.test(e))
+  if (!Is.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function Ce(e, t) {
+function Te(e, t) {
   if (!Number.isInteger(e) || e < 0)
     throw new Error(`${t} must be a non-negative integer, got ${e}`);
 }
-function _s(e) {
+function Hs(e) {
   if (Ae(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
     throw new Error(
       `htlcVout must be a non-negative integer, got ${e.htlcVout}`
@@ -2754,27 +2778,27 @@ function _s(e) {
     throw new Error(
       `batch[${e.htlcVout}].amount (${t.amount}) does not match target amount (${e.amount})`
     );
-  if (Ce(e.offchainParamsVersion, "offchainParamsVersion"), Ce(e.appVaultKeepersVersion, "appVaultKeepersVersion"), Ce(
+  if (Te(e.offchainParamsVersion, "offchainParamsVersion"), Te(e.appVaultKeepersVersion, "appVaultKeepersVersion"), Te(
     e.universalChallengersVersion,
     "universalChallengersVersion"
-  ), Ur(
+  ), Jr(
     e.vaultCoreVersion,
     "VaultRefundData.vaultCoreVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
     throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!ks.test(e.unsignedPrePeginTxHex))
+  if (!Vs.test(e.unsignedPrePeginTxHex))
     throw new Error(
       "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
     );
-  if (!e.depositorBtcPubkey || !Wt.test(e.depositorBtcPubkey))
+  if (!e.depositorBtcPubkey || !Yt.test(e.depositorBtcPubkey))
     throw new Error(
       "depositorBtcPubkey must be 32 or 33 bytes of hex (optional 0x prefix)"
     );
   if (typeof e.amount != "bigint" || e.amount <= 0n)
     throw new Error(`amount must be a positive bigint, got ${e.amount}`);
 }
-function Ss(e) {
-  if (!e.vaultProviderPubkey || !Wt.test(e.vaultProviderPubkey))
+function Os(e) {
+  if (!e.vaultProviderPubkey || !Yt.test(e.vaultProviderPubkey))
     throw new Error("vaultProviderPubkey must be 32 or 33 bytes of hex");
   if (e.vaultKeeperPubkeys.length === 0)
     throw new Error("vaultKeeperPubkeys must be non-empty");
@@ -2799,7 +2823,7 @@ function Ss(e) {
       `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
     );
 }
-async function En(e) {
+async function Bn(e) {
   const {
     vaultId: t,
     readVault: r,
@@ -2811,23 +2835,23 @@ async function En(e) {
   } = e;
   i == null || i.throwIfAborted(), Ae(t, "vaultId");
   const u = await r();
-  _s(u), i == null || i.throwIfAborted();
+  Hs(u), i == null || i.throwIfAborted();
   const l = await o(u);
-  if (Ss(l), i == null || i.throwIfAborted(), !Number.isFinite(s) || s <= 0)
+  if (Os(l), i == null || i.throwIfAborted(), !Number.isFinite(s) || s <= 0)
     throw new Error(`feeRate must be a positive number, got ${s}`);
-  if (s > lt)
+  if (s > ct)
     throw new Error(
-      `feeRate ${s} sat/vB exceeds refund safety cap ${lt} sat/vB; refusing to sign refund.`
+      `feeRate ${s} sat/vB exceeds refund safety cap ${ct} sat/vB; refusing to sign refund.`
     );
-  const c = BigInt(Math.ceil(s * Yt)), d = u.amount * dt / ht;
-  if (c > d)
+  const c = BigInt(Math.ceil(s * Jt)), h = u.amount * lt / dt;
+  if (c > h)
     throw new Error(
-      `Refund fee ${c} sats exceeds the per-vault safety cap of ${d} sats (${dt}/${ht} of vault.amount=${u.amount}); refusing to sign refund.`
+      `Refund fee ${c} sats exceeds the per-vault safety cap of ${h} sats (${lt}/${dt} of vault.amount=${u.amount}); refusing to sign refund.`
     );
   i == null || i.throwIfAborted();
-  const h = he(
+  const d = pe(
     u.depositorBtcPubkey
-  ), g = b(u.unsignedPrePeginTxHex), p = sr(g);
+  ), g = b(u.unsignedPrePeginTxHex), p = ir(g);
   if (p !== void 0 && p.vout !== u.batch.length)
     throw new Error(
       `Auth-anchor OP_RETURN at vout ${p.vout} does not match batch size (${u.batch.length} HTLC outputs expect the anchor at vout ${u.batch.length}). Refund refused — sibling HTLC vector is incomplete.`
@@ -2845,10 +2869,10 @@ async function En(e) {
     throw new Error(
       `Funded Pre-PegIn tx has ${f.outs.length} outputs but batch requires at least ${u.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
     );
-  const { psbtHex: m } = await Mr({
+  const { psbtHex: m } = await jr({
     prePeginParams: {
       vaultCoreVersion: u.vaultCoreVersion,
-      depositorPubkey: h,
+      depositorPubkey: d,
       vaultProviderPubkey: b(l.vaultProviderPubkey),
       vaultKeeperPubkeys: l.vaultKeeperPubkeys.map(b),
       universalChallengerPubkeys: l.universalChallengerPubkeys.map(b),
@@ -2879,52 +2903,52 @@ async function En(e) {
     hashlock: b(u.hashlock)
   });
   i == null || i.throwIfAborted();
-  const k = ue(
+  const $ = ce(
     u.depositorBtcPubkey,
-    Ts
-  ), x = await n(m, k);
-  ie({
+    Rs
+  ), x = await n(m, $);
+  ae({
     requestedPsbtHex: m,
     returnedPsbtHex: x
   });
-  const v = 0, E = ae(
+  const v = 0, E = ue(
     x,
-    h,
+    d,
     v
   );
-  re({
+  oe({
     requestedPsbtHex: m,
     signatureHex: E,
-    signerXOnlyPubkeyHex: h,
+    signerXOnlyPubkeyHex: d,
     inputIndex: v
   });
-  const T = Ct({
+  const T = Tt({
     requestedPsbtHex: m,
     signaturesHex: [E],
-    signerXOnlyPubkeyHex: h
+    signerXOnlyPubkeyHex: d
   });
   i == null || i.throwIfAborted();
   try {
     return await a(T);
   } catch (w) {
-    throw w instanceof Error && Cs.test(w.message) ? new Es(t, w) : w;
+    throw w instanceof Error && Ks.test(w.message) ? new Bs(t, w) : w;
   }
 }
-class pt extends Error {
+class ht extends Error {
   constructor(r, o, s) {
     super(r);
     /** Fee the reclaim would have paid, in satoshis. */
-    z(this, "feeSats");
+    W(this, "feeSats");
     /** Sum of the reserves the reclaim would have swept, in satoshis. */
-    z(this, "sweptTotalSats");
+    W(this, "sweptTotalSats");
     this.name = "ReclaimUneconomicalError", this.feeSats = o, this.sweptTotalSats = s;
   }
 }
-const gt = 2e3, ft = 25n, yt = 100n, $n = 10n;
-async function As(e, t, r) {
+const pt = 2e3, gt = 25n, ft = 100n, In = 10n;
+async function Ns(e, t, r) {
   for (let o = 0; o < e.length; o++) {
-    const s = qr(e[o].depositorSignedPeginTxHex), n = Ie(
-      await yr(
+    const s = Qr(e[o].depositorSignedPeginTxHex), n = Ie(
+      await mr(
         b(s),
         b(r)
       )
@@ -2935,7 +2959,7 @@ async function As(e, t, r) {
       );
   }
 }
-async function kn(e) {
+async function Vn(e) {
   const {
     vaultIds: t,
     depositorEthAddress: r,
@@ -2950,9 +2974,9 @@ async function kn(e) {
     throw new Error("Reclaim requires at least one vault id; got none.");
   if (!Number.isFinite(n) || n <= 0)
     throw new Error(`feeRate must be a positive number, got ${n}`);
-  if (n > gt)
-    throw new pt(
-      `Fee rate ${n} sat/vB exceeds the reclaim safety cap of ${gt} sat/vB; refusing to sign.`,
+  if (n > pt)
+    throw new ht(
+      `Fee rate ${n} sat/vB exceeds the reclaim safety cap of ${pt} sat/vB; refusing to sign.`,
       0n,
       0n
     );
@@ -2961,127 +2985,127 @@ async function kn(e) {
     throw new Error(
       `readVaults returned ${l.length} reserves for ${t.length} vault id(s); refusing to sweep a set that does not match the request.`
     );
-  await As(l, t, r), u == null || u.throwIfAborted();
-  const c = he(o), d = l.map((v) => ({
+  await Ns(l, t, r), u == null || u.throwIfAborted();
+  const c = pe(o), h = l.map((v) => ({
     depositorSignedPeginTxHex: v.depositorSignedPeginTxHex,
     observed: v.observed,
     expectedValue: v.expectedClaimValue
-  })), h = Lr(n, d.length), g = d.reduce((v, E) => v + E.expectedValue, 0n), p = g * ft / yt;
-  if (h > p)
-    throw new pt(
-      `Reclaim fee ${h} sats exceeds ${ft}/${yt} of the swept total (${g} sats, cap ${p} sats). The reserve is not at risk — it stays where it is until fee rates fall.`,
-      h,
+  })), d = Wr(n, h.length), g = h.reduce((v, E) => v + E.expectedValue, 0n), p = g * gt / ft;
+  if (d > p)
+    throw new ht(
+      `Reclaim fee ${d} sats exceeds ${gt}/${ft} of the swept total (${g} sats, cap ${p} sats). The reserve is not at risk — it stays where it is until fee rates fall.`,
+      d,
       g
     );
   u == null || u.throwIfAborted();
-  const { psbtHex: y } = Fr({
+  const { psbtHex: y } = Yr({
     depositorPubkey: c,
-    inputs: d,
-    feeSats: h
+    inputs: h,
+    feeSats: d
   });
   u == null || u.throwIfAborted();
-  const f = ue(
+  const f = ce(
     o,
-    d.length
+    h.length
   ), m = await a(y, f);
-  ie({
+  ae({
     requestedPsbtHex: y,
     returnedPsbtHex: m
   });
-  const k = d.map((v, E) => {
-    const T = ae(
+  const $ = h.map((v, E) => {
+    const T = ue(
       m,
       c,
       E
     );
-    return re({
+    return oe({
       requestedPsbtHex: y,
       signatureHex: T,
       signerXOnlyPubkeyHex: c,
       inputIndex: E
     }), T;
-  }), x = Ct({
+  }), x = Tt({
     requestedPsbtHex: y,
-    signaturesHex: k,
+    signaturesHex: $,
     signerXOnlyPubkeyHex: c
   });
   return u == null || u.throwIfAborted(), i(x);
 }
 export {
-  wn as $,
+  Sn as $,
   K as A,
-  an as B,
-  eo as C,
+  fn as B,
+  uo as C,
   U as D,
-  Qo as E,
-  un as F,
+  is as E,
+  yn as F,
   P as G,
-  is as H,
-  cn as I,
+  gs as H,
+  vn as I,
   Se as J,
-  dn as K,
-  hn as L,
-  pn as M,
-  gn as N,
-  vn as O,
-  ro as P,
-  yn as Q,
-  fn as R,
-  j as S,
-  bs as T,
-  ms as U,
-  io as V,
-  zt as W,
-  bn as X,
-  mn as Y,
-  jt as Z,
-  Pn as _,
-  Js as a,
+  mn as K,
+  Pn as L,
+  wn as M,
+  xn as N,
+  $n as O,
+  lo as P,
+  kn as Q,
+  En as R,
+  Y as S,
+  Cs as T,
+  Ts as U,
+  fo as V,
+  jt as W,
+  Cn as X,
+  Tn as Y,
+  Wt as Z,
+  _n as _,
+  nn as a,
   Xt as a0,
-  ln as a1,
-  ke as a2,
-  ys as a3,
-  it as a4,
-  Ho as a5,
-  Ko as a6,
-  Ot as a7,
-  Es as a8,
-  En as a9,
-  xn as aa,
-  ht as ab,
-  dt as ac,
-  lt as ad,
-  Yt as ae,
-  pt as af,
-  kn as ag,
-  yt as ah,
-  ft as ai,
-  gt as aj,
-  $n as ak,
-  Qs as b,
-  Zs as c,
-  tn as d,
-  wo as e,
-  Qr as f,
-  to as g,
-  rn as h,
-  oo as i,
-  se as j,
-  no as k,
-  co as l,
-  en as m,
-  Eo as n,
-  So as o,
-  bo as p,
-  ko as q,
-  on as r,
-  po as s,
+  bn as a1,
+  $e as a2,
+  ks as a3,
+  nt as a4,
+  qo as a5,
+  Uo as a6,
+  Nt as a7,
+  Bs as a8,
+  Bn as a9,
+  An as aa,
+  dt as ab,
+  lt as ac,
+  ct as ad,
+  Jt as ae,
+  ht as af,
+  Vn as ag,
+  ft as ah,
+  gt as ai,
+  pt as aj,
+  In as ak,
+  an as b,
+  un as c,
+  ln as d,
+  So as e,
+  io as f,
+  co as g,
+  dn as h,
+  ho as i,
+  ne as j,
+  go as k,
+  bo as l,
+  cn as m,
+  Bo as n,
+  Oo as o,
+  Co as p,
+  Vo as q,
+  hn as r,
+  wo as s,
   St as t,
-  No as u,
+  Go as u,
   Dt as v,
-  Mt as w,
-  Lo as x,
-  sn as y,
-  nn as z
+  Lt as w,
+  Wo as x,
+  pn as y,
+  gn as z
 };
-//# sourceMappingURL=buildAndBroadcastReclaim-CcQ0b1be.js.map
+//# sourceMappingURL=buildAndBroadcastReclaim-CQANDXVJ.js.map