@babylonlabs-io/ts-sdk 3.0.2 → 3.1.0

package/dist/buildAndBroadcastReclaim-D5520lbL.js

@@ -1,2210 +0,0 @@
-var dt = Object.defineProperty;
-var gt = (e, t, r) => t in e ? dt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var K = (e, t, r) => gt(e, typeof t != "symbol" ? t + "" : t, r);
-import { B as Me } from "./BTCVaultRegistry.abi-B0x9_Bza.js";
-import { e as Fe, s as b, i as ft, c as C, v as yt, u as Le, p as Q, f as H } from "./bitcoin-C-TuHb-v.js";
-import { v as bt, d as Ue, s as mt, P as vt, a as Pt } from "./PayoutManager-BSwbUQeF.js";
-import { Buffer as A } from "buffer";
-import { b as xt, a as U, c as wt } from "./signing-Dhr2t0Z6.js";
-import { buildClaimPsbt as Et, buildAssertClaimerPsbt as _t, buildPayoutClaimerPsbt as kt, buildWronglyChallengedPsbts as Tt, buildPayoutDepositorPsbt as $t, finalizeClaimTx as Ct, buildWatchtowerArtifacts as At, extractTapScriptSig as St, expandWotsSeed as It, wotsKeypairFromSeed as Rt, validateWotsKeypairAgainstGraph as Bt, verifyWatchtowerArtifacts as Vt, deriveVaultId as Ht } from "./tbv/core/wasm/index.js";
-import { p as Ge, P as G, f as Ot, i as X, g as q, j } from "./verifyScriptPathSchnorrSignature-CpjSTfMj.js";
-import { Psbt as Xe, Transaction as B } from "bitcoinjs-lib";
-import { m as ge, n as fe, N as J, o as ye, D as be } from "./constants-D5vORbQE.js";
-import { d as Nt } from "./deriveVaultRoot-BcvmER1E.js";
-import { d as Kt, a as me } from "./onChainBtcPubkey-CCTdl53s.js";
-import { zeroAddress as Dt, isAddress as Mt, isAddressEqual as Ft } from "viem";
-import { v as ve, D as R, c as Lt, b as Ut, R as Gt, d as qe } from "./state-CFn1rT74.js";
-import { h as Pe, b as Xt, s as qt, j as jt } from "./sha2-YqVHJiFj.js";
-import { d as zt, c as Wt, b as Yt, f as je, e as Qt, a as Jt } from "./noPayout-qBXWKwav.js";
-import { a as Zt } from "./secp256k1-D-H9jmd7.js";
-const er = /^0x[0-9a-fA-F]{64}$/, tr = /^0x[0-9a-fA-F]{40}$/, rr = /^0x([0-9a-fA-F]{2})*$/;
-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 (!er.test(e))
-    throw new Error(
-      `${t} must contain only hex characters after the 0x prefix`
-    );
-}
-function or(e, t) {
-  if (!tr.test(e))
-    throw new Error(
-      `${t} must be a 20-byte 0x-prefixed hex address (42 chars)`
-    );
-}
-function nr(e, t) {
-  if (!rr.test(e))
-    throw new Error(
-      `${t} must be a 0x-prefixed hex string with an even number of hex chars`
-    );
-}
-function ze(e) {
-  or(e.btcVaultRegistryAddress, "btcVaultRegistryAddress"), Z(e.vaultId, "vaultId");
-  const t = Fe(e.secret);
-  if (Z(t, "secret"), e.hashlock !== void 0 && (Z(e.hashlock, "hashlock"), !bt(t, e.hashlock)))
-    throw new Error(
-      "Invalid secret: SHA256(secret) does not match the provided hashlock"
-    );
-  return t;
-}
-async function Uo(e) {
-  const {
-    btcVaultRegistryAddress: t,
-    vaultId: r,
-    hashlock: o,
-    activationMetadata: n,
-    writeContract: i,
-    signal: a
-  } = e;
-  a == null || a.throwIfAborted();
-  const s = ze({
-    btcVaultRegistryAddress: t,
-    vaultId: r,
-    secret: e.secret,
-    hashlock: o
-  });
-  return nr(n, "activationMetadata"), i({
-    address: t,
-    abi: Me,
-    functionName: "activateVaultWithSecret",
-    args: [r, s, n]
-  });
-}
-async function Go(e) {
-  const { btcVaultRegistryAddress: t, vaultId: r, hashlock: o, writeContract: n, signal: i } = e;
-  i == null || i.throwIfAborted();
-  const a = ze({
-    btcVaultRegistryAddress: t,
-    vaultId: r,
-    secret: e.secret,
-    hashlock: o
-  });
-  return n({
-    address: t,
-    abi: Me,
-    functionName: "activateVaultWithSecretAndRedeem",
-    args: [r, a]
-  });
-}
-class sr extends Error {
-  constructor(t, r) {
-    super(
-      "Transaction graph's challenger set does not match the vault's (local ∪ universal)" + (t.length > 0 ? ` (missing: ${t.join(", ")})` : "") + (r.length > 0 ? ` (unexpected: ${r.join(", ")})` : "") + ". Refusing to sign an incomplete or padded challenger set."
-    ), this.missing = t, this.unexpected = r, this.name = "ChallengerSetMismatchError";
-  }
-}
-function ar(e) {
-  const t = Ge({
-    claimerBtcPubkey: e.depositorBtcPubkey,
-    depositorBtcPubkey: e.depositorBtcPubkey,
-    vaultProviderBtcPubkey: e.vaultProviderBtcPubkey,
-    vaultKeeperBtcPubkeys: e.vaultKeeperBtcPubkeys
-  }), r = e.universalChallengerBtcPubkeys.map(xe), o = t.filter((c) => r.includes(c));
-  if (o.length > 0)
-    throw new Error(
-      `Cannot check the challenger set: vault keepers and universal challengers overlap (${o.join(", ")}).`
-    );
-  const n = e.graphChallengerPubkeys.map(xe), i = new Set(n);
-  if (i.size !== n.length)
-    throw new Error(
-      "Transaction graph lists the same challenger more than once."
-    );
-  const a = [...t, ...r], s = new Set(a), u = a.filter((c) => !i.has(c)), l = n.filter((c) => !s.has(c));
-  if (u.length > 0 || l.length > 0)
-    throw new sr(u, l);
-}
-function xe(e) {
-  return b(e).toLowerCase();
-}
-const We = 0;
-class ir extends Error {
-  constructor(t, r) {
-    super(
-      `Payout transaction output ${We} pays ${r}, not the vault's registered payout script ${t}. Refusing to sign a payout to another destination.`
-    ), this.expectedScriptHex = t, this.actualScriptHex = r, this.name = "PayoutDestinationError";
-  }
-}
-function ur(e) {
-  let t;
-  try {
-    t = Xe.fromBase64(e.payoutPsbtBase64);
-  } catch (u) {
-    throw new Error("Payout PSBT cannot be parsed.", { cause: u });
-  }
-  const { version: r, locktime: o, outs: n } = cr(t);
-  if (r !== ge || o !== fe)
-    throw new Error(
-      `Payout transaction has version ${r} and locktime ${o}, expected ${ge} and ${fe}.`
-    );
-  if (n.length !== J)
-    throw new Error(
-      `Payout transaction has ${n.length} output(s), expected exactly ${J} for a depositor-as-claimer payout.`
-    );
-  const i = b(
-    e.registeredPayoutScriptPubKey
-  ).toLowerCase();
-  if (i.length === 0)
-    throw new Error(
-      "registeredPayoutScriptPubKey is empty; the vault's on-chain payout script is required to check the Payout destination."
-    );
-  const a = n[We].script.toString("hex").toLowerCase();
-  if (!A.from(a, "hex").equals(A.from(i, "hex")))
-    throw new ir(i, a);
-  const s = n[J - 1];
-  if (s.value !== ye)
-    throw new Error(
-      `Payout CPFP anchor value ${s.value} sats must equal ${ye} sats.`
-    );
-}
-function cr(e) {
-  return {
-    version: e.version,
-    locktime: e.locktime,
-    outs: e.txOutputs.map((t) => ({
-      script: A.from(t.script),
-      value: t.value
-    }))
-  };
-}
-const Ye = 0;
-class lr extends Error {
-  constructor(t, r, o) {
-    super(
-      `Transaction graph does not belong to vault ${t}: its Claim spends PegIn ${o}, which derives vault ${r}. Refusing to sign for a graph served for another vault.`
-    ), this.expectedVaultId = t, this.derivedVaultId = r, this.peginTxid = o, this.name = "VaultIdBindingError";
-  }
-}
-function hr(e) {
-  let t;
-  try {
-    t = Xe.fromBase64(e);
-  } catch (o) {
-    throw new Error("Claim PSBT cannot be parsed.", { cause: o });
-  }
-  const r = t.txInputs[Ye];
-  if (!r)
-    throw new Error("Claim PSBT carries no PegIn input to bind the vault to.");
-  return Je(r.hash);
-}
-function pr(e) {
-  const t = e.ins[Ye];
-  if (!t)
-    throw new Error(
-      "Artifacts file's claim_tx carries no PegIn input to bind the vault to."
-    );
-  return Je(t.hash);
-}
-function Qe(e) {
-  const t = z(
-    Kt(e.peginTxid, e.depositorEthAddress)
-  ), r = z(e.expectedVaultId);
-  if (t !== r)
-    throw new lr(r, t, e.peginTxid);
-}
-function z(e) {
-  return `0x${(e.startsWith("0x") ? e.slice(2) : e).toLowerCase()}`;
-}
-function Je(e) {
-  return A.from(e).reverse().toString("hex");
-}
-const dr = 0, gr = 0, fr = 1, yr = 0, br = 0;
-async function Xo(e) {
-  const { txGraphVersion: t } = e.vault, r = e.source.txGraphJson, [o, n, i, a] = await Promise.all([
-    Et(t, r),
-    _t(t, r),
-    kt(t, r),
-    Tt(t, r)
-  ]);
-  Qe({
-    peginTxid: hr(o),
-    depositorEthAddress: e.vault.depositorEthAddress,
-    expectedVaultId: e.vault.vaultId
-  });
-  const s = await $t(
-    t,
-    r
-  );
-  for (const x of [i, s])
-    ur({
-      payoutPsbtBase64: x,
-      registeredPayoutScriptPubKey: e.vault.registeredPayoutScriptPubKey
-    });
-  ar({
-    graphChallengerPubkeys: Object.keys(a),
-    depositorBtcPubkey: e.depositorPublicKey,
-    vaultProviderBtcPubkey: e.vault.vaultProviderBtcPubkey,
-    vaultKeeperBtcPubkeys: e.vault.vaultKeeperBtcPubkeys,
-    universalChallengerBtcPubkeys: e.vault.universalChallengerBtcPubkeys
-  });
-  const u = [
-    { psbtBase64: o, inputIndex: dr },
-    { psbtBase64: n, inputIndex: gr },
-    { psbtBase64: i, inputIndex: fr },
-    {
-      psbtBase64: s,
-      inputIndex: yr
-    }
-  ], l = Object.keys(a);
-  for (const x of l)
-    for (const w of a[x])
-      u.push({ psbtBase64: w, inputIndex: br });
-  const c = await vr(
-    e.btcWallet,
-    e.depositorPublicKey,
-    e.btcNetwork,
-    u
-  );
-  let h = 0;
-  const p = c[h++], d = c[h++], g = c[h++], y = c[h++], f = {};
-  for (const x of l) {
-    const w = a[x].length;
-    f[x] = c.slice(
-      h,
-      h + w
-    ), h += w;
-  }
-  const P = await Ct(
-    t,
-    r,
-    p
-  );
-  return At({
-    txGraphVersion: t,
-    graphJson: r,
-    signedClaimTxHex: P,
-    assertClaimerSigHex: d,
-    payoutClaimerSigHex: g,
-    wronglyChallengedSigs: f,
-    depositorPayoutSigHex: y,
-    verifyingKeyHex: e.source.verifyingKeyHex,
-    claimableEventBlockNumber: e.vault.claimableEventBlockNumber,
-    proverCircuitVersion: e.vault.proverCircuitVersion,
-    vaultIdHex: e.vault.vaultId,
-    babeSessionsJson: e.babeSessionsJson,
-    expectedVaultCoreVersion: e.vault.vaultCoreVersion
-  });
-}
-function we(e) {
-  const t = e.replace(/^0x/, "").toLowerCase();
-  if (t.length === 66) return t.slice(2);
-  if (t.length === 64) return t;
-  throw new Error(
-    `Public key must be 33-byte compressed or 32-byte x-only hex, got ${t.length / 2} bytes.`
-  );
-}
-async function mr(e, t, r) {
-  const o = await e.getPublicKeyHex();
-  if (we(o) !== we(t))
-    throw new Error(
-      "Connected wallet does not hold the vault's depositor key. Select the account that made the deposit, then try again."
-    );
-  const n = await e.getAddress();
-  if (!ft(n, t, r))
-    throw new Error(
-      `Connected wallet reports address "${n}", which is not derived from the vault's depositor key. Select the account that made the deposit, then try again.`
-    );
-  return n;
-}
-async function vr(e, t, r, o) {
-  const n = await mr(
-    e,
-    t,
-    r
-  ), i = await Ue(
-    e,
-    o.map((a) => Pr(a.psbtBase64)),
-    o.map(
-      (a) => xt(
-        t,
-        a.inputIndex,
-        n
-      )
-    )
-  );
-  return Promise.all(
-    i.map(
-      (a, s) => St(xr(a), o[s].inputIndex)
-    )
-  );
-}
-function Pr(e) {
-  return A.from(e, "base64").toString("hex");
-}
-function xr(e) {
-  return A.from(e, "hex").toString("base64");
-}
-async function qo(e) {
-  const t = await Nt(e.btcWallet, e.vaultContext);
-  let r;
-  try {
-    r = await It(t, e.htlcVout);
-  } finally {
-    t.fill(0);
-  }
-  let o;
-  try {
-    o = await Rt(r);
-  } finally {
-    r.fill(0);
-  }
-  return wr(o.pk_hash, e.expectedWotsPkHash), await Bt(
-    e.txGraphVersion,
-    o.keypair,
-    e.txGraphJson
-  ), {
-    wotsKeypairJson: JSON.stringify(o.keypair),
-    pkHash: o.pk_hash
-  };
-}
-function wr(e, t) {
-  if (L(e) !== L(t))
-    throw new Error(
-      `Derived WOTS public-key hash ${L(e)} does not match the vault's on-chain depositorWotsPkHash ${L(t)}. The wallet, the HTLC output index, or the derivation itself is not the one this vault was created with.`
-    );
-}
-function L(e) {
-  return `0x${(e.startsWith("0x") ? e.slice(2) : e).toLowerCase()}`;
-}
-const Er = 3;
-class _r extends Error {
-  constructor(t, r) {
-    super(
-      `Artifacts belong to vault ${r}, not ${t}. Select the artifacts file saved for this vault.`
-    ), this.expectedVaultId = t, this.actualVaultId = r, this.name = "ArtifactsVaultMismatchError";
-  }
-}
-function kr(e) {
-  let t;
-  try {
-    t = JSON.parse(e);
-  } catch (a) {
-    throw new Error("Artifacts file is not valid JSON.", { cause: a });
-  }
-  const r = Ee(t.vault_id, "vault_id"), o = Tr(Ee(t.claim_tx, "claim_tx")), n = ee(
-    t.prover_circuit_version,
-    "prover_circuit_version"
-  ), i = t.claimable_event_block_number === void 0 ? 0n : BigInt(
-    ee(
-      t.claimable_event_block_number,
-      "claimable_event_block_number"
-    )
-  );
-  return {
-    vaultCoreVersion: t.vault_core_version === void 0 ? void 0 : ee(t.vault_core_version, "vault_core_version"),
-    vaultId: r,
-    claimTxid: o.getId(),
-    peginTxid: pr(o),
-    proverCircuitVersion: n,
-    claimableEventBlockNumber: i,
-    babeSessionChallengerPubkeys: Object.keys(
-      $r(t.babe_sessions, "babe_sessions")
-    )
-  };
-}
-async function jo(e) {
-  const t = kr(e.artifactsJson), r = z(e.expectedVaultId), o = z(t.vaultId);
-  if (r !== o)
-    throw new _r(r, o);
-  Qe({
-    peginTxid: t.peginTxid,
-    depositorEthAddress: e.depositorEthAddress,
-    expectedVaultId: r
-  });
-  const n = e.txGraphVersion ?? Er;
-  if (t.vaultCoreVersion !== void 0 && t.vaultCoreVersion !== n)
-    throw new Error(
-      `Artifacts record vault core version ${t.vaultCoreVersion}, but verification was asked for version ${n}.`
-    );
-  if (t.claimableEventBlockNumber === 0n)
-    throw new Error(
-      "Artifacts carry no claimable event block number. They were assembled before the Ethereum withdrawal was initiated; assemble them again."
-    );
-  return await Vt(n, e.artifactsJson), t;
-}
-function Tr(e) {
-  try {
-    return B.fromHex(e);
-  } catch (t) {
-    throw new Error("Artifacts file carries an unparseable claim_tx.", {
-      cause: t
-    });
-  }
-}
-function Ee(e, t) {
-  if (typeof e != "string" || e.length === 0)
-    throw new Error(`Artifacts file is missing a usable "${t}".`);
-  return e;
-}
-function ee(e, t) {
-  if (typeof e != "number" || !Number.isSafeInteger(e) || e < 0)
-    throw new Error(`Artifacts file is missing a usable "${t}".`);
-  return e;
-}
-function $r(e, t) {
-  if (e === void 0) return {};
-  if (typeof e != "object" || e === null || Array.isArray(e))
-    throw new Error(`Artifacts file is missing a usable "${t}".`);
-  return e;
-}
-const Cr = 8, Ar = 6e3, Sr = 10 * 6e4, Ir = 10;
-class Ze extends Error {
-  constructor(t) {
-    super(t), this.name = "PeginRegistrationMissingError";
-  }
-}
-class et extends Error {
-  constructor(t) {
-    super(t), this.name = "PeginRegistrationNotFinalError";
-  }
-}
-function Rr(e) {
-  return e instanceof Ze || e instanceof Error && e.name === "PeginRegistrationMissingError";
-}
-function zo(e) {
-  return e instanceof et || e instanceof Error && e.name === "PeginRegistrationNotFinalError";
-}
-function _e(e) {
-  const { currentBlock: t, createdAtBlock: r } = e, o = t - r + 1n;
-  return o < 0n ? 0 : Number(o);
-}
-async function Wo(e) {
-  const {
-    vaultRegistryReader: t,
-    getBlockNumber: r,
-    vaultIds: o,
-    required: n = Cr,
-    pollIntervalMs: i = Ar,
-    timeoutMs: a = Sr,
-    signal: s,
-    onProgress: u
-  } = e;
-  if (o.length === 0)
-    throw new Error(
-      "waitForPeginRegistrationDepth requires at least one vault ID"
-    );
-  const l = Date.now();
-  let c = !1, h = 0, p;
-  for (; ; ) {
-    if (s != null && s.aborted)
-      throw new Error(
-        `Aborted while waiting for peg-in registration depth (${o.length} vault(s))`
-      );
-    if (Date.now() - l >= a)
-      throw new et(
-        `Peg-in registration did not reach ${n} Ethereum confirmations within ${a}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.` + (p instanceof Error ? ` Last read error: ${p.message}` : "")
-      );
-    try {
-      const d = await r(), g = await Promise.all(
-        o.map((f) => t.getVaultBasicInfo(f))
-      ), y = g.findIndex(
-        (f) => f.depositor === Dt || f.createdAt === 0n
-      );
-      if (y !== -1) {
-        if (h += 1, !c && h > Ir)
-          throw new Ze(
-            `Vault ${o[y]} is still not visible on-chain after ${h} reads — the registration does not exist.`
-          );
-        console.warn(
-          `Peg-in registration for vault ${o[y]} is not visible in chain state at block ${d} — a lagging RPC backend or an Ethereum reorg. Still polling.`
-        ), u == null || u({ confirmations: 0, required: n });
-      } else {
-        c = !0, h = 0, p = void 0;
-        let f = g[0], P = _e({
-          currentBlock: d,
-          createdAtBlock: g[0].createdAt
-        });
-        for (const x of g.slice(1)) {
-          const w = _e({
-            currentBlock: d,
-            createdAtBlock: x.createdAt
-          });
-          w < P && (P = w, f = x);
-        }
-        if (u == null || u({ confirmations: P, required: n }), P >= n)
-          return { confirmations: P, basicInfo: f };
-      }
-    } catch (d) {
-      if (Rr(d))
-        throw d;
-      console.warn(
-        `Registration-depth read failed (retrying in ${i}ms): ` + (d instanceof Error ? d.message : String(d))
-      ), p = d;
-    }
-    await new Promise((d, g) => {
-      const y = () => {
-        clearTimeout(f), g(
-          new Error(
-            `Aborted while waiting for peg-in registration depth (${o.length} vault(s))`
-          )
-        );
-      }, f = setTimeout(() => {
-        s == null || s.removeEventListener("abort", y), d();
-      }, i);
-      s == null || s.addEventListener("abort", y, { once: !0 });
-    });
-  }
-}
-const Br = /^(?:[0-9a-f]{2})*$/, Vr = /^[0-9a-f]{64}$/, Hr = /^([0-9a-f]{64}):(0|[1-9][0-9]*)$/, Or = -2147483648, Nr = 2147483647, te = 4294967295, ke = 2, Te = 2, W = 0;
-class m extends Error {
-  constructor(t) {
-    super(t), this.name = "GraphFingerprintError";
-  }
-}
-function E(e, t, r) {
-  const o = e[t];
-  if (o === void 0)
-    throw new m(`Graph tx ${r} is missing "${t}"`);
-  return o;
-}
-function M(e, t) {
-  if (!Array.isArray(e))
-    throw new m(`Graph tx ${t} is not an array`);
-  return e;
-}
-function S(e, t) {
-  if (e === null || typeof e != "object" || Array.isArray(e))
-    throw new m(`Graph tx ${t} is not an object`);
-  return e;
-}
-function D(e, t, r, o) {
-  if (typeof e != "number" || !Number.isSafeInteger(e) || e < r || e > o)
-    throw new m(
-      `Graph tx ${t} is not an integer in [${r}, ${o}]`
-    );
-  return e;
-}
-function re(e, t) {
-  if (typeof e != "string" || !Br.test(e))
-    throw new m(
-      `Graph tx ${t} is not lowercase hex without a prefix`
-    );
-  return A.from(e, "hex");
-}
-function Y(e, t) {
-  if (typeof e != "string" || !Vr.test(e))
-    throw new m(
-      `Graph ${t} is not 32 bytes of lowercase hex`
-    );
-  return e;
-}
-function $e(e, t) {
-  const r = S(e, t), o = new B();
-  return o.version = D(
-    E(r, "version", t),
-    `${t}.version`,
-    Or,
-    Nr
-  ), o.locktime = D(
-    E(r, "lock_time", t),
-    `${t}.lock_time`,
-    0,
-    te
-  ), M(E(r, "input", t), `${t}.input`).forEach((n, i) => {
-    const a = `${t}.input[${i}]`, s = S(n, a), u = E(s, "previous_output", a), l = typeof u == "string" && Hr.exec(u);
-    if (!l)
-      throw new m(
-        `Graph tx ${a}.previous_output is not "<txid>:<vout>"`
-      );
-    const c = D(Number(l[2]), `${a}.previous_output vout`, 0, te);
-    o.addInput(
-      A.from(l[1], "hex").reverse(),
-      c,
-      D(E(s, "sequence", a), `${a}.sequence`, 0, te),
-      re(E(s, "script_sig", a), `${a}.script_sig`)
-    ), o.ins[i].witness = M(
-      E(s, "witness", a),
-      `${a}.witness`
-    ).map((h, p) => re(h, `${a}.witness[${p}]`));
-  }), M(E(r, "output", t), `${t}.output`).forEach((n, i) => {
-    const a = `${t}.output[${i}]`, s = S(n, a);
-    o.addOutput(
-      re(E(s, "script_pubkey", a), `${a}.script_pubkey`),
-      D(E(s, "value", a), `${a}.value`, 0, Number.MAX_SAFE_INTEGER)
-    );
-  }), new Uint8Array(o.toBuffer());
-}
-function O(e, t) {
-  const r = b(e).toLowerCase();
-  let o;
-  try {
-    o = B.fromHex(r);
-  } catch (n) {
-    throw new m(
-      `Presign ${t} is not one transaction: ${n instanceof Error ? n.message : String(n)}`
-    );
-  }
-  if (o.toHex() !== r)
-    throw new m(
-      `Presign ${t} is not a canonical transaction encoding`
-    );
-  return o;
-}
-function tt(e, t) {
-  const r = e.ins[t];
-  if (r)
-    return {
-      txid: A.from(r.hash).reverse().toString("hex"),
-      vout: r.index
-    };
-}
-function rt(e, t) {
-  if (!e.outs[W])
-    throw new m(
-      `Presign ${t}.claim_tx must have output ${W}`
-    );
-}
-function Kr(e, t, r) {
-  if (e.ins.length !== 1)
-    throw new m(
-      `Presign ${r}.claim_tx must have exactly one input, got ${e.ins.length}`
-    );
-  rt(e, r);
-  const o = tt(e, 0);
-  if ((o == null ? void 0 : o.txid) !== t || o.vout !== G) {
-    const n = o ? `${o.txid}:${o.vout}` : "no input";
-    throw new m(
-      `Presign ${r}.claim_tx must spend ${t}:${G}, got ${n}`
-    );
-  }
-}
-function le(e, t, r) {
-  const o = tt(e, 0);
-  if ((o == null ? void 0 : o.txid) !== t || o.vout !== W) {
-    const n = o ? `${o.txid}:${o.vout}` : "no input";
-    throw new m(
-      `Presign ${r}.assert_tx input 0 must spend ${t}:${W}, got ${n}`
-    );
-  }
-}
-function ot(e) {
-  const t = O(e.peginTxHex, `${e.path}.pegin_tx`), r = O(e.claimTxHex, `${e.path}.claim_tx`), o = O(e.assertTxHex, `${e.path}.assert_tx`);
-  return { peginTx: t, claimTx: r, assertTx: o };
-}
-function Dr(e) {
-  const t = O(e.claimTxHex, `${e.path}.claim_tx`), r = O(e.assertTxHex, `${e.path}.assert_tx`);
-  rt(t, e.path), le(r, t.getId(), e.path);
-}
-function Mr(e) {
-  const { peginTx: t, claimTx: r, assertTx: o } = ot(e);
-  Kr(r, t.getId(), e.path), le(o, r.getId(), e.path);
-}
-function Fr(e, t) {
-  const [r, ...o] = e.ins;
-  if (!r || o.length > 0)
-    throw new m(
-      `Presign claim_tx must have exactly one input, got ${e.ins.length}`
-    );
-  const n = A.from(r.hash).reverse().toString("hex");
-  if (n !== t || r.index !== G)
-    throw new m(
-      `Presign claim_tx must spend ${t}:${G}, got ${n}:${r.index}`
-    );
-  if (e.version !== ke)
-    throw new m(
-      `Presign claim_tx version must be ${ke}, got ${e.version}`
-    );
-  if (r.witness.length > 0)
-    throw new m(
-      `Presign claim_tx input must have an empty witness, got ${r.witness.length} item(s)`
-    );
-  if (e.outs.length !== Te)
-    throw new m(
-      `Presign claim_tx must have exactly ${Te} outputs, got ${e.outs.length}`
-    );
-}
-function nt(e) {
-  const t = [...e.challengers].sort(
-    (o, n) => o.pubkey < n.pubkey ? -1 : o.pubkey > n.pubkey ? 1 : 0
-  ), r = [e.peginTx, e.claimTx, e.assertTx, e.payoutTx];
-  return t.forEach((o, n) => {
-    const i = Y(o.pubkey, "challenger pubkey");
-    if (n > 0 && t[n - 1].pubkey === i)
-      throw new m(`Graph lists challenger ${i} twice`);
-    r.push(Pe(i), o.nopayoutTx);
-    for (const a of o.outputLabelHashes)
-      r.push(Pe(Y(a, "output_label_hashes entry")));
-  }), Xt(qt(jt(...r)));
-}
-function Lr(e) {
-  const t = b(e.peginTxid).toLowerCase(), { peginTx: r, claimTx: o, assertTx: n } = ot({
-    peginTxHex: e.peginTxHex,
-    claimTxHex: e.claimTxHex,
-    assertTxHex: e.assertTxHex,
-    path: "depositor_graph"
-  });
-  if (r.getId() !== t)
-    throw new m(
-      `Presign pegin_tx hashes to ${r.getId()}, expected ${t}`
-    );
-  Fr(o, t), le(n, o.getId(), "depositor_graph");
-  const i = (a) => new Uint8Array(a.toBuffer());
-  return nt({
-    peginTx: i(r),
-    claimTx: i(o),
-    assertTx: i(n),
-    payoutTx: i(O(e.payoutTxHex, "payout_tx")),
-    challengers: e.challengers.map((a) => ({
-      pubkey: C(a.challenger_pubkey),
-      nopayoutTx: i(O(a.nopayout_tx.tx_hex, "nopayout_tx")),
-      outputLabelHashes: a.output_label_hashes.map(
-        (s) => b(s).toLowerCase()
-      )
-    }))
-  });
-}
-function Ur(e) {
-  const t = (o) => $e(S(E(e, o, "graph"), o).tx, o), r = S(
-    E(e, "challenger_subgraphs", "graph"),
-    "challenger_subgraphs"
-  );
-  return nt({
-    peginTx: t("pegin_tx"),
-    claimTx: t("claim_tx"),
-    assertTx: t("assert_tx"),
-    payoutTx: t("payout_tx"),
-    challengers: Object.entries(r).map(([o, n]) => {
-      const i = `challenger_subgraphs[${o}]`, a = S(n, i);
-      return {
-        pubkey: o,
-        nopayoutTx: $e(
-          S(E(a, "nopayout_tx", i), `${i}.nopayout_tx`).tx,
-          `${i}.nopayout_tx`
-        ),
-        outputLabelHashes: M(
-          E(a, "output_label_hashes", i),
-          `${i}.output_label_hashes`
-        ).map(
-          (s, u) => Y(s, `${i}.output_label_hashes[${u}]`)
-        )
-      };
-    })
-  });
-}
-function Gr(e) {
-  const t = S(
-    E(e, "challenger_pubkeys", "graph"),
-    "challenger_pubkeys"
-  ), r = /* @__PURE__ */ new Set();
-  for (const o of ["local", "universal"])
-    M(
-      E(t, o, "challenger_pubkeys"),
-      `challenger_pubkeys.${o}`
-    ).forEach((n, i) => {
-      const a = Y(n, `challenger_pubkeys.${o}[${i}]`);
-      if (r.has(a))
-        throw new m(
-          `Graph declares challenger ${a} more than once`
-        );
-      r.add(a);
-    });
-  return r;
-}
-function Yo(e, t) {
-  const r = Ur(e);
-  if (r !== t)
-    throw new m(
-      `Graph fingerprint ${r} does not match the presign fingerprint ${t}`
-    );
-  const o = Object.keys(
-    S(e.challenger_subgraphs, "challenger_subgraphs")
-  ), n = Gr(e);
-  if (o.length !== n.size || o.some((i) => !n.has(i)))
-    throw new m(
-      `Graph challenger_subgraphs keys ${o.join(", ")} do not match challenger_pubkeys ${[...n].join(", ")}`
-    );
-}
-const Xr = 1;
-function qr(e, t, r) {
-  const o = r.map(
-    (h) => b(h).toLowerCase()
-  ), n = t.filter((h) => o.includes(h));
-  if (n.length > 0)
-    throw new Error(
-      `Cannot validate challenger set: vault keepers and universal challengers overlap (${n.join(", ")})`
-    );
-  const i = [...t, ...o], a = e.map(
-    (h) => b(h.challenger_pubkey).toLowerCase()
-  ), s = new Set(a);
-  if (s.size !== a.length)
-    throw new Error(
-      "Depositor graph contains duplicate challenger entries in challenger_presign_data"
-    );
-  const u = new Set(i), l = i.filter((h) => !s.has(h)), c = a.filter((h) => !u.has(h));
-  if (l.length > 0 || c.length > 0)
-    throw new Error(
-      "Depositor graph challenger set does not match expected (local ∪ universal)" + (l.length > 0 ? ` (missing: ${l.join(", ")})` : "") + (c.length > 0 ? ` (unexpected: ${c.join(", ")})` : "")
-    );
-}
-function jr(e, t) {
-  const r = e.ins[t];
-  return Le(new Uint8Array(r.hash).slice().reverse());
-}
-function oe(e, t, r, o, n) {
-  const i = e.ins[t];
-  if (i.index !== 0)
-    throw new Error(
-      `NoPayout (challenger ${n}) input ${t} expected to spend ${o} vout 0, got vout ${i.index}`
-    );
-  const a = r.getId(), s = jr(e, t);
-  if (s !== a)
-    throw new Error(
-      `NoPayout (challenger ${n}) input ${t} does not reference ${o} (expected txid ${a}, got ${s})`
-    );
-}
-async function zr(e, t, r) {
-  const o = [], n = [], i = [], a = Ge({
-    claimerBtcPubkey: r.depositorBtcPubkey,
-    depositorBtcPubkey: r.depositorBtcPubkey,
-    vaultProviderBtcPubkey: r.vaultProviderBtcPubkey,
-    vaultKeeperBtcPubkeys: r.vaultKeeperBtcPubkeys
-  });
-  qr(
-    e.challenger_presign_data,
-    a,
-    r.universalChallengerBtcPubkeys
-  );
-  const s = await Ot({
-    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: Xr,
-    protocolFeeRate: r.protocolFeeRate,
-    councilMembers: r.councilMembers,
-    councilQuorum: r.councilQuorum
-  });
-  o.push(s.psbtHex), n.push(
-    U(
-      t,
-      be
-    )
-  );
-  const u = b(r.depositorBtcPubkey), l = B.fromHex(
-    b(e.assert_tx.tx_hex)
-  );
-  for (const c of e.challenger_presign_data) {
-    const h = b(c.challenger_pubkey), p = o.length, d = await Wr({
-      challenger: c,
-      challengerPubkey: h,
-      claimerPubkey: u,
-      localChallengers: a,
-      assertTxParsed: l,
-      ctx: r
-    });
-    o.push(d), n.push(
-      U(
-        t,
-        be
-      )
-    ), i.push({
-      challengerPubkey: h,
-      noPayoutIdx: p
-    });
-  }
-  return { psbtHexes: o, signOptions: n, challengerEntries: i };
-}
-async function Wr(e) {
-  const {
-    challenger: t,
-    challengerPubkey: r,
-    claimerPubkey: o,
-    localChallengers: n,
-    assertTxParsed: i,
-    ctx: a
-  } = e;
-  zt(
-    t.nopayout_tx.tx_hex,
-    r,
-    a.network
-  );
-  const s = B.fromHex(
-    b(t.nopayout_tx.tx_hex)
-  ), u = B.fromHex(
-    b(t.challenge_assert_x_tx.tx_hex)
-  ), l = B.fromHex(
-    b(t.challenge_assert_y_tx.tx_hex)
-  );
-  if (s.ins.length !== 3)
-    throw new Error(
-      `NoPayout (challenger ${r}) must have exactly 3 inputs, got ${s.ins.length}`
-    );
-  oe(
-    s,
-    0,
-    i,
-    "Assert",
-    r
-  ), oe(
-    s,
-    1,
-    u,
-    "ChallengeAssertX",
-    r
-  ), oe(
-    s,
-    2,
-    l,
-    "ChallengeAssertY",
-    r
-  );
-  const c = [
-    i.outs[0],
-    u.outs[0],
-    l.outs[0]
-  ].map((h) => ({
-    script_pubkey: Le(new Uint8Array(h.script)),
-    value: h.value
-  }));
-  return Wt({
-    noPayoutTxHex: t.nopayout_tx.tx_hex,
-    challengerPubkey: r,
-    prevouts: c,
-    connectorParams: {
-      txGraphVersion: a.vaultCoreVersion,
-      claimer: o,
-      localChallengers: n,
-      universalChallengers: a.universalChallengerBtcPubkeys,
-      timelockAssert: a.timelockAssert,
-      councilMembers: a.councilMembers,
-      councilQuorum: a.councilQuorum
-    }
-  });
-}
-function Yr(e, t, r) {
-  X(e[0]);
-  const n = q(
-    e[0].returnedPsbtHex,
-    r
-  );
-  j({
-    requestedPsbtHex: e[0].requestedPsbtHex,
-    signatureHex: n,
-    signerXOnlyPubkeyHex: r,
-    inputIndex: 0
-  });
-  const i = {};
-  for (const a of t) {
-    X(e[a.noPayoutIdx]);
-    const s = q(
-      e[a.noPayoutIdx].returnedPsbtHex,
-      r
-    );
-    j({
-      requestedPsbtHex: e[a.noPayoutIdx].requestedPsbtHex,
-      signatureHex: s,
-      signerXOnlyPubkeyHex: r,
-      inputIndex: 0
-    }), i[a.challengerPubkey] = {
-      nopayout_signature: s
-    };
-  }
-  return {
-    payout_signatures: {
-      payout_signature: n
-    },
-    per_challenger: i
-  };
-}
-async function Qr(e) {
-  const { depositorGraph: t, btcWallet: r, signingContext: o } = e;
-  Mr({
-    peginTxHex: o.peginTxHex,
-    claimTxHex: t.claim_tx.tx_hex,
-    assertTxHex: t.assert_tx.tx_hex,
-    path: "depositor_graph"
-  });
-  const n = await r.getPublicKeyHex(), { depositorPubkey: i } = yt(
-    n,
-    b(o.depositorBtcPubkey)
-  ), { psbtHexes: a, signOptions: s, challengerEntries: u } = await zr(
-    t,
-    n,
-    o
-  ), l = await Ue(
-    r,
-    a,
-    s
-  ), c = a.map((h, p) => ({
-    requestedPsbtHex: h,
-    returnedPsbtHex: l[p]
-  }));
-  return Yr(
-    c,
-    u,
-    i
-  );
-}
-const Jr = 1e4, N = 10;
-async function st(e) {
-  const {
-    statusReader: t,
-    vaultId: r,
-    peginTxid: o,
-    targetStatuses: n,
-    timeoutMs: i,
-    pollIntervalMs: a = Jr,
-    signal: s
-  } = e, u = Date.now();
-  for (; ; ) {
-    if (s != null && s.aborted)
-      throw new Error(
-        `Polling aborted for vault ${r.slice(0, N)}… (target: ${[...n].join(", ")})`
-      );
-    if (Date.now() - u >= i)
-      throw new Error(
-        `Polling timeout after ${i}ms for vault ${r.slice(0, N)}… (target: ${[...n].join(", ")})`
-      );
-    try {
-      const l = await t.getPeginStatusByVaultId(
-        { vault_id: r },
-        s
-      );
-      if (ve(l.vault_id) !== ve(r))
-        throw new Error(
-          `getPeginStatusByVaultId returned status for vault ${l.vault_id.slice(0, N)}…, requested ${r.slice(0, N)}…`
-        );
-      if (l.pegin_txid.toLowerCase() !== o.toLowerCase())
-        throw new Error(
-          `getPeginStatusByVaultId returned status for pegin ${l.pegin_txid.slice(0, 8)}…, requested ${o.slice(0, 8)}…`
-        );
-      const c = l.status;
-      if (n.has(c) || c === R.ACTIVATED)
-        return c;
-      if (c === R.EXPIRED || Lt.has(c))
-        throw new Error(
-          `Vault ${r.slice(0, N)}… reached terminal status "${c}" while waiting for ${[...n].join(", ")}`
-        );
-    } catch (l) {
-      if (!(l instanceof Ut && l.code === Gt.PEGIN_NOT_FOUND))
-        throw l;
-    }
-    await new Promise((l, c) => {
-      const h = () => {
-        clearTimeout(p), c(
-          new Error(
-            `Polling aborted for vault ${r.slice(0, N)}… (target: ${[...n].join(", ")})`
-          )
-        );
-      }, p = setTimeout(() => {
-        s == null || s.removeEventListener("abort", h), l();
-      }, a);
-      s == null || s.addEventListener("abort", h, { once: !0 });
-    });
-  }
-}
-const Zr = 1200 * 1e3, at = /* @__PURE__ */ new Set([
-  R.PENDING_ACKS,
-  R.PENDING_ACTIVATION,
-  R.ACTIVATED_PENDING_BROADCAST,
-  R.ACTIVATED
-]), eo = /* @__PURE__ */ new Set([
-  R.PENDING_DEPOSITOR_SIGNATURES,
-  ...at
-]);
-function to(e) {
-  return e.map((t) => ({
-    claimerPubkeyXOnly: Q(t.claimer_pubkey),
-    payoutTxHex: t.payout_tx.tx_hex,
-    assertTxHex: t.assert_tx.tx_hex
-  }));
-}
-function I(e) {
-  return Q(e).toLowerCase();
-}
-function ro(e, t) {
-  const r = (u, l, c) => {
-    throw new Error(
-      `Deposit terms ${u} (${String(l)}) does not match the vault's version-locked signing context (${String(c)}); 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 [u, l, c] of o)
-    l !== c && r(u, l, c);
-  const n = (u) => u.map(I).sort(), i = (u, l) => {
-    const c = n(u), h = n(l);
-    return c.length === h.length && c.every((p, d) => p === h[d]);
-  };
-  i(e.vaultKeeperBtcPubkeys, t.vaultKeeperBtcPubkeys) || r(
-    "vaultKeeperBtcPubkeys",
-    e.vaultKeeperBtcPubkeys.join(","),
-    t.vaultKeeperBtcPubkeys.join(",")
-  ), i(
-    e.universalChallengerBtcPubkeys,
-    t.universalChallengerBtcPubkeys
-  ) || r(
-    "universalChallengerBtcPubkeys",
-    e.universalChallengerBtcPubkeys.join(","),
-    t.universalChallengerBtcPubkeys.join(",")
-  );
-  const a = I(t.vaultProviderBtcPubkey), s = e.vaults.map(
-    (u) => I(u.vaultProviderBtcPubkey)
-  );
-  s.includes(a) || r(
-    "vaults[].vaultProviderBtcPubkey",
-    s.join(",") || "<no vaults>",
-    t.vaultProviderBtcPubkey
-  );
-}
-function oo(e, t, r, o) {
-  const n = I(o), i = [
-    I(t),
-    ...r.map(I)
-  ], a = new Set(i);
-  if (a.size !== i.length)
-    throw new Error(
-      "Cannot validate claimer set: signing context contains duplicate vault provider or vault keeper key"
-    );
-  if (a.has(n))
-    throw new Error(
-      "Cannot validate claimer set: depositor key overlaps with vault provider or vault keeper set"
-    );
-  const s = e.map(
-    (p) => I(p.claimer_pubkey)
-  );
-  if (new Set(s).size !== s.length)
-    throw new Error("Presign response contains duplicate claimer entries");
-  const u = s.filter((p) => p !== n), l = new Set(u), c = i.filter((p) => !l.has(p)), h = u.filter((p) => !a.has(p));
-  if (c.length > 0 || h.length > 0)
-    throw new Error(
-      "Presign response claimer set does not match expected (vault provider ∪ vault keepers)" + (c.length > 0 ? ` (missing: ${c.join(", ")})` : "") + (h.length > 0 ? ` (unexpected: ${h.join(", ")})` : "")
-    );
-}
-function Ce(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 no(e, t, r, o) {
-  const n = new vt({
-    network: t.network,
-    btcWallet: e
-  }), i = r.length;
-  o == null || o(0, i);
-  let a;
-  if (n.supportsBatchSigning())
-    a = (await n.signPayoutTransactionsBatch(
-      r.map((l) => Ce(l, t))
-    )).map((l) => l.payoutSignature);
-  else {
-    a = [];
-    for (let u = 0; u < r.length; u++) {
-      o == null || o(u, i);
-      const l = await n.signPayoutTransaction(
-        Ce(r[u], t)
-      );
-      a.push(l.signature);
-    }
-  }
-  const s = {};
-  for (let u = 0; u < r.length; u++)
-    s[r[u].claimerPubkeyXOnly] = {
-      payout_signature: a[u]
-    };
-  return o == null || o(i, i), s;
-}
-async function Qo(e) {
-  const {
-    statusReader: t,
-    presignClient: r,
-    btcWallet: o,
-    vaultId: n,
-    peginTxid: i,
-    depositorPk: a,
-    signingContext: s,
-    depositTerms: u,
-    timeoutMs: l = Zr,
-    signal: c,
-    onProgress: h,
-    recordGraphFingerprint: p
-  } = e, d = await st({
-    statusReader: t,
-    vaultId: n,
-    peginTxid: i,
-    targetStatuses: eo,
-    timeoutMs: l,
-    signal: c
-  });
-  if (at.has(d))
-    return;
-  c == null || c.throwIfAborted(), u !== void 0 && ro(u, s);
-  const g = mt(o) ? o : void 0;
-  let y;
-  if (g) {
-    if (!u)
-      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)."
-      );
-    y = u;
-  }
-  const f = await r.requestDepositorPresignTransactions(
-    {
-      pegin_txid: i,
-      depositor_pk: a
-    },
-    c
-  );
-  c == null || c.throwIfAborted(), f.txs.forEach((V, F) => {
-    Dr({
-      claimTxHex: V.claim_tx.tx_hex,
-      assertTxHex: V.assert_tx.tx_hex,
-      path: `txs[${F}]`
-    });
-  });
-  const P = Lr({
-    peginTxid: i,
-    peginTxHex: s.peginTxHex,
-    claimTxHex: f.depositor_graph.claim_tx.tx_hex,
-    assertTxHex: f.depositor_graph.assert_tx.tx_hex,
-    payoutTxHex: f.depositor_graph.payout_tx.tx_hex,
-    challengers: f.depositor_graph.challenger_presign_data
-  }), x = I(a);
-  oo(
-    f.txs,
-    s.vaultProviderBtcPubkey,
-    s.vaultKeeperBtcPubkeys,
-    a
-  );
-  const w = f.txs.filter(
-    (V) => I(V.claimer_pubkey) !== x
-  ), _ = to(w);
-  g && y && (typeof g.validateDepositTerms == "function" && await g.validateDepositTerms(y), await g.approveDepositTerms(y)), c == null || c.throwIfAborted();
-  const k = await no(
-    o,
-    s,
-    _,
-    h
-  );
-  c == null || c.throwIfAborted();
-  const T = await Qr({
-    depositorGraph: f.depositor_graph,
-    btcWallet: o,
-    signingContext: {
-      vaultCoreVersion: s.vaultCoreVersion,
-      peginTxHex: s.peginTxHex,
-      depositorBtcPubkey: a,
-      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
-    }
-  });
-  c == null || c.throwIfAborted(), await p(P), c == null || c.throwIfAborted();
-  const v = { ...k };
-  v[b(a)] = T.payout_signatures, await r.submitDepositorPresignatures(
-    {
-      pegin_txid: i,
-      depositor_pk: a,
-      signatures: v,
-      depositor_claimer_presignatures: T
-    },
-    c
-  );
-}
-const so = 300 * 1e3, ao = /* @__PURE__ */ new Set([
-  R.PENDING_DEPOSITOR_WOTS_PK,
-  ...qe
-]);
-async function Jo(e) {
-  const {
-    statusReader: t,
-    wotsSubmitter: r,
-    vaultId: o,
-    peginTxid: n,
-    depositorPk: i,
-    wotsPublicKeys: a,
-    timeoutMs: s = so,
-    signal: u
-  } = e;
-  u == null || u.throwIfAborted();
-  const l = await st({
-    statusReader: t,
-    vaultId: o,
-    peginTxid: n,
-    targetStatuses: ao,
-    timeoutMs: s,
-    signal: u
-  });
-  qe.has(l) || (u == null || u.throwIfAborted(), await r.submitDepositorWotsKey(
-    {
-      pegin_txid: n,
-      depositor_pk: i,
-      wots_public_keys: a
-    },
-    u
-  ));
-}
-function ne(e) {
-  return e.registration || e.operation;
-}
-function io(e, t, r) {
-  const o = C(e);
-  return {
-    registration: o === C(t),
-    operation: o === C(r)
-  };
-}
-function Ae(e, t, r) {
-  const o = se(e);
-  return {
-    registration: Se(o, se(t)),
-    operation: Se(o, se(r))
-  };
-}
-function se(e) {
-  return e.map(C).sort();
-}
-function Se(e, t) {
-  return e.length === t.length && e.every((r, o) => r === t[o]);
-}
-async function Zo(e) {
-  const {
-    vaultProviderEthAddress: t,
-    hintBtcPubkey: r,
-    registrationBtcPubkey: o,
-    readCurrentOperationBtcPubkey: n,
-    context: i
-  } = e;
-  if (!r) return;
-  const a = C(r);
-  if (a === C(o)) return;
-  const s = C(
-    await n()
-  );
-  if (a !== s)
-    throw new Error(
-      `Vault provider BTC pubkey mismatch for ${t}: indexer hint matches neither the registration key nor the current operation key on-chain.${i ? ` ${i}` : ""}`
-    );
-}
-function ae(e, t, r) {
-  const o = `${e} operation key (admin=${t.ethAddress})`, n = me(
-    t.btcPubKey,
-    `${e} roster key (admin=${t.ethAddress})`
-  ), i = me(r, o);
-  return {
-    adminAddress: t.ethAddress,
-    genesisBtcPubkey: n,
-    operationBtcPubkey: i,
-    rotated: i !== n
-  };
-}
-function uo(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 it(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 = ae(
-    "vault provider",
-    {
-      ethAddress: e.vaultProviderEthAddress,
-      btcPubKey: e.vaultProviderGenesisBtcPubkey
-    },
-    t.vaultProvider
-  ), n = e.vaultKeepers.map(
-    (a, s) => ae("vault keeper", a, t.vaultKeepers[s])
-  ), i = e.universalChallengers.map(
-    (a, s) => ae("universal challenger", a, t.universalChallengers[s])
-  );
-  return uo([
-    o,
-    ...n,
-    ...i
-  ]), {
-    vaultProvider: o,
-    vaultKeepers: n,
-    universalChallengers: i,
-    // Derived from the pairs, never the reverse — see ParticipantKeySet.
-    vaultKeeperOperationKeysSorted: n.map((a) => a.operationBtcPubkey).sort(),
-    universalChallengerOperationKeysSorted: i.map((a) => a.operationBtcPubkey).sort(),
-    resolvedAt: r,
-    query: e
-  };
-}
-async function co(e) {
-  const t = await e.operationKeyReader.getCurrentOperationKeys(
-    e.query,
-    e.blockNumber
-  );
-  return it(e.query, t, { mode: "current" });
-}
-async function lo(e) {
-  const t = await e.operationKeyReader.getOperationKeysAtEpochs(
-    e.query,
-    e.epochs
-  );
-  return it(e.query, t, {
-    mode: "epochs",
-    epochs: e.epochs
-  });
-}
-class ue extends Error {
-  constructor(t) {
-    super(t), this.name = "ApplicationEntryPointMismatchError";
-  }
-}
-function en(e) {
-  return e instanceof ue || e instanceof Error && e.name === "ApplicationEntryPointMismatchError";
-}
-const Ie = (e) => e.map(C).sort();
-async function tn(e) {
-  const {
-    vaultRegistryReader: t,
-    vaultKeeperReader: r,
-    universalChallengerReader: o,
-    vaultProviderEthAddress: n,
-    applicationEntryPoint: i,
-    expectedVaultProviderBtcPubkey: a,
-    expectedVaultKeeperBtcPubkeys: s,
-    expectedUniversalChallengerBtcPubkeys: u,
-    operationKeyReader: l,
-    onIndexerServingOperationKeys: c,
-    onIndexerHintsInconsistent: h,
-    blockNumber: p
-  } = e, [
-    d,
-    g,
-    y,
-    f
-  ] = await Promise.all([
-    t.getVaultProviderApplication(
-      n,
-      p
-    ),
-    t.getVaultProviderGenesisBtcPubKey(
-      n,
-      p
-    ),
-    o.getLatestUniversalChallengersVersion(p),
-    o.getCurrentUcKeyEpoch(p)
-  ]);
-  if (!Mt(i, { strict: !1 }))
-    throw new ue(
-      `The application entry point this deposit was prepared for is not a valid address: ${i}`
-    );
-  if (!Ft(d, i))
-    throw new ue(
-      `Vault provider ${n} is registered to application ${d}, but this deposit was prepared for ${i}. 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 [P, x] = await Promise.all(
-    [
-      r.getCurrentVaultKeepersVersion(
-        d,
-        p
-      ),
-      r.getCurrentAppKeeperKeyEpoch(
-        d,
-        p
-      )
-    ]
-  ), [w, _] = await Promise.all([
-    r.getVaultKeepersByVersion(
-      d,
-      P,
-      p
-    ),
-    o.getUniversalChallengersByVersion(
-      y,
-      p
-    )
-  ]), k = {
-    vaultProvider: C(g),
-    vaultKeepers: Ie(w.map(($) => $.btcPubKey)),
-    universalChallengers: Ie(_.map(($) => $.btcPubKey))
-  }, T = await co({
-    operationKeyReader: l,
-    query: {
-      vaultProviderEthAddress: n,
-      vaultProviderGenesisBtcPubkey: `0x${g}`,
-      applicationEntryPoint: d,
-      vaultKeepers: w,
-      universalChallengers: _
-    },
-    blockNumber: p
-  }), v = {
-    vaultProvider: T.vaultProvider.operationBtcPubkey,
-    vaultKeepers: [...T.vaultKeeperOperationKeysSorted],
-    universalChallengers: [
-      ...T.universalChallengerOperationKeysSorted
-    ]
-  }, V = io(
-    a,
-    k.vaultProvider,
-    v.vaultProvider
-  ), F = Ae(
-    s,
-    k.vaultKeepers,
-    v.vaultKeepers
-  ), he = Ae(
-    u,
-    k.universalChallengers,
-    v.universalChallengers
-  );
-  if (!ne(V))
-    throw new Error(
-      `Vault provider BTC pubkey indexer hint does not match BTCVaultRegistry for ${n}. Refresh and try again.`
-    );
-  if (!ne(F))
-    throw new Error(
-      `Vault keeper BTC pubkeys (v${P}) indexer set does not match ApplicationRegistry on-chain set. Refresh and try again.`
-    );
-  if (!ne(he))
-    throw new Error(
-      `Universal challenger BTC pubkeys (v${y}) indexer set does not match ProtocolParams on-chain set. Refresh and try again.`
-    );
-  const pe = [V, F, he], pt = pe.some(($) => $.registration && !$.operation), de = pe.some(($) => $.operation && !$.registration);
-  if (pt && de) {
-    const $ = `Indexer participant hints are internally inconsistent for vault provider ${n}: some roles match the registration keys while others match the rotated operation keys.`;
-    throw h == null || h($), new Error(`${$} Refresh and try again.`);
-  }
-  return de && (c == null || c(
-    `Indexer is serving rotated operation keys for vault provider ${n}`
-  )), {
-    vaultProviderBtcPubkeyXOnly: v.vaultProvider,
-    vaultKeeperBtcPubkeysSorted: v.vaultKeepers,
-    universalChallengerBtcPubkeysSorted: v.universalChallengers,
-    expectedAppVaultKeepersVersion: P,
-    expectedUniversalChallengersVersion: y,
-    appKeeperKeyEpoch: x,
-    ucKeyEpoch: f,
-    registrationKeys: k,
-    participantKeys: T
-  };
-}
-function ho(e) {
-  return /^[0-9a-fA-F]{64}$/.test(e);
-}
-function rn(e) {
-  const {
-    amountSats: t,
-    minDeposit: r,
-    maxDeposit: o,
-    btcBalance: n,
-    estimatedFeeSats: i,
-    depositorClaimValue: a
-  } = e;
-  return !(t <= 0n || t < r || o && o > 0n && t > o || i == null || a == null || t + i + a > n);
-}
-function on(e, t, r) {
-  return e <= 0n ? {
-    valid: !1,
-    error: "Deposit amount must be greater than zero"
-  } : e < t ? {
-    valid: !1,
-    error: `Minimum deposit is ${H(t)} BTC`
-  } : r && r > 0n && e > r ? {
-    valid: !1,
-    error: `Maximum deposit is ${H(r)} BTC`
-  } : { valid: !0 };
-}
-function nn(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 (${H(r)} BTC)`
-  } : { valid: !0 };
-}
-function sn(e, t) {
-  if (!e || e.length === 0)
-    return {
-      valid: !1,
-      error: "At least one vault provider must be selected"
-    };
-  const r = t.map(
-    (n) => n.toLowerCase()
-  );
-  return e.filter(
-    (n) => !r.includes(n.toLowerCase())
-  ).length > 0 ? {
-    valid: !1,
-    error: "Invalid vault provider selected"
-  } : { valid: !0 };
-}
-function po(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 n = e[o];
-    if (n <= 0n)
-      return {
-        valid: !1,
-        error: `Vault ${o + 1} amount must be positive`
-      };
-    if (t && n < t)
-      return {
-        valid: !1,
-        error: `Vault ${o + 1} amount ${H(n)} BTC is below minimum deposit ${H(t)} BTC`
-      };
-    if (r && n > r)
-      return {
-        valid: !1,
-        error: `Vault ${o + 1} amount ${H(n)} BTC exceeds maximum deposit ${H(r)} BTC`
-      };
-  }
-  return { valid: !0 };
-}
-function go(e) {
-  const t = b(e);
-  return ho(t) ? { valid: !0 } : {
-    valid: !1,
-    error: "Invalid pubkey format: must be 64 hex characters (32-byte x-only public key, no 0x prefix)"
-  };
-}
-function fo(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 yo(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 bo(e) {
-  if (e.length === 0)
-    throw new Error("No spendable UTXOs available");
-}
-function an(e) {
-  const {
-    vaultAmounts: t,
-    confirmedUTXOs: r,
-    vaultProviderBtcPubkey: o,
-    vaultKeeperBtcPubkeys: n,
-    universalChallengerBtcPubkeys: i,
-    minDeposit: a,
-    maxDeposit: s
-  } = e, u = po(
-    t,
-    a,
-    s
-  );
-  if (!u.valid)
-    throw new Error(u.error);
-  const l = go(o);
-  if (!l.valid)
-    throw new Error(l.error);
-  fo(n), yo(i), bo(r);
-}
-class ut extends Error {
-  constructor(t) {
-    super(t), this.name = "ParticipantKeyDriftError";
-  }
-}
-function un(e) {
-  return e instanceof ut || e instanceof Error && e.name === "ParticipantKeyDriftError";
-}
-function Re(e, t, r) {
-  return t.length === r.length && t.every((o, n) => o === r[n]) ? null : `${e} expected [${t.join(", ")}], got [${r.join(", ")}]`;
-}
-async function cn(e) {
-  const { vaultRegistryReader: t, operationKeyReader: r, vaultIds: o, expected: n } = e, i = n.query;
-  if (o.length === 0) return;
-  const a = await t.getVaultKeyEpochsBatch(o), s = [];
-  for (const [u, l] of a.entries()) {
-    const c = o[u];
-    let h;
-    try {
-      h = await lo({
-        operationKeyReader: r,
-        query: i,
-        epochs: l
-      });
-    } catch (g) {
-      s.push(
-        `vault ${c}: could not resolve participants at frozen epochs (vp=${l.vpKeyEpoch}, keeper=${l.appKeeperKeyEpoch}, uc=${l.ucKeyEpoch}): ${g.message}`
-      );
-      continue;
-    }
-    h.vaultProvider.operationBtcPubkey !== n.vaultProvider.operationBtcPubkey && s.push(
-      `vault ${c}: vault provider key expected ${n.vaultProvider.operationBtcPubkey}, got ${h.vaultProvider.operationBtcPubkey}`
-    );
-    const p = Re(
-      `vault ${c}: vault keeper keys`,
-      n.vaultKeeperOperationKeysSorted,
-      h.vaultKeeperOperationKeysSorted
-    );
-    p && s.push(p);
-    const d = Re(
-      `vault ${c}: universal challenger keys`,
-      n.universalChallengerOperationKeysSorted,
-      h.universalChallengerOperationKeysSorted
-    );
-    d && s.push(d);
-  }
-  if (s.length > 0)
-    throw new ut(
-      `Aborting BTC broadcast: participant operation keys changed during registration (${s.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
-    );
-}
-class ct extends Error {
-  constructor(t) {
-    super(t), this.name = "RegisteredVaultVersionMismatchError";
-  }
-}
-function ln(e) {
-  return e instanceof ct || e instanceof Error && e.name === "RegisteredVaultVersionMismatchError";
-}
-async function hn(e) {
-  const {
-    vaultRegistryReader: t,
-    vaultIds: r,
-    expectedOffchainParamsVersion: o,
-    expectedAppVaultKeepersVersion: n,
-    expectedUniversalChallengersVersion: i,
-    expectedVaultCoreVersion: a
-  } = e, s = await t.getProtocolInfoBatch(r), u = [];
-  if (s.forEach((l, c) => {
-    const h = r[c];
-    l.offchainParamsVersion !== o && u.push(
-      `vault ${h}: offchainParams expected v${o}, got v${l.offchainParamsVersion}`
-    ), l.appVaultKeepersVersion !== n && u.push(
-      `vault ${h}: appVaultKeepers expected v${n}, got v${l.appVaultKeepersVersion}`
-    ), l.universalChallengersVersion !== i && u.push(
-      `vault ${h}: universalChallengers expected v${i}, got v${l.universalChallengersVersion}`
-    ), l.vaultCoreVersion !== a && u.push(
-      `vault ${h}: vaultCoreVersion expected v${a} (build-time active), got v${l.vaultCoreVersion}`
-    );
-  }), u.length > 0)
-    throw new ct(
-      `Aborting BTC broadcast: signer-set or offchain-params versions changed during registration (${u.join("; ")}). The Pre-PegIn was not broadcast; the registered ETH vault will time out per protocol rules.`
-    );
-}
-class mo extends Error {
-  constructor(r, o) {
-    super(`Refund not yet mature (BIP68 not final): ${o.message}`);
-    K(this, "vaultId");
-    K(this, "cause");
-    this.name = "BIP68NotMatureError", this.vaultId = r, this.cause = o;
-  }
-}
-const vo = /^0x[0-9a-fA-F]{64}$/, Po = /^(?:0x)?(?:[0-9a-fA-F]{2})+$/, lt = /^(?:0x)?(?:[0-9a-fA-F]{64}|[0-9a-fA-F]{66})$/, ht = 160, Be = 2e3, Ve = 10n, He = 100n;
-function pn(e) {
-  if (!Number.isFinite(e) || e <= 0)
-    throw new Error(
-      `feeRateSatsVb must be a positive finite number, got ${e}`
-    );
-  return BigInt(Math.ceil(e * ht));
-}
-const xo = 1, wo = /non-BIP68-final/i;
-function ce(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 (!vo.test(e))
-    throw new Error(
-      `${t} must contain only hex characters after the 0x prefix`
-    );
-}
-function ie(e, t) {
-  if (!Number.isInteger(e) || e < 0)
-    throw new Error(`${t} must be a non-negative integer, got ${e}`);
-}
-function Eo(e) {
-  if (ce(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 (ce(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 (ie(e.offchainParamsVersion, "offchainParamsVersion"), ie(e.appVaultKeepersVersion, "appVaultKeepersVersion"), ie(
-    e.universalChallengersVersion,
-    "universalChallengersVersion"
-  ), Zt(
-    e.vaultCoreVersion,
-    "VaultRefundData.vaultCoreVersion"
-  ), typeof e.unsignedPrePeginTxHex != "string" || e.unsignedPrePeginTxHex.length === 0)
-    throw new Error("unsignedPrePeginTxHex must be a non-empty hex string");
-  if (!Po.test(e.unsignedPrePeginTxHex))
-    throw new Error(
-      "unsignedPrePeginTxHex must be a hex byte string (optional 0x prefix, even length)"
-    );
-  if (!e.depositorBtcPubkey || !lt.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 _o(e) {
-  if (!e.vaultProviderPubkey || !lt.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 dn(e) {
-  const {
-    vaultId: t,
-    readVault: r,
-    readPrePeginContext: o,
-    feeRate: n,
-    signPsbt: i,
-    broadcastTx: a,
-    signal: s
-  } = e;
-  s == null || s.throwIfAborted(), ce(t, "vaultId");
-  const u = await r();
-  Eo(u), s == null || s.throwIfAborted();
-  const l = await o(u);
-  if (_o(l), s == null || s.throwIfAborted(), !Number.isFinite(n) || n <= 0)
-    throw new Error(`feeRate must be a positive number, got ${n}`);
-  if (n > Be)
-    throw new Error(
-      `feeRate ${n} sat/vB exceeds refund safety cap ${Be} sat/vB; refusing to sign refund.`
-    );
-  const c = BigInt(Math.ceil(n * ht)), h = u.amount * Ve / He;
-  if (c > h)
-    throw new Error(
-      `Refund fee ${c} sats exceeds the per-vault safety cap of ${h} sats (${Ve}/${He} of vault.amount=${u.amount}); refusing to sign refund.`
-    );
-  s == null || s.throwIfAborted();
-  const p = Q(
-    u.depositorBtcPubkey
-  ), d = b(u.unsignedPrePeginTxHex), g = Pt(d);
-  if (g !== void 0 && g.vout !== u.batch.length)
-    throw new Error(
-      `Auth-anchor OP_RETURN at vout ${g.vout} does not match batch size (${u.batch.length} HTLC outputs expect the anchor at vout ${u.batch.length}). Refund refused — sibling HTLC vector is incomplete.`
-    );
-  const y = g == null ? void 0 : g.hash;
-  let f;
-  try {
-    f = B.fromHex(d);
-  } catch (v) {
-    throw new Error(
-      `Failed to parse funded Pre-PegIn transaction hex: ${v instanceof Error ? v.message : String(v)}`
-    );
-  }
-  if (f.outs.length < u.batch.length)
-    throw new Error(
-      `Funded Pre-PegIn tx has ${f.outs.length} outputs but batch requires at least ${u.batch.length} HTLC outputs. Refund refused — funded tx shape disagrees with sibling vector.`
-    );
-  const { psbtHex: P } = await Yt({
-    prePeginParams: {
-      vaultCoreVersion: u.vaultCoreVersion,
-      depositorPubkey: p,
-      vaultProviderPubkey: b(l.vaultProviderPubkey),
-      vaultKeeperPubkeys: l.vaultKeeperPubkeys.map(b),
-      universalChallengerPubkeys: l.universalChallengerPubkeys.map(b),
-      hashlocks: u.batch.map((v) => b(v.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: u.batch.map((v) => v.amount),
-      feeRate: l.feeRate,
-      minPeginFeeRate: l.minPeginFeeRate,
-      numLocalChallengers: l.numLocalChallengers,
-      councilQuorum: l.councilQuorum,
-      councilSize: l.councilSize,
-      network: l.network,
-      authAnchorHash: y
-    },
-    fundedPrePeginTxHex: d,
-    htlcVout: u.htlcVout,
-    refundFee: c,
-    // 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: b(u.hashlock)
-  });
-  s == null || s.throwIfAborted();
-  const x = U(
-    u.depositorBtcPubkey,
-    xo
-  ), w = await i(P, x);
-  X({
-    requestedPsbtHex: P,
-    returnedPsbtHex: w
-  });
-  const _ = 0, k = q(
-    w,
-    p,
-    _
-  );
-  j({
-    requestedPsbtHex: P,
-    signatureHex: k,
-    signerXOnlyPubkeyHex: p,
-    inputIndex: _
-  });
-  const T = je({
-    requestedPsbtHex: P,
-    signaturesHex: [k],
-    signerXOnlyPubkeyHex: p
-  });
-  s == null || s.throwIfAborted();
-  try {
-    return await a(T);
-  } catch (v) {
-    throw v instanceof Error && wo.test(v.message) ? new mo(t, v) : v;
-  }
-}
-class Oe extends Error {
-  constructor(r, o, n) {
-    super(r);
-    /** Fee the reclaim would have paid, in satoshis. */
-    K(this, "feeSats");
-    /** Sum of the reserves the reclaim would have swept, in satoshis. */
-    K(this, "sweptTotalSats");
-    this.name = "ReclaimUneconomicalError", this.feeSats = o, this.sweptTotalSats = n;
-  }
-}
-const Ne = 2e3, Ke = 25n, De = 100n, gn = 10n;
-async function ko(e, t, r) {
-  for (let o = 0; o < e.length; o++) {
-    const n = wt(e[o].depositorSignedPeginTxHex), i = Fe(
-      await Ht(
-        b(n),
-        b(r)
-      )
-    ).toLowerCase();
-    if (i !== t[o].toLowerCase())
-      throw new Error(
-        `Reserve ${o} belongs to vault ${i}, 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 fn(e) {
-  const {
-    vaultIds: t,
-    depositorEthAddress: r,
-    depositorBtcPubkey: o,
-    readVaults: n,
-    feeRate: i,
-    signPsbt: a,
-    broadcastTx: s,
-    signal: u
-  } = e;
-  if (u == null || u.throwIfAborted(), t.length === 0)
-    throw new Error("Reclaim requires at least one vault id; got none.");
-  if (!Number.isFinite(i) || i <= 0)
-    throw new Error(`feeRate must be a positive number, got ${i}`);
-  if (i > Ne)
-    throw new Oe(
-      `Fee rate ${i} sat/vB exceeds the reclaim safety cap of ${Ne} sat/vB; refusing to sign.`,
-      0n,
-      0n
-    );
-  const l = await n();
-  if (u == null || u.throwIfAborted(), l.length !== t.length)
-    throw new Error(
-      `readVaults returned ${l.length} reserves for ${t.length} vault id(s); refusing to sweep a set that does not match the request.`
-    );
-  await ko(l, t, r), u == null || u.throwIfAborted();
-  const c = Q(o), h = l.map((_) => ({
-    depositorSignedPeginTxHex: _.depositorSignedPeginTxHex,
-    observed: _.observed,
-    expectedValue: _.expectedClaimValue
-  })), p = Qt(i, h.length), d = h.reduce((_, k) => _ + k.expectedValue, 0n), g = d * Ke / De;
-  if (p > g)
-    throw new Oe(
-      `Reclaim fee ${p} sats exceeds ${Ke}/${De} of the swept total (${d} sats, cap ${g} sats). The reserve is not at risk — it stays where it is until fee rates fall.`,
-      p,
-      d
-    );
-  u == null || u.throwIfAborted();
-  const { psbtHex: y } = Jt({
-    depositorPubkey: c,
-    inputs: h,
-    feeSats: p
-  });
-  u == null || u.throwIfAborted();
-  const f = U(
-    o,
-    h.length
-  ), P = await a(y, f);
-  X({
-    requestedPsbtHex: y,
-    returnedPsbtHex: P
-  });
-  const x = h.map((_, k) => {
-    const T = q(
-      P,
-      c,
-      k
-    );
-    return j({
-      requestedPsbtHex: y,
-      signatureHex: T,
-      signerXOnlyPubkeyHex: c,
-      inputIndex: k
-    }), T;
-  }), w = je({
-    requestedPsbtHex: y,
-    signaturesHex: x,
-    signerXOnlyPubkeyHex: c
-  });
-  return u == null || u.throwIfAborted(), s(w);
-}
-export {
-  Ve as $,
-  _r as A,
-  sn as B,
-  sr as C,
-  Er as D,
-  nn as E,
-  po as F,
-  m as G,
-  go as H,
-  ut as I,
-  un as J,
-  cn as K,
-  ln as L,
-  hn as M,
-  st as N,
-  Zo as O,
-  ir as P,
-  ne as Q,
-  ct as R,
-  io as S,
-  Ae as T,
-  co as U,
-  lr as V,
-  lo as W,
-  mo as X,
-  dn as Y,
-  pn as Z,
-  He as _,
-  Uo as a,
-  Be as a0,
-  ht as a1,
-  Oe as a2,
-  fn as a3,
-  De as a4,
-  Ke as a5,
-  Ne as a6,
-  gn as a7,
-  Go as b,
-  Xo as c,
-  qo as d,
-  jo as e,
-  ar as f,
-  ur as g,
-  Qe as h,
-  Cr as i,
-  Ze as j,
-  et as k,
-  Rr as l,
-  zo as m,
-  Yo as n,
-  Ur as o,
-  Qr as p,
-  Jo as q,
-  Qo as r,
-  kr as s,
-  ue as t,
-  en as u,
-  tn as v,
-  Wo as w,
-  rn as x,
-  on as y,
-  an as z
-};
-//# sourceMappingURL=buildAndBroadcastReclaim-D5520lbL.js.map