@babylonlabs-io/ts-sdk 0.58.1 → 0.59.0

package/dist/{buildAndBroadcastRefund-DBA-Mp4I.js → buildAndBroadcastRefund-C-rbYMy6.js}

@@ -1,122 +1,148 @@
-var he = Object.defineProperty;
-var de = (e, t, r) => t in e ? he(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var A = (e, t, r) => de(e, typeof t != "symbol" ? t + "" : t, r);
-import { B as ge } from "./BTCVaultRegistry.abi-CixOlp3B.js";
-import { e as fe, v as ye, s as d, u as te, p as L, c as k, f as C } from "./bitcoin-d9eaaZB_.js";
-import { v as ve, b as Pe, s as me, P as be, d as we } from "./signPsbtsWithFallback-eY1YgV13.js";
-import { D as E, c as ke, b as xe, R as Ee, d as re } from "./json-rpc-client-DuUARJvV.js";
-import { Transaction as $, Psbt as Ce } from "bitcoinjs-lib";
-import { c as Te, d as N, e as D, f as F } from "./verifyScriptPathSchnorrSignature-Bav08_7R.js";
-import { c as Se, a as $e, b as _e } from "./noPayout-DuE-UyhQ.js";
+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-Ch0IiqNK.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";
 import { c as M } from "./signing-DaLvGwQe.js";
 import { a as X } from "./onChainBtcPubkey-DeF4cKoO.js";
-import { a as Be } from "./constants-GjWXdaqV.js";
-const Ae = /^0x[0-9a-fA-F]{64}$/, Re = /^0x[0-9a-fA-F]{40}$/, Ke = /^0x([0-9a-fA-F]{2})*$/;
+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) {
   if (e.length !== 66)
     throw new Error(
       `${t} must be 32 bytes (66 hex chars with 0x prefix), got length ${e.length}`
     );
-  if (!Ae.test(e))
+  if (!Re.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function Ve(e, t) {
-  if (!Re.test(e))
+function Ie(e, t) {
+  if (!Ve.test(e))
     throw new Error(
       `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
     );
 }
-function Ie(e, t) {
+function Oe(e, t) {
   if (!Ke.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
 }
-async function _t(e) {
+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)))
+    throw new Error(
+      "Invalid secret: SHA256(secret) does not match the provided hashlock"
+    );
+  return t;
+}
+async function Bt(e) {
   const {
     btcVaultRegistryAddress: t,
     vaultId: r,
     hashlock: n,
-    activationMetadata: s,
-    writeContract: l,
+    activationMetadata: a,
+    writeContract: u,
     signal: o
   } = e;
-  o == null || o.throwIfAborted(), Ve(t, "btcVaultRegistryAddress"), R(r, "vaultId");
-  const a = fe(e.secret);
-  if (R(a, "secret"), n !== void 0 && (R(n, "hashlock"), !ve(a, n)))
-    throw new Error(
-      "Invalid secret: SHA256(secret) does not match the provided hashlock"
-    );
-  return Ie(s, "activationMetadata"), l({
+  o == null || o.throwIfAborted();
+  const s = oe({
+    btcVaultRegistryAddress: t,
+    vaultId: r,
+    secret: e.secret,
+    hashlock: n
+  });
+  return Oe(a, "activationMetadata"), u({
     address: t,
-    abi: ge,
+    abi: te,
     functionName: "activateVaultWithSecret",
-    args: [r, a, s]
+    args: [r, s, a]
+  });
+}
+async function At(e) {
+  const { btcVaultRegistryAddress: t, vaultId: r, hashlock: n, writeContract: a, signal: u } = e;
+  u == null || u.throwIfAborted();
+  const o = oe({
+    btcVaultRegistryAddress: t,
+    vaultId: r,
+    secret: e.secret,
+    hashlock: n
+  });
+  return a({
+    address: t,
+    abi: te,
+    functionName: "activateVaultWithSecretAndRedeem",
+    args: [r, o]
   });
 }
-const G = 1, Oe = 1;
-function He(e, t) {
-  const r = d(t).toLowerCase(), s = e.map((l) => d(l).toLowerCase()).filter((l) => l !== r);
-  if (s.length === 0)
+const G = 1, He = 1;
+function Ne(e, t) {
+  const r = d(t).toLowerCase(), a = e.map((u) => d(u).toLowerCase()).filter((u) => u !== r);
+  if (a.length === 0)
     throw new Error(
       "Cannot derive localChallengers: vault keeper set is empty (or contains only the depositor)"
     );
-  if (new Set(s).size !== s.length)
+  if (new Set(a).size !== a.length)
     throw new Error(
       "Cannot derive localChallengers: duplicate vaultKeeper key — signing context is misconfigured"
     );
-  return s;
+  return a;
 }
-function Ne(e, t, r) {
+function De(e, t, r) {
   const n = r.map(
     (c) => d(c).toLowerCase()
-  ), s = t.filter((c) => n.includes(c));
-  if (s.length > 0)
+  ), a = t.filter((c) => n.includes(c));
+  if (a.length > 0)
     throw new Error(
-      `Cannot validate challenger set: vault keepers and universal challengers overlap (${s.join(", ")})`
+      `Cannot validate challenger set: vault keepers and universal challengers overlap (${a.join(", ")})`
     );
-  const l = [...t, ...n], o = e.map(
+  const u = [...t, ...n], o = e.map(
     (c) => d(c.challenger_pubkey).toLowerCase()
-  ), a = new Set(o);
-  if (a.size !== o.length)
+  ), 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) => !a.has(c)), p = o.filter((c) => !u.has(c));
+  const l = new Set(u), i = u.filter((c) => !s.has(c)), p = o.filter((c) => !l.has(c));
   if (i.length > 0 || p.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(", ")})` : "")
     );
 }
-function De(e, t) {
+function Fe(e, t) {
   const r = e.ins[t];
-  return te(new Uint8Array(r.hash).slice().reverse());
+  return re(new Uint8Array(r.hash).slice().reverse());
 }
-function K(e, t, r, n, s) {
-  const l = e.ins[t];
-  if (l.index !== 0)
+function V(e, t, r, n, a) {
+  const u = e.ins[t];
+  if (u.index !== 0)
     throw new Error(
-      `NoPayout (challenger ${s}) input ${t} expected to spend ${n} vout 0, got vout ${l.index}`
+      `NoPayout (challenger ${a}) input ${t} expected to spend ${n} vout 0, got vout ${u.index}`
     );
-  const o = r.getId(), a = De(e, t);
-  if (a !== o)
+  const o = r.getId(), s = Fe(e, t);
+  if (s !== o)
     throw new Error(
-      `NoPayout (challenger ${s}) input ${t} does not reference ${n} (expected txid ${o}, got ${a})`
+      `NoPayout (challenger ${a}) input ${t} does not reference ${n} (expected txid ${o}, got ${s})`
     );
 }
-async function Fe(e, t, r) {
-  const n = [], s = [], l = [], o = He(
+async function Me(e, t, r) {
+  const n = [], a = [], u = [], o = Ne(
     r.vaultKeeperBtcPubkeys,
     r.depositorBtcPubkey
   );
-  Ne(
+  De(
     e.challenger_presign_data,
     o,
     r.universalChallengerBtcPubkeys
   );
-  const a = await Te({
+  const s = await Se({
     vaultCoreVersion: r.vaultCoreVersion,
     vkClaimerPayoutScriptPubKeys: r.vkClaimerPayoutScriptPubKeys,
     vpCommissionScriptPubKey: r.vpCommissionScriptPubKey,
@@ -132,100 +158,100 @@ async function Fe(e, t, r) {
     network: r.network,
     claimerBtcPubkey: r.depositorBtcPubkey,
     registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
-    commissionBps: Oe,
+    commissionBps: He,
     protocolFeeRate: r.protocolFeeRate,
     councilSize: r.councilMembers.length
   });
-  n.push(a.psbtHex), s.push(
+  n.push(s.psbtHex), a.push(
     M(
       t,
       G
     )
   );
-  const u = d(r.depositorBtcPubkey), i = $.fromHex(
+  const l = d(r.depositorBtcPubkey), i = $.fromHex(
     d(e.assert_tx.tx_hex)
   );
   for (const p of e.challenger_presign_data) {
-    const c = d(p.challenger_pubkey), h = n.length, f = await Me({
+    const c = d(p.challenger_pubkey), h = n.length, f = await Ue({
       challenger: p,
       challengerPubkey: c,
-      claimerPubkey: u,
+      claimerPubkey: l,
       localChallengers: o,
       assertTxParsed: i,
       ctx: r
     });
-    n.push(f), s.push(
+    n.push(f), a.push(
       M(
         t,
         G
       )
-    ), l.push({
+    ), u.push({
       challengerPubkey: c,
       noPayoutIdx: h
     });
   }
-  return { psbtHexes: n, signOptions: s, challengerEntries: l };
+  return { psbtHexes: n, signOptions: a, challengerEntries: u };
 }
-async function Me(e) {
+async function Ue(e) {
   const {
     challenger: t,
     challengerPubkey: r,
     claimerPubkey: n,
-    localChallengers: s,
-    assertTxParsed: l,
+    localChallengers: a,
+    assertTxParsed: u,
     ctx: o
   } = e;
-  Se(
+  $e(
     t.nopayout_tx.tx_hex,
     r,
     o.network
   );
-  const a = $.fromHex(
+  const s = $.fromHex(
     d(t.nopayout_tx.tx_hex)
-  ), u = $.fromHex(
+  ), l = $.fromHex(
     d(t.challenge_assert_x_tx.tx_hex)
   ), i = $.fromHex(
     d(t.challenge_assert_y_tx.tx_hex)
   );
-  if (a.ins.length !== 3)
+  if (s.ins.length !== 3)
     throw new Error(
-      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${a.ins.length}`
+      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${s.ins.length}`
     );
-  K(
-    a,
+  V(
+    s,
     0,
-    l,
+    u,
     "Assert",
     r
-  ), K(
-    a,
+  ), V(
+    s,
     1,
-    u,
+    l,
     "ChallengeAssertX",
     r
-  ), K(
-    a,
+  ), V(
+    s,
     2,
     i,
     "ChallengeAssertY",
     r
   );
   const p = [
-    l.outs[0],
     u.outs[0],
+    l.outs[0],
     i.outs[0]
   ].map((c) => ({
-    script_pubkey: te(new Uint8Array(c.script)),
+    script_pubkey: re(new Uint8Array(c.script)),
     value: c.value
   }));
-  return $e({
+  return _e({
     noPayoutTxHex: t.nopayout_tx.tx_hex,
     challengerPubkey: r,
     prevouts: p,
     connectorParams: {
       txGraphVersion: o.vaultCoreVersion,
       claimer: n,
-      localChallengers: s,
+      localChallengers: a,
       universalChallengers: o.universalChallengerBtcPubkeys,
       timelockAssert: o.timelockAssert,
       councilMembers: o.councilMembers,
@@ -233,103 +259,103 @@ async function Me(e) {
     }
   });
 }
-function Ue(e, t, r) {
+function Le(e, t, r) {
   N(e[0]);
-  const s = D(
+  const a = D(
     e[0].returnedPsbtHex,
     r
   );
   F({
     requestedPsbtHex: e[0].requestedPsbtHex,
-    signatureHex: s,
+    signatureHex: a,
     signerXOnlyPubkeyHex: r,
     inputIndex: 0
   });
-  const l = {};
+  const u = {};
   for (const o of t) {
     N(e[o.noPayoutIdx]);
-    const a = D(
+    const s = D(
       e[o.noPayoutIdx].returnedPsbtHex,
       r
     );
     F({
       requestedPsbtHex: e[o.noPayoutIdx].requestedPsbtHex,
-      signatureHex: a,
+      signatureHex: s,
       signerXOnlyPubkeyHex: r,
       inputIndex: 0
-    }), l[o.challengerPubkey] = {
-      nopayout_signature: a
+    }), u[o.challengerPubkey] = {
+      nopayout_signature: s
     };
   }
   return {
     payout_signatures: {
-      payout_signature: s
+      payout_signature: a
     },
-    per_challenger: l
+    per_challenger: u
   };
 }
-async function Le(e) {
-  const { depositorGraph: t, btcWallet: r, signingContext: n } = e, s = await r.getPublicKeyHex(), { depositorPubkey: l } = ye(
-    s,
+async function ze(e) {
+  const { depositorGraph: t, btcWallet: r, signingContext: n } = e, a = await r.getPublicKeyHex(), { depositorPubkey: u } = ye(
+    a,
     d(n.depositorBtcPubkey)
-  ), { psbtHexes: o, signOptions: a, challengerEntries: u } = await Fe(
+  ), { psbtHexes: o, signOptions: s, challengerEntries: l } = await Me(
     t,
-    s,
+    a,
     n
-  ), i = await Pe(
+  ), i = await me(
     r,
     o,
-    a
+    s
   ), p = o.map((c, h) => ({
     requestedPsbtHex: c,
     returnedPsbtHex: i[h]
   }));
-  return Ue(
+  return Le(
     p,
-    u,
-    l
+    l,
+    u
   );
 }
-const ze = 1e4;
-async function ne(e) {
+const Xe = 1e4;
+async function ae(e) {
   const {
     statusReader: t,
     peginTxid: r,
     targetStatuses: n,
-    timeoutMs: s,
-    pollIntervalMs: l = ze,
+    timeoutMs: a,
+    pollIntervalMs: u = Xe,
     signal: o
-  } = e, a = Date.now();
+  } = e, s = Date.now();
   for (; ; ) {
     if (o != null && o.aborted)
       throw new Error(
         `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
       );
-    if (Date.now() - a >= s)
+    if (Date.now() - s >= a)
       throw new Error(
-        `Polling timeout after ${s}ms for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
+        `Polling timeout after ${a}ms for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
       );
     try {
-      const u = await t.getPeginStatus(
+      const l = await t.getPeginStatus(
         { pegin_txid: r },
         o
       );
-      if (u.pegin_txid.toLowerCase() !== r.toLowerCase())
+      if (l.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 ${l.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
         );
-      const i = u.status;
+      const i = l.status;
       if (n.has(i) || i === E.ACTIVATED)
         return i;
-      if (i === E.EXPIRED || ke.has(i))
+      if (i === E.EXPIRED || xe.has(i))
         throw new Error(
           `Pegin ${r.slice(0, 8)}… reached terminal status "${i}" while waiting for ${[...n].join(", ")}`
         );
-    } catch (u) {
-      if (!(u instanceof xe && u.code === Ee.PEGIN_NOT_FOUND))
-        throw u;
+    } catch (l) {
+      if (!(l instanceof Ee && l.code === Ce.PEGIN_NOT_FOUND))
+        throw l;
     }
-    await new Promise((u, i) => {
+    await new Promise((l, i) => {
       const p = () => {
         clearTimeout(c), i(
           new Error(
@@ -337,22 +363,22 @@ async function ne(e) {
           )
         );
       }, c = setTimeout(() => {
-        o == null || o.removeEventListener("abort", p), u();
-      }, l);
+        o == null || o.removeEventListener("abort", p), l();
+      }, u);
       o == null || o.addEventListener("abort", p, { once: !0 });
     });
   }
 }
-const Xe = 1200 * 1e3, oe = /* @__PURE__ */ new Set([
+const Ge = 1200 * 1e3, se = /* @__PURE__ */ new Set([
   E.PENDING_ACKS,
   E.PENDING_ACTIVATION,
   E.ACTIVATED_PENDING_BROADCAST,
   E.ACTIVATED
-]), Ge = /* @__PURE__ */ new Set([
+]), je = /* @__PURE__ */ new Set([
   E.PENDING_DEPOSITOR_SIGNATURES,
-  ...oe
+  ...se
 ]);
-function je(e) {
+function qe(e) {
   return e.map((t) => ({
     claimerPubkeyXOnly: L(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
@@ -362,22 +388,22 @@ function je(e) {
 function w(e) {
   return L(e).toLowerCase();
 }
-function qe(e, t) {
-  const r = (a, u, i) => {
+function Qe(e, t) {
+  const r = (s, l, i) => {
     throw new Error(
-      `Deposit terms ${a} (${String(u)}) does not match the vault's version-locked signing context (${String(i)}); refusing to sign payouts against terms that describe a different graph.`
+      `Deposit terms ${s} (${String(l)}) does not match the vault's version-locked signing context (${String(i)}); refusing to sign payouts against terms that describe a different graph.`
     );
   };
   e.protocolFeeRate !== t.protocolFeeRate && r("protocolFeeRate", e.protocolFeeRate, t.protocolFeeRate);
-  const n = (a) => a.map(w).sort(), s = (a, u) => {
-    const i = n(a), p = n(u);
+  const n = (s) => s.map(w).sort(), a = (s, l) => {
+    const i = n(s), p = n(l);
     return i.length === p.length && i.every((c, h) => c === p[h]);
   };
-  s(e.vaultKeeperBtcPubkeys, t.vaultKeeperBtcPubkeys) || r(
+  a(e.vaultKeeperBtcPubkeys, t.vaultKeeperBtcPubkeys) || r(
     "vaultKeeperBtcPubkeys",
     e.vaultKeeperBtcPubkeys.join(","),
     t.vaultKeeperBtcPubkeys.join(",")
-  ), s(
+  ), a(
     e.universalChallengerBtcPubkeys,
     t.universalChallengerBtcPubkeys
   ) || r(
@@ -385,34 +411,34 @@ function qe(e, t) {
     e.universalChallengerBtcPubkeys.join(","),
     t.universalChallengerBtcPubkeys.join(",")
   );
-  const l = w(t.vaultProviderBtcPubkey), o = e.vaults.map(
-    (a) => w(a.vaultProviderBtcPubkey)
+  const u = w(t.vaultProviderBtcPubkey), o = e.vaults.map(
+    (s) => w(s.vaultProviderBtcPubkey)
   );
-  o.includes(l) || r(
+  o.includes(u) || r(
     "vaults[].vaultProviderBtcPubkey",
     o.join(",") || "<no vaults>",
     t.vaultProviderBtcPubkey
   );
 }
-function Qe(e, t, r, n) {
-  const s = w(n), l = [
+function We(e, t, r, n) {
+  const a = w(n), u = [
     w(t),
     ...r.map(w)
-  ], o = new Set(l);
-  if (o.size !== l.length)
+  ], o = new Set(u);
+  if (o.size !== u.length)
     throw new Error(
       "Cannot validate claimer set: signing context contains duplicate vault provider or vault keeper key"
     );
-  if (o.has(s))
+  if (o.has(a))
     throw new Error(
       "Cannot validate claimer set: depositor key overlaps with vault provider or vault keeper set"
     );
-  const a = e.map(
+  const s = e.map(
     (h) => w(h.claimer_pubkey)
   );
-  if (new Set(a).size !== a.length)
+  if (new Set(s).size !== s.length)
     throw new Error("Presign response contains duplicate claimer entries");
-  const u = a.filter((h) => h !== s), i = new Set(u), p = l.filter((h) => !i.has(h)), c = u.filter((h) => !o.has(h));
+  const l = s.filter((h) => h !== a), i = new Set(l), p = u.filter((h) => !i.has(h)), c = l.filter((h) => !o.has(h));
   if (p.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(", ")})` : "")
@@ -440,92 +466,92 @@ function j(e, t) {
   };
 }
 async function Ye(e, t, r, n) {
-  const s = new be({
+  const a = new we({
     network: t.network,
     btcWallet: e
-  }), l = r.length;
-  n == null || n(0, l);
+  }), u = r.length;
+  n == null || n(0, u);
   let o;
-  if (s.supportsBatchSigning())
-    o = (await s.signPayoutTransactionsBatch(
+  if (a.supportsBatchSigning())
+    o = (await a.signPayoutTransactionsBatch(
       r.map((i) => j(i, t))
     )).map((i) => i.payoutSignature);
   else {
     o = [];
-    for (let u = 0; u < r.length; u++) {
-      n == null || n(u, l);
-      const i = await s.signPayoutTransaction(
-        j(r[u], t)
+    for (let l = 0; l < r.length; l++) {
+      n == null || n(l, u);
+      const i = await a.signPayoutTransaction(
+        j(r[l], t)
       );
       o.push(i.signature);
     }
   }
-  const a = {};
-  for (let u = 0; u < r.length; u++)
-    a[r[u].claimerPubkeyXOnly] = {
-      payout_signature: o[u]
+  const s = {};
+  for (let l = 0; l < r.length; l++)
+    s[r[l].claimerPubkeyXOnly] = {
+      payout_signature: o[l]
     };
-  return n == null || n(l, l), a;
+  return n == null || n(u, u), s;
 }
-async function Bt(e) {
+async function Rt(e) {
   const {
     statusReader: t,
     presignClient: r,
     btcWallet: n,
-    peginTxid: s,
-    depositorPk: l,
+    peginTxid: a,
+    depositorPk: u,
     signingContext: o,
-    depositTerms: a,
-    timeoutMs: u = Xe,
+    depositTerms: s,
+    timeoutMs: l = Ge,
     signal: i,
     onProgress: p
-  } = e, c = await ne({
+  } = e, c = await ae({
     statusReader: t,
-    peginTxid: s,
-    targetStatuses: Ge,
-    timeoutMs: u,
+    peginTxid: a,
+    targetStatuses: je,
+    timeoutMs: l,
     signal: i
   });
-  if (oe.has(c))
+  if (se.has(c))
     return;
-  if (i == null || i.throwIfAborted(), a !== void 0 && qe(a, o), me(n)) {
-    if (!a)
+  if (i == null || i.throwIfAborted(), s !== void 0 && Qe(s, o), be(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(a);
+    await n.approveDepositTerms(s);
   }
   const h = await r.requestDepositorPresignTransactions(
     {
-      pegin_txid: s,
-      depositor_pk: l
+      pegin_txid: a,
+      depositor_pk: u
     },
     i
   );
   i == null || i.throwIfAborted();
-  const f = w(l);
-  Qe(
+  const f = w(u);
+  We(
     h.txs,
     o.vaultProviderBtcPubkey,
     o.vaultKeeperBtcPubkeys,
-    l
+    u
   );
-  const y = h.txs.filter(
-    (v) => w(v.claimer_pubkey) !== f
-  ), T = je(y), x = await Ye(
+  const v = h.txs.filter(
+    (y) => w(y.claimer_pubkey) !== f
+  ), T = qe(v), x = await Ye(
     n,
     o,
     T,
     p
   );
   i == null || i.throwIfAborted();
-  const m = await Le({
+  const m = await ze({
     depositorGraph: h.depositor_graph,
     btcWallet: n,
     signingContext: {
       vaultCoreVersion: o.vaultCoreVersion,
       peginTxHex: o.peginTxHex,
-      depositorBtcPubkey: l,
+      depositorBtcPubkey: u,
       vaultProviderBtcPubkey: o.vaultProviderBtcPubkey,
       vaultKeeperBtcPubkeys: o.vaultKeeperBtcPubkeys,
       universalChallengerBtcPubkeys: o.universalChallengerBtcPubkeys,
@@ -542,51 +568,51 @@ async function Bt(e) {
   });
   i == null || i.throwIfAborted();
   const b = { ...x };
-  b[d(l)] = m.payout_signatures, await r.submitDepositorPresignatures(
+  b[d(u)] = m.payout_signatures, await r.submitDepositorPresignatures(
     {
-      pegin_txid: s,
-      depositor_pk: l,
+      pegin_txid: a,
+      depositor_pk: u,
       signatures: b,
       depositor_claimer_presignatures: m
     },
     i
   );
 }
-const We = 300 * 1e3, Je = /* @__PURE__ */ new Set([
+const Je = 300 * 1e3, Ze = /* @__PURE__ */ new Set([
   E.PENDING_DEPOSITOR_WOTS_PK,
-  ...re
+  ...ne
 ]);
-async function At(e) {
+async function Vt(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
     peginTxid: n,
-    depositorPk: s,
-    wotsPublicKeys: l,
-    timeoutMs: o = We,
-    signal: a
+    depositorPk: a,
+    wotsPublicKeys: u,
+    timeoutMs: o = Je,
+    signal: s
   } = e;
-  a == null || a.throwIfAborted();
-  const u = await ne({
+  s == null || s.throwIfAborted();
+  const l = await ae({
     statusReader: t,
     peginTxid: n,
-    targetStatuses: Je,
+    targetStatuses: Ze,
     timeoutMs: o,
-    signal: a
+    signal: s
   });
-  re.has(u) || (a == null || a.throwIfAborted(), await r.submitDepositorWotsKey(
+  ne.has(l) || (s == null || s.throwIfAborted(), await r.submitDepositorWotsKey(
     {
       pegin_txid: n,
-      depositor_pk: s,
-      wots_public_keys: l
+      depositor_pk: a,
+      wots_public_keys: u
     },
-    a
+    s
   ));
 }
-function V(e) {
+function K(e) {
   return e.registration || e.operation;
 }
-function Ze(e, t, r) {
+function et(e, t, r) {
   const n = k(e);
   return {
     registration: n === k(t),
@@ -606,38 +632,38 @@ function I(e) {
 function Q(e, t) {
   return e.length === t.length && e.every((r, n) => r === t[n]);
 }
-async function Rt(e) {
+async function Kt(e) {
   const {
     vaultProviderEthAddress: t,
     hintBtcPubkey: r,
     registrationBtcPubkey: n,
-    readCurrentOperationBtcPubkey: s,
-    context: l
+    readCurrentOperationBtcPubkey: a,
+    context: u
   } = e;
   if (!r) return;
   const o = k(r);
   if (o === k(n)) return;
-  const a = k(
-    await s()
+  const s = k(
+    await a()
   );
-  if (o !== a)
+  if (o !== s)
     throw new Error(
-      `Vault provider BTC pubkey mismatch for ${t}: indexer hint matches neither the registration key nor the current operation key on-chain.${l ? ` ${l}` : ""}`
+      `Vault provider BTC pubkey mismatch for ${t}: indexer hint matches neither the registration key nor the current operation key on-chain.${u ? ` ${u}` : ""}`
     );
 }
 function O(e, t, r) {
-  const n = `${e} operation key (admin=${t.ethAddress})`, s = X(
+  const n = `${e} operation key (admin=${t.ethAddress})`, a = X(
     t.btcPubKey,
     `${e} roster key (admin=${t.ethAddress})`
-  ), l = X(r, n);
+  ), u = X(r, n);
   return {
     adminAddress: t.ethAddress,
-    genesisBtcPubkey: s,
-    operationBtcPubkey: l,
-    rotated: l !== s
+    genesisBtcPubkey: a,
+    operationBtcPubkey: u,
+    rotated: u !== a
   };
 }
-function et(e) {
+function tt(e) {
   const t = /* @__PURE__ */ new Map();
   for (const r of e) {
     const n = t.get(r.operationBtcPubkey);
@@ -648,7 +674,7 @@ function et(e) {
     t.set(r.operationBtcPubkey, r.adminAddress);
   }
 }
-function ae(e, t, r) {
+function ie(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`
@@ -660,148 +686,148 @@ function ae(e, t, r) {
       btcPubKey: e.vaultProviderGenesisBtcPubkey
     },
     t.vaultProvider
-  ), s = e.vaultKeepers.map(
-    (o, a) => O("vault keeper", o, t.vaultKeepers[a])
-  ), l = e.universalChallengers.map(
-    (o, a) => O("universal challenger", o, t.universalChallengers[a])
+  ), a = e.vaultKeepers.map(
+    (o, s) => O("vault keeper", o, t.vaultKeepers[s])
+  ), u = e.universalChallengers.map(
+    (o, s) => O("universal challenger", o, t.universalChallengers[s])
   );
-  return et([
+  return tt([
     n,
-    ...s,
-    ...l
+    ...a,
+    ...u
   ]), {
     vaultProvider: n,
-    vaultKeepers: s,
-    universalChallengers: l,
+    vaultKeepers: a,
+    universalChallengers: u,
     // Derived from the pairs, never the reverse — see ParticipantKeySet.
-    vaultKeeperOperationKeysSorted: s.map((o) => o.operationBtcPubkey).sort(),
-    universalChallengerOperationKeysSorted: l.map((o) => o.operationBtcPubkey).sort(),
+    vaultKeeperOperationKeysSorted: a.map((o) => o.operationBtcPubkey).sort(),
+    universalChallengerOperationKeysSorted: u.map((o) => o.operationBtcPubkey).sort(),
     resolvedAt: r,
     query: e
   };
 }
-async function tt(e) {
+async function rt(e) {
   const t = await e.operationKeyReader.getCurrentOperationKeys(
     e.query
   );
-  return ae(e.query, t, { mode: "current" });
+  return ie(e.query, t, { mode: "current" });
 }
-async function rt(e) {
+async function nt(e) {
   const t = await e.operationKeyReader.getOperationKeysAtEpochs(
     e.query,
     e.epochs
   );
-  return ae(e.query, t, {
+  return ie(e.query, t, {
     mode: "epochs",
     epochs: e.epochs
   });
 }
-const Y = (e) => e.map(k).sort();
-async function Kt(e) {
+const W = (e) => e.map(k).sort();
+async function It(e) {
   const {
     vaultRegistryReader: t,
     vaultKeeperReader: r,
     universalChallengerReader: n,
-    vaultProviderEthAddress: s,
-    applicationEntryPoint: l,
+    vaultProviderEthAddress: a,
+    applicationEntryPoint: u,
     expectedVaultProviderBtcPubkey: o,
-    expectedVaultKeeperBtcPubkeys: a,
-    expectedUniversalChallengerBtcPubkeys: u,
+    expectedVaultKeeperBtcPubkeys: s,
+    expectedUniversalChallengerBtcPubkeys: l,
     operationKeyReader: i,
     onIndexerServingOperationKeys: p,
     onIndexerHintsInconsistent: c
   } = e, [
     h,
     f,
-    y
+    v
   ] = await Promise.all([
-    t.getVaultProviderBtcPubKey(s),
-    r.getCurrentVaultKeepersVersion(l),
+    t.getVaultProviderBtcPubKey(a),
+    r.getCurrentVaultKeepersVersion(u),
     n.getLatestUniversalChallengersVersion()
   ]), [T, x] = await Promise.all([
     r.getVaultKeepersByVersion(
-      l,
+      u,
       f
     ),
     n.getUniversalChallengersByVersion(
-      y
+      v
     )
   ]), m = {
     vaultProvider: k(h),
-    vaultKeepers: Y(T.map((P) => P.btcPubKey)),
-    universalChallengers: Y(x.map((P) => P.btcPubKey))
-  }, b = await tt({
+    vaultKeepers: W(T.map((P) => P.btcPubKey)),
+    universalChallengers: W(x.map((P) => P.btcPubKey))
+  }, b = await rt({
     operationKeyReader: i,
     query: {
-      vaultProviderEthAddress: s,
+      vaultProviderEthAddress: a,
       vaultProviderGenesisBtcPubkey: `0x${h}`,
-      applicationEntryPoint: l,
+      applicationEntryPoint: u,
       vaultKeepers: T,
       universalChallengers: x
     }
-  }), v = {
+  }), y = {
     vaultProvider: b.vaultProvider.operationBtcPubkey,
     vaultKeepers: [...b.vaultKeeperOperationKeysSorted],
     universalChallengers: [
       ...b.universalChallengerOperationKeysSorted
     ]
-  }, S = Ze(
+  }, S = et(
     o,
     m.vaultProvider,
-    v.vaultProvider
+    y.vaultProvider
   ), _ = q(
-    a,
+    s,
     m.vaultKeepers,
-    v.vaultKeepers
+    y.vaultKeepers
   ), B = q(
-    u,
+    l,
     m.universalChallengers,
-    v.universalChallengers
+    y.universalChallengers
   );
-  if (!V(S))
+  if (!K(S))
     throw new Error(
-      `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${s}. Refresh and try again.`
+      `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${a}. Refresh and try again.`
     );
-  if (!V(_))
+  if (!K(_))
     throw new Error(
       `Vault keeper BTC pubkeys (v${f}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
     );
-  if (!V(B))
+  if (!K(B))
     throw new Error(
-      `Universal challenger BTC pubkeys (v${y}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
+      `Universal challenger BTC pubkeys (v${v}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
     );
-  const g = [S, _, B], pe = g.some((P) => P.registration && !P.operation), z = g.some((P) => P.operation && !P.registration);
-  if (pe && z) {
-    const P = `Indexer participant hints are internally inconsistent for vault provider ${s}: some roles match the registration keys while others match the rotated operation keys.`;
+  const g = [S, _, B], de = g.some((P) => P.registration && !P.operation), z = g.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.`);
   }
   return z && (p == null || p(
-    `Indexer is serving rotated operation keys for vault provider ${s}`
+    `Indexer is serving rotated operation keys for vault provider ${a}`
   )), {
-    vaultProviderBtcPubkeyXOnly: v.vaultProvider,
-    vaultKeeperBtcPubkeysSorted: v.vaultKeepers,
-    universalChallengerBtcPubkeysSorted: v.universalChallengers,
+    vaultProviderBtcPubkeyXOnly: y.vaultProvider,
+    vaultKeeperBtcPubkeysSorted: y.vaultKeepers,
+    universalChallengerBtcPubkeysSorted: y.universalChallengers,
     expectedAppVaultKeepersVersion: f,
-    expectedUniversalChallengersVersion: y,
+    expectedUniversalChallengersVersion: v,
     registrationKeys: m,
     participantKeys: b
   };
 }
-function nt(e) {
+function ot(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function Vt(e) {
+function Ot(e) {
   const {
     amountSats: t,
     minDeposit: r,
     maxDeposit: n,
-    btcBalance: s,
-    estimatedFeeSats: l,
+    btcBalance: a,
+    estimatedFeeSats: u,
     depositorClaimValue: o
   } = e;
-  return !(t <= 0n || t < r || n && n > 0n && t > n || l == null || o == null || t + l + o > s);
+  return !(t <= 0n || t < r || n && n > 0n && t > n || u == null || o == null || t + u + o > a);
 }
-function It(e, t, r) {
+function Ht(e, t, r) {
   return e <= 0n ? {
     valid: !1,
     error: "Deposit amount must be greater than zero"
@@ -813,7 +839,7 @@ function It(e, t, r) {
     error: `Maximum deposit is ${C(r)} BTC`
   } : { valid: !0 };
 }
-function Ot(e) {
+function Nt(e) {
   const { amount: t, effectiveRemaining: r } = e;
   return r === null ? { valid: !0 } : r === 0n ? {
     valid: !1,
@@ -823,191 +849,191 @@ function Ot(e) {
     error: `Vault size exceeds remaining capacity (${C(r)} BTC)`
   } : { valid: !0 };
 }
-function Ht(e, t) {
+function Dt(e, t) {
   if (!e || e.length === 0)
     return {
       valid: !1,
       error: "At least one vault provider must be selected"
     };
   const r = t.map(
-    (s) => s.toLowerCase()
+    (a) => a.toLowerCase()
   );
   return e.filter(
-    (s) => !r.includes(s.toLowerCase())
+    (a) => !r.includes(a.toLowerCase())
   ).length > 0 ? {
     valid: !1,
     error: "Invalid vault provider selected"
   } : { valid: !0 };
 }
-function ot(e, t, r) {
+function at(e, t, r) {
   if (!e || e.length === 0)
     return {
       valid: !1,
       error: "At least one vault amount required"
     };
   for (let n = 0; n < e.length; n++) {
-    const s = e[n];
-    if (s <= 0n)
+    const a = e[n];
+    if (a <= 0n)
       return {
         valid: !1,
         error: `Vault ${n + 1} amount must be positive`
       };
-    if (t && s < t)
+    if (t && a < t)
       return {
         valid: !1,
-        error: `Vault ${n + 1} amount ${C(s)} BTC is below minimum deposit ${C(t)} BTC`
+        error: `Vault ${n + 1} amount ${C(a)} BTC is below minimum deposit ${C(t)} BTC`
       };
-    if (r && s > r)
+    if (r && a > r)
       return {
         valid: !1,
-        error: `Vault ${n + 1} amount ${C(s)} BTC exceeds maximum deposit ${C(r)} BTC`
+        error: `Vault ${n + 1} amount ${C(a)} BTC exceeds maximum deposit ${C(r)} BTC`
       };
   }
   return { valid: !0 };
 }
-function at(e) {
+function st(e) {
   const t = d(e);
-  return nt(t) ? { valid: !0 } : {
+  return ot(t) ? { valid: !0 } : {
     valid: !1,
     error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
   };
 }
-function st(e) {
+function it(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 it(e) {
+function ut(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 ut(e) {
+function lt(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function Nt(e) {
+function Ft(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
     vaultProviderBtcPubkey: n,
-    vaultKeeperBtcPubkeys: s,
-    universalChallengerBtcPubkeys: l,
+    vaultKeeperBtcPubkeys: a,
+    universalChallengerBtcPubkeys: u,
     minDeposit: o,
-    maxDeposit: a
-  } = e, u = ot(
+    maxDeposit: s
+  } = e, l = at(
     t,
     o,
-    a
+    s
   );
-  if (!u.valid)
-    throw new Error(u.error);
-  const i = at(n);
+  if (!l.valid)
+    throw new Error(l.error);
+  const i = st(n);
   if (!i.valid)
     throw new Error(i.error);
-  st(s), it(l), ut(r);
+  it(a), ut(u), lt(r);
 }
-class se extends Error {
+class ue extends Error {
   constructor(t) {
     super(t), this.name = "ParticipantKeyDriftError";
   }
 }
-function Dt(e) {
-  return e instanceof se || e instanceof Error && e.name === "ParticipantKeyDriftError";
+function Mt(e) {
+  return e instanceof ue || e instanceof Error && e.name === "ParticipantKeyDriftError";
 }
-function W(e, t, r) {
-  return t.length === r.length && t.every((n, s) => n === r[s]) ? null : `${e} expected [${t.join(", ")}], got [${r.join(", ")}]`;
+function Y(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 Ft(e) {
-  const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: n, expected: s } = e, l = s.query;
+async function Ut(e) {
+  const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: n, expected: a } = e, u = a.query;
   if (n.length === 0) return;
-  const o = await t.getVaultKeyEpochsBatch(n), a = [];
-  for (const [u, i] of o.entries()) {
-    const p = n[u];
+  const o = await t.getVaultKeyEpochsBatch(n), s = [];
+  for (const [l, i] of o.entries()) {
+    const p = n[l];
     let c;
     try {
-      c = await rt({
+      c = await nt({
         operationKeyReader: r,
-        query: l,
+        query: u,
         epochs: i
       });
-    } catch (y) {
-      a.push(
-        `vault ${p}: could not resolve participants at frozen epochs (vp=${i.vpKeyEpoch}, keeper=${i.appKeeperKeyEpoch}, uc=${i.ucKeyEpoch}): ${y.message}`
+    } catch (v) {
+      s.push(
+        `vault ${p}: could not resolve participants at frozen epochs (vp=${i.vpKeyEpoch}, keeper=${i.appKeeperKeyEpoch}, uc=${i.ucKeyEpoch}): ${v.message}`
       );
       continue;
     }
-    c.vaultProvider.operationBtcPubkey !== s.vaultProvider.operationBtcPubkey && a.push(
-      `vault ${p}: vault provider key expected ${s.vaultProvider.operationBtcPubkey}, got ${c.vaultProvider.operationBtcPubkey}`
+    c.vaultProvider.operationBtcPubkey !== a.vaultProvider.operationBtcPubkey && s.push(
+      `vault ${p}: vault provider key expected ${a.vaultProvider.operationBtcPubkey}, got ${c.vaultProvider.operationBtcPubkey}`
     );
-    const h = W(
+    const h = Y(
       `vault ${p}: vault keeper keys`,
-      s.vaultKeeperOperationKeysSorted,
+      a.vaultKeeperOperationKeysSorted,
       c.vaultKeeperOperationKeysSorted
     );
-    h && a.push(h);
-    const f = W(
+    h && s.push(h);
+    const f = Y(
       `vault ${p}: universal challenger keys`,
-      s.universalChallengerOperationKeysSorted,
+      a.universalChallengerOperationKeysSorted,
       c.universalChallengerOperationKeysSorted
     );
-    f && a.push(f);
+    f && s.push(f);
   }
-  if (a.length > 0)
-    throw new se(
-      `Aborting BTC broadcast: participant operation keys changed during registration (${a.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
+  if (s.length > 0)
+    throw new ue(
+      `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 ie extends Error {
+class le extends Error {
   constructor(t) {
     super(t), this.name = "RegisteredVaultVersionMismatchError";
   }
 }
-function Mt(e) {
-  return e instanceof ie || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
+function Lt(e) {
+  return e instanceof le || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function Ut(e) {
+async function zt(e) {
   const {
     vaultRegistryReader: t,
     vaultIds: r,
     expectedOffchainParamsVersion: n,
-    expectedAppVaultKeepersVersion: s,
-    expectedUniversalChallengersVersion: l,
+    expectedAppVaultKeepersVersion: a,
+    expectedUniversalChallengersVersion: u,
     expectedVaultCoreVersion: o
-  } = e, a = await t.getProtocolInfoBatch(r), u = [];
-  if (a.forEach((i, p) => {
+  } = e, s = await t.getProtocolInfoBatch(r), l = [];
+  if (s.forEach((i, p) => {
     const c = r[p];
-    i.offchainParamsVersion !== n && u.push(
+    i.offchainParamsVersion !== n && l.push(
       `vault ${c}: offchainParams expected v${n}, got v${i.offchainParamsVersion}`
-    ), i.appVaultKeepersVersion !== s && u.push(
-      `vault ${c}: appVaultKeepers expected v${s}, got v${i.appVaultKeepersVersion}`
-    ), i.universalChallengersVersion !== l && u.push(
-      `vault ${c}: universalChallengers expected v${l}, got v${i.universalChallengersVersion}`
-    ), i.vaultCoreVersion !== o && u.push(
+    ), i.appVaultKeepersVersion !== a && l.push(
+      `vault ${c}: appVaultKeepers expected v${a}, got v${i.appVaultKeepersVersion}`
+    ), i.universalChallengersVersion !== u && l.push(
+      `vault ${c}: universalChallengers expected v${u}, got v${i.universalChallengersVersion}`
+    ), i.vaultCoreVersion !== o && l.push(
       `vault ${c}: vaultCoreVersion expected v${o} (build-time active), got v${i.vaultCoreVersion}`
     );
-  }), u.length > 0)
-    throw new ie(
-      `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.`
+  }), l.length > 0)
+    throw new le(
+      `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${l.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-var ue = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(ue || {});
-const lt = /* @__PURE__ */ new Set([
+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([
   "PayoutBroadcast",
   "PayoutBlocked"
   /* PAYOUT_BLOCKED */
 ]);
-function Lt(e) {
-  return Object.values(ue).includes(
+function Xt(e) {
+  return Object.values(ce).includes(
     e
   );
 }
-function zt(e) {
-  return !!e && lt.has(e);
+function Gt(e) {
+  return !!e && ct.has(e);
 }
-class ct extends Error {
+class pt extends Error {
   constructor(r, n) {
     super(`Refund not yet mature (BIP68 not final): ${n.message}`);
     A(this, "vaultId");
@@ -1015,21 +1041,21 @@ class ct extends Error {
     this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = n;
   }
 }
-const pt = /^0x[0-9a-fA-F]{64}$/, ht = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, le = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, ce = 160, J = 2e3, Z = 10n, ee = 100n;
-function Xt(e) {
+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) {
   if (!Number.isFinite(e) || e <= 0)
     throw new Error(
       `feeRateSatsVb must be a positive finite number, got ${e}`
     );
-  return BigInt(Math.ceil(e * ce));
+  return BigInt(Math.ceil(e * he));
 }
-const dt = 1, gt = /non-BIP68-final/i;
+const gt = 1, ft = /non-BIP68-final/i;
 function U(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 (!pt.test(e))
+  if (!ht.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
@@ -1038,7 +1064,7 @@ function H(e, t) {
   if (!Number.isInteger(e) || e < 0)
     throw new Error(`${t} must be a non-negative integer, got ${e}`);
 }
-function ft(e) {
+function vt(e) {
   if (U(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
     throw new Error(
       `htlcVout must be a non-negative integer, got ${e.htlcVout}`
@@ -1072,16 +1098,16 @@ function ft(e) {
   if (H(e.offchainParamsVersion, "offchainParamsVersion"), H(e.appVaultKeepersVersion, "appVaultKeepersVersion"), H(
     e.universalChallengersVersion,
     "universalChallengersVersion"
-  ), Be(
+  ), Ae(
     e.vaultCoreVersion,
     "VaultRefundData.vaultCoreVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
     throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!ht.test(e.unsignedPrePeginTxHex))
+  if (!dt.test(e.unsignedPrePeginTxHex))
     throw new Error(
       "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
     );
-  if (!e.depositorBtcPubkey || !le.test(e.depositorBtcPubkey))
+  if (!e.depositorBtcPubkey || !pe.test(e.depositorBtcPubkey))
     throw new Error(
       "depositorBtcPubkey must be 32 or 33 bytes of hex (optional 0x prefix)"
     );
@@ -1089,7 +1115,7 @@ function ft(e) {
     throw new Error(`amount must be a positive bigint, got ${e.amount}`);
 }
 function yt(e) {
-  if (!e.vaultProviderPubkey || !le.test(e.vaultProviderPubkey))
+  if (!e.vaultProviderPubkey || !pe.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");
@@ -1114,8 +1140,8 @@ function yt(e) {
       `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
     );
 }
-function vt(e) {
-  const t = Ce.fromHex(e);
+function Pt(e) {
+  const t = Te.fromHex(e);
   try {
     t.finalizeAllInputs();
   } catch (r) {
@@ -1125,40 +1151,40 @@ function vt(e) {
   }
   return t.extractTransaction().toHex();
 }
-async function Gt(e) {
+async function qt(e) {
   const {
     vaultId: t,
     readVault: r,
     readPrePeginContext: n,
-    feeRate: s,
-    signPsbt: l,
+    feeRate: a,
+    signPsbt: u,
     broadcastTx: o,
-    signal: a
+    signal: s
   } = e;
-  a == null || a.throwIfAborted(), U(t, "vaultId");
-  const u = await r();
-  ft(u), a == null || a.throwIfAborted();
-  const i = await n(u);
-  if (yt(i), a == null || a.throwIfAborted(), !Number.isFinite(s) || s <= 0)
-    throw new Error(`feeRate must be a positive number, got ${s}`);
-  if (s > J)
+  s == null || s.throwIfAborted(), U(t, "vaultId");
+  const l = await r();
+  vt(l), s == null || s.throwIfAborted();
+  const i = await n(l);
+  if (yt(i), s == null || s.throwIfAborted(), !Number.isFinite(a) || a <= 0)
+    throw new Error(`feeRate must be a positive number, got ${a}`);
+  if (a > J)
     throw new Error(
-      `feeRate ${s} sat/vB exceeds refund safety cap ${J} sat/vB; refusing to sign refund.`
+      `feeRate ${a} sat/vB exceeds refund safety cap ${J} sat/vB; refusing to sign refund.`
     );
-  const p = BigInt(Math.ceil(s * ce)), c = u.amount * Z / ee;
+  const p = BigInt(Math.ceil(a * he)), c = l.amount * Z / ee;
   if (p > 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 ${p} sats exceeds the per-vault safety cap of ${c} sats (${Z}/${ee} of vault.amount=${l.amount}); refusing to sign refund.`
     );
-  a == null || a.throwIfAborted();
+  s == null || s.throwIfAborted();
   const h = L(
-    u.depositorBtcPubkey
-  ), f = d(u.unsignedPrePeginTxHex), y = we(f);
-  if (y !== void 0 && y.vout !== u.batch.length)
+    l.depositorBtcPubkey
+  ), f = d(l.unsignedPrePeginTxHex), v = ke(f);
+  if (v !== void 0 && v.vout !== l.batch.length)
     throw new Error(
-      `Auth-anchor OP_RETURN at vout ${y.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 ${v.vout} does not match batch size (${l.batch.length} HTLC outputs expect the anchor at vout ${l.batch.length}). Refund refused — sibling HTLC vector is incomplete.`
     );
-  const T = y == null ? void 0 : y.hash;
+  const T = v == null ? void 0 : v.hash;
   let x;
   try {
     x = $.fromHex(f);
@@ -1167,18 +1193,18 @@ async function Gt(e) {
       `Failed to parse funded Pre-PegIn transaction hex: ${g instanceof Error ? g.message : String(g)}`
     );
   }
-  if (x.outs.length < u.batch.length)
+  if (x.outs.length < l.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 ${x.outs.length} outputs but batch requires at least ${l.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
     );
-  const { psbtHex: m } = await _e({
+  const { psbtHex: m } = await Be({
     prePeginParams: {
-      vaultCoreVersion: u.vaultCoreVersion,
+      vaultCoreVersion: l.vaultCoreVersion,
       depositorPubkey: h,
       vaultProviderPubkey: d(i.vaultProviderPubkey),
       vaultKeeperPubkeys: i.vaultKeeperPubkeys.map(d),
       universalChallengerPubkeys: i.universalChallengerPubkeys.map(d),
-      hashlocks: u.batch.map((g) => d(g.hashlock)),
+      hashlocks: l.batch.map((g) => d(g.hashlock)),
       timelockRefund: i.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
@@ -1186,7 +1212,7 @@ async function Gt(e) {
       // HTLC output. `buildRefundPsbt`'s value cross-check then binds the result
       // to the funded tx bytes, refusing the refund if the template's HTLC value
       // disagrees with the on-chain commitment.
-      pegInAmounts: u.batch.map((g) => g.amount),
+      pegInAmounts: l.batch.map((g) => g.amount),
       feeRate: i.feeRate,
       minPeginFeeRate: i.minPeginFeeRate,
       numLocalChallengers: i.numLocalChallengers,
@@ -1196,25 +1222,25 @@ async function Gt(e) {
       authAnchorHash: T
     },
     fundedPrePeginTxHex: f,
-    htlcVout: u.htlcVout,
+    htlcVout: l.htlcVout,
     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: d(u.hashlock)
+    hashlock: d(l.hashlock)
   });
-  a == null || a.throwIfAborted();
+  s == null || s.throwIfAborted();
   const b = M(
-    u.depositorBtcPubkey,
-    dt
-  ), v = await l(m, b);
+    l.depositorBtcPubkey,
+    gt
+  ), y = await u(m, b);
   N({
     requestedPsbtHex: m,
-    returnedPsbtHex: v
+    returnedPsbtHex: y
   });
   const S = 0, _ = D(
-    v,
+    y,
     h,
     S
   );
@@ -1224,49 +1250,50 @@ async function Gt(e) {
     signerXOnlyPubkeyHex: h,
     inputIndex: S
   });
-  const B = vt(v);
-  a == null || a.throwIfAborted();
+  const B = Pt(y);
+  s == null || s.throwIfAborted();
   try {
     return await o(B);
   } catch (g) {
-    throw g instanceof Error && gt.test(g.message) ? new ct(t, g) : g;
+    throw g instanceof Error && ft.test(g.message) ? new pt(t, g) : g;
   }
 }
 export {
-  Xt as A,
-  ct as B,
-  ue as C,
-  ee as D,
-  Z as E,
-  J as F,
-  ce as G,
-  se as P,
-  ie as R,
-  _t as a,
+  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,
-  It as c,
-  Nt as d,
-  Ht as e,
-  Ot as f,
-  ot as g,
+  Vt as c,
+  Ht as d,
+  Ft as e,
+  Dt as f,
+  Nt as g,
   at as h,
-  Vt as i,
-  Dt as j,
-  Ft as k,
-  Mt as l,
-  Ut as m,
-  Rt as n,
-  V as o,
-  Ze as p,
-  q,
-  Bt as r,
-  Le as s,
-  tt as t,
+  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,
-  Kt as v,
-  ne as w,
-  Lt as x,
-  zt as y,
+  It as v,
+  ae as w,
+  nt as x,
+  Xt as y,
   Gt as z
 };
-//# sourceMappingURL=buildAndBroadcastRefund-DBA-Mp4I.js.map
+//# sourceMappingURL=buildAndBroadcastRefund-C-rbYMy6.js.map