@babylonlabs-io/ts-sdk 3.1.2 → 3.2.1

package/dist/challengeAssert-B2otuf7y.js

@@ -0,0 +1,509 @@
+import { Transaction as b, Psbt as _, payments as j } from "bitcoinjs-lib";
+import { Buffer as f } from "buffer";
+import { loadTbvWasm as J, tapInternalPubkey as N, getAssertNoPayoutScriptInfo as Z, getChallengeAssertScriptInfo as tt } from "./tbv/core/wasm/index.js";
+import { u as C, T as A, s as g, d as k, h as m, S as B, p as et, k as ot, l as Q } from "./bitcoin-C-TuHb-v.js";
+import { n as rt, l as nt, d as st, P as E, m as it } from "./verifyScriptPathSchnorrSignature-owu3BfyT.js";
+import { R as q, a as X, N as M, b as D, c as G, d as at, A as ut, C as Y, e as H, f as ct, g as lt, h as ht, i as pt } from "./constants-CvQZuxKv.js";
+import { D as z } from "./fundPeginTransaction-CwhRbCQC.js";
+import { X as F } from "./validation-OSC0xTHB.js";
+const dt = (1n << 64n) - 1n;
+function ft(e, n) {
+  if (!Array.isArray(e))
+    throw new Error(
+      `${n} must be an array of positive bigints (got ${typeof e}).`
+    );
+  if (e.length === 0)
+    throw new Error(`${n} must not be empty.`);
+  return e.forEach((t, i) => {
+    if (typeof t != "bigint")
+      throw new Error(
+        `${n}[${i}] must be a bigint (got ${typeof t}); refusing to feed it into satoshi math.`
+      );
+    if (t <= 0n)
+      throw new Error(`${n}[${i}] must be > 0 (got ${t}).`);
+    if (t > dt)
+      throw new Error(
+        `${n}[${i}] must fit in a u64 (got ${t}); refusing to feed it into satoshi math.`
+      );
+  }), e;
+}
+async function Ct(e) {
+  const { WasmPrePeginTx: n } = await J(), { prePeginParams: t, fundedPrePeginTxHex: i, htlcVout: a, refundFee: c, hashlock: s } = e, r = rt(
+    t.authAnchorHash
+  ), o = new n(
+    t.vaultCoreVersion,
+    t.depositorPubkey,
+    t.vaultProviderPubkey,
+    t.vaultKeeperPubkeys,
+    t.universalChallengerPubkeys,
+    [...t.hashlocks],
+    new BigUint64Array(
+      ft(t.pegInAmounts, "pegInAmounts")
+    ),
+    t.timelockRefund,
+    t.feeRate,
+    t.minPeginFeeRate,
+    t.numLocalChallengers,
+    t.councilQuorum,
+    t.councilSize,
+    t.network,
+    r
+  );
+  let u = null;
+  try {
+    const p = o.getHtlcScriptPubKey(a).toLowerCase(), l = nt(t, s), d = l.scriptPubKey.toString("hex");
+    if (p !== d)
+      throw new Error(
+        `WASM HTLC scriptPubKey ${p} does not match the independently derived scriptPubKey ${d}.`
+      );
+    const x = o.getHtlcValue(a);
+    u = o.fromFundedTransaction(i);
+    const w = u.buildRefundTx(c, a), T = i.startsWith("0x") ? i.slice(2) : i, v = b.fromHex(T), P = v.outs[a];
+    if (!P)
+      throw new Error(
+        `HTLC output at vout ${a} not found in funded Pre-PegIn tx (tx has ${v.outs.length} outputs)`
+      );
+    const I = C(
+      new Uint8Array(P.script)
+    ).toLowerCase();
+    if (I !== d)
+      throw new Error(
+        `HTLC scriptPubKey mismatch at vout ${a}: reconstructed template expects ${d}, funded tx carries ${I}. Refund refused — the (hashlocks, pegInAmounts) vector does not match the on-chain commitment.`
+      );
+    const $ = BigInt(P.value);
+    if ($ !== x)
+      throw new Error(
+        `HTLC value mismatch at vout ${a}: reconstructed template expects ${x} sat, funded tx carries ${$} sat. Refund refused — the pegInAmounts vector does not match the on-chain commitment.`
+      );
+    const h = b.fromHex(w);
+    if (h.version !== q)
+      throw new Error(
+        `Refund transaction version ${h.version} does not match protocol version ${q}.`
+      );
+    if (h.locktime !== X)
+      throw new Error(
+        `Refund transaction locktime ${h.locktime} does not match protocol locktime ${X}.`
+      );
+    if (h.ins.length !== 1)
+      throw new Error(
+        `Refund transaction must have exactly 1 input, got ${h.ins.length}`
+      );
+    const y = h.ins[0], O = v.getId(), L = C(
+      new Uint8Array(y.hash).slice().reverse()
+    );
+    if (L !== O)
+      throw new Error(
+        `Refund input does not reference the Pre-PegIn transaction. Expected ${O}, got ${L}`
+      );
+    if (y.index !== a)
+      throw new Error(
+        `Refund input index ${y.index} does not match expected htlcVout ${a}`
+      );
+    if (y.sequence !== t.timelockRefund)
+      throw new Error(
+        `Refund input sequence ${y.sequence} does not match timelockRefund ${t.timelockRefund}.`
+      );
+    const S = new _();
+    if (S.setVersion(h.version), S.setLocktime(h.locktime), S.addInput({
+      hash: y.hash,
+      index: y.index,
+      sequence: y.sequence,
+      witnessUtxo: {
+        script: P.script,
+        value: P.value
+      },
+      tapLeafScript: [
+        {
+          leafVersion: A,
+          script: l.refundScript,
+          controlBlock: l.refundControlBlock
+        }
+      ],
+      tapInternalKey: f.from(N),
+      tapMerkleRoot: l.tapMerkleRoot
+    }), h.outs.length !== 1)
+      throw new Error(
+        `Refund transaction must have exactly 1 output, got ${h.outs.length}`
+      );
+    const R = h.outs[0], U = g(
+      k(t.depositorPubkey)
+    ).toLowerCase(), V = C(
+      new Uint8Array(R.script)
+    ).toLowerCase();
+    if (V !== U)
+      throw new Error(
+        `Refund output scriptPubKey ${V} does not match the depositor's BIP-86 address ${U}. Refund refused — the reclaimed funds would not return to the depositor.`
+      );
+    const K = $ - c;
+    if (BigInt(R.value) !== K)
+      throw new Error(
+        `Refund output value ${BigInt(R.value)} sat does not equal the HTLC value ${$} sat minus the requested fee ${c} sat (expected ${K} sat). Refund refused — the reclaimed amount would be burned as excess fee.`
+      );
+    return S.addOutput({
+      script: R.script,
+      value: R.value
+    }), { psbtHex: S.toHex() };
+  } finally {
+    u == null || u.free(), o.free();
+  }
+}
+const gt = 2, wt = 4294967293, mt = 214, $t = 299, Et = 4;
+function xt(e) {
+  if (!Number.isInteger(e) || e < 1)
+    throw new Error(
+      `Reclaim input count must be a positive integer, got ${e}.`
+    );
+  return Math.ceil(
+    (mt + $t * e) / Et
+  );
+}
+function _t(e, n) {
+  if (!Number.isFinite(e) || e <= 0)
+    throw new Error(
+      `Reclaim fee rate must be a positive number, got ${e}.`
+    );
+  return BigInt(Math.ceil(e * xt(n)));
+}
+function Ht(e) {
+  const { depositorPubkey: n, inputs: t, feeSats: i } = e;
+  if (t.length === 0)
+    throw new Error("Reclaim requires at least one input; got none.");
+  if (i <= 0n)
+    throw new Error(
+      `Reclaim fee must be positive, got ${i} sat. Refusing to build a transaction that would not relay.`
+    );
+  const a = st(n), c = C(
+    new Uint8Array(a.scriptPubKey)
+  ).toLowerCase(), s = new _();
+  s.setVersion(gt), s.setLocktime(0);
+  let r = 0n;
+  const o = /* @__PURE__ */ new Set();
+  if (t.forEach((l, d) => {
+    const x = b.fromHex(
+      g(l.depositorSignedPeginTxHex)
+    ), w = x.getId(), T = x.outs[E];
+    if (!T)
+      throw new Error(
+        `PegIn ${w} has no output at vout ${E} (tx has ${x.outs.length}); there is no depositor-claim reserve to reclaim.`
+      );
+    const v = g(l.observed.txid).toLowerCase();
+    if (v !== w)
+      throw new Error(
+        `Input ${d}: the observation is of ${v}, but this input spends PegIn ${w}. Reclaim refused — the reserve that was looked up is not the one being swept.`
+      );
+    if (l.observed.vout !== E)
+      throw new Error(
+        `Input ${d}: the observation is of vout ${l.observed.vout}, but the depositor-claim reserve is at vout ${E}. Reclaim refused.`
+      );
+    const P = C(
+      new Uint8Array(T.script)
+    ).toLowerCase();
+    if (P !== c)
+      throw new Error(
+        `Input ${d}: PegIn ${w} vout ${E} pays ${P}, but the connected wallet's depositor-claim script is ${c}. Reclaim refused — this reserve belongs to a different wallet.`
+      );
+    const I = g(
+      l.observed.scriptPubKey
+    ).toLowerCase();
+    if (I !== c)
+      throw new Error(
+        `Input ${d}: the observed UTXO ${w}:${E} pays ${I}, expected ${c}. Reclaim refused — chain state disagrees with the contract's PegIn.`
+      );
+    const $ = BigInt(T.value);
+    if ($ !== l.observed.value)
+      throw new Error(
+        `Input ${d}: PegIn ${w} vout ${E} carries ${$} sat, but the observed UTXO carries ${l.observed.value} sat. Reclaim refused.`
+      );
+    if ($ !== l.expectedValue)
+      throw new Error(
+        `Input ${d}: PegIn ${w} vout ${E} carries ${$} sat, but this vault's parameters compute a depositor-claim value of ${l.expectedValue} sat. Reclaim refused.`
+      );
+    const h = `${w}:${E}`;
+    if (o.has(h))
+      throw new Error(
+        `Input ${d} repeats outpoint ${h}, which is already being swept by an earlier input. Reclaim refused.`
+      );
+    o.add(h), r += $, s.addInput({
+      hash: w,
+      index: E,
+      sequence: wt,
+      witnessUtxo: { script: T.script, value: T.value },
+      tapLeafScript: [
+        {
+          leafVersion: A,
+          script: a.leafScript,
+          controlBlock: a.controlBlock
+        }
+      ],
+      tapInternalKey: a.internalKey
+    });
+  }), i >= r)
+    throw new Error(
+      `Reclaim fee ${i} sat is not less than the swept total ${r} sat. Refusing to build a transaction with no output.`
+    );
+  const u = r - i;
+  if (u <= z)
+    throw new Error(
+      `Reclaim output ${u} sat is at or below the dust threshold ${z} sat. The reserve is not at risk — it stays where it is until fee rates fall.`
+    );
+  const p = g(
+    k(n)
+  );
+  return s.addOutput({
+    script: f.from(m(p)),
+    value: Number(u)
+  }), { psbtHex: s.toHex(), outputValue: u, totalInputValue: r };
+}
+function Nt(e) {
+  const { requestedPsbtHex: n, signaturesHex: t, signerXOnlyPubkeyHex: i } = e, a = g(i);
+  if (a.length !== F)
+    throw new Error(
+      `Signer x-only pubkey must be ${F} hex chars (32 bytes), got ${a.length}.`
+    );
+  const c = f.from(m(a)), s = _.fromHex(n);
+  if (t.length !== s.data.inputs.length)
+    throw new Error(
+      `Cannot finalize: got ${t.length} signature(s) for ${s.data.inputs.length} input(s). Every input must be signed — refusing to broadcast a partially signed transaction.`
+    );
+  return s.data.inputs.forEach((r, o) => {
+    if (r.tapKeySig)
+      throw new Error(
+        `Cannot finalize: input ${o} of the locally built PSBT carries a key-path signature. These outputs are script-path only.`
+      );
+    const u = r.tapLeafScript;
+    if (!u || u.length !== 1)
+      throw new Error(
+        `Cannot finalize: input ${o} must have exactly one tapLeafScript, got ${(u == null ? void 0 : u.length) ?? 0}.`
+      );
+    const p = u[0];
+    if (p.leafVersion !== A)
+      throw new Error(
+        `Cannot finalize: input ${o} tapLeafScript has leaf version 0x${p.leafVersion.toString(16)}, expected 0x${A.toString(16)}.`
+      );
+    const l = g(t[o]);
+    if (l.length !== B)
+      throw new Error(
+        `Signature for input ${o} must be ${B} hex chars (64 bytes), got ${l.length}.`
+      );
+    s.updateInput(o, {
+      tapScriptSig: [
+        {
+          pubkey: c,
+          leafHash: it(p.leafVersion, p.script),
+          signature: f.from(m(l))
+        }
+      ]
+    });
+  }), s.finalizeAllInputs(), s.extractTransaction().toHex();
+}
+const W = 65535;
+async function kt(e) {
+  const n = g(e.noPayoutTxHex), t = b.fromHex(n), { noPayoutScript: i, noPayoutControlBlock: a } = await Z(
+    e.connectorParams,
+    e.challengerPubkey
+  ), c = m(i), s = m(a), r = new _();
+  r.setVersion(t.version), r.setLocktime(t.locktime);
+  for (let o = 0; o < t.ins.length; o++) {
+    const u = t.ins[o], p = e.prevouts[o];
+    if (!p)
+      throw new Error(`Missing prevout data for input ${o}`);
+    const l = {
+      hash: u.hash,
+      index: u.index,
+      sequence: u.sequence,
+      witnessUtxo: {
+        script: f.from(m(g(p.script_pubkey))),
+        value: p.value
+      }
+    };
+    o === 0 && (l.tapLeafScript = [
+      {
+        leafVersion: A,
+        script: f.from(c),
+        controlBlock: f.from(s)
+      }
+    ], l.tapInternalKey = f.from(N)), r.addInput(l);
+  }
+  for (const o of t.outs)
+    r.addOutput({
+      script: o.script,
+      value: o.value
+    });
+  return r.toHex();
+}
+function Ot(e, n, t) {
+  const i = b.fromHex(g(e));
+  if (i.outs.length !== 1)
+    throw new Error(
+      `NoPayout transaction must have exactly 1 output, got ${i.outs.length}`
+    );
+  const a = m(et(n)), { output: c } = j.p2tr({
+    internalPubkey: f.from(a),
+    network: ot(t)
+  });
+  if (!c)
+    throw new Error(
+      "Failed to derive challenger BIP-86 P2TR scriptPubKey for NoPayout output validation"
+    );
+  if (!i.outs[0].script.equals(c))
+    throw new Error(
+      "NoPayout transaction does not pay to the expected challenger BIP-86 P2TR address"
+    );
+}
+function Lt(e) {
+  const { noPayoutTx: n, timelockChallengeAssert: t } = e;
+  if (!Number.isInteger(t) || t < 1 || t > W)
+    throw new Error(
+      `timelockChallengeAssert must be an integer in 1..${W}, got ${t}`
+    );
+  if (n.version !== M)
+    throw new Error(
+      `NoPayout version must be ${M}, got ${n.version}`
+    );
+  if (n.locktime !== D)
+    throw new Error(
+      `NoPayout locktime must be ${D}, got ${n.locktime}`
+    );
+  if (n.ins.length !== G)
+    throw new Error(
+      `NoPayout must have exactly ${G} inputs, got ${n.ins.length}`
+    );
+  [
+    {
+      label: "Assert",
+      txid: e.assertTxid,
+      vout: ut,
+      sequence: at
+    },
+    {
+      label: "ChallengeAssertX",
+      txid: e.challengeAssertXTxid,
+      vout: Y,
+      sequence: t
+    },
+    {
+      label: "ChallengeAssertY",
+      txid: e.challengeAssertYTxid,
+      vout: Y,
+      sequence: t
+    }
+  ].forEach((s, r) => {
+    const o = n.ins[r], u = Q(o);
+    if (u !== s.txid || o.index !== s.vout)
+      throw new Error(
+        `NoPayout input ${r} must spend ${s.label} ${s.txid}:${s.vout}, got ${u}:${o.index}`
+      );
+    if (o.sequence !== s.sequence)
+      throw new Error(
+        `NoPayout input ${r} (${s.label}) sequence must be ${s.sequence}, got ${o.sequence}`
+      );
+  });
+  const a = e.prevoutValues.reduce((s, r) => s + r, 0), c = n.outs.reduce((s, r) => s + r.value, 0);
+  if (c > a)
+    throw new Error(
+      `NoPayout output value ${c} exceeds its inputs (${a} sats)`
+    );
+}
+async function Ut(e) {
+  const n = b.fromHex(
+    g(e.challengeAssertTxHex)
+  ), t = b.fromHex(g(e.assertTxHex)), i = t.getId();
+  if (e.connectorParamsPerInput.length !== n.ins.length)
+    throw new Error(
+      `Expected ${n.ins.length} connector params, got ${e.connectorParamsPerInput.length}`
+    );
+  const a = /* @__PURE__ */ new Set();
+  for (let r = 0; r < n.ins.length; r++) {
+    const o = n.ins[r], u = Q(o);
+    if (u !== i)
+      throw new Error(
+        `ChallengeAssert input ${r} must spend an Assert output. Expected txid ${i}, got ${u}`
+      );
+    if (!t.outs[o.index])
+      throw new Error(
+        `Assert output ${o.index} not found for ChallengeAssert input ${r} (txid: ${i})`
+      );
+    if (a.has(o.index))
+      throw new Error(
+        `ChallengeAssert input ${r} duplicates Assert output index ${o.index}`
+      );
+    a.add(o.index);
+  }
+  const c = await Promise.all(
+    e.connectorParamsPerInput.map((r) => tt(r))
+  ), s = new _();
+  s.setVersion(n.version), s.setLocktime(n.locktime);
+  for (let r = 0; r < n.ins.length; r++) {
+    const o = n.ins[r], u = t.outs[o.index], { script: p, controlBlock: l } = c[r], d = m(p), x = m(l);
+    s.addInput({
+      hash: o.hash,
+      index: o.index,
+      sequence: o.sequence,
+      witnessUtxo: {
+        script: u.script,
+        value: u.value
+      },
+      tapLeafScript: [
+        {
+          leafVersion: A,
+          script: f.from(d),
+          controlBlock: f.from(x)
+        }
+      ],
+      tapInternalKey: f.from(N)
+    });
+  }
+  for (const r of n.outs)
+    s.addOutput({
+      script: r.script,
+      value: r.value
+    });
+  return s.toHex();
+}
+function Vt(e) {
+  const n = Pt(e).getId(), t = e.challengeAssertTx.getId();
+  if (t !== n)
+    throw new Error(
+      `ChallengeAssert${e.half} (challenger ${e.challengerPubkey}) is not the canonical transaction for this Assert: expected txid ${n}, got ${t}`
+    );
+}
+function Pt(e) {
+  const { assertTx: n, half: t, challengerIndex: i, challengerCount: a } = e;
+  if (!Number.isInteger(i) || i < 0 || i >= a)
+    throw new Error(
+      `ChallengeAssert${t} challenger index ${i} is outside 0..${a - 1}`
+    );
+  const c = pt + (t === "Y" ? a : 0) + i, s = n.outs[c];
+  if (!s)
+    throw new Error(
+      `Assert has no output ${c} for the ChallengeAssert${t} of challenger index ${i}`
+    );
+  const r = s.value - H;
+  if (r < 0)
+    throw new Error(
+      `Assert output ${c} (${s.value} sats) cannot fund the ${H}-sat ChallengeAssert${t} anchor`
+    );
+  const o = new b();
+  return o.version = ct, o.locktime = lt, o.addInput(n.getHash(), c, ht), o.addOutput(
+    f.from(m(e.outputConnectorScriptPubKey)),
+    r
+  ), o.addOutput(
+    f.from(
+      m(k(e.challengerPubkey))
+    ),
+    H
+  ), o;
+}
+export {
+  Ht as a,
+  Ct as b,
+  kt as c,
+  Ut as d,
+  _t as e,
+  Nt as f,
+  Ot as g,
+  Vt as h,
+  Lt as i,
+  xt as r
+};
+//# sourceMappingURL=challengeAssert-B2otuf7y.js.map