@babylonlabs-io/ts-sdk 0.36.0 → 0.36.2

package/dist/buildAndBroadcastRefund-C2VqXiOx.js

@@ -0,0 +1,893 @@
+var G = Object.defineProperty;
+var W = (e, t, r) => t in e ? G(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var S = (e, t, r) => W(e, typeof t != "symbol" ? t + "" : t, r);
+import { B as Q } from "./BTCVaultRegistry.abi-DbJ5lsFJ.js";
+import { e as Y, v as j, s as c, u as N, p as k, f as m } from "./bitcoin-B0S8SHCX.js";
+import { v as q, P as J } from "./PayoutManager-s_uH8Uuj.js";
+import { c as Z, a as ee, R as te, d as H, D as x } from "./types-TiIjyo2b.js";
+import * as re from "bitcoinjs-lib";
+import { Transaction as T, Psbt as ne } from "bitcoinjs-lib";
+import { Buffer as oe } from "buffer";
+import { c as ae, a as se, b as ie } from "./noPayout-DBX6G96_.js";
+import { a as ue, b as le, e as V } from "./payout-BNFMBXS6.js";
+import { c as R } from "./signing-DaLvGwQe.js";
+const ce = /^0x[0-9a-fA-F]{64}$/, de = /^0x[0-9a-fA-F]{40}$/, he = /^0x([0-9a-fA-F]{2})*$/;
+function C(e, t) {
+  if (e.length !== 66)
+    throw new Error(
+      `${t} must be 32 bytes (66 hex chars with 0x prefix), got length ${e.length}`
+    );
+  if (!ce.test(e))
+    throw new Error(
+      `${t} must contain only hex characters after the 0x prefix`
+    );
+}
+function pe(e, t) {
+  if (!de.test(e))
+    throw new Error(
+      `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
+    );
+}
+function fe(e, t) {
+  if (!he.test(e))
+    throw new Error(
+      `${t} must be a 0x-prefixed hex string with an even number of hex chars`
+    );
+}
+async function nt(e) {
+  const {
+    btcVaultRegistryAddress: t,
+    vaultId: r,
+    hashlock: n,
+    activationMetadata: i,
+    writeContract: u,
+    signal: a
+  } = e;
+  a == null || a.throwIfAborted(), pe(t, "btcVaultRegistryAddress"), C(r, "vaultId");
+  const o = Y(e.secret);
+  if (C(o, "secret"), n !== void 0 && (C(n, "hashlock"), !q(o, n)))
+    throw new Error(
+      "Invalid secret: SHA256(secret) does not match the provided hashlock"
+    );
+  return fe(i, "activationMetadata"), u({
+    address: t,
+    abi: Q,
+    functionName: "activateVaultWithSecret",
+    args: [r, o, i]
+  });
+}
+const ge = 1e4;
+async function L(e) {
+  const {
+    statusReader: t,
+    peginTxid: r,
+    targetStatuses: n,
+    timeoutMs: i,
+    pollIntervalMs: u = ge,
+    signal: a
+  } = e, o = Date.now();
+  for (; ; ) {
+    if (a != null && a.aborted)
+      throw new Error(
+        `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
+      );
+    if (Date.now() - o >= i)
+      throw new Error(
+        `Polling timeout after ${i}ms for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
+      );
+    try {
+      const s = await t.getPeginStatus(
+        { pegin_txid: r },
+        a
+      );
+      if (s.pegin_txid.toLowerCase() !== r.toLowerCase())
+        throw new Error(
+          `getPeginStatus returned status for pegin ${s.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
+        );
+      const l = s.status;
+      if (n.has(l))
+        return l;
+      if (Z.has(l) && !n.has(l))
+        throw new Error(
+          `Pegin ${r.slice(0, 8)}… reached terminal status "${l}" while waiting for ${[...n].join(", ")}`
+        );
+    } catch (s) {
+      if (!(s instanceof ee && s.code === te.NOT_FOUND || s instanceof Error && s.message.includes("PegIn not found")))
+        throw s;
+    }
+    await new Promise((s, l) => {
+      const d = () => {
+        clearTimeout(h), l(
+          new Error(
+            `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...n].join(", ")})`
+          )
+        );
+      }, h = setTimeout(() => {
+        a == null || a.removeEventListener("abort", d), s();
+      }, u);
+      a == null || a.addEventListener("abort", d, { once: !0 });
+    });
+  }
+}
+const ye = 300 * 1e3, Pe = /* @__PURE__ */ new Set([
+  x.PENDING_DEPOSITOR_WOTS_PK,
+  ...H
+]);
+async function ot(e) {
+  const {
+    statusReader: t,
+    wotsSubmitter: r,
+    peginTxid: n,
+    depositorPk: i,
+    wotsPublicKeys: u,
+    timeoutMs: a = ye,
+    signal: o
+  } = e;
+  o == null || o.throwIfAborted();
+  const s = await L({
+    statusReader: t,
+    peginTxid: n,
+    targetStatuses: Pe,
+    timeoutMs: a,
+    signal: o
+  });
+  H.has(s) || (o == null || o.throwIfAborted(), await r.submitDepositorWotsKey(
+    {
+      pegin_txid: n,
+      depositor_pk: i,
+      wots_public_keys: u
+    },
+    o
+  ));
+}
+const I = 1;
+function me(e, t, r) {
+  const n = c(r).toLowerCase(), u = [e, ...t].map(
+    (a) => c(a).toLowerCase()
+  ).filter((a) => a !== n);
+  if (u.length === 0)
+    throw new Error(
+      "Cannot derive localChallengers: removing depositor from {vaultProvider, vaultKeepers} left an empty set"
+    );
+  if (new Set(u).size !== u.length)
+    throw new Error(
+      "Cannot derive localChallengers: vaultProvider key duplicates a vaultKeeper key — signing context is misconfigured"
+    );
+  return u;
+}
+function be(e, t) {
+  const r = e.map(
+    (o) => c(o.challenger_pubkey).toLowerCase()
+  ), n = new Set(r);
+  if (n.size !== r.length)
+    throw new Error(
+      "Depositor graph contains duplicate challenger entries in challenger_presign_data"
+    );
+  const i = new Set(t), u = t.filter((o) => !n.has(o)), a = r.filter((o) => !i.has(o));
+  if (u.length > 0 || a.length > 0)
+    throw new Error(
+      "Depositor graph challenger set does not match localChallengers" + (u.length > 0 ? ` (missing: ${u.join(", ")})` : "") + (a.length > 0 ? ` (unexpected: ${a.join(", ")})` : "")
+    );
+}
+function we(e, t) {
+  const r = e.ins[t];
+  return N(new Uint8Array(r.hash).slice().reverse());
+}
+function B(e, t, r, n, i) {
+  const u = e.ins[t];
+  if (u.index !== 0)
+    throw new Error(
+      `NoPayout (challenger ${i}) input ${t} expected to spend ${n} vout 0, got vout ${u.index}`
+    );
+  const a = r.getId(), o = we(e, t);
+  if (o !== a)
+    throw new Error(
+      `NoPayout (challenger ${i}) input ${t} does not reference ${n} (expected txid ${a}, got ${o})`
+    );
+}
+async function ve(e, t, r) {
+  const n = [], i = [], u = [], a = me(
+    r.vaultProviderBtcPubkey,
+    r.vaultKeeperBtcPubkeys,
+    r.depositorBtcPubkey
+  );
+  be(
+    e.challenger_presign_data,
+    a
+  ), ue(
+    e.payout_tx.tx_hex,
+    r.registeredPayoutScriptPubKey
+  );
+  const o = await le({
+    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
+  });
+  n.push(o.psbtHex), i.push(
+    R(
+      t,
+      I
+    )
+  );
+  const s = c(r.depositorBtcPubkey), l = T.fromHex(
+    c(e.assert_tx.tx_hex)
+  );
+  for (const d of e.challenger_presign_data) {
+    const h = c(d.challenger_pubkey), y = n.length, P = await xe({
+      challenger: d,
+      challengerPubkey: h,
+      claimerPubkey: s,
+      localChallengers: a,
+      assertTxParsed: l,
+      ctx: r
+    });
+    n.push(P), i.push(
+      R(
+        t,
+        I
+      )
+    ), u.push({
+      challengerPubkey: h,
+      noPayoutIdx: y
+    });
+  }
+  return { psbtHexes: n, signOptions: i, challengerEntries: u };
+}
+async function xe(e) {
+  const {
+    challenger: t,
+    challengerPubkey: r,
+    claimerPubkey: n,
+    localChallengers: i,
+    assertTxParsed: u,
+    ctx: a
+  } = e;
+  ae(
+    t.nopayout_tx.tx_hex,
+    r,
+    a.network
+  );
+  const o = T.fromHex(
+    c(t.nopayout_tx.tx_hex)
+  ), s = T.fromHex(
+    c(t.challenge_assert_x_tx.tx_hex)
+  ), l = T.fromHex(
+    c(t.challenge_assert_y_tx.tx_hex)
+  );
+  if (o.ins.length !== 3)
+    throw new Error(
+      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${o.ins.length}`
+    );
+  B(
+    o,
+    0,
+    u,
+    "Assert",
+    r
+  ), B(
+    o,
+    1,
+    s,
+    "ChallengeAssertX",
+    r
+  ), B(
+    o,
+    2,
+    l,
+    "ChallengeAssertY",
+    r
+  );
+  const d = [
+    u.outs[0],
+    s.outs[0],
+    l.outs[0]
+  ].map((h) => ({
+    script_pubkey: N(new Uint8Array(h.script)),
+    value: h.value
+  }));
+  return se({
+    noPayoutTxHex: t.nopayout_tx.tx_hex,
+    challengerPubkey: r,
+    prevouts: d,
+    connectorParams: {
+      claimer: n,
+      localChallengers: i,
+      universalChallengers: a.universalChallengerBtcPubkeys,
+      timelockAssert: a.timelockAssert,
+      councilMembers: a.councilMembers,
+      councilQuorum: a.councilQuorum
+    }
+  });
+}
+function ke(e, t, r) {
+  const n = 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: n
+    },
+    per_challenger: i
+  };
+}
+async function Te(e, t, r) {
+  if (typeof e.signPsbts == "function")
+    return e.signPsbts(t, r);
+  const n = [];
+  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 Ee(e) {
+  const { depositorGraph: t, btcWallet: r, signingContext: n } = e, i = await r.getPublicKeyHex(), { depositorPubkey: u } = j(
+    i,
+    c(n.depositorBtcPubkey)
+  ), { psbtHexes: a, signOptions: o, challengerEntries: s } = await ve(
+    t,
+    i,
+    n
+  ), l = await Te(
+    r,
+    a,
+    o
+  );
+  if (l.length !== a.length)
+    throw new Error(
+      `Wallet returned ${l.length} signed PSBTs, expected ${a.length}`
+    );
+  return ke(
+    l,
+    s,
+    u
+  );
+}
+const _e = 1200 * 1e3, D = /* @__PURE__ */ new Set([
+  x.PENDING_ACKS,
+  x.PENDING_ACTIVATION,
+  x.ACTIVATED
+]), Se = /* @__PURE__ */ new Set([
+  x.PENDING_DEPOSITOR_SIGNATURES,
+  ...D
+]);
+function Ce(e) {
+  return e.map((t) => ({
+    claimerPubkeyXOnly: k(t.claimer_pubkey),
+    payoutTxHex: t.payout_tx.tx_hex,
+    assertTxHex: t.assert_tx.tx_hex
+  }));
+}
+function Be(e) {
+  const { output: t } = re.payments.p2tr({
+    internalPubkey: oe.from(e, "hex")
+  });
+  if (!t)
+    throw new Error("Failed to derive BIP-86 P2TR scriptPubKey");
+  return t.toString("hex");
+}
+function Ae(e, t) {
+  const r = c(e).toLowerCase(), n = c(
+    t.vaultProviderBtcPubkey
+  ).toLowerCase(), i = c(
+    t.depositorBtcPubkey
+  ).toLowerCase();
+  if (r === n || r === i)
+    return t.registeredPayoutScriptPubKey;
+  if (!t.vaultKeeperBtcPubkeys.some(
+    (o) => c(o).toLowerCase() === r
+  ))
+    throw new Error(
+      `Unknown claimer pubkey ${r}: not VP, depositor, or a registered vault keeper`
+    );
+  return `0x${Be(r)}`;
+}
+function K(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: Ae(
+      e.claimerPubkeyXOnly,
+      t
+    )
+  };
+}
+async function Re(e, t, r, n) {
+  const i = new J({
+    network: t.network,
+    btcWallet: e
+  }), u = r.length;
+  n == null || n(0, u);
+  let a;
+  if (i.supportsBatchSigning())
+    a = (await i.signPayoutTransactionsBatch(
+      r.map((l) => K(l, t))
+    )).map((l) => l.payoutSignature);
+  else {
+    a = [];
+    for (let s = 0; s < r.length; s++) {
+      n == null || n(s, u);
+      const l = await i.signPayoutTransaction(
+        K(r[s], t)
+      );
+      a.push(l.signature);
+    }
+  }
+  const o = {};
+  for (let s = 0; s < r.length; s++)
+    o[r[s].claimerPubkeyXOnly] = {
+      payout_signature: a[s]
+    };
+  return n == null || n(u, u), o;
+}
+async function at(e) {
+  const {
+    statusReader: t,
+    presignClient: r,
+    btcWallet: n,
+    peginTxid: i,
+    depositorPk: u,
+    signingContext: a,
+    timeoutMs: o = _e,
+    signal: s,
+    onProgress: l
+  } = e, d = await L({
+    statusReader: t,
+    peginTxid: i,
+    targetStatuses: Se,
+    timeoutMs: o,
+    signal: s
+  });
+  if (D.has(d))
+    return;
+  s == null || s.throwIfAborted();
+  const h = await r.requestDepositorPresignTransactions(
+    {
+      pegin_txid: i,
+      depositor_pk: u
+    },
+    s
+  );
+  s == null || s.throwIfAborted();
+  const y = k(u), P = h.txs.filter(
+    (v) => k(v.claimer_pubkey) !== y
+  ), b = Ce(P), f = await Re(
+    n,
+    a,
+    b,
+    l
+  );
+  s == null || s.throwIfAborted();
+  const g = await Ee({
+    depositorGraph: h.depositor_graph,
+    btcWallet: n,
+    signingContext: {
+      peginTxHex: a.peginTxHex,
+      depositorBtcPubkey: u,
+      vaultProviderBtcPubkey: a.vaultProviderBtcPubkey,
+      vaultKeeperBtcPubkeys: a.vaultKeeperBtcPubkeys,
+      universalChallengerBtcPubkeys: a.universalChallengerBtcPubkeys,
+      timelockPegin: a.timelockPegin,
+      timelockAssert: a.timelockAssert,
+      councilMembers: a.councilMembers,
+      councilQuorum: a.councilQuorum,
+      network: a.network,
+      registeredPayoutScriptPubKey: a.registeredPayoutScriptPubKey
+    }
+  });
+  s == null || s.throwIfAborted();
+  const w = { ...f };
+  w[c(u)] = g.payout_signatures, await r.submitDepositorPresignatures(
+    {
+      pegin_txid: i,
+      depositor_pk: u,
+      signatures: w,
+      depositor_claimer_presignatures: g
+    },
+    s
+  );
+}
+function $e(e) {
+  return /^[0-9a-fA-F]{64}$/.test(e);
+}
+function st(e) {
+  const {
+    amountSats: t,
+    minDeposit: r,
+    maxDeposit: n,
+    btcBalance: i,
+    estimatedFeeSats: u,
+    depositorClaimValue: a
+  } = e;
+  return !(t <= 0n || t < r || n && n > 0n && t > n || u == null || a == null || t + u + a > 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 ${m(t)} BTC`
+  } : r && r > 0n && e > r ? {
+    valid: !1,
+    error: `Maximum deposit is ${m(r)} BTC`
+  } : { valid: !0 };
+}
+function ut(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 (${m(r)} BTC)`
+  } : { valid: !0 };
+}
+function lt(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 Ve(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 i = e[n];
+    if (i <= 0n)
+      return {
+        valid: !1,
+        error: `Vault ${n + 1} amount must be positive`
+      };
+    if (t && i < t)
+      return {
+        valid: !1,
+        error: `Vault ${n + 1} amount ${m(i)} BTC is below minimum deposit ${m(t)} BTC`
+      };
+    if (r && i > r)
+      return {
+        valid: !1,
+        error: `Vault ${n + 1} amount ${m(i)} BTC exceeds maximum deposit ${m(r)} BTC`
+      };
+  }
+  return { valid: !0 };
+}
+function Ie(e) {
+  const t = c(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 Ke(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 Ne(e) {
+  if (e.length === 0)
+    throw new Error("No spendable UTXOs available");
+}
+function ct(e) {
+  const {
+    vaultAmounts: t,
+    confirmedUTXOs: r,
+    vaultProviderBtcPubkey: n,
+    vaultKeeperBtcPubkeys: i,
+    universalChallengerBtcPubkeys: u,
+    minDeposit: a,
+    maxDeposit: o
+  } = e, s = Ve(
+    t,
+    a,
+    o
+  );
+  if (!s.valid)
+    throw new Error(s.error);
+  const l = Ie(n);
+  if (!l.valid)
+    throw new Error(l.error);
+  Ke(i), Oe(u), Ne(r);
+}
+async function dt(e) {
+  const {
+    vaultRegistryReader: t,
+    vaultKeeperReader: r,
+    universalChallengerReader: n,
+    vaultProviderEthAddress: i,
+    applicationEntryPoint: u,
+    expectedVaultProviderBtcPubkey: a,
+    expectedVaultKeeperBtcPubkeys: o,
+    expectedUniversalChallengerBtcPubkeys: s
+  } = e, [
+    l,
+    d,
+    h
+  ] = await Promise.all([
+    t.getVaultProviderBtcPubKey(i),
+    r.getCurrentVaultKeepersVersion(u),
+    n.getLatestUniversalChallengersVersion()
+  ]), [y, P] = await Promise.all([
+    r.getVaultKeepersByVersion(
+      u,
+      d
+    ),
+    n.getUniversalChallengersByVersion(
+      h
+    )
+  ]), b = (p) => k(p).toLowerCase(), f = (p) => p.map(b).sort();
+  if (b(a) !== l)
+    throw new Error(
+      `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${i}. Refresh and try again.`
+    );
+  const w = f(o), v = f(
+    y.map((p) => p.btcPubKey)
+  );
+  if (w.length !== v.length || w.some((p, _) => p !== v[_]))
+    throw new Error(
+      `Vault keeper BTC pubkeys (v${d}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
+    );
+  const $ = f(s), E = f(
+    P.map((p) => p.btcPubKey)
+  );
+  if ($.length !== E.length || $.some((p, _) => p !== E[_]))
+    throw new Error(
+      `Universal challenger BTC pubkeys (v${h}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
+    );
+  return {
+    vaultProviderBtcPubkeyXOnly: l,
+    vaultKeeperBtcPubkeysSorted: v,
+    universalChallengerBtcPubkeysSorted: E,
+    expectedAppVaultKeepersVersion: d,
+    expectedUniversalChallengersVersion: h
+  };
+}
+class M extends Error {
+  constructor(t) {
+    super(t), this.name = "RegisteredVaultVersionMismatchError";
+  }
+}
+function ht(e) {
+  return e instanceof M || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
+}
+async function pt(e) {
+  const {
+    vaultRegistryReader: t,
+    vaultIds: r,
+    expectedOffchainParamsVersion: n,
+    expectedAppVaultKeepersVersion: i,
+    expectedUniversalChallengersVersion: u
+  } = e, a = await t.getProtocolInfoBatch(r), o = [];
+  if (a.forEach((s, l) => {
+    const d = r[l];
+    s.offchainParamsVersion !== n && o.push(
+      `vault ${d}: offchainParams expected v${n}, got v${s.offchainParamsVersion}`
+    ), s.appVaultKeepersVersion !== i && o.push(
+      `vault ${d}: appVaultKeepers expected v${i}, got v${s.appVaultKeepersVersion}`
+    ), s.universalChallengersVersion !== u && o.push(
+      `vault ${d}: universalChallengers expected v${u}, got v${s.universalChallengersVersion}`
+    );
+  }), o.length > 0)
+    throw new M(
+      `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 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 He = /* @__PURE__ */ new Set([
+  "PayoutBroadcast",
+  "Failed"
+  /* FAILED */
+]);
+function ft(e) {
+  return Object.values(U).includes(
+    e
+  );
+}
+function gt(e) {
+  return !!e && He.has(e);
+}
+class Le extends Error {
+  constructor(r, n) {
+    super(`Refund not yet mature (BIP68 not final): ${n.message}`);
+    S(this, "vaultId");
+    S(this, "cause");
+    this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = n;
+  }
+}
+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})$/, X = 160;
+function yt(e) {
+  if (!Number.isFinite(e) || e <= 0)
+    throw new Error(
+      `feeRateSatsVb must be a positive finite number, got ${e}`
+    );
+  return BigInt(Math.ceil(e * X));
+}
+const Ue = 1, O = 65535, Fe = /non-BIP68-final/i;
+function z(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 A(e, t) {
+  if (!Number.isInteger(e) || e < 0)
+    throw new Error(`${t} must be a non-negative integer, got ${e}`);
+}
+function Xe(e) {
+  if (z(e.hashlock, "hashlock"), !Number.isInteger(e.htlcVout) || e.htlcVout < 0 || e.htlcVout > O)
+    throw new Error(
+      `htlcVout must be an integer 0-${O}, got ${e.htlcVout}`
+    );
+  if (A(e.offchainParamsVersion, "offchainParamsVersion"), A(e.appVaultKeepersVersion, "appVaultKeepersVersion"), A(
+    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 ze(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 Ge(e) {
+  const t = ne.fromHex(e);
+  try {
+    t.finalizeAllInputs();
+  } catch (r) {
+    const n = r instanceof Error ? r.message : String(r);
+    if (!n.includes("already finalized"))
+      throw new Error(`Failed to finalize refund PSBT: ${n}`);
+  }
+  return t.extractTransaction().toHex();
+}
+async function Pt(e) {
+  const {
+    vaultId: t,
+    readVault: r,
+    readPrePeginContext: n,
+    feeRate: i,
+    signPsbt: u,
+    broadcastTx: a,
+    signal: o
+  } = e;
+  o == null || o.throwIfAborted(), z(t, "vaultId");
+  const s = await r();
+  Xe(s), o == null || o.throwIfAborted();
+  const l = await n(s);
+  if (ze(l), o == null || o.throwIfAborted(), !Number.isFinite(i) || i <= 0)
+    throw new Error(`feeRate must be a positive number, got ${i}`);
+  const d = BigInt(Math.ceil(i * X));
+  o == null || o.throwIfAborted();
+  const h = k(
+    s.depositorBtcPubkey
+  ), { psbtHex: y } = await ie({
+    prePeginParams: {
+      depositorPubkey: h,
+      vaultProviderPubkey: c(l.vaultProviderPubkey),
+      vaultKeeperPubkeys: l.vaultKeeperPubkeys.map(c),
+      universalChallengerPubkeys: l.universalChallengerPubkeys.map(c),
+      hashlocks: [c(s.hashlock)],
+      timelockRefund: l.timelockRefund,
+      pegInAmounts: [s.amount],
+      feeRate: l.feeRate,
+      numLocalChallengers: l.numLocalChallengers,
+      councilQuorum: l.councilQuorum,
+      councilSize: l.councilSize,
+      network: l.network
+    },
+    fundedPrePeginTxHex: c(s.unsignedPrePeginTxHex),
+    htlcVout: s.htlcVout,
+    refundFee: d,
+    // buildRefundPsbt's top-level `hashlock` param is documented as "no 0x
+    // prefix" and flows into the WASM HTLC connector derivation; a prefixed
+    // value would derive the wrong refund script leaf and yield an
+    // unspendable PSBT. Match the `hashlocks` array handling above.
+    hashlock: c(s.hashlock)
+  });
+  o == null || o.throwIfAborted();
+  const P = R(
+    s.depositorBtcPubkey,
+    Ue
+  ), b = await u(y, P), f = Ge(b);
+  o == null || o.throwIfAborted();
+  try {
+    return await a(f);
+  } catch (g) {
+    throw g instanceof Error && Fe.test(g.message) ? new Le(t, g) : g;
+  }
+}
+export {
+  Le as B,
+  U as C,
+  M as R,
+  nt as a,
+  Ee as b,
+  ut as c,
+  lt as d,
+  Ve as e,
+  Ie as f,
+  ct as g,
+  dt as h,
+  st as i,
+  ht as j,
+  pt as k,
+  ft as l,
+  gt as m,
+  Pt as n,
+  yt as o,
+  X as p,
+  at as r,
+  ot as s,
+  it as v,
+  L as w
+};
+//# sourceMappingURL=buildAndBroadcastRefund-C2VqXiOx.js.map