@babylonlabs-io/ts-sdk 0.28.1 → 0.30.0

package/dist/{buildAndBroadcastRefund-xWS8frc6.js → buildAndBroadcastRefund-BY6mYmFl.js}

@@ -1,16 +1,16 @@
-var W = Object.defineProperty;
-var X = (e, t, r) => t in e ? W(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var y = (e, t, r) => X(e, typeof t != "symbol" ? t + "" : t, r);
-import { B as G, c as Y, a as j, R as q, d as N, D as g } from "./types-CnG3JsRs.js";
-import { e as Q, s as l, v as A, b as J, p as P, f } from "./bitcoin-B-Y0DlqR.js";
+var z = Object.defineProperty;
+var G = (e, t, r) => t in e ? z(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var x = (e, t, r) => G(e, typeof t != "symbol" ? t + "" : t, r);
+import { B as Q, c as Y, a as j, R as q, d as O, D as y } from "./types-CnG3JsRs.js";
+import { e as J, s as c, u as K, v as H, p as m, f } from "./bitcoin-B-Y0DlqR.js";
 import { s as Z } from "./sha2-6wN58S6R.js";
 import * as ee from "bitcoinjs-lib";
-import { Psbt as B, Transaction as te } from "bitcoinjs-lib";
-import { Buffer as V } from "buffer";
+import { Transaction as w, Psbt as te } from "bitcoinjs-lib";
+import { Buffer as re } from "buffer";
 import { c as b } from "./signing-BZigafm0.js";
 import "@babylonlabs-io/babylon-tbv-rust-wasm";
-import { e as w, a as I, b as re } from "./payout-B_fvQU3q.js";
-const H = 66;
+import { a as V, c as S, e as v, g as oe, d as ne, b as se } from "./noPayout-B8JiTaYt.js";
+const $ = 66;
 function L(e) {
   if (!e.startsWith("0x") && !e.startsWith("0X"))
     throw new Error("Expected 0x-prefixed hex string");
@@ -24,201 +24,300 @@ function L(e) {
     r[o] = parseInt(t.slice(o * 2, o * 2 + 2), 16);
   return r;
 }
-function oe(e) {
+function ie(e) {
   return `0x${Array.from(e).map((t) => t.toString(16).padStart(2, "0")).join("")}`;
 }
-function S(e, t) {
-  if (e.length !== H)
+function A(e, t) {
+  if (e.length !== $)
     throw new Error(
-      `${t} must be exactly 32 bytes (${H} hex chars with 0x prefix), got ${e.length}`
+      `${t} must be exactly 32 bytes (${$} hex chars with 0x prefix), got ${e.length}`
     );
 }
-function ne(e) {
-  S(e, "Secret");
+function ae(e) {
+  A(e, "Secret");
   const t = L(e), r = Z(t);
-  return oe(r);
+  return ie(r);
 }
-function ie(e, t) {
-  return S(e, "Secret"), S(t, "Hashlock"), L(t), ne(e).toLowerCase() === t.toLowerCase();
+function ue(e, t) {
+  return A(e, "Secret"), A(t, "Hashlock"), L(t), ae(e).toLowerCase() === t.toLowerCase();
 }
-const se = /^0x[0-9a-fA-F]{64}$/, ae = /^0x[0-9a-fA-F]{40}$/, ue = /^0x([0-9a-fA-F]{2})*$/;
+const le = /^0x[0-9a-fA-F]{64}$/, ce = /^0x[0-9a-fA-F]{40}$/, de = /^0x([0-9a-fA-F]{2})*$/;
 function E(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 (!se.test(e))
+  if (!le.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function ce(e, t) {
-  if (!ae.test(e))
+function he(e, t) {
+  if (!ce.test(e))
     throw new Error(
       `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
     );
 }
-function le(e, t) {
-  if (!ue.test(e))
+function pe(e, t) {
+  if (!de.test(e))
     throw new Error(
       `${t} must be a 0x-prefixed hex string with an even number of hex chars`
     );
 }
-async function Je(e) {
+async function rt(e) {
   const {
     btcVaultRegistryAddress: t,
     vaultId: r,
     hashlock: o,
     activationMetadata: i,
-    writeContract: c,
-    signal: a
+    writeContract: u,
+    signal: s
   } = e;
-  a == null || a.throwIfAborted(), ce(t, "btcVaultRegistryAddress"), E(r, "vaultId");
-  const s = Q(e.secret);
-  if (E(s, "secret"), o !== void 0 && (E(o, "hashlock"), !ie(s, o)))
+  s == null || s.throwIfAborted(), he(t, "btcVaultRegistryAddress"), E(r, "vaultId");
+  const a = J(e.secret);
+  if (E(a, "secret"), o !== void 0 && (E(o, "hashlock"), !ue(a, o)))
     throw new Error(
       "Invalid secret: SHA256(secret) does not match the provided hashlock"
     );
-  return le(i, "activationMetadata"), c({
+  return pe(i, "activationMetadata"), u({
     address: t,
-    abi: G,
+    abi: Q,
     functionName: "activateVaultWithSecret",
-    args: [r, s, i]
+    args: [r, a, i]
   });
 }
-const de = 1e4;
+const fe = 1e4;
 async function D(e) {
   const {
     statusReader: t,
     peginTxid: r,
     targetStatuses: o,
     timeoutMs: i,
-    pollIntervalMs: c = de,
-    signal: a
-  } = e, s = Date.now();
+    pollIntervalMs: u = fe,
+    signal: s
+  } = e, a = 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: ${[...o].join(", ")})`
       );
-    if (Date.now() - s >= i)
+    if (Date.now() - a >= i)
       throw new Error(
         `Polling timeout after ${i}ms for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
       );
     try {
-      const u = (await t.getPeginStatus(
+      const l = (await t.getPeginStatus(
         { pegin_txid: r },
-        a
+        s
       )).status;
-      if (o.has(u))
-        return u;
-      if (Y.has(u) && !o.has(u))
+      if (o.has(l))
+        return l;
+      if (Y.has(l) && !o.has(l))
         throw new Error(
-          `Pegin ${r.slice(0, 8)}… reached terminal status "${u}" while waiting for ${[...o].join(", ")}`
+          `Pegin ${r.slice(0, 8)}… reached terminal status "${l}" while waiting for ${[...o].join(", ")}`
         );
     } catch (n) {
       if (!(n instanceof j && n.code === q.NOT_FOUND || n instanceof Error && n.message.includes("PegIn not found")))
         throw n;
     }
-    await new Promise((n, u) => {
+    await new Promise((n, l) => {
       const d = () => {
-        clearTimeout(h), u(
+        clearTimeout(h), l(
           new Error(
             `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
           )
         );
       }, h = setTimeout(() => {
-        a == null || a.removeEventListener("abort", d), n();
-      }, c);
-      a == null || a.addEventListener("abort", d, { once: !0 });
+        s == null || s.removeEventListener("abort", d), n();
+      }, u);
+      s == null || s.addEventListener("abort", d, { once: !0 });
     });
   }
 }
-const pe = 300 * 1e3, fe = /* @__PURE__ */ new Set([
-  g.PENDING_DEPOSITOR_WOTS_PK,
-  ...N
+const ge = 300 * 1e3, Pe = /* @__PURE__ */ new Set([
+  y.PENDING_DEPOSITOR_WOTS_PK,
+  ...O
 ]);
-async function Ze(e) {
+async function ot(e) {
   const {
     statusReader: t,
     wotsSubmitter: r,
     peginTxid: o,
     depositorPk: i,
-    wotsPublicKeys: c,
-    timeoutMs: a = pe,
-    signal: s
+    wotsPublicKeys: u,
+    timeoutMs: s = ge,
+    signal: a
   } = e;
-  s == null || s.throwIfAborted();
+  a == null || a.throwIfAborted();
   const n = await D({
     statusReader: t,
     peginTxid: o,
-    targetStatuses: fe,
-    timeoutMs: a,
-    signal: s
+    targetStatuses: Pe,
+    timeoutMs: s,
+    signal: a
   });
-  N.has(n) || (s == null || s.throwIfAborted(), await r.submitDepositorWotsKey(
+  O.has(n) || (a == null || a.throwIfAborted(), await r.submitDepositorWotsKey(
     {
       pegin_txid: o,
       depositor_pk: i,
-      wots_public_keys: c
+      wots_public_keys: u
     },
-    s
+    a
   ));
 }
-const R = 1;
-function he(e, t, r) {
-  const o = B.fromBase64(e), i = o.data.getTransaction().toString("hex").toLowerCase(), c = l(t).toLowerCase();
-  if (i !== c)
+const I = 1;
+function ye(e, t, r) {
+  const o = c(r).toLowerCase(), u = [e, ...t].map(
+    (s) => c(s).toLowerCase()
+  ).filter((s) => s !== o);
+  if (u.length === 0)
     throw new Error(
-      `PSBT integrity check failed for ${r}: unsigned transaction does not match tx_hex`
+      "Cannot derive localChallengers: removing depositor from {vaultProvider, vaultKeepers} left an empty set"
     );
-  return o;
+  return u;
 }
-function ge(e) {
-  const t = B.fromHex(e.toHex());
-  for (const r of t.data.inputs)
-    delete r.tapBip32Derivation, delete r.tapMerkleRoot;
-  return t;
+function be(e, t) {
+  const r = e.ins[t];
+  return K(new Uint8Array(r.hash).slice().reverse());
 }
-function $(e, t, r) {
-  if (!e)
-    throw new Error(`Missing ${r} PSBT`);
-  const o = he(e, t, r);
-  return ge(o).toHex();
+function _(e, t, r, o, i) {
+  const u = e.ins[t];
+  if (u.index !== 0)
+    throw new Error(
+      `NoPayout (challenger ${i}) input ${t} expected to spend ${o} vout 0, got vout ${u.index}`
+    );
+  const s = r.getId(), a = be(e, t);
+  if (a !== s)
+    throw new Error(
+      `NoPayout (challenger ${i}) input ${t} does not reference ${o} (expected txid ${s}, got ${a})`
+    );
 }
-function be(e, t) {
-  const r = [], o = [], i = [], c = $(
-    e.payout_psbt,
+async function xe(e, t, r) {
+  const o = [], i = [], u = [];
+  V(
     e.payout_tx.tx_hex,
-    "depositor payout"
+    r.registeredPayoutScriptPubKey
+  );
+  const s = await S({
+    payoutTxHex: e.payout_tx.tx_hex,
+    peginTxHex: r.peginTxHex,
+    assertTxHex: e.assert_tx.tx_hex,
+    depositorBtcPubkey: r.depositorBtcPubkey,
+    vaultProviderBtcPubkey: r.vaultProviderBtcPubkey,
+    vaultKeeperBtcPubkeys: r.vaultKeeperBtcPubkeys,
+    universalChallengerBtcPubkeys: r.universalChallengerBtcPubkeys,
+    timelockPegin: r.timelockPegin,
+    network: r.network
+  });
+  o.push(s.psbtHex), i.push(
+    b(
+      t,
+      I
+    )
   );
-  r.push(c), o.push(
-    b(t, R)
+  const a = ye(
+    r.vaultProviderBtcPubkey,
+    r.vaultKeeperBtcPubkeys,
+    r.depositorBtcPubkey
+  ), n = c(r.depositorBtcPubkey), l = w.fromHex(
+    c(e.assert_tx.tx_hex)
   );
-  for (const a of e.challenger_presign_data) {
-    const s = l(a.challenger_pubkey), n = r.length, u = $(
-      a.nopayout_psbt,
-      a.nopayout_tx.tx_hex,
-      `nopayout (challenger ${s})`
-    );
-    r.push(u), o.push(
-      b(t, R)
-    ), i.push({
-      challengerPubkey: s,
-      noPayoutIdx: n
+  for (const d of e.challenger_presign_data) {
+    const h = c(d.challenger_pubkey), g = o.length, P = await we({
+      challenger: d,
+      challengerPubkey: h,
+      claimerPubkey: n,
+      localChallengers: a,
+      assertTxParsed: l,
+      ctx: r
+    });
+    o.push(P), i.push(
+      b(
+        t,
+        I
+      )
+    ), u.push({
+      challengerPubkey: h,
+      noPayoutIdx: g
     });
   }
-  return { psbtHexes: r, signOptions: o, challengerEntries: i };
+  return { psbtHexes: o, signOptions: i, challengerEntries: u };
 }
-function ye(e, t, r) {
-  const o = w(
+async function we(e) {
+  const {
+    challenger: t,
+    challengerPubkey: r,
+    claimerPubkey: o,
+    localChallengers: i,
+    assertTxParsed: u,
+    ctx: s
+  } = e;
+  oe(
+    t.nopayout_tx.tx_hex,
+    r,
+    s.network
+  );
+  const a = w.fromHex(
+    c(t.nopayout_tx.tx_hex)
+  ), n = w.fromHex(
+    c(t.challenge_assert_x_tx.tx_hex)
+  ), l = w.fromHex(
+    c(t.challenge_assert_y_tx.tx_hex)
+  );
+  if (a.ins.length !== 3)
+    throw new Error(
+      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${a.ins.length}`
+    );
+  _(
+    a,
+    0,
+    u,
+    "Assert",
+    r
+  ), _(
+    a,
+    1,
+    n,
+    "ChallengeAssertX",
+    r
+  ), _(
+    a,
+    2,
+    l,
+    "ChallengeAssertY",
+    r
+  );
+  const d = [
+    u.outs[0],
+    n.outs[0],
+    l.outs[0]
+  ].map((h) => ({
+    script_pubkey: K(new Uint8Array(h.script)),
+    value: h.value
+  }));
+  return ne({
+    noPayoutTxHex: t.nopayout_tx.tx_hex,
+    challengerPubkey: r,
+    prevouts: d,
+    connectorParams: {
+      claimer: o,
+      localChallengers: i,
+      universalChallengers: s.universalChallengerBtcPubkeys,
+      timelockAssert: s.timelockAssert,
+      councilMembers: s.councilMembers,
+      councilQuorum: s.councilQuorum
+    }
+  });
+}
+function me(e, t, r) {
+  const o = v(
     e[0],
     r
   ), i = {};
-  for (const c of t)
-    i[c.challengerPubkey] = {
-      nopayout_signature: w(
-        e[c.noPayoutIdx],
+  for (const u of t)
+    i[u.challengerPubkey] = {
+      nopayout_signature: v(
+        e[u.noPayoutIdx],
         r
       )
     };
@@ -229,7 +328,7 @@ function ye(e, t, r) {
     per_challenger: i
   };
 }
-async function Pe(e, t, r) {
+async function ve(e, t, r) {
   if (typeof e.signPsbts == "function")
     return e.signPsbts(t, r);
   const o = [];
@@ -237,30 +336,34 @@ async function Pe(e, t, r) {
     o.push(await e.signPsbt(t[i], r == null ? void 0 : r[i]));
   return o;
 }
-async function we(e) {
-  const { depositorGraph: t, depositorBtcPubkey: r, btcWallet: o } = e, i = l(r), c = await o.getPublicKeyHex(), { psbtHexes: a, signOptions: s, challengerEntries: n } = be(t, c), u = await Pe(
-    o,
-    a,
-    s
+async function ke(e) {
+  const { depositorGraph: t, btcWallet: r, signingContext: o } = e, i = c(o.depositorBtcPubkey), u = await r.getPublicKeyHex(), { psbtHexes: s, signOptions: a, challengerEntries: n } = await xe(
+    t,
+    u,
+    o
+  ), l = await ve(
+    r,
+    s,
+    a
   );
-  if (u.length !== a.length)
+  if (l.length !== s.length)
     throw new Error(
-      `Wallet returned ${u.length} signed PSBTs, expected ${a.length}`
+      `Wallet returned ${l.length} signed PSBTs, expected ${s.length}`
     );
-  return ye(
-    u,
+  return me(
+    l,
     n,
     i
   );
 }
-class xe {
+class Te {
   /**
    * Creates a new PayoutManager instance.
    *
    * @param config - Manager configuration including wallet
    */
   constructor(t) {
-    y(this, "config");
+    x(this, "config");
     this.config = t;
   }
   /**
@@ -290,10 +393,10 @@ class xe {
       t.payoutTxHex,
       t.registeredPayoutScriptPubKey
     );
-    const r = await this.config.btcWallet.getPublicKeyHex(), { depositorPubkey: o } = A(
+    const r = await this.config.btcWallet.getPublicKeyHex(), { depositorPubkey: o } = H(
       r,
       t.depositorBtcPubkey
-    ), i = await I({
+    ), i = await S({
       payoutTxHex: t.payoutTxHex,
       peginTxHex: t.peginTxHex,
       assertTxHex: t.assertTxHex,
@@ -303,12 +406,12 @@ class xe {
       universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys,
       timelockPegin: t.timelockPegin,
       network: this.config.network
-    }), c = await this.config.btcWallet.signPsbt(
+    }), u = await this.config.btcWallet.signPsbt(
       i.psbtHex,
       b(r, 1)
     );
     return {
-      signature: w(c, o),
+      signature: v(u, o),
       depositorBtcPubkey: o
     };
   }
@@ -342,22 +445,22 @@ class xe {
       throw new Error(
         "Wallet does not support batch signing (signPsbts method not available)"
       );
-    const r = await this.config.btcWallet.getPublicKeyHex(), o = [], i = [], c = [];
+    const r = await this.config.btcWallet.getPublicKeyHex(), o = [], i = [], u = [];
     for (const n of t) {
       this.validatePayoutOutputs(
         n.payoutTxHex,
         n.registeredPayoutScriptPubKey
       );
-      const { depositorPubkey: u } = A(
+      const { depositorPubkey: l } = H(
         r,
         n.depositorBtcPubkey
       );
-      c.push(u);
-      const d = await I({
+      u.push(l);
+      const d = await S({
         payoutTxHex: n.payoutTxHex,
         peginTxHex: n.peginTxHex,
         assertTxHex: n.assertTxHex,
-        depositorBtcPubkey: u,
+        depositorBtcPubkey: l,
         vaultProviderBtcPubkey: n.vaultProviderBtcPubkey,
         vaultKeeperBtcPubkeys: n.vaultKeeperBtcPubkeys,
         universalChallengerBtcPubkeys: n.universalChallengerBtcPubkeys,
@@ -366,26 +469,26 @@ class xe {
       });
       o.push(d.psbtHex), i.push(b(r, 1));
     }
-    const a = await this.config.btcWallet.signPsbts(
+    const s = await this.config.btcWallet.signPsbts(
       o,
       i
     );
-    if (a.length !== t.length)
+    if (s.length !== t.length)
       throw new Error(
-        `Expected ${t.length} signed PSBTs but received ${a.length}`
+        `Expected ${t.length} signed PSBTs but received ${s.length}`
       );
-    const s = [];
+    const a = [];
     for (let n = 0; n < t.length; n++) {
-      const u = c[n], d = w(
-        a[n],
-        u
+      const l = u[n], d = v(
+        s[n],
+        l
       );
-      s.push({
+      a.push({
         payoutSignature: d,
-        depositorBtcPubkey: u
+        depositorBtcPubkey: l
       });
     }
-    return s;
+    return a;
   }
   /**
    * Validates that the payout transaction's largest output pays to the
@@ -402,64 +505,52 @@ class xe {
    * @throws Error if the largest output does not pay to the registered address
    */
   validatePayoutOutputs(t, r) {
-    if (!J(r))
-      throw new Error(
-        "Invalid registeredPayoutScriptPubKey: not valid hex"
-      );
-    const o = V.from(
-      l(r),
-      "hex"
-    ), i = te.fromHex(l(t));
-    if (i.outs.length === 0)
-      throw new Error("Payout transaction has no outputs");
-    if (!i.outs.reduce(
-      (a, s) => s.value > a.value ? s : a
-    ).script.equals(o))
-      throw new Error(
-        "Payout transaction does not pay to the registered depositor payout address"
-      );
+    V(
+      t,
+      r
+    );
   }
 }
-const me = 1200 * 1e3, K = /* @__PURE__ */ new Set([
-  g.PENDING_ACKS,
-  g.PENDING_ACTIVATION,
-  g.ACTIVATED
-]), Te = /* @__PURE__ */ new Set([
-  g.PENDING_DEPOSITOR_SIGNATURES,
-  ...K
+const Ee = 1200 * 1e3, M = /* @__PURE__ */ new Set([
+  y.PENDING_ACKS,
+  y.PENDING_ACTIVATION,
+  y.ACTIVATED
+]), _e = /* @__PURE__ */ new Set([
+  y.PENDING_DEPOSITOR_SIGNATURES,
+  ...M
 ]);
-function ve(e) {
+function Be(e) {
   return e.map((t) => ({
-    claimerPubkeyXOnly: P(t.claimer_pubkey),
+    claimerPubkeyXOnly: m(t.claimer_pubkey),
     payoutTxHex: t.payout_tx.tx_hex,
     assertTxHex: t.assert_tx.tx_hex
   }));
 }
-function Ee(e) {
+function Se(e) {
   const { output: t } = ee.payments.p2tr({
-    internalPubkey: V.from(e, "hex")
+    internalPubkey: re.from(e, "hex")
   });
   if (!t)
     throw new Error("Failed to derive BIP-86 P2TR scriptPubKey");
   return t.toString("hex");
 }
-function ke(e, t) {
-  const r = l(e).toLowerCase(), o = l(
+function Ae(e, t) {
+  const r = c(e).toLowerCase(), o = c(
     t.vaultProviderBtcPubkey
-  ).toLowerCase(), i = l(
+  ).toLowerCase(), i = c(
     t.depositorBtcPubkey
   ).toLowerCase();
   if (r === o || r === i)
     return t.registeredPayoutScriptPubKey;
   if (!t.vaultKeeperBtcPubkeys.some(
-    (s) => l(s).toLowerCase() === r
+    (a) => c(a).toLowerCase() === r
   ))
     throw new Error(
       `Unknown claimer pubkey ${r}: not VP, depositor, or a registered vault keeper`
     );
-  return `0x${Ee(r)}`;
+  return `0x${Se(r)}`;
 }
-function C(e, t) {
+function R(e, t) {
   return {
     payoutTxHex: e.payoutTxHex,
     peginTxHex: t.peginTxHex,
@@ -469,110 +560,122 @@ function C(e, t) {
     universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys,
     depositorBtcPubkey: t.depositorBtcPubkey,
     timelockPegin: t.timelockPegin,
-    registeredPayoutScriptPubKey: ke(
+    registeredPayoutScriptPubKey: Ae(
       e.claimerPubkeyXOnly,
       t
     )
   };
 }
-async function Se(e, t, r, o) {
-  const i = new xe({
+async function Ce(e, t, r, o) {
+  const i = new Te({
     network: t.network,
     btcWallet: e
-  }), c = r.length;
-  o == null || o(0, c);
-  let a;
+  }), u = r.length;
+  o == null || o(0, u);
+  let s;
   if (i.supportsBatchSigning())
-    a = (await i.signPayoutTransactionsBatch(
-      r.map((u) => C(u, t))
-    )).map((u) => u.payoutSignature);
+    s = (await i.signPayoutTransactionsBatch(
+      r.map((l) => R(l, t))
+    )).map((l) => l.payoutSignature);
   else {
-    a = [];
+    s = [];
     for (let n = 0; n < r.length; n++) {
-      o == null || o(n, c);
-      const u = await i.signPayoutTransaction(
-        C(r[n], t)
+      o == null || o(n, u);
+      const l = await i.signPayoutTransaction(
+        R(r[n], t)
       );
-      a.push(u.signature);
+      s.push(l.signature);
     }
   }
-  const s = {};
+  const a = {};
   for (let n = 0; n < r.length; n++)
-    s[r[n].claimerPubkeyXOnly] = {
-      payout_signature: a[n]
+    a[r[n].claimerPubkeyXOnly] = {
+      payout_signature: s[n]
     };
-  return o == null || o(c, c), s;
+  return o == null || o(u, u), a;
 }
-async function et(e) {
+async function nt(e) {
   const {
     statusReader: t,
     presignClient: r,
     btcWallet: o,
     peginTxid: i,
-    depositorPk: c,
-    signingContext: a,
-    timeoutMs: s = me,
+    depositorPk: u,
+    signingContext: s,
+    timeoutMs: a = Ee,
     signal: n,
-    onProgress: u
+    onProgress: l
   } = e, d = await D({
     statusReader: t,
     peginTxid: i,
-    targetStatuses: Te,
-    timeoutMs: s,
+    targetStatuses: _e,
+    timeoutMs: a,
     signal: n
   });
-  if (K.has(d))
+  if (M.has(d))
     return;
   n == null || n.throwIfAborted();
   const h = await r.requestDepositorPresignTransactions(
     {
       pegin_txid: i,
-      depositor_pk: c
+      depositor_pk: u
     },
     n
   );
   n == null || n.throwIfAborted();
-  const x = P(c), m = h.txs.filter(
-    (z) => P(z.claimer_pubkey) !== x
-  ), T = ve(m), v = await Se(
+  const g = m(u), P = h.txs.filter(
+    (X) => m(X.claimer_pubkey) !== g
+  ), k = Be(P), T = await Ce(
     o,
-    a,
-    T,
-    u
+    s,
+    k,
+    l
   );
   n == null || n.throwIfAborted();
-  const p = await we({
+  const p = await ke({
     depositorGraph: h.depositor_graph,
-    depositorBtcPubkey: c,
-    btcWallet: o
+    btcWallet: o,
+    signingContext: {
+      peginTxHex: s.peginTxHex,
+      depositorBtcPubkey: u,
+      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
+    }
   });
   n == null || n.throwIfAborted();
-  const _ = { ...v };
-  _[l(c)] = p.payout_signatures, await r.submitDepositorPresignatures(
+  const C = { ...T };
+  C[c(u)] = p.payout_signatures, await r.submitDepositorPresignatures(
     {
       pegin_txid: i,
-      depositor_pk: c,
-      signatures: _,
+      depositor_pk: u,
+      signatures: C,
       depositor_claimer_presignatures: p
     },
     n
   );
 }
-function Be(e) {
+function He(e) {
   return /^[0-9a-fA-F]{64}$/.test(e);
 }
-function tt(e) {
+function st(e) {
   const {
     amountSats: t,
     minDeposit: r,
     maxDeposit: o,
     btcBalance: i,
-    estimatedFeeSats: c,
-    depositorClaimValue: a
+    estimatedFeeSats: u,
+    depositorClaimValue: s
   } = e;
-  return !(t <= 0n || t < r || o && o > 0n && t > o || c == null || a == null || t + c + a > i);
+  return !(t <= 0n || t < r || o && o > 0n && t > o || u == null || s == null || t + u + s > i);
 }
-function rt(e, t, r) {
+function it(e, t, r) {
   return e <= 0n ? {
     valid: !1,
     error: "Deposit amount must be greater than zero"
@@ -584,7 +687,7 @@ function rt(e, t, r) {
     error: `Maximum deposit is ${f(r)} BTC`
   } : { valid: !0 };
 }
-function ot(e) {
+function at(e) {
   const { amount: t, effectiveRemaining: r } = e;
   return r === null ? { valid: !0 } : r === 0n ? {
     valid: !1,
@@ -594,7 +697,7 @@ function ot(e) {
     error: `Vault size exceeds remaining capacity (${f(r)} BTC)`
   } : { valid: !0 };
 }
-function nt(e, t) {
+function ut(e, t) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -610,7 +713,7 @@ function nt(e, t) {
     error: "Invalid vault provider selected"
   } : { valid: !0 };
 }
-function _e(e, t, r) {
+function $e(e, t, r) {
   if (!e || e.length === 0)
     return {
       valid: !1,
@@ -636,98 +739,98 @@ function _e(e, t, r) {
   }
   return { valid: !0 };
 }
-function Ae(e) {
-  const t = l(e);
-  return Be(t) ? { valid: !0 } : {
+function Ie(e) {
+  const t = c(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 Re(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 Ne(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 Re(e) {
+function Oe(e) {
   if (e.length === 0)
     throw new Error("No spendable UTXOs available");
 }
-function it(e) {
+function lt(e) {
   const {
     vaultAmounts: t,
     confirmedUTXOs: r,
     vaultProviderBtcPubkey: o,
     vaultKeeperBtcPubkeys: i,
-    universalChallengerBtcPubkeys: c,
-    minDeposit: a,
-    maxDeposit: s
-  } = e, n = _e(
+    universalChallengerBtcPubkeys: u,
+    minDeposit: s,
+    maxDeposit: a
+  } = e, n = $e(
     t,
-    a,
-    s
+    s,
+    a
   );
   if (!n.valid)
     throw new Error(n.error);
-  const u = Ae(o);
-  if (!u.valid)
-    throw new Error(u.error);
-  Ie(i), He(c), Re(r);
+  const l = Ie(o);
+  if (!l.valid)
+    throw new Error(l.error);
+  Re(i), Ne(u), Oe(r);
 }
 var U = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.CHALLENGE_ASSERT_OBSERVED = "ChallengeAssertObserved", e.WRONGLY_CHALLENGED_BROADCAST = "WronglyChallengedBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.FAILED = "Failed", e))(U || {});
-const $e = /* @__PURE__ */ new Set([
+const Ke = /* @__PURE__ */ new Set([
   "PayoutBroadcast",
   "Failed"
   /* FAILED */
 ]);
-function st(e) {
+function ct(e) {
   return Object.values(U).includes(
     e
   );
 }
-function at(e) {
-  return !!e && $e.has(e);
+function dt(e) {
+  return !!e && Ke.has(e);
 }
-class Ce extends Error {
+class Ve extends Error {
   constructor(r, o) {
     super(`Refund not yet mature (BIP68 not final): ${o.message}`);
-    y(this, "vaultId");
-    y(this, "cause");
+    x(this, "vaultId");
+    x(this, "cause");
     this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = o;
   }
 }
-const Oe = /^0x[0-9a-fA-F]{64}$/, Ne = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, F = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, Ve = 160, Le = 1, O = 65535, De = /non-BIP68-final/i;
-function M(e, t) {
+const Le = /^0x[0-9a-fA-F]{64}$/, De = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, F = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, Me = 160, Ue = 1, N = 65535, Fe = /non-BIP68-final/i;
+function W(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 (!Oe.test(e))
+  if (!Le.test(e))
     throw new Error(
       `${t} must contain only hex characters after the 0x prefix`
     );
 }
-function k(e, t) {
+function B(e, t) {
   if (!Number.isInteger(e) || e < 0)
     throw new Error(`${t} must be a non-negative integer, got ${e}`);
 }
-function Ke(e) {
-  if (M(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0 || e.htlcVout > O)
+function We(e) {
+  if (W(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0 || e.htlcVout > N)
     throw new Error(
-      `htlcVout must be an integer 0-${O}, got ${e.htlcVout}`
+      `htlcVout must be an integer 0-${N}, got ${e.htlcVout}`
     );
-  if (k(e.offchainParamsVersion, "offchainParamsVersion"), k(e.appVaultKeepersVersion, "appVaultKeepersVersion"), k(
+  if (B(e.offchainParamsVersion, "offchainParamsVersion"), B(e.appVaultKeepersVersion, "appVaultKeepersVersion"), B(
     e.universalChallengersVersion,
     "universalChallengersVersion"
   ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
     throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!Ne.test(e.unsignedPrePeginTxHex))
+  if (!De.test(e.unsignedPrePeginTxHex))
     throw new Error(
       "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
     );
@@ -738,7 +841,7 @@ function Ke(e) {
   if (typeof e.amount != "bigint" || e.amount <= 0n)
     throw new Error(`amount must be a positive bigint, got ${e.amount}`);
 }
-function Ue(e) {
+function Xe(e) {
   if (!e.vaultProviderPubkey || !F.test(e.vaultProviderPubkey))
     throw new Error("vaultProviderPubkey must be 32 or 33 bytes of hex");
   if (e.vaultKeeperPubkeys.length === 0)
@@ -760,8 +863,8 @@ function Ue(e) {
       `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
     );
 }
-function Fe(e) {
-  const t = B.fromHex(e);
+function ze(e) {
+  const t = te.fromHex(e);
   try {
     t.finalizeAllInputs();
   } catch (r) {
@@ -771,82 +874,82 @@ function Fe(e) {
   }
   return t.extractTransaction().toHex();
 }
-async function ut(e) {
+async function ht(e) {
   const {
     vaultId: t,
     readVault: r,
     readPrePeginContext: o,
     feeRate: i,
-    signPsbt: c,
-    broadcastTx: a,
-    signal: s
+    signPsbt: u,
+    broadcastTx: s,
+    signal: a
   } = e;
-  s == null || s.throwIfAborted(), M(t, "vaultId");
+  a == null || a.throwIfAborted(), W(t, "vaultId");
   const n = await r();
-  Ke(n), s == null || s.throwIfAborted();
-  const u = await o(n);
-  if (Ue(u), s == null || s.throwIfAborted(), !Number.isFinite(i) || i <= 0)
+  We(n), a == null || a.throwIfAborted();
+  const l = await o(n);
+  if (Xe(l), a == null || a.throwIfAborted(), !Number.isFinite(i) || i <= 0)
     throw new Error(`feeRate must be a positive number, got ${i}`);
-  const d = BigInt(Math.ceil(i * Ve));
-  s == null || s.throwIfAborted();
-  const h = P(
+  const d = BigInt(Math.ceil(i * Me));
+  a == null || a.throwIfAborted();
+  const h = m(
     n.depositorBtcPubkey
-  ), { psbtHex: x } = await re({
+  ), { psbtHex: g } = await se({
     prePeginParams: {
       depositorPubkey: h,
-      vaultProviderPubkey: l(u.vaultProviderPubkey),
-      vaultKeeperPubkeys: u.vaultKeeperPubkeys.map(l),
-      universalChallengerPubkeys: u.universalChallengerPubkeys.map(l),
-      hashlocks: [l(n.hashlock)],
-      timelockRefund: u.timelockRefund,
+      vaultProviderPubkey: c(l.vaultProviderPubkey),
+      vaultKeeperPubkeys: l.vaultKeeperPubkeys.map(c),
+      universalChallengerPubkeys: l.universalChallengerPubkeys.map(c),
+      hashlocks: [c(n.hashlock)],
+      timelockRefund: l.timelockRefund,
       pegInAmounts: [n.amount],
-      feeRate: u.feeRate,
-      numLocalChallengers: u.numLocalChallengers,
-      councilQuorum: u.councilQuorum,
-      councilSize: u.councilSize,
-      network: u.network
+      feeRate: l.feeRate,
+      numLocalChallengers: l.numLocalChallengers,
+      councilQuorum: l.councilQuorum,
+      councilSize: l.councilSize,
+      network: l.network
     },
-    fundedPrePeginTxHex: l(n.unsignedPrePeginTxHex),
+    fundedPrePeginTxHex: c(n.unsignedPrePeginTxHex),
     htlcVout: n.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: l(n.hashlock)
+    hashlock: c(n.hashlock)
   });
-  s == null || s.throwIfAborted();
-  const m = b(
+  a == null || a.throwIfAborted();
+  const P = b(
     n.depositorBtcPubkey,
-    Le
-  ), T = await c(x, m), v = Fe(T);
-  s == null || s.throwIfAborted();
+    Ue
+  ), k = await u(g, P), T = ze(k);
+  a == null || a.throwIfAborted();
   try {
-    return await a(v);
+    return await s(T);
   } catch (p) {
-    throw p instanceof Error && De.test(p.message) ? new Ce(t, p) : p;
+    throw p instanceof Error && Fe.test(p.message) ? new Ve(t, p) : p;
   }
 }
 export {
-  Ce as B,
+  Ve as B,
   U as C,
-  xe as P,
-  Je as a,
-  we as b,
-  ot as c,
-  nt as d,
-  _e as e,
-  Ae as f,
-  it as g,
-  ne as h,
-  tt as i,
-  ie as j,
-  st as k,
-  at as l,
-  ut as m,
-  et as p,
-  Ze as s,
-  rt as v,
+  Te as P,
+  rt as a,
+  ke as b,
+  at as c,
+  ut as d,
+  $e as e,
+  Ie as f,
+  lt as g,
+  ae as h,
+  st as i,
+  ue as j,
+  ct as k,
+  dt as l,
+  ht as m,
+  nt as p,
+  ot as s,
+  it as v,
   D as w
 };
-//# sourceMappingURL=buildAndBroadcastRefund-xWS8frc6.js.map
+//# sourceMappingURL=buildAndBroadcastRefund-BY6mYmFl.js.map