@babylonlabs-io/ts-sdk 2.0.1 → 3.0.0

package/dist/{buildAndBroadcastReclaim-CqO2DoP8.js → buildAndBroadcastReclaim-T5ZFPUpM.js}

@@ -1,80 +1,81 @@
-var qe = Object.defineProperty;
-var ze = (e, t, r) => t in e ? qe(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var R = (e, t, r) => ze(e, typeof t != "symbol" ? t + "" : t, r);
-import { B as Ee } from "./BTCVaultRegistry.abi-B0x9_Bza.js";
-import { e as xe, s as P, i as je, v as We, u as ke, p as D, c as A, f as S } from "./bitcoin-C-TuHb-v.js";
-import { v as Ye, d as Te, s as Qe, P as Je, a as Ze } from "./PayoutManager-CHTOwj0E.js";
-import { Buffer as $ } from "buffer";
-import { b as et, a as V, c as tt } from "./signing-Dhr2t0Z6.js";
-import { buildClaimPsbt as rt, buildAssertClaimerPsbt as ot, buildPayoutClaimerPsbt as nt, buildWronglyChallengedPsbts as st, buildPayoutDepositorPsbt as at, finalizeClaimTx as it, buildWatchtowerArtifacts as ut, extractTapScriptSig as ct, expandWotsSeed as lt, wotsKeypairFromSeed as ht, validateWotsKeypairAgainstGraph as dt, verifyWatchtowerArtifacts as pt, deriveVaultId as gt } from "./tbv/core/wasm/index.js";
-import { p as Ce, f as ft, i as K, g as O, j as N } from "./verifyScriptPathSchnorrSignature-CpjSTfMj.js";
-import { Psbt as Ae, Transaction as B } from "bitcoinjs-lib";
-import { m as te, n as re, N as M, o as oe, D as ne } from "./constants-D5vORbQE.js";
-import { d as vt } from "./deriveVaultRoot-BwbXmN0x.js";
-import { d as bt, a as se } from "./onChainBtcPubkey-C1WqyxPM.js";
-import { zeroAddress as Pt, isAddress as yt, isAddressEqual as mt } from "viem";
-import { D as _, c as wt, b as Et, R as xt, d as _e } from "./json-rpc-client-DuUARJvV.js";
-import { d as kt, c as Tt, b as Ct, f as Se, e as At, a as _t } from "./noPayout-qBXWKwav.js";
-import { a as St } from "./secp256k1-D-H9jmd7.js";
-const Bt = /^0x[0-9a-fA-F]{64}$/, $t = /^0x[0-9a-fA-F]{40}$/, Rt = /^0x([0-9a-fA-F]{2})*$/;
-function F(e, t) {
+var at = Object.defineProperty;
+var it = (e, t, r) => t in e ? at(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var O = (e, t, r) => it(e, typeof t != "symbol" ? t + "" : t, r);
+import { B as Ne } from "./BTCVaultRegistry.abi-B0x9_Bza.js";
+import { e as He, s as f, i as ut, c as $, v as ct, u as Ke, p as j, f as V } from "./bitcoin-C-TuHb-v.js";
+import { v as lt, d as De, s as ht, P as pt, a as dt } from "./PayoutManager-BSwbUQeF.js";
+import { Buffer as I } from "buffer";
+import { b as gt, a as M, c as ft } from "./signing-Dhr2t0Z6.js";
+import { buildClaimPsbt as yt, buildAssertClaimerPsbt as bt, buildPayoutClaimerPsbt as mt, buildWronglyChallengedPsbts as Pt, buildPayoutDepositorPsbt as vt, finalizeClaimTx as wt, buildWatchtowerArtifacts as xt, extractTapScriptSig as Et, expandWotsSeed as kt, wotsKeypairFromSeed as _t, validateWotsKeypairAgainstGraph as Tt, verifyWatchtowerArtifacts as $t, deriveVaultId as Ct } from "./tbv/core/wasm/index.js";
+import { p as Me, P as le, f as At, i as F, g as U, j as L } from "./verifyScriptPathSchnorrSignature-CpjSTfMj.js";
+import { Psbt as Fe, Transaction as B } from "bitcoinjs-lib";
+import { m as he, n as pe, N as q, o as de, D as ge } from "./constants-D5vORbQE.js";
+import { d as St } from "./deriveVaultRoot-BcvmER1E.js";
+import { d as It, a as fe } from "./onChainBtcPubkey-CCTdl53s.js";
+import { zeroAddress as Rt, isAddress as Bt, isAddressEqual as Vt } from "viem";
+import { D as R, c as Ot, b as Nt, R as Ht, d as Ue } from "./state-mE-QfITd.js";
+import { h as ye, b as Kt, s as Dt, j as Mt } from "./sha2-YqVHJiFj.js";
+import { d as Ft, c as Ut, b as Lt, f as Le, e as Gt, a as Xt } from "./noPayout-qBXWKwav.js";
+import { a as jt } from "./secp256k1-D-H9jmd7.js";
+const qt = /^0x[0-9a-fA-F]{64}$/, zt = /^0x[0-9a-fA-F]{40}$/, Wt = /^0x([0-9a-fA-F]{2})*$/;
+function z(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 (!Bt.test(e))
+  if (!qt.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function It(e, t) {
-  if (!$t.test(e))
+function Yt(e, t) {
+  if (!zt.test(e))
     throw new Error(
       `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
     );
 }
-function Vt(e, t) {
-  if (!Rt.test(e))
+function Qt(e, t) {
+  if (!Wt.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
 }
-function Be(e) {
-  It(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), F(e.vaultId, "vaultId");
-  const t = xe(e.secret);
-  if (F(t, "secret"), e.hashlock !== void 0 && (F(e.hashlock, "hashlock"), !Ye(t, e.hashlock)))
+function Ge(e) {
+  Yt(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), z(e.vaultId, "vaultId");
+  const t = He(e.secret);
+  if (z(t, "secret"), e.hashlock !== void 0 && (z(e.hashlock, "hashlock"), !lt(t, e.hashlock)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
   return t;
 }
-async function ao(e) {
+async function Bo(e) {
   const {
     btcVaultRegistryAddress: t,
     vaultId: r,
     hashlock: o,
     activationMetadata: n,
-    writeContract: u,
+    writeContract: a,
     signal: s
   } = e;
   s == null || s.throwIfAborted();
-  const i = Be({
+  const i = Ge({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
     hashlock: o
   });
-  return Vt(n, "activationMetadata"), u({
+  return Qt(n, "activationMetadata"), a({
     address: t,
-    abi: Ee,
+    abi: Ne,
     functionName: "activateVaultWithSecret",
     args: [r, i, n]
   });
 }
-async function io(e) {
-  const { btcVaultRegistryAddress: t, vaultId: r, hashlock: o, writeContract: n, signal: u } = e;
-  u == null || u.throwIfAborted();
-  const s = Be({
+async function Vo(e) {
+  const { btcVaultRegistryAddress: t, vaultId: r, hashlock: o, writeContract: n, signal: a } = e;
+  a == null || a.throwIfAborted();
+  const s = Ge({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
@@ -82,200 +83,200 @@ async function io(e) {
   });
   return n({
     address: t,
-    abi: Ee,
+    abi: Ne,
     functionName: "activateVaultWithSecretAndRedeem",
     args: [r, s]
   });
 }
-class Kt extends Error {
+class Jt 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 Ot(e) {
-  const t = Ce({
+function Zt(e) {
+  const t = Me({
     claimerBtcPubkey: e.depositorBtcPubkey,
     depositorBtcPubkey: e.depositorBtcPubkey,
     vaultProviderBtcPubkey: e.vaultProviderBtcPubkey,
     vaultKeeperBtcPubkeys: e.vaultKeeperBtcPubkeys
-  }), r = e.universalChallengerBtcPubkeys.map(ae), o = t.filter((h) => r.includes(h));
+  }), r = e.universalChallengerBtcPubkeys.map(be), o = t.filter((h) => r.includes(h));
   if (o.length > 0)
     throw new Error(
       `Cannot check the challenger set: vault keepers and universal challengers overlap (${o.join(", ")}).`
     );
-  const n = e.graphChallengerPubkeys.map(ae), u = new Set(n);
-  if (u.size !== n.length)
+  const n = e.graphChallengerPubkeys.map(be), a = new Set(n);
+  if (a.size !== n.length)
     throw new Error(
       "Transaction graph lists the same challenger more than once."
     );
-  const s = [...t, ...r], i = new Set(s), a = s.filter((h) => !u.has(h)), c = n.filter((h) => !i.has(h));
-  if (a.length > 0 || c.length > 0)
-    throw new Kt(a, c);
+  const s = [...t, ...r], i = new Set(s), u = s.filter((h) => !a.has(h)), c = n.filter((h) => !i.has(h));
+  if (u.length > 0 || c.length > 0)
+    throw new Jt(u, c);
 }
-function ae(e) {
-  return P(e).toLowerCase();
+function be(e) {
+  return f(e).toLowerCase();
 }
-const $e = 0;
-class Nt extends Error {
+const Xe = 0;
+class er extends Error {
   constructor(t, r) {
     super(
-      `Payout transaction output ${$e} pays ${r}, not the vault's registered payout script ${t}. Refusing to sign a payout to another destination.`
+      `Payout transaction output ${Xe} 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 Ht(e) {
+function tr(e) {
   let t;
   try {
-    t = Ae.fromBase64(e.payoutPsbtBase64);
-  } catch (a) {
-    throw new Error("Payout PSBT cannot be parsed.", { cause: a });
+    t = Fe.fromBase64(e.payoutPsbtBase64);
+  } catch (u) {
+    throw new Error("Payout PSBT cannot be parsed.", { cause: u });
   }
-  const { version: r, locktime: o, outs: n } = Dt(t);
-  if (r !== te || o !== re)
+  const { version: r, locktime: o, outs: n } = rr(t);
+  if (r !== he || o !== pe)
     throw new Error(
-      `Payout transaction has version ${r} and locktime ${o}, expected ${te} and ${re}.`
+      `Payout transaction has version ${r} and locktime ${o}, expected ${he} and ${pe}.`
     );
-  if (n.length !== M)
+  if (n.length !== q)
     throw new Error(
-      `Payout transaction has ${n.length} output(s), expected exactly ${M} for a depositor-as-claimer payout.`
+      `Payout transaction has ${n.length} output(s), expected exactly ${q} for a depositor-as-claimer payout.`
     );
-  const u = P(
+  const a = f(
     e.registeredPayoutScriptPubKey
   ).toLowerCase();
-  if (u.length === 0)
+  if (a.length === 0)
     throw new Error(
       "registeredPayoutScriptPubKey is empty; the vault's on-chain payout script is required to check the Payout destination."
     );
-  const s = n[$e].script.toString("hex").toLowerCase();
-  if (!$.from(s, "hex").equals($.from(u, "hex")))
-    throw new Nt(u, s);
-  const i = n[M - 1];
-  if (i.value !== oe)
+  const s = n[Xe].script.toString("hex").toLowerCase();
+  if (!I.from(s, "hex").equals(I.from(a, "hex")))
+    throw new er(a, s);
+  const i = n[q - 1];
+  if (i.value !== de)
     throw new Error(
-      `Payout CPFP anchor value ${i.value} sats must equal ${oe} sats.`
+      `Payout CPFP anchor value ${i.value} sats must equal ${de} sats.`
     );
 }
-function Dt(e) {
+function rr(e) {
   return {
     version: e.version,
     locktime: e.locktime,
     outs: e.txOutputs.map((t) => ({
-      script: $.from(t.script),
+      script: I.from(t.script),
       value: t.value
     }))
   };
 }
-const Re = 0;
-class Mt extends Error {
+const je = 0;
+class or 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 Ft(e) {
+function nr(e) {
   let t;
   try {
-    t = Ae.fromBase64(e);
+    t = Fe.fromBase64(e);
   } catch (o) {
     throw new Error("Claim PSBT cannot be parsed.", { cause: o });
   }
-  const r = t.txInputs[Re];
+  const r = t.txInputs[je];
   if (!r)
     throw new Error("Claim PSBT carries no PegIn input to bind the vault to.");
-  return Ve(r.hash);
+  return ze(r.hash);
 }
-function Ut(e) {
-  const t = e.ins[Re];
+function sr(e) {
+  const t = e.ins[je];
   if (!t)
     throw new Error(
       "Artifacts file's claim_tx carries no PegIn input to bind the vault to."
     );
-  return Ve(t.hash);
+  return ze(t.hash);
 }
-function Ie(e) {
-  const t = H(
-    bt(e.peginTxid, e.depositorEthAddress)
-  ), r = H(e.expectedVaultId);
+function qe(e) {
+  const t = G(
+    It(e.peginTxid, e.depositorEthAddress)
+  ), r = G(e.expectedVaultId);
   if (t !== r)
-    throw new Mt(r, t, e.peginTxid);
+    throw new or(r, t, e.peginTxid);
 }
-function H(e) {
+function G(e) {
   return `0x${(e.startsWith("0x") ? e.slice(2) : e).toLowerCase()}`;
 }
-function Ve(e) {
-  return $.from(e).reverse().toString("hex");
+function ze(e) {
+  return I.from(e).reverse().toString("hex");
 }
-const Lt = 0, Xt = 0, Gt = 1, qt = 0, zt = 0;
-async function uo(e) {
-  const { txGraphVersion: t } = e.vault, r = e.source.txGraphJson, [o, n, u, s] = await Promise.all([
-    rt(t, r),
-    ot(t, r),
-    nt(t, r),
-    st(t, r)
+const ar = 0, ir = 0, ur = 1, cr = 0, lr = 0;
+async function Oo(e) {
+  const { txGraphVersion: t } = e.vault, r = e.source.txGraphJson, [o, n, a, s] = await Promise.all([
+    yt(t, r),
+    bt(t, r),
+    mt(t, r),
+    Pt(t, r)
   ]);
-  Ie({
-    peginTxid: Ft(o),
+  qe({
+    peginTxid: nr(o),
     depositorEthAddress: e.vault.depositorEthAddress,
     expectedVaultId: e.vault.vaultId
   });
-  const i = await at(
+  const i = await vt(
     t,
     r
   );
-  for (const m of [u, i])
-    Ht({
-      payoutPsbtBase64: m,
+  for (const x of [a, i])
+    tr({
+      payoutPsbtBase64: x,
       registeredPayoutScriptPubKey: e.vault.registeredPayoutScriptPubKey
     });
-  Ot({
+  Zt({
     graphChallengerPubkeys: Object.keys(s),
     depositorBtcPubkey: e.depositorPublicKey,
     vaultProviderBtcPubkey: e.vault.vaultProviderBtcPubkey,
     vaultKeeperBtcPubkeys: e.vault.vaultKeeperBtcPubkeys,
     universalChallengerBtcPubkeys: e.vault.universalChallengerBtcPubkeys
   });
-  const a = [
-    { psbtBase64: o, inputIndex: Lt },
-    { psbtBase64: n, inputIndex: Xt },
-    { psbtBase64: u, inputIndex: Gt },
+  const u = [
+    { psbtBase64: o, inputIndex: ar },
+    { psbtBase64: n, inputIndex: ir },
+    { psbtBase64: a, inputIndex: ur },
     {
       psbtBase64: i,
-      inputIndex: qt
+      inputIndex: cr
     }
   ], c = Object.keys(s);
-  for (const m of c)
-    for (const w of s[m])
-      a.push({ psbtBase64: w, inputIndex: zt });
-  const h = await Wt(
+  for (const x of c)
+    for (const w of s[x])
+      u.push({ psbtBase64: w, inputIndex: lr });
+  const h = await pr(
     e.btcWallet,
     e.depositorPublicKey,
     e.btcNetwork,
-    a
+    u
   );
   let l = 0;
-  const d = h[l++], p = h[l++], g = h[l++], b = h[l++], f = {};
-  for (const m of c) {
-    const w = s[m].length;
-    f[m] = h.slice(
+  const p = h[l++], d = h[l++], g = h[l++], b = h[l++], y = {};
+  for (const x of c) {
+    const w = s[x].length;
+    y[x] = h.slice(
       l,
       l + w
     ), l += w;
   }
-  const v = await it(
+  const m = await wt(
     t,
     r,
-    d
+    p
   );
-  return ut({
+  return xt({
     txGraphVersion: t,
     graphJson: r,
-    signedClaimTxHex: v,
-    assertClaimerSigHex: p,
+    signedClaimTxHex: m,
+    assertClaimerSigHex: d,
     payoutClaimerSigHex: g,
-    wronglyChallengedSigs: f,
+    wronglyChallengedSigs: y,
     depositorPayoutSigHex: b,
     verifyingKeyHex: e.source.verifyingKeyHex,
     claimableEventBlockNumber: e.vault.claimableEventBlockNumber,
@@ -285,7 +286,7 @@ async function uo(e) {
     expectedVaultCoreVersion: e.vault.vaultCoreVersion
   });
 }
-function ie(e) {
+function me(e) {
   const t = e.replace(/^0x/, "").toLowerCase();
   if (t.length === 66) return t.slice(2);
   if (t.length === 64) return t;
@@ -293,29 +294,29 @@ function ie(e) {
     `Public key must be 33-byte compressed or 32-byte x-only hex, got ${t.length / 2} bytes.`
   );
 }
-async function jt(e, t, r) {
+async function hr(e, t, r) {
   const o = await e.getPublicKeyHex();
-  if (ie(o) !== ie(t))
+  if (me(o) !== me(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 n = await e.getAddress();
-  if (!je(n, t, r))
+  if (!ut(n, t, r))
     throw new Error(
       `Connected wallet reports address "${n}", which is not derived from the vault's depositor key. Select the account that made the deposit, then try again.`
     );
   return n;
 }
-async function Wt(e, t, r, o) {
-  const n = await jt(
+async function pr(e, t, r, o) {
+  const n = await hr(
     e,
     t,
     r
-  ), u = await Te(
+  ), a = await De(
     e,
-    o.map((s) => Yt(s.psbtBase64)),
+    o.map((s) => dr(s.psbtBase64)),
     o.map(
-      (s) => et(
+      (s) => gt(
         t,
         s.inputIndex,
         n
@@ -323,32 +324,32 @@ async function Wt(e, t, r, o) {
     )
   );
   return Promise.all(
-    u.map(
-      (s, i) => ct(Qt(s), o[i].inputIndex)
+    a.map(
+      (s, i) => Et(gr(s), o[i].inputIndex)
     )
   );
 }
-function Yt(e) {
-  return $.from(e, "base64").toString("hex");
+function dr(e) {
+  return I.from(e, "base64").toString("hex");
 }
-function Qt(e) {
-  return $.from(e, "hex").toString("base64");
+function gr(e) {
+  return I.from(e, "hex").toString("base64");
 }
-async function co(e) {
-  const t = await vt(e.btcWallet, e.vaultContext);
+async function No(e) {
+  const t = await St(e.btcWallet, e.vaultContext);
   let r;
   try {
-    r = await lt(t, e.htlcVout);
+    r = await kt(t, e.htlcVout);
   } finally {
     t.fill(0);
   }
   let o;
   try {
-    o = await ht(r);
+    o = await _t(r);
   } finally {
     r.fill(0);
   }
-  return Jt(o.pk_hash, e.expectedWotsPkHash), await dt(
+  return fr(o.pk_hash, e.expectedWotsPkHash), await Tt(
     e.txGraphVersion,
     o.keypair,
     e.txGraphJson
@@ -357,61 +358,61 @@ async function co(e) {
     pkHash: o.pk_hash
   };
 }
-function Jt(e, t) {
-  if (I(e) !== I(t))
+function fr(e, t) {
+  if (D(e) !== D(t))
     throw new Error(
-      `Derived WOTS public-key hash ${I(e)} does not match the vault's on-chain depositorWotsPkHash ${I(t)}. The wallet, the HTLC output index, or the derivation itself is not the one this vault was created with.`
+      `Derived WOTS public-key hash ${D(e)} does not match the vault's on-chain depositorWotsPkHash ${D(t)}. The wallet, the HTLC output index, or the derivation itself is not the one this vault was created with.`
     );
 }
-function I(e) {
+function D(e) {
   return `0x${(e.startsWith("0x") ? e.slice(2) : e).toLowerCase()}`;
 }
-const Zt = 3;
-class er extends Error {
+const yr = 3;
+class br 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";
   }
 }
-function tr(e) {
+function mr(e) {
   let t;
   try {
     t = JSON.parse(e);
   } catch (s) {
     throw new Error("Artifacts file is not valid JSON.", { cause: s });
   }
-  const r = ue(t.vault_id, "vault_id"), o = rr(ue(t.claim_tx, "claim_tx")), n = U(
+  const r = Pe(t.vault_id, "vault_id"), o = Pr(Pe(t.claim_tx, "claim_tx")), n = W(
     t.prover_circuit_version,
     "prover_circuit_version"
-  ), u = t.claimable_event_block_number === void 0 ? 0n : BigInt(
-    U(
+  ), a = t.claimable_event_block_number === void 0 ? 0n : BigInt(
+    W(
       t.claimable_event_block_number,
       "claimable_event_block_number"
     )
   );
   return {
-    vaultCoreVersion: t.vault_core_version === void 0 ? void 0 : U(t.vault_core_version, "vault_core_version"),
+    vaultCoreVersion: t.vault_core_version === void 0 ? void 0 : W(t.vault_core_version, "vault_core_version"),
     vaultId: r,
     claimTxid: o.getId(),
-    peginTxid: Ut(o),
+    peginTxid: sr(o),
     proverCircuitVersion: n,
-    claimableEventBlockNumber: u,
+    claimableEventBlockNumber: a,
     babeSessionChallengerPubkeys: Object.keys(
-      or(t.babe_sessions, "babe_sessions")
+      vr(t.babe_sessions, "babe_sessions")
     )
   };
 }
-async function lo(e) {
-  const t = tr(e.artifactsJson), r = H(e.expectedVaultId), o = H(t.vaultId);
+async function Ho(e) {
+  const t = mr(e.artifactsJson), r = G(e.expectedVaultId), o = G(t.vaultId);
   if (r !== o)
-    throw new er(r, o);
-  Ie({
+    throw new br(r, o);
+  qe({
     peginTxid: t.peginTxid,
     depositorEthAddress: e.depositorEthAddress,
     expectedVaultId: r
   });
-  const n = e.txGraphVersion ?? Zt;
+  const n = e.txGraphVersion ?? yr;
   if (t.vaultCoreVersion !== void 0 && t.vaultCoreVersion !== n)
     throw new Error(
       `Artifacts record vault core version ${t.vaultCoreVersion}, but verification was asked for version ${n}.`
@@ -420,9 +421,9 @@ async function lo(e) {
     throw new Error(
       "Artifacts carry no claimable event block number. They were assembled before the Ethereum withdrawal was initiated; assemble them again."
     );
-  return await pt(n, e.artifactsJson), t;
+  return await $t(n, e.artifactsJson), t;
 }
-function rr(e) {
+function Pr(e) {
   try {
     return B.fromHex(e);
   } catch (t) {
@@ -431,171 +432,387 @@ function rr(e) {
     });
   }
 }
-function ue(e, t) {
+function Pe(e, t) {
   if (typeof e != "string" || e.length === 0)
     throw new Error(`Artifacts file is missing a usable "${t}".`);
   return e;
 }
-function U(e, t) {
+function W(e, t) {
   if (typeof e != "number" || !Number.isSafeInteger(e) || e < 0)
     throw new Error(`Artifacts file is missing a usable "${t}".`);
   return e;
 }
-function or(e, t) {
+function vr(e, t) {
   if (e === void 0) return {};
   if (typeof e != "object" || e === null || Array.isArray(e))
     throw new Error(`Artifacts file is missing a usable "${t}".`);
   return e;
 }
-const nr = 8, sr = 6e3, ar = 10 * 6e4, ir = 10;
-class Ke extends Error {
+const wr = 8, xr = 6e3, Er = 10 * 6e4, kr = 10;
+class We extends Error {
   constructor(t) {
     super(t), this.name = "PeginRegistrationMissingError";
   }
 }
-class Oe extends Error {
+class Ye extends Error {
   constructor(t) {
     super(t), this.name = "PeginRegistrationNotFinalError";
   }
 }
-function ur(e) {
-  return e instanceof Ke || e instanceof Error && e.name === "PeginRegistrationMissingError";
+function _r(e) {
+  return e instanceof We || e instanceof Error && e.name === "PeginRegistrationMissingError";
 }
-function ho(e) {
-  return e instanceof Oe || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
+function Ko(e) {
+  return e instanceof Ye || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
 }
-function ce(e) {
+function ve(e) {
   const { currentBlock: t, createdAtBlock: r } = e, o = t - r + 1n;
   return o < 0n ? 0 : Number(o);
 }
-async function po(e) {
+async function Do(e) {
   const {
     vaultRegistryReader: t,
     getBlockNumber: r,
     vaultIds: o,
-    required: n = nr,
-    pollIntervalMs: u = sr,
-    timeoutMs: s = ar,
+    required: n = wr,
+    pollIntervalMs: a = xr,
+    timeoutMs: s = Er,
     signal: i,
-    onProgress: a
+    onProgress: u
   } = e;
   if (o.length === 0)
     throw new Error(
       "waitForPeginRegistrationDepth requires at least one vault ID"
     );
   const c = Date.now();
-  let h = !1, l = 0, d;
+  let h = !1, l = 0, p;
   for (; ; ) {
     if (i != null && i.aborted)
       throw new Error(
         `Aborted while waiting for peg-in registration depth (${o.length} vault(s))`
       );
     if (Date.now() - c >= s)
-      throw new Oe(
-        `Peg-in registration did not reach ${n} Ethereum confirmations within ${s}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}` : "")
+      throw new Ye(
+        `Peg-in registration did not reach ${n} Ethereum confirmations within ${s}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}` : "")
       );
     try {
-      const p = await r(), g = await Promise.all(
-        o.map((f) => t.getVaultBasicInfo(f))
+      const d = await r(), g = await Promise.all(
+        o.map((y) => t.getVaultBasicInfo(y))
       ), b = g.findIndex(
-        (f) => f.depositor === Pt || f.createdAt === 0n
+        (y) => y.depositor === Rt || y.createdAt === 0n
       );
       if (b !== -1) {
-        if (l += 1, !h && l > ir)
-          throw new Ke(
+        if (l += 1, !h && l > kr)
+          throw new We(
             `Vault ${o[b]} is still not visible on-chain after ${l} reads — the registration does not exist.`
           );
         console.warn(
-          `Peg-in registration for vault ${o[b]} is not visible in chain state at block ${p} — a lagging RPC backend or an Ethereum reorg. Still polling.`
-        ), a == null || a({ confirmations: 0, required: n });
+          `Peg-in registration for vault ${o[b]} is not visible in chain state at block ${d} — a lagging RPC backend or an Ethereum reorg. Still polling.`
+        ), u == null || u({ confirmations: 0, required: n });
       } else {
-        h = !0, l = 0, d = void 0;
-        let f = g[0], v = ce({
-          currentBlock: p,
+        h = !0, l = 0, p = void 0;
+        let y = g[0], m = ve({
+          currentBlock: d,
           createdAtBlock: g[0].createdAt
         });
-        for (const m of g.slice(1)) {
-          const w = ce({
-            currentBlock: p,
-            createdAtBlock: m.createdAt
+        for (const x of g.slice(1)) {
+          const w = ve({
+            currentBlock: d,
+            createdAtBlock: x.createdAt
           });
-          w < v && (v = w, f = m);
+          w < m && (m = w, y = x);
         }
-        if (a == null || a({ confirmations: v, required: n }), v >= n)
-          return { confirmations: v, basicInfo: f };
+        if (u == null || u({ confirmations: m, required: n }), m >= n)
+          return { confirmations: m, basicInfo: y };
       }
-    } catch (p) {
-      if (ur(p))
-        throw p;
+    } catch (d) {
+      if (_r(d))
+        throw d;
       console.warn(
-        `Registration-depth read failed (retrying in ${u}ms): ` + (p instanceof Error ? p.message : String(p))
-      ), d = p;
+        `Registration-depth read failed (retrying in ${a}ms): ` + (d instanceof Error ? d.message : String(d))
+      ), p = d;
     }
-    await new Promise((p, g) => {
+    await new Promise((d, g) => {
       const b = () => {
-        clearTimeout(f), g(
+        clearTimeout(y), g(
           new Error(
             `Aborted while waiting for peg-in registration depth (${o.length} vault(s))`
           )
         );
-      }, f = setTimeout(() => {
-        i == null || i.removeEventListener("abort", b), p();
-      }, u);
+      }, y = setTimeout(() => {
+        i == null || i.removeEventListener("abort", b), d();
+      }, a);
       i == null || i.addEventListener("abort", b, { once: !0 });
     });
   }
 }
-const cr = 1;
-function lr(e, t, r) {
+const Tr = /^(?:[0-9a-f]{2})*$/, $r = /^[0-9a-f]{64}$/, Cr = /^([0-9a-f]{64}):(0|[1-9][0-9]*)$/, Ar = -2147483648, Sr = 2147483647, Y = 4294967295, we = 2, xe = 2;
+class v extends Error {
+  constructor(t) {
+    super(t), this.name = "GraphFingerprintError";
+  }
+}
+function E(e, t, r) {
+  const o = e[t];
+  if (o === void 0)
+    throw new v(`Graph tx ${r} is missing "${t}"`);
+  return o;
+}
+function K(e, t) {
+  if (!Array.isArray(e))
+    throw new v(`Graph tx ${t} is not an array`);
+  return e;
+}
+function A(e, t) {
+  if (e === null || typeof e != "object" || Array.isArray(e))
+    throw new v(`Graph tx ${t} is not an object`);
+  return e;
+}
+function N(e, t, r, o) {
+  if (typeof e != "number" || !Number.isSafeInteger(e) || e < r || e > o)
+    throw new v(
+      `Graph tx ${t} is not an integer in [${r}, ${o}]`
+    );
+  return e;
+}
+function Q(e, t) {
+  if (typeof e != "string" || !Tr.test(e))
+    throw new v(
+      `Graph tx ${t} is not lowercase hex without a prefix`
+    );
+  return I.from(e, "hex");
+}
+function X(e, t) {
+  if (typeof e != "string" || !$r.test(e))
+    throw new v(
+      `Graph ${t} is not 32 bytes of lowercase hex`
+    );
+  return e;
+}
+function Ee(e, t) {
+  const r = A(e, t), o = new B();
+  return o.version = N(
+    E(r, "version", t),
+    `${t}.version`,
+    Ar,
+    Sr
+  ), o.locktime = N(
+    E(r, "lock_time", t),
+    `${t}.lock_time`,
+    0,
+    Y
+  ), K(E(r, "input", t), `${t}.input`).forEach((n, a) => {
+    const s = `${t}.input[${a}]`, i = A(n, s), u = E(i, "previous_output", s), c = typeof u == "string" && Cr.exec(u);
+    if (!c)
+      throw new v(
+        `Graph tx ${s}.previous_output is not "<txid>:<vout>"`
+      );
+    const h = N(Number(c[2]), `${s}.previous_output vout`, 0, Y);
+    o.addInput(
+      I.from(c[1], "hex").reverse(),
+      h,
+      N(E(i, "sequence", s), `${s}.sequence`, 0, Y),
+      Q(E(i, "script_sig", s), `${s}.script_sig`)
+    ), o.ins[a].witness = K(
+      E(i, "witness", s),
+      `${s}.witness`
+    ).map((l, p) => Q(l, `${s}.witness[${p}]`));
+  }), K(E(r, "output", t), `${t}.output`).forEach((n, a) => {
+    const s = `${t}.output[${a}]`, i = A(n, s);
+    o.addOutput(
+      Q(E(i, "script_pubkey", s), `${s}.script_pubkey`),
+      N(E(i, "value", s), `${s}.value`, 0, Number.MAX_SAFE_INTEGER)
+    );
+  }), new Uint8Array(o.toBuffer());
+}
+function H(e, t) {
+  const r = f(e).toLowerCase();
+  let o;
+  try {
+    o = B.fromHex(r);
+  } catch (n) {
+    throw new v(
+      `Presign ${t} is not one transaction: ${n instanceof Error ? n.message : String(n)}`
+    );
+  }
+  if (o.toHex() !== r)
+    throw new v(
+      `Presign ${t} is not a canonical transaction encoding`
+    );
+  return o;
+}
+function Ir(e, t) {
+  const [r, ...o] = e.ins;
+  if (!r || o.length > 0)
+    throw new v(
+      `Presign claim_tx must have exactly one input, got ${e.ins.length}`
+    );
+  const n = I.from(r.hash).reverse().toString("hex");
+  if (n !== t || r.index !== le)
+    throw new v(
+      `Presign claim_tx must spend ${t}:${le}, got ${n}:${r.index}`
+    );
+  if (e.version !== we)
+    throw new v(
+      `Presign claim_tx version must be ${we}, got ${e.version}`
+    );
+  if (r.witness.length > 0)
+    throw new v(
+      `Presign claim_tx input must have an empty witness, got ${r.witness.length} item(s)`
+    );
+  if (e.outs.length !== xe)
+    throw new v(
+      `Presign claim_tx must have exactly ${xe} outputs, got ${e.outs.length}`
+    );
+}
+function Qe(e) {
+  const t = [...e.challengers].sort(
+    (o, n) => o.pubkey < n.pubkey ? -1 : o.pubkey > n.pubkey ? 1 : 0
+  ), r = [e.peginTx, e.claimTx, e.assertTx, e.payoutTx];
+  return t.forEach((o, n) => {
+    const a = X(o.pubkey, "challenger pubkey");
+    if (n > 0 && t[n - 1].pubkey === a)
+      throw new v(`Graph lists challenger ${a} twice`);
+    r.push(ye(a), o.nopayoutTx);
+    for (const s of o.outputLabelHashes)
+      r.push(ye(X(s, "output_label_hashes entry")));
+  }), Kt(Dt(Mt(...r)));
+}
+function Rr(e) {
+  const t = f(e.peginTxid).toLowerCase(), r = H(e.peginTxHex, "pegin_tx");
+  if (r.getId() !== t)
+    throw new v(
+      `Presign pegin_tx hashes to ${r.getId()}, expected ${t}`
+    );
+  const o = H(e.claimTxHex, "claim_tx");
+  Ir(o, t);
+  const n = (a) => new Uint8Array(a.toBuffer());
+  return Qe({
+    peginTx: n(r),
+    claimTx: n(o),
+    assertTx: n(H(e.assertTxHex, "assert_tx")),
+    payoutTx: n(H(e.payoutTxHex, "payout_tx")),
+    challengers: e.challengers.map((a) => ({
+      pubkey: $(a.challenger_pubkey),
+      nopayoutTx: n(H(a.nopayout_tx.tx_hex, "nopayout_tx")),
+      outputLabelHashes: a.output_label_hashes.map(
+        (s) => f(s).toLowerCase()
+      )
+    }))
+  });
+}
+function Br(e) {
+  const t = (o) => Ee(A(E(e, o, "graph"), o).tx, o), r = A(
+    E(e, "challenger_subgraphs", "graph"),
+    "challenger_subgraphs"
+  );
+  return Qe({
+    peginTx: t("pegin_tx"),
+    claimTx: t("claim_tx"),
+    assertTx: t("assert_tx"),
+    payoutTx: t("payout_tx"),
+    challengers: Object.entries(r).map(([o, n]) => {
+      const a = `challenger_subgraphs[${o}]`, s = A(n, a);
+      return {
+        pubkey: o,
+        nopayoutTx: Ee(
+          A(E(s, "nopayout_tx", a), `${a}.nopayout_tx`).tx,
+          `${a}.nopayout_tx`
+        ),
+        outputLabelHashes: K(
+          E(s, "output_label_hashes", a),
+          `${a}.output_label_hashes`
+        ).map(
+          (i, u) => X(i, `${a}.output_label_hashes[${u}]`)
+        )
+      };
+    })
+  });
+}
+function Vr(e) {
+  const t = A(
+    E(e, "challenger_pubkeys", "graph"),
+    "challenger_pubkeys"
+  ), r = /* @__PURE__ */ new Set();
+  for (const o of ["local", "universal"])
+    K(
+      E(t, o, "challenger_pubkeys"),
+      `challenger_pubkeys.${o}`
+    ).forEach((n, a) => {
+      const s = X(n, `challenger_pubkeys.${o}[${a}]`);
+      if (r.has(s))
+        throw new v(
+          `Graph declares challenger ${s} more than once`
+        );
+      r.add(s);
+    });
+  return r;
+}
+function Mo(e, t) {
+  const r = Br(e);
+  if (r !== t)
+    throw new v(
+      `Graph fingerprint ${r} does not match the presign fingerprint ${t}`
+    );
+  const o = Object.keys(
+    A(e.challenger_subgraphs, "challenger_subgraphs")
+  ), n = Vr(e);
+  if (o.length !== n.size || o.some((a) => !n.has(a)))
+    throw new v(
+      `Graph challenger_subgraphs keys ${o.join(", ")} do not match challenger_pubkeys ${[...n].join(", ")}`
+    );
+}
+const Or = 1;
+function Nr(e, t, r) {
   const o = r.map(
-    (l) => P(l).toLowerCase()
+    (l) => f(l).toLowerCase()
   ), n = t.filter((l) => o.includes(l));
   if (n.length > 0)
     throw new Error(
       `Cannot validate challenger set: vault keepers and universal challengers overlap (${n.join(", ")})`
     );
-  const u = [...t, ...o], s = e.map(
-    (l) => P(l.challenger_pubkey).toLowerCase()
+  const a = [...t, ...o], s = e.map(
+    (l) => f(l.challenger_pubkey).toLowerCase()
   ), i = new Set(s);
   if (i.size !== s.length)
     throw new Error(
       "Depositor graph contains duplicate challenger entries in challenger_presign_data"
     );
-  const a = new Set(u), c = u.filter((l) => !i.has(l)), h = s.filter((l) => !a.has(l));
+  const u = new Set(a), c = a.filter((l) => !i.has(l)), h = s.filter((l) => !u.has(l));
   if (c.length > 0 || h.length > 0)
     throw new Error(
       "Depositor graph challenger set does not match expected (local ∪ universal)" + (c.length > 0 ? ` (missing: ${c.join(", ")})` : "") + (h.length > 0 ? ` (unexpected: ${h.join(", ")})` : "")
     );
 }
-function hr(e, t) {
+function Hr(e, t) {
   const r = e.ins[t];
-  return ke(new Uint8Array(r.hash).slice().reverse());
+  return Ke(new Uint8Array(r.hash).slice().reverse());
 }
-function L(e, t, r, o, n) {
-  const u = e.ins[t];
-  if (u.index !== 0)
+function J(e, t, r, o, n) {
+  const a = e.ins[t];
+  if (a.index !== 0)
     throw new Error(
-      `NoPayout (challenger ${n}) input ${t} expected to spend ${o} vout 0, got vout ${u.index}`
+      `NoPayout (challenger ${n}) input ${t} expected to spend ${o} vout 0, got vout ${a.index}`
     );
-  const s = r.getId(), i = hr(e, t);
+  const s = r.getId(), i = Hr(e, t);
   if (i !== s)
     throw new Error(
       `NoPayout (challenger ${n}) input ${t} does not reference ${o} (expected txid ${s}, got ${i})`
     );
 }
-async function dr(e, t, r) {
-  const o = [], n = [], u = [], s = Ce({
+async function Kr(e, t, r) {
+  const o = [], n = [], a = [], s = Me({
     claimerBtcPubkey: r.depositorBtcPubkey,
     depositorBtcPubkey: r.depositorBtcPubkey,
     vaultProviderBtcPubkey: r.vaultProviderBtcPubkey,
     vaultKeeperBtcPubkeys: r.vaultKeeperBtcPubkeys
   });
-  lr(
+  Nr(
     e.challenger_presign_data,
     s,
     r.universalChallengerBtcPubkeys
   );
-  const i = await ft({
+  const i = await At({
     vaultCoreVersion: r.vaultCoreVersion,
     vkClaimerPayoutScriptPubKeys: r.vkClaimerPayoutScriptPubKeys,
     vpCommissionScriptPubKey: r.vpCommissionScriptPubKey,
@@ -611,79 +828,79 @@ async function dr(e, t, r) {
     network: r.network,
     claimerBtcPubkey: r.depositorBtcPubkey,
     registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
-    commissionBps: cr,
+    commissionBps: Or,
     protocolFeeRate: r.protocolFeeRate,
     councilMembers: r.councilMembers,
     councilQuorum: r.councilQuorum
   });
   o.push(i.psbtHex), n.push(
-    V(
+    M(
       t,
-      ne
+      ge
     )
   );
-  const a = P(r.depositorBtcPubkey), c = B.fromHex(
-    P(e.assert_tx.tx_hex)
+  const u = f(r.depositorBtcPubkey), c = B.fromHex(
+    f(e.assert_tx.tx_hex)
   );
   for (const h of e.challenger_presign_data) {
-    const l = P(h.challenger_pubkey), d = o.length, p = await pr({
+    const l = f(h.challenger_pubkey), p = o.length, d = await Dr({
       challenger: h,
       challengerPubkey: l,
-      claimerPubkey: a,
+      claimerPubkey: u,
       localChallengers: s,
       assertTxParsed: c,
       ctx: r
     });
-    o.push(p), n.push(
-      V(
+    o.push(d), n.push(
+      M(
         t,
-        ne
+        ge
       )
-    ), u.push({
+    ), a.push({
       challengerPubkey: l,
-      noPayoutIdx: d
+      noPayoutIdx: p
     });
   }
-  return { psbtHexes: o, signOptions: n, challengerEntries: u };
+  return { psbtHexes: o, signOptions: n, challengerEntries: a };
 }
-async function pr(e) {
+async function Dr(e) {
   const {
     challenger: t,
     challengerPubkey: r,
     claimerPubkey: o,
     localChallengers: n,
-    assertTxParsed: u,
+    assertTxParsed: a,
     ctx: s
   } = e;
-  kt(
+  Ft(
     t.nopayout_tx.tx_hex,
     r,
     s.network
   );
   const i = B.fromHex(
-    P(t.nopayout_tx.tx_hex)
-  ), a = B.fromHex(
-    P(t.challenge_assert_x_tx.tx_hex)
+    f(t.nopayout_tx.tx_hex)
+  ), u = B.fromHex(
+    f(t.challenge_assert_x_tx.tx_hex)
   ), c = B.fromHex(
-    P(t.challenge_assert_y_tx.tx_hex)
+    f(t.challenge_assert_y_tx.tx_hex)
   );
   if (i.ins.length !== 3)
     throw new Error(
       `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${i.ins.length}`
     );
-  L(
+  J(
     i,
     0,
-    u,
+    a,
     "Assert",
     r
-  ), L(
+  ), J(
     i,
     1,
-    a,
+    u,
     "ChallengeAssertX",
     r
-  ), L(
+  ), J(
     i,
     2,
     c,
@@ -691,14 +908,14 @@ async function pr(e) {
     r
   );
   const h = [
-    u.outs[0],
     a.outs[0],
+    u.outs[0],
     c.outs[0]
   ].map((l) => ({
-    script_pubkey: ke(new Uint8Array(l.script)),
+    script_pubkey: Ke(new Uint8Array(l.script)),
     value: l.value
   }));
-  return Tt({
+  return Ut({
     noPayoutTxHex: t.nopayout_tx.tx_hex,
     challengerPubkey: r,
     prevouts: h,
@@ -713,31 +930,31 @@ async function pr(e) {
     }
   });
 }
-function gr(e, t, r) {
-  K(e[0]);
-  const n = O(
+function Mr(e, t, r) {
+  F(e[0]);
+  const n = U(
     e[0].returnedPsbtHex,
     r
   );
-  N({
+  L({
     requestedPsbtHex: e[0].requestedPsbtHex,
     signatureHex: n,
     signerXOnlyPubkeyHex: r,
     inputIndex: 0
   });
-  const u = {};
+  const a = {};
   for (const s of t) {
-    K(e[s.noPayoutIdx]);
-    const i = O(
+    F(e[s.noPayoutIdx]);
+    const i = U(
       e[s.noPayoutIdx].returnedPsbtHex,
       r
     );
-    N({
+    L({
       requestedPsbtHex: e[s.noPayoutIdx].requestedPsbtHex,
       signatureHex: i,
       signerXOnlyPubkeyHex: r,
       inputIndex: 0
-    }), u[s.challengerPubkey] = {
+    }), a[s.challengerPubkey] = {
       nopayout_signature: i
     };
   }
@@ -745,39 +962,39 @@ function gr(e, t, r) {
     payout_signatures: {
       payout_signature: n
     },
-    per_challenger: u
+    per_challenger: a
   };
 }
-async function fr(e) {
-  const { depositorGraph: t, btcWallet: r, signingContext: o } = e, n = await r.getPublicKeyHex(), { depositorPubkey: u } = We(
+async function Fr(e) {
+  const { depositorGraph: t, btcWallet: r, signingContext: o } = e, n = await r.getPublicKeyHex(), { depositorPubkey: a } = ct(
     n,
-    P(o.depositorBtcPubkey)
-  ), { psbtHexes: s, signOptions: i, challengerEntries: a } = await dr(
+    f(o.depositorBtcPubkey)
+  ), { psbtHexes: s, signOptions: i, challengerEntries: u } = await Kr(
     t,
     n,
     o
-  ), c = await Te(
+  ), c = await De(
     r,
     s,
     i
-  ), h = s.map((l, d) => ({
+  ), h = s.map((l, p) => ({
     requestedPsbtHex: l,
-    returnedPsbtHex: c[d]
+    returnedPsbtHex: c[p]
   }));
-  return gr(
+  return Mr(
     h,
-    a,
-    u
+    u,
+    a
   );
 }
-const vr = 1e4;
-async function Ne(e) {
+const Ur = 1e4;
+async function Je(e) {
   const {
     statusReader: t,
     peginTxid: r,
     targetStatuses: o,
     timeoutMs: n,
-    pollIntervalMs: u = vr,
+    pollIntervalMs: a = Ur,
     signal: s
   } = e, i = Date.now();
   for (; ; ) {
@@ -790,26 +1007,26 @@ async function Ne(e) {
         `Polling timeout after ${n}ms for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
       );
     try {
-      const a = await t.getPeginStatus(
+      const u = await t.getPeginStatus(
         { pegin_txid: r },
         s
       );
-      if (a.pegin_txid.toLowerCase() !== r.toLowerCase())
+      if (u.pegin_txid.toLowerCase() !== r.toLowerCase())
         throw new Error(
-          `getPeginStatus returned status for pegin ${a.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
+          `getPeginStatus returned status for pegin ${u.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
         );
-      const c = a.status;
-      if (o.has(c) || c === _.ACTIVATED)
+      const c = u.status;
+      if (o.has(c) || c === R.ACTIVATED)
         return c;
-      if (c === _.EXPIRED || wt.has(c))
+      if (c === R.EXPIRED || Ot.has(c))
         throw new Error(
           `Pegin ${r.slice(0, 8)}… reached terminal status "${c}" while waiting for ${[...o].join(", ")}`
         );
-    } catch (a) {
-      if (!(a instanceof Et && a.code === xt.PEGIN_NOT_FOUND))
-        throw a;
+    } catch (u) {
+      if (!(u instanceof Nt && u.code === Ht.PEGIN_NOT_FOUND))
+        throw u;
     }
-    await new Promise((a, c) => {
+    await new Promise((u, c) => {
       const h = () => {
         clearTimeout(l), c(
           new Error(
@@ -817,35 +1034,35 @@ async function Ne(e) {
           )
         );
       }, l = setTimeout(() => {
-        s == null || s.removeEventListener("abort", h), a();
-      }, u);
+        s == null || s.removeEventListener("abort", h), u();
+      }, a);
       s == null || s.addEventListener("abort", h, { once: !0 });
     });
   }
 }
-const br = 1200 * 1e3, He = /* @__PURE__ */ new Set([
-  _.PENDING_ACKS,
-  _.PENDING_ACTIVATION,
-  _.ACTIVATED_PENDING_BROADCAST,
-  _.ACTIVATED
-]), Pr = /* @__PURE__ */ new Set([
-  _.PENDING_DEPOSITOR_SIGNATURES,
-  ...He
+const Lr = 1200 * 1e3, Ze = /* @__PURE__ */ new Set([
+  R.PENDING_ACKS,
+  R.PENDING_ACTIVATION,
+  R.ACTIVATED_PENDING_BROADCAST,
+  R.ACTIVATED
+]), Gr = /* @__PURE__ */ new Set([
+  R.PENDING_DEPOSITOR_SIGNATURES,
+  ...Ze
 ]);
-function yr(e) {
+function Xr(e) {
   return e.map((t) => ({
-    claimerPubkeyXOnly: D(t.claimer_pubkey),
+    claimerPubkeyXOnly: j(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
     assertTxHex: t.assert_tx.tx_hex
   }));
 }
-function C(e) {
-  return D(e).toLowerCase();
+function S(e) {
+  return j(e).toLowerCase();
 }
-function mr(e, t) {
-  const r = (a, c, h) => {
+function jr(e, t) {
+  const r = (u, c, h) => {
     throw new Error(
-      `Deposit terms ${a} (${String(c)}) does not match the vault's version-locked signing context (${String(h)}); refusing to sign payouts against terms that describe a different graph.`
+      `Deposit terms ${u} (${String(c)}) does not match the vault's version-locked signing context (${String(h)}); refusing to sign payouts against terms that describe a different graph.`
     );
   }, o = [
     ["protocolFeeRate", e.protocolFeeRate, t.protocolFeeRate],
@@ -853,17 +1070,17 @@ function mr(e, t) {
     ["timelockPegin", e.timelockPegin, t.timelockPegin],
     ["timelockAssert", e.timelockAssert, t.timelockAssert]
   ];
-  for (const [a, c, h] of o)
-    c !== h && r(a, c, h);
-  const n = (a) => a.map(C).sort(), u = (a, c) => {
-    const h = n(a), l = n(c);
-    return h.length === l.length && h.every((d, p) => d === l[p]);
+  for (const [u, c, h] of o)
+    c !== h && r(u, c, h);
+  const n = (u) => u.map(S).sort(), a = (u, c) => {
+    const h = n(u), l = n(c);
+    return h.length === l.length && h.every((p, d) => p === l[d]);
   };
-  u(e.vaultKeeperBtcPubkeys, t.vaultKeeperBtcPubkeys) || r(
+  a(e.vaultKeeperBtcPubkeys, t.vaultKeeperBtcPubkeys) || r(
     "vaultKeeperBtcPubkeys",
     e.vaultKeeperBtcPubkeys.join(","),
     t.vaultKeeperBtcPubkeys.join(",")
-  ), u(
+  ), a(
     e.universalChallengerBtcPubkeys,
     t.universalChallengerBtcPubkeys
   ) || r(
@@ -871,8 +1088,8 @@ function mr(e, t) {
     e.universalChallengerBtcPubkeys.join(","),
     t.universalChallengerBtcPubkeys.join(",")
   );
-  const s = C(t.vaultProviderBtcPubkey), i = e.vaults.map(
-    (a) => C(a.vaultProviderBtcPubkey)
+  const s = S(t.vaultProviderBtcPubkey), i = e.vaults.map(
+    (u) => S(u.vaultProviderBtcPubkey)
   );
   i.includes(s) || r(
     "vaults[].vaultProviderBtcPubkey",
@@ -880,12 +1097,12 @@ function mr(e, t) {
     t.vaultProviderBtcPubkey
   );
 }
-function wr(e, t, r, o) {
-  const n = C(o), u = [
-    C(t),
-    ...r.map(C)
-  ], s = new Set(u);
-  if (s.size !== u.length)
+function qr(e, t, r, o) {
+  const n = S(o), a = [
+    S(t),
+    ...r.map(S)
+  ], s = new Set(a);
+  if (s.size !== a.length)
     throw new Error(
       "Cannot validate claimer set: signing context contains duplicate vault provider or vault keeper key"
     );
@@ -894,17 +1111,17 @@ function wr(e, t, r, o) {
       "Cannot validate claimer set: depositor key overlaps with vault provider or vault keeper set"
     );
   const i = e.map(
-    (d) => C(d.claimer_pubkey)
+    (p) => S(p.claimer_pubkey)
   );
   if (new Set(i).size !== i.length)
     throw new Error("Presign response contains duplicate claimer entries");
-  const a = i.filter((d) => d !== n), c = new Set(a), h = u.filter((d) => !c.has(d)), l = a.filter((d) => !s.has(d));
+  const u = i.filter((p) => p !== n), c = new Set(u), h = a.filter((p) => !c.has(p)), l = u.filter((p) => !s.has(p));
   if (h.length > 0 || l.length > 0)
     throw new Error(
       "Presign response claimer set does not match expected (vault provider ∪ vault keepers)" + (h.length > 0 ? ` (missing: ${h.join(", ")})` : "") + (l.length > 0 ? ` (unexpected: ${l.join(", ")})` : "")
     );
 }
-function le(e, t) {
+function ke(e, t) {
   return {
     vaultCoreVersion: t.vaultCoreVersion,
     payoutTxHex: e.payoutTxHex,
@@ -926,56 +1143,57 @@ function le(e, t) {
     vpCommissionScriptPubKey: t.vpCommissionScriptPubKey
   };
 }
-async function Er(e, t, r, o) {
-  const n = new Je({
+async function zr(e, t, r, o) {
+  const n = new pt({
     network: t.network,
     btcWallet: e
-  }), u = r.length;
-  o == null || o(0, u);
+  }), a = r.length;
+  o == null || o(0, a);
   let s;
   if (n.supportsBatchSigning())
     s = (await n.signPayoutTransactionsBatch(
-      r.map((c) => le(c, t))
+      r.map((c) => ke(c, t))
     )).map((c) => c.payoutSignature);
   else {
     s = [];
-    for (let a = 0; a < r.length; a++) {
-      o == null || o(a, u);
+    for (let u = 0; u < r.length; u++) {
+      o == null || o(u, a);
       const c = await n.signPayoutTransaction(
-        le(r[a], t)
+        ke(r[u], t)
       );
       s.push(c.signature);
     }
   }
   const i = {};
-  for (let a = 0; a < r.length; a++)
-    i[r[a].claimerPubkeyXOnly] = {
-      payout_signature: s[a]
+  for (let u = 0; u < r.length; u++)
+    i[r[u].claimerPubkeyXOnly] = {
+      payout_signature: s[u]
     };
-  return o == null || o(u, u), i;
+  return o == null || o(a, a), i;
 }
-async function go(e) {
+async function Fo(e) {
   const {
     statusReader: t,
     presignClient: r,
     btcWallet: o,
     peginTxid: n,
-    depositorPk: u,
+    depositorPk: a,
     signingContext: s,
     depositTerms: i,
-    timeoutMs: a = br,
+    timeoutMs: u = Lr,
     signal: c,
-    onProgress: h
-  } = e, l = await Ne({
+    onProgress: h,
+    recordGraphFingerprint: l
+  } = e, p = await Je({
     statusReader: t,
     peginTxid: n,
-    targetStatuses: Pr,
-    timeoutMs: a,
+    targetStatuses: Gr,
+    timeoutMs: u,
     signal: c
   });
-  if (He.has(l))
+  if (Ze.has(p))
     return;
-  if (c == null || c.throwIfAborted(), i !== void 0 && mr(i, s), Qe(o)) {
+  if (c == null || c.throwIfAborted(), i !== void 0 && jr(i, s), ht(o)) {
     if (!i)
       throw new Error(
         "runDepositorPresignFlow: this wallet requires approved deposit terms but none were provided. Fresh deposits must pass PreparePeginResult.depositTerms; resume flows must rebuild them from on-chain state (the vault app's rebuildDepositTerms)."
@@ -985,34 +1203,41 @@ async function go(e) {
   const d = await r.requestDepositorPresignTransactions(
     {
       pegin_txid: n,
-      depositor_pk: u
+      depositor_pk: a
     },
     c
   );
   c == null || c.throwIfAborted();
-  const p = C(u);
-  wr(
+  const g = Rr({
+    peginTxid: n,
+    peginTxHex: s.peginTxHex,
+    claimTxHex: d.depositor_graph.claim_tx.tx_hex,
+    assertTxHex: d.depositor_graph.assert_tx.tx_hex,
+    payoutTxHex: d.depositor_graph.payout_tx.tx_hex,
+    challengers: d.depositor_graph.challenger_presign_data
+  }), b = S(a);
+  qr(
     d.txs,
     s.vaultProviderBtcPubkey,
     s.vaultKeeperBtcPubkeys,
-    u
+    a
   );
-  const g = d.txs.filter(
-    (w) => C(w.claimer_pubkey) !== p
-  ), b = yr(g), f = await Er(
+  const y = d.txs.filter(
+    (_) => S(_.claimer_pubkey) !== b
+  ), m = Xr(y), x = await zr(
     o,
     s,
-    b,
+    m,
     h
   );
   c == null || c.throwIfAborted();
-  const v = await fr({
+  const w = await Fr({
     depositorGraph: d.depositor_graph,
     btcWallet: o,
     signingContext: {
       vaultCoreVersion: s.vaultCoreVersion,
       peginTxHex: s.peginTxHex,
-      depositorBtcPubkey: u,
+      depositorBtcPubkey: a,
       vaultProviderBtcPubkey: s.vaultProviderBtcPubkey,
       vaultKeeperBtcPubkeys: s.vaultKeeperBtcPubkeys,
       universalChallengerBtcPubkeys: s.universalChallengerBtcPubkeys,
@@ -1027,104 +1252,104 @@ async function go(e) {
       vpCommissionScriptPubKey: s.vpCommissionScriptPubKey
     }
   });
-  c == null || c.throwIfAborted();
-  const m = { ...f };
-  m[P(u)] = v.payout_signatures, await r.submitDepositorPresignatures(
+  c == null || c.throwIfAborted(), await l(g), c == null || c.throwIfAborted();
+  const k = { ...x };
+  k[f(a)] = w.payout_signatures, await r.submitDepositorPresignatures(
     {
       pegin_txid: n,
-      depositor_pk: u,
-      signatures: m,
-      depositor_claimer_presignatures: v
+      depositor_pk: a,
+      signatures: k,
+      depositor_claimer_presignatures: w
     },
     c
   );
 }
-const xr = 300 * 1e3, kr = /* @__PURE__ */ new Set([
-  _.PENDING_DEPOSITOR_WOTS_PK,
-  ..._e
+const Wr = 300 * 1e3, Yr = /* @__PURE__ */ new Set([
+  R.PENDING_DEPOSITOR_WOTS_PK,
+  ...Ue
 ]);
-async function fo(e) {
+async function Uo(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
     peginTxid: o,
     depositorPk: n,
-    wotsPublicKeys: u,
-    timeoutMs: s = xr,
+    wotsPublicKeys: a,
+    timeoutMs: s = Wr,
     signal: i
   } = e;
   i == null || i.throwIfAborted();
-  const a = await Ne({
+  const u = await Je({
     statusReader: t,
     peginTxid: o,
-    targetStatuses: kr,
+    targetStatuses: Yr,
     timeoutMs: s,
     signal: i
   });
-  _e.has(a) || (i == null || i.throwIfAborted(), await r.submitDepositorWotsKey(
+  Ue.has(u) || (i == null || i.throwIfAborted(), await r.submitDepositorWotsKey(
     {
       pegin_txid: o,
       depositor_pk: n,
-      wots_public_keys: u
+      wots_public_keys: a
     },
     i
   ));
 }
-function X(e) {
+function Z(e) {
   return e.registration || e.operation;
 }
-function Tr(e, t, r) {
-  const o = A(e);
+function Qr(e, t, r) {
+  const o = $(e);
   return {
-    registration: o === A(t),
-    operation: o === A(r)
+    registration: o === $(t),
+    operation: o === $(r)
   };
 }
-function he(e, t, r) {
-  const o = G(e);
+function _e(e, t, r) {
+  const o = ee(e);
   return {
-    registration: de(o, G(t)),
-    operation: de(o, G(r))
+    registration: Te(o, ee(t)),
+    operation: Te(o, ee(r))
   };
 }
-function G(e) {
-  return e.map(A).sort();
+function ee(e) {
+  return e.map($).sort();
 }
-function de(e, t) {
+function Te(e, t) {
   return e.length === t.length && e.every((r, o) => r === t[o]);
 }
-async function vo(e) {
+async function Lo(e) {
   const {
     vaultProviderEthAddress: t,
     hintBtcPubkey: r,
     registrationBtcPubkey: o,
     readCurrentOperationBtcPubkey: n,
-    context: u
+    context: a
   } = e;
   if (!r) return;
-  const s = A(r);
-  if (s === A(o)) return;
-  const i = A(
+  const s = $(r);
+  if (s === $(o)) return;
+  const i = $(
     await n()
   );
   if (s !== i)
     throw new Error(
-      `Vault provider BTC pubkey mismatch for ${t}: indexer hint matches neither the registration key nor the current operation key on-chain.${u ? ` ${u}` : ""}`
+      `Vault provider BTC pubkey mismatch for ${t}: indexer hint matches neither the registration key nor the current operation key on-chain.${a ? ` ${a}` : ""}`
     );
 }
-function q(e, t, r) {
-  const o = `${e} operation key (admin=${t.ethAddress})`, n = se(
+function te(e, t, r) {
+  const o = `${e} operation key (admin=${t.ethAddress})`, n = fe(
     t.btcPubKey,
     `${e} roster key (admin=${t.ethAddress})`
-  ), u = se(r, o);
+  ), a = fe(r, o);
   return {
     adminAddress: t.ethAddress,
     genesisBtcPubkey: n,
-    operationBtcPubkey: u,
-    rotated: u !== n
+    operationBtcPubkey: a,
+    rotated: a !== n
   };
 }
-function Cr(e) {
+function Jr(e) {
   const t = /* @__PURE__ */ new Map();
   for (const r of e) {
     const o = t.get(r.operationBtcPubkey);
@@ -1135,12 +1360,12 @@ function Cr(e) {
     t.set(r.operationBtcPubkey, r.adminAddress);
   }
 }
-function De(e, t, r) {
+function et(e, t, r) {
   if (t.vaultKeepers.length !== e.vaultKeepers.length || t.universalChallengers.length !== e.universalChallengers.length)
     throw new Error(
       `Operation-key resolution returned ${t.vaultKeepers.length} keeper and ${t.universalChallengers.length} challenger keys for a roster of ${e.vaultKeepers.length} keepers and ${e.universalChallengers.length} challengers`
     );
-  const o = q(
+  const o = te(
     "vault provider",
     {
       ethAddress: e.vaultProviderEthAddress,
@@ -1148,212 +1373,212 @@ function De(e, t, r) {
     },
     t.vaultProvider
   ), n = e.vaultKeepers.map(
-    (s, i) => q("vault keeper", s, t.vaultKeepers[i])
-  ), u = e.universalChallengers.map(
-    (s, i) => q("universal challenger", s, t.universalChallengers[i])
+    (s, i) => te("vault keeper", s, t.vaultKeepers[i])
+  ), a = e.universalChallengers.map(
+    (s, i) => te("universal challenger", s, t.universalChallengers[i])
   );
-  return Cr([
+  return Jr([
     o,
     ...n,
-    ...u
+    ...a
   ]), {
     vaultProvider: o,
     vaultKeepers: n,
-    universalChallengers: u,
+    universalChallengers: a,
     // Derived from the pairs, never the reverse — see ParticipantKeySet.
     vaultKeeperOperationKeysSorted: n.map((s) => s.operationBtcPubkey).sort(),
-    universalChallengerOperationKeysSorted: u.map((s) => s.operationBtcPubkey).sort(),
+    universalChallengerOperationKeysSorted: a.map((s) => s.operationBtcPubkey).sort(),
     resolvedAt: r,
     query: e
   };
 }
-async function Ar(e) {
+async function Zr(e) {
   const t = await e.operationKeyReader.getCurrentOperationKeys(
     e.query,
     e.blockNumber
   );
-  return De(e.query, t, { mode: "current" });
+  return et(e.query, t, { mode: "current" });
 }
-async function _r(e) {
+async function eo(e) {
   const t = await e.operationKeyReader.getOperationKeysAtEpochs(
     e.query,
     e.epochs
   );
-  return De(e.query, t, {
+  return et(e.query, t, {
     mode: "epochs",
     epochs: e.epochs
   });
 }
-class j extends Error {
+class oe extends Error {
   constructor(t) {
     super(t), this.name = "ApplicationEntryPointMismatchError";
   }
 }
-function bo(e) {
-  return e instanceof j || e instanceof Error && e.name === "ApplicationEntryPointMismatchError";
+function Go(e) {
+  return e instanceof oe || e instanceof Error && e.name === "ApplicationEntryPointMismatchError";
 }
-const pe = (e) => e.map(A).sort();
-async function Po(e) {
+const $e = (e) => e.map($).sort();
+async function Xo(e) {
   const {
     vaultRegistryReader: t,
     vaultKeeperReader: r,
     universalChallengerReader: o,
     vaultProviderEthAddress: n,
-    applicationEntryPoint: u,
+    applicationEntryPoint: a,
     expectedVaultProviderBtcPubkey: s,
     expectedVaultKeeperBtcPubkeys: i,
-    expectedUniversalChallengerBtcPubkeys: a,
+    expectedUniversalChallengerBtcPubkeys: u,
     operationKeyReader: c,
     onIndexerServingOperationKeys: h,
     onIndexerHintsInconsistent: l,
-    blockNumber: d
+    blockNumber: p
   } = e, [
-    p,
+    d,
     g,
     b,
-    f
+    y
   ] = await Promise.all([
     t.getVaultProviderApplication(
       n,
-      d
+      p
     ),
     t.getVaultProviderGenesisBtcPubKey(
       n,
-      d
+      p
     ),
-    o.getLatestUniversalChallengersVersion(d),
-    o.getCurrentUcKeyEpoch(d)
+    o.getLatestUniversalChallengersVersion(p),
+    o.getCurrentUcKeyEpoch(p)
   ]);
-  if (!yt(u, { strict: !1 }))
-    throw new j(
-      `The application entry point this deposit was prepared for is not a valid address: ${u}`
+  if (!Bt(a, { strict: !1 }))
+    throw new oe(
+      `The application entry point this deposit was prepared for is not a valid address: ${a}`
     );
-  if (!mt(p, u))
-    throw new j(
-      `Vault provider ${n} is registered to application ${p}, but this deposit was prepared for ${u}. 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.`
+  if (!Vt(d, a))
+    throw new oe(
+      `Vault provider ${n} is registered to application ${d}, but this deposit was prepared for ${a}. 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 [v, m] = await Promise.all(
+  const [m, x] = await Promise.all(
     [
       r.getCurrentVaultKeepersVersion(
-        p,
-        d
+        d,
+        p
       ),
       r.getCurrentAppKeeperKeyEpoch(
-        p,
-        d
+        d,
+        p
       )
     ]
-  ), [w, E] = await Promise.all([
+  ), [w, k] = await Promise.all([
     r.getVaultKeepersByVersion(
-      p,
-      v,
-      d
+      d,
+      m,
+      p
     ),
     o.getUniversalChallengersByVersion(
       b,
-      d
+      p
     )
-  ]), x = {
-    vaultProvider: A(g),
-    vaultKeepers: pe(w.map((k) => k.btcPubKey)),
-    universalChallengers: pe(E.map((k) => k.btcPubKey))
-  }, T = await Ar({
+  ]), _ = {
+    vaultProvider: $(g),
+    vaultKeepers: $e(w.map((T) => T.btcPubKey)),
+    universalChallengers: $e(k.map((T) => T.btcPubKey))
+  }, C = await Zr({
     operationKeyReader: c,
     query: {
       vaultProviderEthAddress: n,
       vaultProviderGenesisBtcPubkey: `0x${g}`,
-      applicationEntryPoint: p,
+      applicationEntryPoint: d,
       vaultKeepers: w,
-      universalChallengers: E
+      universalChallengers: k
     },
-    blockNumber: d
-  }), y = {
-    vaultProvider: T.vaultProvider.operationBtcPubkey,
-    vaultKeepers: [...T.vaultKeeperOperationKeysSorted],
+    blockNumber: p
+  }), P = {
+    vaultProvider: C.vaultProvider.operationBtcPubkey,
+    vaultKeepers: [...C.vaultKeeperOperationKeysSorted],
     universalChallengers: [
-      ...T.universalChallengerOperationKeysSorted
+      ...C.universalChallengerOperationKeysSorted
     ]
-  }, Y = Tr(
+  }, se = Qr(
     s,
-    x.vaultProvider,
-    y.vaultProvider
-  ), Q = he(
+    _.vaultProvider,
+    P.vaultProvider
+  ), ae = _e(
     i,
-    x.vaultKeepers,
-    y.vaultKeepers
-  ), J = he(
-    a,
-    x.universalChallengers,
-    y.universalChallengers
+    _.vaultKeepers,
+    P.vaultKeepers
+  ), ie = _e(
+    u,
+    _.universalChallengers,
+    P.universalChallengers
   );
-  if (!X(Y))
+  if (!Z(se))
     throw new Error(
       `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${n}. Refresh and try again.`
     );
-  if (!X(Q))
+  if (!Z(ae))
     throw new Error(
-      `Vault keeper BTC pubkeys (v${v}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
+      `Vault keeper BTC pubkeys (v${m}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
     );
-  if (!X(J))
+  if (!Z(ie))
     throw new Error(
       `Universal challenger BTC pubkeys (v${b}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
     );
-  const Z = [Y, Q, J], Ge = Z.some((k) => k.registration && !k.operation), ee = Z.some((k) => k.operation && !k.registration);
-  if (Ge && ee) {
-    const k = `Indexer participant hints are internally inconsistent for vault provider ${n}: some roles match the registration keys while others match the rotated operation keys.`;
-    throw l == null || l(k), new Error(`${k} Refresh and try again.`);
+  const ue = [se, ae, ie], st = ue.some((T) => T.registration && !T.operation), ce = ue.some((T) => T.operation && !T.registration);
+  if (st && ce) {
+    const T = `Indexer participant hints are internally inconsistent for vault provider ${n}: some roles match the registration keys while others match the rotated operation keys.`;
+    throw l == null || l(T), new Error(`${T} Refresh and try again.`);
   }
-  return ee && (h == null || h(
+  return ce && (h == null || h(
     `Indexer is serving rotated operation keys for vault provider ${n}`
   )), {
-    vaultProviderBtcPubkeyXOnly: y.vaultProvider,
-    vaultKeeperBtcPubkeysSorted: y.vaultKeepers,
-    universalChallengerBtcPubkeysSorted: y.universalChallengers,
-    expectedAppVaultKeepersVersion: v,
+    vaultProviderBtcPubkeyXOnly: P.vaultProvider,
+    vaultKeeperBtcPubkeysSorted: P.vaultKeepers,
+    universalChallengerBtcPubkeysSorted: P.universalChallengers,
+    expectedAppVaultKeepersVersion: m,
     expectedUniversalChallengersVersion: b,
-    appKeeperKeyEpoch: m,
-    ucKeyEpoch: f,
-    registrationKeys: x,
-    participantKeys: T
+    appKeeperKeyEpoch: x,
+    ucKeyEpoch: y,
+    registrationKeys: _,
+    participantKeys: C
   };
 }
-function Sr(e) {
+function to(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function yo(e) {
+function jo(e) {
   const {
     amountSats: t,
     minDeposit: r,
     maxDeposit: o,
     btcBalance: n,
-    estimatedFeeSats: u,
+    estimatedFeeSats: a,
     depositorClaimValue: s
   } = e;
-  return !(t <= 0n || t < r || o && o > 0n && t > o || u == null || s == null || t + u + s > n);
+  return !(t <= 0n || t < r || o && o > 0n && t > o || a == null || s == null || t + a + s > n);
 }
-function mo(e, t, r) {
+function qo(e, t, r) {
   return e <= 0n ? {
     valid: !1,
     error: "Deposit amount must be greater than zero"
   } : e < t ? {
     valid: !1,
-    error: `Minimum deposit is ${S(t)} BTC`
+    error: `Minimum deposit is ${V(t)} BTC`
   } : r && r > 0n && e > r ? {
     valid: !1,
-    error: `Maximum deposit is ${S(r)} BTC`
+    error: `Maximum deposit is ${V(r)} BTC`
   } : { valid: !0 };
 }
-function wo(e) {
+function zo(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 (${S(r)} BTC)`
+    error: `Vault size exceeds remaining capacity (${V(r)} BTC)`
   } : { valid: !0 };
 }
-function Eo(e, t) {
+function Wo(e, t) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -1369,7 +1594,7 @@ function Eo(e, t) {
     error: "Invalid vault provider selected"
   } : { valid: !0 };
 }
-function Br(e, t, r) {
+function ro(e, t, r) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -1385,82 +1610,82 @@ function Br(e, t, r) {
     if (t && n < t)
       return {
         valid: !1,
-        error: `Vault ${o + 1} amount ${S(n)} BTC is below minimum deposit ${S(t)} BTC`
+        error: `Vault ${o + 1} amount ${V(n)} BTC is below minimum deposit ${V(t)} BTC`
       };
     if (r && n > r)
       return {
         valid: !1,
-        error: `Vault ${o + 1} amount ${S(n)} BTC exceeds maximum deposit ${S(r)} BTC`
+        error: `Vault ${o + 1} amount ${V(n)} BTC exceeds maximum deposit ${V(r)} BTC`
       };
   }
   return { valid: !0 };
 }
-function $r(e) {
-  const t = P(e);
-  return Sr(t) ? { valid: !0 } : {
+function oo(e) {
+  const t = f(e);
+  return to(t) ? { valid: !0 } : {
     valid: !1,
     error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
   };
 }
-function Rr(e) {
+function no(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 Ir(e) {
+function so(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 Vr(e) {
+function ao(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function xo(e) {
+function Yo(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
     vaultProviderBtcPubkey: o,
     vaultKeeperBtcPubkeys: n,
-    universalChallengerBtcPubkeys: u,
+    universalChallengerBtcPubkeys: a,
     minDeposit: s,
     maxDeposit: i
-  } = e, a = Br(
+  } = e, u = ro(
     t,
     s,
     i
   );
-  if (!a.valid)
-    throw new Error(a.error);
-  const c = $r(o);
+  if (!u.valid)
+    throw new Error(u.error);
+  const c = oo(o);
   if (!c.valid)
     throw new Error(c.error);
-  Rr(n), Ir(u), Vr(r);
+  no(n), so(a), ao(r);
 }
-class Me extends Error {
+class tt extends Error {
   constructor(t) {
     super(t), this.name = "ParticipantKeyDriftError";
   }
 }
-function ko(e) {
-  return e instanceof Me || e instanceof Error && e.name === "ParticipantKeyDriftError";
+function Qo(e) {
+  return e instanceof tt || e instanceof Error && e.name === "ParticipantKeyDriftError";
 }
-function ge(e, t, r) {
+function Ce(e, t, r) {
   return t.length === r.length && t.every((o, n) => o === r[n]) ? null : `${e} expected [${t.join(", ")}], got [${r.join(", ")}]`;
 }
-async function To(e) {
-  const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: o, expected: n } = e, u = n.query;
+async function Jo(e) {
+  const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: o, expected: n } = e, a = n.query;
   if (o.length === 0) return;
   const s = await t.getVaultKeyEpochsBatch(o), i = [];
-  for (const [a, c] of s.entries()) {
-    const h = o[a];
+  for (const [u, c] of s.entries()) {
+    const h = o[u];
     let l;
     try {
-      l = await _r({
+      l = await eo({
         operationKeyReader: r,
-        query: u,
+        query: a,
         epochs: c
       });
     } catch (g) {
@@ -1472,104 +1697,90 @@ async function To(e) {
     l.vaultProvider.operationBtcPubkey !== n.vaultProvider.operationBtcPubkey && i.push(
       `vault ${h}: vault provider key expected ${n.vaultProvider.operationBtcPubkey}, got ${l.vaultProvider.operationBtcPubkey}`
     );
-    const d = ge(
+    const p = Ce(
       `vault ${h}: vault keeper keys`,
       n.vaultKeeperOperationKeysSorted,
       l.vaultKeeperOperationKeysSorted
     );
-    d && i.push(d);
-    const p = ge(
+    p && i.push(p);
+    const d = Ce(
       `vault ${h}: universal challenger keys`,
       n.universalChallengerOperationKeysSorted,
       l.universalChallengerOperationKeysSorted
     );
-    p && i.push(p);
+    d && i.push(d);
   }
   if (i.length > 0)
-    throw new Me(
+    throw new tt(
       `Aborting BTC broadcast: participant operation keys changed during registration (${i.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-class Fe extends Error {
+class rt extends Error {
   constructor(t) {
     super(t), this.name = "RegisteredVaultVersionMismatchError";
   }
 }
-function Co(e) {
-  return e instanceof Fe || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
+function Zo(e) {
+  return e instanceof rt || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function Ao(e) {
+async function en(e) {
   const {
     vaultRegistryReader: t,
     vaultIds: r,
     expectedOffchainParamsVersion: o,
     expectedAppVaultKeepersVersion: n,
-    expectedUniversalChallengersVersion: u,
+    expectedUniversalChallengersVersion: a,
     expectedVaultCoreVersion: s
-  } = e, i = await t.getProtocolInfoBatch(r), a = [];
+  } = e, i = await t.getProtocolInfoBatch(r), u = [];
   if (i.forEach((c, h) => {
     const l = r[h];
-    c.offchainParamsVersion !== o && a.push(
+    c.offchainParamsVersion !== o && u.push(
       `vault ${l}: offchainParams expected v${o}, got v${c.offchainParamsVersion}`
-    ), c.appVaultKeepersVersion !== n && a.push(
+    ), c.appVaultKeepersVersion !== n && u.push(
       `vault ${l}: appVaultKeepers expected v${n}, got v${c.appVaultKeepersVersion}`
-    ), c.universalChallengersVersion !== u && a.push(
-      `vault ${l}: universalChallengers expected v${u}, got v${c.universalChallengersVersion}`
-    ), c.vaultCoreVersion !== s && a.push(
+    ), c.universalChallengersVersion !== a && u.push(
+      `vault ${l}: universalChallengers expected v${a}, got v${c.universalChallengersVersion}`
+    ), c.vaultCoreVersion !== s && u.push(
       `vault ${l}: vaultCoreVersion expected v${s} (build-time active), got v${c.vaultCoreVersion}`
     );
-  }), a.length > 0)
-    throw new Fe(
-      `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${a.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
+  }), u.length > 0)
+    throw new rt(
+      `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.`
     );
 }
-var Ue = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(Ue || {});
-const Kr = /* @__PURE__ */ new Set([
-  "PayoutBroadcast",
-  "PayoutBlocked"
-  /* PAYOUT_BLOCKED */
-]);
-function _o(e) {
-  return Object.values(Ue).includes(
-    e
-  );
-}
-function So(e) {
-  return !!e && Kr.has(e);
-}
-class Or extends Error {
+class io extends Error {
   constructor(r, o) {
     super(`Refund not yet mature (BIP68 not final): ${o.message}`);
-    R(this, "vaultId");
-    R(this, "cause");
+    O(this, "vaultId");
+    O(this, "cause");
     this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = o;
   }
 }
-const Nr = /^0x[0-9a-fA-F]{64}$/, Hr = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, Le = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, Xe = 160, fe = 2e3, ve = 10n, be = 100n;
-function Bo(e) {
+const uo = /^0x[0-9a-fA-F]{64}$/, co = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, ot = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, nt = 160, Ae = 2e3, Se = 10n, Ie = 100n;
+function tn(e) {
   if (!Number.isFinite(e) || e <= 0)
     throw new Error(
       `feeRateSatsVb must be a positive finite number, got ${e}`
     );
-  return BigInt(Math.ceil(e * Xe));
+  return BigInt(Math.ceil(e * nt));
 }
-const Dr = 1, Mr = /non-BIP68-final/i;
-function W(e, t) {
+const lo = 1, ho = /non-BIP68-final/i;
+function ne(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 (!Nr.test(e))
+  if (!uo.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function z(e, t) {
+function re(e, t) {
   if (!Number.isInteger(e) || e < 0)
     throw new Error(`${t} must be a non-negative integer, got ${e}`);
 }
-function Fr(e) {
-  if (W(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
+function po(e) {
+  if (ne(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
     throw new Error(
       `htlcVout must be a non-negative integer, got ${e.htlcVout}`
     );
@@ -1581,7 +1792,7 @@ function Fr(e) {
     );
   for (let r = 0; r < e.batch.length; r++) {
     const o = e.batch[r];
-    if (W(o.hashlock, `batch[${r}].hashlock`), !Number.isInteger(o.htlcVout) || o.htlcVout !== r)
+    if (ne(o.hashlock, `batch[${r}].hashlock`), !Number.isInteger(o.htlcVout) || o.htlcVout !== r)
       throw new Error(
         `batch[${r}].htlcVout must equal ${r} (contiguous vout-ordered vector), got ${o.htlcVout}`
       );
@@ -1599,27 +1810,27 @@ function Fr(e) {
     throw new Error(
       `batch[${e.htlcVout}].amount (${t.amount}) does not match target amount (${e.amount})`
     );
-  if (z(e.offchainParamsVersion, "offchainParamsVersion"), z(e.appVaultKeepersVersion, "appVaultKeepersVersion"), z(
+  if (re(e.offchainParamsVersion, "offchainParamsVersion"), re(e.appVaultKeepersVersion, "appVaultKeepersVersion"), re(
     e.universalChallengersVersion,
     "universalChallengersVersion"
-  ), St(
+  ), jt(
     e.vaultCoreVersion,
     "VaultRefundData.vaultCoreVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
     throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!Hr.test(e.unsignedPrePeginTxHex))
+  if (!co.test(e.unsignedPrePeginTxHex))
     throw new Error(
       "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
     );
-  if (!e.depositorBtcPubkey || !Le.test(e.depositorBtcPubkey))
+  if (!e.depositorBtcPubkey || !ot.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 Ur(e) {
-  if (!e.vaultProviderPubkey || !Le.test(e.vaultProviderPubkey))
+function go(e) {
+  if (!e.vaultProviderPubkey || !ot.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");
@@ -1644,60 +1855,60 @@ function Ur(e) {
       `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
     );
 }
-async function $o(e) {
+async function rn(e) {
   const {
     vaultId: t,
     readVault: r,
     readPrePeginContext: o,
     feeRate: n,
-    signPsbt: u,
+    signPsbt: a,
     broadcastTx: s,
     signal: i
   } = e;
-  i == null || i.throwIfAborted(), W(t, "vaultId");
-  const a = await r();
-  Fr(a), i == null || i.throwIfAborted();
-  const c = await o(a);
-  if (Ur(c), i == null || i.throwIfAborted(), !Number.isFinite(n) || n <= 0)
+  i == null || i.throwIfAborted(), ne(t, "vaultId");
+  const u = await r();
+  po(u), i == null || i.throwIfAborted();
+  const c = await o(u);
+  if (go(c), i == null || i.throwIfAborted(), !Number.isFinite(n) || n <= 0)
     throw new Error(`feeRate must be a positive number, got ${n}`);
-  if (n > fe)
+  if (n > Ae)
     throw new Error(
-      `feeRate ${n} sat/vB exceeds refund safety cap ${fe} sat/vB; refusing to sign refund.`
+      `feeRate ${n} sat/vB exceeds refund safety cap ${Ae} sat/vB; refusing to sign refund.`
     );
-  const h = BigInt(Math.ceil(n * Xe)), l = a.amount * ve / be;
+  const h = BigInt(Math.ceil(n * nt)), l = u.amount * Se / Ie;
   if (h > l)
     throw new Error(
-      `Refund fee ${h} sats exceeds the per-vault safety cap of ${l} sats (${ve}/${be} of vault.amount=${a.amount}); refusing to sign refund.`
+      `Refund fee ${h} sats exceeds the per-vault safety cap of ${l} sats (${Se}/${Ie} of vault.amount=${u.amount}); refusing to sign refund.`
     );
   i == null || i.throwIfAborted();
-  const d = D(
-    a.depositorBtcPubkey
-  ), p = P(a.unsignedPrePeginTxHex), g = Ze(p);
-  if (g !== void 0 && g.vout !== a.batch.length)
+  const p = j(
+    u.depositorBtcPubkey
+  ), d = f(u.unsignedPrePeginTxHex), g = dt(d);
+  if (g !== void 0 && g.vout !== u.batch.length)
     throw new Error(
-      `Auth-anchor OP_RETURN at vout ${g.vout} does not match batch size (${a.batch.length} HTLC outputs expect the anchor at vout ${a.batch.length}). Refund refused — sibling HTLC vector is incomplete.`
+      `Auth-anchor OP_RETURN at vout ${g.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.`
     );
   const b = g == null ? void 0 : g.hash;
-  let f;
+  let y;
   try {
-    f = B.fromHex(p);
-  } catch (y) {
+    y = B.fromHex(d);
+  } catch (P) {
     throw new Error(
-      `Failed to parse funded Pre-PegIn transaction hex: ${y instanceof Error ? y.message : String(y)}`
+      `Failed to parse funded Pre-PegIn transaction hex: ${P instanceof Error ? P.message : String(P)}`
     );
   }
-  if (f.outs.length < a.batch.length)
+  if (y.outs.length < u.batch.length)
     throw new Error(
-      `Funded Pre-PegIn tx has ${f.outs.length} outputs but batch requires at least ${a.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
+      `Funded Pre-PegIn tx has ${y.outs.length} outputs but batch requires at least ${u.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
     );
-  const { psbtHex: v } = await Ct({
+  const { psbtHex: m } = await Lt({
     prePeginParams: {
-      vaultCoreVersion: a.vaultCoreVersion,
-      depositorPubkey: d,
-      vaultProviderPubkey: P(c.vaultProviderPubkey),
-      vaultKeeperPubkeys: c.vaultKeeperPubkeys.map(P),
-      universalChallengerPubkeys: c.universalChallengerPubkeys.map(P),
-      hashlocks: a.batch.map((y) => P(y.hashlock)),
+      vaultCoreVersion: u.vaultCoreVersion,
+      depositorPubkey: p,
+      vaultProviderPubkey: f(c.vaultProviderPubkey),
+      vaultKeeperPubkeys: c.vaultKeeperPubkeys.map(f),
+      universalChallengerPubkeys: c.universalChallengerPubkeys.map(f),
+      hashlocks: u.batch.map((P) => f(P.hashlock)),
       timelockRefund: c.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
@@ -1705,7 +1916,7 @@ async function $o(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: a.batch.map((y) => y.amount),
+      pegInAmounts: u.batch.map((P) => P.amount),
       feeRate: c.feeRate,
       minPeginFeeRate: c.minPeginFeeRate,
       numLocalChallengers: c.numLocalChallengers,
@@ -1714,206 +1925,206 @@ async function $o(e) {
       network: c.network,
       authAnchorHash: b
     },
-    fundedPrePeginTxHex: p,
-    htlcVout: a.htlcVout,
+    fundedPrePeginTxHex: d,
+    htlcVout: u.htlcVout,
     refundFee: h,
     // buildRefundPsbt's top-level `hashlock` param is documented as "no 0x
     // prefix" and flows into the WASM HTLC connector derivation; a prefixed
     // value would derive the wrong refund script leaf and yield an
     // unspendable PSBT. Match the `hashlocks` array handling above.
-    hashlock: P(a.hashlock)
+    hashlock: f(u.hashlock)
   });
   i == null || i.throwIfAborted();
-  const m = V(
-    a.depositorBtcPubkey,
-    Dr
-  ), w = await u(v, m);
-  K({
-    requestedPsbtHex: v,
+  const x = M(
+    u.depositorBtcPubkey,
+    lo
+  ), w = await a(m, x);
+  F({
+    requestedPsbtHex: m,
     returnedPsbtHex: w
   });
-  const E = 0, x = O(
+  const k = 0, _ = U(
     w,
-    d,
-    E
+    p,
+    k
   );
-  N({
-    requestedPsbtHex: v,
-    signatureHex: x,
-    signerXOnlyPubkeyHex: d,
-    inputIndex: E
+  L({
+    requestedPsbtHex: m,
+    signatureHex: _,
+    signerXOnlyPubkeyHex: p,
+    inputIndex: k
   });
-  const T = Se({
-    requestedPsbtHex: v,
-    signaturesHex: [x],
-    signerXOnlyPubkeyHex: d
+  const C = Le({
+    requestedPsbtHex: m,
+    signaturesHex: [_],
+    signerXOnlyPubkeyHex: p
   });
   i == null || i.throwIfAborted();
   try {
-    return await s(T);
-  } catch (y) {
-    throw y instanceof Error && Mr.test(y.message) ? new Or(t, y) : y;
+    return await s(C);
+  } catch (P) {
+    throw P instanceof Error && ho.test(P.message) ? new io(t, P) : P;
   }
 }
-class Pe extends Error {
+class Re extends Error {
   constructor(r, o, n) {
     super(r);
     /** Fee the reclaim would have paid, in satoshis. */
-    R(this, "feeSats");
+    O(this, "feeSats");
     /** Sum of the reserves the reclaim would have swept, in satoshis. */
-    R(this, "sweptTotalSats");
+    O(this, "sweptTotalSats");
     this.name = "ReclaimUneconomicalError", this.feeSats = o, this.sweptTotalSats = n;
   }
 }
-const ye = 2e3, me = 25n, we = 100n, Ro = 10n;
-async function Lr(e, t, r) {
+const Be = 2e3, Ve = 25n, Oe = 100n, on = 10n;
+async function fo(e, t, r) {
   for (let o = 0; o < e.length; o++) {
-    const n = tt(e[o].depositorSignedPeginTxHex), u = xe(
-      await gt(
-        P(n),
-        P(r)
+    const n = ft(e[o].depositorSignedPeginTxHex), a = He(
+      await Ct(
+        f(n),
+        f(r)
       )
     ).toLowerCase();
-    if (u !== t[o].toLowerCase())
+    if (a !== t[o].toLowerCase())
       throw new Error(
-        `Reserve ${o} belongs to vault ${u}, not the requested ${t[o].toLowerCase()}. Refusing to sweep a reserve whose vault is not the one the caller asked for — the reserve funds that vault's claim transaction and cannot be replaced.`
+        `Reserve ${o} belongs to vault ${a}, not the requested ${t[o].toLowerCase()}. Refusing to sweep a reserve whose vault is not the one the caller asked for — the reserve funds that vault's claim transaction and cannot be replaced.`
       );
   }
 }
-async function Io(e) {
+async function nn(e) {
   const {
     vaultIds: t,
     depositorEthAddress: r,
     depositorBtcPubkey: o,
     readVaults: n,
-    feeRate: u,
+    feeRate: a,
     signPsbt: s,
     broadcastTx: i,
-    signal: a
+    signal: u
   } = e;
-  if (a == null || a.throwIfAborted(), t.length === 0)
+  if (u == null || u.throwIfAborted(), t.length === 0)
     throw new Error("Reclaim requires at least one vault id; got none.");
-  if (!Number.isFinite(u) || u <= 0)
-    throw new Error(`feeRate must be a positive number, got ${u}`);
-  if (u > ye)
-    throw new Pe(
-      `Fee rate ${u} sat/vB exceeds the reclaim safety cap of ${ye} sat/vB; refusing to sign.`,
+  if (!Number.isFinite(a) || a <= 0)
+    throw new Error(`feeRate must be a positive number, got ${a}`);
+  if (a > Be)
+    throw new Re(
+      `Fee rate ${a} sat/vB exceeds the reclaim safety cap of ${Be} sat/vB; refusing to sign.`,
       0n,
       0n
     );
   const c = await n();
-  if (a == null || a.throwIfAborted(), c.length !== t.length)
+  if (u == null || u.throwIfAborted(), c.length !== t.length)
     throw new Error(
       `readVaults returned ${c.length} reserves for ${t.length} vault id(s); refusing to sweep a set that does not match the request.`
     );
-  await Lr(c, t, r), a == null || a.throwIfAborted();
-  const h = D(o), l = c.map((E) => ({
-    depositorSignedPeginTxHex: E.depositorSignedPeginTxHex,
-    observed: E.observed,
-    expectedValue: E.expectedClaimValue
-  })), d = At(u, l.length), p = l.reduce((E, x) => E + x.expectedValue, 0n), g = p * me / we;
-  if (d > g)
-    throw new Pe(
-      `Reclaim fee ${d} sats exceeds ${me}/${we} of the swept total (${p} sats, cap ${g} sats). The reserve is not at risk — it stays where it is until fee rates fall.`,
-      d,
-      p
+  await fo(c, t, r), u == null || u.throwIfAborted();
+  const h = j(o), l = c.map((k) => ({
+    depositorSignedPeginTxHex: k.depositorSignedPeginTxHex,
+    observed: k.observed,
+    expectedValue: k.expectedClaimValue
+  })), p = Gt(a, l.length), d = l.reduce((k, _) => k + _.expectedValue, 0n), g = d * Ve / Oe;
+  if (p > g)
+    throw new Re(
+      `Reclaim fee ${p} sats exceeds ${Ve}/${Oe} of the swept total (${d} sats, cap ${g} sats). The reserve is not at risk — it stays where it is until fee rates fall.`,
+      p,
+      d
     );
-  a == null || a.throwIfAborted();
-  const { psbtHex: b } = _t({
+  u == null || u.throwIfAborted();
+  const { psbtHex: b } = Xt({
     depositorPubkey: h,
     inputs: l,
-    feeSats: d
+    feeSats: p
   });
-  a == null || a.throwIfAborted();
-  const f = V(
+  u == null || u.throwIfAborted();
+  const y = M(
     o,
     l.length
-  ), v = await s(b, f);
-  K({
+  ), m = await s(b, y);
+  F({
     requestedPsbtHex: b,
-    returnedPsbtHex: v
+    returnedPsbtHex: m
   });
-  const m = l.map((E, x) => {
-    const T = O(
-      v,
+  const x = l.map((k, _) => {
+    const C = U(
+      m,
       h,
-      x
+      _
     );
-    return N({
+    return L({
       requestedPsbtHex: b,
-      signatureHex: T,
+      signatureHex: C,
       signerXOnlyPubkeyHex: h,
-      inputIndex: x
-    }), T;
-  }), w = Se({
+      inputIndex: _
+    }), C;
+  }), w = Le({
     requestedPsbtHex: b,
-    signaturesHex: m,
+    signaturesHex: x,
     signerXOnlyPubkeyHex: h
   });
-  return a == null || a.throwIfAborted(), i(w);
+  return u == null || u.throwIfAborted(), i(w);
 }
 export {
-  ve as $,
-  er as A,
-  Br as B,
-  Kt as C,
-  Zt as D,
-  $r as E,
-  Me as F,
-  ko as G,
-  To as H,
-  Co as I,
-  Ao as J,
-  Ne as K,
-  vo as L,
-  X as M,
-  Tr as N,
-  he as O,
-  Nt as P,
-  Ar as Q,
-  Fe as R,
-  _r as S,
-  Ue as T,
-  _o as U,
-  Mt as V,
-  So as W,
-  Or as X,
-  $o as Y,
-  Bo as Z,
-  be as _,
-  ao as a,
-  fe as a0,
-  Xe as a1,
-  Pe as a2,
-  Io as a3,
-  we as a4,
-  me as a5,
-  ye as a6,
-  Ro as a7,
-  io as b,
-  uo as c,
-  co as d,
-  lo as e,
-  Ot as f,
-  Ht as g,
-  Ie as h,
-  nr as i,
-  Ke as j,
-  Oe as k,
-  ur as l,
-  ho as m,
-  fr as n,
-  fo as o,
-  j as p,
-  bo as q,
-  go as r,
-  tr as s,
-  yo as t,
-  mo as u,
-  Po as v,
-  po as w,
-  xo as x,
-  Eo as y,
-  wo as z
+  Se as $,
+  br as A,
+  Wo as B,
+  Jt as C,
+  yr as D,
+  zo as E,
+  ro as F,
+  v as G,
+  oo as H,
+  tt as I,
+  Qo as J,
+  Jo as K,
+  Zo as L,
+  en as M,
+  Je as N,
+  Lo as O,
+  er as P,
+  Z as Q,
+  rt as R,
+  Qr as S,
+  _e as T,
+  Zr as U,
+  or as V,
+  eo as W,
+  io as X,
+  rn as Y,
+  tn as Z,
+  Ie as _,
+  Bo as a,
+  Ae as a0,
+  nt as a1,
+  Re as a2,
+  nn as a3,
+  Oe as a4,
+  Ve as a5,
+  Be as a6,
+  on as a7,
+  Vo as b,
+  Oo as c,
+  No as d,
+  Ho as e,
+  Zt as f,
+  tr as g,
+  qe as h,
+  wr as i,
+  We as j,
+  Ye as k,
+  _r as l,
+  Ko as m,
+  Mo as n,
+  Br as o,
+  Fr as p,
+  Uo as q,
+  Fo as r,
+  mr as s,
+  oe as t,
+  Go as u,
+  Xo as v,
+  Do as w,
+  jo as x,
+  qo as y,
+  Yo as z
 };
-//# sourceMappingURL=buildAndBroadcastReclaim-CqO2DoP8.js.map
+//# sourceMappingURL=buildAndBroadcastReclaim-T5ZFPUpM.js.map