@babylonlabs-io/ts-sdk 2.0.1 → 2.0.2

package/dist/{buildAndBroadcastReclaim-CqO2DoP8.js → buildAndBroadcastReclaim-B19cyK69.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 it = Object.defineProperty;
+var ut = (e, t, r) => t in e ? it(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var O = (e, t, r) => ut(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 ct, c as $, v as lt, u as Ke, p as j, f as V } from "./bitcoin-C-TuHb-v.js";
+import { v as ht, d as De, s as pt, P as dt, a as gt } from "./PayoutManager-BSwbUQeF.js";
+import { Buffer as I } from "buffer";
+import { b as ft, a as M, c as yt } from "./signing-Dhr2t0Z6.js";
+import { buildClaimPsbt as bt, buildAssertClaimerPsbt as mt, buildPayoutClaimerPsbt as Pt, buildWronglyChallengedPsbts as vt, buildPayoutDepositorPsbt as wt, finalizeClaimTx as xt, buildWatchtowerArtifacts as Et, extractTapScriptSig as kt, expandWotsSeed as _t, wotsKeypairFromSeed as Tt, validateWotsKeypairAgainstGraph as $t, verifyWatchtowerArtifacts as At, deriveVaultId as Ct } from "./tbv/core/wasm/index.js";
+import { p as Me, P as le, f as St, 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 It } from "./deriveVaultRoot-BcvmER1E.js";
+import { d as Rt, a as fe } from "./onChainBtcPubkey-CCTdl53s.js";
+import { zeroAddress as Bt, isAddress as Vt, isAddressEqual as Ot } from "viem";
+import { D as R, c as Nt, b as Ht, R as Kt, d as Ue } from "./json-rpc-client-CQLbpuKK.js";
+import { h as ye, b as Dt, s as Mt, j as Ft } from "./sha2-YqVHJiFj.js";
+import { d as Ut, c as Lt, b as Gt, f as Le, e as Xt, a as jt } from "./noPayout-qBXWKwav.js";
+import { a as qt } from "./secp256k1-D-H9jmd7.js";
+const zt = /^0x[0-9a-fA-F]{64}$/, Wt = /^0x[0-9a-fA-F]{40}$/, Yt = /^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 (!zt.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function It(e, t) {
-  if (!$t.test(e))
+function Qt(e, t) {
+  if (!Wt.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 Jt(e, t) {
+  if (!Yt.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) {
+  Qt(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), z(e.vaultId, "vaultId");
+  const t = He(e.secret);
+  if (z(t, "secret"), e.hashlock !== void 0 && (z(e.hashlock, "hashlock"), !ht(t, e.hashlock)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
   return t;
 }
-async function ao(e) {
+async function Oo(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 Jt(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 No(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 Zt 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 er(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 Zt(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 tr 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 rr(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 } = or(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 tr(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 or(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 nr 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 sr(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 ar(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(
+    Rt(e.peginTxid, e.depositorEthAddress)
+  ), r = G(e.expectedVaultId);
   if (t !== r)
-    throw new Mt(r, t, e.peginTxid);
+    throw new nr(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 ir = 0, ur = 0, cr = 1, lr = 0, hr = 0;
+async function Ho(e) {
+  const { txGraphVersion: t } = e.vault, r = e.source.txGraphJson, [o, n, a, s] = await Promise.all([
+    bt(t, r),
+    mt(t, r),
+    Pt(t, r),
+    vt(t, r)
   ]);
-  Ie({
-    peginTxid: Ft(o),
+  qe({
+    peginTxid: sr(o),
     depositorEthAddress: e.vault.depositorEthAddress,
     expectedVaultId: e.vault.vaultId
   });
-  const i = await at(
+  const i = await wt(
     t,
     r
   );
-  for (const m of [u, i])
-    Ht({
-      payoutPsbtBase64: m,
+  for (const x of [a, i])
+    rr({
+      payoutPsbtBase64: x,
       registeredPayoutScriptPubKey: e.vault.registeredPayoutScriptPubKey
     });
-  Ot({
+  er({
     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: ir },
+    { psbtBase64: n, inputIndex: ur },
+    { psbtBase64: a, inputIndex: cr },
     {
       psbtBase64: i,
-      inputIndex: qt
+      inputIndex: lr
     }
   ], 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: hr });
+  const h = await dr(
     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 xt(
     t,
     r,
-    d
+    p
   );
-  return ut({
+  return Et({
     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 pr(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 (!ct(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 dr(e, t, r, o) {
+  const n = await pr(
     e,
     t,
     r
-  ), u = await Te(
+  ), a = await De(
     e,
-    o.map((s) => Yt(s.psbtBase64)),
+    o.map((s) => gr(s.psbtBase64)),
     o.map(
-      (s) => et(
+      (s) => ft(
         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) => kt(fr(s), o[i].inputIndex)
     )
   );
 }
-function Yt(e) {
-  return $.from(e, "base64").toString("hex");
+function gr(e) {
+  return I.from(e, "base64").toString("hex");
 }
-function Qt(e) {
-  return $.from(e, "hex").toString("base64");
+function fr(e) {
+  return I.from(e, "hex").toString("base64");
 }
-async function co(e) {
-  const t = await vt(e.btcWallet, e.vaultContext);
+async function Ko(e) {
+  const t = await It(e.btcWallet, e.vaultContext);
   let r;
   try {
-    r = await lt(t, e.htlcVout);
+    r = await _t(t, e.htlcVout);
   } finally {
     t.fill(0);
   }
   let o;
   try {
-    o = await ht(r);
+    o = await Tt(r);
   } finally {
     r.fill(0);
   }
-  return Jt(o.pk_hash, e.expectedWotsPkHash), await dt(
+  return yr(o.pk_hash, e.expectedWotsPkHash), await $t(
     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 yr(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 br = 3;
+class mr 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 Pr(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 = vr(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: ar(o),
     proverCircuitVersion: n,
-    claimableEventBlockNumber: u,
+    claimableEventBlockNumber: a,
     babeSessionChallengerPubkeys: Object.keys(
-      or(t.babe_sessions, "babe_sessions")
+      wr(t.babe_sessions, "babe_sessions")
     )
   };
 }
-async function lo(e) {
-  const t = tr(e.artifactsJson), r = H(e.expectedVaultId), o = H(t.vaultId);
+async function Do(e) {
+  const t = Pr(e.artifactsJson), r = G(e.expectedVaultId), o = G(t.vaultId);
   if (r !== o)
-    throw new er(r, o);
-  Ie({
+    throw new mr(r, o);
+  qe({
     peginTxid: t.peginTxid,
     depositorEthAddress: e.depositorEthAddress,
     expectedVaultId: r
   });
-  const n = e.txGraphVersion ?? Zt;
+  const n = e.txGraphVersion ?? br;
   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 At(n, e.artifactsJson), t;
 }
-function rr(e) {
+function vr(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 wr(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 xr = 8, Er = 6e3, kr = 10 * 6e4, _r = 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 Tr(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 Mo(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 Fo(e) {
   const {
     vaultRegistryReader: t,
     getBlockNumber: r,
     vaultIds: o,
-    required: n = nr,
-    pollIntervalMs: u = sr,
-    timeoutMs: s = ar,
+    required: n = xr,
+    pollIntervalMs: a = Er,
+    timeoutMs: s = kr,
     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 === Bt || y.createdAt === 0n
       );
       if (b !== -1) {
-        if (l += 1, !h && l > ir)
-          throw new Ke(
+        if (l += 1, !h && l > _r)
+          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 (Tr(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 $r = /^(?:[0-9a-f]{2})*$/, Ar = /^[0-9a-f]{64}$/, Cr = /^([0-9a-f]{64}):(0|[1-9][0-9]*)$/, Sr = -2147483648, Ir = 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 C(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" || !$r.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" || !Ar.test(e))
+    throw new v(
+      `Graph ${t} is not 32 bytes of lowercase hex`
+    );
+  return e;
+}
+function Ee(e, t) {
+  const r = C(e, t), o = new B();
+  return o.version = N(
+    E(r, "version", t),
+    `${t}.version`,
+    Sr,
+    Ir
+  ), 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 = C(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 = C(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 Rr(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")));
+  }), Dt(Mt(Ft(...r)));
+}
+function Br(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");
+  Rr(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 Vr(e) {
+  const t = (o) => Ee(C(E(e, o, "graph"), o).tx, o), r = C(
+    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 = C(n, a);
+      return {
+        pubkey: o,
+        nopayoutTx: Ee(
+          C(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 Or(e) {
+  const t = C(
+    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 Uo(e, t) {
+  const r = Vr(e);
+  if (r !== t)
+    throw new v(
+      `Graph fingerprint ${r} does not match the presign fingerprint ${t}`
+    );
+  const o = Object.keys(
+    C(e.challenger_subgraphs, "challenger_subgraphs")
+  ), n = Or(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 Nr = 1;
+function Hr(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 Kr(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 = Kr(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 Dr(e, t, r) {
+  const o = [], n = [], a = [], s = Me({
     claimerBtcPubkey: r.depositorBtcPubkey,
     depositorBtcPubkey: r.depositorBtcPubkey,
     vaultProviderBtcPubkey: r.vaultProviderBtcPubkey,
     vaultKeeperBtcPubkeys: r.vaultKeeperBtcPubkeys
   });
-  lr(
+  Hr(
     e.challenger_presign_data,
     s,
     r.universalChallengerBtcPubkeys
   );
-  const i = await ft({
+  const i = await St({
     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: Nr,
     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 Mr({
       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 Mr(e) {
   const {
     challenger: t,
     challengerPubkey: r,
     claimerPubkey: o,
     localChallengers: n,
-    assertTxParsed: u,
+    assertTxParsed: a,
     ctx: s
   } = e;
-  kt(
+  Ut(
     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 Lt({
     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 Fr(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 Ur(e) {
+  const { depositorGraph: t, btcWallet: r, signingContext: o } = e, n = await r.getPublicKeyHex(), { depositorPubkey: a } = lt(
     n,
-    P(o.depositorBtcPubkey)
-  ), { psbtHexes: s, signOptions: i, challengerEntries: a } = await dr(
+    f(o.depositorBtcPubkey)
+  ), { psbtHexes: s, signOptions: i, challengerEntries: u } = await Dr(
     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 Fr(
     h,
-    a,
-    u
+    u,
+    a
   );
 }
-const vr = 1e4;
-async function Ne(e) {
+const Lr = 1e4;
+async function Je(e) {
   const {
     statusReader: t,
     peginTxid: r,
     targetStatuses: o,
     timeoutMs: n,
-    pollIntervalMs: u = vr,
+    pollIntervalMs: a = Lr,
     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 || Nt.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 Ht && u.code === Kt.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 Gr = 1200 * 1e3, Ze = /* @__PURE__ */ new Set([
+  R.PENDING_ACKS,
+  R.PENDING_ACTIVATION,
+  R.ACTIVATED_PENDING_BROADCAST,
+  R.ACTIVATED
+]), Xr = /* @__PURE__ */ new Set([
+  R.PENDING_DEPOSITOR_SIGNATURES,
+  ...Ze
 ]);
-function yr(e) {
+function jr(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 qr(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 zr(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 Wr(e, t, r, o) {
+  const n = new dt({
     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 Lo(e) {
   const {
     statusReader: t,
     presignClient: r,
     btcWallet: o,
     peginTxid: n,
-    depositorPk: u,
+    depositorPk: a,
     signingContext: s,
     depositTerms: i,
-    timeoutMs: a = br,
+    timeoutMs: u = Gr,
     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: Xr,
+    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 && qr(i, s), pt(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 = Br({
+    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);
+  zr(
     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 = jr(y), x = await Wr(
     o,
     s,
-    b,
+    m,
     h
   );
   c == null || c.throwIfAborted();
-  const v = await fr({
+  const w = await Ur({
     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 Yr = 300 * 1e3, Qr = /* @__PURE__ */ new Set([
+  R.PENDING_DEPOSITOR_WOTS_PK,
+  ...Ue
 ]);
-async function fo(e) {
+async function Go(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
     peginTxid: o,
     depositorPk: n,
-    wotsPublicKeys: u,
-    timeoutMs: s = xr,
+    wotsPublicKeys: a,
+    timeoutMs: s = Yr,
     signal: i
   } = e;
   i == null || i.throwIfAborted();
-  const a = await Ne({
+  const u = await Je({
     statusReader: t,
     peginTxid: o,
-    targetStatuses: kr,
+    targetStatuses: Qr,
     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 Jr(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 Xo(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 Zr(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 Zr([
     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 eo(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 to(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 jo(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 qo(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 (!Vt(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 (!Ot(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))
+  }, A = await eo({
     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: A.vaultProvider.operationBtcPubkey,
+    vaultKeepers: [...A.vaultKeeperOperationKeysSorted],
     universalChallengers: [
-      ...T.universalChallengerOperationKeysSorted
+      ...A.universalChallengerOperationKeysSorted
     ]
-  }, Y = Tr(
+  }, se = Jr(
     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], at = ue.some((T) => T.registration && !T.operation), ce = ue.some((T) => T.operation && !T.registration);
+  if (at && 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: A
   };
 }
-function Sr(e) {
+function ro(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function yo(e) {
+function zo(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 Wo(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 Yo(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 Qo(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 oo(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 no(e) {
+  const t = f(e);
+  return ro(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 so(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 ao(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 io(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function xo(e) {
+function Jo(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
     vaultProviderBtcPubkey: o,
     vaultKeeperBtcPubkeys: n,
-    universalChallengerBtcPubkeys: u,
+    universalChallengerBtcPubkeys: a,
     minDeposit: s,
     maxDeposit: i
-  } = e, a = Br(
+  } = e, u = oo(
     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 = no(o);
   if (!c.valid)
     throw new Error(c.error);
-  Rr(n), Ir(u), Vr(r);
+  so(n), ao(a), io(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 Zo(e) {
+  return e instanceof tt || e instanceof Error && e.name === "ParticipantKeyDriftError";
 }
-function ge(e, t, r) {
+function Ae(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 en(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 to({
         operationKeyReader: r,
-        query: u,
+        query: a,
         epochs: c
       });
     } catch (g) {
@@ -1472,104 +1697,104 @@ 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 = Ae(
       `vault ${h}: vault keeper keys`,
       n.vaultKeeperOperationKeysSorted,
       l.vaultKeeperOperationKeysSorted
     );
-    d && i.push(d);
-    const p = ge(
+    p && i.push(p);
+    const d = Ae(
       `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 tn(e) {
+  return e instanceof rt || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function Ao(e) {
+async function rn(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([
+var ot = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(ot || {});
+const uo = /* @__PURE__ */ new Set([
   "PayoutBroadcast",
   "PayoutBlocked"
   /* PAYOUT_BLOCKED */
 ]);
-function _o(e) {
-  return Object.values(Ue).includes(
+function on(e) {
+  return Object.values(ot).includes(
     e
   );
 }
-function So(e) {
-  return !!e && Kr.has(e);
+function nn(e) {
+  return !!e && uo.has(e);
 }
-class Or extends Error {
+class co 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 lo = /^0x[0-9a-fA-F]{64}$/, ho = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, nt = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, st = 160, Ce = 2e3, Se = 10n, Ie = 100n;
+function sn(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 * st));
 }
-const Dr = 1, Mr = /non-BIP68-final/i;
-function W(e, t) {
+const po = 1, go = /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 (!lo.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 fo(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 +1806,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 +1824,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(
+  ), qt(
     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 (!ho.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 || !nt.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 yo(e) {
+  if (!e.vaultProviderPubkey || !nt.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 +1869,60 @@ function Ur(e) {
       `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
     );
 }
-async function $o(e) {
+async function an(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();
+  fo(u), i == null || i.throwIfAborted();
+  const c = await o(u);
+  if (yo(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 > Ce)
     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 ${Ce} sat/vB; refusing to sign refund.`
     );
-  const h = BigInt(Math.ceil(n * Xe)), l = a.amount * ve / be;
+  const h = BigInt(Math.ceil(n * st)), 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 = gt(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 Gt({
     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 +1930,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 +1939,209 @@ 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,
+    po
+  ), 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 A = 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(A);
+  } catch (P) {
+    throw P instanceof Error && go.test(P.message) ? new co(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, un = 10n;
+async function bo(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 = yt(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 cn(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 bo(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 = Xt(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 } = jt({
     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 A = U(
+      m,
       h,
-      x
+      _
     );
-    return N({
+    return L({
       requestedPsbtHex: b,
-      signatureHex: T,
+      signatureHex: A,
       signerXOnlyPubkeyHex: h,
-      inputIndex: x
-    }), T;
-  }), w = Se({
+      inputIndex: _
+    }), A;
+  }), 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
+  an as $,
+  mr as A,
+  Qo as B,
+  Zt as C,
+  br as D,
+  Yo as E,
+  oo as F,
+  v as G,
+  no as H,
+  tt as I,
+  Zo as J,
+  en as K,
+  tn as L,
+  rn as M,
+  Je as N,
+  Xo as O,
+  tr as P,
+  Z as Q,
+  rt as R,
+  Jr as S,
+  _e as T,
+  eo as U,
+  nr as V,
+  to as W,
+  ot as X,
+  on as Y,
+  nn as Z,
+  co as _,
+  Oo as a,
+  sn as a0,
+  Ie as a1,
+  Se as a2,
+  Ce as a3,
+  st as a4,
+  Re as a5,
+  cn as a6,
+  Oe as a7,
+  Ve as a8,
+  Be as a9,
+  un as aa,
+  No as b,
+  Ho as c,
+  Ko as d,
+  Do as e,
+  er as f,
+  rr as g,
+  qe as h,
+  xr as i,
+  We as j,
+  Ye as k,
+  Tr as l,
+  Mo as m,
+  Uo as n,
+  Vr as o,
+  Ur as p,
+  Go as q,
+  Lo as r,
+  Pr as s,
+  oe as t,
+  jo as u,
+  qo as v,
+  Fo as w,
+  zo as x,
+  Wo as y,
+  Jo as z
 };
-//# sourceMappingURL=buildAndBroadcastReclaim-CqO2DoP8.js.map
+//# sourceMappingURL=buildAndBroadcastReclaim-B19cyK69.js.map