@babylonlabs-io/ts-sdk 0.56.1 → 0.57.0

package/dist/{buildAndBroadcastRefund-BtXUqBkb.js → buildAndBroadcastRefund-CCb1_z24.js}

@@ -1,164 +1,81 @@
-var J = Object.defineProperty;
-var Z = (e, t, r) => t in e ? J(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var A = (e, t, r) => Z(e, typeof t != "symbol" ? t + "" : t, r);
-import { B as ee } from "./BTCVaultRegistry.abi-Chs4AFBj.js";
-import { e as te, v as re, s as d, u as X, p as R, f as E } from "./bitcoin-B5aNKtsk.js";
-import { v as oe, b as ne, s as se, P as ae, d as ie } from "./PayoutManager-BVgmuKuK.js";
-import { D as x, c as ue, a as le, R as ce, d as z } from "./types-CQDRQvV-.js";
-import { Transaction as S, Psbt as he } from "bitcoinjs-lib";
-import { c as pe, d as I, e as N, f as H } from "./verifyScriptPathSchnorrSignature-CgrnAjMW.js";
-import { c as de, a as ge, b as fe } from "./noPayout-CihCk1HE.js";
-import { c as O } from "./signing-DaLvGwQe.js";
-import { a as me } from "./constants-CDQE812z.js";
-const be = /^0x[0-9a-fA-F]{64}$/, Pe = /^0x[0-9a-fA-F]{40}$/, ye = /^0x([0-9a-fA-F]{2})*$/;
-function $(e, t) {
+var de = Object.defineProperty;
+var ge = (e, t, r) => t in e ? de(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var I = (e, t, r) => ge(e, typeof t != "symbol" ? t + "" : t, r);
+import { B as fe } from "./BTCVaultRegistry.abi-CixOlp3B.js";
+import { e as ve, v as ye, s as d, u as re, p as B, f as k } from "./bitcoin-B5aNKtsk.js";
+import { v as Pe, b as me, s as be, P as we, d as xe } from "./signPsbtsWithFallback-CzZFZf0I.js";
+import { D as x, c as ke, a as Ee, R as Te, d as oe } from "./json-rpc-client-Ehjthcd7.js";
+import { Transaction as S, Psbt as Ce } from "bitcoinjs-lib";
+import { c as Se, d as D, e as F, f as M } from "./verifyScriptPathSchnorrSignature-Xoo9DOHW.js";
+import { c as _e, a as $e, b as Re } from "./noPayout-CI4l1qu2.js";
+import { c as U } from "./signing-DaLvGwQe.js";
+import { a as Q } from "./onChainBtcPubkey-aPY5ib3Q.js";
+import { a as Ae } from "./constants-CDQE812z.js";
+const Be = /^0x[0-9a-fA-F]{64}$/, Ve = /^0x[0-9a-fA-F]{40}$/, Ie = /^0x([0-9a-fA-F]{2})*$/;
+function K(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 (!be.test(e))
+  if (!Be.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function we(e, t) {
-  if (!Pe.test(e))
+function Ke(e, t) {
+  if (!Ve.test(e))
     throw new Error(
       `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
     );
 }
-function ve(e, t) {
-  if (!ye.test(e))
+function Oe(e, t) {
+  if (!Ie.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
 }
-async function lt(e) {
+async function _t(e) {
   const {
     btcVaultRegistryAddress: t,
     vaultId: r,
     hashlock: o,
-    activationMetadata: i,
+    activationMetadata: a,
     writeContract: l,
     signal: n
   } = e;
-  n == null || n.throwIfAborted(), we(t, "btcVaultRegistryAddress"), $(r, "vaultId");
-  const s = te(e.secret);
-  if ($(s, "secret"), o !== void 0 && ($(o, "hashlock"), !oe(s, o)))
+  n == null || n.throwIfAborted(), Ke(t, "btcVaultRegistryAddress"), K(r, "vaultId");
+  const s = ve(e.secret);
+  if (K(s, "secret"), o !== void 0 && (K(o, "hashlock"), !Pe(s, o)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
-  return ve(i, "activationMetadata"), l({
+  return Oe(a, "activationMetadata"), l({
     address: t,
-    abi: ee,
+    abi: fe,
     functionName: "activateVaultWithSecret",
-    args: [r, s, i]
+    args: [r, s, a]
   });
 }
-const xe = 1e4;
-async function G(e) {
-  const {
-    statusReader: t,
-    peginTxid: r,
-    targetStatuses: o,
-    timeoutMs: i,
-    pollIntervalMs: l = xe,
-    signal: n
-  } = e, s = Date.now();
-  for (; ; ) {
-    if (n != null && n.aborted)
-      throw new Error(
-        `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
-      );
-    if (Date.now() - s >= i)
-      throw new Error(
-        `Polling timeout after ${i}ms for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
-      );
-    try {
-      const u = await t.getPeginStatus(
-        { pegin_txid: r },
-        n
-      );
-      if (u.pegin_txid.toLowerCase() !== r.toLowerCase())
-        throw new Error(
-          `getPeginStatus returned status for pegin ${u.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
-        );
-      const a = u.status;
-      if (o.has(a) || a === x.ACTIVATED)
-        return a;
-      if (a === x.EXPIRED || ue.has(a))
-        throw new Error(
-          `Pegin ${r.slice(0, 8)}… reached terminal status "${a}" while waiting for ${[...o].join(", ")}`
-        );
-    } catch (u) {
-      if (!(u instanceof le && u.code === ce.PEGIN_NOT_FOUND))
-        throw u;
-    }
-    await new Promise((u, a) => {
-      const h = () => {
-        clearTimeout(c), a(
-          new Error(
-            `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
-          )
-        );
-      }, c = setTimeout(() => {
-        n == null || n.removeEventListener("abort", h), u();
-      }, l);
-      n == null || n.addEventListener("abort", h, { once: !0 });
-    });
-  }
-}
-const Ee = 300 * 1e3, Te = /* @__PURE__ */ new Set([
-  x.PENDING_DEPOSITOR_WOTS_PK,
-  ...z
-]);
-async function ct(e) {
-  const {
-    statusReader: t,
-    wotsSubmitter: r,
-    peginTxid: o,
-    depositorPk: i,
-    wotsPublicKeys: l,
-    timeoutMs: n = Ee,
-    signal: s
-  } = e;
-  s == null || s.throwIfAborted();
-  const u = await G({
-    statusReader: t,
-    peginTxid: o,
-    targetStatuses: Te,
-    timeoutMs: n,
-    signal: s
-  });
-  z.has(u) || (s == null || s.throwIfAborted(), await r.submitDepositorWotsKey(
-    {
-      pegin_txid: o,
-      depositor_pk: i,
-      wots_public_keys: l
-    },
-    s
-  ));
-}
-const F = 1, ke = 1;
-function _e(e, t) {
-  const r = d(t).toLowerCase(), i = e.map((l) => d(l).toLowerCase()).filter((l) => l !== r);
-  if (i.length === 0)
+const Y = 1, Ne = 1;
+function He(e, t) {
+  const r = d(t).toLowerCase(), a = e.map((l) => d(l).toLowerCase()).filter((l) => l !== r);
+  if (a.length === 0)
     throw new Error(
       "Cannot derive localChallengers: vault keeper set is empty (or contains only the depositor)"
     );
-  if (new Set(i).size !== i.length)
+  if (new Set(a).size !== a.length)
     throw new Error(
       "Cannot derive localChallengers: duplicate vaultKeeper key — signing context is misconfigured"
     );
-  return i;
+  return a;
 }
-function Ce(e, t, r) {
+function De(e, t, r) {
   const o = r.map(
     (c) => d(c).toLowerCase()
-  ), i = t.filter((c) => o.includes(c));
-  if (i.length > 0)
+  ), a = t.filter((c) => o.includes(c));
+  if (a.length > 0)
     throw new Error(
-      `Cannot validate challenger set: vault keepers and universal challengers overlap (${i.join(", ")})`
+      `Cannot validate challenger set: vault keepers and universal challengers overlap (${a.join(", ")})`
     );
   const l = [...t, ...o], n = e.map(
     (c) => d(c.challenger_pubkey).toLowerCase()
@@ -167,40 +84,42 @@ function Ce(e, t, r) {
     throw new Error(
       "Depositor graph contains duplicate challenger entries in challenger_presign_data"
     );
-  const u = new Set(l), a = l.filter((c) => !s.has(c)), h = n.filter((c) => !u.has(c));
-  if (a.length > 0 || h.length > 0)
+  const u = new Set(l), i = l.filter((c) => !s.has(c)), p = n.filter((c) => !u.has(c));
+  if (i.length > 0 || p.length > 0)
     throw new Error(
-      "Depositor graph challenger set does not match expected (local ∪ universal)" + (a.length > 0 ? ` (missing: ${a.join(", ")})` : "") + (h.length > 0 ? ` (unexpected: ${h.join(", ")})` : "")
+      "Depositor graph challenger set does not match expected (local ∪ universal)" + (i.length > 0 ? ` (missing: ${i.join(", ")})` : "") + (p.length > 0 ? ` (unexpected: ${p.join(", ")})` : "")
     );
 }
-function Se(e, t) {
+function Fe(e, t) {
   const r = e.ins[t];
-  return X(new Uint8Array(r.hash).slice().reverse());
+  return re(new Uint8Array(r.hash).slice().reverse());
 }
-function V(e, t, r, o, i) {
+function O(e, t, r, o, a) {
   const l = e.ins[t];
   if (l.index !== 0)
     throw new Error(
-      `NoPayout (challenger ${i}) input ${t} expected to spend ${o} vout 0, got vout ${l.index}`
+      `NoPayout (challenger ${a}) input ${t} expected to spend ${o} vout 0, got vout ${l.index}`
     );
-  const n = r.getId(), s = Se(e, t);
+  const n = r.getId(), s = Fe(e, t);
   if (s !== n)
     throw new Error(
-      `NoPayout (challenger ${i}) input ${t} does not reference ${o} (expected txid ${n}, got ${s})`
+      `NoPayout (challenger ${a}) input ${t} does not reference ${o} (expected txid ${n}, got ${s})`
     );
 }
-async function Re(e, t, r) {
-  const o = [], i = [], l = [], n = _e(
+async function Me(e, t, r) {
+  const o = [], a = [], l = [], n = He(
     r.vaultKeeperBtcPubkeys,
     r.depositorBtcPubkey
   );
-  Ce(
+  De(
     e.challenger_presign_data,
     n,
     r.universalChallengerBtcPubkeys
   );
-  const s = await pe({
+  const s = await Se({
     vaultCoreVersion: r.vaultCoreVersion,
+    vkClaimerPayoutScriptPubKeys: r.vkClaimerPayoutScriptPubKeys,
+    vpCommissionScriptPubKey: r.vpCommissionScriptPubKey,
     payoutTxHex: e.payout_tx.tx_hex,
     peginTxHex: r.peginTxHex,
     assertTxHex: e.assert_tx.tx_hex,
@@ -212,50 +131,50 @@ async function Re(e, t, r) {
     network: r.network,
     claimerBtcPubkey: r.depositorBtcPubkey,
     registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
-    commissionBps: ke,
+    commissionBps: Ne,
     protocolFeeRate: r.protocolFeeRate,
     councilSize: r.councilMembers.length
   });
-  o.push(s.psbtHex), i.push(
-    O(
+  o.push(s.psbtHex), a.push(
+    U(
       t,
-      F
+      Y
     )
   );
-  const u = d(r.depositorBtcPubkey), a = S.fromHex(
+  const u = d(r.depositorBtcPubkey), i = S.fromHex(
     d(e.assert_tx.tx_hex)
   );
-  for (const h of e.challenger_presign_data) {
-    const c = d(h.challenger_pubkey), p = o.length, b = await Ae({
-      challenger: h,
+  for (const p of e.challenger_presign_data) {
+    const c = d(p.challenger_pubkey), h = o.length, v = await Ue({
+      challenger: p,
       challengerPubkey: c,
       claimerPubkey: u,
       localChallengers: n,
-      assertTxParsed: a,
+      assertTxParsed: i,
       ctx: r
     });
-    o.push(b), i.push(
-      O(
+    o.push(v), a.push(
+      U(
         t,
-        F
+        Y
       )
     ), l.push({
       challengerPubkey: c,
-      noPayoutIdx: p
+      noPayoutIdx: h
     });
   }
-  return { psbtHexes: o, signOptions: i, challengerEntries: l };
+  return { psbtHexes: o, signOptions: a, challengerEntries: l };
 }
-async function Ae(e) {
+async function Ue(e) {
   const {
     challenger: t,
     challengerPubkey: r,
     claimerPubkey: o,
-    localChallengers: i,
+    localChallengers: a,
     assertTxParsed: l,
     ctx: n
   } = e;
-  de(
+  _e(
     t.nopayout_tx.tx_hex,
     r,
     n.network
@@ -264,48 +183,48 @@ async function Ae(e) {
     d(t.nopayout_tx.tx_hex)
   ), u = S.fromHex(
     d(t.challenge_assert_x_tx.tx_hex)
-  ), a = S.fromHex(
+  ), i = S.fromHex(
     d(t.challenge_assert_y_tx.tx_hex)
   );
   if (s.ins.length !== 3)
     throw new Error(
       `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${s.ins.length}`
     );
-  V(
+  O(
     s,
     0,
     l,
     "Assert",
     r
-  ), V(
+  ), O(
     s,
     1,
     u,
     "ChallengeAssertX",
     r
-  ), V(
+  ), O(
     s,
     2,
-    a,
+    i,
     "ChallengeAssertY",
     r
   );
-  const h = [
+  const p = [
     l.outs[0],
     u.outs[0],
-    a.outs[0]
+    i.outs[0]
   ].map((c) => ({
-    script_pubkey: X(new Uint8Array(c.script)),
+    script_pubkey: re(new Uint8Array(c.script)),
     value: c.value
   }));
-  return ge({
+  return $e({
     noPayoutTxHex: t.nopayout_tx.tx_hex,
     challengerPubkey: r,
-    prevouts: h,
+    prevouts: p,
     connectorParams: {
       txGraphVersion: n.vaultCoreVersion,
       claimer: o,
-      localChallengers: i,
+      localChallengers: a,
       universalChallengers: n.universalChallengerBtcPubkeys,
       timelockAssert: n.timelockAssert,
       councilMembers: n.councilMembers,
@@ -313,26 +232,26 @@ async function Ae(e) {
     }
   });
 }
-function $e(e, t, r) {
-  I(e[0]);
-  const i = N(
+function Le(e, t, r) {
+  D(e[0]);
+  const a = F(
     e[0].returnedPsbtHex,
     r
   );
-  H({
+  M({
     requestedPsbtHex: e[0].requestedPsbtHex,
-    signatureHex: i,
+    signatureHex: a,
     signerXOnlyPubkeyHex: r,
     inputIndex: 0
   });
   const l = {};
   for (const n of t) {
-    I(e[n.noPayoutIdx]);
-    const s = N(
+    D(e[n.noPayoutIdx]);
+    const s = F(
       e[n.noPayoutIdx].returnedPsbtHex,
       r
     );
-    H({
+    M({
       requestedPsbtHex: e[n.noPayoutIdx].requestedPsbtHex,
       signatureHex: s,
       signerXOnlyPubkeyHex: r,
@@ -343,77 +262,130 @@ function $e(e, t, r) {
   }
   return {
     payout_signatures: {
-      payout_signature: i
+      payout_signature: a
     },
     per_challenger: l
   };
 }
-async function Ve(e) {
-  const { depositorGraph: t, btcWallet: r, signingContext: o } = e, i = await r.getPublicKeyHex(), { depositorPubkey: l } = re(
-    i,
+async function Xe(e) {
+  const { depositorGraph: t, btcWallet: r, signingContext: o } = e, a = await r.getPublicKeyHex(), { depositorPubkey: l } = ye(
+    a,
     d(o.depositorBtcPubkey)
-  ), { psbtHexes: n, signOptions: s, challengerEntries: u } = await Re(
+  ), { psbtHexes: n, signOptions: s, challengerEntries: u } = await Me(
     t,
-    i,
+    a,
     o
-  ), a = await ne(
+  ), i = await me(
     r,
     n,
     s
-  ), h = n.map((c, p) => ({
+  ), p = n.map((c, h) => ({
     requestedPsbtHex: c,
-    returnedPsbtHex: a[p]
+    returnedPsbtHex: i[h]
   }));
-  return $e(
-    h,
+  return Le(
+    p,
     u,
     l
   );
 }
-const Be = 1200 * 1e3, q = /* @__PURE__ */ new Set([
+const ze = 1e4;
+async function ne(e) {
+  const {
+    statusReader: t,
+    peginTxid: r,
+    targetStatuses: o,
+    timeoutMs: a,
+    pollIntervalMs: l = ze,
+    signal: n
+  } = e, s = Date.now();
+  for (; ; ) {
+    if (n != null && n.aborted)
+      throw new Error(
+        `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
+      );
+    if (Date.now() - s >= a)
+      throw new Error(
+        `Polling timeout after ${a}ms for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
+      );
+    try {
+      const u = await t.getPeginStatus(
+        { pegin_txid: r },
+        n
+      );
+      if (u.pegin_txid.toLowerCase() !== r.toLowerCase())
+        throw new Error(
+          `getPeginStatus returned status for pegin ${u.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
+        );
+      const i = u.status;
+      if (o.has(i) || i === x.ACTIVATED)
+        return i;
+      if (i === x.EXPIRED || ke.has(i))
+        throw new Error(
+          `Pegin ${r.slice(0, 8)}… reached terminal status "${i}" while waiting for ${[...o].join(", ")}`
+        );
+    } catch (u) {
+      if (!(u instanceof Ee && u.code === Te.PEGIN_NOT_FOUND))
+        throw u;
+    }
+    await new Promise((u, i) => {
+      const p = () => {
+        clearTimeout(c), i(
+          new Error(
+            `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
+          )
+        );
+      }, c = setTimeout(() => {
+        n == null || n.removeEventListener("abort", p), u();
+      }, l);
+      n == null || n.addEventListener("abort", p, { once: !0 });
+    });
+  }
+}
+const Ge = 1200 * 1e3, ae = /* @__PURE__ */ new Set([
   x.PENDING_ACKS,
   x.PENDING_ACTIVATION,
   x.ACTIVATED_PENDING_BROADCAST,
   x.ACTIVATED
-]), Ie = /* @__PURE__ */ new Set([
+]), qe = /* @__PURE__ */ new Set([
   x.PENDING_DEPOSITOR_SIGNATURES,
-  ...q
+  ...ae
 ]);
-function Ne(e) {
+function je(e) {
   return e.map((t) => ({
-    claimerPubkeyXOnly: R(t.claimer_pubkey),
+    claimerPubkeyXOnly: B(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
     assertTxHex: t.assert_tx.tx_hex
   }));
 }
-function _(e) {
-  return R(e).toLowerCase();
+function T(e) {
+  return B(e).toLowerCase();
 }
-function He(e, t, r, o) {
-  const i = _(o), l = [
-    _(t),
-    ...r.map(_)
+function Qe(e, t, r, o) {
+  const a = T(o), l = [
+    T(t),
+    ...r.map(T)
   ], n = new Set(l);
   if (n.size !== l.length)
     throw new Error(
       "Cannot validate claimer set: signing context contains duplicate vault provider or vault keeper key"
     );
-  if (n.has(i))
+  if (n.has(a))
     throw new Error(
       "Cannot validate claimer set: depositor key overlaps with vault provider or vault keeper set"
     );
   const s = e.map(
-    (p) => _(p.claimer_pubkey)
+    (h) => T(h.claimer_pubkey)
   );
   if (new Set(s).size !== s.length)
     throw new Error("Presign response contains duplicate claimer entries");
-  const u = s.filter((p) => p !== i), a = new Set(u), h = l.filter((p) => !a.has(p)), c = u.filter((p) => !n.has(p));
-  if (h.length > 0 || c.length > 0)
+  const u = s.filter((h) => h !== a), i = new Set(u), p = l.filter((h) => !i.has(h)), c = u.filter((h) => !n.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 K(e, t) {
+function W(e, t) {
   return {
     vaultCoreVersion: t.vaultCoreVersion,
     payoutTxHex: e.payoutTxHex,
@@ -428,28 +400,30 @@ function K(e, t) {
     claimerBtcPubkey: e.claimerPubkeyXOnly,
     commissionBps: t.commissionBps,
     protocolFeeRate: t.protocolFeeRate,
-    councilSize: t.councilMembers.length
+    councilSize: t.councilMembers.length,
+    vkClaimerPayoutScriptPubKeys: t.vkClaimerPayoutScriptPubKeys,
+    vpCommissionScriptPubKey: t.vpCommissionScriptPubKey
   };
 }
-async function Oe(e, t, r, o) {
-  const i = new ae({
+async function Ye(e, t, r, o) {
+  const a = new we({
     network: t.network,
     btcWallet: e
   }), l = r.length;
   o == null || o(0, l);
   let n;
-  if (i.supportsBatchSigning())
-    n = (await i.signPayoutTransactionsBatch(
-      r.map((a) => K(a, t))
-    )).map((a) => a.payoutSignature);
+  if (a.supportsBatchSigning())
+    n = (await a.signPayoutTransactionsBatch(
+      r.map((i) => W(i, t))
+    )).map((i) => i.payoutSignature);
   else {
     n = [];
     for (let u = 0; u < r.length; u++) {
       o == null || o(u, l);
-      const a = await i.signPayoutTransaction(
-        K(r[u], t)
+      const i = await a.signPayoutTransaction(
+        W(r[u], t)
       );
-      n.push(a.signature);
+      n.push(i.signature);
     }
   }
   const s = {};
@@ -459,64 +433,64 @@ async function Oe(e, t, r, o) {
     };
   return o == null || o(l, l), s;
 }
-async function ht(e) {
+async function $t(e) {
   const {
     statusReader: t,
     presignClient: r,
     btcWallet: o,
-    peginTxid: i,
+    peginTxid: a,
     depositorPk: l,
     signingContext: n,
     depositTerms: s,
-    timeoutMs: u = Be,
-    signal: a,
-    onProgress: h
-  } = e, c = await G({
+    timeoutMs: u = Ge,
+    signal: i,
+    onProgress: p
+  } = e, c = await ne({
     statusReader: t,
-    peginTxid: i,
-    targetStatuses: Ie,
+    peginTxid: a,
+    targetStatuses: qe,
     timeoutMs: u,
-    signal: a
+    signal: i
   });
-  if (q.has(c))
+  if (ae.has(c))
     return;
-  if (a == null || a.throwIfAborted(), s !== void 0 && s.baseFeeRate !== n.protocolFeeRate)
+  if (i == null || i.throwIfAborted(), s !== void 0 && s.baseFeeRate !== n.protocolFeeRate)
     throw new Error(
       `Deposit terms baseFeeRate (${s.baseFeeRate} sat/vB) does not match the vault's version-locked protocolFeeRate (${n.protocolFeeRate} sat/vB); refusing to sign payouts against terms built from a different params version.`
     );
-  if (se(o)) {
+  if (be(o)) {
     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 o.approveDepositTerms(s);
   }
-  const p = await r.requestDepositorPresignTransactions(
+  const h = await r.requestDepositorPresignTransactions(
     {
-      pegin_txid: i,
+      pegin_txid: a,
       depositor_pk: l
     },
-    a
+    i
   );
-  a == null || a.throwIfAborted();
-  const b = _(l);
-  He(
-    p.txs,
+  i == null || i.throwIfAborted();
+  const v = T(l);
+  Qe(
+    h.txs,
     n.vaultProviderBtcPubkey,
     n.vaultKeeperBtcPubkeys,
     l
   );
-  const m = p.txs.filter(
-    (v) => _(v.claimer_pubkey) !== b
-  ), y = Ne(m), T = await Oe(
+  const y = h.txs.filter(
+    (P) => T(P.claimer_pubkey) !== v
+  ), E = je(y), w = await Ye(
     o,
     n,
-    y,
-    h
+    E,
+    p
   );
-  a == null || a.throwIfAborted();
-  const P = await Ve({
-    depositorGraph: p.depositor_graph,
+  i == null || i.throwIfAborted();
+  const m = await Xe({
+    depositorGraph: h.depositor_graph,
     btcWallet: o,
     signingContext: {
       vaultCoreVersion: n.vaultCoreVersion,
@@ -531,276 +505,472 @@ async function ht(e) {
       councilQuorum: n.councilQuorum,
       network: n.network,
       registeredPayoutScriptPubKey: n.registeredPayoutScriptPubKey,
-      protocolFeeRate: n.protocolFeeRate
+      protocolFeeRate: n.protocolFeeRate,
+      vkClaimerPayoutScriptPubKeys: n.vkClaimerPayoutScriptPubKeys,
+      vpCommissionScriptPubKey: n.vpCommissionScriptPubKey
     }
   });
-  a == null || a.throwIfAborted();
-  const w = { ...T };
-  w[d(l)] = P.payout_signatures, await r.submitDepositorPresignatures(
+  i == null || i.throwIfAborted();
+  const b = { ...w };
+  b[d(l)] = m.payout_signatures, await r.submitDepositorPresignatures(
     {
-      pegin_txid: i,
+      pegin_txid: a,
       depositor_pk: l,
-      signatures: w,
-      depositor_claimer_presignatures: P
+      signatures: b,
+      depositor_claimer_presignatures: m
+    },
+    i
+  );
+}
+const We = 300 * 1e3, Je = /* @__PURE__ */ new Set([
+  x.PENDING_DEPOSITOR_WOTS_PK,
+  ...oe
+]);
+async function Rt(e) {
+  const {
+    statusReader: t,
+    wotsSubmitter: r,
+    peginTxid: o,
+    depositorPk: a,
+    wotsPublicKeys: l,
+    timeoutMs: n = We,
+    signal: s
+  } = e;
+  s == null || s.throwIfAborted();
+  const u = await ne({
+    statusReader: t,
+    peginTxid: o,
+    targetStatuses: Je,
+    timeoutMs: n,
+    signal: s
+  });
+  oe.has(u) || (s == null || s.throwIfAborted(), await r.submitDepositorWotsKey(
+    {
+      pegin_txid: o,
+      depositor_pk: a,
+      wots_public_keys: l
     },
-    a
+    s
+  ));
+}
+function N(e, t, r) {
+  const o = `${e} operation key (admin=${t.ethAddress})`, a = Q(
+    t.btcPubKey,
+    `${e} roster key (admin=${t.ethAddress})`
+  ), l = Q(r, o);
+  return {
+    adminAddress: t.ethAddress,
+    genesisBtcPubkey: a,
+    operationBtcPubkey: l,
+    rotated: l !== a
+  };
+}
+function Ze(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const r of e) {
+    const o = t.get(r.operationBtcPubkey);
+    if (o)
+      throw new Error(
+        `Participant operation key collision: ${o} and ${r.adminAddress} both resolve to operation key ${r.operationBtcPubkey}`
+      );
+    t.set(r.operationBtcPubkey, r.adminAddress);
+  }
+}
+function se(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 = N(
+    "vault provider",
+    {
+      ethAddress: e.vaultProviderEthAddress,
+      btcPubKey: e.vaultProviderGenesisBtcPubkey
+    },
+    t.vaultProvider
+  ), a = e.vaultKeepers.map(
+    (n, s) => N("vault keeper", n, t.vaultKeepers[s])
+  ), l = e.universalChallengers.map(
+    (n, s) => N("universal challenger", n, t.universalChallengers[s])
+  );
+  return Ze([
+    o,
+    ...a,
+    ...l
+  ]), {
+    vaultProvider: o,
+    vaultKeepers: a,
+    universalChallengers: l,
+    // Derived from the pairs, never the reverse — see ParticipantKeySet.
+    vaultKeeperOperationKeysSorted: a.map((n) => n.operationBtcPubkey).sort(),
+    universalChallengerOperationKeysSorted: l.map((n) => n.operationBtcPubkey).sort(),
+    resolvedAt: r,
+    query: e
+  };
+}
+async function et(e) {
+  const t = await e.operationKeyReader.getCurrentOperationKeys(
+    e.query
+  );
+  return se(e.query, t, { mode: "current" });
+}
+async function tt(e) {
+  const t = await e.operationKeyReader.getOperationKeysAtEpochs(
+    e.query,
+    e.epochs
   );
+  return se(e.query, t, {
+    mode: "epochs",
+    epochs: e.epochs
+  });
 }
-function De(e) {
+const L = (e) => B(e).toLowerCase(), R = (e) => e.map(L).sort();
+function A(e, t) {
+  return e.length === t.length && e.every((r, o) => r === t[o]);
+}
+async function At(e) {
+  const {
+    vaultRegistryReader: t,
+    vaultKeeperReader: r,
+    universalChallengerReader: o,
+    vaultProviderEthAddress: a,
+    applicationEntryPoint: l,
+    expectedVaultProviderBtcPubkey: n,
+    expectedVaultKeeperBtcPubkeys: s,
+    expectedUniversalChallengerBtcPubkeys: u,
+    operationKeyReader: i,
+    onIndexerServingOperationKeys: p,
+    onIndexerHintsInconsistent: c
+  } = e, [
+    h,
+    v,
+    y
+  ] = await Promise.all([
+    t.getVaultProviderBtcPubKey(a),
+    r.getCurrentVaultKeepersVersion(l),
+    o.getLatestUniversalChallengersVersion()
+  ]), [E, w] = await Promise.all([
+    r.getVaultKeepersByVersion(
+      l,
+      v
+    ),
+    o.getUniversalChallengersByVersion(
+      y
+    )
+  ]), m = {
+    vaultProvider: L(h),
+    vaultKeepers: R(E.map((f) => f.btcPubKey)),
+    universalChallengers: R(w.map((f) => f.btcPubKey))
+  }, b = await et({
+    operationKeyReader: i,
+    query: {
+      vaultProviderEthAddress: a,
+      vaultProviderGenesisBtcPubkey: `0x${h}`,
+      applicationEntryPoint: l,
+      vaultKeepers: E,
+      universalChallengers: w
+    }
+  }), P = {
+    vaultProvider: b.vaultProvider.operationBtcPubkey,
+    vaultKeepers: [...b.vaultKeeperOperationKeysSorted],
+    universalChallengers: [
+      ...b.universalChallengerOperationKeysSorted
+    ]
+  }, C = L(n), _ = R(s), $ = R(u), g = {
+    registration: C === m.vaultProvider,
+    operation: C === P.vaultProvider
+  }, z = {
+    registration: A(_, m.vaultKeepers),
+    operation: A(_, P.vaultKeepers)
+  }, G = {
+    registration: A(
+      $,
+      m.universalChallengers
+    ),
+    operation: A($, P.universalChallengers)
+  }, V = (f) => f.registration || f.operation;
+  if (!V(g))
+    throw new Error(
+      `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${a}. Refresh and try again.`
+    );
+  if (!V(z))
+    throw new Error(
+      `Vault keeper BTC pubkeys (v${v}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
+    );
+  if (!V(G))
+    throw new Error(
+      `Universal challenger BTC pubkeys (v${y}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
+    );
+  const q = [g, z, G], he = q.some((f) => f.registration && !f.operation), j = q.some((f) => f.operation && !f.registration);
+  if (he && j) {
+    const f = `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(f), new Error(`${f} Refresh and try again.`);
+  }
+  return j && (p == null || p(
+    `Indexer is serving rotated operation keys for vault provider ${a}`
+  )), {
+    vaultProviderBtcPubkeyXOnly: P.vaultProvider,
+    vaultKeeperBtcPubkeysSorted: P.vaultKeepers,
+    universalChallengerBtcPubkeysSorted: P.universalChallengers,
+    expectedAppVaultKeepersVersion: v,
+    expectedUniversalChallengersVersion: y,
+    registrationKeys: m,
+    participantKeys: b
+  };
+}
+function rt(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function pt(e) {
+function Bt(e) {
   const {
     amountSats: t,
     minDeposit: r,
     maxDeposit: o,
-    btcBalance: i,
+    btcBalance: a,
     estimatedFeeSats: l,
     depositorClaimValue: n
   } = e;
-  return !(t <= 0n || t < r || o && o > 0n && t > o || l == null || n == null || t + l + n > i);
+  return !(t <= 0n || t < r || o && o > 0n && t > o || l == null || n == null || t + l + n > a);
 }
-function dt(e, t, r) {
+function Vt(e, t, r) {
   return e <= 0n ? {
     valid: !1,
     error: "Deposit amount must be greater than zero"
   } : e < t ? {
     valid: !1,
-    error: `Minimum deposit is ${E(t)} BTC`
+    error: `Minimum deposit is ${k(t)} BTC`
   } : r && r > 0n && e > r ? {
     valid: !1,
-    error: `Maximum deposit is ${E(r)} BTC`
+    error: `Maximum deposit is ${k(r)} BTC`
   } : { valid: !0 };
 }
-function gt(e) {
+function It(e) {
   const { amount: t, effectiveRemaining: r } = e;
   return r === null ? { valid: !0 } : r === 0n ? {
     valid: !1,
     error: "Supply cap reached — deposits temporarily paused"
   } : t > r ? {
     valid: !1,
-    error: `Vault size exceeds remaining capacity (${E(r)} BTC)`
+    error: `Vault size exceeds remaining capacity (${k(r)} BTC)`
   } : { valid: !0 };
 }
-function ft(e, t) {
+function Kt(e, t) {
   if (!e || e.length === 0)
     return {
       valid: !1,
       error: "At least one vault provider must be selected"
     };
   const r = t.map(
-    (i) => i.toLowerCase()
+    (a) => a.toLowerCase()
   );
   return e.filter(
-    (i) => !r.includes(i.toLowerCase())
+    (a) => !r.includes(a.toLowerCase())
   ).length > 0 ? {
     valid: !1,
     error: "Invalid vault provider selected"
   } : { valid: !0 };
 }
-function Fe(e, t, r) {
+function ot(e, t, r) {
   if (!e || e.length === 0)
     return {
       valid: !1,
       error: "At least one vault amount required"
     };
   for (let o = 0; o < e.length; o++) {
-    const i = e[o];
-    if (i <= 0n)
+    const a = e[o];
+    if (a <= 0n)
       return {
         valid: !1,
         error: `Vault ${o + 1} amount must be positive`
       };
-    if (t && i < t)
+    if (t && a < t)
       return {
         valid: !1,
-        error: `Vault ${o + 1} amount ${E(i)} BTC is below minimum deposit ${E(t)} BTC`
+        error: `Vault ${o + 1} amount ${k(a)} BTC is below minimum deposit ${k(t)} BTC`
       };
-    if (r && i > r)
+    if (r && a > r)
       return {
         valid: !1,
-        error: `Vault ${o + 1} amount ${E(i)} BTC exceeds maximum deposit ${E(r)} BTC`
+        error: `Vault ${o + 1} amount ${k(a)} BTC exceeds maximum deposit ${k(r)} BTC`
       };
   }
   return { valid: !0 };
 }
-function Ke(e) {
+function nt(e) {
   const t = d(e);
-  return De(t) ? { valid: !0 } : {
+  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 Ue(e) {
+function at(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 Me(e) {
+function st(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 Le(e) {
+function it(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function mt(e) {
+function Ot(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
     vaultProviderBtcPubkey: o,
-    vaultKeeperBtcPubkeys: i,
+    vaultKeeperBtcPubkeys: a,
     universalChallengerBtcPubkeys: l,
     minDeposit: n,
     maxDeposit: s
-  } = e, u = Fe(
+  } = e, u = ot(
     t,
     n,
     s
   );
   if (!u.valid)
     throw new Error(u.error);
-  const a = Ke(o);
-  if (!a.valid)
-    throw new Error(a.error);
-  Ue(i), Me(l), Le(r);
+  const i = nt(o);
+  if (!i.valid)
+    throw new Error(i.error);
+  at(a), st(l), it(r);
 }
-async function bt(e) {
-  const {
-    vaultRegistryReader: t,
-    vaultKeeperReader: r,
-    universalChallengerReader: o,
-    vaultProviderEthAddress: i,
-    applicationEntryPoint: l,
-    expectedVaultProviderBtcPubkey: n,
-    expectedVaultKeeperBtcPubkeys: s,
-    expectedUniversalChallengerBtcPubkeys: u
-  } = e, [
-    a,
-    h,
-    c
-  ] = await Promise.all([
-    t.getVaultProviderBtcPubKey(i),
-    r.getCurrentVaultKeepersVersion(l),
-    o.getLatestUniversalChallengersVersion()
-  ]), [p, b] = await Promise.all([
-    r.getVaultKeepersByVersion(
-      l,
-      h
-    ),
-    o.getUniversalChallengersByVersion(
-      c
-    )
-  ]), m = (g) => R(g).toLowerCase(), y = (g) => g.map(m).sort();
-  if (m(n) !== a)
-    throw new Error(
-      `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${i}. Refresh and try again.`
+class ie extends Error {
+  constructor(t) {
+    super(t), this.name = "ParticipantKeyDriftError";
+  }
+}
+function Nt(e) {
+  return e instanceof ie || e instanceof Error && e.name === "ParticipantKeyDriftError";
+}
+function J(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 Ht(e) {
+  const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: o, expected: a } = e, l = a.query;
+  if (o.length === 0) return;
+  const n = await t.getVaultKeyEpochsBatch(o), s = [];
+  for (const [u, i] of n.entries()) {
+    const p = o[u];
+    let c;
+    try {
+      c = await tt({
+        operationKeyReader: r,
+        query: l,
+        epochs: i
+      });
+    } catch (y) {
+      s.push(
+        `vault ${p}: could not resolve participants at frozen epochs (vp=${i.vpKeyEpoch}, keeper=${i.appKeeperKeyEpoch}, uc=${i.ucKeyEpoch}): ${y.message}`
+      );
+      continue;
+    }
+    c.vaultProvider.operationBtcPubkey !== a.vaultProvider.operationBtcPubkey && s.push(
+      `vault ${p}: vault provider key expected ${a.vaultProvider.operationBtcPubkey}, got ${c.vaultProvider.operationBtcPubkey}`
     );
-  const P = y(s), w = y(
-    p.map((g) => g.btcPubKey)
-  );
-  if (P.length !== w.length || P.some((g, C) => g !== w[C]))
-    throw new Error(
-      `Vault keeper BTC pubkeys (v${h}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
+    const h = J(
+      `vault ${p}: vault keeper keys`,
+      a.vaultKeeperOperationKeysSorted,
+      c.vaultKeeperOperationKeysSorted
     );
-  const v = y(u), k = y(
-    b.map((g) => g.btcPubKey)
-  );
-  if (v.length !== k.length || v.some((g, C) => g !== k[C]))
-    throw new Error(
-      `Universal challenger BTC pubkeys (v${c}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
+    h && s.push(h);
+    const v = J(
+      `vault ${p}: universal challenger keys`,
+      a.universalChallengerOperationKeysSorted,
+      c.universalChallengerOperationKeysSorted
+    );
+    v && s.push(v);
+  }
+  if (s.length > 0)
+    throw new ie(
+      `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.`
     );
-  return {
-    vaultProviderBtcPubkeyXOnly: a,
-    vaultKeeperBtcPubkeysSorted: w,
-    universalChallengerBtcPubkeysSorted: k,
-    expectedAppVaultKeepersVersion: h,
-    expectedUniversalChallengersVersion: c
-  };
 }
-class j extends Error {
+class ue extends Error {
   constructor(t) {
     super(t), this.name = "RegisteredVaultVersionMismatchError";
   }
 }
-function Pt(e) {
-  return e instanceof j || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
+function Dt(e) {
+  return e instanceof ue || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function yt(e) {
+async function Ft(e) {
   const {
     vaultRegistryReader: t,
     vaultIds: r,
     expectedOffchainParamsVersion: o,
-    expectedAppVaultKeepersVersion: i,
+    expectedAppVaultKeepersVersion: a,
     expectedUniversalChallengersVersion: l,
     expectedVaultCoreVersion: n
   } = e, s = await t.getProtocolInfoBatch(r), u = [];
-  if (s.forEach((a, h) => {
-    const c = r[h];
-    a.offchainParamsVersion !== o && u.push(
-      `vault ${c}: offchainParams expected v${o}, got v${a.offchainParamsVersion}`
-    ), a.appVaultKeepersVersion !== i && u.push(
-      `vault ${c}: appVaultKeepers expected v${i}, got v${a.appVaultKeepersVersion}`
-    ), a.universalChallengersVersion !== l && u.push(
-      `vault ${c}: universalChallengers expected v${l}, got v${a.universalChallengersVersion}`
-    ), a.vaultCoreVersion !== n && u.push(
-      `vault ${c}: vaultCoreVersion expected v${n} (build-time active), got v${a.vaultCoreVersion}`
+  if (s.forEach((i, p) => {
+    const c = r[p];
+    i.offchainParamsVersion !== o && u.push(
+      `vault ${c}: offchainParams expected v${o}, got v${i.offchainParamsVersion}`
+    ), i.appVaultKeepersVersion !== a && u.push(
+      `vault ${c}: appVaultKeepers expected v${a}, got v${i.appVaultKeepersVersion}`
+    ), i.universalChallengersVersion !== l && u.push(
+      `vault ${c}: universalChallengers expected v${l}, got v${i.universalChallengersVersion}`
+    ), i.vaultCoreVersion !== n && u.push(
+      `vault ${c}: vaultCoreVersion expected v${n} (build-time active), got v${i.vaultCoreVersion}`
     );
   }), u.length > 0)
-    throw new j(
+    throw new ue(
       `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${u.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-var Q = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(Q || {});
-const Xe = /* @__PURE__ */ new Set([
+var le = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(le || {});
+const ut = /* @__PURE__ */ new Set([
   "PayoutBroadcast",
   "PayoutBlocked"
   /* PAYOUT_BLOCKED */
 ]);
-function wt(e) {
-  return Object.values(Q).includes(
+function Mt(e) {
+  return Object.values(le).includes(
     e
   );
 }
-function vt(e) {
-  return !!e && Xe.has(e);
+function Ut(e) {
+  return !!e && ut.has(e);
 }
-class ze extends Error {
+class lt extends Error {
   constructor(r, o) {
     super(`Refund not yet mature (BIP68 not final): ${o.message}`);
-    A(this, "vaultId");
-    A(this, "cause");
+    I(this, "vaultId");
+    I(this, "cause");
     this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = o;
   }
 }
-const Ge = /^0x[0-9a-fA-F]{64}$/, qe = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, Y = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, W = 160, U = 2e3, M = 10n, L = 100n;
-function xt(e) {
+const ct = /^0x[0-9a-fA-F]{64}$/, pt = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, ce = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, pe = 160, Z = 2e3, ee = 10n, te = 100n;
+function Lt(e) {
   if (!Number.isFinite(e) || e <= 0)
     throw new Error(
       `feeRateSatsVb must be a positive finite number, got ${e}`
     );
-  return BigInt(Math.ceil(e * W));
+  return BigInt(Math.ceil(e * pe));
 }
-const je = 1, Qe = /non-BIP68-final/i;
-function D(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 (!Ge.test(e))
+  if (!ct.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function B(e, t) {
+function H(e, t) {
   if (!Number.isInteger(e) || e < 0)
     throw new Error(`${t} must be a non-negative integer, got ${e}`);
 }
-function Ye(e) {
-  if (D(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
+function gt(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}`
     );
@@ -812,7 +982,7 @@ function Ye(e) {
     );
   for (let r = 0; r < e.batch.length; r++) {
     const o = e.batch[r];
-    if (D(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}`
       );
@@ -830,27 +1000,27 @@ function Ye(e) {
     throw new Error(
       `batch[${e.htlcVout}].amount (${t.amount}) does not match target amount (${e.amount})`
     );
-  if (B(e.offchainParamsVersion, "offchainParamsVersion"), B(e.appVaultKeepersVersion, "appVaultKeepersVersion"), B(
+  if (H(e.offchainParamsVersion, "offchainParamsVersion"), H(e.appVaultKeepersVersion, "appVaultKeepersVersion"), H(
     e.universalChallengersVersion,
     "universalChallengersVersion"
-  ), me(
+  ), 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 (!qe.test(e.unsignedPrePeginTxHex))
+  if (!pt.test(e.unsignedPrePeginTxHex))
     throw new Error(
       "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
     );
-  if (!e.depositorBtcPubkey || !Y.test(e.depositorBtcPubkey))
+  if (!e.depositorBtcPubkey || !ce.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 We(e) {
-  if (!e.vaultProviderPubkey || !Y.test(e.vaultProviderPubkey))
+function ft(e) {
+  if (!e.vaultProviderPubkey || !ce.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");
@@ -875,8 +1045,8 @@ function We(e) {
       `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
     );
 }
-function Je(e) {
-  const t = he.fromHex(e);
+function vt(e) {
+  const t = Ce.fromHex(e);
   try {
     t.finalizeAllInputs();
   } catch (r) {
@@ -886,79 +1056,79 @@ function Je(e) {
   }
   return t.extractTransaction().toHex();
 }
-async function Et(e) {
+async function Xt(e) {
   const {
     vaultId: t,
     readVault: r,
     readPrePeginContext: o,
-    feeRate: i,
+    feeRate: a,
     signPsbt: l,
     broadcastTx: n,
     signal: s
   } = e;
-  s == null || s.throwIfAborted(), D(t, "vaultId");
+  s == null || s.throwIfAborted(), X(t, "vaultId");
   const u = await r();
-  Ye(u), s == null || s.throwIfAborted();
-  const a = await o(u);
-  if (We(a), s == null || s.throwIfAborted(), !Number.isFinite(i) || i <= 0)
-    throw new Error(`feeRate must be a positive number, got ${i}`);
-  if (i > U)
+  gt(u), s == null || s.throwIfAborted();
+  const i = await o(u);
+  if (ft(i), s == null || s.throwIfAborted(), !Number.isFinite(a) || a <= 0)
+    throw new Error(`feeRate must be a positive number, got ${a}`);
+  if (a > Z)
     throw new Error(
-      `feeRate ${i} sat/vB exceeds refund safety cap ${U} sat/vB; refusing to sign refund.`
+      `feeRate ${a} sat/vB exceeds refund safety cap ${Z} sat/vB; refusing to sign refund.`
     );
-  const h = BigInt(Math.ceil(i * W)), c = u.amount * M / L;
-  if (h > c)
+  const p = BigInt(Math.ceil(a * pe)), c = u.amount * ee / te;
+  if (p > c)
     throw new Error(
-      `Refund fee ${h} sats exceeds the per-vault safety cap of ${c} sats (${M}/${L} of vault.amount=${u.amount}); refusing to sign refund.`
+      `Refund fee ${p} sats exceeds the per-vault safety cap of ${c} sats (${ee}/${te} of vault.amount=${u.amount}); refusing to sign refund.`
     );
   s == null || s.throwIfAborted();
-  const p = R(
+  const h = B(
     u.depositorBtcPubkey
-  ), b = d(u.unsignedPrePeginTxHex), m = ie(b);
-  if (m !== void 0 && m.vout !== u.batch.length)
+  ), v = d(u.unsignedPrePeginTxHex), y = xe(v);
+  if (y !== void 0 && y.vout !== u.batch.length)
     throw new Error(
-      `Auth-anchor OP_RETURN at vout ${m.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 ${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.`
     );
-  const y = m == null ? void 0 : m.hash;
-  let T;
+  const E = y == null ? void 0 : y.hash;
+  let w;
   try {
-    T = S.fromHex(b);
-  } catch (f) {
+    w = S.fromHex(v);
+  } catch (g) {
     throw new Error(
-      `Failed to parse funded Pre-PegIn transaction hex: ${f instanceof Error ? f.message : String(f)}`
+      `Failed to parse funded Pre-PegIn transaction hex: ${g instanceof Error ? g.message : String(g)}`
     );
   }
-  if (T.outs.length < u.batch.length)
+  if (w.outs.length < u.batch.length)
     throw new Error(
-      `Funded Pre-PegIn tx has ${T.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 ${w.outs.length} outputs but batch requires at least ${u.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
     );
-  const { psbtHex: P } = await fe({
+  const { psbtHex: m } = await Re({
     prePeginParams: {
       vaultCoreVersion: u.vaultCoreVersion,
-      depositorPubkey: p,
-      vaultProviderPubkey: d(a.vaultProviderPubkey),
-      vaultKeeperPubkeys: a.vaultKeeperPubkeys.map(d),
-      universalChallengerPubkeys: a.universalChallengerPubkeys.map(d),
-      hashlocks: u.batch.map((f) => d(f.hashlock)),
-      timelockRefund: a.timelockRefund,
+      depositorPubkey: h,
+      vaultProviderPubkey: d(i.vaultProviderPubkey),
+      vaultKeeperPubkeys: i.vaultKeeperPubkeys.map(d),
+      universalChallengerPubkeys: i.universalChallengerPubkeys.map(d),
+      hashlocks: u.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
       // reserve (`depositorClaimValue + minPeginFee`) internally when sizing the
       // HTLC output. `buildRefundPsbt`'s value cross-check then binds the result
       // to the funded tx bytes, refusing the refund if the template's HTLC value
       // disagrees with the on-chain commitment.
-      pegInAmounts: u.batch.map((f) => f.amount),
-      feeRate: a.feeRate,
-      minPeginFeeRate: a.minPeginFeeRate,
-      numLocalChallengers: a.numLocalChallengers,
-      councilQuorum: a.councilQuorum,
-      councilSize: a.councilSize,
-      network: a.network,
-      authAnchorHash: y
+      pegInAmounts: u.batch.map((g) => g.amount),
+      feeRate: i.feeRate,
+      minPeginFeeRate: i.minPeginFeeRate,
+      numLocalChallengers: i.numLocalChallengers,
+      councilQuorum: i.councilQuorum,
+      councilSize: i.councilSize,
+      network: i.network,
+      authAnchorHash: E
     },
-    fundedPrePeginTxHex: b,
+    fundedPrePeginTxHex: v,
     htlcVout: u.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
@@ -966,59 +1136,64 @@ async function Et(e) {
     hashlock: d(u.hashlock)
   });
   s == null || s.throwIfAborted();
-  const w = O(
+  const b = U(
     u.depositorBtcPubkey,
-    je
-  ), v = await l(P, w);
-  I({
-    requestedPsbtHex: P,
-    returnedPsbtHex: v
+    ht
+  ), P = await l(m, b);
+  D({
+    requestedPsbtHex: m,
+    returnedPsbtHex: P
   });
-  const k = 0, g = N(
-    v,
-    p,
-    k
+  const C = 0, _ = F(
+    P,
+    h,
+    C
   );
-  H({
-    requestedPsbtHex: P,
-    signatureHex: g,
-    signerXOnlyPubkeyHex: p,
-    inputIndex: k
+  M({
+    requestedPsbtHex: m,
+    signatureHex: _,
+    signerXOnlyPubkeyHex: h,
+    inputIndex: C
   });
-  const C = Je(v);
+  const $ = vt(P);
   s == null || s.throwIfAborted();
   try {
-    return await n(C);
-  } catch (f) {
-    throw f instanceof Error && Qe.test(f.message) ? new ze(t, f) : f;
+    return await n($);
+  } catch (g) {
+    throw g instanceof Error && dt.test(g.message) ? new lt(t, g) : g;
   }
 }
 export {
-  ze as B,
-  Q as C,
-  j as R,
-  lt as a,
-  Ve as b,
-  gt as c,
-  ft as d,
-  Fe as e,
-  Ke as f,
-  mt as g,
-  bt as h,
-  pt as i,
-  Pt as j,
-  yt as k,
-  wt as l,
-  vt as m,
-  Et as n,
-  xt as o,
-  L as p,
-  M as q,
-  ht as r,
-  ct as s,
-  U as t,
-  W as u,
-  dt as v,
-  G as w
+  pe as A,
+  lt as B,
+  le as C,
+  ie as P,
+  ue as R,
+  _t as a,
+  Rt as b,
+  Vt as c,
+  Ot as d,
+  Kt as e,
+  It as f,
+  ot as g,
+  nt as h,
+  Bt as i,
+  Nt as j,
+  Ht as k,
+  Dt as l,
+  Ft as m,
+  et as n,
+  tt as o,
+  Mt as p,
+  Ut as q,
+  $t as r,
+  Xe as s,
+  Xt as t,
+  Lt as u,
+  At as v,
+  ne as w,
+  te as x,
+  ee as y,
+  Z as z
 };
-//# sourceMappingURL=buildAndBroadcastRefund-BtXUqBkb.js.map
+//# sourceMappingURL=buildAndBroadcastRefund-CCb1_z24.js.map