@babylonlabs-io/ts-sdk 3.0.0 → 3.0.1

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

@@ -1,81 +1,81 @@
-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";
+var ut = Object.defineProperty;
+var ct = (e, t, r) => t in e ? ut(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var N = (e, t, r) => ct(e, typeof t != "symbol" ? t + "" : t, r);
+import { B as Ke } from "./BTCVaultRegistry.abi-B0x9_Bza.js";
+import { e as De, s as f, i as lt, c as C, v as ht, u as Me, p as j, f as V } from "./bitcoin-C-TuHb-v.js";
+import { v as pt, d as Fe, s as dt, P as gt, a as ft } 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) {
+import { b as yt, a as F, c as bt } from "./signing-Dhr2t0Z6.js";
+import { buildClaimPsbt as mt, buildAssertClaimerPsbt as vt, buildPayoutClaimerPsbt as Pt, buildWronglyChallengedPsbts as wt, buildPayoutDepositorPsbt as xt, finalizeClaimTx as Et, buildWatchtowerArtifacts as kt, extractTapScriptSig as _t, expandWotsSeed as Tt, wotsKeypairFromSeed as $t, validateWotsKeypairAgainstGraph as Ct, verifyWatchtowerArtifacts as At, deriveVaultId as St } from "./tbv/core/wasm/index.js";
+import { p as Le, P as he, f as It, i as L, g as U, j as G } from "./verifyScriptPathSchnorrSignature-CpjSTfMj.js";
+import { Psbt as Ue, Transaction as B } from "bitcoinjs-lib";
+import { m as pe, n as de, N as z, o as ge, D as fe } from "./constants-D5vORbQE.js";
+import { d as Rt } from "./deriveVaultRoot-BcvmER1E.js";
+import { d as Bt, a as ye } from "./onChainBtcPubkey-CCTdl53s.js";
+import { zeroAddress as Vt, isAddress as Ot, isAddressEqual as Nt } from "viem";
+import { v as be, D as R, c as Ht, b as Kt, R as Dt, d as Ge } from "./state-CFn1rT74.js";
+import { h as me, b as Mt, s as Ft, j as Lt } from "./sha2-YqVHJiFj.js";
+import { d as Ut, c as Gt, b as Xt, f as Xe, e as qt, a as jt } from "./noPayout-qBXWKwav.js";
+import { a as zt } from "./secp256k1-D-H9jmd7.js";
+const Wt = /^0x[0-9a-fA-F]{64}$/, Yt = /^0x[0-9a-fA-F]{40}$/, Qt = /^0x([0-9a-fA-F]{2})*$/;
+function W(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 (!qt.test(e))
+  if (!Wt.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function Yt(e, t) {
-  if (!zt.test(e))
+function Jt(e, t) {
+  if (!Yt.test(e))
     throw new Error(
       `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
     );
 }
-function Qt(e, t) {
-  if (!Wt.test(e))
+function Zt(e, t) {
+  if (!Qt.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
 }
-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)))
+function qe(e) {
+  Jt(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), W(e.vaultId, "vaultId");
+  const t = De(e.secret);
+  if (W(t, "secret"), e.hashlock !== void 0 && (W(e.hashlock, "hashlock"), !pt(t, e.hashlock)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
   return t;
 }
-async function Bo(e) {
+async function Oo(e) {
   const {
     btcVaultRegistryAddress: t,
     vaultId: r,
     hashlock: o,
     activationMetadata: n,
-    writeContract: a,
-    signal: s
+    writeContract: i,
+    signal: a
   } = e;
-  s == null || s.throwIfAborted();
-  const i = Ge({
+  a == null || a.throwIfAborted();
+  const s = qe({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
     hashlock: o
   });
-  return Qt(n, "activationMetadata"), a({
+  return Zt(n, "activationMetadata"), i({
     address: t,
-    abi: Ne,
+    abi: Ke,
     functionName: "activateVaultWithSecret",
-    args: [r, i, n]
+    args: [r, s, n]
   });
 }
-async function Vo(e) {
-  const { btcVaultRegistryAddress: t, vaultId: r, hashlock: o, writeContract: n, signal: a } = e;
-  a == null || a.throwIfAborted();
-  const s = Ge({
+async function No(e) {
+  const { btcVaultRegistryAddress: t, vaultId: r, hashlock: o, writeContract: n, signal: i } = e;
+  i == null || i.throwIfAborted();
+  const a = qe({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
@@ -83,82 +83,82 @@ async function Vo(e) {
   });
   return n({
     address: t,
-    abi: Ne,
+    abi: Ke,
     functionName: "activateVaultWithSecretAndRedeem",
-    args: [r, s]
+    args: [r, a]
   });
 }
-class Jt extends Error {
+class er 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 Zt(e) {
-  const t = Me({
+function tr(e) {
+  const t = Le({
     claimerBtcPubkey: e.depositorBtcPubkey,
     depositorBtcPubkey: e.depositorBtcPubkey,
     vaultProviderBtcPubkey: e.vaultProviderBtcPubkey,
     vaultKeeperBtcPubkeys: e.vaultKeeperBtcPubkeys
-  }), r = e.universalChallengerBtcPubkeys.map(be), o = t.filter((h) => r.includes(h));
+  }), r = e.universalChallengerBtcPubkeys.map(ve), o = t.filter((l) => r.includes(l));
   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(be), a = new Set(n);
-  if (a.size !== n.length)
+  const n = e.graphChallengerPubkeys.map(ve), i = new Set(n);
+  if (i.size !== n.length)
     throw new Error(
       "Transaction graph lists the same challenger more than once."
     );
-  const s = [...t, ...r], i = new Set(s), u = s.filter((h) => !a.has(h)), c = n.filter((h) => !i.has(h));
+  const a = [...t, ...r], s = new Set(a), u = a.filter((l) => !i.has(l)), c = n.filter((l) => !s.has(l));
   if (u.length > 0 || c.length > 0)
-    throw new Jt(u, c);
+    throw new er(u, c);
 }
-function be(e) {
+function ve(e) {
   return f(e).toLowerCase();
 }
-const Xe = 0;
-class er extends Error {
+const je = 0;
+class rr extends Error {
   constructor(t, r) {
     super(
-      `Payout transaction output ${Xe} pays ${r}, not the vault's registered payout script ${t}. Refusing to sign a payout to another destination.`
+      `Payout transaction output ${je} 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 tr(e) {
+function or(e) {
   let t;
   try {
-    t = Fe.fromBase64(e.payoutPsbtBase64);
+    t = Ue.fromBase64(e.payoutPsbtBase64);
   } catch (u) {
     throw new Error("Payout PSBT cannot be parsed.", { cause: u });
   }
-  const { version: r, locktime: o, outs: n } = rr(t);
-  if (r !== he || o !== pe)
+  const { version: r, locktime: o, outs: n } = nr(t);
+  if (r !== pe || o !== de)
     throw new Error(
-      `Payout transaction has version ${r} and locktime ${o}, expected ${he} and ${pe}.`
+      `Payout transaction has version ${r} and locktime ${o}, expected ${pe} and ${de}.`
     );
-  if (n.length !== q)
+  if (n.length !== z)
     throw new Error(
-      `Payout transaction has ${n.length} output(s), expected exactly ${q} for a depositor-as-claimer payout.`
+      `Payout transaction has ${n.length} output(s), expected exactly ${z} for a depositor-as-claimer payout.`
     );
-  const a = f(
+  const i = f(
     e.registeredPayoutScriptPubKey
   ).toLowerCase();
-  if (a.length === 0)
+  if (i.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[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)
+  const a = n[je].script.toString("hex").toLowerCase();
+  if (!I.from(a, "hex").equals(I.from(i, "hex")))
+    throw new rr(i, a);
+  const s = n[z - 1];
+  if (s.value !== ge)
     throw new Error(
-      `Payout CPFP anchor value ${i.value} sats must equal ${de} sats.`
+      `Payout CPFP anchor value ${s.value} sats must equal ${ge} sats.`
     );
 }
-function rr(e) {
+function nr(e) {
   return {
     version: e.version,
     locktime: e.locktime,
@@ -168,109 +168,109 @@ function rr(e) {
     }))
   };
 }
-const je = 0;
-class or extends Error {
+const ze = 0;
+class sr 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 nr(e) {
+function ar(e) {
   let t;
   try {
-    t = Fe.fromBase64(e);
+    t = Ue.fromBase64(e);
   } catch (o) {
     throw new Error("Claim PSBT cannot be parsed.", { cause: o });
   }
-  const r = t.txInputs[je];
+  const r = t.txInputs[ze];
   if (!r)
     throw new Error("Claim PSBT carries no PegIn input to bind the vault to.");
-  return ze(r.hash);
+  return Ye(r.hash);
 }
-function sr(e) {
-  const t = e.ins[je];
+function ir(e) {
+  const t = e.ins[ze];
   if (!t)
     throw new Error(
       "Artifacts file's claim_tx carries no PegIn input to bind the vault to."
     );
-  return ze(t.hash);
+  return Ye(t.hash);
 }
-function qe(e) {
-  const t = G(
-    It(e.peginTxid, e.depositorEthAddress)
-  ), r = G(e.expectedVaultId);
+function We(e) {
+  const t = X(
+    Bt(e.peginTxid, e.depositorEthAddress)
+  ), r = X(e.expectedVaultId);
   if (t !== r)
-    throw new or(r, t, e.peginTxid);
+    throw new sr(r, t, e.peginTxid);
 }
-function G(e) {
+function X(e) {
   return `0x${(e.startsWith("0x") ? e.slice(2) : e).toLowerCase()}`;
 }
-function ze(e) {
+function Ye(e) {
   return I.from(e).reverse().toString("hex");
 }
-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),
+const ur = 0, cr = 0, lr = 1, hr = 0, pr = 0;
+async function Ho(e) {
+  const { txGraphVersion: t } = e.vault, r = e.source.txGraphJson, [o, n, i, a] = await Promise.all([
     mt(t, r),
-    Pt(t, r)
+    vt(t, r),
+    Pt(t, r),
+    wt(t, r)
   ]);
-  qe({
-    peginTxid: nr(o),
+  We({
+    peginTxid: ar(o),
     depositorEthAddress: e.vault.depositorEthAddress,
     expectedVaultId: e.vault.vaultId
   });
-  const i = await vt(
+  const s = await xt(
     t,
     r
   );
-  for (const x of [a, i])
-    tr({
-      payoutPsbtBase64: x,
+  for (const w of [i, s])
+    or({
+      payoutPsbtBase64: w,
       registeredPayoutScriptPubKey: e.vault.registeredPayoutScriptPubKey
     });
-  Zt({
-    graphChallengerPubkeys: Object.keys(s),
+  tr({
+    graphChallengerPubkeys: Object.keys(a),
     depositorBtcPubkey: e.depositorPublicKey,
     vaultProviderBtcPubkey: e.vault.vaultProviderBtcPubkey,
     vaultKeeperBtcPubkeys: e.vault.vaultKeeperBtcPubkeys,
     universalChallengerBtcPubkeys: e.vault.universalChallengerBtcPubkeys
   });
   const u = [
-    { psbtBase64: o, inputIndex: ar },
-    { psbtBase64: n, inputIndex: ir },
-    { psbtBase64: a, inputIndex: ur },
+    { psbtBase64: o, inputIndex: ur },
+    { psbtBase64: n, inputIndex: cr },
+    { psbtBase64: i, inputIndex: lr },
     {
-      psbtBase64: i,
-      inputIndex: cr
+      psbtBase64: s,
+      inputIndex: hr
     }
-  ], c = Object.keys(s);
-  for (const x of c)
-    for (const w of s[x])
-      u.push({ psbtBase64: w, inputIndex: lr });
-  const h = await pr(
+  ], c = Object.keys(a);
+  for (const w of c)
+    for (const x of a[w])
+      u.push({ psbtBase64: x, inputIndex: pr });
+  const l = await gr(
     e.btcWallet,
     e.depositorPublicKey,
     e.btcNetwork,
     u
   );
-  let l = 0;
-  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;
+  let h = 0;
+  const p = l[h++], d = l[h++], g = l[h++], b = l[h++], y = {};
+  for (const w of c) {
+    const x = a[w].length;
+    y[w] = l.slice(
+      h,
+      h + x
+    ), h += x;
   }
-  const m = await wt(
+  const m = await Et(
     t,
     r,
     p
   );
-  return xt({
+  return kt({
     txGraphVersion: t,
     graphJson: r,
     signedClaimTxHex: m,
@@ -286,7 +286,7 @@ async function Oo(e) {
     expectedVaultCoreVersion: e.vault.vaultCoreVersion
   });
 }
-function me(e) {
+function Pe(e) {
   const t = e.replace(/^0x/, "").toLowerCase();
   if (t.length === 66) return t.slice(2);
   if (t.length === 64) return t;
@@ -294,62 +294,62 @@ function me(e) {
     `Public key must be 33-byte compressed or 32-byte x-only hex, got ${t.length / 2} bytes.`
   );
 }
-async function hr(e, t, r) {
+async function dr(e, t, r) {
   const o = await e.getPublicKeyHex();
-  if (me(o) !== me(t))
+  if (Pe(o) !== Pe(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 (!ut(n, t, r))
+  if (!lt(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 pr(e, t, r, o) {
-  const n = await hr(
+async function gr(e, t, r, o) {
+  const n = await dr(
     e,
     t,
     r
-  ), a = await De(
+  ), i = await Fe(
     e,
-    o.map((s) => dr(s.psbtBase64)),
+    o.map((a) => fr(a.psbtBase64)),
     o.map(
-      (s) => gt(
+      (a) => yt(
         t,
-        s.inputIndex,
+        a.inputIndex,
         n
       )
     )
   );
   return Promise.all(
-    a.map(
-      (s, i) => Et(gr(s), o[i].inputIndex)
+    i.map(
+      (a, s) => _t(yr(a), o[s].inputIndex)
     )
   );
 }
-function dr(e) {
+function fr(e) {
   return I.from(e, "base64").toString("hex");
 }
-function gr(e) {
+function yr(e) {
   return I.from(e, "hex").toString("base64");
 }
-async function No(e) {
-  const t = await St(e.btcWallet, e.vaultContext);
+async function Ko(e) {
+  const t = await Rt(e.btcWallet, e.vaultContext);
   let r;
   try {
-    r = await kt(t, e.htlcVout);
+    r = await Tt(t, e.htlcVout);
   } finally {
     t.fill(0);
   }
   let o;
   try {
-    o = await _t(r);
+    o = await $t(r);
   } finally {
     r.fill(0);
   }
-  return fr(o.pk_hash, e.expectedWotsPkHash), await Tt(
+  return br(o.pk_hash, e.expectedWotsPkHash), await Ct(
     e.txGraphVersion,
     o.keypair,
     e.txGraphJson
@@ -358,61 +358,61 @@ async function No(e) {
     pkHash: o.pk_hash
   };
 }
-function fr(e, t) {
-  if (D(e) !== D(t))
+function br(e, t) {
+  if (M(e) !== M(t))
     throw new Error(
-      `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.`
+      `Derived WOTS public-key hash ${M(e)} does not match the vault's on-chain depositorWotsPkHash ${M(t)}. The wallet, the HTLC output index, or the derivation itself is not the one this vault was created with.`
     );
 }
-function D(e) {
+function M(e) {
   return `0x${(e.startsWith("0x") ? e.slice(2) : e).toLowerCase()}`;
 }
-const yr = 3;
-class br extends Error {
+const mr = 3;
+class vr 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 mr(e) {
+function Pr(e) {
   let t;
   try {
     t = JSON.parse(e);
-  } catch (s) {
-    throw new Error("Artifacts file is not valid JSON.", { cause: s });
+  } catch (a) {
+    throw new Error("Artifacts file is not valid JSON.", { cause: a });
   }
-  const r = Pe(t.vault_id, "vault_id"), o = Pr(Pe(t.claim_tx, "claim_tx")), n = W(
+  const r = we(t.vault_id, "vault_id"), o = wr(we(t.claim_tx, "claim_tx")), n = Y(
     t.prover_circuit_version,
     "prover_circuit_version"
-  ), a = t.claimable_event_block_number === void 0 ? 0n : BigInt(
-    W(
+  ), i = t.claimable_event_block_number === void 0 ? 0n : BigInt(
+    Y(
       t.claimable_event_block_number,
       "claimable_event_block_number"
     )
   );
   return {
-    vaultCoreVersion: t.vault_core_version === void 0 ? void 0 : W(t.vault_core_version, "vault_core_version"),
+    vaultCoreVersion: t.vault_core_version === void 0 ? void 0 : Y(t.vault_core_version, "vault_core_version"),
     vaultId: r,
     claimTxid: o.getId(),
-    peginTxid: sr(o),
+    peginTxid: ir(o),
     proverCircuitVersion: n,
-    claimableEventBlockNumber: a,
+    claimableEventBlockNumber: i,
     babeSessionChallengerPubkeys: Object.keys(
-      vr(t.babe_sessions, "babe_sessions")
+      xr(t.babe_sessions, "babe_sessions")
     )
   };
 }
-async function Ho(e) {
-  const t = mr(e.artifactsJson), r = G(e.expectedVaultId), o = G(t.vaultId);
+async function Do(e) {
+  const t = Pr(e.artifactsJson), r = X(e.expectedVaultId), o = X(t.vaultId);
   if (r !== o)
-    throw new br(r, o);
-  qe({
+    throw new vr(r, o);
+  We({
     peginTxid: t.peginTxid,
     depositorEthAddress: e.depositorEthAddress,
     expectedVaultId: r
   });
-  const n = e.txGraphVersion ?? yr;
+  const n = e.txGraphVersion ?? mr;
   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}.`
@@ -421,9 +421,9 @@ async function Ho(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 $t(n, e.artifactsJson), t;
+  return await At(n, e.artifactsJson), t;
 }
-function Pr(e) {
+function wr(e) {
   try {
     return B.fromHex(e);
   } catch (t) {
@@ -432,52 +432,52 @@ function Pr(e) {
     });
   }
 }
-function Pe(e, t) {
+function we(e, t) {
   if (typeof e != "string" || e.length === 0)
     throw new Error(`Artifacts file is missing a usable "${t}".`);
   return e;
 }
-function W(e, t) {
+function Y(e, t) {
   if (typeof e != "number" || !Number.isSafeInteger(e) || e < 0)
     throw new Error(`Artifacts file is missing a usable "${t}".`);
   return e;
 }
-function vr(e, t) {
+function xr(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 wr = 8, xr = 6e3, Er = 10 * 6e4, kr = 10;
-class We extends Error {
+const Er = 8, kr = 6e3, _r = 10 * 6e4, Tr = 10;
+class Qe extends Error {
   constructor(t) {
     super(t), this.name = "PeginRegistrationMissingError";
   }
 }
-class Ye extends Error {
+class Je extends Error {
   constructor(t) {
     super(t), this.name = "PeginRegistrationNotFinalError";
   }
 }
-function _r(e) {
-  return e instanceof We || e instanceof Error && e.name === "PeginRegistrationMissingError";
+function $r(e) {
+  return e instanceof Qe || e instanceof Error && e.name === "PeginRegistrationMissingError";
 }
-function Ko(e) {
-  return e instanceof Ye || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
+function Mo(e) {
+  return e instanceof Je || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
 }
-function ve(e) {
+function xe(e) {
   const { currentBlock: t, createdAtBlock: r } = e, o = t - r + 1n;
   return o < 0n ? 0 : Number(o);
 }
-async function Do(e) {
+async function Fo(e) {
   const {
     vaultRegistryReader: t,
     getBlockNumber: r,
     vaultIds: o,
-    required: n = wr,
-    pollIntervalMs: a = xr,
-    timeoutMs: s = Er,
-    signal: i,
+    required: n = Er,
+    pollIntervalMs: i = kr,
+    timeoutMs: a = _r,
+    signal: s,
     onProgress: u
   } = e;
   if (o.length === 0)
@@ -485,51 +485,51 @@ async function Do(e) {
       "waitForPeginRegistrationDepth requires at least one vault ID"
     );
   const c = Date.now();
-  let h = !1, l = 0, p;
+  let l = !1, h = 0, p;
   for (; ; ) {
-    if (i != null && i.aborted)
+    if (s != null && s.aborted)
       throw new Error(
         `Aborted while waiting for peg-in registration depth (${o.length} vault(s))`
       );
-    if (Date.now() - c >= s)
-      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}` : "")
+    if (Date.now() - c >= a)
+      throw new Je(
+        `Peg-in registration did not reach ${n} Ethereum confirmations within ${a}ms. The registration transaction was submitted but is not yet final, so the Pre-PegIn Bitcoin transaction was never sent and no funds are at risk. Resume this deposit from the dashboard once the network settles.` + (p instanceof Error ? ` Last read error: ${p.message}` : "")
       );
     try {
       const d = await r(), g = await Promise.all(
         o.map((y) => t.getVaultBasicInfo(y))
       ), b = g.findIndex(
-        (y) => y.depositor === Rt || y.createdAt === 0n
+        (y) => y.depositor === Vt || y.createdAt === 0n
       );
       if (b !== -1) {
-        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.`
+        if (h += 1, !l && h > Tr)
+          throw new Qe(
+            `Vault ${o[b]} is still not visible on-chain after ${h} reads — the registration does not exist.`
           );
         console.warn(
           `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, p = void 0;
-        let y = g[0], m = ve({
+        l = !0, h = 0, p = void 0;
+        let y = g[0], m = xe({
           currentBlock: d,
           createdAtBlock: g[0].createdAt
         });
-        for (const x of g.slice(1)) {
-          const w = ve({
+        for (const w of g.slice(1)) {
+          const x = xe({
             currentBlock: d,
-            createdAtBlock: x.createdAt
+            createdAtBlock: w.createdAt
           });
-          w < m && (m = w, y = x);
+          x < m && (m = x, y = w);
         }
         if (u == null || u({ confirmations: m, required: n }), m >= n)
           return { confirmations: m, basicInfo: y };
       }
     } catch (d) {
-      if (_r(d))
+      if ($r(d))
         throw d;
       console.warn(
-        `Registration-depth read failed (retrying in ${a}ms): ` + (d instanceof Error ? d.message : String(d))
+        `Registration-depth read failed (retrying in ${i}ms): ` + (d instanceof Error ? d.message : String(d))
       ), p = d;
     }
     await new Promise((d, g) => {
@@ -540,14 +540,14 @@ async function Do(e) {
           )
         );
       }, y = setTimeout(() => {
-        i == null || i.removeEventListener("abort", b), d();
-      }, a);
-      i == null || i.addEventListener("abort", b, { once: !0 });
+        s == null || s.removeEventListener("abort", b), d();
+      }, i);
+      s == null || s.addEventListener("abort", b, { once: !0 });
     });
   }
 }
-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 {
+const Cr = /^(?:[0-9a-f]{2})*$/, Ar = /^[0-9a-f]{64}$/, Sr = /^([0-9a-f]{64}):(0|[1-9][0-9]*)$/, Ir = -2147483648, Rr = 2147483647, Q = 4294967295, Ee = 2, ke = 2;
+class P extends Error {
   constructor(t) {
     super(t), this.name = "GraphFingerprintError";
   }
@@ -555,264 +555,264 @@ class v extends Error {
 function E(e, t, r) {
   const o = e[t];
   if (o === void 0)
-    throw new v(`Graph tx ${r} is missing "${t}"`);
+    throw new P(`Graph tx ${r} is missing "${t}"`);
   return o;
 }
-function K(e, t) {
+function D(e, t) {
   if (!Array.isArray(e))
-    throw new v(`Graph tx ${t} is not an array`);
+    throw new P(`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`);
+    throw new P(`Graph tx ${t} is not an object`);
   return e;
 }
-function N(e, t, r, o) {
+function H(e, t, r, o) {
   if (typeof e != "number" || !Number.isSafeInteger(e) || e < r || e > o)
-    throw new v(
+    throw new P(
       `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(
+function J(e, t) {
+  if (typeof e != "string" || !Cr.test(e))
+    throw new P(
       `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(
+function q(e, t) {
+  if (typeof e != "string" || !Ar.test(e))
+    throw new P(
       `Graph ${t} is not 32 bytes of lowercase hex`
     );
   return e;
 }
-function Ee(e, t) {
+function _e(e, t) {
   const r = A(e, t), o = new B();
-  return o.version = N(
+  return o.version = H(
     E(r, "version", t),
     `${t}.version`,
-    Ar,
-    Sr
-  ), o.locktime = N(
+    Ir,
+    Rr
+  ), o.locktime = H(
     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);
+    Q
+  ), D(E(r, "input", t), `${t}.input`).forEach((n, i) => {
+    const a = `${t}.input[${i}]`, s = A(n, a), u = E(s, "previous_output", a), c = typeof u == "string" && Sr.exec(u);
     if (!c)
-      throw new v(
-        `Graph tx ${s}.previous_output is not "<txid>:<vout>"`
+      throw new P(
+        `Graph tx ${a}.previous_output is not "<txid>:<vout>"`
       );
-    const h = N(Number(c[2]), `${s}.previous_output vout`, 0, Y);
+    const l = H(Number(c[2]), `${a}.previous_output vout`, 0, Q);
     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);
+      l,
+      H(E(s, "sequence", a), `${a}.sequence`, 0, Q),
+      J(E(s, "script_sig", a), `${a}.script_sig`)
+    ), o.ins[i].witness = D(
+      E(s, "witness", a),
+      `${a}.witness`
+    ).map((h, p) => J(h, `${a}.witness[${p}]`));
+  }), D(E(r, "output", t), `${t}.output`).forEach((n, i) => {
+    const a = `${t}.output[${i}]`, s = A(n, a);
     o.addOutput(
-      Q(E(i, "script_pubkey", s), `${s}.script_pubkey`),
-      N(E(i, "value", s), `${s}.value`, 0, Number.MAX_SAFE_INTEGER)
+      J(E(s, "script_pubkey", a), `${a}.script_pubkey`),
+      H(E(s, "value", a), `${a}.value`, 0, Number.MAX_SAFE_INTEGER)
     );
   }), new Uint8Array(o.toBuffer());
 }
-function H(e, t) {
+function K(e, t) {
   const r = f(e).toLowerCase();
   let o;
   try {
     o = B.fromHex(r);
   } catch (n) {
-    throw new v(
+    throw new P(
       `Presign ${t} is not one transaction: ${n instanceof Error ? n.message : String(n)}`
     );
   }
   if (o.toHex() !== r)
-    throw new v(
+    throw new P(
       `Presign ${t} is not a canonical transaction encoding`
     );
   return o;
 }
-function Ir(e, t) {
+function Br(e, t) {
   const [r, ...o] = e.ins;
   if (!r || o.length > 0)
-    throw new v(
+    throw new P(
       `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 (n !== t || r.index !== he)
+    throw new P(
+      `Presign claim_tx must spend ${t}:${he}, got ${n}:${r.index}`
     );
-  if (e.version !== we)
-    throw new v(
-      `Presign claim_tx version must be ${we}, got ${e.version}`
+  if (e.version !== Ee)
+    throw new P(
+      `Presign claim_tx version must be ${Ee}, got ${e.version}`
     );
   if (r.witness.length > 0)
-    throw new v(
+    throw new P(
       `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}`
+  if (e.outs.length !== ke)
+    throw new P(
+      `Presign claim_tx must have exactly ${ke} outputs, got ${e.outs.length}`
     );
 }
-function Qe(e) {
+function Ze(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");
+    const i = q(o.pubkey, "challenger pubkey");
+    if (n > 0 && t[n - 1].pubkey === i)
+      throw new P(`Graph lists challenger ${i} twice`);
+    r.push(me(i), o.nopayoutTx);
+    for (const a of o.outputLabelHashes)
+      r.push(me(q(a, "output_label_hashes entry")));
+  }), Mt(Ft(Lt(...r)));
+}
+function Vr(e) {
+  const t = f(e.peginTxid).toLowerCase(), r = K(e.peginTxHex, "pegin_tx");
   if (r.getId() !== t)
-    throw new v(
+    throw new P(
       `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({
+  const o = K(e.claimTxHex, "claim_tx");
+  Br(o, t);
+  const n = (i) => new Uint8Array(i.toBuffer());
+  return Ze({
     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()
+    assertTx: n(K(e.assertTxHex, "assert_tx")),
+    payoutTx: n(K(e.payoutTxHex, "payout_tx")),
+    challengers: e.challengers.map((i) => ({
+      pubkey: C(i.challenger_pubkey),
+      nopayoutTx: n(K(i.nopayout_tx.tx_hex, "nopayout_tx")),
+      outputLabelHashes: i.output_label_hashes.map(
+        (a) => f(a).toLowerCase()
       )
     }))
   });
 }
-function Br(e) {
-  const t = (o) => Ee(A(E(e, o, "graph"), o).tx, o), r = A(
+function Or(e) {
+  const t = (o) => _e(A(E(e, o, "graph"), o).tx, o), r = A(
     E(e, "challenger_subgraphs", "graph"),
     "challenger_subgraphs"
   );
-  return Qe({
+  return Ze({
     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);
+      const i = `challenger_subgraphs[${o}]`, a = A(n, i);
       return {
         pubkey: o,
-        nopayoutTx: Ee(
-          A(E(s, "nopayout_tx", a), `${a}.nopayout_tx`).tx,
-          `${a}.nopayout_tx`
+        nopayoutTx: _e(
+          A(E(a, "nopayout_tx", i), `${i}.nopayout_tx`).tx,
+          `${i}.nopayout_tx`
         ),
-        outputLabelHashes: K(
-          E(s, "output_label_hashes", a),
-          `${a}.output_label_hashes`
+        outputLabelHashes: D(
+          E(a, "output_label_hashes", i),
+          `${i}.output_label_hashes`
         ).map(
-          (i, u) => X(i, `${a}.output_label_hashes[${u}]`)
+          (s, u) => q(s, `${i}.output_label_hashes[${u}]`)
         )
       };
     })
   });
 }
-function Vr(e) {
+function Nr(e) {
   const t = A(
     E(e, "challenger_pubkeys", "graph"),
     "challenger_pubkeys"
   ), r = /* @__PURE__ */ new Set();
   for (const o of ["local", "universal"])
-    K(
+    D(
       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`
+    ).forEach((n, i) => {
+      const a = q(n, `challenger_pubkeys.${o}[${i}]`);
+      if (r.has(a))
+        throw new P(
+          `Graph declares challenger ${a} more than once`
         );
-      r.add(s);
+      r.add(a);
     });
   return r;
 }
-function Mo(e, t) {
-  const r = Br(e);
+function Lo(e, t) {
+  const r = Or(e);
   if (r !== t)
-    throw new v(
+    throw new P(
       `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(
+  ), n = Nr(e);
+  if (o.length !== n.size || o.some((i) => !n.has(i)))
+    throw new P(
       `Graph challenger_subgraphs keys ${o.join(", ")} do not match challenger_pubkeys ${[...n].join(", ")}`
     );
 }
-const Or = 1;
-function Nr(e, t, r) {
+const Hr = 1;
+function Kr(e, t, r) {
   const o = r.map(
-    (l) => f(l).toLowerCase()
-  ), n = t.filter((l) => o.includes(l));
+    (h) => f(h).toLowerCase()
+  ), n = t.filter((h) => o.includes(h));
   if (n.length > 0)
     throw new Error(
       `Cannot validate challenger set: vault keepers and universal challengers overlap (${n.join(", ")})`
     );
-  const a = [...t, ...o], s = e.map(
-    (l) => f(l.challenger_pubkey).toLowerCase()
-  ), i = new Set(s);
-  if (i.size !== s.length)
+  const i = [...t, ...o], a = e.map(
+    (h) => f(h.challenger_pubkey).toLowerCase()
+  ), s = new Set(a);
+  if (s.size !== a.length)
     throw new Error(
       "Depositor graph contains duplicate challenger entries in challenger_presign_data"
     );
-  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)
+  const u = new Set(i), c = i.filter((h) => !s.has(h)), l = a.filter((h) => !u.has(h));
+  if (c.length > 0 || l.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(", ")})` : "")
+      "Depositor graph challenger set does not match expected (local ∪ universal)" + (c.length > 0 ? ` (missing: ${c.join(", ")})` : "") + (l.length > 0 ? ` (unexpected: ${l.join(", ")})` : "")
     );
 }
-function Hr(e, t) {
+function Dr(e, t) {
   const r = e.ins[t];
-  return Ke(new Uint8Array(r.hash).slice().reverse());
+  return Me(new Uint8Array(r.hash).slice().reverse());
 }
-function J(e, t, r, o, n) {
-  const a = e.ins[t];
-  if (a.index !== 0)
+function Z(e, t, r, o, n) {
+  const i = e.ins[t];
+  if (i.index !== 0)
     throw new Error(
-      `NoPayout (challenger ${n}) input ${t} expected to spend ${o} vout 0, got vout ${a.index}`
+      `NoPayout (challenger ${n}) input ${t} expected to spend ${o} vout 0, got vout ${i.index}`
     );
-  const s = r.getId(), i = Hr(e, t);
-  if (i !== s)
+  const a = r.getId(), s = Dr(e, t);
+  if (s !== a)
     throw new Error(
-      `NoPayout (challenger ${n}) input ${t} does not reference ${o} (expected txid ${s}, got ${i})`
+      `NoPayout (challenger ${n}) input ${t} does not reference ${o} (expected txid ${a}, got ${s})`
     );
 }
-async function Kr(e, t, r) {
-  const o = [], n = [], a = [], s = Me({
+async function Mr(e, t, r) {
+  const o = [], n = [], i = [], a = Le({
     claimerBtcPubkey: r.depositorBtcPubkey,
     depositorBtcPubkey: r.depositorBtcPubkey,
     vaultProviderBtcPubkey: r.vaultProviderBtcPubkey,
     vaultKeeperBtcPubkeys: r.vaultKeeperBtcPubkeys
   });
-  Nr(
+  Kr(
     e.challenger_presign_data,
-    s,
+    a,
     r.universalChallengerBtcPubkeys
   );
-  const i = await At({
+  const s = await It({
     vaultCoreVersion: r.vaultCoreVersion,
     vkClaimerPayoutScriptPubKeys: r.vkClaimerPayoutScriptPubKeys,
     vpCommissionScriptPubKey: r.vpCommissionScriptPubKey,
@@ -828,228 +828,233 @@ async function Kr(e, t, r) {
     network: r.network,
     claimerBtcPubkey: r.depositorBtcPubkey,
     registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
-    commissionBps: Or,
+    commissionBps: Hr,
     protocolFeeRate: r.protocolFeeRate,
     councilMembers: r.councilMembers,
     councilQuorum: r.councilQuorum
   });
-  o.push(i.psbtHex), n.push(
-    M(
+  o.push(s.psbtHex), n.push(
+    F(
       t,
-      ge
+      fe
     )
   );
   const u = f(r.depositorBtcPubkey), c = B.fromHex(
     f(e.assert_tx.tx_hex)
   );
-  for (const h of e.challenger_presign_data) {
-    const l = f(h.challenger_pubkey), p = o.length, d = await Dr({
-      challenger: h,
-      challengerPubkey: l,
+  for (const l of e.challenger_presign_data) {
+    const h = f(l.challenger_pubkey), p = o.length, d = await Fr({
+      challenger: l,
+      challengerPubkey: h,
       claimerPubkey: u,
-      localChallengers: s,
+      localChallengers: a,
       assertTxParsed: c,
       ctx: r
     });
     o.push(d), n.push(
-      M(
+      F(
         t,
-        ge
+        fe
       )
-    ), a.push({
-      challengerPubkey: l,
+    ), i.push({
+      challengerPubkey: h,
       noPayoutIdx: p
     });
   }
-  return { psbtHexes: o, signOptions: n, challengerEntries: a };
+  return { psbtHexes: o, signOptions: n, challengerEntries: i };
 }
-async function Dr(e) {
+async function Fr(e) {
   const {
     challenger: t,
     challengerPubkey: r,
     claimerPubkey: o,
     localChallengers: n,
-    assertTxParsed: a,
-    ctx: s
+    assertTxParsed: i,
+    ctx: a
   } = e;
-  Ft(
+  Ut(
     t.nopayout_tx.tx_hex,
     r,
-    s.network
+    a.network
   );
-  const i = B.fromHex(
+  const s = B.fromHex(
     f(t.nopayout_tx.tx_hex)
   ), u = B.fromHex(
     f(t.challenge_assert_x_tx.tx_hex)
   ), c = B.fromHex(
     f(t.challenge_assert_y_tx.tx_hex)
   );
-  if (i.ins.length !== 3)
+  if (s.ins.length !== 3)
     throw new Error(
-      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${i.ins.length}`
+      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${s.ins.length}`
     );
-  J(
-    i,
+  Z(
+    s,
     0,
-    a,
+    i,
     "Assert",
     r
-  ), J(
-    i,
+  ), Z(
+    s,
     1,
     u,
     "ChallengeAssertX",
     r
-  ), J(
-    i,
+  ), Z(
+    s,
     2,
     c,
     "ChallengeAssertY",
     r
   );
-  const h = [
-    a.outs[0],
+  const l = [
+    i.outs[0],
     u.outs[0],
     c.outs[0]
-  ].map((l) => ({
-    script_pubkey: Ke(new Uint8Array(l.script)),
-    value: l.value
+  ].map((h) => ({
+    script_pubkey: Me(new Uint8Array(h.script)),
+    value: h.value
   }));
-  return Ut({
+  return Gt({
     noPayoutTxHex: t.nopayout_tx.tx_hex,
     challengerPubkey: r,
-    prevouts: h,
+    prevouts: l,
     connectorParams: {
-      txGraphVersion: s.vaultCoreVersion,
+      txGraphVersion: a.vaultCoreVersion,
       claimer: o,
       localChallengers: n,
-      universalChallengers: s.universalChallengerBtcPubkeys,
-      timelockAssert: s.timelockAssert,
-      councilMembers: s.councilMembers,
-      councilQuorum: s.councilQuorum
+      universalChallengers: a.universalChallengerBtcPubkeys,
+      timelockAssert: a.timelockAssert,
+      councilMembers: a.councilMembers,
+      councilQuorum: a.councilQuorum
     }
   });
 }
-function Mr(e, t, r) {
-  F(e[0]);
+function Lr(e, t, r) {
+  L(e[0]);
   const n = U(
     e[0].returnedPsbtHex,
     r
   );
-  L({
+  G({
     requestedPsbtHex: e[0].requestedPsbtHex,
     signatureHex: n,
     signerXOnlyPubkeyHex: r,
     inputIndex: 0
   });
-  const a = {};
-  for (const s of t) {
-    F(e[s.noPayoutIdx]);
-    const i = U(
-      e[s.noPayoutIdx].returnedPsbtHex,
+  const i = {};
+  for (const a of t) {
+    L(e[a.noPayoutIdx]);
+    const s = U(
+      e[a.noPayoutIdx].returnedPsbtHex,
       r
     );
-    L({
-      requestedPsbtHex: e[s.noPayoutIdx].requestedPsbtHex,
-      signatureHex: i,
+    G({
+      requestedPsbtHex: e[a.noPayoutIdx].requestedPsbtHex,
+      signatureHex: s,
       signerXOnlyPubkeyHex: r,
       inputIndex: 0
-    }), a[s.challengerPubkey] = {
-      nopayout_signature: i
+    }), i[a.challengerPubkey] = {
+      nopayout_signature: s
     };
   }
   return {
     payout_signatures: {
       payout_signature: n
     },
-    per_challenger: a
+    per_challenger: i
   };
 }
-async function Fr(e) {
-  const { depositorGraph: t, btcWallet: r, signingContext: o } = e, n = await r.getPublicKeyHex(), { depositorPubkey: a } = ct(
+async function Ur(e) {
+  const { depositorGraph: t, btcWallet: r, signingContext: o } = e, n = await r.getPublicKeyHex(), { depositorPubkey: i } = ht(
     n,
     f(o.depositorBtcPubkey)
-  ), { psbtHexes: s, signOptions: i, challengerEntries: u } = await Kr(
+  ), { psbtHexes: a, signOptions: s, challengerEntries: u } = await Mr(
     t,
     n,
     o
-  ), c = await De(
+  ), c = await Fe(
     r,
-    s,
-    i
-  ), h = s.map((l, p) => ({
-    requestedPsbtHex: l,
+    a,
+    s
+  ), l = a.map((h, p) => ({
+    requestedPsbtHex: h,
     returnedPsbtHex: c[p]
   }));
-  return Mr(
-    h,
+  return Lr(
+    l,
     u,
-    a
+    i
   );
 }
-const Ur = 1e4;
-async function Je(e) {
+const Gr = 1e4, O = 10;
+async function et(e) {
   const {
     statusReader: t,
-    peginTxid: r,
-    targetStatuses: o,
-    timeoutMs: n,
-    pollIntervalMs: a = Ur,
+    vaultId: r,
+    peginTxid: o,
+    targetStatuses: n,
+    timeoutMs: i,
+    pollIntervalMs: a = Gr,
     signal: s
-  } = e, i = Date.now();
+  } = e, u = Date.now();
   for (; ; ) {
     if (s != null && s.aborted)
       throw new Error(
-        `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
+        `Polling aborted for vault ${r.slice(0, O)}… (target: ${[...n].join(", ")})`
       );
-    if (Date.now() - i >= n)
+    if (Date.now() - u >= i)
       throw new Error(
-        `Polling timeout after ${n}ms for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
+        `Polling timeout after ${i}ms for vault ${r.slice(0, O)}… (target: ${[...n].join(", ")})`
       );
     try {
-      const u = await t.getPeginStatus(
-        { pegin_txid: r },
+      const c = await t.getPeginStatusByVaultId(
+        { vault_id: r },
         s
       );
-      if (u.pegin_txid.toLowerCase() !== r.toLowerCase())
+      if (be(c.vault_id) !== be(r))
         throw new Error(
-          `getPeginStatus returned status for pegin ${u.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
+          `getPeginStatusByVaultId returned status for vault ${c.vault_id.slice(0, O)}…, requested ${r.slice(0, O)}…`
         );
-      const c = u.status;
-      if (o.has(c) || c === R.ACTIVATED)
-        return c;
-      if (c === R.EXPIRED || Ot.has(c))
+      if (c.pegin_txid.toLowerCase() !== o.toLowerCase())
         throw new Error(
-          `Pegin ${r.slice(0, 8)}… reached terminal status "${c}" while waiting for ${[...o].join(", ")}`
+          `getPeginStatusByVaultId returned status for pegin ${c.pegin_txid.slice(0, 8)}…, requested ${o.slice(0, 8)}…`
         );
-    } catch (u) {
-      if (!(u instanceof Nt && u.code === Ht.PEGIN_NOT_FOUND))
-        throw u;
+      const l = c.status;
+      if (n.has(l) || l === R.ACTIVATED)
+        return l;
+      if (l === R.EXPIRED || Ht.has(l))
+        throw new Error(
+          `Vault ${r.slice(0, O)}… reached terminal status "${l}" while waiting for ${[...n].join(", ")}`
+        );
+    } catch (c) {
+      if (!(c instanceof Kt && c.code === Dt.PEGIN_NOT_FOUND))
+        throw c;
     }
-    await new Promise((u, c) => {
+    await new Promise((c, l) => {
       const h = () => {
-        clearTimeout(l), c(
+        clearTimeout(p), l(
           new Error(
-            `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
+            `Polling aborted for vault ${r.slice(0, O)}… (target: ${[...n].join(", ")})`
           )
         );
-      }, l = setTimeout(() => {
-        s == null || s.removeEventListener("abort", h), u();
+      }, p = setTimeout(() => {
+        s == null || s.removeEventListener("abort", h), c();
       }, a);
       s == null || s.addEventListener("abort", h, { once: !0 });
     });
   }
 }
-const Lr = 1200 * 1e3, Ze = /* @__PURE__ */ new Set([
+const Xr = 1200 * 1e3, tt = /* @__PURE__ */ new Set([
   R.PENDING_ACKS,
   R.PENDING_ACTIVATION,
   R.ACTIVATED_PENDING_BROADCAST,
   R.ACTIVATED
-]), Gr = /* @__PURE__ */ new Set([
+]), qr = /* @__PURE__ */ new Set([
   R.PENDING_DEPOSITOR_SIGNATURES,
-  ...Ze
+  ...tt
 ]);
-function Xr(e) {
+function jr(e) {
   return e.map((t) => ({
     claimerPubkeyXOnly: j(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
@@ -1059,10 +1064,10 @@ function Xr(e) {
 function S(e) {
   return j(e).toLowerCase();
 }
-function jr(e, t) {
-  const r = (u, c, h) => {
+function zr(e, t) {
+  const r = (u, c, l) => {
     throw new Error(
-      `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.`
+      `Deposit terms ${u} (${String(c)}) does not match the vault's version-locked signing context (${String(l)}); refusing to sign payouts against terms that describe a different graph.`
     );
   }, o = [
     ["protocolFeeRate", e.protocolFeeRate, t.protocolFeeRate],
@@ -1070,17 +1075,17 @@ function jr(e, t) {
     ["timelockPegin", e.timelockPegin, t.timelockPegin],
     ["timelockAssert", e.timelockAssert, t.timelockAssert]
   ];
-  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]);
+  for (const [u, c, l] of o)
+    c !== l && r(u, c, l);
+  const n = (u) => u.map(S).sort(), i = (u, c) => {
+    const l = n(u), h = n(c);
+    return l.length === h.length && l.every((p, d) => p === h[d]);
   };
-  a(e.vaultKeeperBtcPubkeys, t.vaultKeeperBtcPubkeys) || r(
+  i(e.vaultKeeperBtcPubkeys, t.vaultKeeperBtcPubkeys) || r(
     "vaultKeeperBtcPubkeys",
     e.vaultKeeperBtcPubkeys.join(","),
     t.vaultKeeperBtcPubkeys.join(",")
-  ), a(
+  ), i(
     e.universalChallengerBtcPubkeys,
     t.universalChallengerBtcPubkeys
   ) || r(
@@ -1088,40 +1093,40 @@ function jr(e, t) {
     e.universalChallengerBtcPubkeys.join(","),
     t.universalChallengerBtcPubkeys.join(",")
   );
-  const s = S(t.vaultProviderBtcPubkey), i = e.vaults.map(
+  const a = S(t.vaultProviderBtcPubkey), s = e.vaults.map(
     (u) => S(u.vaultProviderBtcPubkey)
   );
-  i.includes(s) || r(
+  s.includes(a) || r(
     "vaults[].vaultProviderBtcPubkey",
-    i.join(",") || "<no vaults>",
+    s.join(",") || "<no vaults>",
     t.vaultProviderBtcPubkey
   );
 }
-function qr(e, t, r, o) {
-  const n = S(o), a = [
+function Wr(e, t, r, o) {
+  const n = S(o), i = [
     S(t),
     ...r.map(S)
-  ], s = new Set(a);
-  if (s.size !== a.length)
+  ], a = new Set(i);
+  if (a.size !== i.length)
     throw new Error(
       "Cannot validate claimer set: signing context contains duplicate vault provider or vault keeper key"
     );
-  if (s.has(n))
+  if (a.has(n))
     throw new Error(
       "Cannot validate claimer set: depositor key overlaps with vault provider or vault keeper set"
     );
-  const i = e.map(
+  const s = e.map(
     (p) => S(p.claimer_pubkey)
   );
-  if (new Set(i).size !== i.length)
+  if (new Set(s).size !== s.length)
     throw new Error("Presign response contains duplicate claimer entries");
-  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)
+  const u = s.filter((p) => p !== n), c = new Set(u), l = i.filter((p) => !c.has(p)), h = u.filter((p) => !a.has(p));
+  if (l.length > 0 || h.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(", ")})` : "")
+      "Presign response claimer set does not match expected (vault provider ∪ vault keepers)" + (l.length > 0 ? ` (missing: ${l.join(", ")})` : "") + (h.length > 0 ? ` (unexpected: ${h.join(", ")})` : "")
     );
 }
-function ke(e, t) {
+function Te(e, t) {
   return {
     vaultCoreVersion: t.vaultCoreVersion,
     payoutTxHex: e.payoutTxHex,
@@ -1143,96 +1148,98 @@ function ke(e, t) {
     vpCommissionScriptPubKey: t.vpCommissionScriptPubKey
   };
 }
-async function zr(e, t, r, o) {
-  const n = new pt({
+async function Yr(e, t, r, o) {
+  const n = new gt({
     network: t.network,
     btcWallet: e
-  }), a = r.length;
-  o == null || o(0, a);
-  let s;
+  }), i = r.length;
+  o == null || o(0, i);
+  let a;
   if (n.supportsBatchSigning())
-    s = (await n.signPayoutTransactionsBatch(
-      r.map((c) => ke(c, t))
+    a = (await n.signPayoutTransactionsBatch(
+      r.map((c) => Te(c, t))
     )).map((c) => c.payoutSignature);
   else {
-    s = [];
+    a = [];
     for (let u = 0; u < r.length; u++) {
-      o == null || o(u, a);
+      o == null || o(u, i);
       const c = await n.signPayoutTransaction(
-        ke(r[u], t)
+        Te(r[u], t)
       );
-      s.push(c.signature);
+      a.push(c.signature);
     }
   }
-  const i = {};
+  const s = {};
   for (let u = 0; u < r.length; u++)
-    i[r[u].claimerPubkeyXOnly] = {
-      payout_signature: s[u]
+    s[r[u].claimerPubkeyXOnly] = {
+      payout_signature: a[u]
     };
-  return o == null || o(a, a), i;
+  return o == null || o(i, i), s;
 }
-async function Fo(e) {
+async function Uo(e) {
   const {
     statusReader: t,
     presignClient: r,
     btcWallet: o,
-    peginTxid: n,
+    vaultId: n,
+    peginTxid: i,
     depositorPk: a,
     signingContext: s,
-    depositTerms: i,
-    timeoutMs: u = Lr,
-    signal: c,
+    depositTerms: u,
+    timeoutMs: c = Xr,
+    signal: l,
     onProgress: h,
-    recordGraphFingerprint: l
-  } = e, p = await Je({
+    recordGraphFingerprint: p
+  } = e, d = await et({
     statusReader: t,
-    peginTxid: n,
-    targetStatuses: Gr,
-    timeoutMs: u,
-    signal: c
+    vaultId: n,
+    peginTxid: i,
+    targetStatuses: qr,
+    timeoutMs: c,
+    signal: l
   });
-  if (Ze.has(p))
+  if (tt.has(d))
     return;
-  if (c == null || c.throwIfAborted(), i !== void 0 && jr(i, s), ht(o)) {
-    if (!i)
+  if (l == null || l.throwIfAborted(), u !== void 0 && zr(u, s), dt(o)) {
+    if (!u)
       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)."
       );
-    typeof o.validateDepositTerms == "function" && await o.validateDepositTerms(i), await o.approveDepositTerms(i);
+    typeof o.validateDepositTerms == "function" && await o.validateDepositTerms(u), await o.approveDepositTerms(u);
   }
-  const d = await r.requestDepositorPresignTransactions(
+  const g = await r.requestDepositorPresignTransactions(
     {
-      pegin_txid: n,
+      pegin_txid: i,
       depositor_pk: a
     },
-    c
+    l
   );
-  c == null || c.throwIfAborted();
-  const g = Rr({
-    peginTxid: n,
+  l == null || l.throwIfAborted();
+  const b = Vr({
+    peginTxid: i,
     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,
+    claimTxHex: g.depositor_graph.claim_tx.tx_hex,
+    assertTxHex: g.depositor_graph.assert_tx.tx_hex,
+    payoutTxHex: g.depositor_graph.payout_tx.tx_hex,
+    challengers: g.depositor_graph.challenger_presign_data
+  }), y = S(a);
+  Wr(
+    g.txs,
     s.vaultProviderBtcPubkey,
     s.vaultKeeperBtcPubkeys,
     a
   );
-  const y = d.txs.filter(
-    (_) => S(_.claimer_pubkey) !== b
-  ), m = Xr(y), x = await zr(
+  const m = g.txs.filter(
+    ($) => S($.claimer_pubkey) !== y
+  ), w = jr(m), x = await Yr(
     o,
     s,
-    m,
+    w,
     h
   );
-  c == null || c.throwIfAborted();
-  const w = await Fr({
-    depositorGraph: d.depositor_graph,
+  l == null || l.throwIfAborted();
+  const k = await Ur({
+    depositorGraph: g.depositor_graph,
     btcWallet: o,
     signingContext: {
       vaultCoreVersion: s.vaultCoreVersion,
@@ -1252,104 +1259,106 @@ async function Fo(e) {
       vpCommissionScriptPubKey: s.vpCommissionScriptPubKey
     }
   });
-  c == null || c.throwIfAborted(), await l(g), c == null || c.throwIfAborted();
-  const k = { ...x };
-  k[f(a)] = w.payout_signatures, await r.submitDepositorPresignatures(
+  l == null || l.throwIfAborted(), await p(b), l == null || l.throwIfAborted();
+  const _ = { ...x };
+  _[f(a)] = k.payout_signatures, await r.submitDepositorPresignatures(
     {
-      pegin_txid: n,
+      pegin_txid: i,
       depositor_pk: a,
-      signatures: k,
-      depositor_claimer_presignatures: w
+      signatures: _,
+      depositor_claimer_presignatures: k
     },
-    c
+    l
   );
 }
-const Wr = 300 * 1e3, Yr = /* @__PURE__ */ new Set([
+const Qr = 300 * 1e3, Jr = /* @__PURE__ */ new Set([
   R.PENDING_DEPOSITOR_WOTS_PK,
-  ...Ue
+  ...Ge
 ]);
-async function Uo(e) {
+async function Go(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
-    peginTxid: o,
-    depositorPk: n,
+    vaultId: o,
+    peginTxid: n,
+    depositorPk: i,
     wotsPublicKeys: a,
-    timeoutMs: s = Wr,
-    signal: i
+    timeoutMs: s = Qr,
+    signal: u
   } = e;
-  i == null || i.throwIfAborted();
-  const u = await Je({
+  u == null || u.throwIfAborted();
+  const c = await et({
     statusReader: t,
-    peginTxid: o,
-    targetStatuses: Yr,
+    vaultId: o,
+    peginTxid: n,
+    targetStatuses: Jr,
     timeoutMs: s,
-    signal: i
+    signal: u
   });
-  Ue.has(u) || (i == null || i.throwIfAborted(), await r.submitDepositorWotsKey(
+  Ge.has(c) || (u == null || u.throwIfAborted(), await r.submitDepositorWotsKey(
     {
-      pegin_txid: o,
-      depositor_pk: n,
+      pegin_txid: n,
+      depositor_pk: i,
       wots_public_keys: a
     },
-    i
+    u
   ));
 }
-function Z(e) {
+function ee(e) {
   return e.registration || e.operation;
 }
-function Qr(e, t, r) {
-  const o = $(e);
+function Zr(e, t, r) {
+  const o = C(e);
   return {
-    registration: o === $(t),
-    operation: o === $(r)
+    registration: o === C(t),
+    operation: o === C(r)
   };
 }
-function _e(e, t, r) {
-  const o = ee(e);
+function $e(e, t, r) {
+  const o = te(e);
   return {
-    registration: Te(o, ee(t)),
-    operation: Te(o, ee(r))
+    registration: Ce(o, te(t)),
+    operation: Ce(o, te(r))
   };
 }
-function ee(e) {
-  return e.map($).sort();
+function te(e) {
+  return e.map(C).sort();
 }
-function Te(e, t) {
+function Ce(e, t) {
   return e.length === t.length && e.every((r, o) => r === t[o]);
 }
-async function Lo(e) {
+async function Xo(e) {
   const {
     vaultProviderEthAddress: t,
     hintBtcPubkey: r,
     registrationBtcPubkey: o,
     readCurrentOperationBtcPubkey: n,
-    context: a
+    context: i
   } = e;
   if (!r) return;
-  const s = $(r);
-  if (s === $(o)) return;
-  const i = $(
+  const a = C(r);
+  if (a === C(o)) return;
+  const s = C(
     await n()
   );
-  if (s !== i)
+  if (a !== s)
     throw new Error(
-      `Vault provider BTC pubkey mismatch for ${t}: indexer hint matches neither the registration key nor the current operation key on-chain.${a ? ` ${a}` : ""}`
+      `Vault provider BTC pubkey mismatch for ${t}: indexer hint matches neither the registration key nor the current operation key on-chain.${i ? ` ${i}` : ""}`
     );
 }
-function te(e, t, r) {
-  const o = `${e} operation key (admin=${t.ethAddress})`, n = fe(
+function re(e, t, r) {
+  const o = `${e} operation key (admin=${t.ethAddress})`, n = ye(
     t.btcPubKey,
     `${e} roster key (admin=${t.ethAddress})`
-  ), a = fe(r, o);
+  ), i = ye(r, o);
   return {
     adminAddress: t.ethAddress,
     genesisBtcPubkey: n,
-    operationBtcPubkey: a,
-    rotated: a !== n
+    operationBtcPubkey: i,
+    rotated: i !== n
   };
 }
-function Jr(e) {
+function eo(e) {
   const t = /* @__PURE__ */ new Map();
   for (const r of e) {
     const o = t.get(r.operationBtcPubkey);
@@ -1360,12 +1369,12 @@ function Jr(e) {
     t.set(r.operationBtcPubkey, r.adminAddress);
   }
 }
-function et(e, t, r) {
+function rt(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 = te(
+  const o = re(
     "vault provider",
     {
       ethAddress: e.vaultProviderEthAddress,
@@ -1373,64 +1382,64 @@ function et(e, t, r) {
     },
     t.vaultProvider
   ), n = e.vaultKeepers.map(
-    (s, i) => te("vault keeper", s, t.vaultKeepers[i])
-  ), a = e.universalChallengers.map(
-    (s, i) => te("universal challenger", s, t.universalChallengers[i])
+    (a, s) => re("vault keeper", a, t.vaultKeepers[s])
+  ), i = e.universalChallengers.map(
+    (a, s) => re("universal challenger", a, t.universalChallengers[s])
   );
-  return Jr([
+  return eo([
     o,
     ...n,
-    ...a
+    ...i
   ]), {
     vaultProvider: o,
     vaultKeepers: n,
-    universalChallengers: a,
+    universalChallengers: i,
     // Derived from the pairs, never the reverse — see ParticipantKeySet.
-    vaultKeeperOperationKeysSorted: n.map((s) => s.operationBtcPubkey).sort(),
-    universalChallengerOperationKeysSorted: a.map((s) => s.operationBtcPubkey).sort(),
+    vaultKeeperOperationKeysSorted: n.map((a) => a.operationBtcPubkey).sort(),
+    universalChallengerOperationKeysSorted: i.map((a) => a.operationBtcPubkey).sort(),
     resolvedAt: r,
     query: e
   };
 }
-async function Zr(e) {
+async function to(e) {
   const t = await e.operationKeyReader.getCurrentOperationKeys(
     e.query,
     e.blockNumber
   );
-  return et(e.query, t, { mode: "current" });
+  return rt(e.query, t, { mode: "current" });
 }
-async function eo(e) {
+async function ro(e) {
   const t = await e.operationKeyReader.getOperationKeysAtEpochs(
     e.query,
     e.epochs
   );
-  return et(e.query, t, {
+  return rt(e.query, t, {
     mode: "epochs",
     epochs: e.epochs
   });
 }
-class oe extends Error {
+class ne extends Error {
   constructor(t) {
     super(t), this.name = "ApplicationEntryPointMismatchError";
   }
 }
-function Go(e) {
-  return e instanceof oe || e instanceof Error && e.name === "ApplicationEntryPointMismatchError";
+function qo(e) {
+  return e instanceof ne || e instanceof Error && e.name === "ApplicationEntryPointMismatchError";
 }
-const $e = (e) => e.map($).sort();
-async function Xo(e) {
+const Ae = (e) => e.map(C).sort();
+async function jo(e) {
   const {
     vaultRegistryReader: t,
     vaultKeeperReader: r,
     universalChallengerReader: o,
     vaultProviderEthAddress: n,
-    applicationEntryPoint: a,
-    expectedVaultProviderBtcPubkey: s,
-    expectedVaultKeeperBtcPubkeys: i,
+    applicationEntryPoint: i,
+    expectedVaultProviderBtcPubkey: a,
+    expectedVaultKeeperBtcPubkeys: s,
     expectedUniversalChallengerBtcPubkeys: u,
     operationKeyReader: c,
-    onIndexerServingOperationKeys: h,
-    onIndexerHintsInconsistent: l,
+    onIndexerServingOperationKeys: l,
+    onIndexerHintsInconsistent: h,
     blockNumber: p
   } = e, [
     d,
@@ -1449,15 +1458,15 @@ async function Xo(e) {
     o.getLatestUniversalChallengersVersion(p),
     o.getCurrentUcKeyEpoch(p)
   ]);
-  if (!Bt(a, { strict: !1 }))
-    throw new oe(
-      `The application entry point this deposit was prepared for is not a valid address: ${a}`
+  if (!Ot(i, { strict: !1 }))
+    throw new ne(
+      `The application entry point this deposit was prepared for is not a valid address: ${i}`
     );
-  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.`
+  if (!Nt(d, i))
+    throw new ne(
+      `Vault provider ${n} is registered to application ${d}, but this deposit was prepared for ${i}. Refusing to build: the vault keeper roster, its version, and the keeper key epoch would all resolve against a different application than the one selected.`
     );
-  const [m, x] = await Promise.all(
+  const [m, w] = await Promise.all(
     [
       r.getCurrentVaultKeepersVersion(
         d,
@@ -1468,7 +1477,7 @@ async function Xo(e) {
         p
       )
     ]
-  ), [w, k] = await Promise.all([
+  ), [x, k] = await Promise.all([
     r.getVaultKeepersByVersion(
       d,
       m,
@@ -1479,84 +1488,84 @@ async function Xo(e) {
       p
     )
   ]), _ = {
-    vaultProvider: $(g),
-    vaultKeepers: $e(w.map((T) => T.btcPubKey)),
-    universalChallengers: $e(k.map((T) => T.btcPubKey))
-  }, C = await Zr({
+    vaultProvider: C(g),
+    vaultKeepers: Ae(x.map((T) => T.btcPubKey)),
+    universalChallengers: Ae(k.map((T) => T.btcPubKey))
+  }, $ = await to({
     operationKeyReader: c,
     query: {
       vaultProviderEthAddress: n,
       vaultProviderGenesisBtcPubkey: `0x${g}`,
       applicationEntryPoint: d,
-      vaultKeepers: w,
+      vaultKeepers: x,
       universalChallengers: k
     },
     blockNumber: p
-  }), P = {
-    vaultProvider: C.vaultProvider.operationBtcPubkey,
-    vaultKeepers: [...C.vaultKeeperOperationKeysSorted],
+  }), v = {
+    vaultProvider: $.vaultProvider.operationBtcPubkey,
+    vaultKeepers: [...$.vaultKeeperOperationKeysSorted],
     universalChallengers: [
-      ...C.universalChallengerOperationKeysSorted
+      ...$.universalChallengerOperationKeysSorted
     ]
-  }, se = Qr(
-    s,
+  }, ae = Zr(
+    a,
     _.vaultProvider,
-    P.vaultProvider
-  ), ae = _e(
-    i,
+    v.vaultProvider
+  ), ie = $e(
+    s,
     _.vaultKeepers,
-    P.vaultKeepers
-  ), ie = _e(
+    v.vaultKeepers
+  ), ue = $e(
     u,
     _.universalChallengers,
-    P.universalChallengers
+    v.universalChallengers
   );
-  if (!Z(se))
+  if (!ee(ae))
     throw new Error(
       `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${n}. Refresh and try again.`
     );
-  if (!Z(ae))
+  if (!ee(ie))
     throw new Error(
       `Vault keeper BTC pubkeys (v${m}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
     );
-  if (!Z(ie))
+  if (!ee(ue))
     throw new Error(
       `Universal challenger BTC pubkeys (v${b}) indexer set does not match ProtocolParams on-chain set. 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 ce = [ae, ie, ue], it = ce.some((T) => T.registration && !T.operation), le = ce.some((T) => T.operation && !T.registration);
+  if (it && le) {
     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.`);
+    throw h == null || h(T), new Error(`${T} Refresh and try again.`);
   }
-  return ce && (h == null || h(
+  return le && (l == null || l(
     `Indexer is serving rotated operation keys for vault provider ${n}`
   )), {
-    vaultProviderBtcPubkeyXOnly: P.vaultProvider,
-    vaultKeeperBtcPubkeysSorted: P.vaultKeepers,
-    universalChallengerBtcPubkeysSorted: P.universalChallengers,
+    vaultProviderBtcPubkeyXOnly: v.vaultProvider,
+    vaultKeeperBtcPubkeysSorted: v.vaultKeepers,
+    universalChallengerBtcPubkeysSorted: v.universalChallengers,
     expectedAppVaultKeepersVersion: m,
     expectedUniversalChallengersVersion: b,
-    appKeeperKeyEpoch: x,
+    appKeeperKeyEpoch: w,
     ucKeyEpoch: y,
     registrationKeys: _,
-    participantKeys: C
+    participantKeys: $
   };
 }
-function to(e) {
+function oo(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function jo(e) {
+function zo(e) {
   const {
     amountSats: t,
     minDeposit: r,
     maxDeposit: o,
     btcBalance: n,
-    estimatedFeeSats: a,
-    depositorClaimValue: s
+    estimatedFeeSats: i,
+    depositorClaimValue: a
   } = e;
-  return !(t <= 0n || t < r || o && o > 0n && t > o || a == null || s == null || t + a + s > n);
+  return !(t <= 0n || t < r || o && o > 0n && t > o || i == null || a == null || t + i + a > n);
 }
-function qo(e, t, r) {
+function Wo(e, t, r) {
   return e <= 0n ? {
     valid: !1,
     error: "Deposit amount must be greater than zero"
@@ -1568,7 +1577,7 @@ function qo(e, t, r) {
     error: `Maximum deposit is ${V(r)} BTC`
   } : { valid: !0 };
 }
-function zo(e) {
+function Yo(e) {
   const { amount: t, effectiveRemaining: r } = e;
   return r === null ? { valid: !0 } : r === 0n ? {
     valid: !1,
@@ -1578,7 +1587,7 @@ function zo(e) {
     error: `Vault size exceeds remaining capacity (${V(r)} BTC)`
   } : { valid: !0 };
 }
-function Wo(e, t) {
+function Qo(e, t) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -1594,7 +1603,7 @@ function Wo(e, t) {
     error: "Invalid vault provider selected"
   } : { valid: !0 };
 }
-function ro(e, t, r) {
+function no(e, t, r) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -1620,167 +1629,167 @@ function ro(e, t, r) {
   }
   return { valid: !0 };
 }
-function oo(e) {
+function so(e) {
   const t = f(e);
-  return to(t) ? { valid: !0 } : {
+  return oo(t) ? { valid: !0 } : {
     valid: !1,
     error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
   };
 }
-function no(e) {
+function ao(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 so(e) {
+function io(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 ao(e) {
+function uo(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function Yo(e) {
+function Jo(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
     vaultProviderBtcPubkey: o,
     vaultKeeperBtcPubkeys: n,
-    universalChallengerBtcPubkeys: a,
-    minDeposit: s,
-    maxDeposit: i
-  } = e, u = ro(
+    universalChallengerBtcPubkeys: i,
+    minDeposit: a,
+    maxDeposit: s
+  } = e, u = no(
     t,
-    s,
-    i
+    a,
+    s
   );
   if (!u.valid)
     throw new Error(u.error);
-  const c = oo(o);
+  const c = so(o);
   if (!c.valid)
     throw new Error(c.error);
-  no(n), so(a), ao(r);
+  ao(n), io(i), uo(r);
 }
-class tt extends Error {
+class ot extends Error {
   constructor(t) {
     super(t), this.name = "ParticipantKeyDriftError";
   }
 }
-function Qo(e) {
-  return e instanceof tt || e instanceof Error && e.name === "ParticipantKeyDriftError";
+function Zo(e) {
+  return e instanceof ot || e instanceof Error && e.name === "ParticipantKeyDriftError";
 }
-function Ce(e, t, r) {
+function Se(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 Jo(e) {
-  const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: o, expected: n } = e, a = n.query;
+async function en(e) {
+  const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: o, expected: n } = e, i = n.query;
   if (o.length === 0) return;
-  const s = await t.getVaultKeyEpochsBatch(o), i = [];
-  for (const [u, c] of s.entries()) {
-    const h = o[u];
-    let l;
+  const a = await t.getVaultKeyEpochsBatch(o), s = [];
+  for (const [u, c] of a.entries()) {
+    const l = o[u];
+    let h;
     try {
-      l = await eo({
+      h = await ro({
         operationKeyReader: r,
-        query: a,
+        query: i,
         epochs: c
       });
     } catch (g) {
-      i.push(
-        `vault ${h}: could not resolve participants at frozen epochs (vp=${c.vpKeyEpoch}, keeper=${c.appKeeperKeyEpoch}, uc=${c.ucKeyEpoch}): ${g.message}`
+      s.push(
+        `vault ${l}: could not resolve participants at frozen epochs (vp=${c.vpKeyEpoch}, keeper=${c.appKeeperKeyEpoch}, uc=${c.ucKeyEpoch}): ${g.message}`
       );
       continue;
     }
-    l.vaultProvider.operationBtcPubkey !== n.vaultProvider.operationBtcPubkey && i.push(
-      `vault ${h}: vault provider key expected ${n.vaultProvider.operationBtcPubkey}, got ${l.vaultProvider.operationBtcPubkey}`
+    h.vaultProvider.operationBtcPubkey !== n.vaultProvider.operationBtcPubkey && s.push(
+      `vault ${l}: vault provider key expected ${n.vaultProvider.operationBtcPubkey}, got ${h.vaultProvider.operationBtcPubkey}`
     );
-    const p = Ce(
-      `vault ${h}: vault keeper keys`,
+    const p = Se(
+      `vault ${l}: vault keeper keys`,
       n.vaultKeeperOperationKeysSorted,
-      l.vaultKeeperOperationKeysSorted
+      h.vaultKeeperOperationKeysSorted
     );
-    p && i.push(p);
-    const d = Ce(
-      `vault ${h}: universal challenger keys`,
+    p && s.push(p);
+    const d = Se(
+      `vault ${l}: universal challenger keys`,
       n.universalChallengerOperationKeysSorted,
-      l.universalChallengerOperationKeysSorted
+      h.universalChallengerOperationKeysSorted
     );
-    d && i.push(d);
+    d && s.push(d);
   }
-  if (i.length > 0)
-    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.`
+  if (s.length > 0)
+    throw new ot(
+      `Aborting BTC broadcast: participant operation keys changed during registration (${s.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-class rt extends Error {
+class nt extends Error {
   constructor(t) {
     super(t), this.name = "RegisteredVaultVersionMismatchError";
   }
 }
-function Zo(e) {
-  return e instanceof rt || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
+function tn(e) {
+  return e instanceof nt || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function en(e) {
+async function rn(e) {
   const {
     vaultRegistryReader: t,
     vaultIds: r,
     expectedOffchainParamsVersion: o,
     expectedAppVaultKeepersVersion: n,
-    expectedUniversalChallengersVersion: a,
-    expectedVaultCoreVersion: s
-  } = e, i = await t.getProtocolInfoBatch(r), u = [];
-  if (i.forEach((c, h) => {
-    const l = r[h];
+    expectedUniversalChallengersVersion: i,
+    expectedVaultCoreVersion: a
+  } = e, s = await t.getProtocolInfoBatch(r), u = [];
+  if (s.forEach((c, l) => {
+    const h = r[l];
     c.offchainParamsVersion !== o && u.push(
-      `vault ${l}: offchainParams expected v${o}, got v${c.offchainParamsVersion}`
+      `vault ${h}: offchainParams expected v${o}, got v${c.offchainParamsVersion}`
     ), c.appVaultKeepersVersion !== n && u.push(
-      `vault ${l}: appVaultKeepers expected v${n}, got v${c.appVaultKeepersVersion}`
-    ), 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}`
+      `vault ${h}: appVaultKeepers expected v${n}, got v${c.appVaultKeepersVersion}`
+    ), c.universalChallengersVersion !== i && u.push(
+      `vault ${h}: universalChallengers expected v${i}, got v${c.universalChallengersVersion}`
+    ), c.vaultCoreVersion !== a && u.push(
+      `vault ${h}: vaultCoreVersion expected v${a} (build-time active), got v${c.vaultCoreVersion}`
     );
   }), u.length > 0)
-    throw new rt(
+    throw new nt(
       `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${u.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-class io extends Error {
+class co extends Error {
   constructor(r, o) {
     super(`Refund not yet mature (BIP68 not final): ${o.message}`);
-    O(this, "vaultId");
-    O(this, "cause");
+    N(this, "vaultId");
+    N(this, "cause");
     this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = o;
   }
 }
-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) {
+const lo = /^0x[0-9a-fA-F]{64}$/, ho = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, st = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, at = 160, Ie = 2e3, Re = 10n, Be = 100n;
+function on(e) {
   if (!Number.isFinite(e) || e <= 0)
     throw new Error(
       `feeRateSatsVb must be a positive finite number, got ${e}`
     );
-  return BigInt(Math.ceil(e * nt));
+  return BigInt(Math.ceil(e * at));
 }
-const lo = 1, ho = /non-BIP68-final/i;
-function ne(e, t) {
+const po = 1, go = /non-BIP68-final/i;
+function se(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 (!uo.test(e))
+  if (!lo.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function re(e, t) {
+function oe(e, t) {
   if (!Number.isInteger(e) || e < 0)
     throw new Error(`${t} must be a non-negative integer, got ${e}`);
 }
-function po(e) {
-  if (ne(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
+function fo(e) {
+  if (se(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
     throw new Error(
       `htlcVout must be a non-negative integer, got ${e.htlcVout}`
     );
@@ -1792,7 +1801,7 @@ function po(e) {
     );
   for (let r = 0; r < e.batch.length; r++) {
     const o = e.batch[r];
-    if (ne(o.hashlock, `batch[${r}].hashlock`), !Number.isInteger(o.htlcVout) || o.htlcVout !== r)
+    if (se(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}`
       );
@@ -1810,27 +1819,27 @@ function po(e) {
     throw new Error(
       `batch[${e.htlcVout}].amount (${t.amount}) does not match target amount (${e.amount})`
     );
-  if (re(e.offchainParamsVersion, "offchainParamsVersion"), re(e.appVaultKeepersVersion, "appVaultKeepersVersion"), re(
+  if (oe(e.offchainParamsVersion, "offchainParamsVersion"), oe(e.appVaultKeepersVersion, "appVaultKeepersVersion"), oe(
     e.universalChallengersVersion,
     "universalChallengersVersion"
-  ), jt(
+  ), zt(
     e.vaultCoreVersion,
     "VaultRefundData.vaultCoreVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
     throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!co.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 || !ot.test(e.depositorBtcPubkey))
+  if (!e.depositorBtcPubkey || !st.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 go(e) {
-  if (!e.vaultProviderPubkey || !ot.test(e.vaultProviderPubkey))
+function yo(e) {
+  if (!e.vaultProviderPubkey || !st.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");
@@ -1855,35 +1864,35 @@ function go(e) {
       `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
     );
 }
-async function rn(e) {
+async function nn(e) {
   const {
     vaultId: t,
     readVault: r,
     readPrePeginContext: o,
     feeRate: n,
-    signPsbt: a,
-    broadcastTx: s,
-    signal: i
+    signPsbt: i,
+    broadcastTx: a,
+    signal: s
   } = e;
-  i == null || i.throwIfAborted(), ne(t, "vaultId");
+  s == null || s.throwIfAborted(), se(t, "vaultId");
   const u = await r();
-  po(u), i == null || i.throwIfAborted();
+  fo(u), s == null || s.throwIfAborted();
   const c = await o(u);
-  if (go(c), i == null || i.throwIfAborted(), !Number.isFinite(n) || n <= 0)
+  if (yo(c), s == null || s.throwIfAborted(), !Number.isFinite(n) || n <= 0)
     throw new Error(`feeRate must be a positive number, got ${n}`);
-  if (n > Ae)
+  if (n > Ie)
     throw new Error(
-      `feeRate ${n} sat/vB exceeds refund safety cap ${Ae} sat/vB; refusing to sign refund.`
+      `feeRate ${n} sat/vB exceeds refund safety cap ${Ie} sat/vB; refusing to sign refund.`
     );
-  const h = BigInt(Math.ceil(n * nt)), l = u.amount * Se / Ie;
-  if (h > l)
+  const l = BigInt(Math.ceil(n * at)), h = u.amount * Re / Be;
+  if (l > h)
     throw new Error(
-      `Refund fee ${h} sats exceeds the per-vault safety cap of ${l} sats (${Se}/${Ie} of vault.amount=${u.amount}); refusing to sign refund.`
+      `Refund fee ${l} sats exceeds the per-vault safety cap of ${h} sats (${Re}/${Be} of vault.amount=${u.amount}); refusing to sign refund.`
     );
-  i == null || i.throwIfAborted();
+  s == null || s.throwIfAborted();
   const p = j(
     u.depositorBtcPubkey
-  ), d = f(u.unsignedPrePeginTxHex), g = dt(d);
+  ), d = f(u.unsignedPrePeginTxHex), g = ft(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 (${u.batch.length} HTLC outputs expect the anchor at vout ${u.batch.length}). Refund refused — sibling HTLC vector is incomplete.`
@@ -1892,23 +1901,23 @@ async function rn(e) {
   let y;
   try {
     y = B.fromHex(d);
-  } catch (P) {
+  } catch (v) {
     throw new Error(
-      `Failed to parse funded Pre-PegIn transaction hex: ${P instanceof Error ? P.message : String(P)}`
+      `Failed to parse funded Pre-PegIn transaction hex: ${v instanceof Error ? v.message : String(v)}`
     );
   }
   if (y.outs.length < u.batch.length)
     throw new Error(
       `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: m } = await Lt({
+  const { psbtHex: m } = await Xt({
     prePeginParams: {
       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)),
+      hashlocks: u.batch.map((v) => f(v.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
@@ -1916,7 +1925,7 @@ async function rn(e) {
       // HTLC output. `buildRefundPsbt`'s value cross-check then binds the result
       // to the funded tx bytes, refusing the refund if the template's HTLC value
       // disagrees with the on-chain commitment.
-      pegInAmounts: u.batch.map((P) => P.amount),
+      pegInAmounts: u.batch.map((v) => v.amount),
       feeRate: c.feeRate,
       minPeginFeeRate: c.minPeginFeeRate,
       numLocalChallengers: c.numLocalChallengers,
@@ -1927,88 +1936,88 @@ async function rn(e) {
     },
     fundedPrePeginTxHex: d,
     htlcVout: u.htlcVout,
-    refundFee: h,
+    refundFee: l,
     // 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: f(u.hashlock)
   });
-  i == null || i.throwIfAborted();
-  const x = M(
+  s == null || s.throwIfAborted();
+  const w = F(
     u.depositorBtcPubkey,
-    lo
-  ), w = await a(m, x);
-  F({
+    po
+  ), x = await i(m, w);
+  L({
     requestedPsbtHex: m,
-    returnedPsbtHex: w
+    returnedPsbtHex: x
   });
   const k = 0, _ = U(
-    w,
+    x,
     p,
     k
   );
-  L({
+  G({
     requestedPsbtHex: m,
     signatureHex: _,
     signerXOnlyPubkeyHex: p,
     inputIndex: k
   });
-  const C = Le({
+  const $ = Xe({
     requestedPsbtHex: m,
     signaturesHex: [_],
     signerXOnlyPubkeyHex: p
   });
-  i == null || i.throwIfAborted();
+  s == null || s.throwIfAborted();
   try {
-    return await s(C);
-  } catch (P) {
-    throw P instanceof Error && ho.test(P.message) ? new io(t, P) : P;
+    return await a($);
+  } catch (v) {
+    throw v instanceof Error && go.test(v.message) ? new co(t, v) : v;
   }
 }
-class Re extends Error {
+class Ve extends Error {
   constructor(r, o, n) {
     super(r);
     /** Fee the reclaim would have paid, in satoshis. */
-    O(this, "feeSats");
+    N(this, "feeSats");
     /** Sum of the reserves the reclaim would have swept, in satoshis. */
-    O(this, "sweptTotalSats");
+    N(this, "sweptTotalSats");
     this.name = "ReclaimUneconomicalError", this.feeSats = o, this.sweptTotalSats = n;
   }
 }
-const Be = 2e3, Ve = 25n, Oe = 100n, on = 10n;
-async function fo(e, t, r) {
+const Oe = 2e3, Ne = 25n, He = 100n, sn = 10n;
+async function bo(e, t, r) {
   for (let o = 0; o < e.length; o++) {
-    const n = ft(e[o].depositorSignedPeginTxHex), a = He(
-      await Ct(
+    const n = bt(e[o].depositorSignedPeginTxHex), i = De(
+      await St(
         f(n),
         f(r)
       )
     ).toLowerCase();
-    if (a !== t[o].toLowerCase())
+    if (i !== t[o].toLowerCase())
       throw new Error(
-        `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.`
+        `Reserve ${o} belongs to vault ${i}, 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 nn(e) {
+async function an(e) {
   const {
     vaultIds: t,
     depositorEthAddress: r,
     depositorBtcPubkey: o,
     readVaults: n,
-    feeRate: a,
-    signPsbt: s,
-    broadcastTx: i,
+    feeRate: i,
+    signPsbt: a,
+    broadcastTx: s,
     signal: u
   } = e;
   if (u == null || u.throwIfAborted(), t.length === 0)
     throw new Error("Reclaim requires at least one vault id; got none.");
-  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.`,
+  if (!Number.isFinite(i) || i <= 0)
+    throw new Error(`feeRate must be a positive number, got ${i}`);
+  if (i > Oe)
+    throw new Ve(
+      `Fee rate ${i} sat/vB exceeds the reclaim safety cap of ${Oe} sat/vB; refusing to sign.`,
       0n,
       0n
     );
@@ -2017,114 +2026,114 @@ async function nn(e) {
     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 fo(c, t, r), u == null || u.throwIfAborted();
-  const h = j(o), l = c.map((k) => ({
+  await bo(c, t, r), u == null || u.throwIfAborted();
+  const l = j(o), h = 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;
+  })), p = qt(i, h.length), d = h.reduce((k, _) => k + _.expectedValue, 0n), g = d * Ne / He;
   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.`,
+    throw new Ve(
+      `Reclaim fee ${p} sats exceeds ${Ne}/${He} 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
     );
   u == null || u.throwIfAborted();
-  const { psbtHex: b } = Xt({
-    depositorPubkey: h,
-    inputs: l,
+  const { psbtHex: b } = jt({
+    depositorPubkey: l,
+    inputs: h,
     feeSats: p
   });
   u == null || u.throwIfAborted();
-  const y = M(
+  const y = F(
     o,
-    l.length
-  ), m = await s(b, y);
-  F({
+    h.length
+  ), m = await a(b, y);
+  L({
     requestedPsbtHex: b,
     returnedPsbtHex: m
   });
-  const x = l.map((k, _) => {
-    const C = U(
+  const w = h.map((k, _) => {
+    const $ = U(
       m,
-      h,
+      l,
       _
     );
-    return L({
+    return G({
       requestedPsbtHex: b,
-      signatureHex: C,
-      signerXOnlyPubkeyHex: h,
+      signatureHex: $,
+      signerXOnlyPubkeyHex: l,
       inputIndex: _
-    }), C;
-  }), w = Le({
+    }), $;
+  }), x = Xe({
     requestedPsbtHex: b,
-    signaturesHex: x,
-    signerXOnlyPubkeyHex: h
+    signaturesHex: w,
+    signerXOnlyPubkeyHex: l
   });
-  return u == null || u.throwIfAborted(), i(w);
+  return u == null || u.throwIfAborted(), s(x);
 }
 export {
-  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
+  Re as $,
+  vr as A,
+  Qo as B,
+  er as C,
+  mr as D,
+  Yo as E,
+  no as F,
+  P as G,
+  so as H,
+  ot as I,
+  Zo as J,
+  en as K,
+  tn as L,
+  rn as M,
+  et as N,
+  Xo as O,
+  rr as P,
+  ee as Q,
+  nt as R,
+  Zr as S,
+  $e as T,
+  to as U,
+  sr as V,
+  ro as W,
+  co as X,
+  nn as Y,
+  on as Z,
+  Be as _,
+  Oo as a,
+  Ie as a0,
+  at as a1,
+  Ve as a2,
+  an as a3,
+  He as a4,
+  Ne as a5,
+  Oe as a6,
+  sn as a7,
+  No as b,
+  Ho as c,
+  Ko as d,
+  Do as e,
+  tr as f,
+  or as g,
+  We as h,
+  Er as i,
+  Qe as j,
+  Je as k,
+  $r as l,
+  Mo as m,
+  Lo as n,
+  Or as o,
+  Ur as p,
+  Go as q,
+  Uo as r,
+  Pr as s,
+  ne as t,
+  qo as u,
+  jo as v,
+  Fo as w,
+  zo as x,
+  Wo as y,
+  Jo as z
 };
-//# sourceMappingURL=buildAndBroadcastReclaim-T5ZFPUpM.js.map
+//# sourceMappingURL=buildAndBroadcastReclaim-C55KaRJF.js.map