@babylonlabs-io/ts-sdk 5.1.0 → 6.0.0

package/dist/{buildAndBroadcastReclaim-Acz637Vf.js → buildAndBroadcastReclaim-Bs_zdDGN.js}

@@ -1,58 +1,58 @@
-var tr = Object.defineProperty;
-var rr = (e, t, r) => t in e ? tr(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var W = (e, t, r) => rr(e, typeof t != "symbol" ? t + "" : t, r);
+var rr = Object.defineProperty;
+var or = (e, t, r) => t in e ? rr(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var B = (e, t, r) => or(e, typeof t != "symbol" ? t + "" : t, r);
 import { B as Be } from "./BTCVaultRegistry.abi-DnP4UkB5.js";
-import { e as Ie, s as P, i as or, u as yt, c as _, v as sr, g as nr, p as he, f as N } from "./bitcoin-C-TuHb-v.js";
-import { v as ir, s as vt, b as Pt, P as ar, d as ur } from "./PayoutManager-BHeiLQ1j.js";
-import { verifyWatchtowerArtifacts as cr, buildClaimPsbt as lr, buildAssertClaimerPsbt as pr, buildPayoutClaimerPsbt as dr, buildWronglyChallengedPsbts as hr, buildPayoutDepositorPsbt as gr, finalizeClaimTx as fr, buildWatchtowerArtifacts as yr, extractTapScriptSig as mt, expandWotsSeed as vr, wotsKeypairFromSeed as Pr, validateWotsKeypairAgainstGraph as mr, getChallengeAssertOutputScriptPubKey as br, deriveVaultId as wr } from "./tbv/core/wasm/index.js";
-import { m as xr, d as bt, k as Er, a as _e, V as Le, i as kr, g as $r, f as Cr, r as Tr, h as _r } from "./registration-records-D39ApuHS.js";
-import { Psbt as q, Transaction as S } from "bitcoinjs-lib";
-import { F as U, G as A, H as re, I as J, A as G, z as Z, J as ge, v as Me, E as ee, K as Ve, w as Ue, x as Fe, y as qe, W as Sr, D as Ge, C as Xe, L as Ar, O as Br, Q as Ir } from "./constants-CmDDuM3L.js";
-import { p as Vr, q as Rr, r as wt, P as X, j as oe, f as Kr, i as ae, g as ue, s as Hr } from "./verifyScriptPathSchnorrSignature-DLNGgm4j.js";
-import { Buffer as H } from "buffer";
-import { C as xt, X as Et } from "./validation-OSC0xTHB.js";
+import { e as Ie, s as P, i as sr, u as vt, c as _, v as nr, g as ir, p as he, f as D } from "./bitcoin-C-TuHb-v.js";
+import { v as ar, s as Pt, b as mt, P as ur, d as cr } from "./PayoutManager-BHeiLQ1j.js";
+import { verifyWatchtowerArtifacts as lr, buildClaimPsbt as dr, buildAssertClaimerPsbt as pr, buildPayoutClaimerPsbt as hr, buildWronglyChallengedPsbts as gr, buildPayoutDepositorPsbt as fr, finalizeClaimTx as yr, buildWatchtowerArtifacts as vr, extractTapScriptSig as bt, expandWotsSeed as Pr, wotsKeypairFromSeed as mr, validateWotsKeypairAgainstGraph as br, getChallengeAssertOutputScriptPubKey as wr, deriveVaultId as xr } from "./tbv/core/wasm/index.js";
+import { m as Er, d as wt, k as $r, a as _e, V as Le, i as kr, g as Cr, f as Tr, r as _r, h as Sr } from "./registration-records-D39ApuHS.js";
+import { Psbt as G, Transaction as S } from "bitcoinjs-lib";
+import { F, G as A, H as re, I as J, A as X, z as Z, J as ge, v as Me, E as ee, K as Ve, w as Ue, x as Fe, y as qe, W as Ar, D as Ge, C as Xe, L as Br, O as Ir, Q as Vr } from "./constants-CmDDuM3L.js";
+import { p as Rr, q as Kr, r as xt, P as z, j as oe, f as Hr, i as ae, g as ue, s as Or } from "./verifyScriptPathSchnorrSignature-DLNGgm4j.js";
+import { Buffer as O } from "buffer";
+import { C as Et, X as $t } from "./validation-OSC0xTHB.js";
 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 Or } from "./types-K_aM5GZO.js";
-import { zeroAddress as Nr, isAddress as Dr, isAddressEqual as Lr } from "viem";
-import { v as je, D as R, c as Mr, b as Ur, R as Fr, d as Ct } from "./state-CFn1rT74.js";
-import { h as We, b as qr, s as Gr, j as Xr } from "./sha2-YqVHJiFj.js";
-import { c as zr, g as jr, h as Wr, i as Yr, b as Qr, f as Tt, e as Jr, a as Zr } from "./challengeAssert-D_lRvsO0.js";
-import { a as eo } from "./secp256k1-BuxBFUHm.js";
-import { c as to } from "./btcTxHash-BRZ8_EZq.js";
-const ro = /^0x[0-9a-fA-F]{64}$/, oo = /^0x[0-9a-fA-F]{40}$/, so = /^0x([0-9a-fA-F]{2})*$/;
+import { d as Ct } from "./deriveVaultRoot-BcvmER1E.js";
+import { O as ze, d as Nr } from "./types-K_aM5GZO.js";
+import { zeroAddress as Dr, isAddress as Lr, isAddressEqual as Mr } from "viem";
+import { v as je, D as K, c as Ur, b as Fr, R as qr, d as Tt } from "./state-CFn1rT74.js";
+import { h as We, b as Gr, s as Xr, j as zr } from "./sha2-YqVHJiFj.js";
+import { c as jr, g as Wr, h as Yr, i as Qr, b as Jr, f as _t, e as Zr, a as eo } from "./challengeAssert-D_lRvsO0.js";
+import { a as to } from "./secp256k1-BuxBFUHm.js";
+import { c as ro } from "./btcTxHash-BRZ8_EZq.js";
+const oo = /^0x[0-9a-fA-F]{64}$/, so = /^0x[0-9a-fA-F]{40}$/, no = /^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 (!ro.test(e))
+  if (!oo.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function no(e, t) {
-  if (!oo.test(e))
+function io(e, t) {
+  if (!so.test(e))
     throw new Error(
       `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
     );
 }
-function io(e, t) {
-  if (!so.test(e))
+function ao(e, t) {
+  if (!no.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
 }
 function Re(e) {
-  no(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), ye(e.vaultId, "vaultId");
+  io(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), ye(e.vaultId, "vaultId");
   const t = Ie(e.secret);
-  if (ye(t, "secret"), e.hashlock !== void 0 && (ye(e.hashlock, "hashlock"), !ir(t, e.hashlock)))
+  if (ye(t, "secret"), e.hashlock !== void 0 && (ye(e.hashlock, "hashlock"), !ar(t, e.hashlock)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
   return t;
 }
-async function cn(e) {
+async function pn(e) {
   const {
     btcVaultRegistryAddress: t,
     vaultId: r,
@@ -68,14 +68,14 @@ async function cn(e) {
     secret: e.secret,
     hashlock: o
   });
-  return io(s, "activationMetadata"), n({
+  return ao(s, "activationMetadata"), n({
     address: t,
     abi: Be,
     functionName: "activateVaultWithSecret",
     args: [r, i, s]
   });
 }
-async function ln(e) {
+async function hn(e) {
   const { btcVaultRegistryAddress: t, vaultId: r, hashlock: o, writeContract: s, signal: n } = e;
   n == null || n.throwIfAborted();
   const a = Re({
@@ -91,7 +91,7 @@ async function ln(e) {
     args: [r, a]
   });
 }
-async function pn(e) {
+async function gn(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");
@@ -108,22 +108,22 @@ async function pn(e) {
     args: [r, a]
   });
 }
-class K extends Error {
+class H extends Error {
   constructor(t, r) {
     super(t, r), this.name = "AssertBindingError";
   }
 }
 function ve(e, t) {
   try {
-    return q.fromBase64(t);
+    return G.fromBase64(t);
   } catch (r) {
-    throw new K(`${e} PSBT cannot be parsed.`, { cause: r });
+    throw new H(`${e} PSBT cannot be parsed.`, { cause: r });
   }
 }
-function ao(e, t, r) {
+function uo(e, t, r) {
   const o = t.txInputs[r];
   if (!o)
-    throw new K(`${e} PSBT has no input ${r}.`);
+    throw new H(`${e} PSBT has no input ${r}.`);
   return o.hash;
 }
 function Ye(e) {
@@ -134,61 +134,61 @@ function Ye(e) {
 function Pe(e, t, r, o, s, n) {
   const a = t.txInputs[r];
   if (!a)
-    throw new K(`${e} PSBT has no input ${r}.`);
+    throw new H(`${e} PSBT has no input ${r}.`);
   if (!a.hash.equals(o) || a.index !== s)
-    throw new K(
+    throw new H(
       `${e} input ${r} does not spend ${n}: the graph pairs this ${e} with a different transaction.`
     );
 }
-function uo(e, t) {
+function co(e, t) {
   var s;
-  const r = (s = e.data.inputs[U]) == null ? void 0 : s.witnessUtxo;
+  const r = (s = e.data.inputs[F]) == null ? void 0 : s.witnessUtxo;
   if (r === void 0)
-    throw new K(
-      `Assert input ${U} carries no witnessUtxo, so the amount and script its signature commits to cannot be checked; refusing to sign assert.`
+    throw new H(
+      `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[J];
   if (!o)
-    throw new K(
+    throw new H(
       `Claim PSBT has no output ${J} for the Assert to spend; refusing to sign assert.`
     );
   if (r.value !== o.value)
-    throw new K(
-      `Assert input ${U} declares a prevout of ${r.value} sats but the Claim's output ${J} is worth ${o.value}; refusing to sign assert.`
+    throw new H(
+      `Assert input ${F} declares a prevout of ${r.value} sats but the Claim's output ${J} is worth ${o.value}; refusing to sign assert.`
     );
   if (!r.script.equals(o.script))
-    throw new K(
-      `Assert input ${U} declares a prevout script that is not the Claim's output ${J} script; refusing to sign assert.`
+    throw new H(
+      `Assert input ${F} declares a prevout script that is not the Claim's output ${J} script; refusing to sign assert.`
     );
 }
-function co(e) {
+function lo(e) {
   const t = ve("Claim", e.claimPsbtBase64), r = ve("Assert", e.assertPsbtBase64), o = ve("Payout", e.payoutClaimerPsbtBase64);
   Pe(
     "Assert",
     r,
-    U,
+    F,
     Ye(t),
     J,
     "Claim:0"
-  ), uo(r, t), Pe(
+  ), co(r, t), Pe(
     "Payout",
     o,
     A,
     Ye(r),
-    G,
+    X,
     "Assert:0"
   ), Pe(
     "Payout",
     o,
     re,
-    ao("Claim", t, ge),
+    uo("Claim", t, ge),
     Z,
     "this vault's PegIn:0"
   );
 }
 function me(e, t) {
   try {
-    return q.fromBase64(t);
+    return G.fromBase64(t);
   } catch (r) {
     throw new Error(`${e} PSBT cannot be parsed.`, { cause: r });
   }
@@ -204,7 +204,7 @@ function Qe(e, t, r, o) {
     {
       inputIndex: A,
       expectedSats: o.value,
-      source: `the Assert's output ${G}`
+      source: `the Assert's output ${X}`
     }
   ];
   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 ${G} script; refusing to sign payout.`
+      `${e} Payout input ${A} declares a prevout script that is not the Assert's output ${X} script; refusing to sign payout.`
     );
 }
-async function lo(e) {
+async function po(e) {
   const { vault: t } = e, r = {
     vaultCoreVersion: t.vaultCoreVersion,
     numVaultKeepers: t.vaultKeeperBtcPubkeys.length,
@@ -232,7 +232,7 @@ async function lo(e) {
     councilSize: t.councilSize,
     protocolFeeRate: t.protocolFeeRate
   };
-  Vr(r);
+  Rr(r);
   const o = me("Claimer Payout", e.payoutClaimerPsbtBase64), s = me(
     "Depositor Payout",
     e.payoutDepositorPsbtBase64
@@ -241,10 +241,10 @@ async function lo(e) {
     throw new Error(
       "Depositor and claimer Payout PSBTs describe different transactions; refusing to sign payout."
     );
-  const a = n.txOutputs[G];
+  const a = n.txOutputs[X];
   if (a === void 0)
     throw new Error(
-      `Assert transaction has no output ${G}; the Payout's implicit fee cannot be measured.`
+      `Assert transaction has no output ${X}; the Payout's implicit fee cannot be measured.`
     );
   if (o.txInputs.length !== Me)
     throw new Error(
@@ -276,27 +276,27 @@ async function lo(e) {
     throw new Error(
       `Payout transaction has ${c.length} output(s), expected exactly ${ee} for a depositor-as-claimer payout.`
     );
-  let d = 0;
-  for (const p of c) d += p.value;
-  if (d > l)
+  let p = 0;
+  for (const d of c) p += d.value;
+  if (p > l)
     throw new Error(
-      `Payout outputs (${d} sats) exceed inputs (${l} sats); invalid transaction.`
+      `Payout outputs (${p} sats) exceed inputs (${l} sats); invalid transaction.`
     );
-  await Rr(r, {
-    implicitFeeSats: l - d,
+  await Kr(r, {
+    implicitFeeSats: l - p,
     out0Len: c[Ve].script.length,
     out1Len: void 0
   });
 }
-class po extends Error {
+class ho 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 ho(e) {
-  const t = wt({
+function go(e) {
+  const t = xt({
     claimerBtcPubkey: e.depositorBtcPubkey,
     depositorBtcPubkey: e.depositorBtcPubkey,
     vaultProviderBtcPubkey: e.vaultProviderBtcPubkey,
@@ -313,26 +313,26 @@ function ho(e) {
     );
   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 po(u, l);
+    throw new ho(u, l);
 }
 function Je(e) {
   return P(e).toLowerCase();
 }
-class go extends Error {
+class fo extends Error {
   constructor(t, r) {
     super(
       `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 fo(e) {
+function yo(e) {
   let t;
   try {
-    t = q.fromBase64(e.payoutPsbtBase64);
+    t = G.fromBase64(e.payoutPsbtBase64);
   } catch (c) {
     throw new Error("Payout PSBT cannot be parsed.", { cause: c });
   }
-  const { version: r, locktime: o, outs: s } = yo(t);
+  const { version: r, locktime: o, outs: s } = vo(t);
   if (r !== Ue || o !== Fe)
     throw new Error(
       `Payout transaction has version ${r} and locktime ${o}, expected ${Ue} and ${Fe}.`
@@ -350,26 +350,26 @@ function fo(e) {
     );
   const a = s[Ve].script.toString("hex").toLowerCase();
   if (a !== n)
-    throw new go(n, a);
+    throw new fo(n, a);
   const i = s[ee - 1];
   if (i.value !== qe)
     throw new Error(
       `Payout CPFP anchor value ${i.value} sats must equal ${qe} sats.`
     );
   const u = P(
-    xr(P(e.depositorBtcPubkey).toLowerCase())
+    Er(P(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 yo(e) {
+function vo(e) {
   return {
     version: e.version,
     locktime: e.locktime,
     outs: e.txOutputs.map((t) => ({
-      script: H.from(t.script),
+      script: O.from(t.script),
       value: t.value
     }))
   };
@@ -379,8 +379,8 @@ class ne extends Error {
     super(t), this.name = "PayoutInputLeafError";
   }
 }
-function vo(e) {
-  const t = q.fromBase64(e.payoutDepositorPsbtBase64), r = q.fromBase64(e.payoutClaimerPsbtBase64), o = t.data.globalMap.unsignedTx.toBuffer(), s = r.data.globalMap.unsignedTx.toBuffer();
+function Po(e) {
+  const t = G.fromBase64(e.payoutDepositorPsbtBase64), r = G.fromBase64(e.payoutClaimerPsbtBase64), o = t.data.globalMap.unsignedTx.toBuffer(), s = r.data.globalMap.unsignedTx.toBuffer();
   if (!o.equals(s))
     throw new ne(
       "Depositor and claimer Payout PSBTs describe different transactions; the graph is inconsistent."
@@ -404,59 +404,59 @@ function vo(e) {
     ...n.tapMerkleRoot ? { tapMerkleRoot: n.tapMerkleRoot } : {}
   }), t.toBase64();
 }
-class Po extends Error {
+class mo 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 mo(e) {
+function bo(e) {
   let t;
   try {
-    t = q.fromBase64(e);
+    t = G.fromBase64(e);
   } catch (o) {
     throw new Error("Claim PSBT cannot be parsed.", { cause: o });
   }
   const r = t.txInputs[ge];
   if (!r)
     throw new Error("Claim PSBT carries no PegIn input to bind the vault to.");
-  return _t(
+  return St(
     "Claim PSBT",
     t.txInputs.length,
     r.index
   ), Ke(r.hash);
 }
-function bo(e) {
+function wo(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."
     );
-  return _t(
+  return St(
     "Artifacts file's claim_tx",
     e.ins.length,
     t.index
   ), Ke(t.hash);
 }
-function _t(e, t, r) {
-  if (t !== 1 || r !== X)
+function St(e, t, r) {
+  if (t !== 1 || r !== z)
     throw new Error(
-      `${e} must have exactly one input spending PegIn output ${X}; it has ${t} input(s) and the first spends output ${r}.`
+      `${e} must have exactly one input spending PegIn output ${z}; it has ${t} input(s) and the first spends output ${r}.`
     );
 }
-function St(e) {
-  const t = z(
-    bt(e.peginTxid, e.depositorEthAddress)
-  ), r = z(e.expectedVaultId);
+function At(e) {
+  const t = j(
+    wt(e.peginTxid, e.depositorEthAddress)
+  ), r = j(e.expectedVaultId);
   if (t !== r)
-    throw new Po(r, t, e.peginTxid);
+    throw new mo(r, t, e.peginTxid);
 }
-function z(e) {
+function j(e) {
   return `0x${(e.startsWith("0x") ? e.slice(2) : e).toLowerCase()}`;
 }
 function Ke(e) {
-  return H.from(e).reverse().toString("hex");
+  return O.from(e).reverse().toString("hex");
 }
 function le(e, t) {
   const r = P(e);
@@ -464,7 +464,7 @@ function le(e, t) {
     throw new Error(`${t} must be non-empty, even-length hex.`);
   return r.toLowerCase();
 }
-function At(e) {
+function Bt(e) {
   const t = le(
     e.servedVerifyingKeyHex,
     "source.verifyingKeyHex"
@@ -477,22 +477,22 @@ function At(e) {
     `Vault provider served Groth16 verifying key ${t} but the trusted key for prover circuit version ${e.proverCircuitVersion} is ${r}; refusing to sign a claim whose proof would verify under a substituted key.`
   );
 }
-const F = 1;
-class wo extends Error {
+const q = 1;
+class xo 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 xo = /^(?:[0-9a-fA-F]{2})+$/;
-function Eo(e) {
-  const t = Co(e, "babe_sessions"), r = Object.keys(t);
+const Eo = /^(?:[0-9a-fA-F]{2})+$/;
+function $o(e) {
+  const t = To(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" || !xo.test(n))
+    if (typeof n != "string" || !Eo.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".`
       );
@@ -506,7 +506,7 @@ function ko(e) {
   } catch (a) {
     throw new Error("Artifacts file is not valid JSON.", { cause: a });
   }
-  const r = be(t.vault_id, "vault_id"), o = $o(be(t.claim_tx, "claim_tx")), s = we(
+  const r = be(t.vault_id, "vault_id"), o = Co(be(t.claim_tx, "claim_tx")), s = we(
     t.prover_circuit_version,
     "prover_circuit_version"
   ), n = BigInt(
@@ -522,26 +522,26 @@ function ko(e) {
     ),
     vaultId: r,
     claimTxid: o.getId(),
-    peginTxid: bo(o),
+    peginTxid: wo(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: be(t.verifying_key, "verifying_key"),
-    babeSessions: Eo(t.babe_sessions)
+    babeSessions: $o(t.babe_sessions)
   };
 }
-async function dn(e) {
-  const t = ko(e.artifactsJson), r = z(e.expectedVaultId), o = z(t.vaultId);
+async function fn(e) {
+  const t = ko(e.artifactsJson), r = j(e.expectedVaultId), o = j(t.vaultId);
   if (r !== o)
-    throw new wo(r, o);
-  St({
+    throw new xo(r, o);
+  At({
     peginTxid: t.peginTxid,
     depositorEthAddress: e.depositorEthAddress,
     expectedVaultId: r
   });
-  const s = e.txGraphVersion ?? F;
+  const s = e.txGraphVersion ?? q;
   if (t.vaultCoreVersion !== s)
     throw new Error(
       `Artifacts record vault core version ${t.vaultCoreVersion}, but verification was asked for version ${s}.`
@@ -569,9 +569,9 @@ async function dn(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 cr(s, e.artifactsJson), t;
+  return await lr(s, e.artifactsJson), t;
 }
-function $o(e) {
+function Co(e) {
   try {
     return S.fromHex(e);
   } catch (t) {
@@ -590,15 +590,15 @@ function we(e, t) {
     throw new Error(`Artifacts file is missing a usable "${t}".`);
   return e;
 }
-function Co(e, t) {
+function To(e, t) {
   if (typeof e != "object" || e === null || Array.isArray(e))
     throw new Error(`Artifacts file is missing a usable "${t}".`);
   return e;
 }
-function Bt(e, t) {
+function It(e, t) {
   return `wronglyChallenged:${e}:${t}`;
 }
-function It(e) {
+function Vt(e) {
   const t = [
     {
       id: "claim",
@@ -610,7 +610,7 @@ function It(e) {
       id: "assert",
       kind: "assert",
       psbtBase64: e.assert,
-      inputIndex: U
+      inputIndex: F
     },
     {
       id: "payoutClaimer",
@@ -628,95 +628,95 @@ function It(e) {
   for (const r of Object.keys(e.wronglyChallenged))
     e.wronglyChallenged[r].forEach((o, s) => {
       t.push({
-        id: Bt(r, s),
+        id: It(r, s),
         kind: "wronglyChallenged",
         psbtBase64: o,
-        inputIndex: Sr
+        inputIndex: Ar
       });
     });
   return t;
 }
-const To = "{}", _o = xt - Et;
-function V(e) {
+const _o = "{}", So = Et - $t;
+function R(e) {
   const t = e.replace(/^0x/, "").toLowerCase();
-  if (t.length === xt)
-    return t.slice(_o);
-  if (t.length === Et) return t;
+  if (t.length === Et)
+    return t.slice(So);
+  if (t.length === $t) 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 Ze(e, t, r) {
   const o = await e.getPublicKeyHex();
-  if (V(o) !== V(t))
+  if (R(o) !== R(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 (!or(s, o, r))
+  if (!sr(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.`
     );
   return s;
 }
-async function Vt(e, t, r, o) {
-  const s = V(o);
+async function Rt(e, t, r, o) {
+  const s = R(o);
   if (s !== r.depositorBtcPubkey)
     throw new Error(
       `Depositor key ${s} is not the vault's registered depositor key ${r.depositorBtcPubkey}; refusing to plan a claim for another key.`
     );
   try {
-    Er(
+    $r(
       Ie(r.registeredPayoutScriptPubKey),
       r.depositorBtcPubkey,
       o
     );
-  } catch (d) {
+  } catch (p) {
     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: ${p instanceof Error ? p.message : String(p)}. 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: p }
     );
   }
-  if (e !== F)
+  if (e !== q)
     throw new Error(
-      `Graph version ${e} is not the delegated-claim graph version ${F}; vaults on other graphs have no delegated-claim path.`
+      `Graph version ${e} is not the delegated-claim graph version ${q}; vaults on other graphs have no delegated-claim path.`
     );
   if (e !== r.vaultCoreVersion)
     throw new Error(
       `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([
-    lr(e, t),
-    pr(e, t),
     dr(e, t),
+    pr(e, t),
     hr(e, t),
-    gr(e, t)
+    gr(e, t),
+    fr(e, t)
   ]);
-  St({
-    peginTxid: mo(n),
+  At({
+    peginTxid: bo(n),
     depositorEthAddress: r.depositorEthAddress,
     expectedVaultId: r.vaultId
-  }), co({
+  }), lo({
     claimPsbtBase64: n,
     assertPsbtBase64: a,
     payoutClaimerPsbtBase64: i
   });
-  for (const d of [i, l])
-    fo({
-      payoutPsbtBase64: d,
+  for (const p of [i, l])
+    yo({
+      payoutPsbtBase64: p,
       registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
       depositorBtcPubkey: r.depositorBtcPubkey
     });
-  const c = vo({
+  const c = Po({
     payoutDepositorPsbtBase64: l,
     payoutClaimerPsbtBase64: i
   });
-  return await lo({
+  return await po({
     payoutClaimerPsbtBase64: i,
     payoutDepositorPsbtBase64: c,
     assertPsbtBase64: a,
     vault: r
-  }), ho({
+  }), go({
     graphChallengerPubkeys: Object.keys(u),
     depositorBtcPubkey: o,
     vaultProviderBtcPubkey: r.vaultProviderBtcPubkey,
@@ -724,13 +724,13 @@ async function Vt(e, t, r, o) {
     universalChallengerBtcPubkeys: r.universalChallengerBtcPubkeys
   }), { claim: n, assert: a, payoutClaimer: i, payoutDepositor: c, wronglyChallenged: u };
 }
-async function So(e) {
-  At({
+async function Ao(e) {
+  Bt({
     servedVerifyingKeyHex: e.source.verifyingKeyHex,
     trustedVerifyingKeyHex: e.trustedVerifyingKeyHex,
     proverCircuitVersion: e.vault.proverCircuitVersion
   });
-  const t = await Vt(
+  const t = await Rt(
     e.vault.txGraphVersion,
     e.source.txGraphJson,
     e.vault,
@@ -743,30 +743,30 @@ async function So(e) {
     source: e.source,
     vault: e.vault,
     // Omitted means unjoined: the browser cannot hold the real sessions.
-    babeSessionsJson: e.babeSessionsJson === void 0 ? To : e.babeSessionsJson,
-    requests: It(t)
+    babeSessionsJson: e.babeSessionsJson === void 0 ? _o : e.babeSessionsJson,
+    requests: Vt(t)
   };
 }
 function fe(e, t, r) {
   oe({
     requestedPsbtHex: He(t.psbtBase64),
     signatureHex: r,
-    signerXOnlyPubkeyHex: V(e.depositorPublicKey),
+    signerXOnlyPubkeyHex: R(e.depositorPublicKey),
     inputIndex: t.inputIndex
   });
 }
 function He(e) {
-  return H.from(e, "base64").toString("hex");
+  return O.from(e, "base64").toString("hex");
 }
-function Rt(e) {
-  return H.from(e, "hex").toString("base64");
+function Kt(e) {
+  return O.from(e, "hex").toString("base64");
 }
 class Y extends Error {
   constructor(t) {
     super(t), this.name = "SigningPlanMismatchError";
   }
 }
-function Ao(e, t) {
+function Bo(e, t) {
   if (e.length !== t.length)
     throw new Y(
       `Plan has ${e.length} requests but the graph builds ${t.length}; the plan was altered after planning.`
@@ -791,7 +791,7 @@ function Ao(e, t) {
       );
   }
 }
-function Bo(e, t) {
+function Io(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(", ");
@@ -799,7 +799,7 @@ function Bo(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 L(e, t) {
+function M(e, t) {
   const r = e.get(t);
   if (r === void 0)
     throw new Error(
@@ -807,45 +807,45 @@ function L(e, t) {
     );
   return r;
 }
-async function Io(e) {
-  const { plan: t, signatures: r } = e, { txGraphVersion: o } = t.vault, s = t.source.txGraphJson, n = At({
+async function Vo(e) {
+  const { plan: t, signatures: r } = e, { txGraphVersion: o } = t.vault, s = t.source.txGraphJson, n = Bt({
     servedVerifyingKeyHex: t.source.verifyingKeyHex,
     trustedVerifyingKeyHex: t.trustedVerifyingKeyHex,
     proverCircuitVersion: t.vault.proverCircuitVersion
-  }), a = await Vt(
+  }), a = await Rt(
     o,
     s,
     t.vault,
     t.depositorPublicKey
-  ), i = It(a);
-  Ao(t.requests, i), Bo(i, r);
+  ), i = Vt(a);
+  Bo(t.requests, i), Io(i, r);
   for (const c of i)
     fe(
       t,
       c,
-      L(r, c.id)
+      M(r, c.id)
     );
   const u = {};
   for (const c of Object.keys(a.wronglyChallenged))
     u[c] = a.wronglyChallenged[c].map(
-      (d, p) => L(
+      (p, d) => M(
         r,
-        Bt(c, p)
+        It(c, d)
       )
     );
-  const l = await fr(
+  const l = await yr(
     o,
     s,
-    L(r, "claim")
+    M(r, "claim")
   );
-  return yr({
+  return vr({
     txGraphVersion: o,
     graphJson: s,
     signedClaimTxHex: l,
-    assertClaimerSigHex: L(r, "assert"),
-    payoutClaimerSigHex: L(r, "payoutClaimer"),
+    assertClaimerSigHex: M(r, "assert"),
+    payoutClaimerSigHex: M(r, "payoutClaimer"),
     wronglyChallengedSigs: u,
-    depositorPayoutSigHex: L(r, "payoutDepositor"),
+    depositorPayoutSigHex: M(r, "payoutDepositor"),
     verifyingKeyHex: n,
     claimableEventBlockNumber: t.vault.claimableEventBlockNumber,
     proverCircuitVersion: t.vault.proverCircuitVersion,
@@ -854,44 +854,44 @@ async function Io(e) {
     expectedVaultCoreVersion: t.vault.vaultCoreVersion
   });
 }
-function Vo(e) {
+function Ro(e) {
   return typeof e.signDelegatedClaimPsbt == "function";
 }
-class Ro extends Error {
+class Ko extends Error {
   constructor(t, r, o, s) {
     super(t, s), this.signatures = r, this.failedRequestId = o, this.name = "DelegatedClaimSigningIncompleteError";
   }
 }
-const Kt = {
+const Ht = {
   assert: "intentBound",
   payoutDepositor: "intentBound",
   payoutClaimer: "standalone",
   claim: "standalone",
   wronglyChallenged: "standalone"
-}, Ko = [
+}, Ho = [
   "payoutClaimer",
   "claim",
   "wronglyChallenged"
 ];
-async function Ho(e, t, r = {}) {
+async function Oo(e, t, r = {}) {
   var s;
-  if ((s = r.signal) == null || s.throwIfAborted(), Oo(e), V(e.depositorPublicKey) !== e.vault.depositorBtcPubkey)
+  if ((s = r.signal) == null || s.throwIfAborted(), No(e), R(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.`
+      `Plan depositor key ${R(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 (!Vo(t))
+  if (Pt(t)) {
+    if (!Ro(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 = Do(r, e);
-    Lo(n.depositTerms, e.vault);
-    const a = No(e), i = await Ze(
+    const n = Lo(r, e);
+    Mo(n.depositTerms, e.vault);
+    const a = Do(e), i = await Ze(
       t,
       e.depositorPublicKey,
       e.btcNetwork
     );
-    return Mo(
+    return Uo(
       e,
       t,
       i,
@@ -905,9 +905,9 @@ async function Ho(e, t, r = {}) {
     e.depositorPublicKey,
     e.btcNetwork
   );
-  return Fo(e, t, o, r.signal);
+  return qo(e, t, o, r.signal);
 }
-function Oo(e) {
+function No(e) {
   const t = /* @__PURE__ */ new Set();
   for (const r of e.requests) {
     if (t.has(r.id))
@@ -917,10 +917,10 @@ function Oo(e) {
     t.add(r.id);
   }
 }
-function No(e) {
+function Do(e) {
   const t = e.requests.filter(
-    (s) => Kt[s.kind] === "intentBound"
-  ), r = Ko.flatMap(
+    (s) => Ht[s.kind] === "intentBound"
+  ), r = Ho.flatMap(
     (s) => e.requests.filter((n) => n.kind === s)
   ), o = t.length + r.length;
   if (o !== e.requests.length)
@@ -929,13 +929,13 @@ function No(e) {
     );
   return { intentBound: t, standalone: r };
 }
-function Ht(e, t) {
+function Ot(e, t) {
   if (t.size !== e.requests.length)
     throw new Error(
       `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 Do(e, t) {
+function Lo(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."
@@ -944,15 +944,15 @@ function Do(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 = yt(e.vaultContext.depositorBtcPubkey);
+  const r = vt(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 Lo(e, t) {
-  const r = (s) => s.map((n) => V(n)).sort().join(",");
+function Mo(e, t) {
+  const r = (s) => s.map((n) => R(n)).sort().join(",");
   if (r(e.vaultKeeperBtcPubkeys) !== r(t.vaultKeeperBtcPubkeys) || r(e.universalChallengerBtcPubkeys) !== r(t.universalChallengerBtcPubkeys))
     throw new Error(
       "Deposit terms carry different keeper or challenger rosters than the vault context this claim signs for; the device would bind the Assert to the wrong intent."
@@ -977,22 +977,22 @@ function Lo(e, t) {
     throw new Error(
       "Deposit terms describe no vault group, so they cannot name the vault context's vault provider; the device would bind the Assert to the wrong intent."
     );
-  const o = V(t.vaultProviderBtcPubkey);
+  const o = R(t.vaultProviderBtcPubkey);
   for (const s of e.vaults)
-    if (V(s.vaultProviderBtcPubkey) !== o)
+    if (R(s.vaultProviderBtcPubkey) !== o)
       throw new Error(
         `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 Mo(e, t, r, o, { intentBound: s, standalone: n }, a) {
+async function Uo(e, t, r, o, { intentBound: s, standalone: n }, a) {
   var g;
-  const i = Uo(e, a.resume), u = [...s, ...n];
+  const i = Fo(e, a.resume), u = [...s, ...n];
   let l = 0;
   const c = {
     phase: "clearing any loaded intent"
-  }, d = async (h) => {
-    var m;
-    c.phase = "signing", (m = a.signal) == null || m.throwIfAborted();
+  }, p = async (h) => {
+    var b;
+    c.phase = "signing", (b = a.signal) == null || b.throwIfAborted();
     const y = await t.signDelegatedClaimPsbt(
       He(h.psbtBase64),
       kt(
@@ -1000,42 +1000,42 @@ async function Mo(e, t, r, o, { intentBound: s, standalone: n }, a) {
         h.inputIndex,
         r
       )
-    ), f = await mt(
-      Rt(y),
+    ), f = await bt(
+      Kt(y),
       h.inputIndex
     );
     fe(e, h, f), i.set(h.id, f);
-  }, p = async (h) => {
+  }, d = async (h) => {
     var f;
-    c.phase = h, (f = a.signal) == null || f.throwIfAborted(), (await $t(t, o.vaultContext)).fill(0);
+    c.phase = h, (f = a.signal) == null || f.throwIfAborted(), (await Ct(t, o.vaultContext)).fill(0);
   };
   typeof t.validateDepositTerms == "function" && await t.validateDepositTerms(o.depositTerms);
   try {
-    await p("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 h of s)
-      await d(h), l++;
-    await p("releasing the loaded intent");
+      await p(h), l++;
+    await d("releasing the loaded intent");
     for (const h of n)
-      i.has(h.id) || await d(h), l++;
+      i.has(h.id) || await p(h), l++;
   } catch (h) {
     const y = u[l];
     if (i.size === 0 || y === void 0) throw h;
     const f = c.phase === "signing" ? `stopped at "${y.id}"` : `stopped before "${y.id}" while ${c.phase}`;
-    throw new Ro(
+    throw new Ko(
       `Delegated-claim signing ${f}; ${i.size} of ${e.requests.length} signatures were collected.`,
       i,
       y.id,
       { cause: h }
     );
   }
-  return Ht(e, i), i;
+  return Ot(e, i), i;
 }
-function Uo(e, t) {
+function Fo(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")) {
+    if (!(s === void 0 || Ht[o.kind] === "intentBound")) {
       try {
         fe(e, o, s);
       } catch {
@@ -1046,8 +1046,8 @@ function Uo(e, t) {
   }
   return r;
 }
-async function Fo(e, t, r, o) {
-  const s = e.requests, n = await Pt(
+async function qo(e, t, r, o) {
+  const s = e.requests, n = await mt(
     t,
     s.map((i) => He(i.psbtBase64)),
     s.map(
@@ -1060,43 +1060,43 @@ async function Fo(e, t, r, o) {
     o
   ), a = /* @__PURE__ */ new Map();
   for (let i = 0; i < s.length; i++) {
-    const u = await mt(
-      Rt(n[i]),
+    const u = await bt(
+      Kt(n[i]),
       s[i].inputIndex
     );
     fe(e, s[i], u), a.set(s[i].id, u);
   }
-  return Ht(e, a), a;
+  return Ot(e, a), a;
 }
-async function hn(e) {
-  const t = await So({
+async function yn(e) {
+  const t = await Ao({
     depositorPublicKey: e.depositorPublicKey,
     btcNetwork: e.btcNetwork,
     source: e.source,
     trustedVerifyingKeyHex: e.trustedVerifyingKeyHex,
     vault: e.vault,
     babeSessionsJson: e.babeSessionsJson
-  }), r = await Ho(t, e.btcWallet, {
+  }), r = await Oo(t, e.btcWallet, {
     depositTerms: e.depositTerms,
     vaultContext: e.vaultContext
   });
-  return Io({ plan: t, signatures: r });
+  return Vo({ plan: t, signatures: r });
 }
-async function gn(e) {
-  const t = await $t(e.btcWallet, e.vaultContext);
+async function vn(e) {
+  const t = await Ct(e.btcWallet, e.vaultContext);
   let r;
   try {
-    r = await vr(t, e.htlcVout);
+    r = await Pr(t, e.htlcVout);
   } finally {
     t.fill(0);
   }
   let o;
   try {
-    o = await Pr(r);
+    o = await mr(r);
   } finally {
     r.fill(0);
   }
-  return qo(o.pk_hash, e.expectedWotsPkHash), await mr(
+  return Go(o.pk_hash, e.expectedWotsPkHash), await br(
     e.txGraphVersion,
     o.keypair,
     e.txGraphJson
@@ -1105,7 +1105,7 @@ async function gn(e) {
     pkHash: o.pk_hash
   };
 }
-function qo(e, t) {
+function Go(e, t) {
   if (ie(e) !== ie(t))
     throw new Error(
       `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.`
@@ -1126,7 +1126,7 @@ function xe(e, t, r) {
     rotated: n !== s
   };
 }
-function Go(e) {
+function Xo(e) {
   const t = /* @__PURE__ */ new Map();
   for (const r of e) {
     const o = t.get(r.operationBtcPubkey);
@@ -1137,7 +1137,7 @@ function Go(e) {
     t.set(r.operationBtcPubkey, r.adminAddress);
   }
 }
-function Ot(e, t, r) {
+function Nt(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`
@@ -1154,7 +1154,7 @@ function Ot(e, t, r) {
   ), n = e.universalChallengers.map(
     (a, i) => xe("universal challenger", a, t.universalChallengers[i])
   );
-  return Go([
+  return Xo([
     o,
     ...s,
     ...n
@@ -1169,24 +1169,24 @@ function Ot(e, t, r) {
     query: e
   };
 }
-async function Xo(e) {
+async function zo(e) {
   const t = await e.operationKeyReader.getCurrentOperationKeys(
     e.query,
     e.blockNumber
   );
-  return Ot(e.query, t, { mode: "current" });
+  return Nt(e.query, t, { mode: "current" });
 }
-async function Nt(e) {
+async function Dt(e) {
   const t = await e.operationKeyReader.getOperationKeysAtEpochs(
     e.query,
     e.epochs
   );
-  return Ot(e.query, t, {
+  return Nt(e.query, t, {
     mode: "epochs",
     epochs: e.epochs
   });
 }
-async function Dt(e) {
+async function Lt(e) {
   const { basic: t, protocol: r } = e.vault, {
     registryReader: o,
     vaultKeeperReader: s,
@@ -1216,7 +1216,7 @@ async function Dt(e) {
     throw new Error(
       `No universal challengers for version ${r.universalChallengersVersion}`
     );
-  return Nt({
+  return Dt({
     operationKeyReader: a,
     query: {
       vaultProviderEthAddress: t.vaultProvider,
@@ -1228,11 +1228,11 @@ async function Dt(e) {
     epochs: c
   });
 }
-async function fn(e) {
+async function Pn(e) {
   const { vaultId: t, readers: r } = e, o = await r.registryReader.getVaultData(t), { basic: s, protocol: n } = o;
-  if (n.vaultCoreVersion !== F)
+  if (n.vaultCoreVersion !== q)
     throw new Error(
-      `Vault ${t} is stamped vault core version ${n.vaultCoreVersion}; delegated claim requires ${F}.`
+      `Vault ${t} is stamped vault core version ${n.vaultCoreVersion}; delegated claim requires ${q}.`
     );
   const a = _e(
     s.depositorBtcPubKey,
@@ -1247,7 +1247,7 @@ async function fn(e) {
       `the vault's status is ${s.status}, not Redeemed (${ze.REDEEMED}); no scan was made`
     );
   const [i, u, l, c] = await Promise.all([
-    Dt({ vaultId: t, vault: o, readers: r }),
+    Lt({ vaultId: t, vault: o, readers: r }),
     r.registryReader.getRegistrationRecordsAtBlock(s.createdAt),
     r.registryReader.getVaultClaimableBy(t, s.depositorBtcPubKey, s.createdAt).catch((v) => {
       throw kr(v) ? new Le(
@@ -1262,54 +1262,54 @@ async function fn(e) {
     r.protocolParamsReader.getOffchainParamsByVersion(
       n.offchainParamsVersion
     )
-  ]), d = Or(c.timelockAssert), p = $r(u, t, s.createdAt);
-  Cr(p);
-  const g = Tr(p);
+  ]), p = Nr(c.timelockAssert), d = Cr(u, t, s.createdAt);
+  Tr(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 (p.vaultCoreVersion !== n.vaultCoreVersion)
+  if (d.vaultCoreVersion !== n.vaultCoreVersion)
     throw new Error(
-      `Registration log of vault ${t} records vault core version ${p.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 (p.amount !== s.amount)
+  if (d.amount !== s.amount)
     throw new Error(
-      `Registration log of vault ${t} records amount ${p.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 (p.depositor.toLowerCase() !== s.depositor.toLowerCase())
+  if (d.depositor.toLowerCase() !== s.depositor.toLowerCase())
     throw new Error(
-      `Registration log of vault ${t} records depositor ${p.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 (p.vaultProvider.toLowerCase() !== s.vaultProvider.toLowerCase())
+  if (d.vaultProvider.toLowerCase() !== s.vaultProvider.toLowerCase())
     throw new Error(
-      `Registration log of vault ${t} records vaultProvider ${p.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 !== p.proverCircuitVersion)
+  if (l.proverCircuitVersion !== d.proverCircuitVersion)
     throw new Error(
-      `Redemption log of vault ${t} records proverCircuitVersion ${l.proverCircuitVersion} but the registration log says ${p.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 (p.proverCircuitVersion !== c.proverCircuitVersion)
+  if (d.proverCircuitVersion !== c.proverCircuitVersion)
     throw new Error(
-      `Registration log of vault ${t} records proverCircuitVersion ${p.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 h = _r(n.depositorSignedPeginTx);
+  const h = Sr(n.depositorSignedPeginTx);
   for (const [v, E] of [
-    ["Registration", p.peginTxHash],
+    ["Registration", d.peginTxHash],
     ["Redemption", l.peginTxHash]
   ])
     if (E.toLowerCase() !== h.toLowerCase())
       throw new Error(
         `${v} log of vault ${t} records peginTxHash ${E} but the vault's depositor-signed PegIn hashes to ${h}; refusing an inconsistent node.`
       );
-  const y = z(
-    bt(h, s.depositor)
+  const y = j(
+    wt(h, s.depositor)
   );
-  if (y !== z(t))
+  if (y !== j(t))
     throw new Error(
       `Depositor-signed PegIn of vault ${t} derives vault id ${y} with depositor ${s.depositor}; refusing an inconsistent node.`
     );
@@ -1318,9 +1318,9 @@ async function fn(e) {
     "universalChallengersVersion",
     "appVaultKeepersVersion"
   ]) {
-    if (p[v] !== n[v])
+    if (d[v] !== n[v])
       throw new Error(
-        `Registration log of vault ${t} records ${v} ${p[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(
@@ -1334,10 +1334,10 @@ async function fn(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 = Ke(f.ins[0].hash), $ = f.ins[0].index;
-  if (m !== P(n.prePeginTxHash).toLowerCase() || $ !== n.htlcVout)
+  const b = Ke(f.ins[0].hash), k = f.ins[0].index;
+  if (b !== P(n.prePeginTxHash).toLowerCase() || k !== n.htlcVout)
     throw new Error(
-      `Depositor-signed PegIn of vault ${t} spends ${m}:${$} but the vault record says Pre-PegIn ${n.prePeginTxHash} output ${n.htlcVout}; refusing an inconsistent node.`
+      `Depositor-signed PegIn of vault ${t} spends ${b}:${k} but the vault record says Pre-PegIn ${n.prePeginTxHash} output ${n.htlcVout}; refusing an inconsistent node.`
     );
   const x = f.outs[Z];
   if (x === void 0)
@@ -1354,7 +1354,7 @@ async function fn(e) {
       depositorEthAddress: s.depositor,
       depositorBtcPubkey: a,
       registeredPayoutScriptPubKey: P(
-        p.depositorPayoutScriptPubKey
+        d.depositorPayoutScriptPubKey
       ),
       vaultProviderBtcPubkey: i.vaultProvider.operationBtcPubkey,
       vaultKeeperBtcPubkeys: [
@@ -1363,18 +1363,18 @@ async function fn(e) {
       universalChallengerBtcPubkeys: [
         ...i.universalChallengerOperationKeysSorted
       ],
-      txGraphVersion: F,
+      txGraphVersion: q,
       proverCircuitVersion: c.proverCircuitVersion,
       vaultCoreVersion: n.vaultCoreVersion,
       claimableEventBlockNumber: l.blockNumber,
       peginVaultOutputValueSats: x.value,
       protocolFeeRate: c.feeRate,
       councilSize: c.securityCouncilKeys.length,
-      timelockPegin: d,
+      timelockPegin: p,
       timelockAssert: Number(c.timelockAssert)
     },
     vault: o,
-    registrationRecord: p,
+    registrationRecord: d,
     registrationRecords: u,
     participantKeys: i,
     offchainParams: c,
@@ -1386,35 +1386,35 @@ async function fn(e) {
     htlcVout: n.htlcVout
   };
 }
-const zo = 8, jo = 6e3, Wo = 10 * 6e4, Yo = 10;
-class Lt extends Error {
+const jo = 8, Wo = 6e3, Yo = 10 * 6e4, Qo = 10;
+class Mt extends Error {
   constructor(t) {
     super(t), this.name = "PeginRegistrationMissingError";
   }
 }
-class Mt extends Error {
+class Ut extends Error {
   constructor(t) {
     super(t), this.name = "PeginRegistrationNotFinalError";
   }
 }
-function Qo(e) {
-  return e instanceof Lt || e instanceof Error && e.name === "PeginRegistrationMissingError";
+function Jo(e) {
+  return e instanceof Mt || e instanceof Error && e.name === "PeginRegistrationMissingError";
 }
-function yn(e) {
-  return e instanceof Mt || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
+function mn(e) {
+  return e instanceof Ut || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
 }
 function et(e) {
   const { currentBlock: t, createdAtBlock: r } = e, o = t - r + 1n;
   return o < 0n ? 0 : Number(o);
 }
-async function vn(e) {
+async function bn(e) {
   const {
     vaultRegistryReader: t,
     getBlockNumber: r,
     vaultIds: o,
-    required: s = zo,
-    pollIntervalMs: n = jo,
-    timeoutMs: a = Wo,
+    required: s = jo,
+    pollIntervalMs: n = Wo,
+    timeoutMs: a = Yo,
     signal: i,
     onProgress: u
   } = e;
@@ -1423,52 +1423,52 @@ async function vn(e) {
       "waitForPeginRegistrationDepth requires at least one vault ID"
     );
   const l = Date.now();
-  let c = !1, d = 0, p;
+  let c = !1, p = 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.` + (p instanceof Error ? ` Last read error: ${p.message}` : "")
+      throw new Ut(
+        `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(), h = await Promise.all(
         o.map((f) => t.getVaultBasicInfo(f))
       ), y = h.findIndex(
-        (f) => f.depositor === Nr || f.createdAt === 0n
+        (f) => f.depositor === Dr || f.createdAt === 0n
       );
       if (y !== -1) {
-        if (d += 1, !c && d > Yo)
-          throw new Lt(
-            `Vault ${o[y]} is still not visible on-chain after ${d} reads — the registration does not exist.`
+        if (p += 1, !c && p > Qo)
+          throw new Mt(
+            `Vault ${o[y]} is still not visible on-chain after ${p} 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, p = void 0;
-        let f = h[0], m = et({
+        c = !0, p = 0, d = void 0;
+        let f = h[0], b = et({
           currentBlock: g,
           createdAtBlock: h[0].createdAt
         });
-        for (const $ of h.slice(1)) {
+        for (const k of h.slice(1)) {
           const x = et({
             currentBlock: g,
-            createdAtBlock: $.createdAt
+            createdAtBlock: k.createdAt
           });
-          x < m && (m = x, f = $);
+          x < b && (b = x, f = k);
         }
-        if (u == null || u({ confirmations: m, required: s }), m >= s)
-          return { confirmations: m, basicInfo: f };
+        if (u == null || u({ confirmations: b, required: s }), b >= s)
+          return { confirmations: b, basicInfo: f };
       }
     } catch (g) {
-      if (Qo(g))
+      if (Jo(g))
         throw g;
       console.warn(
         `Registration-depth read failed (retrying in ${n}ms): ` + (g instanceof Error ? g.message : String(g))
-      ), p = g;
+      ), d = g;
     }
     await new Promise((g, h) => {
       const y = () => {
@@ -1484,307 +1484,307 @@ async function vn(e) {
     });
   }
 }
-const Jo = /^(?:[0-9a-f]{2})*$/, Zo = /^[0-9a-f]{64}$/, es = /^([0-9a-f]{64}):(0|[1-9][0-9]*)$/, ts = -2147483648, rs = 2147483647, Ee = 4294967295, tt = 2, rt = 2, pe = 0;
-class b extends Error {
+const Zo = /^(?:[0-9a-f]{2})*$/, es = /^[0-9a-f]{64}$/, ts = /^([0-9a-f]{64}):(0|[1-9][0-9]*)$/, rs = -2147483648, os = 2147483647, Ee = 4294967295, tt = 2, rt = 2, de = 0;
+class w extends Error {
   constructor(t) {
     super(t), this.name = "GraphFingerprintError";
   }
 }
-function k(e, t, r) {
+function $(e, t, r) {
   const o = e[t];
   if (o === void 0)
-    throw new b(`Graph tx ${r} is missing "${t}"`);
+    throw new w(`Graph tx ${r} is missing "${t}"`);
   return o;
 }
 function te(e, t) {
   if (!Array.isArray(e))
-    throw new b(`Graph tx ${t} is not an array`);
+    throw new w(`Graph tx ${t} is not an array`);
   return e;
 }
-function B(e, t) {
+function I(e, t) {
   if (e === null || typeof e != "object" || Array.isArray(e))
-    throw new b(`Graph tx ${t} is not an object`);
+    throw new w(`Graph tx ${t} is not an object`);
   return e;
 }
 function Q(e, t, r, o) {
   if (typeof e != "number" || !Number.isSafeInteger(e) || e < r || e > o)
-    throw new b(
+    throw new w(
       `Graph tx ${t} is not an integer in [${r}, ${o}]`
     );
   return e;
 }
-function ke(e, t) {
-  if (typeof e != "string" || !Jo.test(e))
-    throw new b(
+function $e(e, t) {
+  if (typeof e != "string" || !Zo.test(e))
+    throw new w(
       `Graph tx ${t} is not lowercase hex without a prefix`
     );
-  return H.from(e, "hex");
+  return O.from(e, "hex");
 }
-function de(e, t) {
-  if (typeof e != "string" || !Zo.test(e))
-    throw new b(
+function pe(e, t) {
+  if (typeof e != "string" || !es.test(e))
+    throw new w(
       `Graph ${t} is not 32 bytes of lowercase hex`
     );
   return e;
 }
 function ot(e, t) {
-  const r = B(e, t), o = new S();
+  const r = I(e, t), o = new S();
   return o.version = Q(
-    k(r, "version", t),
+    $(r, "version", t),
     `${t}.version`,
-    ts,
-    rs
+    rs,
+    os
   ), o.locktime = Q(
-    k(r, "lock_time", t),
+    $(r, "lock_time", t),
     `${t}.lock_time`,
     0,
     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" && es.exec(u);
+  ), te($(r, "input", t), `${t}.input`).forEach((s, n) => {
+    const a = `${t}.input[${n}]`, i = I(s, a), u = $(i, "previous_output", a), l = typeof u == "string" && ts.exec(u);
     if (!l)
-      throw new b(
+      throw new w(
         `Graph tx ${a}.previous_output is not "<txid>:<vout>"`
       );
     const c = Q(Number(l[2]), `${a}.previous_output vout`, 0, Ee);
     o.addInput(
-      H.from(l[1], "hex").reverse(),
+      O.from(l[1], "hex").reverse(),
       c,
-      Q(k(i, "sequence", a), `${a}.sequence`, 0, Ee),
-      ke(k(i, "script_sig", a), `${a}.script_sig`)
+      Q($(i, "sequence", a), `${a}.sequence`, 0, Ee),
+      $e($(i, "script_sig", a), `${a}.script_sig`)
     ), o.ins[n].witness = te(
-      k(i, "witness", a),
+      $(i, "witness", a),
       `${a}.witness`
-    ).map((d, p) => ke(d, `${a}.witness[${p}]`));
-  }), te(k(r, "output", t), `${t}.output`).forEach((s, n) => {
-    const a = `${t}.output[${n}]`, i = B(s, a);
+    ).map((p, d) => $e(p, `${a}.witness[${d}]`));
+  }), te($(r, "output", t), `${t}.output`).forEach((s, n) => {
+    const a = `${t}.output[${n}]`, i = I(s, a);
     o.addOutput(
-      ke(k(i, "script_pubkey", a), `${a}.script_pubkey`),
-      Q(k(i, "value", a), `${a}.value`, 0, Number.MAX_SAFE_INTEGER)
+      $e($(i, "script_pubkey", a), `${a}.script_pubkey`),
+      Q($(i, "value", a), `${a}.value`, 0, Number.MAX_SAFE_INTEGER)
     );
   }), new Uint8Array(o.toBuffer());
 }
-function D(e, t) {
+function L(e, t) {
   const r = P(e).toLowerCase();
   let o;
   try {
     o = S.fromHex(r);
   } catch (s) {
-    throw new b(
+    throw new w(
       `Presign ${t} is not one transaction: ${s instanceof Error ? s.message : String(s)}`
     );
   }
   if (o.toHex() !== r)
-    throw new b(
+    throw new w(
       `Presign ${t} is not a canonical transaction encoding`
     );
   return o;
 }
-function Ut(e, t) {
+function Ft(e, t) {
   const r = e.ins[t];
   if (r)
     return {
-      txid: H.from(r.hash).reverse().toString("hex"),
+      txid: O.from(r.hash).reverse().toString("hex"),
       vout: r.index
     };
 }
-function Ft(e, t) {
-  if (!e.outs[pe])
-    throw new b(
-      `Presign ${t}.claim_tx must have output ${pe}`
+function qt(e, t) {
+  if (!e.outs[de])
+    throw new w(
+      `Presign ${t}.claim_tx must have output ${de}`
     );
 }
-function os(e, t, r) {
+function ss(e, t, r) {
   if (e.ins.length !== 1)
-    throw new b(
+    throw new w(
       `Presign ${r}.claim_tx must have exactly one input, got ${e.ins.length}`
     );
-  Ft(e, r);
-  const o = Ut(e, 0);
-  if ((o == null ? void 0 : o.txid) !== t || o.vout !== X) {
+  qt(e, r);
+  const o = Ft(e, 0);
+  if ((o == null ? void 0 : o.txid) !== t || o.vout !== z) {
     const s = o ? `${o.txid}:${o.vout}` : "no input";
-    throw new b(
-      `Presign ${r}.claim_tx must spend ${t}:${X}, got ${s}`
+    throw new w(
+      `Presign ${r}.claim_tx must spend ${t}:${z}, got ${s}`
     );
   }
 }
 function Oe(e, t, r) {
-  const o = Ut(e, 0);
-  if ((o == null ? void 0 : o.txid) !== t || o.vout !== pe) {
+  const o = Ft(e, 0);
+  if ((o == null ? void 0 : o.txid) !== t || o.vout !== de) {
     const s = o ? `${o.txid}:${o.vout}` : "no input";
-    throw new b(
-      `Presign ${r}.assert_tx input 0 must spend ${t}:${pe}, got ${s}`
+    throw new w(
+      `Presign ${r}.assert_tx input 0 must spend ${t}:${de}, got ${s}`
     );
   }
 }
-function qt(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`);
+function Gt(e) {
+  const t = L(e.peginTxHex, `${e.path}.pegin_tx`), r = L(e.claimTxHex, `${e.path}.claim_tx`), o = L(e.assertTxHex, `${e.path}.assert_tx`);
   return { peginTx: t, claimTx: r, assertTx: o };
 }
-function ss(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 ns(e) {
-  const { peginTx: t, claimTx: r, assertTx: o } = qt(e);
-  os(r, t.getId(), e.path), Oe(o, r.getId(), e.path);
+  const t = L(e.claimTxHex, `${e.path}.claim_tx`), r = L(e.assertTxHex, `${e.path}.assert_tx`);
+  qt(t, e.path), Oe(r, t.getId(), e.path);
+}
+function is(e) {
+  const { peginTx: t, claimTx: r, assertTx: o } = Gt(e);
+  ss(r, t.getId(), e.path), Oe(o, r.getId(), e.path);
 }
-function is(e, t) {
+function as(e, t) {
   const [r, ...o] = e.ins;
   if (!r || o.length > 0)
-    throw new b(
+    throw new w(
       `Presign claim_tx must have exactly one input, got ${e.ins.length}`
     );
-  const s = H.from(r.hash).reverse().toString("hex");
-  if (s !== t || r.index !== X)
-    throw new b(
-      `Presign claim_tx must spend ${t}:${X}, got ${s}:${r.index}`
+  const s = O.from(r.hash).reverse().toString("hex");
+  if (s !== t || r.index !== z)
+    throw new w(
+      `Presign claim_tx must spend ${t}:${z}, got ${s}:${r.index}`
     );
   if (e.version !== tt)
-    throw new b(
+    throw new w(
       `Presign claim_tx version must be ${tt}, got ${e.version}`
     );
   if (r.witness.length > 0)
-    throw new b(
+    throw new w(
       `Presign claim_tx input must have an empty witness, got ${r.witness.length} item(s)`
     );
   if (e.outs.length !== rt)
-    throw new b(
+    throw new w(
       `Presign claim_tx must have exactly ${rt} outputs, got ${e.outs.length}`
     );
 }
-function Gt(e) {
+function Xt(e) {
   const t = [...e.challengers].sort(
     (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 = pe(o.pubkey, "challenger pubkey");
     if (s > 0 && t[s - 1].pubkey === n)
-      throw new b(`Graph lists challenger ${n} twice`);
+      throw new w(`Graph lists challenger ${n} twice`);
     r.push(We(n), o.nopayoutTx);
     for (const a of o.outputLabelHashes)
-      r.push(We(de(a, "output_label_hashes entry")));
-  }), qr(Gr(Xr(...r)));
+      r.push(We(pe(a, "output_label_hashes entry")));
+  }), Gr(Xr(zr(...r)));
 }
-function as(e) {
-  const t = P(e.peginTxid).toLowerCase(), { peginTx: r, claimTx: o, assertTx: s } = qt({
+function us(e) {
+  const t = P(e.peginTxid).toLowerCase(), { peginTx: r, claimTx: o, assertTx: s } = Gt({
     peginTxHex: e.peginTxHex,
     claimTxHex: e.claimTxHex,
     assertTxHex: e.assertTxHex,
     path: "depositor_graph"
   });
   if (r.getId() !== t)
-    throw new b(
+    throw new w(
       `Presign pegin_tx hashes to ${r.getId()}, expected ${t}`
     );
-  is(o, t), Oe(s, o.getId(), "depositor_graph");
+  as(o, t), Oe(s, o.getId(), "depositor_graph");
   const n = (a) => new Uint8Array(a.toBuffer());
-  return Gt({
+  return Xt({
     peginTx: n(r),
     claimTx: n(o),
     assertTx: n(s),
-    payoutTx: n(D(e.payoutTxHex, "payout_tx")),
+    payoutTx: n(L(e.payoutTxHex, "payout_tx")),
     challengers: e.challengers.map((a) => ({
       pubkey: _(a.challenger_pubkey),
-      nopayoutTx: n(D(a.nopayout_tx.tx_hex, "nopayout_tx")),
+      nopayoutTx: n(L(a.nopayout_tx.tx_hex, "nopayout_tx")),
       outputLabelHashes: a.output_label_hashes.map(
         (i) => P(i).toLowerCase()
       )
     }))
   });
 }
-function us(e) {
-  const t = (o) => ot(B(k(e, o, "graph"), o).tx, o), r = B(
-    k(e, "challenger_subgraphs", "graph"),
+function cs(e) {
+  const t = (o) => ot(I($(e, o, "graph"), o).tx, o), r = I(
+    $(e, "challenger_subgraphs", "graph"),
     "challenger_subgraphs"
   );
-  return Gt({
+  return Xt({
     peginTx: t("pegin_tx"),
     claimTx: t("claim_tx"),
     assertTx: t("assert_tx"),
     payoutTx: t("payout_tx"),
     challengers: Object.entries(r).map(([o, s]) => {
-      const n = `challenger_subgraphs[${o}]`, a = B(s, n);
+      const n = `challenger_subgraphs[${o}]`, a = I(s, n);
       return {
         pubkey: o,
         nopayoutTx: ot(
-          B(k(a, "nopayout_tx", n), `${n}.nopayout_tx`).tx,
+          I($(a, "nopayout_tx", n), `${n}.nopayout_tx`).tx,
           `${n}.nopayout_tx`
         ),
         outputLabelHashes: te(
-          k(a, "output_label_hashes", n),
+          $(a, "output_label_hashes", n),
           `${n}.output_label_hashes`
         ).map(
-          (i, u) => de(i, `${n}.output_label_hashes[${u}]`)
+          (i, u) => pe(i, `${n}.output_label_hashes[${u}]`)
         )
       };
     })
   });
 }
-function cs(e) {
-  const t = B(
-    k(e, "challenger_pubkeys", "graph"),
+function ls(e) {
+  const t = I(
+    $(e, "challenger_pubkeys", "graph"),
     "challenger_pubkeys"
   ), r = /* @__PURE__ */ new Set();
   for (const o of ["local", "universal"])
     te(
-      k(t, o, "challenger_pubkeys"),
+      $(t, o, "challenger_pubkeys"),
       `challenger_pubkeys.${o}`
     ).forEach((s, n) => {
-      const a = de(s, `challenger_pubkeys.${o}[${n}]`);
+      const a = pe(s, `challenger_pubkeys.${o}[${n}]`);
       if (r.has(a))
-        throw new b(
+        throw new w(
           `Graph declares challenger ${a} more than once`
         );
       r.add(a);
     });
   return r;
 }
-function Pn(e, t) {
-  const r = us(e);
+function wn(e, t) {
+  const r = cs(e);
   if (r !== t)
-    throw new b(
+    throw new w(
       `Graph fingerprint ${r} does not match the presign fingerprint ${t}`
     );
   const o = Object.keys(
-    B(e.challenger_subgraphs, "challenger_subgraphs")
-  ), s = cs(e);
+    I(e.challenger_subgraphs, "challenger_subgraphs")
+  ), s = ls(e);
   if (o.length !== s.size || o.some((n) => !s.has(n)))
-    throw new b(
+    throw new w(
       `Graph challenger_subgraphs keys ${o.join(", ")} do not match challenger_pubkeys ${[...s].join(", ")}`
     );
 }
-const ls = 1;
+const ds = 1;
 function ps(e, t, r) {
   const o = r.map(
-    (d) => P(d).toLowerCase()
-  ), s = t.filter((d) => o.includes(d));
+    (p) => P(p).toLowerCase()
+  ), s = t.filter((p) => o.includes(p));
   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) => P(d.challenger_pubkey).toLowerCase()
+    (p) => P(p.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((p) => !i.has(p)), c = a.filter((p) => !u.has(p));
   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 nr(n);
+  return ir(n);
 }
-function ds(e, t) {
-  const r = Ar + Br * t + Ir;
+function hs(e, t) {
+  const r = Br + Ir * t + Vr;
   if (e.outs.length !== r)
     throw new Error(
       `Assert must have ${r} outputs for ${t} challengers, got ${e.outs.length}`
     );
 }
-async function Xt(e, t) {
-  const r = wt({
+async function zt(e, t) {
+  const r = xt({
     claimerBtcPubkey: t.depositorBtcPubkey,
     depositorBtcPubkey: t.depositorBtcPubkey,
     vaultProviderBtcPubkey: t.vaultProviderBtcPubkey,
@@ -1796,12 +1796,12 @@ async function Xt(e, t) {
   ), s = P(t.depositorBtcPubkey), n = S.fromHex(
     P(e.assert_tx.tx_hex)
   );
-  ds(n, o.length);
+  hs(n, o.length);
   const a = [];
   for (const i of e.challenger_presign_data) {
     const u = P(i.challenger_pubkey), l = o.indexOf(
       u.toLowerCase()
-    ), c = await hs({
+    ), c = await gs({
       challenger: i,
       challengerPubkey: u,
       challengerIndex: l,
@@ -1814,7 +1814,7 @@ async function Xt(e, t) {
   }
   return { localChallengers: r, noPayouts: a };
 }
-async function hs(e) {
+async function gs(e) {
   const {
     challenger: t,
     challengerPubkey: r,
@@ -1824,7 +1824,7 @@ async function hs(e) {
     assertTx: a,
     ctx: i
   } = e;
-  jr(
+  Wr(
     t.nopayout_tx.tx_hex,
     r,
     i.network
@@ -1835,7 +1835,7 @@ async function hs(e) {
     P(t.challenge_assert_x_tx.tx_hex)
   ), c = S.fromHex(
     P(t.challenge_assert_y_tx.tx_hex)
-  ), d = await br({
+  ), p = await wr({
     txGraphVersion: i.vaultCoreVersion,
     claimer: n,
     challenger: r,
@@ -1849,38 +1849,38 @@ async function hs(e) {
     ["X", l],
     ["Y", c]
   ])
-    Wr({
+    Yr({
       challengeAssertTx: h,
       assertTx: a,
       half: g,
       challengerIndex: o,
       challengerCount: s,
       challengerPubkey: r,
-      outputConnectorScriptPubKey: d
+      outputConnectorScriptPubKey: p
     });
-  const p = [
-    a.outs[G],
+  const d = [
+    a.outs[X],
     l.outs[Xe],
     c.outs[Xe]
   ];
-  return Yr({
+  return Qr({
     noPayoutTx: u,
     assertTxid: a.getId(),
     challengeAssertXTxid: l.getId(),
     challengeAssertYTxid: c.getId(),
     timelockChallengeAssert: i.timelockChallengeAssert,
     prevoutValues: [
-      p[0].value,
-      p[1].value,
-      p[2].value
+      d[0].value,
+      d[1].value,
+      d[2].value
     ]
-  }), p.map((g) => ({
-    script_pubkey: yt(new Uint8Array(g.script)),
+  }), d.map((g) => ({
+    script_pubkey: vt(new Uint8Array(g.script)),
     value: g.value
   }));
 }
-async function gs(e, t, r) {
-  const o = [], s = [], n = [], { localChallengers: a, noPayouts: i } = await Xt(e, r), u = await Kr({
+async function fs(e, t, r) {
+  const o = [], s = [], n = [], { localChallengers: a, noPayouts: i } = await zt(e, r), u = await Hr({
     vaultCoreVersion: r.vaultCoreVersion,
     vkClaimerPayoutScriptPubKeys: r.vkClaimerPayoutScriptPubKeys,
     vpCommissionScriptPubKey: r.vpCommissionScriptPubKey,
@@ -1896,7 +1896,7 @@ async function gs(e, t, r) {
     network: r.network,
     claimerBtcPubkey: r.depositorBtcPubkey,
     registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
-    commissionBps: ls,
+    commissionBps: ds,
     protocolFeeRate: r.protocolFeeRate,
     councilMembers: r.councilMembers,
     councilQuorum: r.councilQuorum
@@ -1908,11 +1908,11 @@ async function gs(e, t, r) {
     )
   );
   const l = P(r.depositorBtcPubkey);
-  for (const { challenger: c, challengerPubkey: d, prevouts: p } of i) {
-    const g = o.length, h = await zr({
+  for (const { challenger: c, challengerPubkey: p, prevouts: d } of i) {
+    const g = o.length, h = await jr({
       noPayoutTxHex: c.nopayout_tx.tx_hex,
-      challengerPubkey: d,
-      prevouts: p,
+      challengerPubkey: p,
+      prevouts: d,
       connectorParams: {
         txGraphVersion: r.vaultCoreVersion,
         claimer: l,
@@ -1929,13 +1929,13 @@ async function gs(e, t, r) {
         Ge
       )
     ), n.push({
-      challengerPubkey: d,
+      challengerPubkey: p,
       noPayoutIdx: g
     });
   }
   return { psbtHexes: o, signOptions: s, challengerEntries: n };
 }
-function fs(e, t, r) {
+function ys(e, t, r) {
   ae(e[0]);
   const s = ue(
     e[0].returnedPsbtHex,
@@ -1970,54 +1970,54 @@ function fs(e, t, r) {
     per_challenger: n
   };
 }
-async function ys(e) {
+async function vs(e) {
   const { depositorGraph: t, btcWallet: r, signingContext: o } = e;
-  ns({
+  is({
     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 } = sr(
+  const s = await r.getPublicKeyHex(), { depositorPubkey: n } = nr(
     s,
     P(o.depositorBtcPubkey)
-  ), { psbtHexes: a, signOptions: i, challengerEntries: u } = await gs(
+  ), { psbtHexes: a, signOptions: i, challengerEntries: u } = await fs(
     t,
     s,
     o
-  ), l = await Pt(
+  ), l = await mt(
     r,
     a,
     i
-  ), c = a.map((d, p) => ({
-    requestedPsbtHex: d,
-    returnedPsbtHex: l[p]
+  ), c = a.map((p, d) => ({
+    requestedPsbtHex: p,
+    returnedPsbtHex: l[d]
   }));
-  return fs(
+  return ys(
     c,
     u,
     n
   );
 }
-const vs = 1e4, M = 10;
-async function zt(e) {
+const Ps = 1e4, U = 10;
+async function jt(e) {
   const {
     statusReader: t,
     vaultId: r,
     peginTxid: o,
     targetStatuses: s,
     timeoutMs: n,
-    pollIntervalMs: a = vs,
+    pollIntervalMs: a = Ps,
     signal: i
   } = e, u = Date.now();
   for (; ; ) {
     if (i != null && i.aborted)
       throw new Error(
-        `Polling aborted for vault ${r.slice(0, M)}… (target: ${[...s].join(", ")})`
+        `Polling aborted for vault ${r.slice(0, U)}… (target: ${[...s].join(", ")})`
       );
     if (Date.now() - u >= n)
       throw new Error(
-        `Polling timeout after ${n}ms for vault ${r.slice(0, M)}… (target: ${[...s].join(", ")})`
+        `Polling timeout after ${n}ms for vault ${r.slice(0, U)}… (target: ${[...s].join(", ")})`
       );
     try {
       const l = await t.getPeginStatusByVaultId(
@@ -2026,57 +2026,57 @@ async function zt(e) {
       );
       if (je(l.vault_id) !== je(r))
         throw new Error(
-          `getPeginStatusByVaultId returned status for vault ${l.vault_id.slice(0, M)}…, requested ${r.slice(0, M)}…`
+          `getPeginStatusByVaultId returned status for vault ${l.vault_id.slice(0, U)}…, requested ${r.slice(0, U)}…`
         );
       if (l.pegin_txid.toLowerCase() !== o.toLowerCase())
         throw new Error(
           `getPeginStatusByVaultId returned status for pegin ${l.pegin_txid.slice(0, 8)}…, requested ${o.slice(0, 8)}…`
         );
       const c = l.status;
-      if (s.has(c) || c === R.ACTIVATED)
+      if (s.has(c) || c === K.ACTIVATED)
         return c;
-      if (c === R.EXPIRED || Mr.has(c))
+      if (c === K.EXPIRED || Ur.has(c))
         throw new Error(
-          `Vault ${r.slice(0, M)}… reached terminal status "${c}" while waiting for ${[...s].join(", ")}`
+          `Vault ${r.slice(0, U)}… reached terminal status "${c}" while waiting for ${[...s].join(", ")}`
         );
     } catch (l) {
-      if (!(l instanceof Ur && l.code === Fr.PEGIN_NOT_FOUND))
+      if (!(l instanceof Fr && l.code === qr.PEGIN_NOT_FOUND))
         throw l;
     }
     await new Promise((l, c) => {
-      const d = () => {
-        clearTimeout(p), c(
+      const p = () => {
+        clearTimeout(d), c(
           new Error(
-            `Polling aborted for vault ${r.slice(0, M)}… (target: ${[...s].join(", ")})`
+            `Polling aborted for vault ${r.slice(0, U)}… (target: ${[...s].join(", ")})`
           )
         );
-      }, p = setTimeout(() => {
-        i == null || i.removeEventListener("abort", d), l();
+      }, d = setTimeout(() => {
+        i == null || i.removeEventListener("abort", p), l();
       }, a);
-      i == null || i.addEventListener("abort", d, { once: !0 });
+      i == null || i.addEventListener("abort", p, { once: !0 });
     });
   }
 }
-const Ps = 1200 * 1e3, jt = /* @__PURE__ */ new Set([
-  R.PENDING_ACKS,
-  R.PENDING_ACTIVATION,
-  R.ACTIVATED_PENDING_BROADCAST,
-  R.ACTIVATED
-]), ms = /* @__PURE__ */ new Set([
-  R.PENDING_DEPOSITOR_SIGNATURES,
-  ...jt
+const ms = 1200 * 1e3, Wt = /* @__PURE__ */ new Set([
+  K.PENDING_ACKS,
+  K.PENDING_ACTIVATION,
+  K.ACTIVATED_PENDING_BROADCAST,
+  K.ACTIVATED
+]), bs = /* @__PURE__ */ new Set([
+  K.PENDING_DEPOSITOR_SIGNATURES,
+  ...Wt
 ]);
-function bs(e) {
+function ws(e) {
   return e.map((t) => ({
     claimerPubkeyXOnly: he(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
     assertTxHex: t.assert_tx.tx_hex
   }));
 }
-function I(e) {
+function V(e) {
   return he(e).toLowerCase();
 }
-function ws(e, t) {
+function xs(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.`
@@ -2089,9 +2089,9 @@ function ws(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((p, g) => p === d[g]);
+  const s = (u) => u.map(V).sort(), n = (u, l) => {
+    const c = s(u), p = s(l);
+    return c.length === p.length && c.every((d, g) => d === p[g]);
   };
   n(e.vaultKeeperBtcPubkeys, t.vaultKeeperBtcPubkeys) || r(
     "vaultKeeperBtcPubkeys",
@@ -2105,8 +2105,8 @@ function ws(e, t) {
     e.universalChallengerBtcPubkeys.join(","),
     t.universalChallengerBtcPubkeys.join(",")
   );
-  const a = I(t.vaultProviderBtcPubkey), i = e.vaults.map(
-    (u) => I(u.vaultProviderBtcPubkey)
+  const a = V(t.vaultProviderBtcPubkey), i = e.vaults.map(
+    (u) => V(u.vaultProviderBtcPubkey)
   );
   i.includes(a) || r(
     "vaults[].vaultProviderBtcPubkey",
@@ -2114,10 +2114,10 @@ function ws(e, t) {
     t.vaultProviderBtcPubkey
   );
 }
-function xs(e, t, r, o) {
-  const s = I(o), n = [
-    I(t),
-    ...r.map(I)
+function Es(e, t, r, o) {
+  const s = V(o), n = [
+    V(t),
+    ...r.map(V)
   ], a = new Set(n);
   if (a.size !== n.length)
     throw new Error(
@@ -2128,14 +2128,14 @@ function xs(e, t, r, o) {
       "Cannot validate claimer set: depositor key overlaps with vault provider or vault keeper set"
     );
   const i = e.map(
-    (p) => I(p.claimer_pubkey)
+    (d) => V(d.claimer_pubkey)
   );
   if (new Set(i).size !== i.length)
     throw new Error("Presign response contains duplicate claimer entries");
-  const u = i.filter((p) => p !== s), l = new Set(u), c = n.filter((p) => !l.has(p)), d = u.filter((p) => !a.has(p));
-  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)), p = u.filter((d) => !a.has(d));
+  if (c.length > 0 || p.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(", ")})` : "") + (p.length > 0 ? ` (unexpected: ${p.join(", ")})` : "")
     );
 }
 function st(e, t) {
@@ -2160,8 +2160,8 @@ function st(e, t) {
     vpCommissionScriptPubKey: t.vpCommissionScriptPubKey
   };
 }
-async function Es(e, t, r, o) {
-  const s = new ar({
+async function $s(e, t, r, o) {
+  const s = new ur({
     network: t.network,
     btcWallet: e
   }), n = r.length;
@@ -2188,7 +2188,7 @@ async function Es(e, t, r, o) {
     };
   return o == null || o(n, n), i;
 }
-async function mn(e) {
+async function xn(e) {
   const {
     statusReader: t,
     presignClient: r,
@@ -2198,22 +2198,22 @@ async function mn(e) {
     depositorPk: a,
     signingContext: i,
     depositTerms: u,
-    timeoutMs: l = Ps,
+    timeoutMs: l = ms,
     signal: c,
-    onProgress: d,
-    recordGraphFingerprint: p
-  } = e, g = await zt({
+    onProgress: p,
+    recordGraphFingerprint: d
+  } = e, g = await jt({
     statusReader: t,
     vaultId: s,
     peginTxid: n,
-    targetStatuses: ms,
+    targetStatuses: bs,
     timeoutMs: l,
     signal: c
   });
-  if (jt.has(g))
+  if (Wt.has(g))
     return;
-  c == null || c.throwIfAborted(), u !== void 0 && ws(u, i);
-  const h = vt(o) ? o : void 0;
+  c == null || c.throwIfAborted(), u !== void 0 && xs(u, i);
+  const h = Pt(o) ? o : void 0;
   let y;
   if (h) {
     if (!u)
@@ -2229,21 +2229,21 @@ async function mn(e) {
     },
     c
   );
-  c == null || c.throwIfAborted(), f.txs.forEach((O, se) => {
-    ss({
-      claimTxHex: O.claim_tx.tx_hex,
-      assertTxHex: O.assert_tx.tx_hex,
+  c == null || c.throwIfAborted(), f.txs.forEach((N, se) => {
+    ns({
+      claimTxHex: N.claim_tx.tx_hex,
+      assertTxHex: N.assert_tx.tx_hex,
       path: `txs[${se}]`
     });
   });
-  const m = as({
+  const b = us({
     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 = {
     vaultCoreVersion: i.vaultCoreVersion,
     peginTxHex: i.peginTxHex,
     depositorBtcPubkey: a,
@@ -2261,50 +2261,50 @@ async function mn(e) {
     vkClaimerPayoutScriptPubKeys: i.vkClaimerPayoutScriptPubKeys,
     vpCommissionScriptPubKey: i.vpCommissionScriptPubKey
   };
-  await Xt(
+  await zt(
     f.depositor_graph,
-    $
+    k
   ), c == null || c.throwIfAborted();
-  const x = I(a);
-  xs(
+  const x = V(a);
+  Es(
     f.txs,
     i.vaultProviderBtcPubkey,
     i.vaultKeeperBtcPubkeys,
     a
   );
   const v = f.txs.filter(
-    (O) => I(O.claimer_pubkey) !== x
-  ), E = bs(v);
+    (N) => V(N.claimer_pubkey) !== x
+  ), E = ws(v);
   h && y && (typeof h.validateDepositTerms == "function" && await h.validateDepositTerms(y), await h.approveDepositTerms(y)), c == null || c.throwIfAborted();
-  const T = await Es(
+  const C = await $s(
     o,
     i,
     E,
-    d
+    p
   );
   c == null || c.throwIfAborted();
-  const w = await ys({
+  const m = await vs({
     depositorGraph: f.depositor_graph,
     btcWallet: o,
-    signingContext: $
+    signingContext: k
   });
-  c == null || c.throwIfAborted(), await p(m), c == null || c.throwIfAborted();
-  const j = { ...T };
-  j[P(a)] = w.payout_signatures, await r.submitDepositorPresignatures(
+  c == null || c.throwIfAborted(), await d(b), c == null || c.throwIfAborted();
+  const W = { ...C };
+  W[P(a)] = m.payout_signatures, await r.submitDepositorPresignatures(
     {
       pegin_txid: n,
       depositor_pk: a,
-      signatures: j,
-      depositor_claimer_presignatures: w
+      signatures: W,
+      depositor_claimer_presignatures: m
     },
     c
   );
 }
-const ks = 300 * 1e3, $s = /* @__PURE__ */ new Set([
-  R.PENDING_DEPOSITOR_WOTS_PK,
-  ...Ct
+const ks = 300 * 1e3, Cs = /* @__PURE__ */ new Set([
+  K.PENDING_DEPOSITOR_WOTS_PK,
+  ...Tt
 ]);
-async function bn(e) {
+async function En(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
@@ -2316,15 +2316,15 @@ async function bn(e) {
     signal: u
   } = e;
   u == null || u.throwIfAborted();
-  const l = await zt({
+  const l = await jt({
     statusReader: t,
     vaultId: o,
     peginTxid: s,
-    targetStatuses: $s,
+    targetStatuses: Cs,
     timeoutMs: i,
     signal: u
   });
-  Ct.has(l) || (u == null || u.throwIfAborted(), await r.submitDepositorWotsKey(
+  Tt.has(l) || (u == null || u.throwIfAborted(), await r.submitDepositorWotsKey(
     {
       pegin_txid: s,
       depositor_pk: n,
@@ -2333,10 +2333,10 @@ async function bn(e) {
     u
   ));
 }
-function $e(e) {
+function ke(e) {
   return e.registration || e.operation;
 }
-function Cs(e, t, r) {
+function Ts(e, t, r) {
   const o = _(e);
   return {
     registration: o === _(t),
@@ -2356,7 +2356,7 @@ function Ce(e) {
 function it(e, t) {
   return e.length === t.length && e.every((r, o) => r === t[o]);
 }
-async function wn(e) {
+async function $n(e) {
   const {
     vaultProviderEthAddress: t,
     hintBtcPubkey: r,
@@ -2380,11 +2380,11 @@ class Se extends Error {
     super(t), this.name = "ApplicationEntryPointMismatchError";
   }
 }
-function xn(e) {
+function kn(e) {
   return e instanceof Se || e instanceof Error && e.name === "ApplicationEntryPointMismatchError";
 }
 const at = (e) => e.map(_).sort();
-async function En(e) {
+async function Cn(e) {
   const {
     vaultRegistryReader: t,
     vaultKeeperReader: r,
@@ -2396,8 +2396,8 @@ async function En(e) {
     expectedUniversalChallengerBtcPubkeys: u,
     operationKeyReader: l,
     onIndexerServingOperationKeys: c,
-    onIndexerHintsInconsistent: d,
-    blockNumber: p
+    onIndexerHintsInconsistent: p,
+    blockNumber: d
   } = e, [
     g,
     h,
@@ -2406,49 +2406,49 @@ async function En(e) {
   ] = await Promise.all([
     t.getVaultProviderApplication(
       s,
-      p
+      d
     ),
     t.getVaultProviderGenesisBtcPubKey(
       s,
-      p
+      d
     ),
-    o.getLatestUniversalChallengersVersion(p),
-    o.getCurrentUcKeyEpoch(p)
+    o.getLatestUniversalChallengersVersion(d),
+    o.getCurrentUcKeyEpoch(d)
   ]);
-  if (!Dr(n, { strict: !1 }))
+  if (!Lr(n, { strict: !1 }))
     throw new Se(
       `The application entry point this deposit was prepared for is not a valid address: ${n}`
     );
-  if (!Lr(g, n))
+  if (!Mr(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, $] = await Promise.all(
+  const [b, k] = await Promise.all(
     [
       r.getCurrentVaultKeepersVersion(
         g,
-        p
+        d
       ),
       r.getCurrentAppKeeperKeyEpoch(
         g,
-        p
+        d
       )
     ]
   ), [x, v] = await Promise.all([
     r.getVaultKeepersByVersion(
       g,
-      m,
-      p
+      b,
+      d
     ),
     o.getUniversalChallengersByVersion(
       y,
-      p
+      d
     )
   ]), E = {
     vaultProvider: _(h),
-    vaultKeepers: at(x.map((C) => C.btcPubKey)),
-    universalChallengers: at(v.map((C) => C.btcPubKey))
-  }, T = await Xo({
+    vaultKeepers: at(x.map((T) => T.btcPubKey)),
+    universalChallengers: at(v.map((T) => T.btcPubKey))
+  }, C = await zo({
     operationKeyReader: l,
     query: {
       vaultProviderEthAddress: s,
@@ -2457,61 +2457,61 @@ async function En(e) {
       vaultKeepers: x,
       universalChallengers: v
     },
-    blockNumber: p
-  }), w = {
-    vaultProvider: T.vaultProvider.operationBtcPubkey,
-    vaultKeepers: [...T.vaultKeeperOperationKeysSorted],
+    blockNumber: d
+  }), m = {
+    vaultProvider: C.vaultProvider.operationBtcPubkey,
+    vaultKeepers: [...C.vaultKeeperOperationKeysSorted],
     universalChallengers: [
-      ...T.universalChallengerOperationKeysSorted
+      ...C.universalChallengerOperationKeysSorted
     ]
-  }, j = Cs(
+  }, W = Ts(
     a,
     E.vaultProvider,
-    w.vaultProvider
-  ), O = nt(
+    m.vaultProvider
+  ), N = nt(
     i,
     E.vaultKeepers,
-    w.vaultKeepers
+    m.vaultKeepers
   ), se = nt(
     u,
     E.universalChallengers,
-    w.universalChallengers
+    m.universalChallengers
   );
-  if (!$e(j))
+  if (!ke(W))
     throw new Error(
       `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${s}. Refresh and try again.`
     );
-  if (!$e(O))
+  if (!ke(N))
     throw new Error(
-      `Vault keeper BTC pubkeys (v${m}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
+      `Vault keeper BTC pubkeys (v${b}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
     );
-  if (!$e(se))
+  if (!ke(se))
     throw new Error(
       `Universal challenger BTC pubkeys (v${y}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
     );
-  const Ne = [j, O, se], er = Ne.some((C) => C.registration && !C.operation), De = Ne.some((C) => C.operation && !C.registration);
-  if (er && 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.`);
+  const Ne = [W, N, se], tr = Ne.some((T) => T.registration && !T.operation), De = Ne.some((T) => T.operation && !T.registration);
+  if (tr && De) {
+    const T = `Indexer participant hints are internally inconsistent for vault provider ${s}: some roles match the registration keys while others match the rotated operation keys.`;
+    throw p == null || p(T), new Error(`${T} Refresh and try again.`);
   }
   return De && (c == null || c(
     `Indexer is serving rotated operation keys for vault provider ${s}`
   )), {
-    vaultProviderBtcPubkeyXOnly: w.vaultProvider,
-    vaultKeeperBtcPubkeysSorted: w.vaultKeepers,
-    universalChallengerBtcPubkeysSorted: w.universalChallengers,
-    expectedAppVaultKeepersVersion: m,
+    vaultProviderBtcPubkeyXOnly: m.vaultProvider,
+    vaultKeeperBtcPubkeysSorted: m.vaultKeepers,
+    universalChallengerBtcPubkeysSorted: m.universalChallengers,
+    expectedAppVaultKeepersVersion: b,
     expectedUniversalChallengersVersion: y,
-    appKeeperKeyEpoch: $,
+    appKeeperKeyEpoch: k,
     ucKeyEpoch: f,
     registrationKeys: E,
-    participantKeys: T
+    participantKeys: C
   };
 }
-function Ts(e) {
+function _s(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function kn(e) {
+function Tn(e) {
   const {
     amountSats: t,
     minDeposit: r,
@@ -2522,29 +2522,29 @@ function kn(e) {
   } = e;
   return !(t <= 0n || t < r || o && o > 0n && t > o || n == null || a == null || t + n + a > s);
 }
-function $n(e, t, r) {
+function _n(e, t, r) {
   return e <= 0n ? {
     valid: !1,
     error: "Deposit amount must be greater than zero"
   } : e < t ? {
     valid: !1,
-    error: `Minimum deposit is ${N(t)} BTC`
+    error: `Minimum deposit is ${D(t)} BTC`
   } : r && r > 0n && e > r ? {
     valid: !1,
-    error: `Maximum deposit is ${N(r)} BTC`
+    error: `Maximum deposit is ${D(r)} BTC`
   } : { valid: !0 };
 }
-function Cn(e) {
+function Sn(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 (${N(r)} BTC)`
+    error: `Vault size exceeds remaining capacity (${D(r)} BTC)`
   } : { valid: !0 };
 }
-function Tn(e, t) {
+function An(e, t) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -2560,7 +2560,7 @@ function Tn(e, t) {
     error: "Invalid vault provider selected"
   } : { valid: !0 };
 }
-function _s(e, t, r) {
+function Ss(e, t, r) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -2576,40 +2576,40 @@ function _s(e, t, r) {
     if (t && s < t)
       return {
         valid: !1,
-        error: `Vault ${o + 1} amount ${N(s)} BTC is below minimum deposit ${N(t)} BTC`
+        error: `Vault ${o + 1} amount ${D(s)} BTC is below minimum deposit ${D(t)} BTC`
       };
     if (r && s > r)
       return {
         valid: !1,
-        error: `Vault ${o + 1} amount ${N(s)} BTC exceeds maximum deposit ${N(r)} BTC`
+        error: `Vault ${o + 1} amount ${D(s)} BTC exceeds maximum deposit ${D(r)} BTC`
       };
   }
   return { valid: !0 };
 }
-function Ss(e) {
+function As(e) {
   const t = P(e);
-  return Ts(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 As(e) {
+function Bs(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 Bs(e) {
+function Is(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 Is(e) {
+function Vs(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function _n(e) {
+function Bn(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
@@ -2618,38 +2618,38 @@ function _n(e) {
     universalChallengerBtcPubkeys: n,
     minDeposit: a,
     maxDeposit: i
-  } = e, u = _s(
+  } = e, u = Ss(
     t,
     a,
     i
   );
   if (!u.valid)
     throw new Error(u.error);
-  const l = Ss(o);
+  const l = As(o);
   if (!l.valid)
     throw new Error(l.error);
-  As(s), Bs(n), Is(r);
+  Bs(s), Is(n), Vs(r);
 }
-class Wt extends Error {
+class Yt extends Error {
   constructor(t) {
     super(t), this.name = "ParticipantKeyDriftError";
   }
 }
-function Sn(e) {
-  return e instanceof Wt || e instanceof Error && e.name === "ParticipantKeyDriftError";
+function In(e) {
+  return e instanceof Yt || e instanceof Error && e.name === "ParticipantKeyDriftError";
 }
-class Yt extends Error {
+class Qt extends Error {
   constructor(t) {
     super(t), this.name = "UnsupportedPayoutScriptError";
   }
 }
-function An(e) {
-  return e instanceof Yt || e instanceof Error && e.name === "UnsupportedPayoutScriptError";
+function Vn(e) {
+  return e instanceof Qt || e instanceof Error && e.name === "UnsupportedPayoutScriptError";
 }
 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 Vs(e) {
+async function Rs(e) {
   const { operationKeyReader: t, query: r, epochs: o, vaultIds: s } = e, n = await t.getPayoutScriptsAtEpochs(
     r,
     o
@@ -2660,7 +2660,7 @@ async function Vs(e) {
     );
   const a = [], i = (u, l) => {
     try {
-      Hr(u, l);
+      Or(u, l);
     } catch (c) {
       a.push(
         `vaults ${s.join(", ")}: ${c.message}`
@@ -2677,57 +2677,57 @@ async function Vs(e) {
       `Vault keeper ${l.ethAddress} payout script`
     );
   if (a.length > 0)
-    throw new Yt(
+    throw new Qt(
       `Aborting Pre-PegIn broadcast: an operator payout script registered for this vault is not a standard output type this app can verify (${a.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-async function Bn(e) {
+async function Rn(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 [l, c] of a.entries()) {
-    const d = o[l];
-    let p;
+    const p = o[l];
+    let d;
     try {
-      p = await Nt({
+      d = await Dt({
         operationKeyReader: r,
         query: n,
         epochs: c
       });
     } catch (y) {
       i.push(
-        `vault ${d}: could not resolve participants at frozen epochs (vp=${c.vpKeyEpoch}, keeper=${c.appKeeperKeyEpoch}, uc=${c.ucKeyEpoch}): ${y.message}`
+        `vault ${p}: could not resolve participants at frozen epochs (vp=${c.vpKeyEpoch}, keeper=${c.appKeeperKeyEpoch}, uc=${c.ucKeyEpoch}): ${y.message}`
       );
       continue;
     }
-    p.vaultProvider.operationBtcPubkey !== s.vaultProvider.operationBtcPubkey && i.push(
-      `vault ${d}: vault provider key expected ${s.vaultProvider.operationBtcPubkey}, got ${p.vaultProvider.operationBtcPubkey}`
+    d.vaultProvider.operationBtcPubkey !== s.vaultProvider.operationBtcPubkey && i.push(
+      `vault ${p}: vault provider key expected ${s.vaultProvider.operationBtcPubkey}, got ${d.vaultProvider.operationBtcPubkey}`
     );
     const g = ut(
-      `vault ${d}: vault keeper keys`,
+      `vault ${p}: vault keeper keys`,
       s.vaultKeeperOperationKeysSorted,
-      p.vaultKeeperOperationKeysSorted
+      d.vaultKeeperOperationKeysSorted
     );
     g && i.push(g);
     const h = ut(
-      `vault ${d}: universal challenger keys`,
+      `vault ${p}: universal challenger keys`,
       s.universalChallengerOperationKeysSorted,
-      p.universalChallengerOperationKeysSorted
+      d.universalChallengerOperationKeysSorted
     );
     h && i.push(h);
   }
   if (i.length > 0)
-    throw new Wt(
+    throw new Yt(
       `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.`
     );
   const u = /* @__PURE__ */ new Map();
   for (const [l, c] of a.entries()) {
-    const d = `${c.vpKeyEpoch}:${c.appKeeperKeyEpoch}:${c.ucKeyEpoch}`, p = u.get(d);
-    p ? p.vaultIds.push(o[l]) : u.set(d, { epochs: c, vaultIds: [o[l]] });
+    const p = `${c.vpKeyEpoch}:${c.appKeeperKeyEpoch}:${c.ucKeyEpoch}`, d = u.get(p);
+    d ? d.vaultIds.push(o[l]) : u.set(p, { epochs: c, vaultIds: [o[l]] });
   }
   await Promise.all(
     [...u.values()].map(
-      ({ epochs: l, vaultIds: c }) => Vs({
+      ({ epochs: l, vaultIds: c }) => Rs({
         operationKeyReader: r,
         query: n,
         epochs: l,
@@ -2736,15 +2736,15 @@ async function Bn(e) {
     )
   );
 }
-class Qt extends Error {
+class Jt extends Error {
   constructor(t) {
     super(t), this.name = "RegisteredVaultVersionMismatchError";
   }
 }
-function In(e) {
-  return e instanceof Qt || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
+function Kn(e) {
+  return e instanceof Jt || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function Vn(e) {
+async function Hn(e) {
   const {
     vaultRegistryReader: t,
     vaultIds: r,
@@ -2754,44 +2754,56 @@ async function Vn(e) {
     expectedVaultCoreVersion: a
   } = e, i = await t.getProtocolInfoBatch(r), u = [];
   if (i.forEach((l, c) => {
-    const d = r[c];
+    const p = r[c];
     l.offchainParamsVersion !== o && u.push(
-      `vault ${d}: offchainParams expected v${o}, got v${l.offchainParamsVersion}`
+      `vault ${p}: offchainParams expected v${o}, got v${l.offchainParamsVersion}`
     ), l.appVaultKeepersVersion !== s && u.push(
-      `vault ${d}: appVaultKeepers expected v${s}, got v${l.appVaultKeepersVersion}`
+      `vault ${p}: appVaultKeepers expected v${s}, got v${l.appVaultKeepersVersion}`
     ), l.universalChallengersVersion !== n && u.push(
-      `vault ${d}: universalChallengers expected v${n}, got v${l.universalChallengersVersion}`
+      `vault ${p}: 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 ${p}: vaultCoreVersion expected v${a} (build-time active), got v${l.vaultCoreVersion}`
     );
   }), u.length > 0)
-    throw new Qt(
+    throw new Jt(
       `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 Rs extends Error {
+class Ks extends Error {
   constructor(r, o) {
     super(`Refund not yet mature (BIP68 not final): ${o.message}`);
-    W(this, "vaultId");
-    W(this, "cause");
+    B(this, "vaultId");
+    B(this, "cause");
     this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = o;
   }
 }
-const Ks = /^0x[0-9a-fA-F]{64}$/, Hs = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, Jt = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, Zt = 160, ct = 2e3, lt = 10n, pt = 100n;
-function Rn(e) {
+class ct extends Error {
+  constructor(r, o, s, n) {
+    super(
+      `Refund broadcast rejected (bitcoind code ${r}): ${n.message}`
+    );
+    B(this, "code");
+    B(this, "vaultId");
+    B(this, "signedTxHex");
+    B(this, "cause");
+    this.name = "RefundBroadcastRejectedError", this.code = r, this.vaultId = o, this.signedTxHex = s, this.cause = n;
+  }
+}
+const Hs = /^0x[0-9a-fA-F]{64}$/, Os = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, Zt = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, er = 160, lt = 2e3, dt = 10n, pt = 100n;
+function On(e) {
   if (!Number.isFinite(e) || e <= 0)
     throw new Error(
       `feeRateSatsVb must be a positive finite number, got ${e}`
     );
-  return BigInt(Math.ceil(e * Zt));
+  return BigInt(Math.ceil(e * er));
 }
-const Os = 1, Ns = /non-BIP68-final/i;
+const Ns = 1, Ds = /non-BIP68-final/i, Ls = /"code"\s*:\s*-27\b/, Ms = /"code"\s*:\s*-25\b/;
 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 (!Ks.test(e))
+  if (!Hs.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
@@ -2800,7 +2812,7 @@ function Te(e, t) {
   if (!Number.isInteger(e) || e < 0)
     throw new Error(`${t} must be a non-negative integer, got ${e}`);
 }
-function Ds(e) {
+function Us(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}`
@@ -2834,24 +2846,24 @@ function Ds(e) {
   if (Te(e.offchainParamsVersion, "offchainParamsVersion"), Te(e.appVaultKeepersVersion, "appVaultKeepersVersion"), Te(
     e.universalChallengersVersion,
     "universalChallengersVersion"
-  ), eo(
+  ), to(
     e.vaultCoreVersion,
     "VaultRefundData.vaultCoreVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
     throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!Hs.test(e.unsignedPrePeginTxHex))
+  if (!Os.test(e.unsignedPrePeginTxHex))
     throw new Error(
       "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
     );
-  if (!e.depositorBtcPubkey || !Jt.test(e.depositorBtcPubkey))
+  if (!e.depositorBtcPubkey || !Zt.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 Ls(e) {
-  if (!e.vaultProviderPubkey || !Jt.test(e.vaultProviderPubkey))
+function Fs(e) {
+  if (!e.vaultProviderPubkey || !Zt.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");
@@ -2876,7 +2888,7 @@ function Ls(e) {
       `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
     );
 }
-async function Kn(e) {
+async function Nn(e) {
   const {
     vaultId: t,
     readVault: r,
@@ -2888,23 +2900,23 @@ async function Kn(e) {
   } = e;
   i == null || i.throwIfAborted(), Ae(t, "vaultId");
   const u = await r();
-  Ds(u), i == null || i.throwIfAborted();
+  Us(u), i == null || i.throwIfAborted();
   const l = await o(u);
-  if (Ls(l), i == null || i.throwIfAborted(), !Number.isFinite(s) || s <= 0)
+  if (Fs(l), i == null || i.throwIfAborted(), !Number.isFinite(s) || s <= 0)
     throw new Error(`feeRate must be a positive number, got ${s}`);
-  if (s > ct)
+  if (s > lt)
     throw new Error(
-      `feeRate ${s} sat/vB exceeds refund safety cap ${ct} sat/vB; refusing to sign refund.`
+      `feeRate ${s} sat/vB exceeds refund safety cap ${lt} sat/vB; refusing to sign refund.`
     );
-  const c = BigInt(Math.ceil(s * Zt)), d = u.amount * lt / pt;
-  if (c > d)
+  const c = BigInt(Math.ceil(s * er)), p = u.amount * dt / pt;
+  if (c > p)
     throw new Error(
-      `Refund fee ${c} sats exceeds the per-vault safety cap of ${d} sats (${lt}/${pt} of vault.amount=${u.amount}); refusing to sign refund.`
+      `Refund fee ${c} sats exceeds the per-vault safety cap of ${p} sats (${dt}/${pt} of vault.amount=${u.amount}); refusing to sign refund.`
     );
   i == null || i.throwIfAborted();
-  const p = he(
+  const d = he(
     u.depositorBtcPubkey
-  ), g = P(u.unsignedPrePeginTxHex), h = ur(g);
+  ), g = P(u.unsignedPrePeginTxHex), h = cr(g);
   if (h !== void 0 && h.vout !== u.batch.length)
     throw new Error(
       `Auth-anchor OP_RETURN at vout ${h.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.`
@@ -2913,23 +2925,23 @@ async function Kn(e) {
   let f;
   try {
     f = S.fromHex(g);
-  } catch (w) {
+  } catch (m) {
     throw new Error(
-      `Failed to parse funded Pre-PegIn transaction hex: ${w instanceof Error ? w.message : String(w)}`
+      `Failed to parse funded Pre-PegIn transaction hex: ${m instanceof Error ? m.message : String(m)}`
     );
   }
   if (f.outs.length < u.batch.length)
     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 Qr({
+  const { psbtHex: b } = await Jr({
     prePeginParams: {
       vaultCoreVersion: u.vaultCoreVersion,
-      depositorPubkey: p,
+      depositorPubkey: d,
       vaultProviderPubkey: P(l.vaultProviderPubkey),
       vaultKeeperPubkeys: l.vaultKeeperPubkeys.map(P),
       universalChallengerPubkeys: l.universalChallengerPubkeys.map(P),
-      hashlocks: u.batch.map((w) => P(w.hashlock)),
+      hashlocks: u.batch.map((m) => P(m.hashlock)),
       timelockRefund: l.timelockRefund,
       // `batch[i].amount` is the on-chain vault deposit (peg-in) amount, which
       // is exactly what WASM's `pegInAmounts` expects — it re-adds the protocol
@@ -2937,7 +2949,7 @@ async function Kn(e) {
       // HTLC output. `buildRefundPsbt`'s value cross-check then binds the result
       // to the funded tx bytes, refusing the refund if the template's HTLC value
       // disagrees with the on-chain commitment.
-      pegInAmounts: u.batch.map((w) => w.amount),
+      pegInAmounts: u.batch.map((m) => m.amount),
       feeRate: l.feeRate,
       minPeginFeeRate: l.minPeginFeeRate,
       numLocalChallengers: l.numLocalChallengers,
@@ -2956,40 +2968,48 @@ async function Kn(e) {
     hashlock: P(u.hashlock)
   });
   i == null || i.throwIfAborted();
-  const $ = ce(
+  const k = ce(
     u.depositorBtcPubkey,
-    Os
-  ), x = await n(m, $);
+    Ns
+  ), x = await n(b, k);
   ae({
-    requestedPsbtHex: m,
+    requestedPsbtHex: b,
     returnedPsbtHex: x
   });
   const v = 0, E = ue(
     x,
-    p,
+    d,
     v
   );
   oe({
-    requestedPsbtHex: m,
+    requestedPsbtHex: b,
     signatureHex: E,
-    signerXOnlyPubkeyHex: p,
+    signerXOnlyPubkeyHex: d,
     inputIndex: v
   });
-  const T = Tt({
-    requestedPsbtHex: m,
+  const C = _t({
+    requestedPsbtHex: b,
     signaturesHex: [E],
-    signerXOnlyPubkeyHex: p
+    signerXOnlyPubkeyHex: d
   });
   i == null || i.throwIfAborted();
   try {
-    return await a(T);
-  } catch (w) {
-    throw w instanceof Error && Ns.test(w.message) ? new Rs(t, w) : w;
+    return await a(C);
+  } catch (m) {
+    if (m instanceof Error) {
+      if (Ds.test(m.message))
+        throw new Ks(t, m);
+      if (Ls.test(m.message))
+        throw new ct(-27, t, C, m);
+      if (Ms.test(m.message))
+        throw new ct(-25, t, C, m);
+    }
+    throw m;
   }
 }
-async function Hn(e) {
+async function Dn(e) {
   const { vaultId: t, vault: r, readers: o, network: s } = e, [n, a] = await Promise.all([
-    Dt({
+    Lt({
       vaultId: t,
       vault: {
         basic: {
@@ -3023,21 +3043,21 @@ async function Hn(e) {
     network: s
   };
 }
-class dt extends Error {
+class ht extends Error {
   constructor(r, o, s) {
     super(r);
     /** Fee the reclaim would have paid, in satoshis. */
-    W(this, "feeSats");
+    B(this, "feeSats");
     /** Sum of the reserves the reclaim would have swept, in satoshis. */
-    W(this, "sweptTotalSats");
+    B(this, "sweptTotalSats");
     this.name = "ReclaimUneconomicalError", this.feeSats = o, this.sweptTotalSats = s;
   }
 }
-const ht = 2e3, gt = 25n, ft = 100n, On = 10n;
-async function Ms(e, t, r) {
+const gt = 2e3, ft = 25n, yt = 100n, Ln = 10n;
+async function qs(e, t, r) {
   for (let o = 0; o < e.length; o++) {
-    const s = to(e[o].depositorSignedPeginTxHex), n = Ie(
-      await wr(
+    const s = ro(e[o].depositorSignedPeginTxHex), n = Ie(
+      await xr(
         P(s),
         P(r)
       )
@@ -3048,7 +3068,7 @@ async function Ms(e, t, r) {
       );
   }
 }
-async function Nn(e) {
+async function Mn(e) {
   const {
     vaultIds: t,
     depositorEthAddress: r,
@@ -3063,9 +3083,9 @@ async function Nn(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 > ht)
-    throw new dt(
-      `Fee rate ${n} sat/vB exceeds the reclaim safety cap of ${ht} sat/vB; refusing to sign.`,
+  if (n > gt)
+    throw new ht(
+      `Fee rate ${n} sat/vB exceeds the reclaim safety cap of ${gt} sat/vB; refusing to sign.`,
       0n,
       0n
     );
@@ -3074,131 +3094,132 @@ async function Nn(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 Ms(l, t, r), u == null || u.throwIfAborted();
-  const c = he(o), d = l.map((v) => ({
+  await qs(l, t, r), u == null || u.throwIfAborted();
+  const c = he(o), p = l.map((v) => ({
     depositorSignedPeginTxHex: v.depositorSignedPeginTxHex,
     observed: v.observed,
     expectedValue: v.expectedClaimValue
-  })), p = Jr(n, d.length), g = d.reduce((v, E) => v + E.expectedValue, 0n), h = g * gt / ft;
-  if (p > h)
-    throw new dt(
-      `Reclaim fee ${p} sats exceeds ${gt}/${ft} of the swept total (${g} sats, cap ${h} sats). The reserve is not at risk — it stays where it is until fee rates fall.`,
-      p,
+  })), d = Zr(n, p.length), g = p.reduce((v, E) => v + E.expectedValue, 0n), h = g * ft / yt;
+  if (d > h)
+    throw new ht(
+      `Reclaim fee ${d} sats exceeds ${ft}/${yt} of the swept total (${g} sats, cap ${h} 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 } = Zr({
+  const { psbtHex: y } = eo({
     depositorPubkey: c,
-    inputs: d,
-    feeSats: p
+    inputs: p,
+    feeSats: d
   });
   u == null || u.throwIfAborted();
   const f = ce(
     o,
-    d.length
-  ), m = await a(y, f);
+    p.length
+  ), b = await a(y, f);
   ae({
     requestedPsbtHex: y,
-    returnedPsbtHex: m
+    returnedPsbtHex: b
   });
-  const $ = d.map((v, E) => {
-    const T = ue(
-      m,
+  const k = p.map((v, E) => {
+    const C = ue(
+      b,
       c,
       E
     );
     return oe({
       requestedPsbtHex: y,
-      signatureHex: T,
+      signatureHex: C,
       signerXOnlyPubkeyHex: c,
       inputIndex: E
-    }), T;
-  }), x = Tt({
+    }), C;
+  }), x = _t({
     requestedPsbtHex: y,
-    signaturesHex: $,
+    signaturesHex: k,
     signerXOnlyPubkeyHex: c
   });
   return u == null || u.throwIfAborted(), i(x);
 }
 export {
-  Bn as $,
-  K as A,
-  Pn as B,
-  po as C,
-  F as D,
-  us as E,
-  mn as F,
-  b as G,
-  ys as H,
-  bn as I,
+  Rn as $,
+  H as A,
+  wn as B,
+  ho as C,
+  q as D,
+  cs as E,
+  xn as F,
+  w as G,
+  vs as H,
+  En as I,
   Se as J,
-  xn as K,
-  En as L,
-  kn as M,
-  $n as N,
-  _n as O,
-  go as P,
-  Tn as Q,
-  Cn as R,
+  kn as K,
+  Cn as L,
+  Tn as M,
+  _n as N,
+  Bn as O,
+  fo as P,
+  An as Q,
+  Sn as R,
   Y as S,
-  _s as T,
-  Ss as U,
-  Po as V,
-  Wt as W,
-  Yt as X,
-  Vs as Y,
-  Sn as Z,
-  An as _,
-  cn as a,
-  Qt as a0,
-  In as a1,
-  Vn as a2,
-  zt as a3,
-  wn as a4,
-  $e as a5,
-  Cs as a6,
+  Ss as T,
+  As as U,
+  mo as V,
+  Yt as W,
+  Qt as X,
+  Rs as Y,
+  In as Z,
+  Vn as _,
+  pn as a,
+  Jt as a0,
+  Kn as a1,
+  Hn as a2,
+  jt as a3,
+  $n as a4,
+  ke as a5,
+  Ts as a6,
   nt as a7,
-  Dt as a8,
-  Xo as a9,
-  Nt as aa,
-  Rs as ab,
-  Kn as ac,
-  Rn as ad,
-  pt as ae,
-  lt as af,
-  ct as ag,
-  Zt as ah,
-  Hn as ai,
-  dt as aj,
-  Nn as ak,
-  ft as al,
-  gt as am,
-  ht as an,
-  On as ao,
-  ln as b,
-  pn as c,
-  hn as d,
-  Io as e,
-  co as f,
-  ho as g,
-  gn as h,
-  fo as i,
+  Lt as a8,
+  zo as a9,
+  Dt as aa,
+  Ks as ab,
+  ct as ac,
+  Nn as ad,
+  On as ae,
+  pt as af,
+  dt as ag,
+  lt as ah,
+  er as ai,
+  Dn as aj,
+  ht as ak,
+  Mn as al,
+  yt as am,
+  ft as an,
+  gt as ao,
+  Ln as ap,
+  hn as b,
+  gn as c,
+  yn as d,
+  Vo as e,
+  lo as f,
+  go as g,
+  vn as h,
+  yo as i,
   ne as j,
-  vo as k,
-  wo as l,
-  dn as m,
-  Ro as n,
-  Lo as o,
-  So as p,
-  Ho as q,
-  fn as r,
+  Po as k,
+  xo as l,
+  fn as m,
+  Ko as n,
+  Mo as o,
+  Ao as p,
+  Oo as q,
+  Pn as r,
   ko as s,
-  St as t,
-  zo as u,
-  Lt as v,
-  Mt as w,
-  Qo as x,
-  yn as y,
-  vn as z
+  At as t,
+  jo as u,
+  Mt as v,
+  Ut as w,
+  Jo as x,
+  mn as y,
+  bn as z
 };
-//# sourceMappingURL=buildAndBroadcastReclaim-Acz637Vf.js.map
+//# sourceMappingURL=buildAndBroadcastReclaim-Bs_zdDGN.js.map