@babylonlabs-io/ts-sdk 0.49.0 → 0.49.1

package/dist/buildAndBroadcastRefund-Bmz9WJuN.js

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