@babylonlabs-io/ts-sdk 3.0.2 → 3.1.1

package/dist/toRefundInputs-dKDSvpVI.js

@@ -0,0 +1,698 @@
+var se = Object.defineProperty;
+var ie = (e, t, o) => t in e ? se(e, t, { enumerable: !0, configurable: !0, writable: !0, value: o }) : e[t] = o;
+var z = (e, t, o) => ie(e, typeof t != "symbol" ? t + "" : t, o);
+import { r as S } from "./registration-records-CKLAv3gw.js";
+import { s as g, c as ae, h as ce, p as q, u as ue, e as le } from "./bitcoin-C-TuHb-v.js";
+import { c as H } from "./btcTxHash-BRZ8_EZq.js";
+import { Transaction as M } from "bitcoinjs-lib";
+import { Buffer as he } from "buffer";
+import { getUtxoInfo as de } from "./tbv/core/clients/mempool/index.js";
+import { M as D } from "./validation-OSC0xTHB.js";
+import { keccak256 as J, toHex as me, encodeAbiParameters as pe, isAddress as ge, zeroAddress as fe } from "viem";
+import { s as Pe } from "./sha2-YqVHJiFj.js";
+import { d as _ } from "./PayoutManager-BZ212yml.js";
+import { b as ve, a as be } from "./PeginManager-QRwMUxZg.js";
+import { computeMinClaimValue as Y, computeMinPeginFee as Z, peginP2aAnchorOutput as ee, getPrePeginHtlcConnectorInfo as we, expandAuthAnchor as ye } from "./tbv/core/wasm/index.js";
+import { d as Ce } from "./deriveVaultRoot-BcvmER1E.js";
+import { p as xe } from "./parseFundingOutpoints-GSM-IaaK.js";
+import { o as Ee, H as U } from "./verifyScriptPathSchnorrSignature-B3-VkvnK.js";
+import { c as j } from "./fundPeginTransaction-CwhRbCQC.js";
+const Re = [
+  "vaultCoreVersion",
+  "offchainParamsVersion",
+  "appVaultKeepersVersion",
+  "universalChallengersVersion"
+], ke = [
+  "applicationEntryPoint",
+  "vaultProvider"
+];
+function Ve(e, t) {
+  const o = t.depositor.toLowerCase(), r = S(t).toLowerCase();
+  return e.filter(
+    (n) => n.vaultId !== t.vaultId && n.depositor.toLowerCase() === o && S(n).toLowerCase() === r
+  );
+}
+function $e(e, t) {
+  for (const o of t) {
+    for (const r of Re)
+      if (o.vault.protocol[r] !== e.vault.protocol[r])
+        throw new Error(
+          `Sibling vaults of this Pre-PegIn disagree on ${r} (${o.vault.protocol[r]} vs ${e.vault.protocol[r]}); the batch cannot be described by one set of deposit terms.`
+        );
+    if (o.maxAcceptableCommissionBps !== e.maxAcceptableCommissionBps)
+      throw new Error(
+        `Sibling vaults of this Pre-PegIn disagree on maxAcceptableCommissionBps (${o.maxAcceptableCommissionBps} vs ${e.maxAcceptableCommissionBps}); the batch cannot be described by one set of deposit terms.`
+      );
+    for (const r of ke)
+      if (o.vault.basic[r].toLowerCase() !== e.vault.basic[r].toLowerCase())
+        throw new Error(
+          `Sibling vaults of this Pre-PegIn disagree on ${r} (${o.vault.basic[r]} vs ${e.vault.basic[r]}); the batch cannot be described by one set of deposit terms.`
+        );
+  }
+}
+function Ae(e) {
+  const t = [...e].sort(
+    (o, r) => o.vault.protocol.htlcVout - r.vault.protocol.htlcVout
+  );
+  return t.forEach((o, r) => {
+    if (o.vault.protocol.htlcVout !== r)
+      throw new Error(
+        `Sibling discovery produced a non-contiguous HTLC vector (${t.map((n) => n.vault.protocol.htlcVout).join(", ")}).`
+      );
+  }), t.map((o) => ({
+    hashlock: o.vault.protocol.hashlock,
+    amount: o.vault.basic.amount
+  }));
+}
+const te = "DepositTermsRejectedError";
+class Te extends Error {
+  constructor(o, r = "device-envelope") {
+    super(o);
+    z(this, "reason");
+    this.name = te, this.reason = r;
+  }
+}
+function dt(e) {
+  if (e instanceof Te) return !0;
+  if (typeof e != "object" || e === null) return !1;
+  const t = e;
+  return t.name === te && t.reason === "device-envelope";
+}
+async function Be(e, t) {
+  const o = M.fromHex(g(e)), n = (await Promise.all(
+    o.ins.map(
+      (i) => (
+        // Bitcoin stores the prev-txid in reverse (internal) byte order.
+        de(
+          he.from(i.hash).reverse().toString("hex"),
+          i.index,
+          t
+        )
+      )
+    )
+  )).reduce((i, a) => i + BigInt(a.value), 0n), u = o.outs.reduce((i, a) => i + BigInt(a.value), 0n), s = n - u;
+  if (s <= 0n)
+    throw new Error(
+      `The funded Pre-PegIn transaction's inputs do not cover its outputs plus a fee (computed fee: ${s} sats).`
+    );
+  if (s > D)
+    throw new Error(
+      `The funded Pre-PegIn transaction's computed fee (${s} sats) exceeds the maximum reasonable fee (${D} sats); the mempool API may have returned manipulated prevout data.`
+    );
+  return s;
+}
+async function oe(e) {
+  const t = e.siblings.length;
+  if (t === 0)
+    throw new Error(
+      "rebuildDepositTermsCore: at least one sibling is required"
+    );
+  for (const [l, b] of e.siblings.entries())
+    if (b.amount <= 0n)
+      throw new Error(
+        `rebuildDepositTermsCore: sibling[${l}] has non-positive on-chain pegin amount ${b.amount}; the chain-read vault record is invalid. Resume refused.`
+      );
+  if (e.prepeginMaxFee <= 0n)
+    throw new Error(
+      `rebuildDepositTermsCore: prepeginMaxFee must be > 0, got ${e.prepeginMaxFee}`
+    );
+  const o = g(e.prepeginTxid).toLowerCase(), r = g(
+    H(e.fundedPrePeginTxHex)
+  ).toLowerCase();
+  if (r !== o)
+    throw new Error(
+      `Funded Pre-PegIn tx hashes to ${r}, expected ${o} (on-chain prepeginTxid). Resume refused.`
+    );
+  const n = _(
+    g(e.fundedPrePeginTxHex)
+  );
+  if (n === void 0)
+    throw new Error(
+      "Funded Pre-PegIn carries no single, unambiguous auth-anchor OP_RETURN commitment — it either predates auth anchoring or is malformed. The intent resume path requires the anchor to prove sibling completeness. Resume refused."
+    );
+  if (n.vout !== t)
+    throw new Error(
+      `Auth-anchor OP_RETURN at vout ${n.vout} does not match the discovered sibling count ${t}; the discovered sibling set does not cover this transaction's HTLC outputs (a lagging index can cause this — retry later). Resume refused.`
+    );
+  const u = e.vaultKeeperBtcPubkeys.length, s = e.universalChallengerBtcPubkeys.length, i = await Y(
+    e.vaultCoreVersion,
+    u,
+    s,
+    e.councilQuorum,
+    e.councilSize,
+    e.protocolFeeRate
+  ), a = await Z(
+    e.vaultCoreVersion,
+    u,
+    s,
+    e.minPeginFeeRate
+  ), d = await ee(e.vaultCoreVersion), c = (d == null ? void 0 : d.value) ?? 0n;
+  if (i <= 0n)
+    throw new Error(
+      `WASM returned non-positive depositorClaimValue ${i}; expected > 0. Resume refused.`
+    );
+  if (a <= 0n)
+    throw new Error(
+      `WASM returned non-positive peginMaxFee ${a}; expected > 0. Resume refused.`
+    );
+  if (c < 0n)
+    throw new Error(
+      `WASM returned negative P2A anchor value ${c}. Resume refused.`
+    );
+  const h = a + c, v = e.minPeginFeeRate * j;
+  if (h <= 0n || h > v)
+    throw new Error(
+      `WASM implied PegIn reserve ${h} sat is outside (0, ${v}] (minPeginFeeRate=${e.minPeginFeeRate} × ${j} vbytes). Resume refused.`
+    );
+  const y = e.siblings.map(
+    (l) => l.amount + i + a + c
+  ), x = await Promise.all(
+    e.siblings.map(async (l) => (await we({
+      txGraphVersion: e.vaultCoreVersion,
+      depositorPubkey: e.depositorBtcPubkey,
+      vaultProviderPubkey: e.vaultProviderBtcPubkey,
+      vaultKeeperPubkeys: [...e.vaultKeeperBtcPubkeys],
+      universalChallengerPubkeys: [...e.universalChallengerBtcPubkeys],
+      hashlock: g(l.hashlock),
+      timelockRefund: e.timelockRefund,
+      network: e.network
+    })).scriptPubKey)
+  ), C = M.fromHex(
+    g(e.fundedPrePeginTxHex)
+  ).outs.map((l) => ({ value: l.value, script: l.script }));
+  return Ee(
+    C,
+    y,
+    x
+  ), ve({
+    vaultCoreVersion: e.vaultCoreVersion,
+    protocolFeeRate: e.protocolFeeRate,
+    timelockPegin: e.timelockPegin,
+    timelockAssert: e.timelockAssert,
+    timelockRefund: e.timelockRefund,
+    prepeginTxid: e.prepeginTxid,
+    prepeginMaxFee: e.prepeginMaxFee,
+    vaultProviderBtcPubkey: e.vaultProviderBtcPubkey,
+    vaultKeeperBtcPubkeys: e.vaultKeeperBtcPubkeys,
+    universalChallengerBtcPubkeys: e.universalChallengerBtcPubkeys,
+    maxAcceptableCommissionBps: e.maxAcceptableCommissionBps,
+    peginAmounts: e.siblings.map((l) => l.amount),
+    depositorClaimValue: i,
+    peginMaxFee: a
+  });
+}
+async function mt(e) {
+  const { read: t } = e, o = ae(e.depositorBtcPubkey);
+  if (o !== t.context.depositorBtcPubkey)
+    throw new Error(
+      "Connected wallet key is not the vault's depositor key; select the account that made the deposit."
+    );
+  const r = g(t.prePeginTxHash).toLowerCase(), n = g(
+    H(e.fundedPrePeginTxHex)
+  ).toLowerCase();
+  if (n !== r)
+    throw new Error(
+      `Funded Pre-PegIn tx hashes to ${n}, expected ${r} (on-chain prePeginTxHash).`
+    );
+  const u = await Promise.all(
+    Ve(
+      t.registrationRecords,
+      t.registrationRecord
+    ).map(async (d) => {
+      const c = await e.siblingReader.getVaultData(d.vaultId);
+      if (c.protocol.prePeginTxHash.toLowerCase() !== S(d).toLowerCase())
+        throw new Error(
+          `Sibling ${d.vaultId} is registered against a different Pre-PegIn on chain than its registration log records; refusing an inconsistent node.`
+        );
+      return {
+        vault: c,
+        maxAcceptableCommissionBps: d.maxAcceptableCommissionBps
+      };
+    })
+  ), s = {
+    vault: t.vault,
+    maxAcceptableCommissionBps: t.registrationRecord.maxAcceptableCommissionBps
+  };
+  $e(s, u);
+  const i = Ae([s, ...u]), a = await Be(
+    e.fundedPrePeginTxHex,
+    e.mempoolApiUrl
+  );
+  return oe({
+    vaultCoreVersion: t.vault.protocol.vaultCoreVersion,
+    siblings: i,
+    fundedPrePeginTxHex: e.fundedPrePeginTxHex,
+    depositorBtcPubkey: o,
+    vaultProviderBtcPubkey: t.participantKeys.vaultProvider.operationBtcPubkey,
+    vaultKeeperBtcPubkeys: t.participantKeys.vaultKeeperOperationKeysSorted,
+    universalChallengerBtcPubkeys: t.participantKeys.universalChallengerOperationKeysSorted,
+    protocolFeeRate: t.offchainParams.feeRate,
+    minPeginFeeRate: t.offchainParams.minPeginFeeRate,
+    councilQuorum: t.offchainParams.councilQuorum,
+    councilSize: t.offchainParams.securityCouncilKeys.length,
+    timelockPegin: t.context.timelockPegin,
+    timelockAssert: t.context.timelockAssert,
+    timelockRefund: t.offchainParams.tRefund,
+    prepeginTxid: r,
+    prepeginMaxFee: a,
+    // The submitted ceiling, verbatim: the device must see the terms the
+    // depositor originally approved.
+    maxAcceptableCommissionBps: t.registrationRecord.maxAcceptableCommissionBps,
+    network: e.network
+  });
+}
+function pt(e) {
+  const t = (e instanceof Error ? e.message : typeof e == "string" ? e : "").toLowerCase();
+  return t.includes("wots") && t.includes("hash") && t.includes("does not match");
+}
+const Ie = "TBV.PeginFingerprint.v1", Fe = J(
+  me(Ie)
+), G = 65535, Q = 2n ** 64n - 1n, Se = 2n ** 256n - 1n, Ke = /^0x[0-9a-fA-F]{64}$/, W = 1;
+class P extends Error {
+  constructor(t) {
+    super(t), this.name = "PeginFingerprintInputError";
+  }
+}
+function gt(e) {
+  return e instanceof P || e instanceof Error && e.name === "PeginFingerprintInputError";
+}
+function I(e, t, o, r) {
+  if (typeof t != "bigint")
+    throw new P(
+      `${e} must be a bigint (Solidity ${r}), got ${typeof t}`
+    );
+  if (t < 0n || t > o)
+    throw new P(
+      `${e} must fit Solidity ${r} (0..${o}), got ${t}`
+    );
+}
+function $(e, t) {
+  if (!Number.isInteger(t) || t < 0 || t > G)
+    throw new P(
+      `${e} must be an integer fitting Solidity uint16 (0..${G}), got ${t}`
+    );
+}
+function He(e, t) {
+  if (!Ke.test(t))
+    throw new P(
+      `${e} must be 32 bytes as 0x-prefixed hex (66 characters), got "${t}"`
+    );
+  return t.toLowerCase();
+}
+function Me(e) {
+  if (!ge(e, { strict: !1 }))
+    throw new P(
+      `registryAddress must be a 20-byte 0x-prefixed address, got "${e}"`
+    );
+  const t = e.toLowerCase();
+  if (t === fe)
+    throw new P(
+      "registryAddress must not be the zero address; a zero here means the registry address was never resolved"
+    );
+  return t;
+}
+const _e = [
+  { name: "domain", type: "bytes32" },
+  { name: "chainId", type: "uint256" },
+  { name: "registry", type: "address" },
+  { name: "vaultProviderBtcKey", type: "bytes32" },
+  { name: "appKeeperKeyEpoch", type: "uint64" },
+  { name: "ucKeyEpoch", type: "uint64" },
+  { name: "appVaultKeepersVersion", type: "uint16" },
+  { name: "universalChallengersVersion", type: "uint16" },
+  { name: "offchainParamsVersion", type: "uint16" },
+  { name: "vaultCoreVersion", type: "uint16" }
+];
+function Ne(e) {
+  if (I("chainId", e.chainId, Se, "uint256"), e.chainId === 0n)
+    throw new P(
+      "chainId must not be 0; a zero here means the chain id was never resolved"
+    );
+  const t = Me(e.registryAddress), o = He(
+    "vaultProviderBtcKey",
+    e.vaultProviderBtcKey
+  );
+  if (I(
+    "appKeeperKeyEpoch",
+    e.appKeeperKeyEpoch,
+    Q,
+    "uint64"
+  ), I("ucKeyEpoch", e.ucKeyEpoch, Q, "uint64"), $("appVaultKeepersVersion", e.appVaultKeepersVersion), $(
+    "universalChallengersVersion",
+    e.universalChallengersVersion
+  ), $("offchainParamsVersion", e.offchainParamsVersion), $("vaultCoreVersion", e.vaultCoreVersion), e.vaultCoreVersion < W)
+    throw new P(
+      `vaultCoreVersion must be at least ${W}; ${e.vaultCoreVersion} means the version was never resolved`
+    );
+  return pe(_e, [
+    Fe,
+    e.chainId,
+    t,
+    o,
+    e.appKeeperKeyEpoch,
+    e.ucKeyEpoch,
+    e.appVaultKeepersVersion,
+    e.universalChallengersVersion,
+    e.offchainParamsVersion,
+    e.vaultCoreVersion
+  ]);
+}
+function ft(e) {
+  return J(Ne(e));
+}
+class Oe extends Error {
+  constructor(t, o) {
+    super(
+      `Re-derived vault root does not match this Pre-PegIn: derived auth-anchor hash ${t}, transaction commits to ${o}. Connect the same wallet, on the same account and the same network, that created the deposit.`
+    ), this.derivedAuthAnchorHash = t, this.onChainAuthAnchorHash = o, this.name = "VaultRootMismatchError";
+  }
+}
+class K extends Error {
+  constructor(t) {
+    super(t), this.name = "UnanchoredPrePeginError";
+  }
+}
+class Le extends Error {
+  constructor(t, o, r = []) {
+    super(
+      `No candidate parameter set reproduces this Pre-PegIn's HTLC outputs (${t} candidate(s) tried). ` + (r.length > 0 ? `${r.length} version(s) could not be resolved and may hold the answer: ${r.join(" | ")}. ` : "") + `Sample rejections: ${o.join(" | ")}`
+    ), this.candidatesTried = t, this.sampleRejections = o, this.unresolvedLabels = r, this.name = "PeginParamsNotFoundError";
+  }
+}
+class ze extends Error {
+  constructor(t) {
+    super(
+      `${t.length} candidate parameter sets reproduce this Pre-PegIn's HTLC outputs, so the vault's stamped versions cannot be determined: ${t.join(" | ")}. Reconstruction refused.`
+    ), this.survivorLabels = t, this.name = "PeginParamsAmbiguousError";
+  }
+}
+class De extends Error {
+  constructor(t, o) {
+    super(
+      `A candidate matched this Pre-PegIn (${t}), but ${o.length} version(s) could not be resolved, so the search space did not provably contain the true parameters: ${o.join(" | ")}. A version sharing the matched timelockRefund and participants is indistinguishable from the true one, so the match cannot be trusted. Reconstruction refused.`
+    ), this.matchedLabel = t, this.unresolvedLabels = o, this.name = "PeginParamsIncompleteSpaceError";
+  }
+}
+class A extends Error {
+  constructor(t) {
+    super(`${t}. Reconstruction refused.`), this.name = "PeginSizingIntegrityError";
+  }
+}
+async function Pt(e) {
+  const { wallet: t, depositorBtcPubkey: o, fundedPrePeginTxHex: r } = e, n = g(r), u = _(n);
+  if (u === void 0)
+    throw new K(
+      "Pre-PegIn carries no single, unambiguous auth-anchor OP_RETURN, so the number of HTLC outputs it funds cannot be determined. Legacy pre-anchor deposits are not recoverable by this path."
+    );
+  const s = u.vout;
+  if (s === 0)
+    throw new K(
+      "Pre-PegIn's auth-anchor OP_RETURN is at vout 0, implying zero HTLC outputs; there is nothing to recover."
+    );
+  const i = xe(n), a = await Ce(t, {
+    // The vault context takes the 32-byte x-only key; a wallet's compressed
+    // key would otherwise fail a byte-length check deep in the encoder with
+    // nothing pointing back at the caller.
+    depositorBtcPubkey: ce(
+      q(o)
+    ),
+    fundingOutpoints: i
+  });
+  try {
+    const c = await ye(a);
+    let h;
+    try {
+      h = ue(Pe(c));
+    } finally {
+      c.fill(0);
+    }
+    if (h !== u.hash)
+      throw new Oe(h, u.hash);
+  } catch (c) {
+    throw a.fill(0), c;
+  }
+  const { hashlocks: d } = await be(a, s);
+  return { vaultCount: s, hashlocks: d, authAnchorHash: u.hash };
+}
+function vt(e) {
+  const { vaultCoreVersion: t, offchainParams: o, participantKeySets: r } = e;
+  if (!Number.isInteger(t) || t < 1)
+    throw new Error(
+      `buildPeginParamsCandidates: vaultCoreVersion must be a positive integer, got ${t}`
+    );
+  if (o.length === 0)
+    throw new Error(
+      "buildPeginParamsCandidates: at least one offchain-params version is required"
+    );
+  if (r.length === 0)
+    throw new Error(
+      "buildPeginParamsCandidates: at least one participant key set is required"
+    );
+  const n = [];
+  for (const u of o)
+    for (const s of r)
+      n.push({
+        vaultCoreVersion: t,
+        offchainParams: u,
+        participants: s
+      });
+  return n;
+}
+function Ue(e) {
+  return `${e.axis} v${e.version} (${e.reason})`;
+}
+function F(e) {
+  const { participants: t } = e;
+  return `core=${e.vaultCoreVersion} offchain=${e.offchainParams.version} keepers=${t.appVaultKeepersVersion} challengers=${t.universalChallengersVersion} vp=${t.vaultProvider}`;
+}
+const X = 5;
+function je(e, t) {
+  return JSON.stringify(
+    { terms: e, peginAmounts: t },
+    (o, r) => typeof r == "bigint" ? `${r}` : r
+  );
+}
+function Ge(e) {
+  const { offchainParams: t, participants: o } = e;
+  return [
+    e.vaultCoreVersion,
+    o.vaultKeeperBtcPubkeys.length,
+    o.universalChallengerBtcPubkeys.length,
+    t.councilQuorum,
+    t.councilSize,
+    t.protocolFeeRate,
+    t.minPeginFeeRate
+  ].join("|");
+}
+async function Qe(e) {
+  const { offchainParams: t, participants: o } = e, r = o.vaultKeeperBtcPubkeys.length, n = o.universalChallengerBtcPubkeys.length, [u, s, i] = await Promise.all([
+    Y(
+      e.vaultCoreVersion,
+      r,
+      n,
+      t.councilQuorum,
+      t.councilSize,
+      t.protocolFeeRate
+    ),
+    Z(
+      e.vaultCoreVersion,
+      r,
+      n,
+      t.minPeginFeeRate
+    ),
+    ee(e.vaultCoreVersion)
+  ]), a = (i == null ? void 0 : i.value) ?? 0n;
+  if (u <= 0n)
+    throw new A(
+      `WASM returned non-positive depositorClaimValue ${u} for graph version ${e.vaultCoreVersion}`
+    );
+  if (s <= 0n)
+    throw new A(
+      `WASM returned non-positive peginMaxFee ${s} for graph version ${e.vaultCoreVersion}`
+    );
+  if (a < 0n)
+    throw new A(
+      `WASM returned negative P2A anchor value ${a} for graph version ${e.vaultCoreVersion}`
+    );
+  return { depositorClaimValue: u, peginMaxFee: s, p2aAnchorValue: a };
+}
+async function bt(e) {
+  const {
+    hashlocks: t,
+    fundedPrePeginTxHex: o,
+    depositorBtcPubkey: r,
+    prepeginMaxFee: n,
+    maxAcceptableCommissionBps: u,
+    network: s,
+    candidates: i,
+    unresolvedVersions: a
+  } = e;
+  if (t.length === 0)
+    throw new Error(
+      "reconstructPeginParams: at least one hashlock is required"
+    );
+  if (i.length === 0)
+    throw new Error("reconstructPeginParams: candidate space is empty");
+  const d = q(r), c = g(o), h = _(c);
+  if (h === void 0)
+    throw new K(
+      "Pre-PegIn carries no single, unambiguous auth-anchor OP_RETURN; the sibling set cannot be proven complete. Reconstruction refused."
+    );
+  if (h.vout !== t.length)
+    throw new Error(
+      `reconstructPeginParams: ${t.length} hashlock(s) supplied but the auth-anchor OP_RETURN sits at vout ${h.vout}, so the transaction funds ${h.vout} HTLC output(s). Reconstruction refused.`
+    );
+  const v = M.fromHex(c).outs, y = t.map((m, p) => BigInt(v[p].value)), x = g(
+    H(c)
+  ).toLowerCase(), C = /* @__PURE__ */ new Map(), l = [], b = [], T = [];
+  let N = 0;
+  for (const m of i)
+    try {
+      const p = Ge(m);
+      let f = C.get(p);
+      f === void 0 && (f = await Qe(m), C.set(p, f));
+      const E = f.depositorClaimValue + f.peginMaxFee + f.p2aAnchorValue, R = y.map((k) => k - E), V = R.findIndex((k) => k <= 0n);
+      if (V !== -1)
+        throw new U(
+          `HTLC output[${V}] value ${y[V]} is not above this candidate's reserve ${E}, so it implies a non-positive pegin amount ${R[V]}.`
+        );
+      const { offchainParams: w, participants: B } = m, L = await oe({
+        vaultCoreVersion: m.vaultCoreVersion,
+        siblings: t.map((k, ne) => ({
+          hashlock: k,
+          amount: R[ne]
+        })),
+        fundedPrePeginTxHex: c,
+        depositorBtcPubkey: d,
+        vaultProviderBtcPubkey: B.vaultProviderBtcPubkey,
+        vaultKeeperBtcPubkeys: B.vaultKeeperBtcPubkeys,
+        universalChallengerBtcPubkeys: B.universalChallengerBtcPubkeys,
+        protocolFeeRate: w.protocolFeeRate,
+        minPeginFeeRate: w.minPeginFeeRate,
+        councilQuorum: w.councilQuorum,
+        councilSize: w.councilSize,
+        timelockPegin: w.timelockPegin,
+        timelockAssert: w.timelockAssert,
+        timelockRefund: w.timelockRefund,
+        prepeginTxid: x,
+        prepeginMaxFee: n,
+        maxAcceptableCommissionBps: u,
+        network: s
+      });
+      l.push({
+        candidate: m,
+        terms: L,
+        peginAmounts: R,
+        fingerprint: je(L, R)
+      });
+    } catch (p) {
+      if (p instanceof A)
+        throw p;
+      const f = F(m), E = p instanceof Error ? p.message : String(p);
+      p instanceof U ? b.length < X && b.push(`[${f}] ${E}`) : (N++, T.length < X && T.push(`${f} (${E})`));
+    }
+  const re = a.length + N, O = [
+    ...a.map(Ue),
+    ...T
+  ];
+  if (l.length === 0)
+    throw new Le(i.length, b, O);
+  if (new Set(l.map((m) => m.fingerprint)).size > 1)
+    throw new ze(
+      l.map((m) => F(m.candidate))
+    );
+  if (re > 0)
+    throw new De(
+      F(l[0].candidate),
+      O
+    );
+  return {
+    candidate: l[0].candidate,
+    terms: l[0].terms,
+    peginAmounts: l[0].peginAmounts,
+    authAnchorHash: h.hash,
+    candidatesTried: i.length,
+    matchedCandidates: l.map((m) => m.candidate)
+  };
+}
+function wt(e, t) {
+  const {
+    htlcVout: o,
+    depositorBtcPubkey: r,
+    applicationEntryPoint: n,
+    fundedPrePeginTxHex: u,
+    hashlocks: s,
+    network: i
+  } = t, { candidate: a, peginAmounts: d } = e, { offchainParams: c, participants: h } = a;
+  if (s.length !== d.length)
+    throw new Error(
+      `toRefundInputs: ${s.length} hashlock(s) but ${d.length} reconstructed amount(s); the reconstruction and the hashlock vector describe different transactions.`
+    );
+  if (!Number.isInteger(o) || o < 0 || o >= d.length)
+    throw new Error(
+      `toRefundInputs: htlcVout ${o} is outside the reconstructed batch of ${d.length} vault(s).`
+    );
+  const v = d.map((C, l) => ({
+    hashlock: le(s[l]),
+    amount: C,
+    htlcVout: l
+  })), y = {
+    vaultCoreVersion: a.vaultCoreVersion,
+    hashlock: v[o].hashlock,
+    htlcVout: o,
+    offchainParamsVersion: c.version,
+    appVaultKeepersVersion: h.appVaultKeepersVersion,
+    universalChallengersVersion: h.universalChallengersVersion,
+    vaultProvider: h.vaultProvider,
+    applicationEntryPoint: n,
+    amount: d[o],
+    unsignedPrePeginTxHex: u,
+    depositorBtcPubkey: r,
+    batch: v
+  }, x = {
+    vaultProviderPubkey: h.vaultProviderBtcPubkey,
+    vaultKeeperPubkeys: h.vaultKeeperBtcPubkeys,
+    universalChallengerPubkeys: h.universalChallengerBtcPubkeys,
+    timelockRefund: c.timelockRefund,
+    feeRate: c.protocolFeeRate,
+    minPeginFeeRate: c.minPeginFeeRate,
+    // Depositor-as-claimer: the local-challenger count is the keeper count,
+    // the vault provider excluded — btc-vault graph.rs derive_challengers.
+    numLocalChallengers: h.vaultKeeperBtcPubkeys.length,
+    councilQuorum: c.councilQuorum,
+    councilSize: c.councilSize,
+    network: i
+  };
+  return { vault: y, context: x };
+}
+export {
+  te as D,
+  Fe as P,
+  K as U,
+  Oe as V,
+  Ie as a,
+  P as b,
+  ft as c,
+  gt as d,
+  Ne as e,
+  $e as f,
+  Te as g,
+  dt as h,
+  pt as i,
+  Be as j,
+  mt as k,
+  Pt as l,
+  vt as m,
+  Ue as n,
+  Ae as o,
+  F as p,
+  bt as q,
+  oe as r,
+  Ve as s,
+  Le as t,
+  ze as u,
+  De as v,
+  A as w,
+  wt as x
+};
+//# sourceMappingURL=toRefundInputs-dKDSvpVI.js.map