@babylonlabs-io/ts-sdk 0.60.0 → 0.62.0

package/dist/{buildAndBroadcastRefund-CoPc7UHA.js → buildAndBroadcastRefund-CH2awK6h.js}

@@ -1,49 +1,50 @@
-var ge = Object.defineProperty;
-var fe = (e, t, r) => t in e ? ge(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var A = (e, t, r) => fe(e, typeof t != "symbol" ? t + "" : t, r);
-import { B as te } from "./BTCVaultRegistry.abi-B3BLhpJ4.js";
-import { e as ve, v as ye, s as d, u as re, p as L, c as k, f as C } from "./bitcoin-d9eaaZB_.js";
-import { v as Pe, b as me, s as be, P as we, d as ke } from "./signPsbtsWithFallback-eY1YgV13.js";
-import { D as E, c as xe, b as Ee, R as Ce, d as ne } from "./json-rpc-client-DuUARJvV.js";
-import { Transaction as $, Psbt as Te } from "bitcoinjs-lib";
-import { c as Se, d as N, e as D, f as F } from "./verifyScriptPathSchnorrSignature-Bav08_7R.js";
-import { c as $e, a as _e, b as Be } from "./noPayout-DuE-UyhQ.js";
+var Pe = Object.defineProperty;
+var me = (e, t, r) => t in e ? Pe(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var $ = (e, t, r) => me(e, typeof t != "symbol" ? t + "" : t, r);
+import { B as re } from "./BTCVaultRegistry.abi-B3BLhpJ4.js";
+import { e as ye, v as be, s as f, u as ne, p as U, c as x, f as C } from "./bitcoin-d9eaaZB_.js";
+import { v as we, d as ke, s as Ee, P as xe, a as Te } from "./signPsbtsWithFallback-DC4rUCsy.js";
+import { zeroAddress as Ce } from "viem";
+import { D as T, c as Se, b as Ae, R as Re, d as oe } from "./json-rpc-client-DuUARJvV.js";
+import { Transaction as A, Psbt as _e } from "bitcoinjs-lib";
+import { c as $e, d as H, e as D, f as F } from "./verifyScriptPathSchnorrSignature-XsICweGG.js";
+import { c as Be, a as Ie, b as Ve } from "./noPayout-oaUVsEjk.js";
 import { c as M } from "./signing-DaLvGwQe.js";
 import { a as X } from "./onChainBtcPubkey-DeF4cKoO.js";
-import { a as Ae } from "./constants-GjWXdaqV.js";
-const Re = /^0x[0-9a-fA-F]{64}$/, Ve = /^0x[0-9a-fA-F]{40}$/, Ke = /^0x([0-9a-fA-F]{2})*$/;
-function R(e, t) {
+import { a as Ke } from "./constants-GjWXdaqV.js";
+const Ne = /^0x[0-9a-fA-F]{64}$/, Oe = /^0x[0-9a-fA-F]{40}$/, He = /^0x([0-9a-fA-F]{2})*$/;
+function B(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 (!Re.test(e))
+  if (!Ne.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function Ie(e, t) {
-  if (!Ve.test(e))
+function De(e, t) {
+  if (!Oe.test(e))
     throw new Error(
       `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
     );
 }
-function Oe(e, t) {
-  if (!Ke.test(e))
+function Fe(e, t) {
+  if (!He.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
 }
-function oe(e) {
-  Ie(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), R(e.vaultId, "vaultId");
-  const t = ve(e.secret);
-  if (R(t, "secret"), e.hashlock !== void 0 && (R(e.hashlock, "hashlock"), !Pe(t, e.hashlock)))
+function ae(e) {
+  De(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), B(e.vaultId, "vaultId");
+  const t = ye(e.secret);
+  if (B(t, "secret"), e.hashlock !== void 0 && (B(e.hashlock, "hashlock"), !we(t, e.hashlock)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
   return t;
 }
-async function Bt(e) {
+async function Ft(e) {
   const {
     btcVaultRegistryAddress: t,
     vaultId: r,
@@ -53,23 +54,23 @@ async function Bt(e) {
     signal: o
   } = e;
   o == null || o.throwIfAborted();
-  const s = oe({
+  const s = ae({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
     hashlock: n
   });
-  return Oe(a, "activationMetadata"), l({
+  return Fe(a, "activationMetadata"), l({
     address: t,
-    abi: te,
+    abi: re,
     functionName: "activateVaultWithSecret",
     args: [r, s, a]
   });
 }
-async function At(e) {
+async function Mt(e) {
   const { btcVaultRegistryAddress: t, vaultId: r, hashlock: n, writeContract: a, signal: l } = e;
   l == null || l.throwIfAborted();
-  const o = oe({
+  const o = ae({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
@@ -77,14 +78,112 @@ async function At(e) {
   });
   return a({
     address: t,
-    abi: te,
+    abi: re,
     functionName: "activateVaultWithSecretAndRedeem",
     args: [r, o]
   });
 }
-const G = 1, He = 1;
-function Ne(e, t) {
-  const r = d(t).toLowerCase(), a = e.map((l) => d(l).toLowerCase()).filter((l) => l !== r);
+const Me = 8, Le = 6e3, Ue = 10 * 6e4, ze = 10;
+class se extends Error {
+  constructor(t) {
+    super(t), this.name = "PeginRegistrationMissingError";
+  }
+}
+class ie extends Error {
+  constructor(t) {
+    super(t), this.name = "PeginRegistrationNotFinalError";
+  }
+}
+function Xe(e) {
+  return e instanceof se || e instanceof Error && e.name === "PeginRegistrationMissingError";
+}
+function Lt(e) {
+  return e instanceof ie || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
+}
+function G(e) {
+  const { currentBlock: t, createdAtBlock: r } = e, n = t - r + 1n;
+  return n < 0n ? 0 : Number(n);
+}
+async function Ut(e) {
+  const {
+    vaultRegistryReader: t,
+    getBlockNumber: r,
+    vaultIds: n,
+    required: a = Me,
+    pollIntervalMs: l = Le,
+    timeoutMs: o = Ue,
+    signal: s,
+    onProgress: i
+  } = e;
+  if (n.length === 0)
+    throw new Error(
+      "waitForPeginRegistrationDepth requires at least one vault ID"
+    );
+  const u = Date.now();
+  let h = !1, c = 0, p;
+  for (; ; ) {
+    if (s != null && s.aborted)
+      throw new Error(
+        `Aborted while waiting for peg-in registration depth (${n.length} vault(s))`
+      );
+    if (Date.now() - u >= o)
+      throw new ie(
+        `Peg-in registration did not reach ${a} Ethereum confirmations within ${o}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(
+        n.map((v) => t.getVaultBasicInfo(v))
+      ), b = g.findIndex(
+        (v) => v.depositor === Ce || v.createdAt === 0n
+      );
+      if (b !== -1) {
+        if (c += 1, !h && c > ze)
+          throw new se(
+            `Vault ${n[b]} is still not visible on-chain after ${c} reads — the registration does not exist.`
+          );
+        console.warn(
+          `Peg-in registration for vault ${n[b]} is not visible in chain state at block ${d} — a lagging RPC backend or an Ethereum reorg. Still polling.`
+        ), i == null || i({ confirmations: 0, required: a });
+      } else {
+        h = !0, c = 0, p = void 0;
+        let v = g[0], P = G({
+          currentBlock: d,
+          createdAtBlock: g[0].createdAt
+        });
+        for (const w of g.slice(1)) {
+          const m = G({
+            currentBlock: d,
+            createdAtBlock: w.createdAt
+          });
+          m < P && (P = m, v = w);
+        }
+        if (i == null || i({ confirmations: P, required: a }), P >= a)
+          return { confirmations: P, basicInfo: v };
+      }
+    } catch (d) {
+      if (Xe(d))
+        throw d;
+      console.warn(
+        `Registration-depth read failed (retrying in ${l}ms): ` + (d instanceof Error ? d.message : String(d))
+      ), p = d;
+    }
+    await new Promise((d, g) => {
+      const b = () => {
+        clearTimeout(v), g(
+          new Error(
+            `Aborted while waiting for peg-in registration depth (${n.length} vault(s))`
+          )
+        );
+      }, v = setTimeout(() => {
+        s == null || s.removeEventListener("abort", b), d();
+      }, l);
+      s == null || s.addEventListener("abort", b, { once: !0 });
+    });
+  }
+}
+const j = 1, Ge = 1;
+function je(e, t) {
+  const r = f(t).toLowerCase(), a = e.map((l) => f(l).toLowerCase()).filter((l) => l !== r);
   if (a.length === 0)
     throw new Error(
       "Cannot derive localChallengers: vault keeper set is empty (or contains only the depositor)"
@@ -95,54 +194,54 @@ function Ne(e, t) {
     );
   return a;
 }
-function De(e, t, r) {
+function qe(e, t, r) {
   const n = r.map(
-    (c) => d(c).toLowerCase()
+    (c) => f(c).toLowerCase()
   ), a = t.filter((c) => n.includes(c));
   if (a.length > 0)
     throw new Error(
       `Cannot validate challenger set: vault keepers and universal challengers overlap (${a.join(", ")})`
     );
   const l = [...t, ...n], o = e.map(
-    (c) => d(c.challenger_pubkey).toLowerCase()
+    (c) => f(c.challenger_pubkey).toLowerCase()
   ), s = new Set(o);
   if (s.size !== o.length)
     throw new Error(
       "Depositor graph contains duplicate challenger entries in challenger_presign_data"
     );
-  const u = new Set(l), i = l.filter((c) => !s.has(c)), p = o.filter((c) => !u.has(c));
-  if (i.length > 0 || p.length > 0)
+  const i = new Set(l), u = l.filter((c) => !s.has(c)), h = o.filter((c) => !i.has(c));
+  if (u.length > 0 || h.length > 0)
     throw new Error(
-      "Depositor graph challenger set does not match expected (local ∪ universal)" + (i.length > 0 ? ` (missing: ${i.join(", ")})` : "") + (p.length > 0 ? ` (unexpected: ${p.join(", ")})` : "")
+      "Depositor graph challenger set does not match expected (local ∪ universal)" + (u.length > 0 ? ` (missing: ${u.join(", ")})` : "") + (h.length > 0 ? ` (unexpected: ${h.join(", ")})` : "")
     );
 }
-function Fe(e, t) {
+function Qe(e, t) {
   const r = e.ins[t];
-  return re(new Uint8Array(r.hash).slice().reverse());
+  return ne(new Uint8Array(r.hash).slice().reverse());
 }
-function V(e, t, r, n, a) {
+function I(e, t, r, n, a) {
   const l = e.ins[t];
   if (l.index !== 0)
     throw new Error(
       `NoPayout (challenger ${a}) input ${t} expected to spend ${n} vout 0, got vout ${l.index}`
     );
-  const o = r.getId(), s = Fe(e, t);
+  const o = r.getId(), s = Qe(e, t);
   if (s !== o)
     throw new Error(
       `NoPayout (challenger ${a}) input ${t} does not reference ${n} (expected txid ${o}, got ${s})`
     );
 }
-async function Me(e, t, r) {
-  const n = [], a = [], l = [], o = Ne(
+async function We(e, t, r) {
+  const n = [], a = [], l = [], o = je(
     r.vaultKeeperBtcPubkeys,
     r.depositorBtcPubkey
   );
-  De(
+  qe(
     e.challenger_presign_data,
     o,
     r.universalChallengerBtcPubkeys
   );
-  const s = await Se({
+  const s = await $e({
     vaultCoreVersion: r.vaultCoreVersion,
     vkClaimerPayoutScriptPubKeys: r.vkClaimerPayoutScriptPubKeys,
     vpCommissionScriptPubKey: r.vpCommissionScriptPubKey,
@@ -158,41 +257,41 @@ async function Me(e, t, r) {
     network: r.network,
     claimerBtcPubkey: r.depositorBtcPubkey,
     registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
-    commissionBps: He,
+    commissionBps: Ge,
     protocolFeeRate: r.protocolFeeRate,
     councilSize: r.councilMembers.length
   });
   n.push(s.psbtHex), a.push(
     M(
       t,
-      G
+      j
     )
   );
-  const u = d(r.depositorBtcPubkey), i = $.fromHex(
-    d(e.assert_tx.tx_hex)
+  const i = f(r.depositorBtcPubkey), u = A.fromHex(
+    f(e.assert_tx.tx_hex)
   );
-  for (const p of e.challenger_presign_data) {
-    const c = d(p.challenger_pubkey), h = n.length, g = await Ue({
-      challenger: p,
+  for (const h of e.challenger_presign_data) {
+    const c = f(h.challenger_pubkey), p = n.length, d = await Ye({
+      challenger: h,
       challengerPubkey: c,
-      claimerPubkey: u,
+      claimerPubkey: i,
       localChallengers: o,
-      assertTxParsed: i,
+      assertTxParsed: u,
       ctx: r
     });
-    n.push(g), a.push(
+    n.push(d), a.push(
       M(
         t,
-        G
+        j
       )
     ), l.push({
       challengerPubkey: c,
-      noPayoutIdx: h
+      noPayoutIdx: p
     });
   }
   return { psbtHexes: n, signOptions: a, challengerEntries: l };
 }
-async function Ue(e) {
+async function Ye(e) {
   const {
     challenger: t,
     challengerPubkey: r,
@@ -201,53 +300,53 @@ async function Ue(e) {
     assertTxParsed: l,
     ctx: o
   } = e;
-  $e(
+  Be(
     t.nopayout_tx.tx_hex,
     r,
     o.network
   );
-  const s = $.fromHex(
-    d(t.nopayout_tx.tx_hex)
-  ), u = $.fromHex(
-    d(t.challenge_assert_x_tx.tx_hex)
-  ), i = $.fromHex(
-    d(t.challenge_assert_y_tx.tx_hex)
+  const s = A.fromHex(
+    f(t.nopayout_tx.tx_hex)
+  ), i = A.fromHex(
+    f(t.challenge_assert_x_tx.tx_hex)
+  ), u = A.fromHex(
+    f(t.challenge_assert_y_tx.tx_hex)
   );
   if (s.ins.length !== 3)
     throw new Error(
       `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${s.ins.length}`
     );
-  V(
+  I(
     s,
     0,
     l,
     "Assert",
     r
-  ), V(
+  ), I(
     s,
     1,
-    u,
+    i,
     "ChallengeAssertX",
     r
-  ), V(
+  ), I(
     s,
     2,
-    i,
+    u,
     "ChallengeAssertY",
     r
   );
-  const p = [
+  const h = [
     l.outs[0],
-    u.outs[0],
-    i.outs[0]
+    i.outs[0],
+    u.outs[0]
   ].map((c) => ({
-    script_pubkey: re(new Uint8Array(c.script)),
+    script_pubkey: ne(new Uint8Array(c.script)),
     value: c.value
   }));
-  return _e({
+  return Ie({
     noPayoutTxHex: t.nopayout_tx.tx_hex,
     challengerPubkey: r,
-    prevouts: p,
+    prevouts: h,
     connectorParams: {
       txGraphVersion: o.vaultCoreVersion,
       claimer: n,
@@ -259,8 +358,8 @@ async function Ue(e) {
     }
   });
 }
-function Le(e, t, r) {
-  N(e[0]);
+function Je(e, t, r) {
+  H(e[0]);
   const a = D(
     e[0].returnedPsbtHex,
     r
@@ -273,7 +372,7 @@ function Le(e, t, r) {
   });
   const l = {};
   for (const o of t) {
-    N(e[o.noPayoutIdx]);
+    H(e[o.noPayoutIdx]);
     const s = D(
       e[o.noPayoutIdx].returnedPsbtHex,
       r
@@ -294,36 +393,36 @@ function Le(e, t, r) {
     per_challenger: l
   };
 }
-async function ze(e) {
-  const { depositorGraph: t, btcWallet: r, signingContext: n } = e, a = await r.getPublicKeyHex(), { depositorPubkey: l } = ye(
+async function Ze(e) {
+  const { depositorGraph: t, btcWallet: r, signingContext: n } = e, a = await r.getPublicKeyHex(), { depositorPubkey: l } = be(
     a,
-    d(n.depositorBtcPubkey)
-  ), { psbtHexes: o, signOptions: s, challengerEntries: u } = await Me(
+    f(n.depositorBtcPubkey)
+  ), { psbtHexes: o, signOptions: s, challengerEntries: i } = await We(
     t,
     a,
     n
-  ), i = await me(
+  ), u = await ke(
     r,
     o,
     s
-  ), p = o.map((c, h) => ({
+  ), h = o.map((c, p) => ({
     requestedPsbtHex: c,
-    returnedPsbtHex: i[h]
+    returnedPsbtHex: u[p]
   }));
-  return Le(
-    p,
-    u,
+  return Je(
+    h,
+    i,
     l
   );
 }
-const Xe = 1e4;
-async function ae(e) {
+const et = 1e4;
+async function ue(e) {
   const {
     statusReader: t,
     peginTxid: r,
     targetStatuses: n,
     timeoutMs: a,
-    pollIntervalMs: l = Xe,
+    pollIntervalMs: l = et,
     signal: o
   } = e, s = Date.now();
   for (; ; ) {
@@ -336,62 +435,62 @@ async function ae(e) {
         `Polling timeout after ${a}ms for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
       );
     try {
-      const u = await t.getPeginStatus(
+      const i = await t.getPeginStatus(
         { pegin_txid: r },
         o
       );
-      if (u.pegin_txid.toLowerCase() !== r.toLowerCase())
+      if (i.pegin_txid.toLowerCase() !== r.toLowerCase())
         throw new Error(
-          `getPeginStatus returned status for pegin ${u.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
+          `getPeginStatus returned status for pegin ${i.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
         );
-      const i = u.status;
-      if (n.has(i) || i === E.ACTIVATED)
-        return i;
-      if (i === E.EXPIRED || xe.has(i))
+      const u = i.status;
+      if (n.has(u) || u === T.ACTIVATED)
+        return u;
+      if (u === T.EXPIRED || Se.has(u))
         throw new Error(
-          `Pegin ${r.slice(0, 8)}… reached terminal status "${i}" while waiting for ${[...n].join(", ")}`
+          `Pegin ${r.slice(0, 8)}… reached terminal status "${u}" while waiting for ${[...n].join(", ")}`
         );
-    } catch (u) {
-      if (!(u instanceof Ee && u.code === Ce.PEGIN_NOT_FOUND))
-        throw u;
+    } catch (i) {
+      if (!(i instanceof Ae && i.code === Re.PEGIN_NOT_FOUND))
+        throw i;
     }
-    await new Promise((u, i) => {
-      const p = () => {
-        clearTimeout(c), i(
+    await new Promise((i, u) => {
+      const h = () => {
+        clearTimeout(c), u(
           new Error(
             `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
           )
         );
       }, c = setTimeout(() => {
-        o == null || o.removeEventListener("abort", p), u();
+        o == null || o.removeEventListener("abort", h), i();
       }, l);
-      o == null || o.addEventListener("abort", p, { once: !0 });
+      o == null || o.addEventListener("abort", h, { once: !0 });
     });
   }
 }
-const Ge = 1200 * 1e3, se = /* @__PURE__ */ new Set([
-  E.PENDING_ACKS,
-  E.PENDING_ACTIVATION,
-  E.ACTIVATED_PENDING_BROADCAST,
-  E.ACTIVATED
-]), je = /* @__PURE__ */ new Set([
-  E.PENDING_DEPOSITOR_SIGNATURES,
-  ...se
+const tt = 1200 * 1e3, le = /* @__PURE__ */ new Set([
+  T.PENDING_ACKS,
+  T.PENDING_ACTIVATION,
+  T.ACTIVATED_PENDING_BROADCAST,
+  T.ACTIVATED
+]), rt = /* @__PURE__ */ new Set([
+  T.PENDING_DEPOSITOR_SIGNATURES,
+  ...le
 ]);
-function qe(e) {
+function nt(e) {
   return e.map((t) => ({
-    claimerPubkeyXOnly: L(t.claimer_pubkey),
+    claimerPubkeyXOnly: U(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
     assertTxHex: t.assert_tx.tx_hex
   }));
 }
-function w(e) {
-  return L(e).toLowerCase();
+function E(e) {
+  return U(e).toLowerCase();
 }
-function Qe(e, t) {
-  const r = (u, i, p) => {
+function ot(e, t) {
+  const r = (i, u, h) => {
     throw new Error(
-      `Deposit terms ${u} (${String(i)}) does not match the vault's version-locked signing context (${String(p)}); refusing to sign payouts against terms that describe a different graph.`
+      `Deposit terms ${i} (${String(u)}) does not match the vault's version-locked signing context (${String(h)}); refusing to sign payouts against terms that describe a different graph.`
     );
   }, n = [
     ["protocolFeeRate", e.protocolFeeRate, t.protocolFeeRate],
@@ -399,11 +498,11 @@ function Qe(e, t) {
     ["timelockPegin", e.timelockPegin, t.timelockPegin],
     ["timelockAssert", e.timelockAssert, t.timelockAssert]
   ];
-  for (const [u, i, p] of n)
-    i !== p && r(u, i, p);
-  const a = (u) => u.map(w).sort(), l = (u, i) => {
-    const p = a(u), c = a(i);
-    return p.length === c.length && p.every((h, g) => h === c[g]);
+  for (const [i, u, h] of n)
+    u !== h && r(i, u, h);
+  const a = (i) => i.map(E).sort(), l = (i, u) => {
+    const h = a(i), c = a(u);
+    return h.length === c.length && h.every((p, d) => p === c[d]);
   };
   l(e.vaultKeeperBtcPubkeys, t.vaultKeeperBtcPubkeys) || r(
     "vaultKeeperBtcPubkeys",
@@ -417,8 +516,8 @@ function Qe(e, t) {
     e.universalChallengerBtcPubkeys.join(","),
     t.universalChallengerBtcPubkeys.join(",")
   );
-  const o = w(t.vaultProviderBtcPubkey), s = e.vaults.map(
-    (u) => w(u.vaultProviderBtcPubkey)
+  const o = E(t.vaultProviderBtcPubkey), s = e.vaults.map(
+    (i) => E(i.vaultProviderBtcPubkey)
   );
   s.includes(o) || r(
     "vaults[].vaultProviderBtcPubkey",
@@ -426,10 +525,10 @@ function Qe(e, t) {
     t.vaultProviderBtcPubkey
   );
 }
-function We(e, t, r, n) {
-  const a = w(n), l = [
-    w(t),
-    ...r.map(w)
+function at(e, t, r, n) {
+  const a = E(n), l = [
+    E(t),
+    ...r.map(E)
   ], o = new Set(l);
   if (o.size !== l.length)
     throw new Error(
@@ -440,17 +539,17 @@ function We(e, t, r, n) {
       "Cannot validate claimer set: depositor key overlaps with vault provider or vault keeper set"
     );
   const s = e.map(
-    (h) => w(h.claimer_pubkey)
+    (p) => E(p.claimer_pubkey)
   );
   if (new Set(s).size !== s.length)
     throw new Error("Presign response contains duplicate claimer entries");
-  const u = s.filter((h) => h !== a), i = new Set(u), p = l.filter((h) => !i.has(h)), c = u.filter((h) => !o.has(h));
-  if (p.length > 0 || c.length > 0)
+  const i = s.filter((p) => p !== a), u = new Set(i), h = l.filter((p) => !u.has(p)), c = i.filter((p) => !o.has(p));
+  if (h.length > 0 || c.length > 0)
     throw new Error(
-      "Presign response claimer set does not match expected (vault provider ∪ vault keepers)" + (p.length > 0 ? ` (missing: ${p.join(", ")})` : "") + (c.length > 0 ? ` (unexpected: ${c.join(", ")})` : "")
+      "Presign response claimer set does not match expected (vault provider ∪ vault keepers)" + (h.length > 0 ? ` (missing: ${h.join(", ")})` : "") + (c.length > 0 ? ` (unexpected: ${c.join(", ")})` : "")
     );
 }
-function j(e, t) {
+function q(e, t) {
   return {
     vaultCoreVersion: t.vaultCoreVersion,
     payoutTxHex: e.payoutTxHex,
@@ -471,8 +570,8 @@ function j(e, t) {
     vpCommissionScriptPubKey: t.vpCommissionScriptPubKey
   };
 }
-async function Ye(e, t, r, n) {
-  const a = new we({
+async function st(e, t, r, n) {
+  const a = new xe({
     network: t.network,
     btcWallet: e
   }), l = r.length;
@@ -480,26 +579,26 @@ async function Ye(e, t, r, n) {
   let o;
   if (a.supportsBatchSigning())
     o = (await a.signPayoutTransactionsBatch(
-      r.map((i) => j(i, t))
-    )).map((i) => i.payoutSignature);
+      r.map((u) => q(u, t))
+    )).map((u) => u.payoutSignature);
   else {
     o = [];
-    for (let u = 0; u < r.length; u++) {
-      n == null || n(u, l);
-      const i = await a.signPayoutTransaction(
-        j(r[u], t)
+    for (let i = 0; i < r.length; i++) {
+      n == null || n(i, l);
+      const u = await a.signPayoutTransaction(
+        q(r[i], t)
       );
-      o.push(i.signature);
+      o.push(u.signature);
     }
   }
   const s = {};
-  for (let u = 0; u < r.length; u++)
-    s[r[u].claimerPubkeyXOnly] = {
-      payout_signature: o[u]
+  for (let i = 0; i < r.length; i++)
+    s[r[i].claimerPubkeyXOnly] = {
+      payout_signature: o[i]
     };
   return n == null || n(l, l), s;
 }
-async function Rt(e) {
+async function zt(e) {
   const {
     statusReader: t,
     presignClient: r,
@@ -508,51 +607,51 @@ async function Rt(e) {
     depositorPk: l,
     signingContext: o,
     depositTerms: s,
-    timeoutMs: u = Ge,
-    signal: i,
-    onProgress: p
-  } = e, c = await ae({
+    timeoutMs: i = tt,
+    signal: u,
+    onProgress: h
+  } = e, c = await ue({
     statusReader: t,
     peginTxid: a,
-    targetStatuses: je,
-    timeoutMs: u,
-    signal: i
+    targetStatuses: rt,
+    timeoutMs: i,
+    signal: u
   });
-  if (se.has(c))
+  if (le.has(c))
     return;
-  if (i == null || i.throwIfAborted(), s !== void 0 && Qe(s, o), be(n)) {
+  if (u == null || u.throwIfAborted(), s !== void 0 && ot(s, o), Ee(n)) {
     if (!s)
       throw new Error(
         "runDepositorPresignFlow: this wallet requires approved deposit terms but none were provided. Fresh deposits must pass PreparePeginResult.depositTerms; resume-path rebuild is not wired yet."
       );
     await n.approveDepositTerms(s);
   }
-  const h = await r.requestDepositorPresignTransactions(
+  const p = await r.requestDepositorPresignTransactions(
     {
       pegin_txid: a,
       depositor_pk: l
     },
-    i
+    u
   );
-  i == null || i.throwIfAborted();
-  const g = w(l);
-  We(
-    h.txs,
+  u == null || u.throwIfAborted();
+  const d = E(l);
+  at(
+    p.txs,
     o.vaultProviderBtcPubkey,
     o.vaultKeeperBtcPubkeys,
     l
   );
-  const v = h.txs.filter(
-    (y) => w(y.claimer_pubkey) !== g
-  ), T = qe(v), x = await Ye(
+  const g = p.txs.filter(
+    (m) => E(m.claimer_pubkey) !== d
+  ), b = nt(g), v = await st(
     n,
     o,
-    T,
-    p
+    b,
+    h
   );
-  i == null || i.throwIfAborted();
-  const m = await ze({
-    depositorGraph: h.depositor_graph,
+  u == null || u.throwIfAborted();
+  const P = await Ze({
+    depositorGraph: p.depositor_graph,
     btcWallet: n,
     signingContext: {
       vaultCoreVersion: o.vaultCoreVersion,
@@ -572,41 +671,41 @@ async function Rt(e) {
       vpCommissionScriptPubKey: o.vpCommissionScriptPubKey
     }
   });
-  i == null || i.throwIfAborted();
-  const b = { ...x };
-  b[d(l)] = m.payout_signatures, await r.submitDepositorPresignatures(
+  u == null || u.throwIfAborted();
+  const w = { ...v };
+  w[f(l)] = P.payout_signatures, await r.submitDepositorPresignatures(
     {
       pegin_txid: a,
       depositor_pk: l,
-      signatures: b,
-      depositor_claimer_presignatures: m
+      signatures: w,
+      depositor_claimer_presignatures: P
     },
-    i
+    u
   );
 }
-const Je = 300 * 1e3, Ze = /* @__PURE__ */ new Set([
-  E.PENDING_DEPOSITOR_WOTS_PK,
-  ...ne
+const it = 300 * 1e3, ut = /* @__PURE__ */ new Set([
+  T.PENDING_DEPOSITOR_WOTS_PK,
+  ...oe
 ]);
-async function Vt(e) {
+async function Xt(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
     peginTxid: n,
     depositorPk: a,
     wotsPublicKeys: l,
-    timeoutMs: o = Je,
+    timeoutMs: o = it,
     signal: s
   } = e;
   s == null || s.throwIfAborted();
-  const u = await ae({
+  const i = await ue({
     statusReader: t,
     peginTxid: n,
-    targetStatuses: Ze,
+    targetStatuses: ut,
     timeoutMs: o,
     signal: s
   });
-  ne.has(u) || (s == null || s.throwIfAborted(), await r.submitDepositorWotsKey(
+  oe.has(i) || (s == null || s.throwIfAborted(), await r.submitDepositorWotsKey(
     {
       pegin_txid: n,
       depositor_pk: a,
@@ -615,30 +714,30 @@ async function Vt(e) {
     s
   ));
 }
-function K(e) {
+function V(e) {
   return e.registration || e.operation;
 }
-function et(e, t, r) {
-  const n = k(e);
+function lt(e, t, r) {
+  const n = x(e);
   return {
-    registration: n === k(t),
-    operation: n === k(r)
+    registration: n === x(t),
+    operation: n === x(r)
   };
 }
-function q(e, t, r) {
-  const n = I(e);
+function Q(e, t, r) {
+  const n = K(e);
   return {
-    registration: Q(n, I(t)),
-    operation: Q(n, I(r))
+    registration: W(n, K(t)),
+    operation: W(n, K(r))
   };
 }
-function I(e) {
-  return e.map(k).sort();
+function K(e) {
+  return e.map(x).sort();
 }
-function Q(e, t) {
+function W(e, t) {
   return e.length === t.length && e.every((r, n) => r === t[n]);
 }
-async function Kt(e) {
+async function Gt(e) {
   const {
     vaultProviderEthAddress: t,
     hintBtcPubkey: r,
@@ -647,9 +746,9 @@ async function Kt(e) {
     context: l
   } = e;
   if (!r) return;
-  const o = k(r);
-  if (o === k(n)) return;
-  const s = k(
+  const o = x(r);
+  if (o === x(n)) return;
+  const s = x(
     await a()
   );
   if (o !== s)
@@ -657,7 +756,7 @@ async function Kt(e) {
       `Vault provider BTC pubkey mismatch for ${t}: indexer hint matches neither the registration key nor the current operation key on-chain.${l ? ` ${l}` : ""}`
     );
 }
-function O(e, t, r) {
+function N(e, t, r) {
   const n = `${e} operation key (admin=${t.ethAddress})`, a = X(
     t.btcPubKey,
     `${e} roster key (admin=${t.ethAddress})`
@@ -669,7 +768,7 @@ function O(e, t, r) {
     rotated: l !== a
   };
 }
-function tt(e) {
+function ct(e) {
   const t = /* @__PURE__ */ new Map();
   for (const r of e) {
     const n = t.get(r.operationBtcPubkey);
@@ -680,12 +779,12 @@ function tt(e) {
     t.set(r.operationBtcPubkey, r.adminAddress);
   }
 }
-function ie(e, t, r) {
+function ce(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 n = O(
+  const n = N(
     "vault provider",
     {
       ethAddress: e.vaultProviderEthAddress,
@@ -693,11 +792,11 @@ function ie(e, t, r) {
     },
     t.vaultProvider
   ), a = e.vaultKeepers.map(
-    (o, s) => O("vault keeper", o, t.vaultKeepers[s])
+    (o, s) => N("vault keeper", o, t.vaultKeepers[s])
   ), l = e.universalChallengers.map(
-    (o, s) => O("universal challenger", o, t.universalChallengers[s])
+    (o, s) => N("universal challenger", o, t.universalChallengers[s])
   );
-  return tt([
+  return ct([
     n,
     ...a,
     ...l
@@ -712,24 +811,24 @@ function ie(e, t, r) {
     query: e
   };
 }
-async function rt(e) {
+async function ht(e) {
   const t = await e.operationKeyReader.getCurrentOperationKeys(
     e.query
   );
-  return ie(e.query, t, { mode: "current" });
+  return ce(e.query, t, { mode: "current" });
 }
-async function nt(e) {
+async function pt(e) {
   const t = await e.operationKeyReader.getOperationKeysAtEpochs(
     e.query,
     e.epochs
   );
-  return ie(e.query, t, {
+  return ce(e.query, t, {
     mode: "epochs",
     epochs: e.epochs
   });
 }
-const W = (e) => e.map(k).sort();
-async function It(e) {
+const Y = (e) => e.map(x).sort();
+async function jt(e) {
   const {
     vaultRegistryReader: t,
     vaultKeeperReader: r,
@@ -738,93 +837,93 @@ async function It(e) {
     applicationEntryPoint: l,
     expectedVaultProviderBtcPubkey: o,
     expectedVaultKeeperBtcPubkeys: s,
-    expectedUniversalChallengerBtcPubkeys: u,
-    operationKeyReader: i,
-    onIndexerServingOperationKeys: p,
+    expectedUniversalChallengerBtcPubkeys: i,
+    operationKeyReader: u,
+    onIndexerServingOperationKeys: h,
     onIndexerHintsInconsistent: c
   } = e, [
-    h,
-    g,
-    v
+    p,
+    d,
+    g
   ] = await Promise.all([
     t.getVaultProviderGenesisBtcPubKey(
       a
     ),
     r.getCurrentVaultKeepersVersion(l),
     n.getLatestUniversalChallengersVersion()
-  ]), [T, x] = await Promise.all([
+  ]), [b, v] = await Promise.all([
     r.getVaultKeepersByVersion(
       l,
-      g
+      d
     ),
     n.getUniversalChallengersByVersion(
-      v
+      g
     )
-  ]), m = {
-    vaultProvider: k(h),
-    vaultKeepers: W(T.map((P) => P.btcPubKey)),
-    universalChallengers: W(x.map((P) => P.btcPubKey))
-  }, b = await rt({
-    operationKeyReader: i,
+  ]), P = {
+    vaultProvider: x(p),
+    vaultKeepers: Y(b.map((k) => k.btcPubKey)),
+    universalChallengers: Y(v.map((k) => k.btcPubKey))
+  }, w = await ht({
+    operationKeyReader: u,
     query: {
       vaultProviderEthAddress: a,
-      vaultProviderGenesisBtcPubkey: `0x${h}`,
+      vaultProviderGenesisBtcPubkey: `0x${p}`,
       applicationEntryPoint: l,
-      vaultKeepers: T,
-      universalChallengers: x
+      vaultKeepers: b,
+      universalChallengers: v
     }
-  }), y = {
-    vaultProvider: b.vaultProvider.operationBtcPubkey,
-    vaultKeepers: [...b.vaultKeeperOperationKeysSorted],
+  }), m = {
+    vaultProvider: w.vaultProvider.operationBtcPubkey,
+    vaultKeepers: [...w.vaultKeeperOperationKeysSorted],
     universalChallengers: [
-      ...b.universalChallengerOperationKeysSorted
+      ...w.universalChallengerOperationKeysSorted
     ]
-  }, S = et(
+  }, S = lt(
     o,
-    m.vaultProvider,
-    y.vaultProvider
-  ), _ = q(
+    P.vaultProvider,
+    m.vaultProvider
+  ), R = Q(
     s,
-    m.vaultKeepers,
-    y.vaultKeepers
-  ), B = q(
-    u,
-    m.universalChallengers,
-    y.universalChallengers
+    P.vaultKeepers,
+    m.vaultKeepers
+  ), _ = Q(
+    i,
+    P.universalChallengers,
+    m.universalChallengers
   );
-  if (!K(S))
+  if (!V(S))
     throw new Error(
       `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${a}. Refresh and try again.`
     );
-  if (!K(_))
+  if (!V(R))
     throw new Error(
-      `Vault keeper BTC pubkeys (v${g}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
+      `Vault keeper BTC pubkeys (v${d}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
     );
-  if (!K(B))
+  if (!V(_))
     throw new Error(
-      `Universal challenger BTC pubkeys (v${v}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
+      `Universal challenger BTC pubkeys (v${g}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
     );
-  const f = [S, _, B], de = f.some((P) => P.registration && !P.operation), z = f.some((P) => P.operation && !P.registration);
-  if (de && z) {
-    const P = `Indexer participant hints are internally inconsistent for vault provider ${a}: some roles match the registration keys while others match the rotated operation keys.`;
-    throw c == null || c(P), new Error(`${P} Refresh and try again.`);
+  const y = [S, R, _], ve = y.some((k) => k.registration && !k.operation), z = y.some((k) => k.operation && !k.registration);
+  if (ve && z) {
+    const k = `Indexer participant hints are internally inconsistent for vault provider ${a}: some roles match the registration keys while others match the rotated operation keys.`;
+    throw c == null || c(k), new Error(`${k} Refresh and try again.`);
   }
-  return z && (p == null || p(
+  return z && (h == null || h(
     `Indexer is serving rotated operation keys for vault provider ${a}`
   )), {
-    vaultProviderBtcPubkeyXOnly: y.vaultProvider,
-    vaultKeeperBtcPubkeysSorted: y.vaultKeepers,
-    universalChallengerBtcPubkeysSorted: y.universalChallengers,
-    expectedAppVaultKeepersVersion: g,
-    expectedUniversalChallengersVersion: v,
-    registrationKeys: m,
-    participantKeys: b
+    vaultProviderBtcPubkeyXOnly: m.vaultProvider,
+    vaultKeeperBtcPubkeysSorted: m.vaultKeepers,
+    universalChallengerBtcPubkeysSorted: m.universalChallengers,
+    expectedAppVaultKeepersVersion: d,
+    expectedUniversalChallengersVersion: g,
+    registrationKeys: P,
+    participantKeys: w
   };
 }
-function ot(e) {
+function dt(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function Ot(e) {
+function qt(e) {
   const {
     amountSats: t,
     minDeposit: r,
@@ -835,7 +934,7 @@ function Ot(e) {
   } = e;
   return !(t <= 0n || t < r || n && n > 0n && t > n || l == null || o == null || t + l + o > a);
 }
-function Ht(e, t, r) {
+function Qt(e, t, r) {
   return e <= 0n ? {
     valid: !1,
     error: "Deposit amount must be greater than zero"
@@ -847,7 +946,7 @@ function Ht(e, t, r) {
     error: `Maximum deposit is ${C(r)} BTC`
   } : { valid: !0 };
 }
-function Nt(e) {
+function Wt(e) {
   const { amount: t, effectiveRemaining: r } = e;
   return r === null ? { valid: !0 } : r === 0n ? {
     valid: !1,
@@ -857,7 +956,7 @@ function Nt(e) {
     error: `Vault size exceeds remaining capacity (${C(r)} BTC)`
   } : { valid: !0 };
 }
-function Dt(e, t) {
+function Yt(e, t) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -873,7 +972,7 @@ function Dt(e, t) {
     error: "Invalid vault provider selected"
   } : { valid: !0 };
 }
-function at(e, t, r) {
+function gt(e, t, r) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -899,30 +998,30 @@ function at(e, t, r) {
   }
   return { valid: !0 };
 }
-function st(e) {
-  const t = d(e);
-  return ot(t) ? { valid: !0 } : {
+function ft(e) {
+  const t = f(e);
+  return dt(t) ? { valid: !0 } : {
     valid: !1,
     error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
   };
 }
-function it(e) {
+function vt(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 ut(e) {
+function Pt(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 lt(e) {
+function mt(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function Ft(e) {
+function Jt(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
@@ -931,78 +1030,78 @@ function Ft(e) {
     universalChallengerBtcPubkeys: l,
     minDeposit: o,
     maxDeposit: s
-  } = e, u = at(
+  } = e, i = gt(
     t,
     o,
     s
   );
-  if (!u.valid)
-    throw new Error(u.error);
-  const i = st(n);
   if (!i.valid)
     throw new Error(i.error);
-  it(a), ut(l), lt(r);
+  const u = ft(n);
+  if (!u.valid)
+    throw new Error(u.error);
+  vt(a), Pt(l), mt(r);
 }
-class ue extends Error {
+class he extends Error {
   constructor(t) {
     super(t), this.name = "ParticipantKeyDriftError";
   }
 }
-function Mt(e) {
-  return e instanceof ue || e instanceof Error && e.name === "ParticipantKeyDriftError";
+function Zt(e) {
+  return e instanceof he || e instanceof Error && e.name === "ParticipantKeyDriftError";
 }
-function Y(e, t, r) {
+function J(e, t, r) {
   return t.length === r.length && t.every((n, a) => n === r[a]) ? null : `${e} expected [${t.join(", ")}], got [${r.join(", ")}]`;
 }
-async function Ut(e) {
+async function er(e) {
   const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: n, expected: a } = e, l = a.query;
   if (n.length === 0) return;
   const o = await t.getVaultKeyEpochsBatch(n), s = [];
-  for (const [u, i] of o.entries()) {
-    const p = n[u];
+  for (const [i, u] of o.entries()) {
+    const h = n[i];
     let c;
     try {
-      c = await nt({
+      c = await pt({
         operationKeyReader: r,
         query: l,
-        epochs: i
+        epochs: u
       });
-    } catch (v) {
+    } catch (g) {
       s.push(
-        `vault ${p}: could not resolve participants at frozen epochs (vp=${i.vpKeyEpoch}, keeper=${i.appKeeperKeyEpoch}, uc=${i.ucKeyEpoch}): ${v.message}`
+        `vault ${h}: could not resolve participants at frozen epochs (vp=${u.vpKeyEpoch}, keeper=${u.appKeeperKeyEpoch}, uc=${u.ucKeyEpoch}): ${g.message}`
       );
       continue;
     }
     c.vaultProvider.operationBtcPubkey !== a.vaultProvider.operationBtcPubkey && s.push(
-      `vault ${p}: vault provider key expected ${a.vaultProvider.operationBtcPubkey}, got ${c.vaultProvider.operationBtcPubkey}`
+      `vault ${h}: vault provider key expected ${a.vaultProvider.operationBtcPubkey}, got ${c.vaultProvider.operationBtcPubkey}`
     );
-    const h = Y(
-      `vault ${p}: vault keeper keys`,
+    const p = J(
+      `vault ${h}: vault keeper keys`,
       a.vaultKeeperOperationKeysSorted,
       c.vaultKeeperOperationKeysSorted
     );
-    h && s.push(h);
-    const g = Y(
-      `vault ${p}: universal challenger keys`,
+    p && s.push(p);
+    const d = J(
+      `vault ${h}: universal challenger keys`,
       a.universalChallengerOperationKeysSorted,
       c.universalChallengerOperationKeysSorted
     );
-    g && s.push(g);
+    d && s.push(d);
   }
   if (s.length > 0)
-    throw new ue(
+    throw new he(
       `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 le extends Error {
+class pe extends Error {
   constructor(t) {
     super(t), this.name = "RegisteredVaultVersionMismatchError";
   }
 }
-function Lt(e) {
-  return e instanceof le || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
+function tr(e) {
+  return e instanceof pe || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function zt(e) {
+async function rr(e) {
   const {
     vaultRegistryReader: t,
     vaultIds: r,
@@ -1010,70 +1109,70 @@ async function zt(e) {
     expectedAppVaultKeepersVersion: a,
     expectedUniversalChallengersVersion: l,
     expectedVaultCoreVersion: o
-  } = e, s = await t.getProtocolInfoBatch(r), u = [];
-  if (s.forEach((i, p) => {
-    const c = r[p];
-    i.offchainParamsVersion !== n && u.push(
-      `vault ${c}: offchainParams expected v${n}, got v${i.offchainParamsVersion}`
-    ), i.appVaultKeepersVersion !== a && u.push(
-      `vault ${c}: appVaultKeepers expected v${a}, got v${i.appVaultKeepersVersion}`
-    ), i.universalChallengersVersion !== l && u.push(
-      `vault ${c}: universalChallengers expected v${l}, got v${i.universalChallengersVersion}`
-    ), i.vaultCoreVersion !== o && u.push(
-      `vault ${c}: vaultCoreVersion expected v${o} (build-time active), got v${i.vaultCoreVersion}`
+  } = e, s = await t.getProtocolInfoBatch(r), i = [];
+  if (s.forEach((u, h) => {
+    const c = r[h];
+    u.offchainParamsVersion !== n && i.push(
+      `vault ${c}: offchainParams expected v${n}, got v${u.offchainParamsVersion}`
+    ), u.appVaultKeepersVersion !== a && i.push(
+      `vault ${c}: appVaultKeepers expected v${a}, got v${u.appVaultKeepersVersion}`
+    ), u.universalChallengersVersion !== l && i.push(
+      `vault ${c}: universalChallengers expected v${l}, got v${u.universalChallengersVersion}`
+    ), u.vaultCoreVersion !== o && i.push(
+      `vault ${c}: vaultCoreVersion expected v${o} (build-time active), got v${u.vaultCoreVersion}`
     );
-  }), u.length > 0)
-    throw new le(
-      `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.`
+  }), i.length > 0)
+    throw new pe(
+      `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${i.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-var ce = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(ce || {});
-const ct = /* @__PURE__ */ new Set([
+var de = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(de || {});
+const yt = /* @__PURE__ */ new Set([
   "PayoutBroadcast",
   "PayoutBlocked"
   /* PAYOUT_BLOCKED */
 ]);
-function Xt(e) {
-  return Object.values(ce).includes(
+function nr(e) {
+  return Object.values(de).includes(
     e
   );
 }
-function Gt(e) {
-  return !!e && ct.has(e);
+function or(e) {
+  return !!e && yt.has(e);
 }
-class pt extends Error {
+class bt extends Error {
   constructor(r, n) {
     super(`Refund not yet mature (BIP68 not final): ${n.message}`);
-    A(this, "vaultId");
-    A(this, "cause");
+    $(this, "vaultId");
+    $(this, "cause");
     this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = n;
   }
 }
-const ht = /^0x[0-9a-fA-F]{64}$/, dt = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, pe = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, he = 160, J = 2e3, Z = 10n, ee = 100n;
-function jt(e) {
+const wt = /^0x[0-9a-fA-F]{64}$/, kt = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, ge = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, fe = 160, Z = 2e3, ee = 10n, te = 100n;
+function ar(e) {
   if (!Number.isFinite(e) || e <= 0)
     throw new Error(
       `feeRateSatsVb must be a positive finite number, got ${e}`
     );
-  return BigInt(Math.ceil(e * he));
+  return BigInt(Math.ceil(e * fe));
 }
-const gt = 1, ft = /non-BIP68-final/i;
-function U(e, t) {
+const Et = 1, xt = /non-BIP68-final/i;
+function L(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 (!ht.test(e))
+  if (!wt.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function H(e, t) {
+function O(e, t) {
   if (!Number.isInteger(e) || e < 0)
     throw new Error(`${t} must be a non-negative integer, got ${e}`);
 }
-function vt(e) {
-  if (U(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
+function Tt(e) {
+  if (L(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
     throw new Error(
       `htlcVout must be a non-negative integer, got ${e.htlcVout}`
     );
@@ -1085,7 +1184,7 @@ function vt(e) {
     );
   for (let r = 0; r < e.batch.length; r++) {
     const n = e.batch[r];
-    if (U(n.hashlock, `batch[${r}].hashlock`), !Number.isInteger(n.htlcVout) || n.htlcVout !== r)
+    if (L(n.hashlock, `batch[${r}].hashlock`), !Number.isInteger(n.htlcVout) || n.htlcVout !== r)
       throw new Error(
         `batch[${r}].htlcVout must equal ${r} (contiguous vout-ordered vector), got ${n.htlcVout}`
       );
@@ -1103,27 +1202,27 @@ function vt(e) {
     throw new Error(
       `batch[${e.htlcVout}].amount (${t.amount}) does not match target amount (${e.amount})`
     );
-  if (H(e.offchainParamsVersion, "offchainParamsVersion"), H(e.appVaultKeepersVersion, "appVaultKeepersVersion"), H(
+  if (O(e.offchainParamsVersion, "offchainParamsVersion"), O(e.appVaultKeepersVersion, "appVaultKeepersVersion"), O(
     e.universalChallengersVersion,
     "universalChallengersVersion"
-  ), Ae(
+  ), Ke(
     e.vaultCoreVersion,
     "VaultRefundData.vaultCoreVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
     throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!dt.test(e.unsignedPrePeginTxHex))
+  if (!kt.test(e.unsignedPrePeginTxHex))
     throw new Error(
       "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
     );
-  if (!e.depositorBtcPubkey || !pe.test(e.depositorBtcPubkey))
+  if (!e.depositorBtcPubkey || !ge.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 yt(e) {
-  if (!e.vaultProviderPubkey || !pe.test(e.vaultProviderPubkey))
+function Ct(e) {
+  if (!e.vaultProviderPubkey || !ge.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");
@@ -1148,8 +1247,8 @@ function yt(e) {
       `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
     );
 }
-function Pt(e) {
-  const t = Te.fromHex(e);
+function St(e) {
+  const t = _e.fromHex(e);
   try {
     t.finalizeAllInputs();
   } catch (r) {
@@ -1159,7 +1258,7 @@ function Pt(e) {
   }
   return t.extractTransaction().toHex();
 }
-async function qt(e) {
+async function sr(e) {
   const {
     vaultId: t,
     readVault: r,
@@ -1169,139 +1268,145 @@ async function qt(e) {
     broadcastTx: o,
     signal: s
   } = e;
-  s == null || s.throwIfAborted(), U(t, "vaultId");
-  const u = await r();
-  vt(u), s == null || s.throwIfAborted();
-  const i = await n(u);
-  if (yt(i), s == null || s.throwIfAborted(), !Number.isFinite(a) || a <= 0)
+  s == null || s.throwIfAborted(), L(t, "vaultId");
+  const i = await r();
+  Tt(i), s == null || s.throwIfAborted();
+  const u = await n(i);
+  if (Ct(u), s == null || s.throwIfAborted(), !Number.isFinite(a) || a <= 0)
     throw new Error(`feeRate must be a positive number, got ${a}`);
-  if (a > J)
+  if (a > Z)
     throw new Error(
-      `feeRate ${a} sat/vB exceeds refund safety cap ${J} sat/vB; refusing to sign refund.`
+      `feeRate ${a} sat/vB exceeds refund safety cap ${Z} sat/vB; refusing to sign refund.`
     );
-  const p = BigInt(Math.ceil(a * he)), c = u.amount * Z / ee;
-  if (p > c)
+  const h = BigInt(Math.ceil(a * fe)), c = i.amount * ee / te;
+  if (h > c)
     throw new Error(
-      `Refund fee ${p} sats exceeds the per-vault safety cap of ${c} sats (${Z}/${ee} of vault.amount=${u.amount}); refusing to sign refund.`
+      `Refund fee ${h} sats exceeds the per-vault safety cap of ${c} sats (${ee}/${te} of vault.amount=${i.amount}); refusing to sign refund.`
     );
   s == null || s.throwIfAborted();
-  const h = L(
-    u.depositorBtcPubkey
-  ), g = d(u.unsignedPrePeginTxHex), v = ke(g);
-  if (v !== void 0 && v.vout !== u.batch.length)
+  const p = U(
+    i.depositorBtcPubkey
+  ), d = f(i.unsignedPrePeginTxHex), g = Te(d);
+  if (g !== void 0 && g.vout !== i.batch.length)
     throw new Error(
-      `Auth-anchor OP_RETURN at vout ${v.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.`
+      `Auth-anchor OP_RETURN at vout ${g.vout} does not match batch size (${i.batch.length} HTLC outputs expect the anchor at vout ${i.batch.length}). Refund refused — sibling HTLC vector is incomplete.`
     );
-  const T = v == null ? void 0 : v.hash;
-  let x;
+  const b = g == null ? void 0 : g.hash;
+  let v;
   try {
-    x = $.fromHex(g);
-  } catch (f) {
+    v = A.fromHex(d);
+  } catch (y) {
     throw new Error(
-      `Failed to parse funded Pre-PegIn transaction hex: ${f instanceof Error ? f.message : String(f)}`
+      `Failed to parse funded Pre-PegIn transaction hex: ${y instanceof Error ? y.message : String(y)}`
     );
   }
-  if (x.outs.length < u.batch.length)
+  if (v.outs.length < i.batch.length)
     throw new Error(
-      `Funded Pre-PegIn tx has ${x.outs.length} outputs but batch requires at least ${u.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
+      `Funded Pre-PegIn tx has ${v.outs.length} outputs but batch requires at least ${i.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
     );
-  const { psbtHex: m } = await Be({
+  const { psbtHex: P } = await Ve({
     prePeginParams: {
-      vaultCoreVersion: u.vaultCoreVersion,
-      depositorPubkey: h,
-      vaultProviderPubkey: d(i.vaultProviderPubkey),
-      vaultKeeperPubkeys: i.vaultKeeperPubkeys.map(d),
-      universalChallengerPubkeys: i.universalChallengerPubkeys.map(d),
-      hashlocks: u.batch.map((f) => d(f.hashlock)),
-      timelockRefund: i.timelockRefund,
+      vaultCoreVersion: i.vaultCoreVersion,
+      depositorPubkey: p,
+      vaultProviderPubkey: f(u.vaultProviderPubkey),
+      vaultKeeperPubkeys: u.vaultKeeperPubkeys.map(f),
+      universalChallengerPubkeys: u.universalChallengerPubkeys.map(f),
+      hashlocks: i.batch.map((y) => f(y.hashlock)),
+      timelockRefund: u.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
       // reserve (`depositorClaimValue + minPeginFee`) internally when sizing the
       // 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((f) => f.amount),
-      feeRate: i.feeRate,
-      minPeginFeeRate: i.minPeginFeeRate,
-      numLocalChallengers: i.numLocalChallengers,
-      councilQuorum: i.councilQuorum,
-      councilSize: i.councilSize,
-      network: i.network,
-      authAnchorHash: T
+      pegInAmounts: i.batch.map((y) => y.amount),
+      feeRate: u.feeRate,
+      minPeginFeeRate: u.minPeginFeeRate,
+      numLocalChallengers: u.numLocalChallengers,
+      councilQuorum: u.councilQuorum,
+      councilSize: u.councilSize,
+      network: u.network,
+      authAnchorHash: b
     },
-    fundedPrePeginTxHex: g,
-    htlcVout: u.htlcVout,
-    refundFee: p,
+    fundedPrePeginTxHex: d,
+    htlcVout: i.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: d(u.hashlock)
+    hashlock: f(i.hashlock)
   });
   s == null || s.throwIfAborted();
-  const b = M(
-    u.depositorBtcPubkey,
-    gt
-  ), y = await l(m, b);
-  N({
-    requestedPsbtHex: m,
-    returnedPsbtHex: y
+  const w = M(
+    i.depositorBtcPubkey,
+    Et
+  ), m = await l(P, w);
+  H({
+    requestedPsbtHex: P,
+    returnedPsbtHex: m
   });
-  const S = 0, _ = D(
-    y,
-    h,
+  const S = 0, R = D(
+    m,
+    p,
     S
   );
   F({
-    requestedPsbtHex: m,
-    signatureHex: _,
-    signerXOnlyPubkeyHex: h,
+    requestedPsbtHex: P,
+    signatureHex: R,
+    signerXOnlyPubkeyHex: p,
     inputIndex: S
   });
-  const B = Pt(y);
+  const _ = St(m);
   s == null || s.throwIfAborted();
   try {
-    return await o(B);
-  } catch (f) {
-    throw f instanceof Error && ft.test(f.message) ? new pt(t, f) : f;
+    return await o(_);
+  } catch (y) {
+    throw y instanceof Error && xt.test(y.message) ? new bt(t, y) : y;
   }
 }
 export {
-  qt as A,
-  pt as B,
-  ce as C,
-  jt as D,
-  ee as E,
-  Z as F,
-  J as G,
-  he as H,
-  ue as P,
-  le as R,
-  Bt as a,
-  At as b,
-  Vt as c,
-  Ht as d,
-  Ft as e,
-  Dt as f,
-  Nt as g,
-  at as h,
-  Ot as i,
-  st as j,
-  Mt as k,
-  Ut as l,
-  Lt as m,
-  zt as n,
-  Kt as o,
-  K as p,
-  et as q,
-  Rt as r,
-  ze as s,
-  q as t,
-  rt as u,
-  It as v,
-  ae as w,
-  nt as x,
-  Xt as y,
-  Gt as z
+  lt as A,
+  Q as B,
+  ht as C,
+  pt as D,
+  de as E,
+  nr as F,
+  or as G,
+  bt as H,
+  sr as I,
+  ar as J,
+  te as K,
+  ee as L,
+  Z as M,
+  fe as N,
+  Me as P,
+  pe as R,
+  Ft as a,
+  Mt as b,
+  se as c,
+  ie as d,
+  Lt as e,
+  Xt as f,
+  qt as g,
+  Qt as h,
+  Xe as i,
+  Jt as j,
+  Yt as k,
+  Wt as l,
+  gt as m,
+  ft as n,
+  he as o,
+  Zt as p,
+  er as q,
+  zt as r,
+  Ze as s,
+  tr as t,
+  rr as u,
+  jt as v,
+  Ut as w,
+  ue as x,
+  Gt as y,
+  V as z
 };
-//# sourceMappingURL=buildAndBroadcastRefund-CoPc7UHA.js.map
+//# sourceMappingURL=buildAndBroadcastRefund-CH2awK6h.js.map