@babylonlabs-io/ts-sdk 0.33.3 → 0.33.5

package/dist/buildAndBroadcastRefund-Dx09Zbla.js

@@ -1,965 +0,0 @@
-var G = Object.defineProperty;
-var Q = (e, t, r) => t in e ? G(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var x = (e, t, r) => Q(e, typeof t != "symbol" ? t + "" : t, r);
-import { B as Y, c as j, a as q, R as J, d as O, D as y } from "./types-SYvSQWnc.js";
-import { e as Z, s as l, u as K, v as H, p as w, f } from "./bitcoin-B0S8SHCX.js";
-import { s as ee } from "./sha2-6wN58S6R.js";
-import * as te from "bitcoinjs-lib";
-import { Transaction as m, Psbt as re } from "bitcoinjs-lib";
-import { Buffer as oe } from "buffer";
-import { c as b } from "./signing-BZigafm0.js";
-import "@babylonlabs-io/babylon-tbv-rust-wasm";
-import { a as V, c as S, e as v, g as ne, d as se, b as ie } from "./noPayout-BnsetBKW.js";
-const $ = 66;
-function L(e) {
-  if (!e.startsWith("0x") && !e.startsWith("0X"))
-    throw new Error("Expected 0x-prefixed hex string");
-  const t = e.slice(2);
-  if (t.length % 2 !== 0)
-    throw new Error(`Hex string has odd length: ${t.length}`);
-  if (!/^[0-9a-fA-F]*$/.test(t))
-    throw new Error("Hex string contains non-hex characters");
-  const r = new Uint8Array(t.length / 2);
-  for (let o = 0; o < r.length; o++)
-    r[o] = parseInt(t.slice(o * 2, o * 2 + 2), 16);
-  return r;
-}
-function ae(e) {
-  return `0x${Array.from(e).map((t) => t.toString(16).padStart(2, "0")).join("")}`;
-}
-function A(e, t) {
-  if (e.length !== $)
-    throw new Error(
-      `${t} must be exactly 32 bytes (${$} hex chars with 0x prefix), got ${e.length}`
-    );
-}
-function ue(e) {
-  A(e, "Secret");
-  const t = L(e), r = ee(t);
-  return ae(r);
-}
-function ce(e, t) {
-  return A(e, "Secret"), A(t, "Hashlock"), L(t), ue(e).toLowerCase() === t.toLowerCase();
-}
-const le = /^0x[0-9a-fA-F]{64}$/, he = /^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 (!le.test(e))
-    throw new Error(
-      `${t} must contain only hex characters after the 0x prefix`
-    );
-}
-function pe(e, t) {
-  if (!he.test(e))
-    throw new Error(
-      `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
-    );
-}
-function fe(e, t) {
-  if (!de.test(e))
-    throw new Error(
-      `${t} must be a 0x-prefixed hex string with an even number of hex chars`
-    );
-}
-async function rt(e) {
-  const {
-    btcVaultRegistryAddress: t,
-    vaultId: r,
-    hashlock: o,
-    activationMetadata: i,
-    writeContract: u,
-    signal: s
-  } = e;
-  s == null || s.throwIfAborted(), pe(t, "btcVaultRegistryAddress"), E(r, "vaultId");
-  const a = Z(e.secret);
-  if (E(a, "secret"), o !== void 0 && (E(o, "hashlock"), !ce(a, o)))
-    throw new Error(
-      "Invalid secret: SHA256(secret) does not match the provided hashlock"
-    );
-  return fe(i, "activationMetadata"), u({
-    address: t,
-    abi: Y,
-    functionName: "activateVaultWithSecret",
-    args: [r, a, i]
-  });
-}
-const ge = 1e4;
-async function D(e) {
-  const {
-    statusReader: t,
-    peginTxid: r,
-    targetStatuses: o,
-    timeoutMs: i,
-    pollIntervalMs: u = ge,
-    signal: s
-  } = e, a = Date.now();
-  for (; ; ) {
-    if (s != null && s.aborted)
-      throw new Error(
-        `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
-      );
-    if (Date.now() - a >= i)
-      throw new Error(
-        `Polling timeout after ${i}ms for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
-      );
-    try {
-      const c = (await t.getPeginStatus(
-        { pegin_txid: r },
-        s
-      )).status;
-      if (o.has(c))
-        return c;
-      if (j.has(c) && !o.has(c))
-        throw new Error(
-          `Pegin ${r.slice(0, 8)}… reached terminal status "${c}" while waiting for ${[...o].join(", ")}`
-        );
-    } catch (n) {
-      if (!(n instanceof q && n.code === J.NOT_FOUND || n instanceof Error && n.message.includes("PegIn not found")))
-        throw n;
-    }
-    await new Promise((n, c) => {
-      const h = () => {
-        clearTimeout(d), c(
-          new Error(
-            `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
-          )
-        );
-      }, d = setTimeout(() => {
-        s == null || s.removeEventListener("abort", h), n();
-      }, u);
-      s == null || s.addEventListener("abort", h, { once: !0 });
-    });
-  }
-}
-const Pe = 300 * 1e3, ye = /* @__PURE__ */ new Set([
-  y.PENDING_DEPOSITOR_WOTS_PK,
-  ...O
-]);
-async function ot(e) {
-  const {
-    statusReader: t,
-    wotsSubmitter: r,
-    peginTxid: o,
-    depositorPk: i,
-    wotsPublicKeys: u,
-    timeoutMs: s = Pe,
-    signal: a
-  } = e;
-  a == null || a.throwIfAborted();
-  const n = await D({
-    statusReader: t,
-    peginTxid: o,
-    targetStatuses: ye,
-    timeoutMs: s,
-    signal: a
-  });
-  O.has(n) || (a == null || a.throwIfAborted(), await r.submitDepositorWotsKey(
-    {
-      pegin_txid: o,
-      depositor_pk: i,
-      wots_public_keys: u
-    },
-    a
-  ));
-}
-const I = 1;
-function be(e, t, r) {
-  const o = l(r).toLowerCase(), u = [e, ...t].map(
-    (s) => l(s).toLowerCase()
-  ).filter((s) => s !== o);
-  if (u.length === 0)
-    throw new Error(
-      "Cannot derive localChallengers: removing depositor from {vaultProvider, vaultKeepers} left an empty set"
-    );
-  return u;
-}
-function xe(e, t) {
-  const r = e.ins[t];
-  return K(new Uint8Array(r.hash).slice().reverse());
-}
-function B(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 = xe(e, t);
-  if (a !== s)
-    throw new Error(
-      `NoPayout (challenger ${i}) input ${t} does not reference ${o} (expected txid ${s}, got ${a})`
-    );
-}
-async function me(e, t, r) {
-  const o = [], i = [], u = [];
-  V(
-    e.payout_tx.tx_hex,
-    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
-    )
-  );
-  const a = be(
-    r.vaultProviderBtcPubkey,
-    r.vaultKeeperBtcPubkeys,
-    r.depositorBtcPubkey
-  ), n = l(r.depositorBtcPubkey), c = m.fromHex(
-    l(e.assert_tx.tx_hex)
-  );
-  for (const h of e.challenger_presign_data) {
-    const d = l(h.challenger_pubkey), g = o.length, P = await we({
-      challenger: h,
-      challengerPubkey: d,
-      claimerPubkey: n,
-      localChallengers: a,
-      assertTxParsed: c,
-      ctx: r
-    });
-    o.push(P), i.push(
-      b(
-        t,
-        I
-      )
-    ), u.push({
-      challengerPubkey: d,
-      noPayoutIdx: g
-    });
-  }
-  return { psbtHexes: o, signOptions: i, challengerEntries: u };
-}
-async function we(e) {
-  const {
-    challenger: t,
-    challengerPubkey: r,
-    claimerPubkey: o,
-    localChallengers: i,
-    assertTxParsed: u,
-    ctx: s
-  } = e;
-  ne(
-    t.nopayout_tx.tx_hex,
-    r,
-    s.network
-  );
-  const a = m.fromHex(
-    l(t.nopayout_tx.tx_hex)
-  ), n = m.fromHex(
-    l(t.challenge_assert_x_tx.tx_hex)
-  ), c = m.fromHex(
-    l(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}`
-    );
-  B(
-    a,
-    0,
-    u,
-    "Assert",
-    r
-  ), B(
-    a,
-    1,
-    n,
-    "ChallengeAssertX",
-    r
-  ), B(
-    a,
-    2,
-    c,
-    "ChallengeAssertY",
-    r
-  );
-  const h = [
-    u.outs[0],
-    n.outs[0],
-    c.outs[0]
-  ].map((d) => ({
-    script_pubkey: K(new Uint8Array(d.script)),
-    value: d.value
-  }));
-  return se({
-    noPayoutTxHex: t.nopayout_tx.tx_hex,
-    challengerPubkey: r,
-    prevouts: h,
-    connectorParams: {
-      claimer: o,
-      localChallengers: i,
-      universalChallengers: s.universalChallengerBtcPubkeys,
-      timelockAssert: s.timelockAssert,
-      councilMembers: s.councilMembers,
-      councilQuorum: s.councilQuorum
-    }
-  });
-}
-function ve(e, t, r) {
-  const o = v(
-    e[0],
-    r
-  ), i = {};
-  for (const u of t)
-    i[u.challengerPubkey] = {
-      nopayout_signature: v(
-        e[u.noPayoutIdx],
-        r
-      )
-    };
-  return {
-    payout_signatures: {
-      payout_signature: o
-    },
-    per_challenger: i
-  };
-}
-async function ke(e, t, r) {
-  if (typeof e.signPsbts == "function")
-    return e.signPsbts(t, r);
-  const o = [];
-  for (let i = 0; i < t.length; i++)
-    o.push(await e.signPsbt(t[i], r == null ? void 0 : r[i]));
-  return o;
-}
-async function Te(e) {
-  const { depositorGraph: t, btcWallet: r, signingContext: o } = e, i = l(o.depositorBtcPubkey), u = await r.getPublicKeyHex(), { psbtHexes: s, signOptions: a, challengerEntries: n } = await me(
-    t,
-    u,
-    o
-  ), c = await ke(
-    r,
-    s,
-    a
-  );
-  if (c.length !== s.length)
-    throw new Error(
-      `Wallet returned ${c.length} signed PSBTs, expected ${s.length}`
-    );
-  return ve(
-    c,
-    n,
-    i
-  );
-}
-class Ee {
-  /**
-   * Creates a new PayoutManager instance.
-   *
-   * @param config - Manager configuration including wallet
-   */
-  constructor(t) {
-    x(this, "config");
-    this.config = t;
-  }
-  /**
-   * Signs a Payout transaction and extracts the Schnorr signature.
-   *
-   * Flow:
-   * 1. Vault provider submits Claim transaction
-   * 2. Claimer submits Assert transaction to prove validity
-   * 3. Payout can be executed (references Assert tx)
-   *
-   * This method orchestrates the following steps:
-   * 1. Get wallet's public key and convert to x-only format
-   * 2. Validate wallet pubkey matches on-chain depositor pubkey (if provided)
-   * 3. Build unsigned PSBT using primitives
-   * 4. Sign PSBT via btcWallet.signPsbt()
-   * 5. Extract 64-byte Schnorr signature using primitives
-   *
-   * The returned signature can be submitted to the vault provider API.
-   *
-   * @param params - Payout signing parameters
-   * @returns Signature result with 64-byte Schnorr signature and depositor pubkey
-   * @throws Error if wallet pubkey doesn't match depositor pubkey
-   * @throws Error if wallet operations fail or signature extraction fails
-   */
-  async signPayoutTransaction(t) {
-    this.validatePayoutOutputs(
-      t.payoutTxHex,
-      t.registeredPayoutScriptPubKey
-    );
-    const r = await this.config.btcWallet.getPublicKeyHex(), { depositorPubkey: o } = H(
-      r,
-      t.depositorBtcPubkey
-    ), i = await S({
-      payoutTxHex: t.payoutTxHex,
-      peginTxHex: t.peginTxHex,
-      assertTxHex: t.assertTxHex,
-      depositorBtcPubkey: o,
-      vaultProviderBtcPubkey: t.vaultProviderBtcPubkey,
-      vaultKeeperBtcPubkeys: t.vaultKeeperBtcPubkeys,
-      universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys,
-      timelockPegin: t.timelockPegin,
-      network: this.config.network
-    }), u = await this.config.btcWallet.signPsbt(
-      i.psbtHex,
-      b(r, 1)
-    );
-    return {
-      signature: v(u, o),
-      depositorBtcPubkey: o
-    };
-  }
-  /**
-   * Gets the configured Bitcoin network.
-   *
-   * @returns The Bitcoin network (mainnet, testnet, signet, regtest)
-   */
-  getNetwork() {
-    return this.config.network;
-  }
-  /**
-   * Checks if the wallet supports batch signing (signPsbts).
-   *
-   * @returns true if batch signing is supported
-   */
-  supportsBatchSigning() {
-    return typeof this.config.btcWallet.signPsbts == "function";
-  }
-  /**
-   * Batch signs multiple payout transactions (1 per claimer).
-   * This allows signing all transactions with a single wallet interaction.
-   *
-   * @param transactions - Array of payout params to sign
-   * @returns Array of signature results matching input order
-   * @throws Error if wallet doesn't support batch signing
-   * @throws Error if any signing operation fails
-   */
-  async signPayoutTransactionsBatch(t) {
-    if (!this.supportsBatchSigning())
-      throw new Error(
-        "Wallet does not support batch signing (signPsbts method not available)"
-      );
-    const r = await this.config.btcWallet.getPublicKeyHex(), o = [], i = [], u = [];
-    for (const n of t) {
-      this.validatePayoutOutputs(
-        n.payoutTxHex,
-        n.registeredPayoutScriptPubKey
-      );
-      const { depositorPubkey: c } = H(
-        r,
-        n.depositorBtcPubkey
-      );
-      u.push(c);
-      const h = await S({
-        payoutTxHex: n.payoutTxHex,
-        peginTxHex: n.peginTxHex,
-        assertTxHex: n.assertTxHex,
-        depositorBtcPubkey: c,
-        vaultProviderBtcPubkey: n.vaultProviderBtcPubkey,
-        vaultKeeperBtcPubkeys: n.vaultKeeperBtcPubkeys,
-        universalChallengerBtcPubkeys: n.universalChallengerBtcPubkeys,
-        timelockPegin: n.timelockPegin,
-        network: this.config.network
-      });
-      o.push(h.psbtHex), i.push(b(r, 1));
-    }
-    const s = await this.config.btcWallet.signPsbts(
-      o,
-      i
-    );
-    if (s.length !== t.length)
-      throw new Error(
-        `Expected ${t.length} signed PSBTs but received ${s.length}`
-      );
-    const a = [];
-    for (let n = 0; n < t.length; n++) {
-      const c = u[n], h = v(
-        s[n],
-        c
-      );
-      a.push({
-        payoutSignature: h,
-        depositorBtcPubkey: c
-      });
-    }
-    return a;
-  }
-  /**
-   * Validates that the payout transaction's largest output pays to the
-   * registered depositor payout address (scriptPubKey).
-   *
-   * This prevents two attack vectors from a malicious vault provider:
-   * 1. Substituting a completely different payout address
-   * 2. Including a dust output to the correct address while routing
-   *    the actual funds to an attacker-controlled address
-   *
-   * @param payoutTxHex - Raw payout transaction hex
-   * @param registeredPayoutScriptPubKey - On-chain registered scriptPubKey (hex, with or without 0x prefix)
-   * @throws Error if scriptPubKey is invalid hex
-   * @throws Error if the largest output does not pay to the registered address
-   */
-  validatePayoutOutputs(t, r) {
-    V(
-      t,
-      r
-    );
-  }
-}
-const Be = 1200 * 1e3, M = /* @__PURE__ */ new Set([
-  y.PENDING_ACKS,
-  y.PENDING_ACTIVATION,
-  y.ACTIVATED
-]), _e = /* @__PURE__ */ new Set([
-  y.PENDING_DEPOSITOR_SIGNATURES,
-  ...M
-]);
-function Se(e) {
-  return e.map((t) => ({
-    claimerPubkeyXOnly: w(t.claimer_pubkey),
-    payoutTxHex: t.payout_tx.tx_hex,
-    assertTxHex: t.assert_tx.tx_hex
-  }));
-}
-function Ae(e) {
-  const { output: t } = te.payments.p2tr({
-    internalPubkey: oe.from(e, "hex")
-  });
-  if (!t)
-    throw new Error("Failed to derive BIP-86 P2TR scriptPubKey");
-  return t.toString("hex");
-}
-function Ce(e, t) {
-  const r = l(e).toLowerCase(), o = l(
-    t.vaultProviderBtcPubkey
-  ).toLowerCase(), i = l(
-    t.depositorBtcPubkey
-  ).toLowerCase();
-  if (r === o || r === i)
-    return t.registeredPayoutScriptPubKey;
-  if (!t.vaultKeeperBtcPubkeys.some(
-    (a) => l(a).toLowerCase() === r
-  ))
-    throw new Error(
-      `Unknown claimer pubkey ${r}: not VP, depositor, or a registered vault keeper`
-    );
-  return `0x${Ae(r)}`;
-}
-function R(e, t) {
-  return {
-    payoutTxHex: e.payoutTxHex,
-    peginTxHex: t.peginTxHex,
-    assertTxHex: e.assertTxHex,
-    vaultProviderBtcPubkey: t.vaultProviderBtcPubkey,
-    vaultKeeperBtcPubkeys: t.vaultKeeperBtcPubkeys,
-    universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys,
-    depositorBtcPubkey: t.depositorBtcPubkey,
-    timelockPegin: t.timelockPegin,
-    registeredPayoutScriptPubKey: Ce(
-      e.claimerPubkeyXOnly,
-      t
-    )
-  };
-}
-async function He(e, t, r, o) {
-  const i = new Ee({
-    network: t.network,
-    btcWallet: e
-  }), u = r.length;
-  o == null || o(0, u);
-  let s;
-  if (i.supportsBatchSigning())
-    s = (await i.signPayoutTransactionsBatch(
-      r.map((c) => R(c, t))
-    )).map((c) => c.payoutSignature);
-  else {
-    s = [];
-    for (let n = 0; n < r.length; n++) {
-      o == null || o(n, u);
-      const c = await i.signPayoutTransaction(
-        R(r[n], t)
-      );
-      s.push(c.signature);
-    }
-  }
-  const a = {};
-  for (let n = 0; n < r.length; n++)
-    a[r[n].claimerPubkeyXOnly] = {
-      payout_signature: s[n]
-    };
-  return o == null || o(u, u), a;
-}
-async function nt(e) {
-  const {
-    statusReader: t,
-    presignClient: r,
-    btcWallet: o,
-    peginTxid: i,
-    depositorPk: u,
-    signingContext: s,
-    timeoutMs: a = Be,
-    signal: n,
-    onProgress: c
-  } = e, h = await D({
-    statusReader: t,
-    peginTxid: i,
-    targetStatuses: _e,
-    timeoutMs: a,
-    signal: n
-  });
-  if (M.has(h))
-    return;
-  n == null || n.throwIfAborted();
-  const d = await r.requestDepositorPresignTransactions(
-    {
-      pegin_txid: i,
-      depositor_pk: u
-    },
-    n
-  );
-  n == null || n.throwIfAborted();
-  const g = w(u), P = d.txs.filter(
-    (z) => w(z.claimer_pubkey) !== g
-  ), k = Se(P), T = await He(
-    o,
-    s,
-    k,
-    c
-  );
-  n == null || n.throwIfAborted();
-  const p = await Te({
-    depositorGraph: d.depositor_graph,
-    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 C = { ...T };
-  C[l(u)] = p.payout_signatures, await r.submitDepositorPresignatures(
-    {
-      pegin_txid: i,
-      depositor_pk: u,
-      signatures: C,
-      depositor_claimer_presignatures: p
-    },
-    n
-  );
-}
-function $e(e) {
-  return /^[0-9a-fA-F]{64}$/.test(e);
-}
-function st(e) {
-  const {
-    amountSats: t,
-    minDeposit: r,
-    maxDeposit: o,
-    btcBalance: i,
-    estimatedFeeSats: u,
-    depositorClaimValue: s
-  } = e;
-  return !(t <= 0n || t < r || o && o > 0n && t > o || u == null || s == null || t + u + s > i);
-}
-function it(e, t, r) {
-  return e <= 0n ? {
-    valid: !1,
-    error: "Deposit amount must be greater than zero"
-  } : e < t ? {
-    valid: !1,
-    error: `Minimum deposit is ${f(t)} BTC`
-  } : r && r > 0n && e > r ? {
-    valid: !1,
-    error: `Maximum deposit is ${f(r)} BTC`
-  } : { valid: !0 };
-}
-function at(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 (${f(r)} BTC)`
-  } : { valid: !0 };
-}
-function ut(e, t) {
-  if (!e || e.length === 0)
-    return {
-      valid: !1,
-      error: "At least one vault provider must be selected"
-    };
-  const r = t.map(
-    (i) => i.toLowerCase()
-  );
-  return e.filter(
-    (i) => !r.includes(i.toLowerCase())
-  ).length > 0 ? {
-    valid: !1,
-    error: "Invalid vault provider selected"
-  } : { valid: !0 };
-}
-function Ie(e, t, r) {
-  if (!e || e.length === 0)
-    return {
-      valid: !1,
-      error: "At least one vault amount required"
-    };
-  for (let o = 0; o < e.length; o++) {
-    const i = e[o];
-    if (i <= 0n)
-      return {
-        valid: !1,
-        error: `Vault ${o + 1} amount must be positive`
-      };
-    if (t && i < t)
-      return {
-        valid: !1,
-        error: `Vault ${o + 1} amount ${f(i)} BTC is below minimum deposit ${f(t)} BTC`
-      };
-    if (r && i > r)
-      return {
-        valid: !1,
-        error: `Vault ${o + 1} amount ${f(i)} BTC exceeds maximum deposit ${f(r)} BTC`
-      };
-  }
-  return { valid: !0 };
-}
-function Re(e) {
-  const t = l(e);
-  return $e(t) ? { valid: !0 } : {
-    valid: !1,
-    error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
-  };
-}
-function Ne(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 Oe(e) {
-  if (!e || e.length === 0)
-    throw new Error(
-      "No universal challengers available. The system requires at least one universal challenger to create a deposit."
-    );
-}
-function Ke(e) {
-  if (e.length === 0)
-    throw new Error("No spendable UTXOs available");
-}
-function ct(e) {
-  const {
-    vaultAmounts: t,
-    confirmedUTXOs: r,
-    vaultProviderBtcPubkey: o,
-    vaultKeeperBtcPubkeys: i,
-    universalChallengerBtcPubkeys: u,
-    minDeposit: s,
-    maxDeposit: a
-  } = e, n = Ie(
-    t,
-    s,
-    a
-  );
-  if (!n.valid)
-    throw new Error(n.error);
-  const c = Re(o);
-  if (!c.valid)
-    throw new Error(c.error);
-  Ne(i), Oe(u), Ke(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 Ve = /* @__PURE__ */ new Set([
-  "PayoutBroadcast",
-  "Failed"
-  /* FAILED */
-]);
-function lt(e) {
-  return Object.values(U).includes(
-    e
-  );
-}
-function ht(e) {
-  return !!e && Ve.has(e);
-}
-class Le extends Error {
-  constructor(r, o) {
-    super(`Refund not yet mature (BIP68 not final): ${o.message}`);
-    x(this, "vaultId");
-    x(this, "cause");
-    this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = o;
-  }
-}
-const De = /^0x[0-9a-fA-F]{64}$/, Me = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, F = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, W = 160;
-function dt(e) {
-  if (!Number.isFinite(e) || e <= 0)
-    throw new Error(
-      `feeRateSatsVb must be a positive finite number, got ${e}`
-    );
-  return BigInt(Math.ceil(e * W));
-}
-const Ue = 1, N = 65535, Fe = /non-BIP68-final/i;
-function X(e, t) {
-  if (e.length !== 66)
-    throw new Error(
-      `${t} must be 32 bytes (66 hex chars with 0x prefix), got length ${e.length}`
-    );
-  if (!De.test(e))
-    throw new Error(
-      `${t} must contain only hex characters after the 0x prefix`
-    );
-}
-function _(e, t) {
-  if (!Number.isInteger(e) || e < 0)
-    throw new Error(`${t} must be a non-negative integer, got ${e}`);
-}
-function We(e) {
-  if (X(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0 || e.htlcVout > N)
-    throw new Error(
-      `htlcVout must be an integer 0-${N}, got ${e.htlcVout}`
-    );
-  if (_(e.offchainParamsVersion, "offchainParamsVersion"), _(e.appVaultKeepersVersion, "appVaultKeepersVersion"), _(
-    e.universalChallengersVersion,
-    "universalChallengersVersion"
-  ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
-    throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!Me.test(e.unsignedPrePeginTxHex))
-    throw new Error(
-      "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
-    );
-  if (!e.depositorBtcPubkey || !F.test(e.depositorBtcPubkey))
-    throw new Error(
-      "depositorBtcPubkey must be 32 or 33 bytes of hex (optional 0x prefix)"
-    );
-  if (typeof e.amount != "bigint" || e.amount <= 0n)
-    throw new Error(`amount must be a positive bigint, got ${e.amount}`);
-}
-function Xe(e) {
-  if (!e.vaultProviderPubkey || !F.test(e.vaultProviderPubkey))
-    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");
-  if (e.universalChallengerPubkeys.length === 0)
-    throw new Error("universalChallengerPubkeys must be non-empty");
-  if (!Number.isInteger(e.timelockRefund) || e.timelockRefund <= 0)
-    throw new Error(
-      `timelockRefund must be a positive integer, got ${e.timelockRefund}`
-    );
-  if (typeof e.feeRate != "bigint" || e.feeRate <= 0n)
-    throw new Error(
-      `protocol feeRate must be a positive bigint, got ${e.feeRate}`
-    );
-  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)
-    throw new Error(
-      `councilQuorum (${e.councilQuorum}) must be in [1, councilSize=${e.councilSize}]`
-    );
-}
-function ze(e) {
-  const t = re.fromHex(e);
-  try {
-    t.finalizeAllInputs();
-  } catch (r) {
-    const o = r instanceof Error ? r.message : String(r);
-    if (!o.includes("already finalized"))
-      throw new Error(`Failed to finalize refund PSBT: ${o}`);
-  }
-  return t.extractTransaction().toHex();
-}
-async function pt(e) {
-  const {
-    vaultId: t,
-    readVault: r,
-    readPrePeginContext: o,
-    feeRate: i,
-    signPsbt: u,
-    broadcastTx: s,
-    signal: a
-  } = e;
-  a == null || a.throwIfAborted(), X(t, "vaultId");
-  const n = await r();
-  We(n), a == null || a.throwIfAborted();
-  const c = await o(n);
-  if (Xe(c), a == null || a.throwIfAborted(), !Number.isFinite(i) || i <= 0)
-    throw new Error(`feeRate must be a positive number, got ${i}`);
-  const h = BigInt(Math.ceil(i * W));
-  a == null || a.throwIfAborted();
-  const d = w(
-    n.depositorBtcPubkey
-  ), { psbtHex: g } = await ie({
-    prePeginParams: {
-      depositorPubkey: d,
-      vaultProviderPubkey: l(c.vaultProviderPubkey),
-      vaultKeeperPubkeys: c.vaultKeeperPubkeys.map(l),
-      universalChallengerPubkeys: c.universalChallengerPubkeys.map(l),
-      hashlocks: [l(n.hashlock)],
-      timelockRefund: c.timelockRefund,
-      pegInAmounts: [n.amount],
-      feeRate: c.feeRate,
-      numLocalChallengers: c.numLocalChallengers,
-      councilQuorum: c.councilQuorum,
-      councilSize: c.councilSize,
-      network: c.network
-    },
-    fundedPrePeginTxHex: l(n.unsignedPrePeginTxHex),
-    htlcVout: n.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: l(n.hashlock)
-  });
-  a == null || a.throwIfAborted();
-  const P = b(
-    n.depositorBtcPubkey,
-    Ue
-  ), k = await u(g, P), T = ze(k);
-  a == null || a.throwIfAborted();
-  try {
-    return await s(T);
-  } catch (p) {
-    throw p instanceof Error && Fe.test(p.message) ? new Le(t, p) : p;
-  }
-}
-export {
-  Le as B,
-  U as C,
-  Ee as P,
-  W as R,
-  rt as a,
-  Te as b,
-  at as c,
-  ut as d,
-  Ie as e,
-  Re as f,
-  ct as g,
-  ue as h,
-  st as i,
-  ce as j,
-  lt as k,
-  ht as l,
-  pt as m,
-  dt as n,
-  nt as r,
-  ot as s,
-  it as v,
-  D as w
-};
-//# sourceMappingURL=buildAndBroadcastRefund-Dx09Zbla.js.map