@babylonlabs-io/ts-sdk 3.0.2 → 3.1.0

package/dist/toRefundInputs-10RYIfh1.js

@@ -1,559 +0,0 @@
-var re = Object.defineProperty;
-var ne = (e, t, r) => t in e ? re(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
-var _ = (e, t, r) => ne(e, typeof t != "symbol" ? t + "" : t, r);
-import { keccak256 as G, toHex as oe, encodeAbiParameters as se, isAddress as ie, zeroAddress as ae } from "viem";
-import { s as ce } from "./sha2-YqVHJiFj.js";
-import { a as M } from "./PayoutManager-BSwbUQeF.js";
-import { b as ue, a as le } from "./PeginManager-D8WGB8eN.js";
-import { s as f, h as he, p as W, u as de, e as me } from "./bitcoin-C-TuHb-v.js";
-import { computeMinClaimValue as Q, computeMinPeginFee as q, peginP2aAnchorOutput as X, getPrePeginHtlcConnectorInfo as pe, expandAuthAnchor as ge } from "./tbv/core/wasm/index.js";
-import { d as Pe } from "./deriveVaultRoot-BcvmER1E.js";
-import { p as fe } from "./parseFundingOutpoints-GSM-IaaK.js";
-import { Transaction as J } from "bitcoinjs-lib";
-import { o as ve, H as z } from "./verifyScriptPathSchnorrSignature-CpjSTfMj.js";
-import { c as O } from "./fundPeginTransaction-CwhRbCQC.js";
-import { c as Y } from "./signing-Dhr2t0Z6.js";
-const Z = "DepositTermsRejectedError";
-class be extends Error {
-  constructor(r, n = "device-envelope") {
-    super(r);
-    _(this, "reason");
-    this.name = Z, this.reason = n;
-  }
-}
-function Je(e) {
-  if (e instanceof be) return !0;
-  if (typeof e != "object" || e === null) return !1;
-  const t = e;
-  return t.name === Z && t.reason === "device-envelope";
-}
-async function ye(e) {
-  const t = e.siblings.length;
-  if (t === 0)
-    throw new Error(
-      "rebuildDepositTermsCore: at least one sibling is required"
-    );
-  for (const [o, b] of e.siblings.entries())
-    if (b.amount <= 0n)
-      throw new Error(
-        `rebuildDepositTermsCore: sibling[${o}] 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 r = f(e.prepeginTxid).toLowerCase(), n = f(
-    Y(e.fundedPrePeginTxHex)
-  ).toLowerCase();
-  if (n !== r)
-    throw new Error(
-      `Funded Pre-PegIn tx hashes to ${n}, expected ${r} (on-chain prepeginTxid). Resume refused.`
-    );
-  const h = M(
-    f(e.fundedPrePeginTxHex)
-  );
-  if (h === 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 (h.vout !== t)
-    throw new Error(
-      `Auth-anchor OP_RETURN at vout ${h.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 c = e.vaultKeeperBtcPubkeys.length, u = e.universalChallengerBtcPubkeys.length, l = await Q(
-    e.vaultCoreVersion,
-    c,
-    u,
-    e.councilQuorum,
-    e.councilSize,
-    e.protocolFeeRate
-  ), a = await q(
-    e.vaultCoreVersion,
-    c,
-    u,
-    e.minPeginFeeRate
-  ), d = await X(e.vaultCoreVersion), s = (d == null ? void 0 : d.value) ?? 0n;
-  if (l <= 0n)
-    throw new Error(
-      `WASM returned non-positive depositorClaimValue ${l}; expected > 0. Resume refused.`
-    );
-  if (a <= 0n)
-    throw new Error(
-      `WASM returned non-positive peginMaxFee ${a}; expected > 0. Resume refused.`
-    );
-  if (s < 0n)
-    throw new Error(
-      `WASM returned negative P2A anchor value ${s}. Resume refused.`
-    );
-  const i = a + s, v = e.minPeginFeeRate * O;
-  if (i <= 0n || i > v)
-    throw new Error(
-      `WASM implied PegIn reserve ${i} sat is outside (0, ${v}] (minPeginFeeRate=${e.minPeginFeeRate} × ${O} vbytes). Resume refused.`
-    );
-  const w = e.siblings.map(
-    (o) => o.amount + l + a + s
-  ), C = await Promise.all(
-    e.siblings.map(async (o) => (await pe({
-      txGraphVersion: e.vaultCoreVersion,
-      depositorPubkey: e.depositorBtcPubkey,
-      vaultProviderPubkey: e.vaultProviderBtcPubkey,
-      vaultKeeperPubkeys: [...e.vaultKeeperBtcPubkeys],
-      universalChallengerPubkeys: [...e.universalChallengerBtcPubkeys],
-      hashlock: f(o.hashlock),
-      timelockRefund: e.timelockRefund,
-      network: e.network
-    })).scriptPubKey)
-  ), E = J.fromHex(
-    f(e.fundedPrePeginTxHex)
-  ).outs.map((o) => ({ value: o.value, script: o.script }));
-  return ve(
-    E,
-    w,
-    C
-  ), ue({
-    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((o) => o.amount),
-    depositorClaimValue: l,
-    peginMaxFee: a
-  });
-}
-function Ye(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 we = "TBV.PeginFingerprint.v1", Ee = G(
-  oe(we)
-), U = 65535, D = 2n ** 64n - 1n, Ce = 2n ** 256n - 1n, Re = /^0x[0-9a-fA-F]{64}$/, L = 1;
-class P extends Error {
-  constructor(t) {
-    super(t), this.name = "PeginFingerprintInputError";
-  }
-}
-function Ze(e) {
-  return e instanceof P || e instanceof Error && e.name === "PeginFingerprintInputError";
-}
-function F(e, t, r, n) {
-  if (typeof t != "bigint")
-    throw new P(
-      `${e} must be a bigint (Solidity ${n}), got ${typeof t}`
-    );
-  if (t < 0n || t > r)
-    throw new P(
-      `${e} must fit Solidity ${n} (0..${r}), got ${t}`
-    );
-}
-function $(e, t) {
-  if (!Number.isInteger(t) || t < 0 || t > U)
-    throw new P(
-      `${e} must be an integer fitting Solidity uint16 (0..${U}), got ${t}`
-    );
-}
-function ke(e, t) {
-  if (!Re.test(t))
-    throw new P(
-      `${e} must be 32 bytes as 0x-prefixed hex (66 characters), got "${t}"`
-    );
-  return t.toLowerCase();
-}
-function xe(e) {
-  if (!ie(e, { strict: !1 }))
-    throw new P(
-      `registryAddress must be a 20-byte 0x-prefixed address, got "${e}"`
-    );
-  const t = e.toLowerCase();
-  if (t === ae)
-    throw new P(
-      "registryAddress must not be the zero address; a zero here means the registry address was never resolved"
-    );
-  return t;
-}
-const Ve = [
-  { 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 $e(e) {
-  if (F("chainId", e.chainId, Ce, "uint256"), e.chainId === 0n)
-    throw new P(
-      "chainId must not be 0; a zero here means the chain id was never resolved"
-    );
-  const t = xe(e.registryAddress), r = ke(
-    "vaultProviderBtcKey",
-    e.vaultProviderBtcKey
-  );
-  if (F(
-    "appKeeperKeyEpoch",
-    e.appKeeperKeyEpoch,
-    D,
-    "uint64"
-  ), F("ucKeyEpoch", e.ucKeyEpoch, D, "uint64"), $("appVaultKeepersVersion", e.appVaultKeepersVersion), $(
-    "universalChallengersVersion",
-    e.universalChallengersVersion
-  ), $("offchainParamsVersion", e.offchainParamsVersion), $("vaultCoreVersion", e.vaultCoreVersion), e.vaultCoreVersion < L)
-    throw new P(
-      `vaultCoreVersion must be at least ${L}; ${e.vaultCoreVersion} means the version was never resolved`
-    );
-  return se(Ve, [
-    Ee,
-    e.chainId,
-    t,
-    r,
-    e.appKeeperKeyEpoch,
-    e.ucKeyEpoch,
-    e.appVaultKeepersVersion,
-    e.universalChallengersVersion,
-    e.offchainParamsVersion,
-    e.vaultCoreVersion
-  ]);
-}
-function et(e) {
-  return G($e(e));
-}
-class Te extends Error {
-  constructor(t, r) {
-    super(
-      `Re-derived vault root does not match this Pre-PegIn: derived auth-anchor hash ${t}, transaction commits to ${r}. Connect the same wallet, on the same account and the same network, that created the deposit.`
-    ), this.derivedAuthAnchorHash = t, this.onChainAuthAnchorHash = r, this.name = "VaultRootMismatchError";
-  }
-}
-class K extends Error {
-  constructor(t) {
-    super(t), this.name = "UnanchoredPrePeginError";
-  }
-}
-class Ae extends Error {
-  constructor(t, r, n = []) {
-    super(
-      `No candidate parameter set reproduces this Pre-PegIn's HTLC outputs (${t} candidate(s) tried). ` + (n.length > 0 ? `${n.length} version(s) could not be resolved and may hold the answer: ${n.join(" | ")}. ` : "") + `Sample rejections: ${r.join(" | ")}`
-    ), this.candidatesTried = t, this.sampleRejections = r, this.unresolvedLabels = n, this.name = "PeginParamsNotFoundError";
-  }
-}
-class Ie 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 Fe extends Error {
-  constructor(t, r) {
-    super(
-      `A candidate matched this Pre-PegIn (${t}), but ${r.length} version(s) could not be resolved, so the search space did not provably contain the true parameters: ${r.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 = r, this.name = "PeginParamsIncompleteSpaceError";
-  }
-}
-class T extends Error {
-  constructor(t) {
-    super(`${t}. Reconstruction refused.`), this.name = "PeginSizingIntegrityError";
-  }
-}
-async function tt(e) {
-  const { wallet: t, depositorBtcPubkey: r, fundedPrePeginTxHex: n } = e, h = f(n), c = M(h);
-  if (c === 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 u = c.vout;
-  if (u === 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 l = fe(h), a = await Pe(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: he(
-      W(r)
-    ),
-    fundingOutpoints: l
-  });
-  try {
-    const s = await ge(a);
-    let i;
-    try {
-      i = de(ce(s));
-    } finally {
-      s.fill(0);
-    }
-    if (i !== c.hash)
-      throw new Te(i, c.hash);
-  } catch (s) {
-    throw a.fill(0), s;
-  }
-  const { hashlocks: d } = await le(a, u);
-  return { vaultCount: u, hashlocks: d, authAnchorHash: c.hash };
-}
-function rt(e) {
-  const { vaultCoreVersion: t, offchainParams: r, participantKeySets: n } = e;
-  if (!Number.isInteger(t) || t < 1)
-    throw new Error(
-      `buildPeginParamsCandidates: vaultCoreVersion must be a positive integer, got ${t}`
-    );
-  if (r.length === 0)
-    throw new Error(
-      "buildPeginParamsCandidates: at least one offchain-params version is required"
-    );
-  if (n.length === 0)
-    throw new Error(
-      "buildPeginParamsCandidates: at least one participant key set is required"
-    );
-  const h = [];
-  for (const c of r)
-    for (const u of n)
-      h.push({
-        vaultCoreVersion: t,
-        offchainParams: c,
-        participants: u
-      });
-  return h;
-}
-function Be(e) {
-  return `${e.axis} v${e.version} (${e.reason})`;
-}
-function B(e) {
-  const { participants: t } = e;
-  return `core=${e.vaultCoreVersion} offchain=${e.offchainParams.version} keepers=${t.appVaultKeepersVersion} challengers=${t.universalChallengersVersion} vp=${t.vaultProvider}`;
-}
-const j = 5;
-function Ke(e, t) {
-  return JSON.stringify(
-    { terms: e, peginAmounts: t },
-    (r, n) => typeof n == "bigint" ? `${n}` : n
-  );
-}
-function Me(e) {
-  const { offchainParams: t, participants: r } = e;
-  return [
-    e.vaultCoreVersion,
-    r.vaultKeeperBtcPubkeys.length,
-    r.universalChallengerBtcPubkeys.length,
-    t.councilQuorum,
-    t.councilSize,
-    t.protocolFeeRate,
-    t.minPeginFeeRate
-  ].join("|");
-}
-async function Se(e) {
-  const { offchainParams: t, participants: r } = e, n = r.vaultKeeperBtcPubkeys.length, h = r.universalChallengerBtcPubkeys.length, [c, u, l] = await Promise.all([
-    Q(
-      e.vaultCoreVersion,
-      n,
-      h,
-      t.councilQuorum,
-      t.councilSize,
-      t.protocolFeeRate
-    ),
-    q(
-      e.vaultCoreVersion,
-      n,
-      h,
-      t.minPeginFeeRate
-    ),
-    X(e.vaultCoreVersion)
-  ]), a = (l == null ? void 0 : l.value) ?? 0n;
-  if (c <= 0n)
-    throw new T(
-      `WASM returned non-positive depositorClaimValue ${c} for graph version ${e.vaultCoreVersion}`
-    );
-  if (u <= 0n)
-    throw new T(
-      `WASM returned non-positive peginMaxFee ${u} for graph version ${e.vaultCoreVersion}`
-    );
-  if (a < 0n)
-    throw new T(
-      `WASM returned negative P2A anchor value ${a} for graph version ${e.vaultCoreVersion}`
-    );
-  return { depositorClaimValue: c, peginMaxFee: u, p2aAnchorValue: a };
-}
-async function nt(e) {
-  const {
-    hashlocks: t,
-    fundedPrePeginTxHex: r,
-    depositorBtcPubkey: n,
-    prepeginMaxFee: h,
-    maxAcceptableCommissionBps: c,
-    network: u,
-    candidates: l,
-    unresolvedVersions: a
-  } = e;
-  if (t.length === 0)
-    throw new Error(
-      "reconstructPeginParams: at least one hashlock is required"
-    );
-  if (l.length === 0)
-    throw new Error("reconstructPeginParams: candidate space is empty");
-  const d = W(n), s = f(r), i = M(s);
-  if (i === 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 (i.vout !== t.length)
-    throw new Error(
-      `reconstructPeginParams: ${t.length} hashlock(s) supplied but the auth-anchor OP_RETURN sits at vout ${i.vout}, so the transaction funds ${i.vout} HTLC output(s). Reconstruction refused.`
-    );
-  const v = J.fromHex(s).outs, w = t.map((m, p) => BigInt(v[p].value)), C = f(
-    Y(s)
-  ).toLowerCase(), E = /* @__PURE__ */ new Map(), o = [], b = [], A = [];
-  let S = 0;
-  for (const m of l)
-    try {
-      const p = Me(m);
-      let g = E.get(p);
-      g === void 0 && (g = await Se(m), E.set(p, g));
-      const R = g.depositorClaimValue + g.peginMaxFee + g.p2aAnchorValue, k = w.map((x) => x - R), V = k.findIndex((x) => x <= 0n);
-      if (V !== -1)
-        throw new z(
-          `HTLC output[${V}] value ${w[V]} is not above this candidate's reserve ${R}, so it implies a non-positive pegin amount ${k[V]}.`
-        );
-      const { offchainParams: y, participants: I } = m, N = await ye({
-        vaultCoreVersion: m.vaultCoreVersion,
-        siblings: t.map((x, te) => ({
-          hashlock: x,
-          amount: k[te]
-        })),
-        fundedPrePeginTxHex: s,
-        depositorBtcPubkey: d,
-        vaultProviderBtcPubkey: I.vaultProviderBtcPubkey,
-        vaultKeeperBtcPubkeys: I.vaultKeeperBtcPubkeys,
-        universalChallengerBtcPubkeys: I.universalChallengerBtcPubkeys,
-        protocolFeeRate: y.protocolFeeRate,
-        minPeginFeeRate: y.minPeginFeeRate,
-        councilQuorum: y.councilQuorum,
-        councilSize: y.councilSize,
-        timelockPegin: y.timelockPegin,
-        timelockAssert: y.timelockAssert,
-        timelockRefund: y.timelockRefund,
-        prepeginTxid: C,
-        prepeginMaxFee: h,
-        maxAcceptableCommissionBps: c,
-        network: u
-      });
-      o.push({
-        candidate: m,
-        terms: N,
-        peginAmounts: k,
-        fingerprint: Ke(N, k)
-      });
-    } catch (p) {
-      if (p instanceof T)
-        throw p;
-      const g = B(m), R = p instanceof Error ? p.message : String(p);
-      p instanceof z ? b.length < j && b.push(`[${g}] ${R}`) : (S++, A.length < j && A.push(`${g} (${R})`));
-    }
-  const ee = a.length + S, H = [
-    ...a.map(Be),
-    ...A
-  ];
-  if (o.length === 0)
-    throw new Ae(l.length, b, H);
-  if (new Set(o.map((m) => m.fingerprint)).size > 1)
-    throw new Ie(
-      o.map((m) => B(m.candidate))
-    );
-  if (ee > 0)
-    throw new Fe(
-      B(o[0].candidate),
-      H
-    );
-  return {
-    candidate: o[0].candidate,
-    terms: o[0].terms,
-    peginAmounts: o[0].peginAmounts,
-    authAnchorHash: i.hash,
-    candidatesTried: l.length,
-    matchedCandidates: o.map((m) => m.candidate)
-  };
-}
-function ot(e, t) {
-  const {
-    htlcVout: r,
-    depositorBtcPubkey: n,
-    applicationEntryPoint: h,
-    fundedPrePeginTxHex: c,
-    hashlocks: u,
-    network: l
-  } = t, { candidate: a, peginAmounts: d } = e, { offchainParams: s, participants: i } = a;
-  if (u.length !== d.length)
-    throw new Error(
-      `toRefundInputs: ${u.length} hashlock(s) but ${d.length} reconstructed amount(s); the reconstruction and the hashlock vector describe different transactions.`
-    );
-  if (!Number.isInteger(r) || r < 0 || r >= d.length)
-    throw new Error(
-      `toRefundInputs: htlcVout ${r} is outside the reconstructed batch of ${d.length} vault(s).`
-    );
-  const v = d.map((E, o) => ({
-    hashlock: me(u[o]),
-    amount: E,
-    htlcVout: o
-  })), w = {
-    vaultCoreVersion: a.vaultCoreVersion,
-    hashlock: v[r].hashlock,
-    htlcVout: r,
-    offchainParamsVersion: s.version,
-    appVaultKeepersVersion: i.appVaultKeepersVersion,
-    universalChallengersVersion: i.universalChallengersVersion,
-    vaultProvider: i.vaultProvider,
-    applicationEntryPoint: h,
-    amount: d[r],
-    unsignedPrePeginTxHex: c,
-    depositorBtcPubkey: n,
-    batch: v
-  }, C = {
-    vaultProviderPubkey: i.vaultProviderBtcPubkey,
-    vaultKeeperPubkeys: i.vaultKeeperBtcPubkeys,
-    universalChallengerPubkeys: i.universalChallengerBtcPubkeys,
-    timelockRefund: s.timelockRefund,
-    feeRate: s.protocolFeeRate,
-    minPeginFeeRate: s.minPeginFeeRate,
-    // Depositor-as-claimer: the local-challenger count is the keeper count,
-    // the vault provider excluded — btc-vault graph.rs derive_challengers.
-    numLocalChallengers: i.vaultKeeperBtcPubkeys.length,
-    councilQuorum: s.councilQuorum,
-    councilSize: s.councilSize,
-    network: l
-  };
-  return { vault: w, context: C };
-}
-export {
-  Z as D,
-  Ee as P,
-  K as U,
-  Te as V,
-  we as a,
-  P as b,
-  et as c,
-  Ze as d,
-  $e as e,
-  be as f,
-  Je as g,
-  tt as h,
-  Ye as i,
-  rt as j,
-  Be as k,
-  B as l,
-  nt as m,
-  Ae as n,
-  Ie as o,
-  Fe as p,
-  T as q,
-  ye as r,
-  ot as t
-};
-//# sourceMappingURL=toRefundInputs-10RYIfh1.js.map