@babylonlabs-io/ts-sdk 0.39.0 → 0.39.2

package/dist/{buildAndBroadcastRefund-B5cOyUzj.js → buildAndBroadcastRefund-CjWAle7m.js}

@@ -1,38 +1,38 @@
-var G = Object.defineProperty;
-var Q = (e, t, r) => t in e ? G(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var S = (e, t, r) => Q(e, typeof t != "symbol" ? t + "" : t, r);
-import { B as j } from "./BTCVaultRegistry.abi-Cq9-JlqT.js";
-import { e as q, v as W, s as h, u as N, p as k, d as Y, f as x } from "./bitcoin-B5aNKtsk.js";
-import { v as J, P as Z, f as ee } from "./PayoutManager-D29D-K-V.js";
-import { D as v, c as te, a as re, R as ne, d as O } from "./types-TOmEvvRy.js";
-import { Transaction as _, Psbt as oe } from "bitcoinjs-lib";
-import { c as se, d as ae, f as V, e as I } from "./assertPsbtUnsignedTxMatches-mTAnLhCz.js";
-import { c as ie, a as ue, b as le } from "./noPayout-qbaSEKGC.js";
-import { c as $ } from "./signing-DaLvGwQe.js";
-const ce = /^0x[0-9a-fA-F]{64}$/, de = /^0x[0-9a-fA-F]{40}$/, he = /^0x([0-9a-fA-F]{2})*$/;
-function A(e, t) {
+var W = Object.defineProperty;
+var Y = (e, t, r) => t in e ? W(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var A = (e, t, r) => Y(e, typeof t != "symbol" ? t + "" : t, r);
+import { B as J } from "./BTCVaultRegistry.abi-Cq9-JlqT.js";
+import { e as Z, v as ee, s as p, u as M, p as C, d as te, f as w } from "./bitcoin-B5aNKtsk.js";
+import { v as re, P as ne, f as oe } from "./PayoutManager-D29D-K-V.js";
+import { D as m, c as se, a as ae, R as ie, d as L } from "./types-BqGAMOZM.js";
+import { Transaction as _, Psbt as ue } from "bitcoinjs-lib";
+import { c as le, d as ce, f as I, e as N } from "./assertPsbtUnsignedTxMatches-mTAnLhCz.js";
+import { c as de, a as pe, b as he } from "./noPayout-qbaSEKGC.js";
+import { c as V } from "./signing-DaLvGwQe.js";
+const fe = /^0x[0-9a-fA-F]{64}$/, ge = /^0x[0-9a-fA-F]{40}$/, Pe = /^0x([0-9a-fA-F]{2})*$/;
+function B(e, t) {
   if (e.length !== 66)
     throw new Error(
       `${t} must be 32 bytes (66 hex chars with 0x prefix), got length ${e.length}`
     );
-  if (!ce.test(e))
+  if (!fe.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function pe(e, t) {
-  if (!de.test(e))
+function ye(e, t) {
+  if (!ge.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 (!Pe.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
 }
-async function tt(e) {
+async function at(e) {
   const {
     btcVaultRegistryAddress: t,
     vaultId: r,
@@ -41,27 +41,27 @@ async function tt(e) {
     writeContract: u,
     signal: a
   } = e;
-  a == null || a.throwIfAborted(), pe(t, "btcVaultRegistryAddress"), A(r, "vaultId");
-  const i = q(e.secret);
-  if (A(i, "secret"), n !== void 0 && (A(n, "hashlock"), !J(i, n)))
+  a == null || a.throwIfAborted(), ye(t, "btcVaultRegistryAddress"), B(r, "vaultId");
+  const i = Z(e.secret);
+  if (B(i, "secret"), n !== void 0 && (B(n, "hashlock"), !re(i, n)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
-  return fe(o, "activationMetadata"), u({
+  return me(o, "activationMetadata"), u({
     address: t,
-    abi: j,
+    abi: J,
     functionName: "activateVaultWithSecret",
     args: [r, i, o]
   });
 }
-const ge = 1e4;
-async function D(e) {
+const be = 1e4;
+async function F(e) {
   const {
     statusReader: t,
     peginTxid: r,
     targetStatuses: n,
     timeoutMs: o,
-    pollIntervalMs: u = ge,
+    pollIntervalMs: u = be,
     signal: a
   } = e, i = Date.now();
   for (; ; ) {
@@ -83,14 +83,14 @@ async function D(e) {
           `getPeginStatus returned status for pegin ${s.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
         );
       const l = s.status;
-      if (n.has(l) || l === v.ACTIVATED)
+      if (n.has(l) || l === m.ACTIVATED)
         return l;
-      if (l === v.EXPIRED || te.has(l))
+      if (l === m.EXPIRED || se.has(l))
         throw new Error(
           `Pegin ${r.slice(0, 8)}… reached terminal status "${l}" while waiting for ${[...n].join(", ")}`
         );
     } catch (s) {
-      if (!(s instanceof re && s.code === ne.PEGIN_NOT_FOUND))
+      if (!(s instanceof ae && s.code === ie.PEGIN_NOT_FOUND))
         throw s;
     }
     await new Promise((s, l) => {
@@ -107,29 +107,29 @@ async function D(e) {
     });
   }
 }
-const Pe = 300 * 1e3, ye = /* @__PURE__ */ new Set([
-  v.PENDING_DEPOSITOR_WOTS_PK,
-  ...O
+const ve = 300 * 1e3, we = /* @__PURE__ */ new Set([
+  m.PENDING_DEPOSITOR_WOTS_PK,
+  ...L
 ]);
-async function rt(e) {
+async function it(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
     peginTxid: n,
     depositorPk: o,
     wotsPublicKeys: u,
-    timeoutMs: a = Pe,
+    timeoutMs: a = ve,
     signal: i
   } = e;
   i == null || i.throwIfAborted();
-  const s = await D({
+  const s = await F({
     statusReader: t,
     peginTxid: n,
-    targetStatuses: ye,
+    targetStatuses: we,
     timeoutMs: a,
     signal: i
   });
-  O.has(s) || (i == null || i.throwIfAborted(), await r.submitDepositorWotsKey(
+  L.has(s) || (i == null || i.throwIfAborted(), await r.submitDepositorWotsKey(
     {
       pegin_txid: n,
       depositor_pk: o,
@@ -139,8 +139,8 @@ async function rt(e) {
   ));
 }
 const H = 1;
-function be(e, t) {
-  const r = h(t).toLowerCase(), o = e.map((u) => h(u).toLowerCase()).filter((u) => u !== r);
+function xe(e, t) {
+  const r = p(t).toLowerCase(), o = e.map((u) => p(u).toLowerCase()).filter((u) => u !== r);
   if (o.length === 0)
     throw new Error(
       "Cannot derive localChallengers: vault keeper set is empty (or contains only the depositor)"
@@ -151,16 +151,16 @@ function be(e, t) {
     );
   return o;
 }
-function me(e, t, r) {
+function Ee(e, t, r) {
   const n = r.map(
-    (c) => h(c).toLowerCase()
+    (c) => p(c).toLowerCase()
   ), o = t.filter((c) => n.includes(c));
   if (o.length > 0)
     throw new Error(
       `Cannot validate challenger set: vault keepers and universal challengers overlap (${o.join(", ")})`
     );
   const u = [...t, ...n], a = e.map(
-    (c) => h(c.challenger_pubkey).toLowerCase()
+    (c) => p(c.challenger_pubkey).toLowerCase()
   ), i = new Set(a);
   if (i.size !== a.length)
     throw new Error(
@@ -172,36 +172,36 @@ function me(e, t, r) {
       "Depositor graph challenger set does not match expected (local ∪ universal)" + (l.length > 0 ? ` (missing: ${l.join(", ")})` : "") + (d.length > 0 ? ` (unexpected: ${d.join(", ")})` : "")
     );
 }
-function ve(e, t) {
+function Te(e, t) {
   const r = e.ins[t];
-  return N(new Uint8Array(r.hash).slice().reverse());
+  return M(new Uint8Array(r.hash).slice().reverse());
 }
-function B(e, t, r, n, o) {
+function R(e, t, r, n, o) {
   const u = e.ins[t];
   if (u.index !== 0)
     throw new Error(
       `NoPayout (challenger ${o}) input ${t} expected to spend ${n} vout 0, got vout ${u.index}`
     );
-  const a = r.getId(), i = ve(e, t);
+  const a = r.getId(), i = Te(e, t);
   if (i !== a)
     throw new Error(
       `NoPayout (challenger ${o}) input ${t} does not reference ${n} (expected txid ${a}, got ${i})`
     );
 }
-async function we(e, t, r) {
-  const n = [], o = [], u = [], a = be(
+async function ke(e, t, r) {
+  const n = [], o = [], u = [], a = xe(
     r.vaultKeeperBtcPubkeys,
     r.depositorBtcPubkey
   );
-  me(
+  Ee(
     e.challenger_presign_data,
     a,
     r.universalChallengerBtcPubkeys
-  ), se(
+  ), le(
     e.payout_tx.tx_hex,
     r.registeredPayoutScriptPubKey
   );
-  const i = await ae({
+  const i = await ce({
     payoutTxHex: e.payout_tx.tx_hex,
     peginTxHex: r.peginTxHex,
     assertTxHex: e.assert_tx.tx_hex,
@@ -213,16 +213,16 @@ async function we(e, t, r) {
     network: r.network
   });
   n.push(i.psbtHex), o.push(
-    $(
+    V(
       t,
       H
     )
   );
-  const s = h(r.depositorBtcPubkey), l = _.fromHex(
-    h(e.assert_tx.tx_hex)
+  const s = p(r.depositorBtcPubkey), l = _.fromHex(
+    p(e.assert_tx.tx_hex)
   );
   for (const d of e.challenger_presign_data) {
-    const c = h(d.challenger_pubkey), g = n.length, P = await xe({
+    const c = p(d.challenger_pubkey), h = n.length, P = await _e({
       challenger: d,
       challengerPubkey: c,
       claimerPubkey: s,
@@ -231,18 +231,18 @@ async function we(e, t, r) {
       ctx: r
     });
     n.push(P), o.push(
-      $(
+      V(
         t,
         H
       )
     ), u.push({
       challengerPubkey: c,
-      noPayoutIdx: g
+      noPayoutIdx: h
     });
   }
   return { psbtHexes: n, signOptions: o, challengerEntries: u };
 }
-async function xe(e) {
+async function _e(e) {
   const {
     challenger: t,
     challengerPubkey: r,
@@ -251,35 +251,35 @@ async function xe(e) {
     assertTxParsed: u,
     ctx: a
   } = e;
-  ie(
+  de(
     t.nopayout_tx.tx_hex,
     r,
     a.network
   );
   const i = _.fromHex(
-    h(t.nopayout_tx.tx_hex)
+    p(t.nopayout_tx.tx_hex)
   ), s = _.fromHex(
-    h(t.challenge_assert_x_tx.tx_hex)
+    p(t.challenge_assert_x_tx.tx_hex)
   ), l = _.fromHex(
-    h(t.challenge_assert_y_tx.tx_hex)
+    p(t.challenge_assert_y_tx.tx_hex)
   );
   if (i.ins.length !== 3)
     throw new Error(
       `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${i.ins.length}`
     );
-  B(
+  R(
     i,
     0,
     u,
     "Assert",
     r
-  ), B(
+  ), R(
     i,
     1,
     s,
     "ChallengeAssertX",
     r
-  ), B(
+  ), R(
     i,
     2,
     l,
@@ -291,10 +291,10 @@ async function xe(e) {
     s.outs[0],
     l.outs[0]
   ].map((c) => ({
-    script_pubkey: N(new Uint8Array(c.script)),
+    script_pubkey: M(new Uint8Array(c.script)),
     value: c.value
   }));
-  return ue({
+  return pe({
     noPayoutTxHex: t.nopayout_tx.tx_hex,
     challengerPubkey: r,
     prevouts: d,
@@ -308,15 +308,15 @@ async function xe(e) {
     }
   });
 }
-function Te(e, t, r) {
-  V(e[0]);
-  const n = I(
+function Ce(e, t, r) {
+  I(e[0]);
+  const n = N(
     e[0].returnedPsbtHex,
     r
   ), o = {};
   for (const u of t)
-    V(e[u.noPayoutIdx]), o[u.challengerPubkey] = {
-      nopayout_signature: I(
+    I(e[u.noPayoutIdx]), o[u.challengerPubkey] = {
+      nopayout_signature: N(
         e[u.noPayoutIdx].returnedPsbtHex,
         r
       )
@@ -328,7 +328,7 @@ function Te(e, t, r) {
     per_challenger: o
   };
 }
-async function ke(e, t, r) {
+async function Se(e, t, r) {
   if (typeof e.signPsbts == "function")
     return e.signPsbts(t, r);
   const n = [];
@@ -336,15 +336,15 @@ async function ke(e, t, r) {
     n.push(await e.signPsbt(t[o], r == null ? void 0 : r[o]));
   return n;
 }
-async function Ee(e) {
-  const { depositorGraph: t, btcWallet: r, signingContext: n } = e, o = await r.getPublicKeyHex(), { depositorPubkey: u } = W(
+async function Ae(e) {
+  const { depositorGraph: t, btcWallet: r, signingContext: n } = e, o = await r.getPublicKeyHex(), { depositorPubkey: u } = ee(
     o,
-    h(n.depositorBtcPubkey)
-  ), { psbtHexes: a, signOptions: i, challengerEntries: s } = await we(
+    p(n.depositorBtcPubkey)
+  ), { psbtHexes: a, signOptions: i, challengerEntries: s } = await ke(
     t,
     o,
     n
-  ), l = await ke(
+  ), l = await Se(
     r,
     a,
     i
@@ -353,49 +353,78 @@ async function Ee(e) {
     throw new Error(
       `Wallet returned ${l.length} signed PSBTs, expected ${a.length}`
     );
-  const d = a.map((c, g) => ({
+  const d = a.map((c, h) => ({
     requestedPsbtHex: c,
-    returnedPsbtHex: l[g]
+    returnedPsbtHex: l[h]
   }));
-  return Te(
+  return Ce(
     d,
     s,
     u
   );
 }
-const _e = 1200 * 1e3, L = /* @__PURE__ */ new Set([
-  v.PENDING_ACKS,
-  v.PENDING_ACTIVATION,
-  v.ACTIVATED_PENDING_BROADCAST,
-  v.ACTIVATED
-]), Ce = /* @__PURE__ */ new Set([
-  v.PENDING_DEPOSITOR_SIGNATURES,
-  ...L
+const Be = 1200 * 1e3, X = /* @__PURE__ */ new Set([
+  m.PENDING_ACKS,
+  m.PENDING_ACTIVATION,
+  m.ACTIVATED_PENDING_BROADCAST,
+  m.ACTIVATED
+]), Re = /* @__PURE__ */ new Set([
+  m.PENDING_DEPOSITOR_SIGNATURES,
+  ...X
 ]);
-function Se(e) {
+function $e(e) {
   return e.map((t) => ({
-    claimerPubkeyXOnly: k(t.claimer_pubkey),
+    claimerPubkeyXOnly: C(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
     assertTxHex: t.assert_tx.tx_hex
   }));
 }
-function Ae(e, t) {
-  const r = h(e).toLowerCase(), n = h(
+function x(e) {
+  return C(e).toLowerCase();
+}
+function Ie(e, t, r, n) {
+  const o = x(n), u = [
+    x(t),
+    ...r.map(x)
+  ], a = new Set(u);
+  if (a.size !== u.length)
+    throw new Error(
+      "Cannot validate claimer set: signing context contains duplicate vault provider or vault keeper key"
+    );
+  if (a.has(o))
+    throw new Error(
+      "Cannot validate claimer set: depositor key overlaps with vault provider or vault keeper set"
+    );
+  const i = e.map(
+    (h) => x(h.claimer_pubkey)
+  );
+  if (new Set(i).size !== i.length)
+    throw new Error(
+      "Presign response contains duplicate claimer entries"
+    );
+  const s = i.filter((h) => h !== o), l = new Set(s), d = u.filter((h) => !l.has(h)), c = s.filter((h) => !a.has(h));
+  if (d.length > 0 || c.length > 0)
+    throw new Error(
+      "Presign response claimer set does not match expected (vault provider ∪ vault keepers)" + (d.length > 0 ? ` (missing: ${d.join(", ")})` : "") + (c.length > 0 ? ` (unexpected: ${c.join(", ")})` : "")
+    );
+}
+function Ve(e, t) {
+  const r = p(e).toLowerCase(), n = p(
     t.vaultProviderBtcPubkey
-  ).toLowerCase(), o = h(
+  ).toLowerCase(), o = p(
     t.depositorBtcPubkey
   ).toLowerCase();
   if (r === n || r === o)
     return t.registeredPayoutScriptPubKey;
   if (!t.vaultKeeperBtcPubkeys.some(
-    (a) => h(a).toLowerCase() === r
+    (a) => p(a).toLowerCase() === r
   ))
     throw new Error(
       `Unknown claimer pubkey ${r}: not VP, depositor, or a registered vault keeper`
     );
-  return Y(r);
+  return te(r);
 }
-function K(e, t) {
+function O(e, t) {
   return {
     payoutTxHex: e.payoutTxHex,
     peginTxHex: t.peginTxHex,
@@ -405,14 +434,14 @@ function K(e, t) {
     universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys,
     depositorBtcPubkey: t.depositorBtcPubkey,
     timelockPegin: t.timelockPegin,
-    registeredPayoutScriptPubKey: Ae(
+    registeredPayoutScriptPubKey: Ve(
       e.claimerPubkeyXOnly,
       t
     )
   };
 }
-async function Be(e, t, r, n) {
-  const o = new Z({
+async function Ne(e, t, r, n) {
+  const o = new ne({
     network: t.network,
     btcWallet: e
   }), u = r.length;
@@ -420,14 +449,14 @@ async function Be(e, t, r, n) {
   let a;
   if (o.supportsBatchSigning())
     a = (await o.signPayoutTransactionsBatch(
-      r.map((l) => K(l, t))
+      r.map((l) => O(l, t))
     )).map((l) => l.payoutSignature);
   else {
     a = [];
     for (let s = 0; s < r.length; s++) {
       n == null || n(s, u);
       const l = await o.signPayoutTransaction(
-        K(r[s], t)
+        O(r[s], t)
       );
       a.push(l.signature);
     }
@@ -439,7 +468,7 @@ async function Be(e, t, r, n) {
     };
   return n == null || n(u, u), i;
 }
-async function nt(e) {
+async function ut(e) {
   const {
     statusReader: t,
     presignClient: r,
@@ -447,17 +476,17 @@ async function nt(e) {
     peginTxid: o,
     depositorPk: u,
     signingContext: a,
-    timeoutMs: i = _e,
+    timeoutMs: i = Be,
     signal: s,
     onProgress: l
-  } = e, d = await D({
+  } = e, d = await F({
     statusReader: t,
     peginTxid: o,
-    targetStatuses: Ce,
+    targetStatuses: Re,
     timeoutMs: i,
     signal: s
   });
-  if (L.has(d))
+  if (X.has(d))
     return;
   s == null || s.throwIfAborted();
   const c = await r.requestDepositorPresignTransactions(
@@ -468,16 +497,23 @@ async function nt(e) {
     s
   );
   s == null || s.throwIfAborted();
-  const g = k(u), P = c.txs.filter(
-    (b) => k(b.claimer_pubkey) !== g
-  ), p = Se(P), y = await Be(
+  const h = x(u);
+  Ie(
+    c.txs,
+    a.vaultProviderBtcPubkey,
+    a.vaultKeeperBtcPubkeys,
+    u
+  );
+  const P = c.txs.filter(
+    (v) => x(v.claimer_pubkey) !== h
+  ), b = $e(P), g = await Ne(
     n,
     a,
-    p,
+    b,
     l
   );
   s == null || s.throwIfAborted();
-  const T = await Ee({
+  const E = await Ae({
     depositorGraph: c.depositor_graph,
     btcWallet: n,
     signingContext: {
@@ -495,21 +531,21 @@ async function nt(e) {
     }
   });
   s == null || s.throwIfAborted();
-  const w = { ...y };
-  w[h(u)] = T.payout_signatures, await r.submitDepositorPresignatures(
+  const y = { ...g };
+  y[p(u)] = E.payout_signatures, await r.submitDepositorPresignatures(
     {
       pegin_txid: o,
       depositor_pk: u,
-      signatures: w,
-      depositor_claimer_presignatures: T
+      signatures: y,
+      depositor_claimer_presignatures: E
     },
     s
   );
 }
-function Re(e) {
+function He(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function ot(e) {
+function lt(e) {
   const {
     amountSats: t,
     minDeposit: r,
@@ -520,29 +556,29 @@ function ot(e) {
   } = e;
   return !(t <= 0n || t < r || n && n > 0n && t > n || u == null || a == null || t + u + a > o);
 }
-function st(e, t, r) {
+function ct(e, t, r) {
   return e <= 0n ? {
     valid: !1,
     error: "Deposit amount must be greater than zero"
   } : e < t ? {
     valid: !1,
-    error: `Minimum deposit is ${x(t)} BTC`
+    error: `Minimum deposit is ${w(t)} BTC`
   } : r && r > 0n && e > r ? {
     valid: !1,
-    error: `Maximum deposit is ${x(r)} BTC`
+    error: `Maximum deposit is ${w(r)} BTC`
   } : { valid: !0 };
 }
-function at(e) {
+function dt(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 (${x(r)} BTC)`
+    error: `Vault size exceeds remaining capacity (${w(r)} BTC)`
   } : { valid: !0 };
 }
-function it(e, t) {
+function pt(e, t) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -558,7 +594,7 @@ function it(e, t) {
     error: "Invalid vault provider selected"
   } : { valid: !0 };
 }
-function Ve(e, t, r) {
+function Oe(e, t, r) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -574,40 +610,40 @@ function Ve(e, t, r) {
     if (t && o < t)
       return {
         valid: !1,
-        error: `Vault ${n + 1} amount ${x(o)} BTC is below minimum deposit ${x(t)} BTC`
+        error: `Vault ${n + 1} amount ${w(o)} BTC is below minimum deposit ${w(t)} BTC`
       };
     if (r && o > r)
       return {
         valid: !1,
-        error: `Vault ${n + 1} amount ${x(o)} BTC exceeds maximum deposit ${x(r)} BTC`
+        error: `Vault ${n + 1} amount ${w(o)} BTC exceeds maximum deposit ${w(r)} BTC`
       };
   }
   return { valid: !0 };
 }
-function $e(e) {
-  const t = h(e);
-  return Re(t) ? { valid: !0 } : {
+function Ke(e) {
+  const t = p(e);
+  return He(t) ? { valid: !0 } : {
     valid: !1,
     error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
   };
 }
-function Ie(e) {
+function De(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 He(e) {
+function Ue(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 Ke(e) {
+function Me(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function ut(e) {
+function ht(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
@@ -616,19 +652,19 @@ function ut(e) {
     universalChallengerBtcPubkeys: u,
     minDeposit: a,
     maxDeposit: i
-  } = e, s = Ve(
+  } = e, s = Oe(
     t,
     a,
     i
   );
   if (!s.valid)
     throw new Error(s.error);
-  const l = $e(n);
+  const l = Ke(n);
   if (!l.valid)
     throw new Error(l.error);
-  Ie(o), He(u), Ke(r);
+  De(o), Ue(u), Me(r);
 }
-async function lt(e) {
+async function ft(e) {
   const {
     vaultRegistryReader: t,
     vaultKeeperReader: r,
@@ -646,7 +682,7 @@ async function lt(e) {
     t.getVaultProviderBtcPubKey(o),
     r.getCurrentVaultKeepersVersion(u),
     n.getLatestUniversalChallengersVersion()
-  ]), [g, P] = await Promise.all([
+  ]), [h, P] = await Promise.all([
     r.getVaultKeepersByVersion(
       u,
       d
@@ -654,42 +690,42 @@ async function lt(e) {
     n.getUniversalChallengersByVersion(
       c
     )
-  ]), p = (f) => k(f).toLowerCase(), y = (f) => f.map(p).sort();
-  if (p(a) !== l)
+  ]), b = (f) => C(f).toLowerCase(), g = (f) => f.map(b).sort();
+  if (b(a) !== l)
     throw new Error(
       `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${o}. Refresh and try again.`
     );
-  const w = y(i), b = y(
-    g.map((f) => f.btcPubKey)
+  const y = g(i), v = g(
+    h.map((f) => f.btcPubKey)
   );
-  if (w.length !== b.length || w.some((f, C) => f !== b[C]))
+  if (y.length !== v.length || y.some((f, S) => f !== v[S]))
     throw new Error(
       `Vault keeper BTC pubkeys (v${d}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
     );
-  const E = y(s), m = y(
+  const T = g(s), k = g(
     P.map((f) => f.btcPubKey)
   );
-  if (E.length !== m.length || E.some((f, C) => f !== m[C]))
+  if (T.length !== k.length || T.some((f, S) => f !== k[S]))
     throw new Error(
       `Universal challenger BTC pubkeys (v${c}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
     );
   return {
     vaultProviderBtcPubkeyXOnly: l,
-    vaultKeeperBtcPubkeysSorted: b,
-    universalChallengerBtcPubkeysSorted: m,
+    vaultKeeperBtcPubkeysSorted: v,
+    universalChallengerBtcPubkeysSorted: k,
     expectedAppVaultKeepersVersion: d,
     expectedUniversalChallengersVersion: c
   };
 }
-class U extends Error {
+class z extends Error {
   constructor(t) {
     super(t), this.name = "RegisteredVaultVersionMismatchError";
   }
 }
-function ct(e) {
-  return e instanceof U || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
+function gt(e) {
+  return e instanceof z || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function dt(e) {
+async function Pt(e) {
   const {
     vaultRegistryReader: t,
     vaultIds: r,
@@ -707,78 +743,78 @@ async function dt(e) {
       `vault ${d}: universalChallengers expected v${u}, got v${s.universalChallengersVersion}`
     );
   }), i.length > 0)
-    throw new U(
+    throw new z(
       `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${i.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-var M = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(M || {});
-const Ne = /* @__PURE__ */ new Set([
+var G = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(G || {});
+const Le = /* @__PURE__ */ new Set([
   "PayoutBroadcast",
   "PayoutBlocked"
   /* PAYOUT_BLOCKED */
 ]);
-function ht(e) {
-  return Object.values(M).includes(
+function yt(e) {
+  return Object.values(G).includes(
     e
   );
 }
-function pt(e) {
-  return !!e && Ne.has(e);
+function mt(e) {
+  return !!e && Le.has(e);
 }
-class Oe extends Error {
+class Fe extends Error {
   constructor(r, n) {
     super(`Refund not yet mature (BIP68 not final): ${n.message}`);
-    S(this, "vaultId");
-    S(this, "cause");
+    A(this, "vaultId");
+    A(this, "cause");
     this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = n;
   }
 }
-const De = /^0x[0-9a-fA-F]{64}$/, Le = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, F = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, X = 160;
-function ft(e) {
+const Xe = /^0x[0-9a-fA-F]{64}$/, ze = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, j = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, q = 160, K = 2e3, D = 10n, U = 100n;
+function bt(e) {
   if (!Number.isFinite(e) || e <= 0)
     throw new Error(
       `feeRateSatsVb must be a positive finite number, got ${e}`
     );
-  return BigInt(Math.ceil(e * X));
+  return BigInt(Math.ceil(e * q));
 }
-const Ue = 1, Me = /non-BIP68-final/i;
-function z(e, t) {
+const Ge = 1, je = /non-BIP68-final/i;
+function Q(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 (!De.test(e))
+  if (!Xe.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function R(e, t) {
+function $(e, t) {
   if (!Number.isInteger(e) || e < 0)
     throw new Error(`${t} must be a non-negative integer, got ${e}`);
 }
-function Fe(e) {
-  if (z(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout !== 0)
+function qe(e) {
+  if (Q(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout !== 0)
     throw new Error(
       `Multi-vault Pre-PegIn refund is not supported by this SDK call (htlcVout=${e.htlcVout}, expected 0). Refund of batched-deposit vaults requires reconstructing all sibling HTLCs.`
     );
-  if (R(e.offchainParamsVersion, "offchainParamsVersion"), R(e.appVaultKeepersVersion, "appVaultKeepersVersion"), R(
+  if ($(e.offchainParamsVersion, "offchainParamsVersion"), $(e.appVaultKeepersVersion, "appVaultKeepersVersion"), $(
     e.universalChallengersVersion,
     "universalChallengersVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
     throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!Le.test(e.unsignedPrePeginTxHex))
+  if (!ze.test(e.unsignedPrePeginTxHex))
     throw new Error(
       "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
     );
-  if (!e.depositorBtcPubkey || !F.test(e.depositorBtcPubkey))
+  if (!e.depositorBtcPubkey || !j.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 Xe(e) {
-  if (!e.vaultProviderPubkey || !F.test(e.vaultProviderPubkey))
+function Qe(e) {
+  if (!e.vaultProviderPubkey || !j.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");
@@ -799,8 +835,8 @@ function Xe(e) {
       `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
     );
 }
-function ze(e) {
-  const t = oe.fromHex(e);
+function We(e) {
+  const t = ue.fromHex(e);
   try {
     t.finalizeAllInputs();
   } catch (r) {
@@ -810,7 +846,7 @@ function ze(e) {
   }
   return t.extractTransaction().toHex();
 }
-async function gt(e) {
+async function vt(e) {
   const {
     vaultId: t,
     readVault: r,
@@ -820,28 +856,36 @@ async function gt(e) {
     broadcastTx: a,
     signal: i
   } = e;
-  i == null || i.throwIfAborted(), z(t, "vaultId");
+  i == null || i.throwIfAborted(), Q(t, "vaultId");
   const s = await r();
-  Fe(s), i == null || i.throwIfAborted();
+  qe(s), i == null || i.throwIfAborted();
   const l = await n(s);
-  if (Xe(l), i == null || i.throwIfAborted(), !Number.isFinite(o) || o <= 0)
+  if (Qe(l), i == null || i.throwIfAborted(), !Number.isFinite(o) || o <= 0)
     throw new Error(`feeRate must be a positive number, got ${o}`);
-  const d = BigInt(Math.ceil(o * X));
+  if (o > K)
+    throw new Error(
+      `feeRate ${o} sat/vB exceeds refund safety cap ${K} sat/vB; refusing to sign refund.`
+    );
+  const d = BigInt(Math.ceil(o * q)), c = s.amount * D / U;
+  if (d > c)
+    throw new Error(
+      `Refund fee ${d} sats exceeds the per-vault safety cap of ${c} sats (${D}/${U} of vault.amount=${s.amount}); refusing to sign refund.`
+    );
   i == null || i.throwIfAborted();
-  const c = k(
+  const h = C(
     s.depositorBtcPubkey
-  ), g = h(s.unsignedPrePeginTxHex), P = 1, p = ee(g);
-  if (p !== void 0 && p.vout !== P)
+  ), P = p(s.unsignedPrePeginTxHex), b = 1, g = oe(P);
+  if (g !== void 0 && g.vout !== b)
     throw new Error(
-      `Multi-vault Pre-PegIn refund is not supported by this SDK call (auth-anchor OP_RETURN at vout ${p.vout}; single-vault refund expects vout ${P}). Refund of batched-deposit vaults requires reconstructing all sibling HTLCs.`
+      `Multi-vault Pre-PegIn refund is not supported by this SDK call (auth-anchor OP_RETURN at vout ${g.vout}; single-vault refund expects vout ${b}). Refund of batched-deposit vaults requires reconstructing all sibling HTLCs.`
     );
-  const y = p == null ? void 0 : p.hash, { psbtHex: T } = await le({
+  const E = g == null ? void 0 : g.hash, { psbtHex: y } = await he({
     prePeginParams: {
-      depositorPubkey: c,
-      vaultProviderPubkey: h(l.vaultProviderPubkey),
-      vaultKeeperPubkeys: l.vaultKeeperPubkeys.map(h),
-      universalChallengerPubkeys: l.universalChallengerPubkeys.map(h),
-      hashlocks: [h(s.hashlock)],
+      depositorPubkey: h,
+      vaultProviderPubkey: p(l.vaultProviderPubkey),
+      vaultKeeperPubkeys: l.vaultKeeperPubkeys.map(p),
+      universalChallengerPubkeys: l.universalChallengerPubkeys.map(p),
+      hashlocks: [p(s.hashlock)],
       timelockRefund: l.timelockRefund,
       pegInAmounts: [s.amount],
       feeRate: l.feeRate,
@@ -849,57 +893,60 @@ async function gt(e) {
       councilQuorum: l.councilQuorum,
       councilSize: l.councilSize,
       network: l.network,
-      authAnchorHash: y
+      authAnchorHash: E
     },
-    fundedPrePeginTxHex: g,
+    fundedPrePeginTxHex: P,
     htlcVout: s.htlcVout,
     refundFee: d,
     // 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: h(s.hashlock)
+    hashlock: p(s.hashlock)
   });
   i == null || i.throwIfAborted();
-  const w = $(
+  const v = V(
     s.depositorBtcPubkey,
-    Ue
-  ), b = await u(T, w);
-  V({
-    requestedPsbtHex: T,
-    returnedPsbtHex: b
+    Ge
+  ), T = await u(y, v);
+  I({
+    requestedPsbtHex: y,
+    returnedPsbtHex: T
   });
-  const E = ze(b);
+  const k = We(T);
   i == null || i.throwIfAborted();
   try {
-    return await a(E);
-  } catch (m) {
-    throw m instanceof Error && Me.test(m.message) ? new Oe(t, m) : m;
+    return await a(k);
+  } catch (f) {
+    throw f instanceof Error && je.test(f.message) ? new Fe(t, f) : f;
   }
 }
 export {
-  Oe as B,
-  M as C,
-  U as R,
-  tt as a,
-  Ee as b,
-  at as c,
-  it as d,
-  Ve as e,
-  $e as f,
-  ut as g,
-  lt as h,
-  ot as i,
-  ct as j,
-  dt as k,
-  ht as l,
-  pt as m,
-  gt as n,
-  ft as o,
-  X as p,
-  nt as r,
-  rt as s,
-  st as v,
-  D as w
+  Fe as B,
+  G as C,
+  z as R,
+  at as a,
+  Ae as b,
+  dt as c,
+  pt as d,
+  Oe as e,
+  Ke as f,
+  ht as g,
+  ft as h,
+  lt as i,
+  gt as j,
+  Pt as k,
+  yt as l,
+  mt as m,
+  vt as n,
+  bt as o,
+  U as p,
+  D as q,
+  ut as r,
+  it as s,
+  K as t,
+  q as u,
+  ct as v,
+  F as w
 };
-//# sourceMappingURL=buildAndBroadcastRefund-B5cOyUzj.js.map
+//# sourceMappingURL=buildAndBroadcastRefund-CjWAle7m.js.map