@babylonlabs-io/ts-sdk 0.39.3 → 0.40.0

package/dist/{buildAndBroadcastRefund-BRMB7XyC.js → buildAndBroadcastRefund-fIHDHiFh.js}

@@ -1,33 +1,33 @@
 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 C = (e, t, r) => Y(e, typeof t != "symbol" ? t + "" : 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 S, f as w } from "./bitcoin-B5aNKtsk.js";
-import { v as te, P as re, f as ne } from "./PayoutManager-2XpjdLxE.js";
-import { D as y, c as oe, a as se, R as ae, d as L } from "./types-BqGAMOZM.js";
+import { e as Z, v as ee, s as p, u as U, p as C, f as v } from "./bitcoin-B5aNKtsk.js";
+import { v as te, P as re, f as ne } from "./PayoutManager-DChODEOJ.js";
+import { D as y, c as oe, a as ae, R as se, d as L } from "./types-BqGAMOZM.js";
 import { Transaction as _, Psbt as ie } from "bitcoinjs-lib";
-import { c as ue, d as I, e as N } from "./assertPsbtUnsignedTxMatches-CsawQGjC.js";
-import { c as le, a as ce, b as de } from "./noPayout-C5b34rs1.js";
-import { c as V } from "./signing-DaLvGwQe.js";
-const pe = /^0x[0-9a-fA-F]{64}$/, he = /^0x[0-9a-fA-F]{40}$/, fe = /^0x([0-9a-fA-F]{2})*$/;
-function B(e, t) {
+import { c as ue, d as V, e as H } from "./assertPsbtUnsignedTxMatches-CzVv57QF.js";
+import { c as le, a as ce, b as he } from "./noPayout-CS2wnluA.js";
+import { c as I } from "./signing-DaLvGwQe.js";
+const de = /^0x[0-9a-fA-F]{64}$/, pe = /^0x[0-9a-fA-F]{40}$/, ge = /^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 (!pe.test(e))
+  if (!de.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function ge(e, t) {
-  if (!he.test(e))
+function fe(e, t) {
+  if (!pe.test(e))
     throw new Error(
       `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
     );
 }
-function Pe(e, t) {
-  if (!fe.test(e))
+function me(e, t) {
+  if (!ge.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
@@ -37,46 +37,46 @@ async function ot(e) {
     btcVaultRegistryAddress: t,
     vaultId: r,
     hashlock: n,
-    activationMetadata: s,
+    activationMetadata: a,
     writeContract: u,
-    signal: a
+    signal: s
   } = e;
-  a == null || a.throwIfAborted(), ge(t, "btcVaultRegistryAddress"), B(r, "vaultId");
+  s == null || s.throwIfAborted(), fe(t, "btcVaultRegistryAddress"), $(r, "vaultId");
   const i = Z(e.secret);
-  if (B(i, "secret"), n !== void 0 && (B(n, "hashlock"), !te(i, n)))
+  if ($(i, "secret"), n !== void 0 && ($(n, "hashlock"), !te(i, n)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
-  return Pe(s, "activationMetadata"), u({
+  return me(a, "activationMetadata"), u({
     address: t,
     abi: J,
     functionName: "activateVaultWithSecret",
-    args: [r, i, s]
+    args: [r, i, a]
   });
 }
-const me = 1e4;
-async function F(e) {
+const Pe = 1e4;
+async function X(e) {
   const {
     statusReader: t,
     peginTxid: r,
     targetStatuses: n,
-    timeoutMs: s,
-    pollIntervalMs: u = me,
-    signal: a
+    timeoutMs: a,
+    pollIntervalMs: u = Pe,
+    signal: s
   } = e, i = Date.now();
   for (; ; ) {
-    if (a != null && a.aborted)
+    if (s != null && s.aborted)
       throw new Error(
         `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
       );
-    if (Date.now() - i >= s)
+    if (Date.now() - i >= a)
       throw new Error(
-        `Polling timeout after ${s}ms for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
+        `Polling timeout after ${a}ms for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
       );
     try {
       const o = await t.getPeginStatus(
         { pegin_txid: r },
-        a
+        s
       );
       if (o.pegin_txid.toLowerCase() !== r.toLowerCase())
         throw new Error(
@@ -90,112 +90,112 @@ async function F(e) {
           `Pegin ${r.slice(0, 8)}… reached terminal status "${l}" while waiting for ${[...n].join(", ")}`
         );
     } catch (o) {
-      if (!(o instanceof se && o.code === ae.PEGIN_NOT_FOUND))
+      if (!(o instanceof ae && o.code === se.PEGIN_NOT_FOUND))
         throw o;
     }
     await new Promise((o, l) => {
-      const d = () => {
+      const h = () => {
         clearTimeout(c), l(
           new Error(
             `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
           )
         );
       }, c = setTimeout(() => {
-        a == null || a.removeEventListener("abort", d), o();
+        s == null || s.removeEventListener("abort", h), o();
       }, u);
-      a == null || a.addEventListener("abort", d, { once: !0 });
+      s == null || s.addEventListener("abort", h, { once: !0 });
     });
   }
 }
-const ye = 300 * 1e3, be = /* @__PURE__ */ new Set([
+const be = 300 * 1e3, ye = /* @__PURE__ */ new Set([
   y.PENDING_DEPOSITOR_WOTS_PK,
   ...L
 ]);
-async function st(e) {
+async function at(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
     peginTxid: n,
-    depositorPk: s,
+    depositorPk: a,
     wotsPublicKeys: u,
-    timeoutMs: a = ye,
+    timeoutMs: s = be,
     signal: i
   } = e;
   i == null || i.throwIfAborted();
-  const o = await F({
+  const o = await X({
     statusReader: t,
     peginTxid: n,
-    targetStatuses: be,
-    timeoutMs: a,
+    targetStatuses: ye,
+    timeoutMs: s,
     signal: i
   });
   L.has(o) || (i == null || i.throwIfAborted(), await r.submitDepositorWotsKey(
     {
       pegin_txid: n,
-      depositor_pk: s,
+      depositor_pk: a,
       wots_public_keys: u
     },
     i
   ));
 }
-const O = 1, ve = 1;
-function we(e, t) {
-  const r = p(t).toLowerCase(), s = e.map((u) => p(u).toLowerCase()).filter((u) => u !== r);
-  if (s.length === 0)
+const O = 1, we = 1;
+function xe(e, t) {
+  const r = p(t).toLowerCase(), a = e.map((u) => p(u).toLowerCase()).filter((u) => u !== r);
+  if (a.length === 0)
     throw new Error(
       "Cannot derive localChallengers: vault keeper set is empty (or contains only the depositor)"
     );
-  if (new Set(s).size !== s.length)
+  if (new Set(a).size !== a.length)
     throw new Error(
       "Cannot derive localChallengers: duplicate vaultKeeper key — signing context is misconfigured"
     );
-  return s;
+  return a;
 }
-function xe(e, t, r) {
+function ve(e, t, r) {
   const n = r.map(
     (c) => p(c).toLowerCase()
-  ), s = t.filter((c) => n.includes(c));
-  if (s.length > 0)
+  ), a = t.filter((c) => n.includes(c));
+  if (a.length > 0)
     throw new Error(
-      `Cannot validate challenger set: vault keepers and universal challengers overlap (${s.join(", ")})`
+      `Cannot validate challenger set: vault keepers and universal challengers overlap (${a.join(", ")})`
     );
-  const u = [...t, ...n], a = e.map(
+  const u = [...t, ...n], s = e.map(
     (c) => p(c.challenger_pubkey).toLowerCase()
-  ), i = new Set(a);
-  if (i.size !== a.length)
+  ), i = new Set(s);
+  if (i.size !== s.length)
     throw new Error(
       "Depositor graph contains duplicate challenger entries in challenger_presign_data"
     );
-  const o = new Set(u), l = u.filter((c) => !i.has(c)), d = a.filter((c) => !o.has(c));
-  if (l.length > 0 || d.length > 0)
+  const o = new Set(u), l = u.filter((c) => !i.has(c)), h = s.filter((c) => !o.has(c));
+  if (l.length > 0 || h.length > 0)
     throw new Error(
-      "Depositor graph challenger set does not match expected (local ∪ universal)" + (l.length > 0 ? ` (missing: ${l.join(", ")})` : "") + (d.length > 0 ? ` (unexpected: ${d.join(", ")})` : "")
+      "Depositor graph challenger set does not match expected (local ∪ universal)" + (l.length > 0 ? ` (missing: ${l.join(", ")})` : "") + (h.length > 0 ? ` (unexpected: ${h.join(", ")})` : "")
     );
 }
 function Ee(e, t) {
   const r = e.ins[t];
-  return M(new Uint8Array(r.hash).slice().reverse());
+  return U(new Uint8Array(r.hash).slice().reverse());
 }
-function R(e, t, r, n, s) {
+function B(e, t, r, n, a) {
   const u = e.ins[t];
   if (u.index !== 0)
     throw new Error(
-      `NoPayout (challenger ${s}) input ${t} expected to spend ${n} vout 0, got vout ${u.index}`
+      `NoPayout (challenger ${a}) input ${t} expected to spend ${n} vout 0, got vout ${u.index}`
     );
-  const a = r.getId(), i = Ee(e, t);
-  if (i !== a)
+  const s = r.getId(), i = Ee(e, t);
+  if (i !== s)
     throw new Error(
-      `NoPayout (challenger ${s}) input ${t} does not reference ${n} (expected txid ${a}, got ${i})`
+      `NoPayout (challenger ${a}) input ${t} does not reference ${n} (expected txid ${s}, got ${i})`
     );
 }
 async function Te(e, t, r) {
-  const n = [], s = [], u = [], a = we(
+  const n = [], a = [], u = [], s = xe(
     r.vaultKeeperBtcPubkeys,
     r.depositorBtcPubkey
   );
-  xe(
+  ve(
     e.challenger_presign_data,
-    a,
+    s,
     r.universalChallengerBtcPubkeys
   );
   const i = await ue({
@@ -210,10 +210,10 @@ async function Te(e, t, r) {
     network: r.network,
     claimerBtcPubkey: r.depositorBtcPubkey,
     registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
-    commissionBps: ve
+    commissionBps: we
   });
-  n.push(i.psbtHex), s.push(
-    V(
+  n.push(i.psbtHex), a.push(
+    I(
       t,
       O
     )
@@ -221,40 +221,40 @@ async function Te(e, t, r) {
   const o = p(r.depositorBtcPubkey), l = _.fromHex(
     p(e.assert_tx.tx_hex)
   );
-  for (const d of e.challenger_presign_data) {
-    const c = p(d.challenger_pubkey), h = n.length, P = await ke({
-      challenger: d,
+  for (const h of e.challenger_presign_data) {
+    const c = p(h.challenger_pubkey), g = n.length, m = await ke({
+      challenger: h,
       challengerPubkey: c,
       claimerPubkey: o,
-      localChallengers: a,
+      localChallengers: s,
       assertTxParsed: l,
       ctx: r
     });
-    n.push(P), s.push(
-      V(
+    n.push(m), a.push(
+      I(
         t,
         O
       )
     ), u.push({
       challengerPubkey: c,
-      noPayoutIdx: h
+      noPayoutIdx: g
     });
   }
-  return { psbtHexes: n, signOptions: s, challengerEntries: u };
+  return { psbtHexes: n, signOptions: a, challengerEntries: u };
 }
 async function ke(e) {
   const {
     challenger: t,
     challengerPubkey: r,
     claimerPubkey: n,
-    localChallengers: s,
+    localChallengers: a,
     assertTxParsed: u,
-    ctx: a
+    ctx: s
   } = e;
   le(
     t.nopayout_tx.tx_hex,
     r,
-    a.network
+    s.network
   );
   const i = _.fromHex(
     p(t.nopayout_tx.tx_hex)
@@ -267,56 +267,56 @@ async function ke(e) {
     throw new Error(
       `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${i.ins.length}`
     );
-  R(
+  B(
     i,
     0,
     u,
     "Assert",
     r
-  ), R(
+  ), B(
     i,
     1,
     o,
     "ChallengeAssertX",
     r
-  ), R(
+  ), B(
     i,
     2,
     l,
     "ChallengeAssertY",
     r
   );
-  const d = [
+  const h = [
     u.outs[0],
     o.outs[0],
     l.outs[0]
   ].map((c) => ({
-    script_pubkey: M(new Uint8Array(c.script)),
+    script_pubkey: U(new Uint8Array(c.script)),
     value: c.value
   }));
   return ce({
     noPayoutTxHex: t.nopayout_tx.tx_hex,
     challengerPubkey: r,
-    prevouts: d,
+    prevouts: h,
     connectorParams: {
       claimer: n,
-      localChallengers: s,
-      universalChallengers: a.universalChallengerBtcPubkeys,
-      timelockAssert: a.timelockAssert,
-      councilMembers: a.councilMembers,
-      councilQuorum: a.councilQuorum
+      localChallengers: a,
+      universalChallengers: s.universalChallengerBtcPubkeys,
+      timelockAssert: s.timelockAssert,
+      councilMembers: s.councilMembers,
+      councilQuorum: s.councilQuorum
     }
   });
 }
 function _e(e, t, r) {
-  I(e[0]);
-  const n = N(
+  V(e[0]);
+  const n = H(
     e[0].returnedPsbtHex,
     r
-  ), s = {};
+  ), a = {};
   for (const u of t)
-    I(e[u.noPayoutIdx]), s[u.challengerPubkey] = {
-      nopayout_signature: N(
+    V(e[u.noPayoutIdx]), a[u.challengerPubkey] = {
+      nopayout_signature: H(
         e[u.noPayoutIdx].returnedPsbtHex,
         r
       )
@@ -325,90 +325,90 @@ function _e(e, t, r) {
     payout_signatures: {
       payout_signature: n
     },
-    per_challenger: s
+    per_challenger: a
   };
 }
-async function Se(e, t, r) {
+async function Ce(e, t, r) {
   if (typeof e.signPsbts == "function")
     return e.signPsbts(t, r);
   const n = [];
-  for (let s = 0; s < t.length; s++)
-    n.push(await e.signPsbt(t[s], r == null ? void 0 : r[s]));
+  for (let a = 0; a < t.length; a++)
+    n.push(await e.signPsbt(t[a], r == null ? void 0 : r[a]));
   return n;
 }
-async function Ae(e) {
-  const { depositorGraph: t, btcWallet: r, signingContext: n } = e, s = await r.getPublicKeyHex(), { depositorPubkey: u } = ee(
-    s,
+async function Se(e) {
+  const { depositorGraph: t, btcWallet: r, signingContext: n } = e, a = await r.getPublicKeyHex(), { depositorPubkey: u } = ee(
+    a,
     p(n.depositorBtcPubkey)
-  ), { psbtHexes: a, signOptions: i, challengerEntries: o } = await Te(
+  ), { psbtHexes: s, signOptions: i, challengerEntries: o } = await Te(
     t,
-    s,
+    a,
     n
-  ), l = await Se(
+  ), l = await Ce(
     r,
-    a,
+    s,
     i
   );
-  if (l.length !== a.length)
+  if (l.length !== s.length)
     throw new Error(
-      `Wallet returned ${l.length} signed PSBTs, expected ${a.length}`
+      `Wallet returned ${l.length} signed PSBTs, expected ${s.length}`
     );
-  const d = a.map((c, h) => ({
+  const h = s.map((c, g) => ({
     requestedPsbtHex: c,
-    returnedPsbtHex: l[h]
+    returnedPsbtHex: l[g]
   }));
   return _e(
-    d,
+    h,
     o,
     u
   );
 }
-const Ce = 1200 * 1e3, X = /* @__PURE__ */ new Set([
+const Ae = 1200 * 1e3, z = /* @__PURE__ */ new Set([
   y.PENDING_ACKS,
   y.PENDING_ACTIVATION,
   y.ACTIVATED_PENDING_BROADCAST,
   y.ACTIVATED
-]), Be = /* @__PURE__ */ new Set([
+]), $e = /* @__PURE__ */ new Set([
   y.PENDING_DEPOSITOR_SIGNATURES,
-  ...X
+  ...z
 ]);
-function Re(e) {
+function Be(e) {
   return e.map((t) => ({
-    claimerPubkeyXOnly: S(t.claimer_pubkey),
+    claimerPubkeyXOnly: C(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
     assertTxHex: t.assert_tx.tx_hex
   }));
 }
-function x(e) {
-  return S(e).toLowerCase();
+function E(e) {
+  return C(e).toLowerCase();
 }
-function $e(e, t, r, n) {
-  const s = x(n), u = [
-    x(t),
-    ...r.map(x)
-  ], a = new Set(u);
-  if (a.size !== u.length)
+function Re(e, t, r, n) {
+  const a = E(n), u = [
+    E(t),
+    ...r.map(E)
+  ], s = new Set(u);
+  if (s.size !== u.length)
     throw new Error(
       "Cannot validate claimer set: signing context contains duplicate vault provider or vault keeper key"
     );
-  if (a.has(s))
+  if (s.has(a))
     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)
+    (g) => E(g.claimer_pubkey)
   );
   if (new Set(i).size !== i.length)
     throw new Error(
       "Presign response contains duplicate claimer entries"
     );
-  const o = i.filter((h) => h !== s), l = new Set(o), d = u.filter((h) => !l.has(h)), c = o.filter((h) => !a.has(h));
-  if (d.length > 0 || c.length > 0)
+  const o = i.filter((g) => g !== a), l = new Set(o), h = u.filter((g) => !l.has(g)), c = o.filter((g) => !s.has(g));
+  if (h.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(", ")})` : "")
+      "Presign response claimer set does not match expected (vault provider ∪ vault keepers)" + (h.length > 0 ? ` (missing: ${h.join(", ")})` : "") + (c.length > 0 ? ` (unexpected: ${c.join(", ")})` : "")
     );
 }
-function H(e, t) {
+function K(e, t) {
   return {
     payoutTxHex: e.payoutTxHex,
     peginTxHex: t.peginTxHex,
@@ -423,109 +423,109 @@ function H(e, t) {
     commissionBps: t.commissionBps
   };
 }
-async function Ie(e, t, r, n) {
-  const s = new re({
+async function Ve(e, t, r, n) {
+  const a = new re({
     network: t.network,
     btcWallet: e
   }), u = r.length;
   n == null || n(0, u);
-  let a;
-  if (s.supportsBatchSigning())
-    a = (await s.signPayoutTransactionsBatch(
-      r.map((l) => H(l, t))
+  let s;
+  if (a.supportsBatchSigning())
+    s = (await a.signPayoutTransactionsBatch(
+      r.map((l) => K(l, t))
     )).map((l) => l.payoutSignature);
   else {
-    a = [];
+    s = [];
     for (let o = 0; o < r.length; o++) {
       n == null || n(o, u);
-      const l = await s.signPayoutTransaction(
-        H(r[o], t)
+      const l = await a.signPayoutTransaction(
+        K(r[o], t)
       );
-      a.push(l.signature);
+      s.push(l.signature);
     }
   }
   const i = {};
   for (let o = 0; o < r.length; o++)
     i[r[o].claimerPubkeyXOnly] = {
-      payout_signature: a[o]
+      payout_signature: s[o]
     };
   return n == null || n(u, u), i;
 }
-async function at(e) {
+async function st(e) {
   const {
     statusReader: t,
     presignClient: r,
     btcWallet: n,
-    peginTxid: s,
+    peginTxid: a,
     depositorPk: u,
-    signingContext: a,
-    timeoutMs: i = Ce,
+    signingContext: s,
+    timeoutMs: i = Ae,
     signal: o,
     onProgress: l
-  } = e, d = await F({
+  } = e, h = await X({
     statusReader: t,
-    peginTxid: s,
-    targetStatuses: Be,
+    peginTxid: a,
+    targetStatuses: $e,
     timeoutMs: i,
     signal: o
   });
-  if (X.has(d))
+  if (z.has(h))
     return;
   o == null || o.throwIfAborted();
   const c = await r.requestDepositorPresignTransactions(
     {
-      pegin_txid: s,
+      pegin_txid: a,
       depositor_pk: u
     },
     o
   );
   o == null || o.throwIfAborted();
-  const h = x(u);
-  $e(
+  const g = E(u);
+  Re(
     c.txs,
-    a.vaultProviderBtcPubkey,
-    a.vaultKeeperBtcPubkeys,
+    s.vaultProviderBtcPubkey,
+    s.vaultKeeperBtcPubkeys,
     u
   );
-  const P = c.txs.filter(
-    (v) => x(v.claimer_pubkey) !== h
-  ), b = Re(P), g = await Ie(
+  const m = c.txs.filter(
+    (x) => E(x.claimer_pubkey) !== g
+  ), f = Be(m), P = await Ve(
     n,
-    a,
-    b,
+    s,
+    f,
     l
   );
   o == null || o.throwIfAborted();
-  const E = await Ae({
+  const w = await Se({
     depositorGraph: c.depositor_graph,
     btcWallet: n,
     signingContext: {
-      peginTxHex: a.peginTxHex,
+      peginTxHex: s.peginTxHex,
       depositorBtcPubkey: u,
-      vaultProviderBtcPubkey: a.vaultProviderBtcPubkey,
-      vaultKeeperBtcPubkeys: a.vaultKeeperBtcPubkeys,
-      universalChallengerBtcPubkeys: a.universalChallengerBtcPubkeys,
-      timelockPegin: a.timelockPegin,
-      timelockAssert: a.timelockAssert,
-      councilMembers: a.councilMembers,
-      councilQuorum: a.councilQuorum,
-      network: a.network,
-      registeredPayoutScriptPubKey: a.registeredPayoutScriptPubKey
+      vaultProviderBtcPubkey: s.vaultProviderBtcPubkey,
+      vaultKeeperBtcPubkeys: s.vaultKeeperBtcPubkeys,
+      universalChallengerBtcPubkeys: s.universalChallengerBtcPubkeys,
+      timelockPegin: s.timelockPegin,
+      timelockAssert: s.timelockAssert,
+      councilMembers: s.councilMembers,
+      councilQuorum: s.councilQuorum,
+      network: s.network,
+      registeredPayoutScriptPubKey: s.registeredPayoutScriptPubKey
     }
   });
   o == null || o.throwIfAborted();
-  const m = { ...g };
-  m[p(u)] = E.payout_signatures, await r.submitDepositorPresignatures(
+  const b = { ...P };
+  b[p(u)] = w.payout_signatures, await r.submitDepositorPresignatures(
     {
-      pegin_txid: s,
+      pegin_txid: a,
       depositor_pk: u,
-      signatures: m,
-      depositor_claimer_presignatures: E
+      signatures: b,
+      depositor_claimer_presignatures: w
     },
     o
   );
 }
-function Ve(e) {
+function Ie(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
 function it(e) {
@@ -533,11 +533,11 @@ function it(e) {
     amountSats: t,
     minDeposit: r,
     maxDeposit: n,
-    btcBalance: s,
+    btcBalance: a,
     estimatedFeeSats: u,
-    depositorClaimValue: a
+    depositorClaimValue: s
   } = e;
-  return !(t <= 0n || t < r || n && n > 0n && t > n || u == null || a == null || t + u + a > s);
+  return !(t <= 0n || t < r || n && n > 0n && t > n || u == null || s == null || t + u + s > a);
 }
 function ut(e, t, r) {
   return e <= 0n ? {
@@ -545,10 +545,10 @@ function ut(e, t, r) {
     error: "Deposit amount must be greater than zero"
   } : e < t ? {
     valid: !1,
-    error: `Minimum deposit is ${w(t)} BTC`
+    error: `Minimum deposit is ${v(t)} BTC`
   } : r && r > 0n && e > r ? {
     valid: !1,
-    error: `Maximum deposit is ${w(r)} BTC`
+    error: `Maximum deposit is ${v(r)} BTC`
   } : { valid: !0 };
 }
 function lt(e) {
@@ -558,7 +558,7 @@ function lt(e) {
     error: "Supply cap reached — deposits temporarily paused"
   } : t > r ? {
     valid: !1,
-    error: `Vault size exceeds remaining capacity (${w(r)} BTC)`
+    error: `Vault size exceeds remaining capacity (${v(r)} BTC)`
   } : { valid: !0 };
 }
 function ct(e, t) {
@@ -568,10 +568,10 @@ function ct(e, t) {
       error: "At least one vault provider must be selected"
     };
   const r = t.map(
-    (s) => s.toLowerCase()
+    (a) => a.toLowerCase()
   );
   return e.filter(
-    (s) => !r.includes(s.toLowerCase())
+    (a) => !r.includes(a.toLowerCase())
   ).length > 0 ? {
     valid: !1,
     error: "Invalid vault provider selected"
@@ -584,33 +584,33 @@ function Ne(e, t, r) {
       error: "At least one vault amount required"
     };
   for (let n = 0; n < e.length; n++) {
-    const s = e[n];
-    if (s <= 0n)
+    const a = e[n];
+    if (a <= 0n)
       return {
         valid: !1,
         error: `Vault ${n + 1} amount must be positive`
       };
-    if (t && s < t)
+    if (t && a < t)
       return {
         valid: !1,
-        error: `Vault ${n + 1} amount ${w(s)} BTC is below minimum deposit ${w(t)} BTC`
+        error: `Vault ${n + 1} amount ${v(a)} BTC is below minimum deposit ${v(t)} BTC`
       };
-    if (r && s > r)
+    if (r && a > r)
       return {
         valid: !1,
-        error: `Vault ${n + 1} amount ${w(s)} BTC exceeds maximum deposit ${w(r)} BTC`
+        error: `Vault ${n + 1} amount ${v(a)} BTC exceeds maximum deposit ${v(r)} BTC`
       };
   }
   return { valid: !0 };
 }
-function Oe(e) {
+function He(e) {
   const t = p(e);
-  return Ve(t) ? { valid: !0 } : {
+  return Ie(t) ? { valid: !0 } : {
     valid: !1,
     error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
   };
 }
-function He(e) {
+function Oe(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."
@@ -626,170 +626,196 @@ function De(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function dt(e) {
+function ht(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
     vaultProviderBtcPubkey: n,
-    vaultKeeperBtcPubkeys: s,
+    vaultKeeperBtcPubkeys: a,
     universalChallengerBtcPubkeys: u,
-    minDeposit: a,
+    minDeposit: s,
     maxDeposit: i
   } = e, o = Ne(
     t,
-    a,
+    s,
     i
   );
   if (!o.valid)
     throw new Error(o.error);
-  const l = Oe(n);
+  const l = He(n);
   if (!l.valid)
     throw new Error(l.error);
-  He(s), Ke(u), De(r);
+  Oe(a), Ke(u), De(r);
 }
-async function pt(e) {
+async function dt(e) {
   const {
     vaultRegistryReader: t,
     vaultKeeperReader: r,
     universalChallengerReader: n,
-    vaultProviderEthAddress: s,
+    vaultProviderEthAddress: a,
     applicationEntryPoint: u,
-    expectedVaultProviderBtcPubkey: a,
+    expectedVaultProviderBtcPubkey: s,
     expectedVaultKeeperBtcPubkeys: i,
     expectedUniversalChallengerBtcPubkeys: o
   } = e, [
     l,
-    d,
+    h,
     c
   ] = await Promise.all([
-    t.getVaultProviderBtcPubKey(s),
+    t.getVaultProviderBtcPubKey(a),
     r.getCurrentVaultKeepersVersion(u),
     n.getLatestUniversalChallengersVersion()
-  ]), [h, P] = await Promise.all([
+  ]), [g, m] = await Promise.all([
     r.getVaultKeepersByVersion(
       u,
-      d
+      h
     ),
     n.getUniversalChallengersByVersion(
       c
     )
-  ]), b = (f) => S(f).toLowerCase(), g = (f) => f.map(b).sort();
-  if (b(a) !== l)
+  ]), f = (d) => C(d).toLowerCase(), P = (d) => d.map(f).sort();
+  if (f(s) !== l)
     throw new Error(
-      `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${s}. Refresh and try again.`
+      `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${a}. Refresh and try again.`
     );
-  const m = g(i), v = g(
-    h.map((f) => f.btcPubKey)
+  const b = P(i), x = P(
+    g.map((d) => d.btcPubKey)
   );
-  if (m.length !== v.length || m.some((f, A) => f !== v[A]))
+  if (b.length !== x.length || b.some((d, S) => d !== x[S]))
     throw new Error(
-      `Vault keeper BTC pubkeys (v${d}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
+      `Vault keeper BTC pubkeys (v${h}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
     );
-  const T = g(o), k = g(
-    P.map((f) => f.btcPubKey)
+  const T = P(o), k = P(
+    m.map((d) => d.btcPubKey)
   );
-  if (T.length !== k.length || T.some((f, A) => f !== k[A]))
+  if (T.length !== k.length || T.some((d, S) => d !== 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: v,
+    vaultKeeperBtcPubkeysSorted: x,
     universalChallengerBtcPubkeysSorted: k,
-    expectedAppVaultKeepersVersion: d,
+    expectedAppVaultKeepersVersion: h,
     expectedUniversalChallengersVersion: c
   };
 }
-class z extends Error {
+class G extends Error {
   constructor(t) {
     super(t), this.name = "RegisteredVaultVersionMismatchError";
   }
 }
-function ht(e) {
-  return e instanceof z || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
+function pt(e) {
+  return e instanceof G || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function ft(e) {
+async function gt(e) {
   const {
     vaultRegistryReader: t,
     vaultIds: r,
     expectedOffchainParamsVersion: n,
-    expectedAppVaultKeepersVersion: s,
+    expectedAppVaultKeepersVersion: a,
     expectedUniversalChallengersVersion: u
-  } = e, a = await t.getProtocolInfoBatch(r), i = [];
-  if (a.forEach((o, l) => {
-    const d = r[l];
+  } = e, s = await t.getProtocolInfoBatch(r), i = [];
+  if (s.forEach((o, l) => {
+    const h = r[l];
     o.offchainParamsVersion !== n && i.push(
-      `vault ${d}: offchainParams expected v${n}, got v${o.offchainParamsVersion}`
-    ), o.appVaultKeepersVersion !== s && i.push(
-      `vault ${d}: appVaultKeepers expected v${s}, got v${o.appVaultKeepersVersion}`
+      `vault ${h}: offchainParams expected v${n}, got v${o.offchainParamsVersion}`
+    ), o.appVaultKeepersVersion !== a && i.push(
+      `vault ${h}: appVaultKeepers expected v${a}, got v${o.appVaultKeepersVersion}`
     ), o.universalChallengersVersion !== u && i.push(
-      `vault ${d}: universalChallengers expected v${u}, got v${o.universalChallengersVersion}`
+      `vault ${h}: universalChallengers expected v${u}, got v${o.universalChallengersVersion}`
     );
   }), i.length > 0)
-    throw new z(
+    throw new G(
       `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 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 Ue = /* @__PURE__ */ new Set([
+var j = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(j || {});
+const Fe = /* @__PURE__ */ new Set([
   "PayoutBroadcast",
   "PayoutBlocked"
   /* PAYOUT_BLOCKED */
 ]);
-function gt(e) {
-  return Object.values(G).includes(
+function ft(e) {
+  return Object.values(j).includes(
     e
   );
 }
-function Pt(e) {
-  return !!e && Ue.has(e);
+function mt(e) {
+  return !!e && Fe.has(e);
 }
 class Me extends Error {
   constructor(r, n) {
     super(`Refund not yet mature (BIP68 not final): ${n.message}`);
-    C(this, "vaultId");
-    C(this, "cause");
+    A(this, "vaultId");
+    A(this, "cause");
     this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = n;
   }
 }
-const Le = /^0x[0-9a-fA-F]{64}$/, Fe = /^(?: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 mt(e) {
+const Ue = /^0x[0-9a-fA-F]{64}$/, Le = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, q = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, Q = 160, D = 2e3, F = 10n, M = 100n;
+function Pt(e) {
   if (!Number.isFinite(e) || e <= 0)
     throw new Error(
       `feeRateSatsVb must be a positive finite number, got ${e}`
     );
-  return BigInt(Math.ceil(e * q));
+  return BigInt(Math.ceil(e * Q));
 }
 const Xe = 1, ze = /non-BIP68-final/i;
-function Q(e, t) {
+function N(e, t) {
   if (e.length !== 66)
     throw new Error(
       `${t} must be 32 bytes (66 hex chars with 0x prefix), got length ${e.length}`
     );
-  if (!Le.test(e))
+  if (!Ue.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function $(e, t) {
+function R(e, t) {
   if (!Number.isInteger(e) || e < 0)
     throw new Error(`${t} must be a non-negative integer, got ${e}`);
 }
 function Ge(e) {
-  if (Q(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout !== 0)
+  if (N(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
+    throw new Error(
+      `htlcVout must be a non-negative integer, got ${e.htlcVout}`
+    );
+  if (!Array.isArray(e.batch) || e.batch.length === 0)
+    throw new Error("batch must be a non-empty array of HTLC entries");
+  if (e.htlcVout >= e.batch.length)
+    throw new Error(
+      `htlcVout ${e.htlcVout} is out of range for batch of size ${e.batch.length}`
+    );
+  for (let r = 0; r < e.batch.length; r++) {
+    const n = e.batch[r];
+    if (N(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}`
+      );
+    if (typeof n.amount != "bigint" || n.amount <= 0n)
+      throw new Error(
+        `batch[${r}].amount must be a positive bigint, got ${n.amount}`
+      );
+  }
+  const t = e.batch[e.htlcVout];
+  if (t.hashlock.toLowerCase() !== e.hashlock.toLowerCase())
     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.`
+      `batch[${e.htlcVout}].hashlock (${t.hashlock}) does not match target hashlock (${e.hashlock})`
     );
-  if ($(e.offchainParamsVersion, "offchainParamsVersion"), $(e.appVaultKeepersVersion, "appVaultKeepersVersion"), $(
+  if (t.amount !== e.amount)
+    throw new Error(
+      `batch[${e.htlcVout}].amount (${t.amount}) does not match target amount (${e.amount})`
+    );
+  if (R(e.offchainParamsVersion, "offchainParamsVersion"), R(e.appVaultKeepersVersion, "appVaultKeepersVersion"), R(
     e.universalChallengersVersion,
     "universalChallengersVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
     throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!Fe.test(e.unsignedPrePeginTxHex))
+  if (!Le.test(e.unsignedPrePeginTxHex))
     throw new Error(
       "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
     );
-  if (!e.depositorBtcPubkey || !j.test(e.depositorBtcPubkey))
+  if (!e.depositorBtcPubkey || !q.test(e.depositorBtcPubkey))
     throw new Error(
       "depositorBtcPubkey must be 32 or 33 bytes of hex (optional 0x prefix)"
     );
@@ -797,7 +823,7 @@ function Ge(e) {
     throw new Error(`amount must be a positive bigint, got ${e.amount}`);
 }
 function je(e) {
-  if (!e.vaultProviderPubkey || !j.test(e.vaultProviderPubkey))
+  if (!e.vaultProviderPubkey || !q.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");
@@ -811,6 +837,10 @@ function je(e) {
     throw new Error(
       `protocol feeRate must be a positive bigint, got ${e.feeRate}`
     );
+  if (typeof e.minPeginFeeRate != "bigint" || e.minPeginFeeRate <= 0n)
+    throw new Error(
+      `minPeginFeeRate must be a positive bigint, got ${e.minPeginFeeRate}`
+    );
   if (!Number.isInteger(e.numLocalChallengers) || e.numLocalChallengers < 0)
     throw new Error("numLocalChallengers must be a non-negative integer");
   if (!Number.isInteger(e.councilQuorum) || !Number.isInteger(e.councilSize) || e.councilQuorum <= 0 || e.councilSize <= 0 || e.councilQuorum > e.councilSize)
@@ -829,58 +859,72 @@ function qe(e) {
   }
   return t.extractTransaction().toHex();
 }
-async function yt(e) {
+async function bt(e) {
   const {
     vaultId: t,
     readVault: r,
     readPrePeginContext: n,
-    feeRate: s,
+    feeRate: a,
     signPsbt: u,
-    broadcastTx: a,
+    broadcastTx: s,
     signal: i
   } = e;
-  i == null || i.throwIfAborted(), Q(t, "vaultId");
+  i == null || i.throwIfAborted(), N(t, "vaultId");
   const o = await r();
   Ge(o), i == null || i.throwIfAborted();
   const l = await n(o);
-  if (je(l), i == null || i.throwIfAborted(), !Number.isFinite(s) || s <= 0)
-    throw new Error(`feeRate must be a positive number, got ${s}`);
-  if (s > K)
+  if (je(l), i == null || i.throwIfAborted(), !Number.isFinite(a) || a <= 0)
+    throw new Error(`feeRate must be a positive number, got ${a}`);
+  if (a > D)
     throw new Error(
-      `feeRate ${s} sat/vB exceeds refund safety cap ${K} sat/vB; refusing to sign refund.`
+      `feeRate ${a} sat/vB exceeds refund safety cap ${D} sat/vB; refusing to sign refund.`
     );
-  const d = BigInt(Math.ceil(s * q)), c = o.amount * D / U;
-  if (d > c)
+  const h = BigInt(Math.ceil(a * Q)), c = o.amount * F / M;
+  if (h > c)
     throw new Error(
-      `Refund fee ${d} sats exceeds the per-vault safety cap of ${c} sats (${D}/${U} of vault.amount=${o.amount}); refusing to sign refund.`
+      `Refund fee ${h} sats exceeds the per-vault safety cap of ${c} sats (${F}/${M} of vault.amount=${o.amount}); refusing to sign refund.`
     );
   i == null || i.throwIfAborted();
-  const h = S(
+  const g = C(
     o.depositorBtcPubkey
-  ), P = p(o.unsignedPrePeginTxHex), b = 1, g = ne(P);
-  if (g !== void 0 && g.vout !== b)
+  ), m = p(o.unsignedPrePeginTxHex), f = ne(m);
+  if (f !== void 0 && f.vout !== o.batch.length)
+    throw new Error(
+      `Auth-anchor OP_RETURN at vout ${f.vout} does not match batch size (${o.batch.length} HTLC outputs expect the anchor at vout ${o.batch.length}). Refund refused — sibling HTLC vector is incomplete.`
+    );
+  const P = f == null ? void 0 : f.hash;
+  let w;
+  try {
+    w = _.fromHex(m);
+  } catch (d) {
+    throw new Error(
+      `Failed to parse funded Pre-PegIn transaction hex: ${d instanceof Error ? d.message : String(d)}`
+    );
+  }
+  if (w.outs.length < o.batch.length)
     throw new Error(
-      `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.`
+      `Funded Pre-PegIn tx has ${w.outs.length} outputs but batch requires at least ${o.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
     );
-  const E = g == null ? void 0 : g.hash, { psbtHex: m } = await de({
+  const { psbtHex: b } = await he({
     prePeginParams: {
-      depositorPubkey: h,
+      depositorPubkey: g,
       vaultProviderPubkey: p(l.vaultProviderPubkey),
       vaultKeeperPubkeys: l.vaultKeeperPubkeys.map(p),
       universalChallengerPubkeys: l.universalChallengerPubkeys.map(p),
-      hashlocks: [p(o.hashlock)],
+      hashlocks: o.batch.map((d) => p(d.hashlock)),
       timelockRefund: l.timelockRefund,
-      pegInAmounts: [o.amount],
+      pegInAmounts: o.batch.map((d) => d.amount),
       feeRate: l.feeRate,
+      minPeginFeeRate: l.minPeginFeeRate,
       numLocalChallengers: l.numLocalChallengers,
       councilQuorum: l.councilQuorum,
       councilSize: l.councilSize,
       network: l.network,
-      authAnchorHash: E
+      authAnchorHash: P
     },
-    fundedPrePeginTxHex: P,
+    fundedPrePeginTxHex: m,
     htlcVout: o.htlcVout,
-    refundFee: d,
+    refundFee: h,
     // 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
@@ -888,48 +932,48 @@ async function yt(e) {
     hashlock: p(o.hashlock)
   });
   i == null || i.throwIfAborted();
-  const v = V(
+  const x = I(
     o.depositorBtcPubkey,
     Xe
-  ), T = await u(m, v);
-  I({
-    requestedPsbtHex: m,
+  ), T = await u(b, x);
+  V({
+    requestedPsbtHex: b,
     returnedPsbtHex: T
   });
   const k = qe(T);
   i == null || i.throwIfAborted();
   try {
-    return await a(k);
-  } catch (f) {
-    throw f instanceof Error && ze.test(f.message) ? new Me(t, f) : f;
+    return await s(k);
+  } catch (d) {
+    throw d instanceof Error && ze.test(d.message) ? new Me(t, d) : d;
   }
 }
 export {
   Me as B,
-  G as C,
-  z as R,
+  j as C,
+  G as R,
   ot as a,
-  Ae as b,
+  Se as b,
   lt as c,
   ct as d,
   Ne as e,
-  Oe as f,
-  dt as g,
-  pt as h,
+  He as f,
+  ht as g,
+  dt as h,
   it as i,
-  ht as j,
-  ft as k,
-  gt as l,
-  Pt as m,
-  yt as n,
-  mt as o,
-  U as p,
-  D as q,
-  at as r,
-  st as s,
-  K as t,
-  q as u,
+  pt as j,
+  gt as k,
+  ft as l,
+  mt as m,
+  bt as n,
+  Pt as o,
+  M as p,
+  F as q,
+  st as r,
+  at as s,
+  D as t,
+  Q as u,
   ut as v,
-  F as w
+  X as w
 };
-//# sourceMappingURL=buildAndBroadcastRefund-BRMB7XyC.js.map
+//# sourceMappingURL=buildAndBroadcastRefund-fIHDHiFh.js.map