@babylonlabs-io/ts-sdk 0.66.1 → 0.68.0

package/dist/{buildAndBroadcastRefund-C4LiPATK.js → buildAndBroadcastRefund-CpMDJ8up.js}

@@ -1,44 +1,44 @@
 var me = Object.defineProperty;
-var Pe = (e, t, r) => t in e ? me(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var $ = (e, t, r) => Pe(e, typeof t != "symbol" ? t + "" : t, r);
+var ve = (e, t, r) => t in e ? me(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var _ = (e, t, r) => ve(e, typeof t != "symbol" ? t + "" : t, r);
 import { B as re } from "./BTCVaultRegistry.abi-CJwWI2EO.js";
-import { e as ye, v as be, s as f, u as ne, p as U, c as x, f as C } from "./bitcoin-d9eaaZB_.js";
-import { v as we, d as ke, s as Ee, P as xe, a as Te } from "./signPsbtsWithFallback-Bb66DfY5.js";
+import { e as ye, v as be, s as m, u as ne, p as L, c as x, f as C } from "./bitcoin-Ch_jxnDa.js";
+import { v as we, d as ke, s as Ee, P as xe, a as Te } from "./signPsbtsWithFallback-Bv79gLFe.js";
 import { zeroAddress as Ce } from "viem";
-import { D as T, c as Se, b as Ae, R as Re, d as oe } from "./json-rpc-client-DuUARJvV.js";
-import { Transaction as A, Psbt as _e } from "bitcoinjs-lib";
-import { c as $e, d as H, e as D, f as F } from "./verifyScriptPathSchnorrSignature-i-koT139.js";
-import { c as Be, a as Ie, b as Ve } from "./noPayout-BaZGRLD2.js";
+import { D as T, c as Se, b as Ae, R as Be, d as oe } from "./json-rpc-client-DuUARJvV.js";
+import { Transaction as A, Psbt as Re } from "bitcoinjs-lib";
+import { j as _e, d as $e, f as H, e as D, g as F } from "./verifyScriptPathSchnorrSignature-Dy9gF5RF.js";
+import { c as Ie, a as Ve, b as Ke } from "./noPayout-CXn-geIS.js";
 import { c as M } from "./signing-DaLvGwQe.js";
-import { a as X } from "./onChainBtcPubkey-DeF4cKoO.js";
-import { a as Ke } from "./constants-GjWXdaqV.js";
-const Ne = /^0x[0-9a-fA-F]{64}$/, Oe = /^0x[0-9a-fA-F]{40}$/, He = /^0x([0-9a-fA-F]{2})*$/;
-function B(e, t) {
+import { a as X } from "./onChainBtcPubkey-BAHZyKQL.js";
+import { a as Ne } from "./constants-GjWXdaqV.js";
+const Oe = /^0x[0-9a-fA-F]{64}$/, He = /^0x[0-9a-fA-F]{40}$/, De = /^0x([0-9a-fA-F]{2})*$/;
+function $(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 (!Ne.test(e))
+  if (!Oe.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function De(e, t) {
-  if (!Oe.test(e))
+function Fe(e, t) {
+  if (!He.test(e))
     throw new Error(
       `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
     );
 }
-function Fe(e, t) {
-  if (!He.test(e))
+function Me(e, t) {
+  if (!De.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
 }
-function se(e) {
-  De(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), B(e.vaultId, "vaultId");
+function ae(e) {
+  Fe(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), $(e.vaultId, "vaultId");
   const t = ye(e.secret);
-  if (B(t, "secret"), e.hashlock !== void 0 && (B(e.hashlock, "hashlock"), !we(t, e.hashlock)))
+  if ($(t, "secret"), e.hashlock !== void 0 && ($(e.hashlock, "hashlock"), !we(t, e.hashlock)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
@@ -54,13 +54,13 @@ async function Ft(e) {
     signal: o
   } = e;
   o == null || o.throwIfAborted();
-  const a = se({
+  const a = ae({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
     hashlock: n
   });
-  return Fe(s, "activationMetadata"), l({
+  return Me(s, "activationMetadata"), l({
     address: t,
     abi: re,
     functionName: "activateVaultWithSecret",
@@ -70,7 +70,7 @@ async function Ft(e) {
 async function Mt(e) {
   const { btcVaultRegistryAddress: t, vaultId: r, hashlock: n, writeContract: s, signal: l } = e;
   l == null || l.throwIfAborted();
-  const o = se({
+  const o = ae({
     btcVaultRegistryAddress: t,
     vaultId: r,
     secret: e.secret,
@@ -83,8 +83,8 @@ async function Mt(e) {
     args: [r, o]
   });
 }
-const Me = 8, Le = 6e3, Ue = 10 * 6e4, ze = 10;
-class ae extends Error {
+const Ue = 8, Le = 6e3, ze = 10 * 6e4, Xe = 10;
+class se extends Error {
   constructor(t) {
     super(t), this.name = "PeginRegistrationMissingError";
   }
@@ -94,24 +94,24 @@ class ie extends Error {
     super(t), this.name = "PeginRegistrationNotFinalError";
   }
 }
-function Xe(e) {
-  return e instanceof ae || e instanceof Error && e.name === "PeginRegistrationMissingError";
+function Ge(e) {
+  return e instanceof se || e instanceof Error && e.name === "PeginRegistrationMissingError";
 }
-function Lt(e) {
+function Ut(e) {
   return e instanceof ie || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
 }
 function G(e) {
   const { currentBlock: t, createdAtBlock: r } = e, n = t - r + 1n;
   return n < 0n ? 0 : Number(n);
 }
-async function Ut(e) {
+async function Lt(e) {
   const {
     vaultRegistryReader: t,
     getBlockNumber: r,
     vaultIds: n,
-    required: s = Me,
+    required: s = Ue,
     pollIntervalMs: l = Le,
-    timeoutMs: o = Ue,
+    timeoutMs: o = ze,
     signal: a,
     onProgress: i
   } = e;
@@ -132,13 +132,13 @@ async function Ut(e) {
       );
     try {
       const d = await r(), g = await Promise.all(
-        n.map((v) => t.getVaultBasicInfo(v))
+        n.map((f) => t.getVaultBasicInfo(f))
       ), b = g.findIndex(
-        (v) => v.depositor === Ce || v.createdAt === 0n
+        (f) => f.depositor === Ce || f.createdAt === 0n
       );
       if (b !== -1) {
-        if (c += 1, !h && c > ze)
-          throw new ae(
+        if (c += 1, !h && c > Xe)
+          throw new se(
             `Vault ${n[b]} is still not visible on-chain after ${c} reads — the registration does not exist.`
           );
         console.warn(
@@ -146,22 +146,22 @@ async function Ut(e) {
         ), i == null || i({ confirmations: 0, required: s });
       } else {
         h = !0, c = 0, p = void 0;
-        let v = g[0], m = G({
+        let f = g[0], P = G({
           currentBlock: d,
           createdAtBlock: g[0].createdAt
         });
         for (const w of g.slice(1)) {
-          const P = G({
+          const v = G({
             currentBlock: d,
             createdAtBlock: w.createdAt
           });
-          P < m && (m = P, v = w);
+          v < P && (P = v, f = w);
         }
-        if (i == null || i({ confirmations: m, required: s }), m >= s)
-          return { confirmations: m, basicInfo: v };
+        if (i == null || i({ confirmations: P, required: s }), P >= s)
+          return { confirmations: P, basicInfo: f };
       }
     } catch (d) {
-      if (Xe(d))
+      if (Ge(d))
         throw d;
       console.warn(
         `Registration-depth read failed (retrying in ${l}ms): ` + (d instanceof Error ? d.message : String(d))
@@ -169,41 +169,29 @@ async function Ut(e) {
     }
     await new Promise((d, g) => {
       const b = () => {
-        clearTimeout(v), g(
+        clearTimeout(f), g(
           new Error(
             `Aborted while waiting for peg-in registration depth (${n.length} vault(s))`
           )
         );
-      }, v = setTimeout(() => {
+      }, f = setTimeout(() => {
         a == null || a.removeEventListener("abort", b), d();
       }, l);
       a == null || a.addEventListener("abort", b, { once: !0 });
     });
   }
 }
-const j = 1, Ge = 1;
-function je(e, t) {
-  const r = f(t).toLowerCase(), s = e.map((l) => f(l).toLowerCase()).filter((l) => l !== r);
-  if (s.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)
-    throw new Error(
-      "Cannot derive localChallengers: duplicate vaultKeeper key — signing context is misconfigured"
-    );
-  return s;
-}
+const j = 1, je = 1;
 function qe(e, t, r) {
   const n = r.map(
-    (c) => f(c).toLowerCase()
+    (c) => m(c).toLowerCase()
   ), s = t.filter((c) => n.includes(c));
   if (s.length > 0)
     throw new Error(
       `Cannot validate challenger set: vault keepers and universal challengers overlap (${s.join(", ")})`
     );
   const l = [...t, ...n], o = e.map(
-    (c) => f(c.challenger_pubkey).toLowerCase()
+    (c) => m(c.challenger_pubkey).toLowerCase()
   ), a = new Set(o);
   if (a.size !== o.length)
     throw new Error(
@@ -232,10 +220,12 @@ function I(e, t, r, n, s) {
     );
 }
 async function We(e, t, r) {
-  const n = [], s = [], l = [], o = je(
-    r.vaultKeeperBtcPubkeys,
-    r.depositorBtcPubkey
-  );
+  const n = [], s = [], l = [], o = _e({
+    claimerBtcPubkey: r.depositorBtcPubkey,
+    depositorBtcPubkey: r.depositorBtcPubkey,
+    vaultProviderBtcPubkey: r.vaultProviderBtcPubkey,
+    vaultKeeperBtcPubkeys: r.vaultKeeperBtcPubkeys
+  });
   qe(
     e.challenger_presign_data,
     o,
@@ -257,9 +247,10 @@ async function We(e, t, r) {
     network: r.network,
     claimerBtcPubkey: r.depositorBtcPubkey,
     registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
-    commissionBps: Ge,
+    commissionBps: je,
     protocolFeeRate: r.protocolFeeRate,
-    councilSize: r.councilMembers.length
+    councilMembers: r.councilMembers,
+    councilQuorum: r.councilQuorum
   });
   n.push(a.psbtHex), s.push(
     M(
@@ -267,11 +258,11 @@ async function We(e, t, r) {
       j
     )
   );
-  const i = f(r.depositorBtcPubkey), u = A.fromHex(
-    f(e.assert_tx.tx_hex)
+  const i = m(r.depositorBtcPubkey), u = A.fromHex(
+    m(e.assert_tx.tx_hex)
   );
   for (const h of e.challenger_presign_data) {
-    const c = f(h.challenger_pubkey), p = n.length, d = await Ye({
+    const c = m(h.challenger_pubkey), p = n.length, d = await Ye({
       challenger: h,
       challengerPubkey: c,
       claimerPubkey: i,
@@ -300,17 +291,17 @@ async function Ye(e) {
     assertTxParsed: l,
     ctx: o
   } = e;
-  Be(
+  Ie(
     t.nopayout_tx.tx_hex,
     r,
     o.network
   );
   const a = A.fromHex(
-    f(t.nopayout_tx.tx_hex)
+    m(t.nopayout_tx.tx_hex)
   ), i = A.fromHex(
-    f(t.challenge_assert_x_tx.tx_hex)
+    m(t.challenge_assert_x_tx.tx_hex)
   ), u = A.fromHex(
-    f(t.challenge_assert_y_tx.tx_hex)
+    m(t.challenge_assert_y_tx.tx_hex)
   );
   if (a.ins.length !== 3)
     throw new Error(
@@ -343,7 +334,7 @@ async function Ye(e) {
     script_pubkey: ne(new Uint8Array(c.script)),
     value: c.value
   }));
-  return Ie({
+  return Ve({
     noPayoutTxHex: t.nopayout_tx.tx_hex,
     challengerPubkey: r,
     prevouts: h,
@@ -396,7 +387,7 @@ function Je(e, t, r) {
 async function Ze(e) {
   const { depositorGraph: t, btcWallet: r, signingContext: n } = e, s = await r.getPublicKeyHex(), { depositorPubkey: l } = be(
     s,
-    f(n.depositorBtcPubkey)
+    m(n.depositorBtcPubkey)
   ), { psbtHexes: o, signOptions: a, challengerEntries: i } = await We(
     t,
     s,
@@ -451,7 +442,7 @@ async function ue(e) {
           `Pegin ${r.slice(0, 8)}… reached terminal status "${u}" while waiting for ${[...n].join(", ")}`
         );
     } catch (i) {
-      if (!(i instanceof Ae && i.code === Re.PEGIN_NOT_FOUND))
+      if (!(i instanceof Ae && i.code === Be.PEGIN_NOT_FOUND))
         throw i;
     }
     await new Promise((i, u) => {
@@ -479,13 +470,13 @@ const tt = 1200 * 1e3, le = /* @__PURE__ */ new Set([
 ]);
 function nt(e) {
   return e.map((t) => ({
-    claimerPubkeyXOnly: U(t.claimer_pubkey),
+    claimerPubkeyXOnly: L(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
     assertTxHex: t.assert_tx.tx_hex
   }));
 }
 function E(e) {
-  return U(e).toLowerCase();
+  return L(e).toLowerCase();
 }
 function ot(e, t) {
   const r = (i, u, h) => {
@@ -525,7 +516,7 @@ function ot(e, t) {
     t.vaultProviderBtcPubkey
   );
 }
-function st(e, t, r, n) {
+function at(e, t, r, n) {
   const s = E(n), l = [
     E(t),
     ...r.map(E)
@@ -565,12 +556,13 @@ function q(e, t) {
     claimerBtcPubkey: e.claimerPubkeyXOnly,
     commissionBps: t.commissionBps,
     protocolFeeRate: t.protocolFeeRate,
-    councilSize: t.councilMembers.length,
+    councilMembers: t.councilMembers,
+    councilQuorum: t.councilQuorum,
     vkClaimerPayoutScriptPubKeys: t.vkClaimerPayoutScriptPubKeys,
     vpCommissionScriptPubKey: t.vpCommissionScriptPubKey
   };
 }
-async function at(e, t, r, n) {
+async function st(e, t, r, n) {
   const s = new xe({
     network: t.network,
     btcWallet: e
@@ -635,22 +627,22 @@ async function zt(e) {
   );
   u == null || u.throwIfAborted();
   const d = E(l);
-  st(
+  at(
     p.txs,
     o.vaultProviderBtcPubkey,
     o.vaultKeeperBtcPubkeys,
     l
   );
   const g = p.txs.filter(
-    (P) => E(P.claimer_pubkey) !== d
-  ), b = nt(g), v = await at(
+    (v) => E(v.claimer_pubkey) !== d
+  ), b = nt(g), f = await st(
     n,
     o,
     b,
     h
   );
   u == null || u.throwIfAborted();
-  const m = await Ze({
+  const P = await Ze({
     depositorGraph: p.depositor_graph,
     btcWallet: n,
     signingContext: {
@@ -672,13 +664,13 @@ async function zt(e) {
     }
   });
   u == null || u.throwIfAborted();
-  const w = { ...v };
-  w[f(l)] = m.payout_signatures, await r.submitDepositorPresignatures(
+  const w = { ...f };
+  w[m(l)] = P.payout_signatures, await r.submitDepositorPresignatures(
     {
       pegin_txid: s,
       depositor_pk: l,
       signatures: w,
-      depositor_claimer_presignatures: m
+      depositor_claimer_presignatures: P
     },
     u
   );
@@ -851,7 +843,7 @@ async function jt(e) {
     ),
     r.getCurrentVaultKeepersVersion(l),
     n.getLatestUniversalChallengersVersion()
-  ]), [b, v] = await Promise.all([
+  ]), [b, f] = await Promise.all([
     r.getVaultKeepersByVersion(
       l,
       d
@@ -859,10 +851,10 @@ async function jt(e) {
     n.getUniversalChallengersByVersion(
       g
     )
-  ]), m = {
+  ]), P = {
     vaultProvider: x(p),
     vaultKeepers: Y(b.map((k) => k.btcPubKey)),
-    universalChallengers: Y(v.map((k) => k.btcPubKey))
+    universalChallengers: Y(f.map((k) => k.btcPubKey))
   }, w = await ht({
     operationKeyReader: u,
     query: {
@@ -870,9 +862,9 @@ async function jt(e) {
       vaultProviderGenesisBtcPubkey: `0x${p}`,
       applicationEntryPoint: l,
       vaultKeepers: b,
-      universalChallengers: v
+      universalChallengers: f
     }
-  }), P = {
+  }), v = {
     vaultProvider: w.vaultProvider.operationBtcPubkey,
     vaultKeepers: [...w.vaultKeeperOperationKeysSorted],
     universalChallengers: [
@@ -880,43 +872,43 @@ async function jt(e) {
     ]
   }, S = lt(
     o,
-    m.vaultProvider,
-    P.vaultProvider
-  ), R = Q(
+    P.vaultProvider,
+    v.vaultProvider
+  ), B = Q(
     a,
-    m.vaultKeepers,
-    P.vaultKeepers
-  ), _ = Q(
+    P.vaultKeepers,
+    v.vaultKeepers
+  ), R = Q(
     i,
-    m.universalChallengers,
-    P.universalChallengers
+    P.universalChallengers,
+    v.universalChallengers
   );
   if (!V(S))
     throw new Error(
       `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${s}. Refresh and try again.`
     );
-  if (!V(R))
+  if (!V(B))
     throw new Error(
       `Vault keeper BTC pubkeys (v${d}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
     );
-  if (!V(_))
+  if (!V(R))
     throw new Error(
       `Universal challenger BTC pubkeys (v${g}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
     );
-  const y = [S, R, _], ve = y.some((k) => k.registration && !k.operation), z = y.some((k) => k.operation && !k.registration);
-  if (ve && z) {
+  const y = [S, B, R], Pe = y.some((k) => k.registration && !k.operation), z = y.some((k) => k.operation && !k.registration);
+  if (Pe && z) {
     const k = `Indexer participant hints are internally inconsistent for vault provider ${s}: some roles match the registration keys while others match the rotated operation keys.`;
     throw c == null || c(k), new Error(`${k} Refresh and try again.`);
   }
   return z && (h == null || h(
     `Indexer is serving rotated operation keys for vault provider ${s}`
   )), {
-    vaultProviderBtcPubkeyXOnly: P.vaultProvider,
-    vaultKeeperBtcPubkeysSorted: P.vaultKeepers,
-    universalChallengerBtcPubkeysSorted: P.universalChallengers,
+    vaultProviderBtcPubkeyXOnly: v.vaultProvider,
+    vaultKeeperBtcPubkeysSorted: v.vaultKeepers,
+    universalChallengerBtcPubkeysSorted: v.universalChallengers,
     expectedAppVaultKeepersVersion: d,
     expectedUniversalChallengersVersion: g,
-    registrationKeys: m,
+    registrationKeys: P,
     participantKeys: w
   };
 }
@@ -999,13 +991,13 @@ function gt(e, t, r) {
   return { valid: !0 };
 }
 function ft(e) {
-  const t = f(e);
+  const t = m(e);
   return dt(t) ? { valid: !0 } : {
     valid: !1,
     error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
   };
 }
-function vt(e) {
+function Pt(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."
@@ -1017,7 +1009,7 @@ function mt(e) {
       "No universal challengers available. The system requires at least one universal challenger to create a deposit."
     );
 }
-function Pt(e) {
+function vt(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
@@ -1040,7 +1032,7 @@ function Jt(e) {
   const u = ft(n);
   if (!u.valid)
     throw new Error(u.error);
-  vt(s), mt(l), Pt(r);
+  Pt(s), mt(l), vt(r);
 }
 class he extends Error {
   constructor(t) {
@@ -1143,13 +1135,13 @@ function or(e) {
 class bt extends Error {
   constructor(r, n) {
     super(`Refund not yet mature (BIP68 not final): ${n.message}`);
-    $(this, "vaultId");
-    $(this, "cause");
+    _(this, "vaultId");
+    _(this, "cause");
     this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = n;
   }
 }
 const wt = /^0x[0-9a-fA-F]{64}$/, kt = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, ge = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, fe = 160, Z = 2e3, ee = 10n, te = 100n;
-function sr(e) {
+function ar(e) {
   if (!Number.isFinite(e) || e <= 0)
     throw new Error(
       `feeRateSatsVb must be a positive finite number, got ${e}`
@@ -1157,7 +1149,7 @@ function sr(e) {
   return BigInt(Math.ceil(e * fe));
 }
 const Et = 1, xt = /non-BIP68-final/i;
-function L(e, t) {
+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}`
@@ -1172,7 +1164,7 @@ function O(e, t) {
     throw new Error(`${t} must be a non-negative integer, got ${e}`);
 }
 function Tt(e) {
-  if (L(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
+  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}`
     );
@@ -1184,7 +1176,7 @@ function Tt(e) {
     );
   for (let r = 0; r < e.batch.length; r++) {
     const n = e.batch[r];
-    if (L(n.hashlock, `batch[${r}].hashlock`), !Number.isInteger(n.htlcVout) || n.htlcVout !== r)
+    if (U(n.hashlock, `batch[${r}].hashlock`), !Number.isInteger(n.htlcVout) || n.htlcVout !== r)
       throw new Error(
         `batch[${r}].htlcVout must equal ${r} (contiguous vout-ordered vector), got ${n.htlcVout}`
       );
@@ -1205,7 +1197,7 @@ function Tt(e) {
   if (O(e.offchainParamsVersion, "offchainParamsVersion"), O(e.appVaultKeepersVersion, "appVaultKeepersVersion"), O(
     e.universalChallengersVersion,
     "universalChallengersVersion"
-  ), Ke(
+  ), Ne(
     e.vaultCoreVersion,
     "VaultRefundData.vaultCoreVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
@@ -1248,7 +1240,7 @@ function Ct(e) {
     );
 }
 function St(e) {
-  const t = _e.fromHex(e);
+  const t = Re.fromHex(e);
   try {
     t.finalizeAllInputs();
   } catch (r) {
@@ -1258,7 +1250,7 @@ function St(e) {
   }
   return t.extractTransaction().toHex();
 }
-async function ar(e) {
+async function sr(e) {
   const {
     vaultId: t,
     readVault: r,
@@ -1268,7 +1260,7 @@ async function ar(e) {
     broadcastTx: o,
     signal: a
   } = e;
-  a == null || a.throwIfAborted(), L(t, "vaultId");
+  a == null || a.throwIfAborted(), U(t, "vaultId");
   const i = await r();
   Tt(i), a == null || a.throwIfAborted();
   const u = await n(i);
@@ -1284,34 +1276,34 @@ async function ar(e) {
       `Refund fee ${h} sats exceeds the per-vault safety cap of ${c} sats (${ee}/${te} of vault.amount=${i.amount}); refusing to sign refund.`
     );
   a == null || a.throwIfAborted();
-  const p = U(
+  const p = L(
     i.depositorBtcPubkey
-  ), d = f(i.unsignedPrePeginTxHex), g = Te(d);
+  ), d = m(i.unsignedPrePeginTxHex), g = Te(d);
   if (g !== void 0 && g.vout !== i.batch.length)
     throw new Error(
       `Auth-anchor OP_RETURN at vout ${g.vout} does not match batch size (${i.batch.length} HTLC outputs expect the anchor at vout ${i.batch.length}). Refund refused — sibling HTLC vector is incomplete.`
     );
   const b = g == null ? void 0 : g.hash;
-  let v;
+  let f;
   try {
-    v = A.fromHex(d);
+    f = A.fromHex(d);
   } catch (y) {
     throw new Error(
       `Failed to parse funded Pre-PegIn transaction hex: ${y instanceof Error ? y.message : String(y)}`
     );
   }
-  if (v.outs.length < i.batch.length)
+  if (f.outs.length < i.batch.length)
     throw new Error(
-      `Funded Pre-PegIn tx has ${v.outs.length} outputs but batch requires at least ${i.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
+      `Funded Pre-PegIn tx has ${f.outs.length} outputs but batch requires at least ${i.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
     );
-  const { psbtHex: m } = await Ve({
+  const { psbtHex: P } = await Ke({
     prePeginParams: {
       vaultCoreVersion: i.vaultCoreVersion,
       depositorPubkey: p,
-      vaultProviderPubkey: f(u.vaultProviderPubkey),
-      vaultKeeperPubkeys: u.vaultKeeperPubkeys.map(f),
-      universalChallengerPubkeys: u.universalChallengerPubkeys.map(f),
-      hashlocks: i.batch.map((y) => f(y.hashlock)),
+      vaultProviderPubkey: m(u.vaultProviderPubkey),
+      vaultKeeperPubkeys: u.vaultKeeperPubkeys.map(m),
+      universalChallengerPubkeys: u.universalChallengerPubkeys.map(m),
+      hashlocks: i.batch.map((y) => m(y.hashlock)),
       timelockRefund: u.timelockRefund,
       // `batch[i].amount` is the on-chain vault deposit (peg-in) amount, which
       // is exactly what WASM's `pegInAmounts` expects — it re-adds the protocol
@@ -1335,32 +1327,32 @@ async function ar(e) {
     // prefix" and flows into the WASM HTLC connector derivation; a prefixed
     // value would derive the wrong refund script leaf and yield an
     // unspendable PSBT. Match the `hashlocks` array handling above.
-    hashlock: f(i.hashlock)
+    hashlock: m(i.hashlock)
   });
   a == null || a.throwIfAborted();
   const w = M(
     i.depositorBtcPubkey,
     Et
-  ), P = await l(m, w);
+  ), v = await l(P, w);
   H({
-    requestedPsbtHex: m,
-    returnedPsbtHex: P
+    requestedPsbtHex: P,
+    returnedPsbtHex: v
   });
-  const S = 0, R = D(
-    P,
+  const S = 0, B = D(
+    v,
     p,
     S
   );
   F({
-    requestedPsbtHex: m,
-    signatureHex: R,
+    requestedPsbtHex: P,
+    signatureHex: B,
     signerXOnlyPubkeyHex: p,
     inputIndex: S
   });
-  const _ = St(P);
+  const R = St(v);
   a == null || a.throwIfAborted();
   try {
-    return await o(_);
+    return await o(R);
   } catch (y) {
     throw y instanceof Error && xt.test(y.message) ? new bt(t, y) : y;
   }
@@ -1374,23 +1366,23 @@ export {
   nr as F,
   or as G,
   bt as H,
-  ar as I,
-  sr as J,
+  sr as I,
+  ar as J,
   te as K,
   ee as L,
   Z as M,
   fe as N,
-  Me as P,
+  Ue as P,
   pe as R,
   Ft as a,
   Mt as b,
-  ae as c,
+  se as c,
   ie as d,
-  Lt as e,
+  Ut as e,
   Xt as f,
   qt as g,
   Qt as h,
-  Xe as i,
+  Ge as i,
   Jt as j,
   Yt as k,
   Wt as l,
@@ -1404,9 +1396,9 @@ export {
   tr as t,
   rr as u,
   jt as v,
-  Ut as w,
+  Lt as w,
   ue as x,
   Gt as y,
   V as z
 };
-//# sourceMappingURL=buildAndBroadcastRefund-C4LiPATK.js.map
+//# sourceMappingURL=buildAndBroadcastRefund-CpMDJ8up.js.map