@babylonlabs-io/ts-sdk 1.0.0 → 1.2.0

package/dist/buildAndBroadcastReclaim-OMvihzJg.js

@@ -1,1545 +0,0 @@
-var Re = Object.defineProperty;
-var _e = (e, t, r) => t in e ? Re(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var S = (e, t, r) => _e(e, typeof t != "symbol" ? t + "" : t, r);
-import { B as pe } from "./BTCVaultRegistry.abi-B0x9_Bza.js";
-import { e as he, v as Se, s as y, u as de, p as O, c as C, f as _ } from "./bitcoin-C-TuHb-v.js";
-import { v as $e, d as Be, s as Ie, P as Ve, a as Ke } from "./signPsbtsWithFallback-DoRbHHua.js";
-import { zeroAddress as Oe, isAddress as Ne, isAddressEqual as He } from "viem";
-import { D as R, c as De, b as Me, R as Fe, d as ge } from "./json-rpc-client-DuUARJvV.js";
-import { Transaction as $ } from "bitcoinjs-lib";
-import { p as Ue, f as Le, i as B, g as I, j as V } from "./verifyScriptPathSchnorrSignature-CpjSTfMj.js";
-import { D as W } from "./constants-D5vORbQE.js";
-import { d as Xe, c as qe, b as Ge, f as fe, e as ze, a as je } from "./noPayout-qBXWKwav.js";
-import { a as K, c as Qe } from "./signing-Cm-McVR2.js";
-import { a as Y } from "./onChainBtcPubkey-C-6UWpD8.js";
-import { a as We } from "./secp256k1-D-H9jmd7.js";
-import { deriveVaultId as Ye } from "./tbv/core/wasm/index.js";
-const Je = /^0x[0-9a-fA-F]{64}$/, Ze = /^0x[0-9a-fA-F]{40}$/, et = /^0x([0-9a-fA-F]{2})*$/;
-function N(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 (!Je.test(e))
-    throw new Error(
-      `${t} must contain only hex characters after the 0x prefix`
-    );
-}
-function tt(e, t) {
-  if (!Ze.test(e))
-    throw new Error(
-      `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
-    );
-}
-function rt(e, t) {
-  if (!et.test(e))
-    throw new Error(
-      `${t} must be a 0x-prefixed hex string with an even number of hex chars`
-    );
-}
-function me(e) {
-  tt(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), N(e.vaultId, "vaultId");
-  const t = he(e.secret);
-  if (N(t, "secret"), e.hashlock !== void 0 && (N(e.hashlock, "hashlock"), !$e(t, e.hashlock)))
-    throw new Error(
-      "Invalid secret: SHA256(secret) does not match the provided hashlock"
-    );
-  return t;
-}
-async function or(e) {
-  const {
-    btcVaultRegistryAddress: t,
-    vaultId: r,
-    hashlock: o,
-    activationMetadata: a,
-    writeContract: l,
-    signal: s
-  } = e;
-  s == null || s.throwIfAborted();
-  const i = me({
-    btcVaultRegistryAddress: t,
-    vaultId: r,
-    secret: e.secret,
-    hashlock: o
-  });
-  return rt(a, "activationMetadata"), l({
-    address: t,
-    abi: pe,
-    functionName: "activateVaultWithSecret",
-    args: [r, i, a]
-  });
-}
-async function nr(e) {
-  const { btcVaultRegistryAddress: t, vaultId: r, hashlock: o, writeContract: a, signal: l } = e;
-  l == null || l.throwIfAborted();
-  const s = me({
-    btcVaultRegistryAddress: t,
-    vaultId: r,
-    secret: e.secret,
-    hashlock: o
-  });
-  return a({
-    address: t,
-    abi: pe,
-    functionName: "activateVaultWithSecretAndRedeem",
-    args: [r, s]
-  });
-}
-const ot = 8, nt = 6e3, st = 10 * 6e4, at = 10;
-class Pe extends Error {
-  constructor(t) {
-    super(t), this.name = "PeginRegistrationMissingError";
-  }
-}
-class ve extends Error {
-  constructor(t) {
-    super(t), this.name = "PeginRegistrationNotFinalError";
-  }
-}
-function it(e) {
-  return e instanceof Pe || e instanceof Error && e.name === "PeginRegistrationMissingError";
-}
-function sr(e) {
-  return e instanceof ve || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
-}
-function J(e) {
-  const { currentBlock: t, createdAtBlock: r } = e, o = t - r + 1n;
-  return o < 0n ? 0 : Number(o);
-}
-async function ar(e) {
-  const {
-    vaultRegistryReader: t,
-    getBlockNumber: r,
-    vaultIds: o,
-    required: a = ot,
-    pollIntervalMs: l = nt,
-    timeoutMs: s = st,
-    signal: i,
-    onProgress: n
-  } = e;
-  if (o.length === 0)
-    throw new Error(
-      "waitForPeginRegistrationDepth requires at least one vault ID"
-    );
-  const u = Date.now();
-  let p = !1, c = 0, h;
-  for (; ; ) {
-    if (i != null && i.aborted)
-      throw new Error(
-        `Aborted while waiting for peg-in registration depth (${o.length} vault(s))`
-      );
-    if (Date.now() - u >= s)
-      throw new ve(
-        `Peg-in registration did not reach ${a} Ethereum confirmations within ${s}ms. The registration transaction was submitted but is not yet final, so the Pre-PegIn Bitcoin transaction was never sent and no funds are at risk. Resume this deposit from the dashboard once the network settles.` + (h instanceof Error ? ` Last read error: ${h.message}` : "")
-      );
-    try {
-      const d = await r(), g = await Promise.all(
-        o.map((P) => t.getVaultBasicInfo(P))
-      ), m = g.findIndex(
-        (P) => P.depositor === Oe || P.createdAt === 0n
-      );
-      if (m !== -1) {
-        if (c += 1, !p && c > at)
-          throw new Pe(
-            `Vault ${o[m]} is still not visible on-chain after ${c} reads — the registration does not exist.`
-          );
-        console.warn(
-          `Peg-in registration for vault ${o[m]} is not visible in chain state at block ${d} — a lagging RPC backend or an Ethereum reorg. Still polling.`
-        ), n == null || n({ confirmations: 0, required: a });
-      } else {
-        p = !0, c = 0, h = void 0;
-        let P = g[0], f = J({
-          currentBlock: d,
-          createdAtBlock: g[0].createdAt
-        });
-        for (const x of g.slice(1)) {
-          const b = J({
-            currentBlock: d,
-            createdAtBlock: x.createdAt
-          });
-          b < f && (f = b, P = x);
-        }
-        if (n == null || n({ confirmations: f, required: a }), f >= a)
-          return { confirmations: f, basicInfo: P };
-      }
-    } catch (d) {
-      if (it(d))
-        throw d;
-      console.warn(
-        `Registration-depth read failed (retrying in ${l}ms): ` + (d instanceof Error ? d.message : String(d))
-      ), h = d;
-    }
-    await new Promise((d, g) => {
-      const m = () => {
-        clearTimeout(P), g(
-          new Error(
-            `Aborted while waiting for peg-in registration depth (${o.length} vault(s))`
-          )
-        );
-      }, P = setTimeout(() => {
-        i == null || i.removeEventListener("abort", m), d();
-      }, l);
-      i == null || i.addEventListener("abort", m, { once: !0 });
-    });
-  }
-}
-const ut = 1;
-function lt(e, t, r) {
-  const o = r.map(
-    (c) => y(c).toLowerCase()
-  ), a = t.filter((c) => o.includes(c));
-  if (a.length > 0)
-    throw new Error(
-      `Cannot validate challenger set: vault keepers and universal challengers overlap (${a.join(", ")})`
-    );
-  const l = [...t, ...o], s = e.map(
-    (c) => y(c.challenger_pubkey).toLowerCase()
-  ), i = new Set(s);
-  if (i.size !== s.length)
-    throw new Error(
-      "Depositor graph contains duplicate challenger entries in challenger_presign_data"
-    );
-  const n = new Set(l), u = l.filter((c) => !i.has(c)), p = s.filter((c) => !n.has(c));
-  if (u.length > 0 || p.length > 0)
-    throw new Error(
-      "Depositor graph challenger set does not match expected (local ∪ universal)" + (u.length > 0 ? ` (missing: ${u.join(", ")})` : "") + (p.length > 0 ? ` (unexpected: ${p.join(", ")})` : "")
-    );
-}
-function ct(e, t) {
-  const r = e.ins[t];
-  return de(new Uint8Array(r.hash).slice().reverse());
-}
-function H(e, t, r, o, a) {
-  const l = e.ins[t];
-  if (l.index !== 0)
-    throw new Error(
-      `NoPayout (challenger ${a}) input ${t} expected to spend ${o} vout 0, got vout ${l.index}`
-    );
-  const s = r.getId(), i = ct(e, t);
-  if (i !== s)
-    throw new Error(
-      `NoPayout (challenger ${a}) input ${t} does not reference ${o} (expected txid ${s}, got ${i})`
-    );
-}
-async function pt(e, t, r) {
-  const o = [], a = [], l = [], s = Ue({
-    claimerBtcPubkey: r.depositorBtcPubkey,
-    depositorBtcPubkey: r.depositorBtcPubkey,
-    vaultProviderBtcPubkey: r.vaultProviderBtcPubkey,
-    vaultKeeperBtcPubkeys: r.vaultKeeperBtcPubkeys
-  });
-  lt(
-    e.challenger_presign_data,
-    s,
-    r.universalChallengerBtcPubkeys
-  );
-  const i = await Le({
-    vaultCoreVersion: r.vaultCoreVersion,
-    vkClaimerPayoutScriptPubKeys: r.vkClaimerPayoutScriptPubKeys,
-    vpCommissionScriptPubKey: r.vpCommissionScriptPubKey,
-    payoutTxHex: e.payout_tx.tx_hex,
-    peginTxHex: r.peginTxHex,
-    assertTxHex: e.assert_tx.tx_hex,
-    timelockAssert: r.timelockAssert,
-    depositorBtcPubkey: r.depositorBtcPubkey,
-    vaultProviderBtcPubkey: r.vaultProviderBtcPubkey,
-    vaultKeeperBtcPubkeys: r.vaultKeeperBtcPubkeys,
-    universalChallengerBtcPubkeys: r.universalChallengerBtcPubkeys,
-    timelockPegin: r.timelockPegin,
-    network: r.network,
-    claimerBtcPubkey: r.depositorBtcPubkey,
-    registeredPayoutScriptPubKey: r.registeredPayoutScriptPubKey,
-    commissionBps: ut,
-    protocolFeeRate: r.protocolFeeRate,
-    councilMembers: r.councilMembers,
-    councilQuorum: r.councilQuorum
-  });
-  o.push(i.psbtHex), a.push(
-    K(
-      t,
-      W
-    )
-  );
-  const n = y(r.depositorBtcPubkey), u = $.fromHex(
-    y(e.assert_tx.tx_hex)
-  );
-  for (const p of e.challenger_presign_data) {
-    const c = y(p.challenger_pubkey), h = o.length, d = await ht({
-      challenger: p,
-      challengerPubkey: c,
-      claimerPubkey: n,
-      localChallengers: s,
-      assertTxParsed: u,
-      ctx: r
-    });
-    o.push(d), a.push(
-      K(
-        t,
-        W
-      )
-    ), l.push({
-      challengerPubkey: c,
-      noPayoutIdx: h
-    });
-  }
-  return { psbtHexes: o, signOptions: a, challengerEntries: l };
-}
-async function ht(e) {
-  const {
-    challenger: t,
-    challengerPubkey: r,
-    claimerPubkey: o,
-    localChallengers: a,
-    assertTxParsed: l,
-    ctx: s
-  } = e;
-  Xe(
-    t.nopayout_tx.tx_hex,
-    r,
-    s.network
-  );
-  const i = $.fromHex(
-    y(t.nopayout_tx.tx_hex)
-  ), n = $.fromHex(
-    y(t.challenge_assert_x_tx.tx_hex)
-  ), u = $.fromHex(
-    y(t.challenge_assert_y_tx.tx_hex)
-  );
-  if (i.ins.length !== 3)
-    throw new Error(
-      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${i.ins.length}`
-    );
-  H(
-    i,
-    0,
-    l,
-    "Assert",
-    r
-  ), H(
-    i,
-    1,
-    n,
-    "ChallengeAssertX",
-    r
-  ), H(
-    i,
-    2,
-    u,
-    "ChallengeAssertY",
-    r
-  );
-  const p = [
-    l.outs[0],
-    n.outs[0],
-    u.outs[0]
-  ].map((c) => ({
-    script_pubkey: de(new Uint8Array(c.script)),
-    value: c.value
-  }));
-  return qe({
-    noPayoutTxHex: t.nopayout_tx.tx_hex,
-    challengerPubkey: r,
-    prevouts: p,
-    connectorParams: {
-      txGraphVersion: s.vaultCoreVersion,
-      claimer: o,
-      localChallengers: a,
-      universalChallengers: s.universalChallengerBtcPubkeys,
-      timelockAssert: s.timelockAssert,
-      councilMembers: s.councilMembers,
-      councilQuorum: s.councilQuorum
-    }
-  });
-}
-function dt(e, t, r) {
-  B(e[0]);
-  const a = I(
-    e[0].returnedPsbtHex,
-    r
-  );
-  V({
-    requestedPsbtHex: e[0].requestedPsbtHex,
-    signatureHex: a,
-    signerXOnlyPubkeyHex: r,
-    inputIndex: 0
-  });
-  const l = {};
-  for (const s of t) {
-    B(e[s.noPayoutIdx]);
-    const i = I(
-      e[s.noPayoutIdx].returnedPsbtHex,
-      r
-    );
-    V({
-      requestedPsbtHex: e[s.noPayoutIdx].requestedPsbtHex,
-      signatureHex: i,
-      signerXOnlyPubkeyHex: r,
-      inputIndex: 0
-    }), l[s.challengerPubkey] = {
-      nopayout_signature: i
-    };
-  }
-  return {
-    payout_signatures: {
-      payout_signature: a
-    },
-    per_challenger: l
-  };
-}
-async function gt(e) {
-  const { depositorGraph: t, btcWallet: r, signingContext: o } = e, a = await r.getPublicKeyHex(), { depositorPubkey: l } = Se(
-    a,
-    y(o.depositorBtcPubkey)
-  ), { psbtHexes: s, signOptions: i, challengerEntries: n } = await pt(
-    t,
-    a,
-    o
-  ), u = await Be(
-    r,
-    s,
-    i
-  ), p = s.map((c, h) => ({
-    requestedPsbtHex: c,
-    returnedPsbtHex: u[h]
-  }));
-  return dt(
-    p,
-    n,
-    l
-  );
-}
-const ft = 1e4;
-async function ye(e) {
-  const {
-    statusReader: t,
-    peginTxid: r,
-    targetStatuses: o,
-    timeoutMs: a,
-    pollIntervalMs: l = ft,
-    signal: s
-  } = e, i = 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() - i >= a)
-      throw new Error(
-        `Polling timeout after ${a}ms for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
-      );
-    try {
-      const n = await t.getPeginStatus(
-        { pegin_txid: r },
-        s
-      );
-      if (n.pegin_txid.toLowerCase() !== r.toLowerCase())
-        throw new Error(
-          `getPeginStatus returned status for pegin ${n.pegin_txid.slice(0, 8)}…, requested ${r.slice(0, 8)}…`
-        );
-      const u = n.status;
-      if (o.has(u) || u === R.ACTIVATED)
-        return u;
-      if (u === R.EXPIRED || De.has(u))
-        throw new Error(
-          `Pegin ${r.slice(0, 8)}… reached terminal status "${u}" while waiting for ${[...o].join(", ")}`
-        );
-    } catch (n) {
-      if (!(n instanceof Me && n.code === Fe.PEGIN_NOT_FOUND))
-        throw n;
-    }
-    await new Promise((n, u) => {
-      const p = () => {
-        clearTimeout(c), u(
-          new Error(
-            `Polling aborted for pegin ${r.slice(0, 8)}… (target: ${[...o].join(", ")})`
-          )
-        );
-      }, c = setTimeout(() => {
-        s == null || s.removeEventListener("abort", p), n();
-      }, l);
-      s == null || s.addEventListener("abort", p, { once: !0 });
-    });
-  }
-}
-const mt = 1200 * 1e3, be = /* @__PURE__ */ new Set([
-  R.PENDING_ACKS,
-  R.PENDING_ACTIVATION,
-  R.ACTIVATED_PENDING_BROADCAST,
-  R.ACTIVATED
-]), Pt = /* @__PURE__ */ new Set([
-  R.PENDING_DEPOSITOR_SIGNATURES,
-  ...be
-]);
-function vt(e) {
-  return e.map((t) => ({
-    claimerPubkeyXOnly: O(t.claimer_pubkey),
-    payoutTxHex: t.payout_tx.tx_hex,
-    assertTxHex: t.assert_tx.tx_hex
-  }));
-}
-function A(e) {
-  return O(e).toLowerCase();
-}
-function yt(e, t) {
-  const r = (n, u, p) => {
-    throw new Error(
-      `Deposit terms ${n} (${String(u)}) does not match the vault's version-locked signing context (${String(p)}); refusing to sign payouts against terms that describe a different graph.`
-    );
-  }, o = [
-    ["protocolFeeRate", e.protocolFeeRate, t.protocolFeeRate],
-    ["vaultCoreVersion", e.vaultCoreVersion, t.vaultCoreVersion],
-    ["timelockPegin", e.timelockPegin, t.timelockPegin],
-    ["timelockAssert", e.timelockAssert, t.timelockAssert]
-  ];
-  for (const [n, u, p] of o)
-    u !== p && r(n, u, p);
-  const a = (n) => n.map(A).sort(), l = (n, u) => {
-    const p = a(n), c = a(u);
-    return p.length === c.length && p.every((h, d) => h === c[d]);
-  };
-  l(e.vaultKeeperBtcPubkeys, t.vaultKeeperBtcPubkeys) || r(
-    "vaultKeeperBtcPubkeys",
-    e.vaultKeeperBtcPubkeys.join(","),
-    t.vaultKeeperBtcPubkeys.join(",")
-  ), l(
-    e.universalChallengerBtcPubkeys,
-    t.universalChallengerBtcPubkeys
-  ) || r(
-    "universalChallengerBtcPubkeys",
-    e.universalChallengerBtcPubkeys.join(","),
-    t.universalChallengerBtcPubkeys.join(",")
-  );
-  const s = A(t.vaultProviderBtcPubkey), i = e.vaults.map(
-    (n) => A(n.vaultProviderBtcPubkey)
-  );
-  i.includes(s) || r(
-    "vaults[].vaultProviderBtcPubkey",
-    i.join(",") || "<no vaults>",
-    t.vaultProviderBtcPubkey
-  );
-}
-function bt(e, t, r, o) {
-  const a = A(o), l = [
-    A(t),
-    ...r.map(A)
-  ], s = new Set(l);
-  if (s.size !== l.length)
-    throw new Error(
-      "Cannot validate claimer set: signing context contains duplicate vault provider or vault keeper key"
-    );
-  if (s.has(a))
-    throw new Error(
-      "Cannot validate claimer set: depositor key overlaps with vault provider or vault keeper set"
-    );
-  const i = e.map(
-    (h) => A(h.claimer_pubkey)
-  );
-  if (new Set(i).size !== i.length)
-    throw new Error("Presign response contains duplicate claimer entries");
-  const n = i.filter((h) => h !== a), u = new Set(n), p = l.filter((h) => !u.has(h)), c = n.filter((h) => !s.has(h));
-  if (p.length > 0 || c.length > 0)
-    throw new Error(
-      "Presign response claimer set does not match expected (vault provider ∪ vault keepers)" + (p.length > 0 ? ` (missing: ${p.join(", ")})` : "") + (c.length > 0 ? ` (unexpected: ${c.join(", ")})` : "")
-    );
-}
-function Z(e, t) {
-  return {
-    vaultCoreVersion: t.vaultCoreVersion,
-    payoutTxHex: e.payoutTxHex,
-    peginTxHex: t.peginTxHex,
-    assertTxHex: e.assertTxHex,
-    vaultProviderBtcPubkey: t.vaultProviderBtcPubkey,
-    vaultKeeperBtcPubkeys: t.vaultKeeperBtcPubkeys,
-    universalChallengerBtcPubkeys: t.universalChallengerBtcPubkeys,
-    depositorBtcPubkey: t.depositorBtcPubkey,
-    timelockPegin: t.timelockPegin,
-    timelockAssert: t.timelockAssert,
-    registeredPayoutScriptPubKey: t.registeredPayoutScriptPubKey,
-    claimerBtcPubkey: e.claimerPubkeyXOnly,
-    commissionBps: t.commissionBps,
-    protocolFeeRate: t.protocolFeeRate,
-    councilMembers: t.councilMembers,
-    councilQuorum: t.councilQuorum,
-    vkClaimerPayoutScriptPubKeys: t.vkClaimerPayoutScriptPubKeys,
-    vpCommissionScriptPubKey: t.vpCommissionScriptPubKey
-  };
-}
-async function wt(e, t, r, o) {
-  const a = new Ve({
-    network: t.network,
-    btcWallet: e
-  }), l = r.length;
-  o == null || o(0, l);
-  let s;
-  if (a.supportsBatchSigning())
-    s = (await a.signPayoutTransactionsBatch(
-      r.map((u) => Z(u, t))
-    )).map((u) => u.payoutSignature);
-  else {
-    s = [];
-    for (let n = 0; n < r.length; n++) {
-      o == null || o(n, l);
-      const u = await a.signPayoutTransaction(
-        Z(r[n], t)
-      );
-      s.push(u.signature);
-    }
-  }
-  const i = {};
-  for (let n = 0; n < r.length; n++)
-    i[r[n].claimerPubkeyXOnly] = {
-      payout_signature: s[n]
-    };
-  return o == null || o(l, l), i;
-}
-async function ir(e) {
-  const {
-    statusReader: t,
-    presignClient: r,
-    btcWallet: o,
-    peginTxid: a,
-    depositorPk: l,
-    signingContext: s,
-    depositTerms: i,
-    timeoutMs: n = mt,
-    signal: u,
-    onProgress: p
-  } = e, c = await ye({
-    statusReader: t,
-    peginTxid: a,
-    targetStatuses: Pt,
-    timeoutMs: n,
-    signal: u
-  });
-  if (be.has(c))
-    return;
-  if (u == null || u.throwIfAborted(), i !== void 0 && yt(i, s), Ie(o)) {
-    if (!i)
-      throw new Error(
-        "runDepositorPresignFlow: this wallet requires approved deposit terms but none were provided. Fresh deposits must pass PreparePeginResult.depositTerms; resume flows must rebuild them from on-chain state (the vault app's rebuildDepositTerms)."
-      );
-    typeof o.validateDepositTerms == "function" && await o.validateDepositTerms(i), await o.approveDepositTerms(i);
-  }
-  const h = await r.requestDepositorPresignTransactions(
-    {
-      pegin_txid: a,
-      depositor_pk: l
-    },
-    u
-  );
-  u == null || u.throwIfAborted();
-  const d = A(l);
-  bt(
-    h.txs,
-    s.vaultProviderBtcPubkey,
-    s.vaultKeeperBtcPubkeys,
-    l
-  );
-  const g = h.txs.filter(
-    (b) => A(b.claimer_pubkey) !== d
-  ), m = vt(g), P = await wt(
-    o,
-    s,
-    m,
-    p
-  );
-  u == null || u.throwIfAborted();
-  const f = await gt({
-    depositorGraph: h.depositor_graph,
-    btcWallet: o,
-    signingContext: {
-      vaultCoreVersion: s.vaultCoreVersion,
-      peginTxHex: s.peginTxHex,
-      depositorBtcPubkey: l,
-      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,
-      protocolFeeRate: s.protocolFeeRate,
-      vkClaimerPayoutScriptPubKeys: s.vkClaimerPayoutScriptPubKeys,
-      vpCommissionScriptPubKey: s.vpCommissionScriptPubKey
-    }
-  });
-  u == null || u.throwIfAborted();
-  const x = { ...P };
-  x[y(l)] = f.payout_signatures, await r.submitDepositorPresignatures(
-    {
-      pegin_txid: a,
-      depositor_pk: l,
-      signatures: x,
-      depositor_claimer_presignatures: f
-    },
-    u
-  );
-}
-const Et = 300 * 1e3, kt = /* @__PURE__ */ new Set([
-  R.PENDING_DEPOSITOR_WOTS_PK,
-  ...ge
-]);
-async function ur(e) {
-  const {
-    statusReader: t,
-    wotsSubmitter: r,
-    peginTxid: o,
-    depositorPk: a,
-    wotsPublicKeys: l,
-    timeoutMs: s = Et,
-    signal: i
-  } = e;
-  i == null || i.throwIfAborted();
-  const n = await ye({
-    statusReader: t,
-    peginTxid: o,
-    targetStatuses: kt,
-    timeoutMs: s,
-    signal: i
-  });
-  ge.has(n) || (i == null || i.throwIfAborted(), await r.submitDepositorWotsKey(
-    {
-      pegin_txid: o,
-      depositor_pk: a,
-      wots_public_keys: l
-    },
-    i
-  ));
-}
-function D(e) {
-  return e.registration || e.operation;
-}
-function xt(e, t, r) {
-  const o = C(e);
-  return {
-    registration: o === C(t),
-    operation: o === C(r)
-  };
-}
-function ee(e, t, r) {
-  const o = M(e);
-  return {
-    registration: te(o, M(t)),
-    operation: te(o, M(r))
-  };
-}
-function M(e) {
-  return e.map(C).sort();
-}
-function te(e, t) {
-  return e.length === t.length && e.every((r, o) => r === t[o]);
-}
-async function lr(e) {
-  const {
-    vaultProviderEthAddress: t,
-    hintBtcPubkey: r,
-    registrationBtcPubkey: o,
-    readCurrentOperationBtcPubkey: a,
-    context: l
-  } = e;
-  if (!r) return;
-  const s = C(r);
-  if (s === C(o)) return;
-  const i = C(
-    await a()
-  );
-  if (s !== i)
-    throw new Error(
-      `Vault provider BTC pubkey mismatch for ${t}: indexer hint matches neither the registration key nor the current operation key on-chain.${l ? ` ${l}` : ""}`
-    );
-}
-function F(e, t, r) {
-  const o = `${e} operation key (admin=${t.ethAddress})`, a = Y(
-    t.btcPubKey,
-    `${e} roster key (admin=${t.ethAddress})`
-  ), l = Y(r, o);
-  return {
-    adminAddress: t.ethAddress,
-    genesisBtcPubkey: a,
-    operationBtcPubkey: l,
-    rotated: l !== a
-  };
-}
-function Tt(e) {
-  const t = /* @__PURE__ */ new Map();
-  for (const r of e) {
-    const o = t.get(r.operationBtcPubkey);
-    if (o)
-      throw new Error(
-        `Participant operation key collision: ${o} and ${r.adminAddress} both resolve to operation key ${r.operationBtcPubkey}`
-      );
-    t.set(r.operationBtcPubkey, r.adminAddress);
-  }
-}
-function we(e, t, r) {
-  if (t.vaultKeepers.length !== e.vaultKeepers.length || t.universalChallengers.length !== e.universalChallengers.length)
-    throw new Error(
-      `Operation-key resolution returned ${t.vaultKeepers.length} keeper and ${t.universalChallengers.length} challenger keys for a roster of ${e.vaultKeepers.length} keepers and ${e.universalChallengers.length} challengers`
-    );
-  const o = F(
-    "vault provider",
-    {
-      ethAddress: e.vaultProviderEthAddress,
-      btcPubKey: e.vaultProviderGenesisBtcPubkey
-    },
-    t.vaultProvider
-  ), a = e.vaultKeepers.map(
-    (s, i) => F("vault keeper", s, t.vaultKeepers[i])
-  ), l = e.universalChallengers.map(
-    (s, i) => F("universal challenger", s, t.universalChallengers[i])
-  );
-  return Tt([
-    o,
-    ...a,
-    ...l
-  ]), {
-    vaultProvider: o,
-    vaultKeepers: a,
-    universalChallengers: l,
-    // Derived from the pairs, never the reverse — see ParticipantKeySet.
-    vaultKeeperOperationKeysSorted: a.map((s) => s.operationBtcPubkey).sort(),
-    universalChallengerOperationKeysSorted: l.map((s) => s.operationBtcPubkey).sort(),
-    resolvedAt: r,
-    query: e
-  };
-}
-async function At(e) {
-  const t = await e.operationKeyReader.getCurrentOperationKeys(
-    e.query,
-    e.blockNumber
-  );
-  return we(e.query, t, { mode: "current" });
-}
-async function Ct(e) {
-  const t = await e.operationKeyReader.getOperationKeysAtEpochs(
-    e.query,
-    e.epochs
-  );
-  return we(e.query, t, {
-    mode: "epochs",
-    epochs: e.epochs
-  });
-}
-class L extends Error {
-  constructor(t) {
-    super(t), this.name = "ApplicationEntryPointMismatchError";
-  }
-}
-function cr(e) {
-  return e instanceof L || e instanceof Error && e.name === "ApplicationEntryPointMismatchError";
-}
-const re = (e) => e.map(C).sort();
-async function pr(e) {
-  const {
-    vaultRegistryReader: t,
-    vaultKeeperReader: r,
-    universalChallengerReader: o,
-    vaultProviderEthAddress: a,
-    applicationEntryPoint: l,
-    expectedVaultProviderBtcPubkey: s,
-    expectedVaultKeeperBtcPubkeys: i,
-    expectedUniversalChallengerBtcPubkeys: n,
-    operationKeyReader: u,
-    onIndexerServingOperationKeys: p,
-    onIndexerHintsInconsistent: c,
-    blockNumber: h
-  } = e, [
-    d,
-    g,
-    m,
-    P
-  ] = await Promise.all([
-    t.getVaultProviderApplication(
-      a,
-      h
-    ),
-    t.getVaultProviderGenesisBtcPubKey(
-      a,
-      h
-    ),
-    o.getLatestUniversalChallengersVersion(h),
-    o.getCurrentUcKeyEpoch(h)
-  ]);
-  if (!Ne(l, { strict: !1 }))
-    throw new L(
-      `The application entry point this deposit was prepared for is not a valid address: ${l}`
-    );
-  if (!He(d, l))
-    throw new L(
-      `Vault provider ${a} is registered to application ${d}, but this deposit was prepared for ${l}. Refusing to build: the vault keeper roster, its version, and the keeper key epoch would all resolve against a different application than the one selected.`
-    );
-  const [f, x] = await Promise.all(
-    [
-      r.getCurrentVaultKeepersVersion(
-        d,
-        h
-      ),
-      r.getCurrentAppKeeperKeyEpoch(
-        d,
-        h
-      )
-    ]
-  ), [b, w] = await Promise.all([
-    r.getVaultKeepersByVersion(
-      d,
-      f,
-      h
-    ),
-    o.getUniversalChallengersByVersion(
-      m,
-      h
-    )
-  ]), E = {
-    vaultProvider: C(g),
-    vaultKeepers: re(b.map((k) => k.btcPubKey)),
-    universalChallengers: re(w.map((k) => k.btcPubKey))
-  }, T = await At({
-    operationKeyReader: u,
-    query: {
-      vaultProviderEthAddress: a,
-      vaultProviderGenesisBtcPubkey: `0x${g}`,
-      applicationEntryPoint: d,
-      vaultKeepers: b,
-      universalChallengers: w
-    },
-    blockNumber: h
-  }), v = {
-    vaultProvider: T.vaultProvider.operationBtcPubkey,
-    vaultKeepers: [...T.vaultKeeperOperationKeysSorted],
-    universalChallengers: [
-      ...T.universalChallengerOperationKeysSorted
-    ]
-  }, q = xt(
-    s,
-    E.vaultProvider,
-    v.vaultProvider
-  ), G = ee(
-    i,
-    E.vaultKeepers,
-    v.vaultKeepers
-  ), z = ee(
-    n,
-    E.universalChallengers,
-    v.universalChallengers
-  );
-  if (!D(q))
-    throw new Error(
-      `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${a}. Refresh and try again.`
-    );
-  if (!D(G))
-    throw new Error(
-      `Vault keeper BTC pubkeys (v${f}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
-    );
-  if (!D(z))
-    throw new Error(
-      `Universal challenger BTC pubkeys (v${m}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
-    );
-  const j = [q, G, z], Ce = j.some((k) => k.registration && !k.operation), Q = j.some((k) => k.operation && !k.registration);
-  if (Ce && Q) {
-    const k = `Indexer participant hints are internally inconsistent for vault provider ${a}: some roles match the registration keys while others match the rotated operation keys.`;
-    throw c == null || c(k), new Error(`${k} Refresh and try again.`);
-  }
-  return Q && (p == null || p(
-    `Indexer is serving rotated operation keys for vault provider ${a}`
-  )), {
-    vaultProviderBtcPubkeyXOnly: v.vaultProvider,
-    vaultKeeperBtcPubkeysSorted: v.vaultKeepers,
-    universalChallengerBtcPubkeysSorted: v.universalChallengers,
-    expectedAppVaultKeepersVersion: f,
-    expectedUniversalChallengersVersion: m,
-    appKeeperKeyEpoch: x,
-    ucKeyEpoch: P,
-    registrationKeys: E,
-    participantKeys: T
-  };
-}
-function Rt(e) {
-  return /^[0-9a-fA-F]{64}$/.test(e);
-}
-function hr(e) {
-  const {
-    amountSats: t,
-    minDeposit: r,
-    maxDeposit: o,
-    btcBalance: a,
-    estimatedFeeSats: l,
-    depositorClaimValue: s
-  } = e;
-  return !(t <= 0n || t < r || o && o > 0n && t > o || l == null || s == null || t + l + s > a);
-}
-function dr(e, t, r) {
-  return e <= 0n ? {
-    valid: !1,
-    error: "Deposit amount must be greater than zero"
-  } : e < t ? {
-    valid: !1,
-    error: `Minimum deposit is ${_(t)} BTC`
-  } : r && r > 0n && e > r ? {
-    valid: !1,
-    error: `Maximum deposit is ${_(r)} BTC`
-  } : { valid: !0 };
-}
-function gr(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 (${_(r)} BTC)`
-  } : { valid: !0 };
-}
-function fr(e, t) {
-  if (!e || e.length === 0)
-    return {
-      valid: !1,
-      error: "At least one vault provider must be selected"
-    };
-  const r = t.map(
-    (a) => a.toLowerCase()
-  );
-  return e.filter(
-    (a) => !r.includes(a.toLowerCase())
-  ).length > 0 ? {
-    valid: !1,
-    error: "Invalid vault provider selected"
-  } : { valid: !0 };
-}
-function _t(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 a = e[o];
-    if (a <= 0n)
-      return {
-        valid: !1,
-        error: `Vault ${o + 1} amount must be positive`
-      };
-    if (t && a < t)
-      return {
-        valid: !1,
-        error: `Vault ${o + 1} amount ${_(a)} BTC is below minimum deposit ${_(t)} BTC`
-      };
-    if (r && a > r)
-      return {
-        valid: !1,
-        error: `Vault ${o + 1} amount ${_(a)} BTC exceeds maximum deposit ${_(r)} BTC`
-      };
-  }
-  return { valid: !0 };
-}
-function St(e) {
-  const t = y(e);
-  return Rt(t) ? { valid: !0 } : {
-    valid: !1,
-    error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
-  };
-}
-function $t(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 Bt(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 It(e) {
-  if (e.length === 0)
-    throw new Error("No spendable UTXOs available");
-}
-function mr(e) {
-  const {
-    vaultAmounts: t,
-    confirmedUTXOs: r,
-    vaultProviderBtcPubkey: o,
-    vaultKeeperBtcPubkeys: a,
-    universalChallengerBtcPubkeys: l,
-    minDeposit: s,
-    maxDeposit: i
-  } = e, n = _t(
-    t,
-    s,
-    i
-  );
-  if (!n.valid)
-    throw new Error(n.error);
-  const u = St(o);
-  if (!u.valid)
-    throw new Error(u.error);
-  $t(a), Bt(l), It(r);
-}
-class Ee extends Error {
-  constructor(t) {
-    super(t), this.name = "ParticipantKeyDriftError";
-  }
-}
-function Pr(e) {
-  return e instanceof Ee || e instanceof Error && e.name === "ParticipantKeyDriftError";
-}
-function oe(e, t, r) {
-  return t.length === r.length && t.every((o, a) => o === r[a]) ? null : `${e} expected [${t.join(", ")}], got [${r.join(", ")}]`;
-}
-async function vr(e) {
-  const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: o, expected: a } = e, l = a.query;
-  if (o.length === 0) return;
-  const s = await t.getVaultKeyEpochsBatch(o), i = [];
-  for (const [n, u] of s.entries()) {
-    const p = o[n];
-    let c;
-    try {
-      c = await Ct({
-        operationKeyReader: r,
-        query: l,
-        epochs: u
-      });
-    } catch (g) {
-      i.push(
-        `vault ${p}: could not resolve participants at frozen epochs (vp=${u.vpKeyEpoch}, keeper=${u.appKeeperKeyEpoch}, uc=${u.ucKeyEpoch}): ${g.message}`
-      );
-      continue;
-    }
-    c.vaultProvider.operationBtcPubkey !== a.vaultProvider.operationBtcPubkey && i.push(
-      `vault ${p}: vault provider key expected ${a.vaultProvider.operationBtcPubkey}, got ${c.vaultProvider.operationBtcPubkey}`
-    );
-    const h = oe(
-      `vault ${p}: vault keeper keys`,
-      a.vaultKeeperOperationKeysSorted,
-      c.vaultKeeperOperationKeysSorted
-    );
-    h && i.push(h);
-    const d = oe(
-      `vault ${p}: universal challenger keys`,
-      a.universalChallengerOperationKeysSorted,
-      c.universalChallengerOperationKeysSorted
-    );
-    d && i.push(d);
-  }
-  if (i.length > 0)
-    throw new Ee(
-      `Aborting BTC broadcast: participant operation keys changed during registration (${i.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
-    );
-}
-class ke extends Error {
-  constructor(t) {
-    super(t), this.name = "RegisteredVaultVersionMismatchError";
-  }
-}
-function yr(e) {
-  return e instanceof ke || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
-}
-async function br(e) {
-  const {
-    vaultRegistryReader: t,
-    vaultIds: r,
-    expectedOffchainParamsVersion: o,
-    expectedAppVaultKeepersVersion: a,
-    expectedUniversalChallengersVersion: l,
-    expectedVaultCoreVersion: s
-  } = e, i = await t.getProtocolInfoBatch(r), n = [];
-  if (i.forEach((u, p) => {
-    const c = r[p];
-    u.offchainParamsVersion !== o && n.push(
-      `vault ${c}: offchainParams expected v${o}, got v${u.offchainParamsVersion}`
-    ), u.appVaultKeepersVersion !== a && n.push(
-      `vault ${c}: appVaultKeepers expected v${a}, got v${u.appVaultKeepersVersion}`
-    ), u.universalChallengersVersion !== l && n.push(
-      `vault ${c}: universalChallengers expected v${l}, got v${u.universalChallengersVersion}`
-    ), u.vaultCoreVersion !== s && n.push(
-      `vault ${c}: vaultCoreVersion expected v${s} (build-time active), got v${u.vaultCoreVersion}`
-    );
-  }), n.length > 0)
-    throw new ke(
-      `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${n.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
-    );
-}
-var xe = /* @__PURE__ */ ((e) => (e.CLAIM_EVENT_RECEIVED = "ClaimEventReceived", e.CLAIM_BROADCAST = "ClaimBroadcast", e.ASSERT_BROADCAST = "AssertBroadcast", e.PAYOUT_BROADCAST = "PayoutBroadcast", e.PAYOUT_BLOCKED = "PayoutBlocked", e))(xe || {});
-const Vt = /* @__PURE__ */ new Set([
-  "PayoutBroadcast",
-  "PayoutBlocked"
-  /* PAYOUT_BLOCKED */
-]);
-function wr(e) {
-  return Object.values(xe).includes(
-    e
-  );
-}
-function Er(e) {
-  return !!e && Vt.has(e);
-}
-class Kt extends Error {
-  constructor(r, o) {
-    super(`Refund not yet mature (BIP68 not final): ${o.message}`);
-    S(this, "vaultId");
-    S(this, "cause");
-    this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = o;
-  }
-}
-const Ot = /^0x[0-9a-fA-F]{64}$/, Nt = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, Te = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, Ae = 160, ne = 2e3, se = 10n, ae = 100n;
-function kr(e) {
-  if (!Number.isFinite(e) || e <= 0)
-    throw new Error(
-      `feeRateSatsVb must be a positive finite number, got ${e}`
-    );
-  return BigInt(Math.ceil(e * Ae));
-}
-const Ht = 1, Dt = /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 (!Ot.test(e))
-    throw new Error(
-      `${t} must contain only hex characters after the 0x prefix`
-    );
-}
-function U(e, t) {
-  if (!Number.isInteger(e) || e < 0)
-    throw new Error(`${t} must be a non-negative integer, got ${e}`);
-}
-function Mt(e) {
-  if (X(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 r = 0; r < e.batch.length; r++) {
-    const o = e.batch[r];
-    if (X(o.hashlock, `batch[${r}].hashlock`), !Number.isInteger(o.htlcVout) || o.htlcVout !== r)
-      throw new Error(
-        `batch[${r}].htlcVout must equal ${r} (contiguous vout-ordered vector), got ${o.htlcVout}`
-      );
-    if (typeof o.amount != "bigint" || o.amount <= 0n)
-      throw new Error(
-        `batch[${r}].amount must be a positive bigint, got ${o.amount}`
-      );
-  }
-  const t = e.batch[e.htlcVout];
-  if (t.hashlock.toLowerCase() !== e.hashlock.toLowerCase())
-    throw new Error(
-      `batch[${e.htlcVout}].hashlock (${t.hashlock}) does not match target hashlock (${e.hashlock})`
-    );
-  if (t.amount !== e.amount)
-    throw new Error(
-      `batch[${e.htlcVout}].amount (${t.amount}) does not match target amount (${e.amount})`
-    );
-  if (U(e.offchainParamsVersion, "offchainParamsVersion"), U(e.appVaultKeepersVersion, "appVaultKeepersVersion"), U(
-    e.universalChallengersVersion,
-    "universalChallengersVersion"
-  ), We(
-    e.vaultCoreVersion,
-    "VaultRefundData.vaultCoreVersion"
-  ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
-    throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!Nt.test(e.unsignedPrePeginTxHex))
-    throw new Error(
-      "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
-    );
-  if (!e.depositorBtcPubkey || !Te.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 Ft(e) {
-  if (!e.vaultProviderPubkey || !Te.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}]`
-    );
-}
-async function xr(e) {
-  const {
-    vaultId: t,
-    readVault: r,
-    readPrePeginContext: o,
-    feeRate: a,
-    signPsbt: l,
-    broadcastTx: s,
-    signal: i
-  } = e;
-  i == null || i.throwIfAborted(), X(t, "vaultId");
-  const n = await r();
-  Mt(n), i == null || i.throwIfAborted();
-  const u = await o(n);
-  if (Ft(u), i == null || i.throwIfAborted(), !Number.isFinite(a) || a <= 0)
-    throw new Error(`feeRate must be a positive number, got ${a}`);
-  if (a > ne)
-    throw new Error(
-      `feeRate ${a} sat/vB exceeds refund safety cap ${ne} sat/vB; refusing to sign refund.`
-    );
-  const p = BigInt(Math.ceil(a * Ae)), c = n.amount * se / ae;
-  if (p > c)
-    throw new Error(
-      `Refund fee ${p} sats exceeds the per-vault safety cap of ${c} sats (${se}/${ae} of vault.amount=${n.amount}); refusing to sign refund.`
-    );
-  i == null || i.throwIfAborted();
-  const h = O(
-    n.depositorBtcPubkey
-  ), d = y(n.unsignedPrePeginTxHex), g = Ke(d);
-  if (g !== void 0 && g.vout !== n.batch.length)
-    throw new Error(
-      `Auth-anchor OP_RETURN at vout ${g.vout} does not match batch size (${n.batch.length} HTLC outputs expect the anchor at vout ${n.batch.length}). Refund refused — sibling HTLC vector is incomplete.`
-    );
-  const m = g == null ? void 0 : g.hash;
-  let P;
-  try {
-    P = $.fromHex(d);
-  } catch (v) {
-    throw new Error(
-      `Failed to parse funded Pre-PegIn transaction hex: ${v instanceof Error ? v.message : String(v)}`
-    );
-  }
-  if (P.outs.length < n.batch.length)
-    throw new Error(
-      `Funded Pre-PegIn tx has ${P.outs.length} outputs but batch requires at least ${n.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
-    );
-  const { psbtHex: f } = await Ge({
-    prePeginParams: {
-      vaultCoreVersion: n.vaultCoreVersion,
-      depositorPubkey: h,
-      vaultProviderPubkey: y(u.vaultProviderPubkey),
-      vaultKeeperPubkeys: u.vaultKeeperPubkeys.map(y),
-      universalChallengerPubkeys: u.universalChallengerPubkeys.map(y),
-      hashlocks: n.batch.map((v) => y(v.hashlock)),
-      timelockRefund: u.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: n.batch.map((v) => v.amount),
-      feeRate: u.feeRate,
-      minPeginFeeRate: u.minPeginFeeRate,
-      numLocalChallengers: u.numLocalChallengers,
-      councilQuorum: u.councilQuorum,
-      councilSize: u.councilSize,
-      network: u.network,
-      authAnchorHash: m
-    },
-    fundedPrePeginTxHex: d,
-    htlcVout: n.htlcVout,
-    refundFee: p,
-    // 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: y(n.hashlock)
-  });
-  i == null || i.throwIfAborted();
-  const x = K(
-    n.depositorBtcPubkey,
-    Ht
-  ), b = await l(f, x);
-  B({
-    requestedPsbtHex: f,
-    returnedPsbtHex: b
-  });
-  const w = 0, E = I(
-    b,
-    h,
-    w
-  );
-  V({
-    requestedPsbtHex: f,
-    signatureHex: E,
-    signerXOnlyPubkeyHex: h,
-    inputIndex: w
-  });
-  const T = fe({
-    requestedPsbtHex: f,
-    signaturesHex: [E],
-    signerXOnlyPubkeyHex: h
-  });
-  i == null || i.throwIfAborted();
-  try {
-    return await s(T);
-  } catch (v) {
-    throw v instanceof Error && Dt.test(v.message) ? new Kt(t, v) : v;
-  }
-}
-class ie extends Error {
-  constructor(r, o, a) {
-    super(r);
-    /** Fee the reclaim would have paid, in satoshis. */
-    S(this, "feeSats");
-    /** Sum of the reserves the reclaim would have swept, in satoshis. */
-    S(this, "sweptTotalSats");
-    this.name = "ReclaimUneconomicalError", this.feeSats = o, this.sweptTotalSats = a;
-  }
-}
-const ue = 2e3, le = 25n, ce = 100n, Tr = 10n;
-async function Ut(e, t, r) {
-  for (let o = 0; o < e.length; o++) {
-    const a = Qe(e[o].depositorSignedPeginTxHex), l = he(
-      await Ye(
-        y(a),
-        y(r)
-      )
-    ).toLowerCase();
-    if (l !== t[o].toLowerCase())
-      throw new Error(
-        `Reserve ${o} belongs to vault ${l}, not the requested ${t[o].toLowerCase()}. Refusing to sweep a reserve whose vault is not the one the caller asked for — the reserve funds that vault's claim transaction and cannot be replaced.`
-      );
-  }
-}
-async function Ar(e) {
-  const {
-    vaultIds: t,
-    depositorEthAddress: r,
-    depositorBtcPubkey: o,
-    readVaults: a,
-    feeRate: l,
-    signPsbt: s,
-    broadcastTx: i,
-    signal: n
-  } = e;
-  if (n == null || n.throwIfAborted(), t.length === 0)
-    throw new Error("Reclaim requires at least one vault id; got none.");
-  if (!Number.isFinite(l) || l <= 0)
-    throw new Error(`feeRate must be a positive number, got ${l}`);
-  if (l > ue)
-    throw new ie(
-      `Fee rate ${l} sat/vB exceeds the reclaim safety cap of ${ue} sat/vB; refusing to sign.`,
-      0n,
-      0n
-    );
-  const u = await a();
-  if (n == null || n.throwIfAborted(), u.length !== t.length)
-    throw new Error(
-      `readVaults returned ${u.length} reserves for ${t.length} vault id(s); refusing to sweep a set that does not match the request.`
-    );
-  await Ut(u, t, r), n == null || n.throwIfAborted();
-  const p = O(o), c = u.map((w) => ({
-    depositorSignedPeginTxHex: w.depositorSignedPeginTxHex,
-    observed: w.observed,
-    expectedValue: w.expectedClaimValue
-  })), h = ze(l, c.length), d = c.reduce((w, E) => w + E.expectedValue, 0n), g = d * le / ce;
-  if (h > g)
-    throw new ie(
-      `Reclaim fee ${h} sats exceeds ${le}/${ce} of the swept total (${d} sats, cap ${g} sats). The reserve is not at risk — it stays where it is until fee rates fall.`,
-      h,
-      d
-    );
-  n == null || n.throwIfAborted();
-  const { psbtHex: m } = je({
-    depositorPubkey: p,
-    inputs: c,
-    feeSats: h
-  });
-  n == null || n.throwIfAborted();
-  const P = K(
-    o,
-    c.length
-  ), f = await s(m, P);
-  B({
-    requestedPsbtHex: m,
-    returnedPsbtHex: f
-  });
-  const x = c.map((w, E) => {
-    const T = I(
-      f,
-      p,
-      E
-    );
-    return V({
-      requestedPsbtHex: m,
-      signatureHex: T,
-      signerXOnlyPubkeyHex: p,
-      inputIndex: E
-    }), T;
-  }), b = fe({
-    requestedPsbtHex: m,
-    signaturesHex: x,
-    signerXOnlyPubkeyHex: p
-  });
-  return n == null || n.throwIfAborted(), i(b);
-}
-export {
-  L as A,
-  D as B,
-  xt as C,
-  ee as D,
-  At as E,
-  Ct as F,
-  xe as G,
-  wr as H,
-  Er as I,
-  Kt as J,
-  xr as K,
-  kr as L,
-  ae as M,
-  se as N,
-  ne as O,
-  ot as P,
-  Ae as Q,
-  ke as R,
-  ie as S,
-  Ar as T,
-  ce as U,
-  le as V,
-  ue as W,
-  Tr as X,
-  or as a,
-  nr as b,
-  Pe as c,
-  ve as d,
-  sr as e,
-  ur as f,
-  cr as g,
-  hr as h,
-  it as i,
-  dr as j,
-  mr as k,
-  fr as l,
-  gr as m,
-  _t as n,
-  St as o,
-  Ee as p,
-  Pr as q,
-  ir as r,
-  gt as s,
-  vr as t,
-  yr as u,
-  pr as v,
-  ar as w,
-  br as x,
-  ye as y,
-  lr as z
-};
-//# sourceMappingURL=buildAndBroadcastReclaim-OMvihzJg.js.map