@babylonlabs-io/ts-sdk 0.48.1 → 0.48.2

package/dist/{buildAndBroadcastRefund-hM9Wo0VZ.js → buildAndBroadcastRefund-DXHs6unL.js}

@@ -1,100 +1,100 @@
-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 S = (e, t, r) => Y(e, typeof t != "symbol" ? t + "" : t, r);
-import { B as J } from "./BTCVaultRegistry.abi-Chs4AFBj.js";
-import { e as Z, v as ee, s as d, u as L, p as A, f as E } from "./bitcoin-B5aNKtsk.js";
-import { v as te, P as re, f as ne } from "./PayoutManager-BbemBIo9.js";
-import { D as w, c as oe, a as ae, R as se, d as U } from "./types-CQDRQvV-.js";
-import { Transaction as _, Psbt as ie } from "bitcoinjs-lib";
-import { c as ue, d as V, e as H } from "./assertPsbtUnsignedTxMatches-BHyBdtxs.js";
-import { c as le, a as ce, b as he } from "./noPayout-BwSaoU7w.js";
-import { c as I } from "./signing-DaLvGwQe.js";
-import { computeMinClaimValue as de, computeMinPeginFee as pe } from "@babylonlabs-io/babylon-tbv-rust-wasm";
-const ge = /^0x[0-9a-fA-F]{64}$/, fe = /^0x[0-9a-fA-F]{40}$/, me = /^0x([0-9a-fA-F]{2})*$/;
-function $(e, t) {
+var Z = Object.defineProperty;
+var ee = (e, t, r) => t in e ? Z(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var $ = (e, t, r) => ee(e, typeof t != "symbol" ? t + "" : t, r);
+import { B as te } from "./BTCVaultRegistry.abi-Chs4AFBj.js";
+import { e as re, v as ne, s as p, u as X, p as A, f as T } from "./bitcoin-B5aNKtsk.js";
+import { v as oe, P as ae, f as se } from "./PayoutManager-D02AePm4.js";
+import { D as w, c as ie, a as ue, R as le, d as z } from "./types-CQDRQvV-.js";
+import { Transaction as S, Psbt as ce } from "bitcoinjs-lib";
+import { c as he, d as V, e as N, f as H } from "./verifyScriptPathSchnorrSignature-DFJAEleY.js";
+import { c as de, a as pe, b as ge } from "./noPayout-CA4-x5vZ.js";
+import { c as O } from "./signing-DaLvGwQe.js";
+import { computeMinClaimValue as fe, computeMinPeginFee as me } from "@babylonlabs-io/babylon-tbv-rust-wasm";
+const Pe = /^0x[0-9a-fA-F]{64}$/, be = /^0x[0-9a-fA-F]{40}$/, ye = /^0x([0-9a-fA-F]{2})*$/;
+function R(e, t) {
   if (e.length !== 66)
     throw new Error(
       `${t} must be 32 bytes (66 hex chars with 0x prefix), got length ${e.length}`
     );
-  if (!ge.test(e))
+  if (!Pe.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function Pe(e, t) {
-  if (!fe.test(e))
+function we(e, t) {
+  if (!be.test(e))
     throw new Error(
       `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
     );
 }
-function be(e, t) {
-  if (!me.test(e))
+function xe(e, t) {
+  if (!ye.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
 }
-async function ut(e) {
+async function ht(e) {
   const {
     btcVaultRegistryAddress: t,
     vaultId: r,
     hashlock: n,
-    activationMetadata: s,
+    activationMetadata: i,
     writeContract: u,
-    signal: i
+    signal: s
   } = e;
-  i == null || i.throwIfAborted(), Pe(t, "btcVaultRegistryAddress"), $(r, "vaultId");
-  const a = Z(e.secret);
-  if ($(a, "secret"), n !== void 0 && ($(n, "hashlock"), !te(a, n)))
+  s == null || s.throwIfAborted(), we(t, "btcVaultRegistryAddress"), R(r, "vaultId");
+  const o = re(e.secret);
+  if (R(o, "secret"), n !== void 0 && (R(n, "hashlock"), !oe(o, n)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
-  return be(s, "activationMetadata"), u({
+  return xe(i, "activationMetadata"), u({
     address: t,
-    abi: J,
+    abi: te,
     functionName: "activateVaultWithSecret",
-    args: [r, a, s]
+    args: [r, o, i]
   });
 }
-const ye = 1e4;
-async function z(e) {
+const ve = 1e4;
+async function G(e) {
   const {
     statusReader: t,
     peginTxid: r,
     targetStatuses: n,
-    timeoutMs: s,
-    pollIntervalMs: u = ye,
-    signal: i
-  } = e, a = Date.now();
+    timeoutMs: i,
+    pollIntervalMs: u = ve,
+    signal: s
+  } = e, o = Date.now();
   for (; ; ) {
-    if (i != null && i.aborted)
+    if (s != null && s.aborted)
       throw new Error(
         `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
       );
-    if (Date.now() - a >= s)
+    if (Date.now() - o >= i)
       throw new Error(
-        `Polling timeout after ${s}ms for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
+        `Polling timeout after ${i}ms for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
       );
     try {
-      const o = await t.getPeginStatus(
+      const a = await t.getPeginStatus(
         { pegin_txid: r },
-        i
+        s
       );
-      if (o.pegin_txid.toLowerCase() !== r.toLowerCase())
+      if (a.pegin_txid.toLowerCase() !== r.toLowerCase())
         throw new Error(
-          `getPeginStatus returned status for pegin ${o.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
+          `getPeginStatus returned status for pegin ${a.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
         );
-      const l = o.status;
+      const l = a.status;
       if (n.has(l) || l === w.ACTIVATED)
         return l;
-      if (l === w.EXPIRED || oe.has(l))
+      if (l === w.EXPIRED || ie.has(l))
         throw new Error(
           `Pegin ${r.slice(0, 8)}… reached terminal status "${l}" while waiting for ${[...n].join(", ")}`
         );
-    } catch (o) {
-      if (!(o instanceof ae && o.code === se.PEGIN_NOT_FOUND))
-        throw o;
+    } catch (a) {
+      if (!(a instanceof ue && a.code === le.PEGIN_NOT_FOUND))
+        throw a;
     }
-    await new Promise((o, l) => {
+    await new Promise((a, l) => {
       const h = () => {
         clearTimeout(c), l(
           new Error(
@@ -102,104 +102,104 @@ async function z(e) {
           )
         );
       }, c = setTimeout(() => {
-        i == null || i.removeEventListener("abort", h), o();
+        s == null || s.removeEventListener("abort", h), a();
       }, u);
-      i == null || i.addEventListener("abort", h, { once: !0 });
+      s == null || s.addEventListener("abort", h, { once: !0 });
     });
   }
 }
-const we = 300 * 1e3, ve = /* @__PURE__ */ new Set([
+const Ee = 300 * 1e3, Te = /* @__PURE__ */ new Set([
   w.PENDING_DEPOSITOR_WOTS_PK,
-  ...U
+  ...z
 ]);
-async function lt(e) {
+async function dt(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
     peginTxid: n,
-    depositorPk: s,
+    depositorPk: i,
     wotsPublicKeys: u,
-    timeoutMs: i = we,
-    signal: a
+    timeoutMs: s = Ee,
+    signal: o
   } = e;
-  a == null || a.throwIfAborted();
-  const o = await z({
+  o == null || o.throwIfAborted();
+  const a = await G({
     statusReader: t,
     peginTxid: n,
-    targetStatuses: ve,
-    timeoutMs: i,
-    signal: a
+    targetStatuses: Te,
+    timeoutMs: s,
+    signal: o
   });
-  U.has(o) || (a == null || a.throwIfAborted(), await r.submitDepositorWotsKey(
+  z.has(a) || (o == null || o.throwIfAborted(), await r.submitDepositorWotsKey(
     {
       pegin_txid: n,
-      depositor_pk: s,
+      depositor_pk: i,
       wots_public_keys: u
     },
-    a
+    o
   ));
 }
-const O = 1, xe = 1;
-function Ee(e, t) {
-  const r = d(t).toLowerCase(), s = e.map((u) => d(u).toLowerCase()).filter((u) => u !== r);
-  if (s.length === 0)
+const K = 1, ke = 1;
+function _e(e, t) {
+  const r = p(t).toLowerCase(), i = e.map((u) => p(u).toLowerCase()).filter((u) => u !== r);
+  if (i.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(i).size !== i.length)
     throw new Error(
       "Cannot derive localChallengers: duplicate vaultKeeper key — signing context is misconfigured"
     );
-  return s;
+  return i;
 }
-function ke(e, t, r) {
+function Se(e, t, r) {
   const n = r.map(
-    (c) => d(c).toLowerCase()
-  ), s = t.filter((c) => n.includes(c));
-  if (s.length > 0)
+    (c) => p(c).toLowerCase()
+  ), i = t.filter((c) => n.includes(c));
+  if (i.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 (${i.join(", ")})`
     );
-  const u = [...t, ...n], i = e.map(
-    (c) => d(c.challenger_pubkey).toLowerCase()
-  ), a = new Set(i);
-  if (a.size !== i.length)
+  const u = [...t, ...n], s = e.map(
+    (c) => p(c.challenger_pubkey).toLowerCase()
+  ), o = new Set(s);
+  if (o.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) => !a.has(c)), h = i.filter((c) => !o.has(c));
+  const a = new Set(u), l = u.filter((c) => !o.has(c)), h = s.filter((c) => !a.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(", ")})` : "") + (h.length > 0 ? ` (unexpected: ${h.join(", ")})` : "")
     );
 }
-function Te(e, t) {
+function Ce(e, t) {
   const r = e.ins[t];
-  return L(new Uint8Array(r.hash).slice().reverse());
+  return X(new Uint8Array(r.hash).slice().reverse());
 }
-function R(e, t, r, n, s) {
+function B(e, t, r, n, i) {
   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 ${i}) input ${t} expected to spend ${n} vout 0, got vout ${u.index}`
     );
-  const i = r.getId(), a = Te(e, t);
-  if (a !== i)
+  const s = r.getId(), o = Ce(e, t);
+  if (o !== s)
     throw new Error(
-      `NoPayout (challenger ${s}) input ${t} does not reference ${n} (expected txid ${i}, got ${a})`
+      `NoPayout (challenger ${i}) input ${t} does not reference ${n} (expected txid ${s}, got ${o})`
     );
 }
-async function _e(e, t, r) {
-  const n = [], s = [], u = [], i = Ee(
+async function Ae(e, t, r) {
+  const n = [], i = [], u = [], s = _e(
     r.vaultKeeperBtcPubkeys,
     r.depositorBtcPubkey
   );
-  ke(
+  Se(
     e.challenger_presign_data,
-    i,
+    s,
     r.universalChallengerBtcPubkeys
   );
-  const a = await ue({
+  const o = await he({
     payoutTxHex: e.payout_tx.tx_hex,
     peginTxHex: r.peginTxHex,
     assertTxHex: e.assert_tx.tx_hex,
@@ -211,77 +211,77 @@ async function _e(e, t, r) {
     network: r.network,
     claimerBtcPubkey: r.depositorBtcPubkey,
     registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
-    commissionBps: xe
+    commissionBps: ke
   });
-  n.push(a.psbtHex), s.push(
-    I(
+  n.push(o.psbtHex), i.push(
+    O(
       t,
-      O
+      K
     )
   );
-  const o = d(r.depositorBtcPubkey), l = _.fromHex(
-    d(e.assert_tx.tx_hex)
+  const a = p(r.depositorBtcPubkey), l = S.fromHex(
+    p(e.assert_tx.tx_hex)
   );
   for (const h of e.challenger_presign_data) {
-    const c = d(h.challenger_pubkey), p = n.length, P = await Ce({
+    const c = p(h.challenger_pubkey), d = n.length, P = await $e({
       challenger: h,
       challengerPubkey: c,
-      claimerPubkey: o,
-      localChallengers: i,
+      claimerPubkey: a,
+      localChallengers: s,
       assertTxParsed: l,
       ctx: r
     });
-    n.push(P), s.push(
-      I(
+    n.push(P), i.push(
+      O(
         t,
-        O
+        K
       )
     ), u.push({
       challengerPubkey: c,
-      noPayoutIdx: p
+      noPayoutIdx: d
     });
   }
-  return { psbtHexes: n, signOptions: s, challengerEntries: u };
+  return { psbtHexes: n, signOptions: i, challengerEntries: u };
 }
-async function Ce(e) {
+async function $e(e) {
   const {
     challenger: t,
     challengerPubkey: r,
     claimerPubkey: n,
-    localChallengers: s,
+    localChallengers: i,
     assertTxParsed: u,
-    ctx: i
+    ctx: s
   } = e;
-  le(
+  de(
     t.nopayout_tx.tx_hex,
     r,
-    i.network
+    s.network
   );
-  const a = _.fromHex(
-    d(t.nopayout_tx.tx_hex)
-  ), o = _.fromHex(
-    d(t.challenge_assert_x_tx.tx_hex)
-  ), l = _.fromHex(
-    d(t.challenge_assert_y_tx.tx_hex)
+  const o = S.fromHex(
+    p(t.nopayout_tx.tx_hex)
+  ), a = S.fromHex(
+    p(t.challenge_assert_x_tx.tx_hex)
+  ), l = S.fromHex(
+    p(t.challenge_assert_y_tx.tx_hex)
   );
-  if (a.ins.length !== 3)
+  if (o.ins.length !== 3)
     throw new Error(
-      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${a.ins.length}`
+      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${o.ins.length}`
     );
-  R(
-    a,
+  B(
+    o,
     0,
     u,
     "Assert",
     r
-  ), R(
-    a,
-    1,
+  ), B(
     o,
+    1,
+    a,
     "ChallengeAssertX",
     r
-  ), R(
-    a,
+  ), B(
+    o,
     2,
     l,
     "ChallengeAssertY",
@@ -289,127 +289,142 @@ async function Ce(e) {
   );
   const h = [
     u.outs[0],
-    o.outs[0],
+    a.outs[0],
     l.outs[0]
   ].map((c) => ({
-    script_pubkey: L(new Uint8Array(c.script)),
+    script_pubkey: X(new Uint8Array(c.script)),
     value: c.value
   }));
-  return ce({
+  return pe({
     noPayoutTxHex: t.nopayout_tx.tx_hex,
     challengerPubkey: r,
     prevouts: h,
     connectorParams: {
       claimer: n,
-      localChallengers: s,
-      universalChallengers: i.universalChallengerBtcPubkeys,
-      timelockAssert: i.timelockAssert,
-      councilMembers: i.councilMembers,
-      councilQuorum: i.councilQuorum
+      localChallengers: i,
+      universalChallengers: s.universalChallengerBtcPubkeys,
+      timelockAssert: s.timelockAssert,
+      councilMembers: s.councilMembers,
+      councilQuorum: s.councilQuorum
     }
   });
 }
-function Ae(e, t, r) {
+function Re(e, t, r) {
   V(e[0]);
-  const n = H(
+  const i = N(
     e[0].returnedPsbtHex,
     r
-  ), s = {};
-  for (const u of t)
-    V(e[u.noPayoutIdx]), s[u.challengerPubkey] = {
-      nopayout_signature: H(
-        e[u.noPayoutIdx].returnedPsbtHex,
-        r
-      )
+  );
+  H({
+    requestedPsbtHex: e[0].requestedPsbtHex,
+    signatureHex: i,
+    signerXOnlyPubkeyHex: r,
+    inputIndex: 0
+  });
+  const u = {};
+  for (const s of t) {
+    V(e[s.noPayoutIdx]);
+    const o = N(
+      e[s.noPayoutIdx].returnedPsbtHex,
+      r
+    );
+    H({
+      requestedPsbtHex: e[s.noPayoutIdx].requestedPsbtHex,
+      signatureHex: o,
+      signerXOnlyPubkeyHex: r,
+      inputIndex: 0
+    }), u[s.challengerPubkey] = {
+      nopayout_signature: o
     };
+  }
   return {
     payout_signatures: {
-      payout_signature: n
+      payout_signature: i
     },
-    per_challenger: s
+    per_challenger: u
   };
 }
-async function Se(e, t, r) {
+async function Be(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 i = 0; i < t.length; i++)
+    n.push(await e.signPsbt(t[i], r == null ? void 0 : r[i]));
   return n;
 }
-async function $e(e) {
-  const { depositorGraph: t, btcWallet: r, signingContext: n } = e, s = await r.getPublicKeyHex(), { depositorPubkey: u } = ee(
-    s,
-    d(n.depositorBtcPubkey)
-  ), { psbtHexes: i, signOptions: a, challengerEntries: o } = await _e(
+async function Ie(e) {
+  const { depositorGraph: t, btcWallet: r, signingContext: n } = e, i = await r.getPublicKeyHex(), { depositorPubkey: u } = ne(
+    i,
+    p(n.depositorBtcPubkey)
+  ), { psbtHexes: s, signOptions: o, challengerEntries: a } = await Ae(
     t,
-    s,
+    i,
     n
-  ), l = await Se(
+  ), l = await Be(
     r,
-    i,
-    a
+    s,
+    o
   );
-  if (l.length !== i.length)
+  if (l.length !== s.length)
     throw new Error(
-      `Wallet returned ${l.length} signed PSBTs, expected ${i.length}`
+      `Wallet returned ${l.length} signed PSBTs, expected ${s.length}`
     );
-  const h = i.map((c, p) => ({
+  const h = s.map((c, d) => ({
     requestedPsbtHex: c,
-    returnedPsbtHex: l[p]
+    returnedPsbtHex: l[d]
   }));
-  return Ae(
+  return Re(
     h,
-    o,
+    a,
     u
   );
 }
-const Re = 1200 * 1e3, X = /* @__PURE__ */ new Set([
+const Ve = 1200 * 1e3, q = /* @__PURE__ */ new Set([
   w.PENDING_ACKS,
   w.PENDING_ACTIVATION,
   w.ACTIVATED_PENDING_BROADCAST,
   w.ACTIVATED
-]), Be = /* @__PURE__ */ new Set([
+]), Ne = /* @__PURE__ */ new Set([
   w.PENDING_DEPOSITOR_SIGNATURES,
-  ...X
+  ...q
 ]);
-function Ve(e) {
+function He(e) {
   return e.map((t) => ({
     claimerPubkeyXOnly: A(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
     assertTxHex: t.assert_tx.tx_hex
   }));
 }
-function T(e) {
+function k(e) {
   return A(e).toLowerCase();
 }
-function Ie(e, t, r, n) {
-  const s = T(n), u = [
-    T(t),
-    ...r.map(T)
-  ], i = new Set(u);
-  if (i.size !== u.length)
+function Oe(e, t, r, n) {
+  const i = k(n), u = [
+    k(t),
+    ...r.map(k)
+  ], 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 (i.has(s))
+  if (s.has(i))
     throw new Error(
       "Cannot validate claimer set: depositor key overlaps with vault provider or vault keeper set"
     );
-  const a = e.map(
-    (p) => T(p.claimer_pubkey)
+  const o = e.map(
+    (d) => k(d.claimer_pubkey)
   );
-  if (new Set(a).size !== a.length)
+  if (new Set(o).size !== o.length)
     throw new Error(
       "Presign response contains duplicate claimer entries"
     );
-  const o = a.filter((p) => p !== s), l = new Set(o), h = u.filter((p) => !l.has(p)), c = o.filter((p) => !i.has(p));
+  const a = o.filter((d) => d !== i), l = new Set(a), h = u.filter((d) => !l.has(d)), c = a.filter((d) => !s.has(d));
   if (h.length > 0 || c.length > 0)
     throw new Error(
       "Presign response claimer set does not match expected (vault provider ∪ vault keepers)" + (h.length > 0 ? ` (missing: ${h.join(", ")})` : "") + (c.length > 0 ? ` (unexpected: ${c.join(", ")})` : "")
     );
 }
-function K(e, t) {
+function F(e, t) {
   return {
     payoutTxHex: e.payoutTxHex,
     peginTxHex: t.peginTxHex,
@@ -424,249 +439,249 @@ function K(e, t) {
     commissionBps: t.commissionBps
   };
 }
-async function Ne(e, t, r, n) {
-  const s = new re({
+async function De(e, t, r, n) {
+  const i = new ae({
     network: t.network,
     btcWallet: e
   }), u = r.length;
   n == null || n(0, u);
-  let i;
-  if (s.supportsBatchSigning())
-    i = (await s.signPayoutTransactionsBatch(
-      r.map((l) => K(l, t))
+  let s;
+  if (i.supportsBatchSigning())
+    s = (await i.signPayoutTransactionsBatch(
+      r.map((l) => F(l, t))
     )).map((l) => l.payoutSignature);
   else {
-    i = [];
-    for (let o = 0; o < r.length; o++) {
-      n == null || n(o, u);
-      const l = await s.signPayoutTransaction(
-        K(r[o], t)
+    s = [];
+    for (let a = 0; a < r.length; a++) {
+      n == null || n(a, u);
+      const l = await i.signPayoutTransaction(
+        F(r[a], t)
       );
-      i.push(l.signature);
+      s.push(l.signature);
     }
   }
-  const a = {};
-  for (let o = 0; o < r.length; o++)
-    a[r[o].claimerPubkeyXOnly] = {
-      payout_signature: i[o]
+  const o = {};
+  for (let a = 0; a < r.length; a++)
+    o[r[a].claimerPubkeyXOnly] = {
+      payout_signature: s[a]
     };
-  return n == null || n(u, u), a;
+  return n == null || n(u, u), o;
 }
-async function ct(e) {
+async function pt(e) {
   const {
     statusReader: t,
     presignClient: r,
     btcWallet: n,
-    peginTxid: s,
+    peginTxid: i,
     depositorPk: u,
-    signingContext: i,
-    timeoutMs: a = Re,
-    signal: o,
+    signingContext: s,
+    timeoutMs: o = Ve,
+    signal: a,
     onProgress: l
-  } = e, h = await z({
+  } = e, h = await G({
     statusReader: t,
-    peginTxid: s,
-    targetStatuses: Be,
-    timeoutMs: a,
-    signal: o
+    peginTxid: i,
+    targetStatuses: Ne,
+    timeoutMs: o,
+    signal: a
   });
-  if (X.has(h))
+  if (q.has(h))
     return;
-  o == null || o.throwIfAborted();
+  a == null || a.throwIfAborted();
   const c = await r.requestDepositorPresignTransactions(
     {
-      pegin_txid: s,
+      pegin_txid: i,
       depositor_pk: u
     },
-    o
+    a
   );
-  o == null || o.throwIfAborted();
-  const p = T(u);
-  Ie(
+  a == null || a.throwIfAborted();
+  const d = k(u);
+  Oe(
     c.txs,
-    i.vaultProviderBtcPubkey,
-    i.vaultKeeperBtcPubkeys,
+    s.vaultProviderBtcPubkey,
+    s.vaultKeeperBtcPubkeys,
     u
   );
   const P = c.txs.filter(
-    (y) => T(y.claimer_pubkey) !== p
-  ), m = Ve(P), b = await Ne(
+    (b) => k(b.claimer_pubkey) !== d
+  ), f = He(P), y = await De(
     n,
-    i,
-    m,
+    s,
+    f,
     l
   );
-  o == null || o.throwIfAborted();
-  const v = await $e({
+  a == null || a.throwIfAborted();
+  const x = await Ie({
     depositorGraph: c.depositor_graph,
     btcWallet: n,
     signingContext: {
-      peginTxHex: i.peginTxHex,
+      peginTxHex: s.peginTxHex,
       depositorBtcPubkey: u,
-      vaultProviderBtcPubkey: i.vaultProviderBtcPubkey,
-      vaultKeeperBtcPubkeys: i.vaultKeeperBtcPubkeys,
-      universalChallengerBtcPubkeys: i.universalChallengerBtcPubkeys,
-      timelockPegin: i.timelockPegin,
-      timelockAssert: i.timelockAssert,
-      councilMembers: i.councilMembers,
-      councilQuorum: i.councilQuorum,
-      network: i.network,
-      registeredPayoutScriptPubKey: i.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 x = { ...b };
-  x[d(u)] = v.payout_signatures, await r.submitDepositorPresignatures(
+  a == null || a.throwIfAborted();
+  const v = { ...y };
+  v[p(u)] = x.payout_signatures, await r.submitDepositorPresignatures(
     {
-      pegin_txid: s,
+      pegin_txid: i,
       depositor_pk: u,
-      signatures: x,
-      depositor_claimer_presignatures: v
+      signatures: v,
+      depositor_claimer_presignatures: x
     },
-    o
+    a
   );
 }
-function He(e) {
+function Ke(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function ht(e) {
+function gt(e) {
   const {
     amountSats: t,
     minDeposit: r,
     maxDeposit: n,
-    btcBalance: s,
+    btcBalance: i,
     estimatedFeeSats: u,
-    depositorClaimValue: i
+    depositorClaimValue: s
   } = e;
-  return !(t <= 0n || t < r || n && n > 0n && t > n || u == null || i == null || t + u + i > s);
+  return !(t <= 0n || t < r || n && n > 0n && t > n || u == null || s == null || t + u + s > i);
 }
-function dt(e, t, r) {
+function ft(e, t, r) {
   return e <= 0n ? {
     valid: !1,
     error: "Deposit amount must be greater than zero"
   } : e < t ? {
     valid: !1,
-    error: `Minimum deposit is ${E(t)} BTC`
+    error: `Minimum deposit is ${T(t)} BTC`
   } : r && r > 0n && e > r ? {
     valid: !1,
-    error: `Maximum deposit is ${E(r)} BTC`
+    error: `Maximum deposit is ${T(r)} BTC`
   } : { valid: !0 };
 }
-function pt(e) {
+function mt(e) {
   const { amount: t, effectiveRemaining: r } = e;
   return r === null ? { valid: !0 } : r === 0n ? {
     valid: !1,
     error: "Supply cap reached — deposits temporarily paused"
   } : t > r ? {
     valid: !1,
-    error: `Vault size exceeds remaining capacity (${E(r)} BTC)`
+    error: `Vault size exceeds remaining capacity (${T(r)} BTC)`
   } : { valid: !0 };
 }
-function gt(e, t) {
+function Pt(e, t) {
   if (!e || e.length === 0)
     return {
       valid: !1,
       error: "At least one vault provider must be selected"
     };
   const r = t.map(
-    (s) => s.toLowerCase()
+    (i) => i.toLowerCase()
   );
   return e.filter(
-    (s) => !r.includes(s.toLowerCase())
+    (i) => !r.includes(i.toLowerCase())
   ).length > 0 ? {
     valid: !1,
     error: "Invalid vault provider selected"
   } : { valid: !0 };
 }
-function Oe(e, t, r) {
+function Fe(e, t, r) {
   if (!e || e.length === 0)
     return {
       valid: !1,
       error: "At least one vault amount required"
     };
   for (let n = 0; n < e.length; n++) {
-    const s = e[n];
-    if (s <= 0n)
+    const i = e[n];
+    if (i <= 0n)
       return {
         valid: !1,
         error: `Vault ${n + 1} amount must be positive`
       };
-    if (t && s < t)
+    if (t && i < t)
       return {
         valid: !1,
-        error: `Vault ${n + 1} amount ${E(s)} BTC is below minimum deposit ${E(t)} BTC`
+        error: `Vault ${n + 1} amount ${T(i)} BTC is below minimum deposit ${T(t)} BTC`
       };
-    if (r && s > r)
+    if (r && i > r)
       return {
         valid: !1,
-        error: `Vault ${n + 1} amount ${E(s)} BTC exceeds maximum deposit ${E(r)} BTC`
+        error: `Vault ${n + 1} amount ${T(i)} BTC exceeds maximum deposit ${T(r)} BTC`
       };
   }
   return { valid: !0 };
 }
-function Ke(e) {
-  const t = d(e);
-  return He(t) ? { valid: !0 } : {
+function Ue(e) {
+  const t = p(e);
+  return Ke(t) ? { valid: !0 } : {
     valid: !1,
     error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
   };
 }
-function De(e) {
+function Me(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 Fe(e) {
+function Le(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 Me(e) {
+function Xe(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function ft(e) {
+function bt(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
     vaultProviderBtcPubkey: n,
-    vaultKeeperBtcPubkeys: s,
+    vaultKeeperBtcPubkeys: i,
     universalChallengerBtcPubkeys: u,
-    minDeposit: i,
-    maxDeposit: a
-  } = e, o = Oe(
+    minDeposit: s,
+    maxDeposit: o
+  } = e, a = Fe(
     t,
-    i,
-    a
+    s,
+    o
   );
-  if (!o.valid)
-    throw new Error(o.error);
-  const l = Ke(n);
+  if (!a.valid)
+    throw new Error(a.error);
+  const l = Ue(n);
   if (!l.valid)
     throw new Error(l.error);
-  De(s), Fe(u), Me(r);
+  Me(i), Le(u), Xe(r);
 }
-async function mt(e) {
+async function yt(e) {
   const {
     vaultRegistryReader: t,
     vaultKeeperReader: r,
     universalChallengerReader: n,
-    vaultProviderEthAddress: s,
+    vaultProviderEthAddress: i,
     applicationEntryPoint: u,
-    expectedVaultProviderBtcPubkey: i,
-    expectedVaultKeeperBtcPubkeys: a,
-    expectedUniversalChallengerBtcPubkeys: o
+    expectedVaultProviderBtcPubkey: s,
+    expectedVaultKeeperBtcPubkeys: o,
+    expectedUniversalChallengerBtcPubkeys: a
   } = e, [
     l,
     h,
     c
   ] = await Promise.all([
-    t.getVaultProviderBtcPubKey(s),
+    t.getVaultProviderBtcPubKey(i),
     r.getCurrentVaultKeepersVersion(u),
     n.getLatestUniversalChallengersVersion()
-  ]), [p, P] = await Promise.all([
+  ]), [d, P] = await Promise.all([
     r.getVaultKeepersByVersion(
       u,
       h
@@ -674,110 +689,110 @@ async function mt(e) {
     n.getUniversalChallengersByVersion(
       c
     )
-  ]), m = (f) => A(f).toLowerCase(), b = (f) => f.map(m).sort();
-  if (m(i) !== l)
+  ]), f = (g) => A(g).toLowerCase(), y = (g) => g.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 ${i}. Refresh and try again.`
     );
-  const x = b(a), y = b(
-    p.map((f) => f.btcPubKey)
+  const v = y(o), b = y(
+    d.map((g) => g.btcPubKey)
   );
-  if (x.length !== y.length || x.some((f, g) => f !== y[g]))
+  if (v.length !== b.length || v.some((g, _) => g !== b[_]))
     throw new Error(
       `Vault keeper BTC pubkeys (v${h}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
     );
-  const C = b(o), k = b(
-    P.map((f) => f.btcPubKey)
+  const C = y(a), E = y(
+    P.map((g) => g.btcPubKey)
   );
-  if (C.length !== k.length || C.some((f, g) => f !== k[g]))
+  if (C.length !== E.length || C.some((g, _) => g !== E[_]))
     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: y,
-    universalChallengerBtcPubkeysSorted: k,
+    vaultKeeperBtcPubkeysSorted: b,
+    universalChallengerBtcPubkeysSorted: E,
     expectedAppVaultKeepersVersion: h,
     expectedUniversalChallengersVersion: c
   };
 }
-class G extends Error {
+class j extends Error {
   constructor(t) {
     super(t), this.name = "RegisteredVaultVersionMismatchError";
   }
 }
-function Pt(e) {
-  return e instanceof G || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
+function wt(e) {
+  return e instanceof j || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
 }
-async function bt(e) {
+async function xt(e) {
   const {
     vaultRegistryReader: t,
     vaultIds: r,
     expectedOffchainParamsVersion: n,
-    expectedAppVaultKeepersVersion: s,
+    expectedAppVaultKeepersVersion: i,
     expectedUniversalChallengersVersion: u
-  } = e, i = await t.getProtocolInfoBatch(r), a = [];
-  if (i.forEach((o, l) => {
+  } = e, s = await t.getProtocolInfoBatch(r), o = [];
+  if (s.forEach((a, l) => {
     const h = r[l];
-    o.offchainParamsVersion !== n && a.push(
-      `vault ${h}: offchainParams expected v${n}, got v${o.offchainParamsVersion}`
-    ), o.appVaultKeepersVersion !== s && a.push(
-      `vault ${h}: appVaultKeepers expected v${s}, got v${o.appVaultKeepersVersion}`
-    ), o.universalChallengersVersion !== u && a.push(
-      `vault ${h}: universalChallengers expected v${u}, got v${o.universalChallengersVersion}`
+    a.offchainParamsVersion !== n && o.push(
+      `vault ${h}: offchainParams expected v${n}, got v${a.offchainParamsVersion}`
+    ), a.appVaultKeepersVersion !== i && o.push(
+      `vault ${h}: appVaultKeepers expected v${i}, got v${a.appVaultKeepersVersion}`
+    ), a.universalChallengersVersion !== u && o.push(
+      `vault ${h}: universalChallengers expected v${u}, got v${a.universalChallengersVersion}`
     );
-  }), a.length > 0)
-    throw new G(
-      `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${a.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
+  }), o.length > 0)
+    throw new j(
+      `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${o.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
     );
 }
-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 Le = /* @__PURE__ */ new Set([
+var Q = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(Q || {});
+const ze = /* @__PURE__ */ new Set([
   "PayoutBroadcast",
   "PayoutBlocked"
   /* PAYOUT_BLOCKED */
 ]);
-function yt(e) {
-  return Object.values(j).includes(
+function vt(e) {
+  return Object.values(Q).includes(
     e
   );
 }
-function wt(e) {
-  return !!e && Le.has(e);
+function Et(e) {
+  return !!e && ze.has(e);
 }
-class Ue extends Error {
+class Ge extends Error {
   constructor(r, n) {
     super(`Refund not yet mature (BIP68 not final): ${n.message}`);
-    S(this, "vaultId");
-    S(this, "cause");
+    $(this, "vaultId");
+    $(this, "cause");
     this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = n;
   }
 }
-const ze = /^0x[0-9a-fA-F]{64}$/, Xe = /^(?: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 vt(e) {
+const qe = /^0x[0-9a-fA-F]{64}$/, je = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, W = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, Y = 160, U = 2e3, M = 10n, L = 100n;
+function Tt(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 * Y));
 }
-const Ge = 1, je = /non-BIP68-final/i;
-function N(e, t) {
+const Qe = 1, We = /non-BIP68-final/i;
+function D(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 (!ze.test(e))
+  if (!qe.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function B(e, t) {
+function I(e, t) {
   if (!Number.isInteger(e) || e < 0)
     throw new Error(`${t} must be a non-negative integer, got ${e}`);
 }
-function Qe(e) {
-  if (N(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
+function Ye(e) {
+  if (D(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0)
     throw new Error(
       `htlcVout must be a non-negative integer, got ${e.htlcVout}`
     );
@@ -789,7 +804,7 @@ function Qe(e) {
     );
   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)
+    if (D(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}`
       );
@@ -807,24 +822,24 @@ function Qe(e) {
     throw new Error(
       `batch[${e.htlcVout}].amount (${t.amount}) does not match target amount (${e.amount})`
     );
-  if (B(e.offchainParamsVersion, "offchainParamsVersion"), B(e.appVaultKeepersVersion, "appVaultKeepersVersion"), B(
+  if (I(e.offchainParamsVersion, "offchainParamsVersion"), I(e.appVaultKeepersVersion, "appVaultKeepersVersion"), I(
     e.universalChallengersVersion,
     "universalChallengersVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
     throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!Xe.test(e.unsignedPrePeginTxHex))
+  if (!je.test(e.unsignedPrePeginTxHex))
     throw new Error(
       "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
     );
-  if (!e.depositorBtcPubkey || !Q.test(e.depositorBtcPubkey))
+  if (!e.depositorBtcPubkey || !W.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 qe(e) {
-  if (!e.vaultProviderPubkey || !Q.test(e.vaultProviderPubkey))
+function Je(e) {
+  if (!e.vaultProviderPubkey || !W.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");
@@ -849,29 +864,29 @@ function qe(e) {
       `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
     );
 }
-async function We(e, t) {
-  const r = await de(
+async function Ze(e, t) {
+  const r = await fe(
     t.numLocalChallengers,
     t.universalChallengerPubkeys.length,
     t.councilQuorum,
     t.councilSize,
     t.feeRate
-  ), n = await pe(
+  ), n = await me(
     t.vaultKeeperPubkeys.length,
     t.universalChallengerPubkeys.length,
     t.minPeginFeeRate
-  ), s = r + n;
-  return e.map((u, i) => {
-    const a = u.amount - s;
-    if (a <= 0n)
+  ), i = r + n;
+  return e.map((u, s) => {
+    const o = u.amount - i;
+    if (o <= 0n)
       throw new Error(
-        `Re-derived peginAmount for batch[${i}] is non-positive (${a}): HTLC value ${u.amount} does not exceed depositorClaimValue ${r} + minPeginFee ${n}. Refusing to build a refund from an inconsistent (amount, protocol params) pair.`
+        `Re-derived peginAmount for batch[${s}] is non-positive (${o}): HTLC value ${u.amount} does not exceed depositorClaimValue ${r} + minPeginFee ${n}. Refusing to build a refund from an inconsistent (amount, protocol params) pair.`
       );
-    return a;
+    return o;
   });
 }
-function Ye(e) {
-  const t = ie.fromHex(e);
+function et(e) {
+  const t = ce.fromHex(e);
   try {
     t.finalizeAllInputs();
   } catch (r) {
@@ -881,123 +896,134 @@ function Ye(e) {
   }
   return t.extractTransaction().toHex();
 }
-async function xt(e) {
+async function kt(e) {
   const {
     vaultId: t,
     readVault: r,
     readPrePeginContext: n,
-    feeRate: s,
+    feeRate: i,
     signPsbt: u,
-    broadcastTx: i,
-    signal: a
+    broadcastTx: s,
+    signal: o
   } = e;
-  a == null || a.throwIfAborted(), N(t, "vaultId");
-  const o = await r();
-  Qe(o), a == null || a.throwIfAborted();
-  const l = await n(o);
-  if (qe(l), a == null || a.throwIfAborted(), !Number.isFinite(s) || s <= 0)
-    throw new Error(`feeRate must be a positive number, got ${s}`);
-  if (s > D)
+  o == null || o.throwIfAborted(), D(t, "vaultId");
+  const a = await r();
+  Ye(a), o == null || o.throwIfAborted();
+  const l = await n(a);
+  if (Je(l), o == null || o.throwIfAborted(), !Number.isFinite(i) || i <= 0)
+    throw new Error(`feeRate must be a positive number, got ${i}`);
+  if (i > U)
     throw new Error(
-      `feeRate ${s} sat/vB exceeds refund safety cap ${D} sat/vB; refusing to sign refund.`
+      `feeRate ${i} sat/vB exceeds refund safety cap ${U} sat/vB; refusing to sign refund.`
     );
-  const h = BigInt(Math.ceil(s * q)), c = o.amount * F / M;
+  const h = BigInt(Math.ceil(i * Y)), c = a.amount * M / L;
   if (h > c)
     throw new Error(
-      `Refund fee ${h} sats exceeds the per-vault safety cap of ${c} sats (${F}/${M} of vault.amount=${o.amount}); refusing to sign refund.`
+      `Refund fee ${h} sats exceeds the per-vault safety cap of ${c} sats (${M}/${L} of vault.amount=${a.amount}); refusing to sign refund.`
     );
-  a == null || a.throwIfAborted();
-  const p = A(
-    o.depositorBtcPubkey
-  ), P = d(o.unsignedPrePeginTxHex), m = ne(P);
-  if (m !== void 0 && m.vout !== o.batch.length)
+  o == null || o.throwIfAborted();
+  const d = A(
+    a.depositorBtcPubkey
+  ), P = p(a.unsignedPrePeginTxHex), f = se(P);
+  if (f !== void 0 && f.vout !== a.batch.length)
     throw new Error(
-      `Auth-anchor OP_RETURN at vout ${m.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.`
+      `Auth-anchor OP_RETURN at vout ${f.vout} does not match batch size (${a.batch.length} HTLC outputs expect the anchor at vout ${a.batch.length}). Refund refused — sibling HTLC vector is incomplete.`
     );
-  const b = m == null ? void 0 : m.hash;
-  let v;
+  const y = f == null ? void 0 : f.hash;
+  let x;
   try {
-    v = _.fromHex(P);
-  } catch (g) {
+    x = S.fromHex(P);
+  } catch (m) {
     throw new Error(
-      `Failed to parse funded Pre-PegIn transaction hex: ${g instanceof Error ? g.message : String(g)}`
+      `Failed to parse funded Pre-PegIn transaction hex: ${m instanceof Error ? m.message : String(m)}`
     );
   }
-  if (v.outs.length < o.batch.length)
+  if (x.outs.length < a.batch.length)
     throw new Error(
-      `Funded Pre-PegIn tx has ${v.outs.length} outputs but batch requires at least ${o.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
+      `Funded Pre-PegIn tx has ${x.outs.length} outputs but batch requires at least ${a.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
     );
-  const x = await We(o.batch, l);
-  a == null || a.throwIfAborted();
-  const { psbtHex: y } = await he({
+  const v = await Ze(a.batch, l);
+  o == null || o.throwIfAborted();
+  const { psbtHex: b } = await ge({
     prePeginParams: {
-      depositorPubkey: p,
-      vaultProviderPubkey: d(l.vaultProviderPubkey),
-      vaultKeeperPubkeys: l.vaultKeeperPubkeys.map(d),
-      universalChallengerPubkeys: l.universalChallengerPubkeys.map(d),
-      hashlocks: o.batch.map((g) => d(g.hashlock)),
+      depositorPubkey: d,
+      vaultProviderPubkey: p(l.vaultProviderPubkey),
+      vaultKeeperPubkeys: l.vaultKeeperPubkeys.map(p),
+      universalChallengerPubkeys: l.universalChallengerPubkeys.map(p),
+      hashlocks: a.batch.map((m) => p(m.hashlock)),
       timelockRefund: l.timelockRefund,
-      pegInAmounts: x,
+      pegInAmounts: v,
       feeRate: l.feeRate,
       minPeginFeeRate: l.minPeginFeeRate,
       numLocalChallengers: l.numLocalChallengers,
       councilQuorum: l.councilQuorum,
       councilSize: l.councilSize,
       network: l.network,
-      authAnchorHash: b
+      authAnchorHash: y
     },
     fundedPrePeginTxHex: P,
-    htlcVout: o.htlcVout,
+    htlcVout: a.htlcVout,
     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
     // unspendable PSBT. Match the `hashlocks` array handling above.
-    hashlock: d(o.hashlock)
+    hashlock: p(a.hashlock)
   });
-  a == null || a.throwIfAborted();
-  const C = I(
-    o.depositorBtcPubkey,
-    Ge
-  ), k = await u(y, C);
+  o == null || o.throwIfAborted();
+  const C = O(
+    a.depositorBtcPubkey,
+    Qe
+  ), E = await u(b, C);
   V({
-    requestedPsbtHex: y,
-    returnedPsbtHex: k
+    requestedPsbtHex: b,
+    returnedPsbtHex: E
   });
-  const f = Ye(k);
-  a == null || a.throwIfAborted();
+  const g = 0, _ = N(
+    E,
+    d,
+    g
+  );
+  H({
+    requestedPsbtHex: b,
+    signatureHex: _,
+    signerXOnlyPubkeyHex: d,
+    inputIndex: g
+  });
+  const J = et(E);
+  o == null || o.throwIfAborted();
   try {
-    return await i(f);
-  } catch (g) {
-    throw g instanceof Error && je.test(g.message) ? new Ue(t, g) : g;
+    return await s(J);
+  } catch (m) {
+    throw m instanceof Error && We.test(m.message) ? new Ge(t, m) : m;
   }
 }
 export {
-  Ue as B,
-  j as C,
-  G as R,
-  ut as a,
-  $e as b,
-  pt as c,
-  gt as d,
-  Oe as e,
-  Ke as f,
-  ft as g,
-  mt as h,
-  ht as i,
-  Pt as j,
-  bt as k,
-  yt as l,
-  wt as m,
-  xt as n,
-  vt as o,
-  M as p,
-  F as q,
-  ct as r,
-  lt as s,
-  D as t,
-  q as u,
-  dt as v,
-  z as w
+  Ge as B,
+  Q as C,
+  j as R,
+  ht as a,
+  Ie as b,
+  mt as c,
+  Pt as d,
+  Fe as e,
+  Ue as f,
+  bt as g,
+  yt as h,
+  gt as i,
+  wt as j,
+  xt as k,
+  vt as l,
+  Et as m,
+  kt as n,
+  Tt as o,
+  L as p,
+  M as q,
+  pt as r,
+  dt as s,
+  U as t,
+  Y as u,
+  ft as v,
+  G as w
 };
-//# sourceMappingURL=buildAndBroadcastRefund-hM9Wo0VZ.js.map
+//# sourceMappingURL=buildAndBroadcastRefund-DXHs6unL.js.map