@babylonlabs-io/ts-sdk 0.77.0 → 0.79.0

package/dist/{buildAndBroadcastReclaim-DCGcupg7.js → buildAndBroadcastReclaim-O6z9kvc4.js}

@@ -1,52 +1,52 @@
-var xe = Object.defineProperty;
-var Te = (e, t, r) => t in e ? xe(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var S = (e, t, r) => Te(e, typeof t != "symbol" ? t + "" : t, r);
-import { B as ie } from "./BTCVaultRegistry.abi-CJwWI2EO.js";
-import { e as ue, v as Re, s as P, u as le, p as O, c as R, f as _ } from "./bitcoin-C-TuHb-v.js";
-import { v as Ce, d as Ae, s as _e, P as Se, a as $e } from "./signPsbtsWithFallback-f7QLp0q8.js";
-import { zeroAddress as Be } from "viem";
-import { D as C, c as Ie, b as Ve, R as Ke, d as ce } from "./json-rpc-client-DuUARJvV.js";
+var Re = Object.defineProperty;
+var _e = (e, t, r) => t in e ? Re(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var S = (e, t, r) => _e(e, typeof t != "symbol" ? t + "" : t, r);
+import { B as pe } from "./BTCVaultRegistry.abi-B0x9_Bza.js";
+import { e as he, v as Se, s as y, u as de, p as O, c as C, f as _ } from "./bitcoin-C-TuHb-v.js";
+import { v as $e, d as Be, s as Ie, P as Ve, a as Ke } from "./signPsbtsWithFallback-f7QLp0q8.js";
+import { zeroAddress as Oe, isAddress as Ne, isAddressEqual as He } from "viem";
+import { D as R, c as De, b as Me, R as Fe, d as ge } from "./json-rpc-client-DuUARJvV.js";
 import { Transaction as $ } from "bitcoinjs-lib";
-import { p as Oe, f as Ne, i as B, g as I, j as V } from "./verifyScriptPathSchnorrSignature-D_epga4j.js";
-import { D as q } from "./constants-D5vORbQE.js";
-import { d as He, c as De, b as Fe, f as he, e as Me, a as Le } from "./noPayout-DiGr4eas.js";
-import { a as K, c as Ue } from "./signing-Cm-McVR2.js";
-import { a as z } from "./onChainBtcPubkey-C-6UWpD8.js";
-import { a as Xe } from "./secp256k1-D-H9jmd7.js";
-import { deriveVaultId as Ge } from "./tbv/core/wasm/index.js";
-const qe = /^0x[0-9a-fA-F]{64}$/, ze = /^0x[0-9a-fA-F]{40}$/, je = /^0x([0-9a-fA-F]{2})*$/;
+import { p as Ue, f as Le, i as B, g as I, j as V } from "./verifyScriptPathSchnorrSignature-D_epga4j.js";
+import { D as W } from "./constants-D5vORbQE.js";
+import { d as Xe, c as qe, b as Ge, f as fe, e as ze, a as je } from "./noPayout-DiGr4eas.js";
+import { a as K, c as Qe } from "./signing-Cm-McVR2.js";
+import { a as Y } from "./onChainBtcPubkey-C-6UWpD8.js";
+import { a as We } from "./secp256k1-D-H9jmd7.js";
+import { deriveVaultId as Ye } from "./tbv/core/wasm/index.js";
+const Je = /^0x[0-9a-fA-F]{64}$/, Ze = /^0x[0-9a-fA-F]{40}$/, et = /^0x([0-9a-fA-F]{2})*$/;
 function N(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 (!qe.test(e))
+  if (!Je.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function Qe(e, t) {
-  if (!ze.test(e))
+function tt(e, t) {
+  if (!Ze.test(e))
     throw new Error(
       `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
     );
 }
-function We(e, t) {
-  if (!je.test(e))
+function rt(e, t) {
+  if (!et.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
 }
-function de(e) {
-  Qe(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), N(e.vaultId, "vaultId");
-  const t = ue(e.secret);
-  if (N(t, "secret"), e.hashlock !== void 0 && (N(e.hashlock, "hashlock"), !Ce(t, e.hashlock)))
+function me(e) {
+  tt(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), N(e.vaultId, "vaultId");
+  const t = he(e.secret);
+  if (N(t, "secret"), e.hashlock !== void 0 && (N(e.hashlock, "hashlock"), !$e(t, e.hashlock)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
   return t;
 }
-async function Yt(e) {
+async function or(e) {
   const {
     btcVaultRegistryAddress: t,
     vaultId: r,
@@ -56,23 +56,23 @@ async function Yt(e) {
     signal: s
   } = e;
   s == null || s.throwIfAborted();
-  const i = de({
+  const i = me({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
     hashlock: o
   });
-  return We(a, "activationMetadata"), l({
+  return rt(a, "activationMetadata"), l({
     address: t,
-    abi: ie,
+    abi: pe,
     functionName: "activateVaultWithSecret",
     args: [r, i, a]
   });
 }
-async function Jt(e) {
+async function nr(e) {
   const { btcVaultRegistryAddress: t, vaultId: r, hashlock: o, writeContract: a, signal: l } = e;
   l == null || l.throwIfAborted();
-  const s = de({
+  const s = me({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
@@ -80,40 +80,40 @@ async function Jt(e) {
   });
   return a({
     address: t,
-    abi: ie,
+    abi: pe,
     functionName: "activateVaultWithSecretAndRedeem",
     args: [r, s]
   });
 }
-const Ye = 8, Je = 6e3, Ze = 10 * 6e4, et = 10;
-class pe extends Error {
+const ot = 8, nt = 6e3, st = 10 * 6e4, at = 10;
+class Pe extends Error {
   constructor(t) {
     super(t), this.name = "PeginRegistrationMissingError";
   }
 }
-class ge extends Error {
+class ve extends Error {
   constructor(t) {
     super(t), this.name = "PeginRegistrationNotFinalError";
   }
 }
-function tt(e) {
-  return e instanceof pe || e instanceof Error && e.name === "PeginRegistrationMissingError";
+function it(e) {
+  return e instanceof Pe || e instanceof Error && e.name === "PeginRegistrationMissingError";
 }
-function Zt(e) {
-  return e instanceof ge || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
+function sr(e) {
+  return e instanceof ve || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
 }
-function j(e) {
+function J(e) {
   const { currentBlock: t, createdAtBlock: r } = e, o = t - r + 1n;
   return o < 0n ? 0 : Number(o);
 }
-async function er(e) {
+async function ar(e) {
   const {
     vaultRegistryReader: t,
     getBlockNumber: r,
     vaultIds: o,
-    required: a = Ye,
-    pollIntervalMs: l = Je,
-    timeoutMs: s = Ze,
+    required: a = ot,
+    pollIntervalMs: l = nt,
+    timeoutMs: s = st,
     signal: i,
     onProgress: n
   } = e;
@@ -122,92 +122,92 @@ async function er(e) {
       "waitForPeginRegistrationDepth requires at least one vault ID"
     );
   const u = Date.now();
-  let h = !1, c = 0, d;
+  let p = !1, c = 0, h;
   for (; ; ) {
     if (i != null && i.aborted)
       throw new Error(
         `Aborted while waiting for peg-in registration depth (${o.length} vault(s))`
       );
     if (Date.now() - u >= s)
-      throw new ge(
-        `Peg-in registration did not reach ${a} Ethereum confirmations within ${s}ms. The registration transaction was submitted but is not yet final, so the Pre-PegIn Bitcoin transaction was never sent and no funds are at risk. Resume this deposit from the dashboard once the network settles.` + (d instanceof Error ? ` Last read error: ${d.message}` : "")
+      throw new ve(
+        `Peg-in registration did not reach ${a} 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.` + (h instanceof Error ? ` Last read error: ${h.message}` : "")
       );
     try {
-      const p = await r(), g = await Promise.all(
-        o.map((f) => t.getVaultBasicInfo(f))
+      const d = await r(), g = await Promise.all(
+        o.map((P) => t.getVaultBasicInfo(P))
       ), m = g.findIndex(
-        (f) => f.depositor === Be || f.createdAt === 0n
+        (P) => P.depositor === Oe || P.createdAt === 0n
       );
       if (m !== -1) {
-        if (c += 1, !h && c > et)
-          throw new pe(
+        if (c += 1, !p && c > at)
+          throw new Pe(
             `Vault ${o[m]} is still not visible on-chain after ${c} reads — the registration does not exist.`
           );
         console.warn(
-          `Peg-in registration for vault ${o[m]} is not visible in chain state at block ${p} — a lagging RPC backend or an Ethereum reorg. Still polling.`
+          `Peg-in registration for vault ${o[m]} is not visible in chain state at block ${d} — a lagging RPC backend or an Ethereum reorg. Still polling.`
         ), n == null || n({ confirmations: 0, required: a });
       } else {
-        h = !0, c = 0, d = void 0;
-        let f = g[0], v = j({
-          currentBlock: p,
+        p = !0, c = 0, h = void 0;
+        let P = g[0], f = J({
+          currentBlock: d,
           createdAtBlock: g[0].createdAt
         });
-        for (const w of g.slice(1)) {
-          const k = j({
-            currentBlock: p,
-            createdAtBlock: w.createdAt
+        for (const x of g.slice(1)) {
+          const b = J({
+            currentBlock: d,
+            createdAtBlock: x.createdAt
           });
-          k < v && (v = k, f = w);
+          b < f && (f = b, P = x);
         }
-        if (n == null || n({ confirmations: v, required: a }), v >= a)
-          return { confirmations: v, basicInfo: f };
+        if (n == null || n({ confirmations: f, required: a }), f >= a)
+          return { confirmations: f, basicInfo: P };
       }
-    } catch (p) {
-      if (tt(p))
-        throw p;
+    } catch (d) {
+      if (it(d))
+        throw d;
       console.warn(
-        `Registration-depth read failed (retrying in ${l}ms): ` + (p instanceof Error ? p.message : String(p))
-      ), d = p;
+        `Registration-depth read failed (retrying in ${l}ms): ` + (d instanceof Error ? d.message : String(d))
+      ), h = d;
     }
-    await new Promise((p, g) => {
+    await new Promise((d, g) => {
       const m = () => {
-        clearTimeout(f), g(
+        clearTimeout(P), g(
           new Error(
             `Aborted while waiting for peg-in registration depth (${o.length} vault(s))`
           )
         );
-      }, f = setTimeout(() => {
-        i == null || i.removeEventListener("abort", m), p();
+      }, P = setTimeout(() => {
+        i == null || i.removeEventListener("abort", m), d();
       }, l);
       i == null || i.addEventListener("abort", m, { once: !0 });
     });
   }
 }
-const rt = 1;
-function ot(e, t, r) {
+const ut = 1;
+function lt(e, t, r) {
   const o = r.map(
-    (c) => P(c).toLowerCase()
+    (c) => y(c).toLowerCase()
   ), a = t.filter((c) => o.includes(c));
   if (a.length > 0)
     throw new Error(
       `Cannot validate challenger set: vault keepers and universal challengers overlap (${a.join(", ")})`
     );
   const l = [...t, ...o], s = e.map(
-    (c) => P(c.challenger_pubkey).toLowerCase()
+    (c) => y(c.challenger_pubkey).toLowerCase()
   ), i = new Set(s);
   if (i.size !== s.length)
     throw new Error(
       "Depositor graph contains duplicate challenger entries in challenger_presign_data"
     );
-  const n = new Set(l), u = l.filter((c) => !i.has(c)), h = s.filter((c) => !n.has(c));
-  if (u.length > 0 || h.length > 0)
+  const n = new Set(l), u = l.filter((c) => !i.has(c)), p = s.filter((c) => !n.has(c));
+  if (u.length > 0 || p.length > 0)
     throw new Error(
-      "Depositor graph challenger set does not match expected (local ∪ universal)" + (u.length > 0 ? ` (missing: ${u.join(", ")})` : "") + (h.length > 0 ? ` (unexpected: ${h.join(", ")})` : "")
+      "Depositor graph challenger set does not match expected (local ∪ universal)" + (u.length > 0 ? ` (missing: ${u.join(", ")})` : "") + (p.length > 0 ? ` (unexpected: ${p.join(", ")})` : "")
     );
 }
-function nt(e, t) {
+function ct(e, t) {
   const r = e.ins[t];
-  return le(new Uint8Array(r.hash).slice().reverse());
+  return de(new Uint8Array(r.hash).slice().reverse());
 }
 function H(e, t, r, o, a) {
   const l = e.ins[t];
@@ -215,25 +215,25 @@ function H(e, t, r, o, a) {
     throw new Error(
       `NoPayout (challenger ${a}) input ${t} expected to spend ${o} vout 0, got vout ${l.index}`
     );
-  const s = r.getId(), i = nt(e, t);
+  const s = r.getId(), i = ct(e, t);
   if (i !== s)
     throw new Error(
       `NoPayout (challenger ${a}) input ${t} does not reference ${o} (expected txid ${s}, got ${i})`
     );
 }
-async function st(e, t, r) {
-  const o = [], a = [], l = [], s = Oe({
+async function pt(e, t, r) {
+  const o = [], a = [], l = [], s = Ue({
     claimerBtcPubkey: r.depositorBtcPubkey,
     depositorBtcPubkey: r.depositorBtcPubkey,
     vaultProviderBtcPubkey: r.vaultProviderBtcPubkey,
     vaultKeeperBtcPubkeys: r.vaultKeeperBtcPubkeys
   });
-  ot(
+  lt(
     e.challenger_presign_data,
     s,
     r.universalChallengerBtcPubkeys
   );
-  const i = await Ne({
+  const i = await Le({
     vaultCoreVersion: r.vaultCoreVersion,
     vkClaimerPayoutScriptPubKeys: r.vkClaimerPayoutScriptPubKeys,
     vpCommissionScriptPubKey: r.vpCommissionScriptPubKey,
@@ -249,7 +249,7 @@ async function st(e, t, r) {
     network: r.network,
     claimerBtcPubkey: r.depositorBtcPubkey,
     registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
-    commissionBps: rt,
+    commissionBps: ut,
     protocolFeeRate: r.protocolFeeRate,
     councilMembers: r.councilMembers,
     councilQuorum: r.councilQuorum
@@ -257,34 +257,34 @@ async function st(e, t, r) {
   o.push(i.psbtHex), a.push(
     K(
       t,
-      q
+      W
     )
   );
-  const n = P(r.depositorBtcPubkey), u = $.fromHex(
-    P(e.assert_tx.tx_hex)
+  const n = y(r.depositorBtcPubkey), u = $.fromHex(
+    y(e.assert_tx.tx_hex)
   );
-  for (const h of e.challenger_presign_data) {
-    const c = P(h.challenger_pubkey), d = o.length, p = await at({
-      challenger: h,
+  for (const p of e.challenger_presign_data) {
+    const c = y(p.challenger_pubkey), h = o.length, d = await ht({
+      challenger: p,
       challengerPubkey: c,
       claimerPubkey: n,
       localChallengers: s,
       assertTxParsed: u,
       ctx: r
     });
-    o.push(p), a.push(
+    o.push(d), a.push(
       K(
         t,
-        q
+        W
       )
     ), l.push({
       challengerPubkey: c,
-      noPayoutIdx: d
+      noPayoutIdx: h
     });
   }
   return { psbtHexes: o, signOptions: a, challengerEntries: l };
 }
-async function at(e) {
+async function ht(e) {
   const {
     challenger: t,
     challengerPubkey: r,
@@ -293,17 +293,17 @@ async function at(e) {
     assertTxParsed: l,
     ctx: s
   } = e;
-  He(
+  Xe(
     t.nopayout_tx.tx_hex,
     r,
     s.network
   );
   const i = $.fromHex(
-    P(t.nopayout_tx.tx_hex)
+    y(t.nopayout_tx.tx_hex)
   ), n = $.fromHex(
-    P(t.challenge_assert_x_tx.tx_hex)
+    y(t.challenge_assert_x_tx.tx_hex)
   ), u = $.fromHex(
-    P(t.challenge_assert_y_tx.tx_hex)
+    y(t.challenge_assert_y_tx.tx_hex)
   );
   if (i.ins.length !== 3)
     throw new Error(
@@ -328,18 +328,18 @@ async function at(e) {
     "ChallengeAssertY",
     r
   );
-  const h = [
+  const p = [
     l.outs[0],
     n.outs[0],
     u.outs[0]
   ].map((c) => ({
-    script_pubkey: le(new Uint8Array(c.script)),
+    script_pubkey: de(new Uint8Array(c.script)),
     value: c.value
   }));
-  return De({
+  return qe({
     noPayoutTxHex: t.nopayout_tx.tx_hex,
     challengerPubkey: r,
-    prevouts: h,
+    prevouts: p,
     connectorParams: {
       txGraphVersion: s.vaultCoreVersion,
       claimer: o,
@@ -351,7 +351,7 @@ async function at(e) {
     }
   });
 }
-function it(e, t, r) {
+function dt(e, t, r) {
   B(e[0]);
   const a = I(
     e[0].returnedPsbtHex,
@@ -386,36 +386,36 @@ function it(e, t, r) {
     per_challenger: l
   };
 }
-async function ut(e) {
-  const { depositorGraph: t, btcWallet: r, signingContext: o } = e, a = await r.getPublicKeyHex(), { depositorPubkey: l } = Re(
+async function gt(e) {
+  const { depositorGraph: t, btcWallet: r, signingContext: o } = e, a = await r.getPublicKeyHex(), { depositorPubkey: l } = Se(
     a,
-    P(o.depositorBtcPubkey)
-  ), { psbtHexes: s, signOptions: i, challengerEntries: n } = await st(
+    y(o.depositorBtcPubkey)
+  ), { psbtHexes: s, signOptions: i, challengerEntries: n } = await pt(
     t,
     a,
     o
-  ), u = await Ae(
+  ), u = await Be(
     r,
     s,
     i
-  ), h = s.map((c, d) => ({
+  ), p = s.map((c, h) => ({
     requestedPsbtHex: c,
-    returnedPsbtHex: u[d]
+    returnedPsbtHex: u[h]
   }));
-  return it(
-    h,
+  return dt(
+    p,
     n,
     l
   );
 }
-const lt = 1e4;
-async function fe(e) {
+const ft = 1e4;
+async function ye(e) {
   const {
     statusReader: t,
     peginTxid: r,
     targetStatuses: o,
     timeoutMs: a,
-    pollIntervalMs: l = lt,
+    pollIntervalMs: l = ft,
     signal: s
   } = e, i = Date.now();
   for (; ; ) {
@@ -437,53 +437,53 @@ async function fe(e) {
           `getPeginStatus returned status for pegin ${n.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
         );
       const u = n.status;
-      if (o.has(u) || u === C.ACTIVATED)
+      if (o.has(u) || u === R.ACTIVATED)
         return u;
-      if (u === C.EXPIRED || Ie.has(u))
+      if (u === R.EXPIRED || De.has(u))
         throw new Error(
           `Pegin ${r.slice(0, 8)}… reached terminal status "${u}" while waiting for ${[...o].join(", ")}`
         );
     } catch (n) {
-      if (!(n instanceof Ve && n.code === Ke.PEGIN_NOT_FOUND))
+      if (!(n instanceof Me && n.code === Fe.PEGIN_NOT_FOUND))
         throw n;
     }
     await new Promise((n, u) => {
-      const h = () => {
+      const p = () => {
         clearTimeout(c), u(
           new Error(
             `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
           )
         );
       }, c = setTimeout(() => {
-        s == null || s.removeEventListener("abort", h), n();
+        s == null || s.removeEventListener("abort", p), n();
       }, l);
-      s == null || s.addEventListener("abort", h, { once: !0 });
+      s == null || s.addEventListener("abort", p, { once: !0 });
     });
   }
 }
-const ct = 1200 * 1e3, me = /* @__PURE__ */ new Set([
-  C.PENDING_ACKS,
-  C.PENDING_ACTIVATION,
-  C.ACTIVATED_PENDING_BROADCAST,
-  C.ACTIVATED
-]), ht = /* @__PURE__ */ new Set([
-  C.PENDING_DEPOSITOR_SIGNATURES,
-  ...me
+const mt = 1200 * 1e3, be = /* @__PURE__ */ new Set([
+  R.PENDING_ACKS,
+  R.PENDING_ACTIVATION,
+  R.ACTIVATED_PENDING_BROADCAST,
+  R.ACTIVATED
+]), Pt = /* @__PURE__ */ new Set([
+  R.PENDING_DEPOSITOR_SIGNATURES,
+  ...be
 ]);
-function dt(e) {
+function vt(e) {
   return e.map((t) => ({
     claimerPubkeyXOnly: O(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
     assertTxHex: t.assert_tx.tx_hex
   }));
 }
-function T(e) {
+function A(e) {
   return O(e).toLowerCase();
 }
-function pt(e, t) {
-  const r = (n, u, h) => {
+function yt(e, t) {
+  const r = (n, u, p) => {
     throw new Error(
-      `Deposit terms ${n} (${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.`
+      `Deposit terms ${n} (${String(u)}) does not match the vault's version-locked signing context (${String(p)}); refusing to sign payouts against terms that describe a different graph.`
     );
   }, o = [
     ["protocolFeeRate", e.protocolFeeRate, t.protocolFeeRate],
@@ -491,11 +491,11 @@ function pt(e, t) {
     ["timelockPegin", e.timelockPegin, t.timelockPegin],
     ["timelockAssert", e.timelockAssert, t.timelockAssert]
   ];
-  for (const [n, u, h] of o)
-    u !== h && r(n, u, h);
-  const a = (n) => n.map(T).sort(), l = (n, u) => {
-    const h = a(n), c = a(u);
-    return h.length === c.length && h.every((d, p) => d === c[p]);
+  for (const [n, u, p] of o)
+    u !== p && r(n, u, p);
+  const a = (n) => n.map(A).sort(), l = (n, u) => {
+    const p = a(n), c = a(u);
+    return p.length === c.length && p.every((h, d) => h === c[d]);
   };
   l(e.vaultKeeperBtcPubkeys, t.vaultKeeperBtcPubkeys) || r(
     "vaultKeeperBtcPubkeys",
@@ -509,8 +509,8 @@ function pt(e, t) {
     e.universalChallengerBtcPubkeys.join(","),
     t.universalChallengerBtcPubkeys.join(",")
   );
-  const s = T(t.vaultProviderBtcPubkey), i = e.vaults.map(
-    (n) => T(n.vaultProviderBtcPubkey)
+  const s = A(t.vaultProviderBtcPubkey), i = e.vaults.map(
+    (n) => A(n.vaultProviderBtcPubkey)
   );
   i.includes(s) || r(
     "vaults[].vaultProviderBtcPubkey",
@@ -518,10 +518,10 @@ function pt(e, t) {
     t.vaultProviderBtcPubkey
   );
 }
-function gt(e, t, r, o) {
-  const a = T(o), l = [
-    T(t),
-    ...r.map(T)
+function bt(e, t, r, o) {
+  const a = A(o), l = [
+    A(t),
+    ...r.map(A)
   ], s = new Set(l);
   if (s.size !== l.length)
     throw new Error(
@@ -532,17 +532,17 @@ function gt(e, t, r, o) {
       "Cannot validate claimer set: depositor key overlaps with vault provider or vault keeper set"
     );
   const i = e.map(
-    (d) => T(d.claimer_pubkey)
+    (h) => A(h.claimer_pubkey)
   );
   if (new Set(i).size !== i.length)
     throw new Error("Presign response contains duplicate claimer entries");
-  const n = i.filter((d) => d !== a), u = new Set(n), h = l.filter((d) => !u.has(d)), c = n.filter((d) => !s.has(d));
-  if (h.length > 0 || c.length > 0)
+  const n = i.filter((h) => h !== a), u = new Set(n), p = l.filter((h) => !u.has(h)), c = n.filter((h) => !s.has(h));
+  if (p.length > 0 || c.length > 0)
     throw new Error(
-      "Presign response claimer set does not match expected (vault provider ∪ vault keepers)" + (h.length > 0 ? ` (missing: ${h.join(", ")})` : "") + (c.length > 0 ? ` (unexpected: ${c.join(", ")})` : "")
+      "Presign response claimer set does not match expected (vault provider ∪ vault keepers)" + (p.length > 0 ? ` (missing: ${p.join(", ")})` : "") + (c.length > 0 ? ` (unexpected: ${c.join(", ")})` : "")
     );
 }
-function Q(e, t) {
+function Z(e, t) {
   return {
     vaultCoreVersion: t.vaultCoreVersion,
     payoutTxHex: e.payoutTxHex,
@@ -564,8 +564,8 @@ function Q(e, t) {
     vpCommissionScriptPubKey: t.vpCommissionScriptPubKey
   };
 }
-async function ft(e, t, r, o) {
-  const a = new Se({
+async function wt(e, t, r, o) {
+  const a = new Ve({
     network: t.network,
     btcWallet: e
   }), l = r.length;
@@ -573,14 +573,14 @@ async function ft(e, t, r, o) {
   let s;
   if (a.supportsBatchSigning())
     s = (await a.signPayoutTransactionsBatch(
-      r.map((u) => Q(u, t))
+      r.map((u) => Z(u, t))
     )).map((u) => u.payoutSignature);
   else {
     s = [];
     for (let n = 0; n < r.length; n++) {
       o == null || o(n, l);
       const u = await a.signPayoutTransaction(
-        Q(r[n], t)
+        Z(r[n], t)
       );
       s.push(u.signature);
     }
@@ -592,7 +592,7 @@ async function ft(e, t, r, o) {
     };
   return o == null || o(l, l), i;
 }
-async function tr(e) {
+async function ir(e) {
   const {
     statusReader: t,
     presignClient: r,
@@ -601,26 +601,26 @@ async function tr(e) {
     depositorPk: l,
     signingContext: s,
     depositTerms: i,
-    timeoutMs: n = ct,
+    timeoutMs: n = mt,
     signal: u,
-    onProgress: h
-  } = e, c = await fe({
+    onProgress: p
+  } = e, c = await ye({
     statusReader: t,
     peginTxid: a,
-    targetStatuses: ht,
+    targetStatuses: Pt,
     timeoutMs: n,
     signal: u
   });
-  if (me.has(c))
+  if (be.has(c))
     return;
-  if (u == null || u.throwIfAborted(), i !== void 0 && pt(i, s), _e(o)) {
+  if (u == null || u.throwIfAborted(), i !== void 0 && yt(i, s), Ie(o)) {
     if (!i)
       throw new Error(
         "runDepositorPresignFlow: this wallet requires approved deposit terms but none were provided. Fresh deposits must pass PreparePeginResult.depositTerms; resume flows must rebuild them from on-chain state (the vault app's rebuildDepositTerms)."
       );
     typeof o.validateDepositTerms == "function" && await o.validateDepositTerms(i), await o.approveDepositTerms(i);
   }
-  const d = await r.requestDepositorPresignTransactions(
+  const h = await r.requestDepositorPresignTransactions(
     {
       pegin_txid: a,
       depositor_pk: l
@@ -628,24 +628,24 @@ async function tr(e) {
     u
   );
   u == null || u.throwIfAborted();
-  const p = T(l);
-  gt(
-    d.txs,
+  const d = A(l);
+  bt(
+    h.txs,
     s.vaultProviderBtcPubkey,
     s.vaultKeeperBtcPubkeys,
     l
   );
-  const g = d.txs.filter(
-    (k) => T(k.claimer_pubkey) !== p
-  ), m = dt(g), f = await ft(
+  const g = h.txs.filter(
+    (b) => A(b.claimer_pubkey) !== d
+  ), m = vt(g), P = await wt(
     o,
     s,
     m,
-    h
+    p
   );
   u == null || u.throwIfAborted();
-  const v = await ut({
-    depositorGraph: d.depositor_graph,
+  const f = await gt({
+    depositorGraph: h.depositor_graph,
     btcWallet: o,
     signingContext: {
       vaultCoreVersion: s.vaultCoreVersion,
@@ -666,40 +666,40 @@ async function tr(e) {
     }
   });
   u == null || u.throwIfAborted();
-  const w = { ...f };
-  w[P(l)] = v.payout_signatures, await r.submitDepositorPresignatures(
+  const x = { ...P };
+  x[y(l)] = f.payout_signatures, await r.submitDepositorPresignatures(
     {
       pegin_txid: a,
       depositor_pk: l,
-      signatures: w,
-      depositor_claimer_presignatures: v
+      signatures: x,
+      depositor_claimer_presignatures: f
     },
     u
   );
 }
-const mt = 300 * 1e3, vt = /* @__PURE__ */ new Set([
-  C.PENDING_DEPOSITOR_WOTS_PK,
-  ...ce
+const Et = 300 * 1e3, kt = /* @__PURE__ */ new Set([
+  R.PENDING_DEPOSITOR_WOTS_PK,
+  ...ge
 ]);
-async function rr(e) {
+async function ur(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
     peginTxid: o,
     depositorPk: a,
     wotsPublicKeys: l,
-    timeoutMs: s = mt,
+    timeoutMs: s = Et,
     signal: i
   } = e;
   i == null || i.throwIfAborted();
-  const n = await fe({
+  const n = await ye({
     statusReader: t,
     peginTxid: o,
-    targetStatuses: vt,
+    targetStatuses: kt,
     timeoutMs: s,
     signal: i
   });
-  ce.has(n) || (i == null || i.throwIfAborted(), await r.submitDepositorWotsKey(
+  ge.has(n) || (i == null || i.throwIfAborted(), await r.submitDepositorWotsKey(
     {
       pegin_txid: o,
       depositor_pk: a,
@@ -711,27 +711,27 @@ async function rr(e) {
 function D(e) {
   return e.registration || e.operation;
 }
-function Pt(e, t, r) {
-  const o = R(e);
+function xt(e, t, r) {
+  const o = C(e);
   return {
-    registration: o === R(t),
-    operation: o === R(r)
+    registration: o === C(t),
+    operation: o === C(r)
   };
 }
-function W(e, t, r) {
-  const o = F(e);
+function ee(e, t, r) {
+  const o = M(e);
   return {
-    registration: Y(o, F(t)),
-    operation: Y(o, F(r))
+    registration: te(o, M(t)),
+    operation: te(o, M(r))
   };
 }
-function F(e) {
-  return e.map(R).sort();
+function M(e) {
+  return e.map(C).sort();
 }
-function Y(e, t) {
+function te(e, t) {
   return e.length === t.length && e.every((r, o) => r === t[o]);
 }
-async function or(e) {
+async function lr(e) {
   const {
     vaultProviderEthAddress: t,
     hintBtcPubkey: r,
@@ -740,9 +740,9 @@ async function or(e) {
     context: l
   } = e;
   if (!r) return;
-  const s = R(r);
-  if (s === R(o)) return;
-  const i = R(
+  const s = C(r);
+  if (s === C(o)) return;
+  const i = C(
     await a()
   );
   if (s !== i)
@@ -750,11 +750,11 @@ async function or(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 M(e, t, r) {
-  const o = `${e} operation key (admin=${t.ethAddress})`, a = z(
+function F(e, t, r) {
+  const o = `${e} operation key (admin=${t.ethAddress})`, a = Y(
     t.btcPubKey,
     `${e} roster key (admin=${t.ethAddress})`
-  ), l = z(r, o);
+  ), l = Y(r, o);
   return {
     adminAddress: t.ethAddress,
     genesisBtcPubkey: a,
@@ -762,7 +762,7 @@ function M(e, t, r) {
     rotated: l !== a
   };
 }
-function bt(e) {
+function Tt(e) {
   const t = /* @__PURE__ */ new Map();
   for (const r of e) {
     const o = t.get(r.operationBtcPubkey);
@@ -773,12 +773,12 @@ function bt(e) {
     t.set(r.operationBtcPubkey, r.adminAddress);
   }
 }
-function ve(e, t, r) {
+function we(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 = M(
+  const o = F(
     "vault provider",
     {
       ethAddress: e.vaultProviderEthAddress,
@@ -786,11 +786,11 @@ function ve(e, t, r) {
     },
     t.vaultProvider
   ), a = e.vaultKeepers.map(
-    (s, i) => M("vault keeper", s, t.vaultKeepers[i])
+    (s, i) => F("vault keeper", s, t.vaultKeepers[i])
   ), l = e.universalChallengers.map(
-    (s, i) => M("universal challenger", s, t.universalChallengers[i])
+    (s, i) => F("universal challenger", s, t.universalChallengers[i])
   );
-  return bt([
+  return Tt([
     o,
     ...a,
     ...l
@@ -805,25 +805,33 @@ function ve(e, t, r) {
     query: e
   };
 }
-async function yt(e) {
+async function At(e) {
   const t = await e.operationKeyReader.getCurrentOperationKeys(
     e.query,
     e.blockNumber
   );
-  return ve(e.query, t, { mode: "current" });
+  return we(e.query, t, { mode: "current" });
 }
-async function wt(e) {
+async function Ct(e) {
   const t = await e.operationKeyReader.getOperationKeysAtEpochs(
     e.query,
     e.epochs
   );
-  return ve(e.query, t, {
+  return we(e.query, t, {
     mode: "epochs",
     epochs: e.epochs
   });
 }
-const J = (e) => e.map(R).sort();
-async function nr(e) {
+class L extends Error {
+  constructor(t) {
+    super(t), this.name = "ApplicationEntryPointMismatchError";
+  }
+}
+function cr(e) {
+  return e instanceof L || e instanceof Error && e.name === "ApplicationEntryPointMismatchError";
+}
+const re = (e) => e.map(C).sort();
+async function pr(e) {
   const {
     vaultRegistryReader: t,
     vaultKeeperReader: r,
@@ -834,99 +842,123 @@ async function nr(e) {
     expectedVaultKeeperBtcPubkeys: i,
     expectedUniversalChallengerBtcPubkeys: n,
     operationKeyReader: u,
-    onIndexerServingOperationKeys: h,
+    onIndexerServingOperationKeys: p,
     onIndexerHintsInconsistent: c,
-    blockNumber: d
+    blockNumber: h
   } = e, [
-    p,
+    d,
     g,
-    m
+    m,
+    P
   ] = await Promise.all([
-    t.getVaultProviderGenesisBtcPubKey(
+    t.getVaultProviderApplication(
       a,
-      d
+      h
     ),
-    r.getCurrentVaultKeepersVersion(
-      l,
-      d
+    t.getVaultProviderGenesisBtcPubKey(
+      a,
+      h
     ),
-    o.getLatestUniversalChallengersVersion(d)
-  ]), [f, v] = await Promise.all([
+    o.getLatestUniversalChallengersVersion(h),
+    o.getCurrentUcKeyEpoch(h)
+  ]);
+  if (!Ne(l, { strict: !1 }))
+    throw new L(
+      `The application entry point this deposit was prepared for is not a valid address: ${l}`
+    );
+  if (!He(d, l))
+    throw new L(
+      `Vault provider ${a} is registered to application ${d}, but this deposit was prepared for ${l}. 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 [f, x] = await Promise.all(
+    [
+      r.getCurrentVaultKeepersVersion(
+        d,
+        h
+      ),
+      r.getCurrentAppKeeperKeyEpoch(
+        d,
+        h
+      )
+    ]
+  ), [b, w] = await Promise.all([
     r.getVaultKeepersByVersion(
-      l,
-      g,
-      d
+      d,
+      f,
+      h
     ),
     o.getUniversalChallengersByVersion(
       m,
-      d
+      h
     )
-  ]), w = {
-    vaultProvider: R(p),
-    vaultKeepers: J(f.map((E) => E.btcPubKey)),
-    universalChallengers: J(v.map((E) => E.btcPubKey))
-  }, k = await yt({
+  ]), E = {
+    vaultProvider: C(g),
+    vaultKeepers: re(b.map((k) => k.btcPubKey)),
+    universalChallengers: re(w.map((k) => k.btcPubKey))
+  }, T = await At({
     operationKeyReader: u,
     query: {
       vaultProviderEthAddress: a,
-      vaultProviderGenesisBtcPubkey: `0x${p}`,
-      applicationEntryPoint: l,
-      vaultKeepers: f,
-      universalChallengers: v
+      vaultProviderGenesisBtcPubkey: `0x${g}`,
+      applicationEntryPoint: d,
+      vaultKeepers: b,
+      universalChallengers: w
     },
-    blockNumber: d
-  }), b = {
-    vaultProvider: k.vaultProvider.operationBtcPubkey,
-    vaultKeepers: [...k.vaultKeeperOperationKeysSorted],
+    blockNumber: h
+  }), v = {
+    vaultProvider: T.vaultProvider.operationBtcPubkey,
+    vaultKeepers: [...T.vaultKeeperOperationKeysSorted],
     universalChallengers: [
-      ...k.universalChallengerOperationKeysSorted
+      ...T.universalChallengerOperationKeysSorted
     ]
-  }, x = Pt(
+  }, q = xt(
     s,
-    w.vaultProvider,
-    b.vaultProvider
-  ), A = W(
+    E.vaultProvider,
+    v.vaultProvider
+  ), G = ee(
     i,
-    w.vaultKeepers,
-    b.vaultKeepers
-  ), y = W(
+    E.vaultKeepers,
+    v.vaultKeepers
+  ), z = ee(
     n,
-    w.universalChallengers,
-    b.universalChallengers
+    E.universalChallengers,
+    v.universalChallengers
   );
-  if (!D(x))
+  if (!D(q))
     throw new Error(
       `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${a}. Refresh and try again.`
     );
-  if (!D(A))
+  if (!D(G))
     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${f}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
     );
-  if (!D(y))
+  if (!D(z))
     throw new Error(
       `Universal challenger BTC pubkeys (v${m}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
     );
-  const X = [x, A, y], Ee = X.some((E) => E.registration && !E.operation), G = X.some((E) => E.operation && !E.registration);
-  if (Ee && G) {
-    const E = `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(E), new Error(`${E} Refresh and try again.`);
+  const j = [q, G, z], Ce = j.some((k) => k.registration && !k.operation), Q = j.some((k) => k.operation && !k.registration);
+  if (Ce && Q) {
+    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 G && (h == null || h(
+  return Q && (p == null || p(
     `Indexer is serving rotated operation keys for vault provider ${a}`
   )), {
-    vaultProviderBtcPubkeyXOnly: b.vaultProvider,
-    vaultKeeperBtcPubkeysSorted: b.vaultKeepers,
-    universalChallengerBtcPubkeysSorted: b.universalChallengers,
-    expectedAppVaultKeepersVersion: g,
+    vaultProviderBtcPubkeyXOnly: v.vaultProvider,
+    vaultKeeperBtcPubkeysSorted: v.vaultKeepers,
+    universalChallengerBtcPubkeysSorted: v.universalChallengers,
+    expectedAppVaultKeepersVersion: f,
     expectedUniversalChallengersVersion: m,
-    registrationKeys: w,
-    participantKeys: k
+    appKeeperKeyEpoch: x,
+    ucKeyEpoch: P,
+    registrationKeys: E,
+    participantKeys: T
   };
 }
-function kt(e) {
+function Rt(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function sr(e) {
+function hr(e) {
   const {
     amountSats: t,
     minDeposit: r,
@@ -937,7 +969,7 @@ function sr(e) {
   } = e;
   return !(t <= 0n || t < r || o && o > 0n && t > o || l == null || s == null || t + l + s > a);
 }
-function ar(e, t, r) {
+function dr(e, t, r) {
   return e <= 0n ? {
     valid: !1,
     error: "Deposit amount must be greater than zero"
@@ -949,7 +981,7 @@ function ar(e, t, r) {
     error: `Maximum deposit is ${_(r)} BTC`
   } : { valid: !0 };
 }
-function ir(e) {
+function gr(e) {
   const { amount: t, effectiveRemaining: r } = e;
   return r === null ? { valid: !0 } : r === 0n ? {
     valid: !1,
@@ -959,7 +991,7 @@ function ir(e) {
     error: `Vault size exceeds remaining capacity (${_(r)} BTC)`
   } : { valid: !0 };
 }
-function ur(e, t) {
+function fr(e, t) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -975,7 +1007,7 @@ function ur(e, t) {
     error: "Invalid vault provider selected"
   } : { valid: !0 };
 }
-function Et(e, t, r) {
+function _t(e, t, r) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -1001,30 +1033,30 @@ function Et(e, t, r) {
   }
   return { valid: !0 };
 }
-function xt(e) {
-  const t = P(e);
-  return kt(t) ? { valid: !0 } : {
+function St(e) {
+  const t = y(e);
+  return Rt(t) ? { valid: !0 } : {
     valid: !1,
     error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
   };
 }
-function Tt(e) {
+function $t(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 Rt(e) {
+function Bt(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 Ct(e) {
+function It(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function lr(e) {
+function mr(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
@@ -1033,78 +1065,78 @@ function lr(e) {
     universalChallengerBtcPubkeys: l,
     minDeposit: s,
     maxDeposit: i
-  } = e, n = Et(
+  } = e, n = _t(
     t,
     s,
     i
   );
   if (!n.valid)
     throw new Error(n.error);
-  const u = xt(o);
+  const u = St(o);
   if (!u.valid)
     throw new Error(u.error);
-  Tt(a), Rt(l), Ct(r);
+  $t(a), Bt(l), It(r);
 }
-class Pe extends Error {
+class Ee extends Error {
   constructor(t) {
     super(t), this.name = "ParticipantKeyDriftError";
   }
 }
-function cr(e) {
-  return e instanceof Pe || e instanceof Error && e.name === "ParticipantKeyDriftError";
+function Pr(e) {
+  return e instanceof Ee || e instanceof Error && e.name === "ParticipantKeyDriftError";
 }
-function Z(e, t, r) {
+function oe(e, t, r) {
   return t.length === r.length && t.every((o, a) => o === r[a]) ? null : `${e} expected [${t.join(", ")}], got [${r.join(", ")}]`;
 }
-async function hr(e) {
+async function vr(e) {
   const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: o, expected: a } = e, l = a.query;
   if (o.length === 0) return;
   const s = await t.getVaultKeyEpochsBatch(o), i = [];
   for (const [n, u] of s.entries()) {
-    const h = o[n];
+    const p = o[n];
     let c;
     try {
-      c = await wt({
+      c = await Ct({
         operationKeyReader: r,
         query: l,
         epochs: u
       });
     } catch (g) {
       i.push(
-        `vault ${h}: could not resolve participants at frozen epochs (vp=${u.vpKeyEpoch}, keeper=${u.appKeeperKeyEpoch}, uc=${u.ucKeyEpoch}): ${g.message}`
+        `vault ${p}: 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 && i.push(
-      `vault ${h}: vault provider key expected ${a.vaultProvider.operationBtcPubkey}, got ${c.vaultProvider.operationBtcPubkey}`
+      `vault ${p}: vault provider key expected ${a.vaultProvider.operationBtcPubkey}, got ${c.vaultProvider.operationBtcPubkey}`
     );
-    const d = Z(
-      `vault ${h}: vault keeper keys`,
+    const h = oe(
+      `vault ${p}: vault keeper keys`,
       a.vaultKeeperOperationKeysSorted,
       c.vaultKeeperOperationKeysSorted
     );
-    d && i.push(d);
-    const p = Z(
-      `vault ${h}: universal challenger keys`,
+    h && i.push(h);
+    const d = oe(
+      `vault ${p}: universal challenger keys`,
       a.universalChallengerOperationKeysSorted,
       c.universalChallengerOperationKeysSorted
     );
-    p && i.push(p);
+    d && i.push(d);
   }
   if (i.length > 0)
-    throw new Pe(
+    throw new Ee(
       `Aborting BTC broadcast: participant operation keys changed during registration (${i.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-class be extends Error {
+class ke extends Error {
   constructor(t) {
     super(t), this.name = "RegisteredVaultVersionMismatchError";
   }
 }
-function dr(e) {
-  return e instanceof be || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
+function yr(e) {
+  return e instanceof ke || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function pr(e) {
+async function br(e) {
   const {
     vaultRegistryReader: t,
     vaultIds: r,
@@ -1113,8 +1145,8 @@ async function pr(e) {
     expectedUniversalChallengersVersion: l,
     expectedVaultCoreVersion: s
   } = e, i = await t.getProtocolInfoBatch(r), n = [];
-  if (i.forEach((u, h) => {
-    const c = r[h];
+  if (i.forEach((u, p) => {
+    const c = r[p];
     u.offchainParamsVersion !== o && n.push(
       `vault ${c}: offchainParams expected v${o}, got v${u.offchainParamsVersion}`
     ), u.appVaultKeepersVersion !== a && n.push(
@@ -1125,25 +1157,25 @@ async function pr(e) {
       `vault ${c}: vaultCoreVersion expected v${s} (build-time active), got v${u.vaultCoreVersion}`
     );
   }), n.length > 0)
-    throw new be(
+    throw new ke(
       `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${n.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-var ye = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(ye || {});
-const At = /* @__PURE__ */ new Set([
+var xe = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(xe || {});
+const Vt = /* @__PURE__ */ new Set([
   "PayoutBroadcast",
   "PayoutBlocked"
   /* PAYOUT_BLOCKED */
 ]);
-function gr(e) {
-  return Object.values(ye).includes(
+function wr(e) {
+  return Object.values(xe).includes(
     e
   );
 }
-function fr(e) {
-  return !!e && At.has(e);
+function Er(e) {
+  return !!e && Vt.has(e);
 }
-class _t extends Error {
+class Kt extends Error {
   constructor(r, o) {
     super(`Refund not yet mature (BIP68 not final): ${o.message}`);
     S(this, "vaultId");
@@ -1151,31 +1183,31 @@ class _t extends Error {
     this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = o;
   }
 }
-const St = /^0x[0-9a-fA-F]{64}$/, $t = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, we = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, ke = 160, ee = 2e3, te = 10n, re = 100n;
-function mr(e) {
+const Ot = /^0x[0-9a-fA-F]{64}$/, Nt = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, Te = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, Ae = 160, ne = 2e3, se = 10n, ae = 100n;
+function kr(e) {
   if (!Number.isFinite(e) || e <= 0)
     throw new Error(
       `feeRateSatsVb must be a positive finite number, got ${e}`
     );
-  return BigInt(Math.ceil(e * ke));
+  return BigInt(Math.ceil(e * Ae));
 }
-const Bt = 1, It = /non-BIP68-final/i;
-function U(e, t) {
+const Ht = 1, Dt = /non-BIP68-final/i;
+function X(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 (!St.test(e))
+  if (!Ot.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function L(e, t) {
+function U(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 Mt(e) {
+  if (X(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
     throw new Error(
       `htlcVout must be a non-negative integer, got ${e.htlcVout}`
     );
@@ -1187,7 +1219,7 @@ function Vt(e) {
     );
   for (let r = 0; r < e.batch.length; r++) {
     const o = e.batch[r];
-    if (U(o.hashlock, `batch[${r}].hashlock`), !Number.isInteger(o.htlcVout) || o.htlcVout !== r)
+    if (X(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}`
       );
@@ -1205,27 +1237,27 @@ function Vt(e) {
     throw new Error(
       `batch[${e.htlcVout}].amount (${t.amount}) does not match target amount (${e.amount})`
     );
-  if (L(e.offchainParamsVersion, "offchainParamsVersion"), L(e.appVaultKeepersVersion, "appVaultKeepersVersion"), L(
+  if (U(e.offchainParamsVersion, "offchainParamsVersion"), U(e.appVaultKeepersVersion, "appVaultKeepersVersion"), U(
     e.universalChallengersVersion,
     "universalChallengersVersion"
-  ), Xe(
+  ), We(
     e.vaultCoreVersion,
     "VaultRefundData.vaultCoreVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
     throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!$t.test(e.unsignedPrePeginTxHex))
+  if (!Nt.test(e.unsignedPrePeginTxHex))
     throw new Error(
       "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
     );
-  if (!e.depositorBtcPubkey || !we.test(e.depositorBtcPubkey))
+  if (!e.depositorBtcPubkey || !Te.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 Kt(e) {
-  if (!e.vaultProviderPubkey || !we.test(e.vaultProviderPubkey))
+function Ft(e) {
+  if (!e.vaultProviderPubkey || !Te.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");
@@ -1250,7 +1282,7 @@ function Kt(e) {
       `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
     );
 }
-async function vr(e) {
+async function xr(e) {
   const {
     vaultId: t,
     readVault: r,
@@ -1260,50 +1292,50 @@ async function vr(e) {
     broadcastTx: s,
     signal: i
   } = e;
-  i == null || i.throwIfAborted(), U(t, "vaultId");
+  i == null || i.throwIfAborted(), X(t, "vaultId");
   const n = await r();
-  Vt(n), i == null || i.throwIfAborted();
+  Mt(n), i == null || i.throwIfAborted();
   const u = await o(n);
-  if (Kt(u), i == null || i.throwIfAborted(), !Number.isFinite(a) || a <= 0)
+  if (Ft(u), i == null || i.throwIfAborted(), !Number.isFinite(a) || a <= 0)
     throw new Error(`feeRate must be a positive number, got ${a}`);
-  if (a > ee)
+  if (a > ne)
     throw new Error(
-      `feeRate ${a} sat/vB exceeds refund safety cap ${ee} sat/vB; refusing to sign refund.`
+      `feeRate ${a} sat/vB exceeds refund safety cap ${ne} sat/vB; refusing to sign refund.`
     );
-  const h = BigInt(Math.ceil(a * ke)), c = n.amount * te / re;
-  if (h > c)
+  const p = BigInt(Math.ceil(a * Ae)), c = n.amount * se / ae;
+  if (p > c)
     throw new Error(
-      `Refund fee ${h} sats exceeds the per-vault safety cap of ${c} sats (${te}/${re} of vault.amount=${n.amount}); refusing to sign refund.`
+      `Refund fee ${p} sats exceeds the per-vault safety cap of ${c} sats (${se}/${ae} of vault.amount=${n.amount}); refusing to sign refund.`
     );
   i == null || i.throwIfAborted();
-  const d = O(
+  const h = O(
     n.depositorBtcPubkey
-  ), p = P(n.unsignedPrePeginTxHex), g = $e(p);
+  ), d = y(n.unsignedPrePeginTxHex), g = Ke(d);
   if (g !== void 0 && g.vout !== n.batch.length)
     throw new Error(
       `Auth-anchor OP_RETURN at vout ${g.vout} does not match batch size (${n.batch.length} HTLC outputs expect the anchor at vout ${n.batch.length}). Refund refused — sibling HTLC vector is incomplete.`
     );
   const m = g == null ? void 0 : g.hash;
-  let f;
+  let P;
   try {
-    f = $.fromHex(p);
-  } catch (y) {
+    P = $.fromHex(d);
+  } catch (v) {
     throw new Error(
-      `Failed to parse funded Pre-PegIn transaction hex: ${y instanceof Error ? y.message : String(y)}`
+      `Failed to parse funded Pre-PegIn transaction hex: ${v instanceof Error ? v.message : String(v)}`
     );
   }
-  if (f.outs.length < n.batch.length)
+  if (P.outs.length < n.batch.length)
     throw new Error(
-      `Funded Pre-PegIn tx has ${f.outs.length} outputs but batch requires at least ${n.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
+      `Funded Pre-PegIn tx has ${P.outs.length} outputs but batch requires at least ${n.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
     );
-  const { psbtHex: v } = await Fe({
+  const { psbtHex: f } = await Ge({
     prePeginParams: {
       vaultCoreVersion: n.vaultCoreVersion,
-      depositorPubkey: d,
-      vaultProviderPubkey: P(u.vaultProviderPubkey),
-      vaultKeeperPubkeys: u.vaultKeeperPubkeys.map(P),
-      universalChallengerPubkeys: u.universalChallengerPubkeys.map(P),
-      hashlocks: n.batch.map((y) => P(y.hashlock)),
+      depositorPubkey: h,
+      vaultProviderPubkey: y(u.vaultProviderPubkey),
+      vaultKeeperPubkeys: u.vaultKeeperPubkeys.map(y),
+      universalChallengerPubkeys: u.universalChallengerPubkeys.map(y),
+      hashlocks: n.batch.map((v) => y(v.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
@@ -1311,7 +1343,7 @@ async function vr(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: n.batch.map((y) => y.amount),
+      pegInAmounts: n.batch.map((v) => v.amount),
       feeRate: u.feeRate,
       minPeginFeeRate: u.minPeginFeeRate,
       numLocalChallengers: u.numLocalChallengers,
@@ -1320,48 +1352,48 @@ async function vr(e) {
       network: u.network,
       authAnchorHash: m
     },
-    fundedPrePeginTxHex: p,
+    fundedPrePeginTxHex: d,
     htlcVout: n.htlcVout,
-    refundFee: h,
+    refundFee: p,
     // buildRefundPsbt's top-level `hashlock` param is documented as "no 0x
     // prefix" and flows into the WASM HTLC connector derivation; a prefixed
     // value would derive the wrong refund script leaf and yield an
     // unspendable PSBT. Match the `hashlocks` array handling above.
-    hashlock: P(n.hashlock)
+    hashlock: y(n.hashlock)
   });
   i == null || i.throwIfAborted();
-  const w = K(
+  const x = K(
     n.depositorBtcPubkey,
-    Bt
-  ), k = await l(v, w);
+    Ht
+  ), b = await l(f, x);
   B({
-    requestedPsbtHex: v,
-    returnedPsbtHex: k
+    requestedPsbtHex: f,
+    returnedPsbtHex: b
   });
-  const b = 0, x = I(
-    k,
-    d,
-    b
+  const w = 0, E = I(
+    b,
+    h,
+    w
   );
   V({
-    requestedPsbtHex: v,
-    signatureHex: x,
-    signerXOnlyPubkeyHex: d,
-    inputIndex: b
+    requestedPsbtHex: f,
+    signatureHex: E,
+    signerXOnlyPubkeyHex: h,
+    inputIndex: w
   });
-  const A = he({
-    requestedPsbtHex: v,
-    signaturesHex: [x],
-    signerXOnlyPubkeyHex: d
+  const T = fe({
+    requestedPsbtHex: f,
+    signaturesHex: [E],
+    signerXOnlyPubkeyHex: h
   });
   i == null || i.throwIfAborted();
   try {
-    return await s(A);
-  } catch (y) {
-    throw y instanceof Error && It.test(y.message) ? new _t(t, y) : y;
+    return await s(T);
+  } catch (v) {
+    throw v instanceof Error && Dt.test(v.message) ? new Kt(t, v) : v;
   }
 }
-class oe extends Error {
+class ie extends Error {
   constructor(r, o, a) {
     super(r);
     /** Fee the reclaim would have paid, in satoshis. */
@@ -1371,13 +1403,13 @@ class oe extends Error {
     this.name = "ReclaimUneconomicalError", this.feeSats = o, this.sweptTotalSats = a;
   }
 }
-const ne = 2e3, se = 25n, ae = 100n, Pr = 10n;
-async function Ot(e, t, r) {
+const ue = 2e3, le = 25n, ce = 100n, Tr = 10n;
+async function Ut(e, t, r) {
   for (let o = 0; o < e.length; o++) {
-    const a = Ue(e[o].depositorSignedPeginTxHex), l = ue(
-      await Ge(
-        P(a),
-        P(r)
+    const a = Qe(e[o].depositorSignedPeginTxHex), l = he(
+      await Ye(
+        y(a),
+        y(r)
       )
     ).toLowerCase();
     if (l !== t[o].toLowerCase())
@@ -1386,7 +1418,7 @@ async function Ot(e, t, r) {
       );
   }
 }
-async function br(e) {
+async function Ar(e) {
   const {
     vaultIds: t,
     depositorEthAddress: r,
@@ -1401,9 +1433,9 @@ async function br(e) {
     throw new Error("Reclaim requires at least one vault id; got none.");
   if (!Number.isFinite(l) || l <= 0)
     throw new Error(`feeRate must be a positive number, got ${l}`);
-  if (l > ne)
-    throw new oe(
-      `Fee rate ${l} sat/vB exceeds the reclaim safety cap of ${ne} sat/vB; refusing to sign.`,
+  if (l > ue)
+    throw new ie(
+      `Fee rate ${l} sat/vB exceeds the reclaim safety cap of ${ue} sat/vB; refusing to sign.`,
       0n,
       0n
     );
@@ -1412,100 +1444,102 @@ async function br(e) {
     throw new Error(
       `readVaults returned ${u.length} reserves for ${t.length} vault id(s); refusing to sweep a set that does not match the request.`
     );
-  await Ot(u, t, r), n == null || n.throwIfAborted();
-  const h = O(o), c = u.map((b) => ({
-    depositorSignedPeginTxHex: b.depositorSignedPeginTxHex,
-    observed: b.observed,
-    expectedValue: b.expectedClaimValue
-  })), d = Me(l, c.length), p = c.reduce((b, x) => b + x.expectedValue, 0n), g = p * se / ae;
-  if (d > g)
-    throw new oe(
-      `Reclaim fee ${d} sats exceeds ${se}/${ae} of the swept total (${p} sats, cap ${g} sats). The reserve is not at risk — it stays where it is until fee rates fall.`,
-      d,
-      p
+  await Ut(u, t, r), n == null || n.throwIfAborted();
+  const p = O(o), c = u.map((w) => ({
+    depositorSignedPeginTxHex: w.depositorSignedPeginTxHex,
+    observed: w.observed,
+    expectedValue: w.expectedClaimValue
+  })), h = ze(l, c.length), d = c.reduce((w, E) => w + E.expectedValue, 0n), g = d * le / ce;
+  if (h > g)
+    throw new ie(
+      `Reclaim fee ${h} sats exceeds ${le}/${ce} of the swept total (${d} sats, cap ${g} sats). The reserve is not at risk — it stays where it is until fee rates fall.`,
+      h,
+      d
     );
   n == null || n.throwIfAborted();
-  const { psbtHex: m } = Le({
-    depositorPubkey: h,
+  const { psbtHex: m } = je({
+    depositorPubkey: p,
     inputs: c,
-    feeSats: d
+    feeSats: h
   });
   n == null || n.throwIfAborted();
-  const f = K(
+  const P = K(
     o,
     c.length
-  ), v = await s(m, f);
+  ), f = await s(m, P);
   B({
     requestedPsbtHex: m,
-    returnedPsbtHex: v
+    returnedPsbtHex: f
   });
-  const w = c.map((b, x) => {
-    const A = I(
-      v,
-      h,
-      x
+  const x = c.map((w, E) => {
+    const T = I(
+      f,
+      p,
+      E
     );
     return V({
       requestedPsbtHex: m,
-      signatureHex: A,
-      signerXOnlyPubkeyHex: h,
-      inputIndex: x
-    }), A;
-  }), k = he({
+      signatureHex: T,
+      signerXOnlyPubkeyHex: p,
+      inputIndex: E
+    }), T;
+  }), b = fe({
     requestedPsbtHex: m,
-    signaturesHex: w,
-    signerXOnlyPubkeyHex: h
+    signaturesHex: x,
+    signerXOnlyPubkeyHex: p
   });
-  return n == null || n.throwIfAborted(), i(k);
+  return n == null || n.throwIfAborted(), i(b);
 }
 export {
-  Pt as A,
-  W as B,
-  yt as C,
-  wt as D,
-  ye as E,
-  gr as F,
-  fr as G,
-  _t as H,
-  vr as I,
-  mr as J,
-  re as K,
-  te as L,
-  ee as M,
-  ke as N,
-  oe as O,
-  Ye as P,
-  br as Q,
-  be as R,
-  ae as S,
-  se as T,
-  ne as U,
-  Pr as V,
-  Yt as a,
-  Jt as b,
-  pe as c,
-  ge as d,
-  Zt as e,
-  rr as f,
-  sr as g,
-  ar as h,
-  tt as i,
-  lr as j,
-  ur as k,
-  ir as l,
-  Et as m,
-  xt as n,
-  Pe as o,
-  cr as p,
-  hr as q,
-  tr as r,
-  ut as s,
-  dr as t,
-  pr as u,
-  nr as v,
-  er as w,
-  fe as x,
-  or as y,
-  D as z
+  L as A,
+  D as B,
+  xt as C,
+  ee as D,
+  At as E,
+  Ct as F,
+  xe as G,
+  wr as H,
+  Er as I,
+  Kt as J,
+  xr as K,
+  kr as L,
+  ae as M,
+  se as N,
+  ne as O,
+  ot as P,
+  Ae as Q,
+  ke as R,
+  ie as S,
+  Ar as T,
+  ce as U,
+  le as V,
+  ue as W,
+  Tr as X,
+  or as a,
+  nr as b,
+  Pe as c,
+  ve as d,
+  sr as e,
+  ur as f,
+  cr as g,
+  hr as h,
+  it as i,
+  dr as j,
+  mr as k,
+  fr as l,
+  gr as m,
+  _t as n,
+  St as o,
+  Ee as p,
+  Pr as q,
+  ir as r,
+  gt as s,
+  vr as t,
+  yr as u,
+  pr as v,
+  ar as w,
+  br as x,
+  ye as y,
+  lr as z
 };
-//# sourceMappingURL=buildAndBroadcastReclaim-DCGcupg7.js.map
+//# sourceMappingURL=buildAndBroadcastReclaim-O6z9kvc4.js.map