@babylonlabs-io/ts-sdk 0.3.0 → 0.4.1-rc.0

package/dist/challengeAssert-ZXE00zkT.js

@@ -0,0 +1,617 @@
+import { createPrePeginTransaction as W, buildPeginTxFromPrePegin as F, getPrePeginHtlcConnectorInfo as K, tapInternalPubkey as k, createPayoutConnector as N, getPeginPayoutScript as q, getAssertNoPayoutScriptInfo as M, getChallengeAssertScriptInfo as z } from "@babylonlabs-io/babylon-tbv-rust-wasm";
+import * as U from "bitcoinjs-lib";
+import { payments as b, networks as T, initEccLib as H, Transaction as y, Psbt as w } from "bitcoinjs-lib";
+import { Buffer as a } from "buffer";
+import * as A from "@bitcoin-js/tiny-secp256k1-asmjs";
+function h(t) {
+  return t.startsWith("0x") ? t.slice(2) : t;
+}
+function ut(t) {
+  return t.startsWith("0x") ? t : `0x${t}`;
+}
+function d(t) {
+  const n = h(t);
+  if (!B(n))
+    throw new Error(`Invalid hex string: ${t}`);
+  const e = new Uint8Array(n.length / 2);
+  for (let o = 0; o < n.length; o += 2)
+    e[o / 2] = parseInt(n.slice(o, o + 2), 16);
+  return e;
+}
+function x(t) {
+  return Array.from(t).map((n) => n.toString(16).padStart(2, "0")).join("");
+}
+function D(t) {
+  return t.length === 32 ? t : t.slice(1, 33);
+}
+function B(t) {
+  return /^[0-9a-fA-F]*$/.test(t) && t.length % 2 === 0;
+}
+function $(t) {
+  const n = h(t);
+  if (!B(n))
+    throw new Error(`Invalid hex characters in public key: ${t}`);
+  if (n.length === 64)
+    return n;
+  if (n.length !== 66 && n.length !== 130)
+    throw new Error(
+      `Invalid public key length: ${n.length} (expected 64, 66, or 130 hex chars)`
+    );
+  const e = d(n);
+  return x(D(e));
+}
+function at(t) {
+  const n = h(t);
+  return B(n);
+}
+function lt(t, n) {
+  const e = $(t), o = n ?? e;
+  if (e.toLowerCase() !== o.toLowerCase())
+    throw new Error(
+      `Wallet public key does not match vault depositor. Expected: ${o}, Got: ${e}. Please connect the wallet that was used to create this vault.`
+    );
+  return { walletPubkeyRaw: t, walletPubkeyXOnly: e, depositorPubkey: o };
+}
+let _ = !1;
+function X() {
+  _ || (H(A), _ = !0);
+}
+function V(t) {
+  switch (t) {
+    case "bitcoin":
+      return T.bitcoin;
+    case "testnet":
+    case "signet":
+      return T.testnet;
+    case "regtest":
+      return T.regtest;
+    default:
+      throw new Error(`Unknown network: ${t}`);
+  }
+}
+function Y(t, n) {
+  X();
+  const e = d($(t)), { address: o } = b.p2tr({
+    internalPubkey: a.from(e),
+    network: V(n)
+  });
+  if (!o)
+    throw new Error("Failed to derive taproot address from public key");
+  return o;
+}
+function Q(t, n) {
+  const e = h(t);
+  if (e.length !== 66)
+    throw new Error(
+      `Native SegWit requires a compressed public key (66 hex chars), got ${e.length}`
+    );
+  const { address: o } = b.p2wpkh({
+    pubkey: a.from(d(e)),
+    network: V(n)
+  });
+  if (!o)
+    throw new Error(
+      "Failed to derive native segwit address from public key"
+    );
+  return o;
+}
+function pt(t, n, e) {
+  const o = h(n);
+  try {
+    if (t === Y(o, e))
+      return !0;
+  } catch {
+  }
+  const r = [];
+  o.length === 66 ? r.push(o) : o.length === 64 && r.push(`02${o}`, `03${o}`);
+  for (const s of r)
+    try {
+      if (t === Q(s, e))
+        return !0;
+    } catch {
+    }
+  return !1;
+}
+function I(t) {
+  return $(t).toLowerCase();
+}
+function ft(t, n, e) {
+  const o = /* @__PURE__ */ new Set();
+  o.add(I(t));
+  for (const r of n)
+    o.add(I(r));
+  return o.delete(I(e)), o.size;
+}
+const ht = 58, dt = 43, gt = 11, G = 546, Z = BigInt(G), j = 30, J = 2, Pt = 1.1;
+function yt(t) {
+  return t <= J ? j : 0;
+}
+const xt = 5;
+function R(t) {
+  const e = t.substring(8, 12) === "0001" ? 12 : 8, o = parseInt(
+    t.substring(e, e + 2),
+    16
+  ), r = parseInt(
+    t.substring(e + 2, e + 4),
+    16
+  );
+  if (o !== 0)
+    throw new Error(`Expected 0 inputs from WASM, got ${o}`);
+  if (r === 0)
+    throw new Error("Expected at least 1 output from WASM, got 0");
+  const s = a.from(t.substring(0, 8), "hex").readUInt32LE(0), u = a.from(
+    t.substring(t.length - 8),
+    "hex"
+  ).readUInt32LE(0), c = [];
+  let i = e + 4;
+  for (let p = 0; p < r; p++) {
+    const l = t.substring(i, i + 16), f = Number(a.from(l, "hex").readBigUInt64LE(0));
+    i += 16;
+    const g = parseInt(t.substring(i, i + 2), 16);
+    i += 2;
+    const P = t.substring(i, i + g * 2), v = a.from(P, "hex");
+    i += g * 2, c.push({ value: f, script: v });
+  }
+  return { version: s, locktime: u, outputs: c };
+}
+function kt(t) {
+  const { unfundedTxHex: n, selectedUTXOs: e, changeAddress: o, changeAmount: r, network: s } = t, { version: u, locktime: c, outputs: i } = R(n), p = new U.Transaction();
+  p.version = u, p.locktime = c;
+  for (const l of e) {
+    const f = a.from(l.txid, "hex").reverse();
+    p.addInput(f, l.vout);
+  }
+  for (const l of i)
+    p.addOutput(l.script, l.value);
+  if (r > Z) {
+    const l = U.address.toOutputScript(o, s);
+    p.addOutput(l, Number(r));
+  }
+  return p.toHex();
+}
+async function wt(t) {
+  const n = await W({
+    depositorPubkey: t.depositorPubkey,
+    vaultProviderPubkey: t.vaultProviderPubkey,
+    vaultKeeperPubkeys: t.vaultKeeperPubkeys,
+    universalChallengerPubkeys: t.universalChallengerPubkeys,
+    hashH: t.hashH,
+    timelockRefund: t.timelockRefund,
+    pegInAmount: t.pegInAmount,
+    feeRate: t.feeRate,
+    numLocalChallengers: t.numLocalChallengers,
+    councilQuorum: t.councilQuorum,
+    councilSize: t.councilSize,
+    network: t.network
+  }), o = R(n.txHex).outputs.reduce(
+    (r, s) => r + BigInt(s.value),
+    0n
+  );
+  return {
+    psbtHex: n.txHex,
+    totalOutputValue: o,
+    htlcValue: n.htlcValue,
+    htlcScriptPubKey: n.htlcScriptPubKey,
+    htlcAddress: n.htlcAddress,
+    peginAmount: n.peginAmount,
+    depositorClaimValue: n.depositorClaimValue
+  };
+}
+async function vt(t) {
+  const n = await F(
+    {
+      depositorPubkey: t.prePeginParams.depositorPubkey,
+      vaultProviderPubkey: t.prePeginParams.vaultProviderPubkey,
+      vaultKeeperPubkeys: t.prePeginParams.vaultKeeperPubkeys,
+      universalChallengerPubkeys: t.prePeginParams.universalChallengerPubkeys,
+      hashH: t.prePeginParams.hashH,
+      timelockRefund: t.prePeginParams.timelockRefund,
+      pegInAmount: t.prePeginParams.pegInAmount,
+      feeRate: t.prePeginParams.feeRate,
+      numLocalChallengers: t.prePeginParams.numLocalChallengers,
+      councilQuorum: t.prePeginParams.councilQuorum,
+      councilSize: t.prePeginParams.councilSize,
+      network: t.prePeginParams.network
+    },
+    t.timelockPegin,
+    t.fundedPrePeginTxid
+  );
+  return {
+    txHex: n.txHex,
+    txid: n.txid,
+    vaultScriptPubKey: n.vaultScriptPubKey,
+    vaultValue: n.vaultValue
+  };
+}
+async function bt(t) {
+  const n = h(t.peginTxHex), e = h(t.fundedPrePeginTxHex), o = await K({
+    depositorPubkey: t.depositorPubkey,
+    vaultProviderPubkey: t.vaultProviderPubkey,
+    vaultKeeperPubkeys: t.vaultKeeperPubkeys,
+    universalChallengerPubkeys: t.universalChallengerPubkeys,
+    hashH: t.hashH,
+    timelockRefund: t.timelockRefund,
+    network: t.network
+  }), r = y.fromHex(n), s = y.fromHex(e);
+  if (r.ins.length !== 1)
+    throw new Error(
+      `PegIn transaction must have exactly 1 input, got ${r.ins.length}`
+    );
+  const u = r.ins[0], c = s.getId(), i = x(
+    new Uint8Array(u.hash).slice().reverse()
+  );
+  if (i !== c)
+    throw new Error(
+      `PegIn input does not reference the Pre-PegIn transaction. Expected ${c}, got ${i}`
+    );
+  const p = s.outs[u.index];
+  if (!p)
+    throw new Error(
+      `Pre-PegIn output ${u.index} not found (Pre-PegIn has ${s.outs.length} outputs)`
+    );
+  const l = d(o.hashlockScript), f = d(o.hashlockControlBlock), g = new w();
+  g.setVersion(r.version), g.setLocktime(r.locktime), g.addInput({
+    hash: u.hash,
+    index: u.index,
+    sequence: u.sequence,
+    witnessUtxo: {
+      script: p.script,
+      value: p.value
+    },
+    tapLeafScript: [
+      {
+        leafVersion: 192,
+        script: a.from(l),
+        controlBlock: a.from(f)
+      }
+    ],
+    tapInternalKey: a.from(k)
+    // sighashType omitted — defaults to SIGHASH_DEFAULT (0x00) for Taproot
+  });
+  for (const P of r.outs)
+    g.addOutput({
+      script: P.script,
+      value: P.value
+    });
+  return { psbtHex: g.toHex() };
+}
+function mt(t, n) {
+  const o = w.fromHex(t).data.inputs[0];
+  if (!o)
+    throw new Error("PegIn PSBT has no inputs");
+  if (o.tapScriptSig && o.tapScriptSig.length > 0) {
+    const r = a.from(
+      d(n)
+    );
+    for (const s of o.tapScriptSig)
+      if (s.pubkey.equals(r))
+        return tt(s.signature);
+    throw new Error(
+      `No PegIn input signature found for depositor pubkey: ${n}`
+    );
+  }
+  throw o.finalScriptWitness && o.finalScriptWitness.length > 0 ? new Error(
+    "PegIn input PSBT is already finalized. Cannot reliably extract the depositor signature from the witness stack. Ensure the wallet returns a non-finalized PSBT with tapScriptSig entries."
+  ) : new Error(
+    "No tapScriptSig or finalScriptWitness found in signed PegIn input PSBT"
+  );
+}
+function tt(t) {
+  if (t.length === 64)
+    return x(new Uint8Array(t));
+  if (t.length === 65)
+    return x(new Uint8Array(t.subarray(0, 64)));
+  throw new Error(`Unexpected PegIn input signature length: ${t.length}`);
+}
+async function et(t) {
+  const n = await N(
+    {
+      depositor: t.depositor,
+      vaultProvider: t.vaultProvider,
+      vaultKeepers: t.vaultKeepers,
+      universalChallengers: t.universalChallengers,
+      timelockPegin: t.timelockPegin
+    },
+    t.network
+  );
+  return {
+    payoutScript: n.payoutScript,
+    taprootScriptHash: n.taprootScriptHash,
+    scriptPubKey: n.scriptPubKey,
+    address: n.address
+  };
+}
+H(A);
+async function St(t) {
+  const n = h(t.payoutTxHex), e = h(t.peginTxHex), o = h(t.assertTxHex), r = await et({
+    depositor: t.depositorBtcPubkey,
+    vaultProvider: t.vaultProviderBtcPubkey,
+    vaultKeepers: t.vaultKeeperBtcPubkeys,
+    universalChallengers: t.universalChallengerBtcPubkeys,
+    timelockPegin: t.timelockPegin,
+    network: t.network
+  }), s = d(r.payoutScript), u = ot(k, s), c = y.fromHex(n), i = y.fromHex(e), p = y.fromHex(o), l = new w();
+  if (l.setVersion(c.version), l.setLocktime(c.locktime), c.ins.length !== 2)
+    throw new Error(
+      `Payout transaction must have exactly 2 inputs, got ${c.ins.length}`
+    );
+  const f = c.ins[0], g = c.ins[1], P = x(
+    new Uint8Array(f.hash).slice().reverse()
+  ), v = i.getId();
+  if (P !== v)
+    throw new Error(
+      `Input 0 does not reference pegin transaction. Expected ${v}, got ${P}`
+    );
+  const m = x(
+    new Uint8Array(g.hash).slice().reverse()
+  ), C = p.getId();
+  if (m !== C)
+    throw new Error(
+      `Input 1 does not reference assert transaction. Expected ${C}, got ${m}`
+    );
+  const S = i.outs[f.index];
+  if (!S)
+    throw new Error(
+      `Previous output not found for input 0 (txid: ${P}, index: ${f.index})`
+    );
+  const E = p.outs[g.index];
+  if (!E)
+    throw new Error(
+      `Previous output not found for input 1 (txid: ${m}, index: ${g.index})`
+    );
+  l.addInput({
+    hash: f.hash,
+    index: f.index,
+    sequence: f.sequence,
+    witnessUtxo: {
+      script: S.script,
+      value: S.value
+    },
+    tapLeafScript: [
+      {
+        leafVersion: 192,
+        script: a.from(s),
+        controlBlock: a.from(u)
+      }
+    ],
+    tapInternalKey: a.from(k)
+    // sighashType omitted - defaults to SIGHASH_DEFAULT (0x00) for Taproot
+  }), l.addInput({
+    hash: g.hash,
+    index: g.index,
+    sequence: g.sequence,
+    witnessUtxo: {
+      script: E.script,
+      value: E.value
+    }
+    // No tapLeafScript - depositor doesn't sign this input
+  });
+  for (const L of c.outs)
+    l.addOutput({
+      script: L.script,
+      value: L.value
+    });
+  return {
+    psbtHex: l.toHex()
+  };
+}
+function Et(t, n, e = 0) {
+  const o = w.fromHex(t);
+  if (e >= o.data.inputs.length)
+    throw new Error(
+      `Input index ${e} out of range (${o.data.inputs.length} inputs)`
+    );
+  const r = o.data.inputs[e];
+  if (r.tapScriptSig && r.tapScriptSig.length > 0) {
+    const s = d(n);
+    for (const u of r.tapScriptSig)
+      if (u.pubkey.equals(a.from(s)))
+        return O(u.signature, e);
+    throw new Error(
+      `No signature found for depositor pubkey: ${n} at input ${e}`
+    );
+  }
+  if (r.finalScriptWitness && r.finalScriptWitness.length > 0) {
+    const s = nt(r.finalScriptWitness);
+    if (s.length >= 1)
+      return O(s[0], e);
+  }
+  throw new Error(
+    `No tapScriptSig or finalScriptWitness found in signed PSBT at input ${e}`
+  );
+}
+function O(t, n) {
+  if (t.length === 64)
+    return x(new Uint8Array(t));
+  if (t.length === 65)
+    return x(new Uint8Array(t.subarray(0, 64)));
+  throw new Error(
+    `Unexpected signature length at input ${n}: ${t.length}`
+  );
+}
+function nt(t) {
+  const n = [];
+  let e = 0;
+  const o = () => {
+    const s = t[e++];
+    if (s < 253) return s;
+    if (s === 253) {
+      const u = t[e] | t[e + 1] << 8;
+      return e += 2, u;
+    }
+    if (s === 254) {
+      const u = t[e] | t[e + 1] << 8 | t[e + 2] << 16 | t[e + 3] << 24;
+      return e += 4, u;
+    }
+    return e += 8, 0;
+  }, r = o();
+  for (let s = 0; s < r; s++) {
+    const u = o();
+    n.push(t.subarray(e, e + u)), e += u;
+  }
+  return n;
+}
+function ot(t, n) {
+  const e = { output: a.from(n) }, r = b.p2tr({
+    internalPubkey: a.from(t),
+    scriptTree: e
+  }).pubkey;
+  if (!r)
+    throw new Error("Failed to compute output key");
+  const s = 192, u = r[0] === 3 ? 1 : 0, c = s | u, i = new Uint8Array(1 + t.length);
+  return i[0] = c, i.set(t, 1), i;
+}
+H(A);
+async function Tt(t) {
+  const n = h(t.payoutTxHex), e = y.fromHex(n), o = await q(t.connectorParams), r = d(o), s = rt(k, r), u = new w();
+  u.setVersion(e.version), u.setLocktime(e.locktime);
+  for (let c = 0; c < e.ins.length; c++) {
+    const i = e.ins[c], p = t.prevouts[c];
+    if (!p)
+      throw new Error(`Missing prevout data for input ${c}`);
+    const l = {
+      hash: i.hash,
+      index: i.index,
+      sequence: i.sequence,
+      witnessUtxo: {
+        script: a.from(d(h(p.script_pubkey))),
+        value: p.value
+      }
+    };
+    c === 0 && (l.tapLeafScript = [
+      {
+        leafVersion: 192,
+        script: a.from(r),
+        controlBlock: a.from(s)
+      }
+    ], l.tapInternalKey = a.from(k)), u.addInput(l);
+  }
+  for (const c of e.outs)
+    u.addOutput({
+      script: c.script,
+      value: c.value
+    });
+  return u.toHex();
+}
+function rt(t, n) {
+  const e = { output: a.from(n) }, r = b.p2tr({
+    internalPubkey: a.from(t),
+    scriptTree: e
+  }).pubkey;
+  if (!r)
+    throw new Error("Failed to compute output key");
+  const s = 192, u = r[0] === 3 ? 1 : 0, c = s | u, i = new Uint8Array(1 + t.length);
+  return i[0] = c, i.set(t, 1), i;
+}
+async function It(t) {
+  const n = h(t.noPayoutTxHex), e = y.fromHex(n), { noPayoutScript: o, noPayoutControlBlock: r } = await M(
+    t.connectorParams,
+    t.challengerPubkey
+  ), s = d(o), u = d(r), c = new w();
+  c.setVersion(e.version), c.setLocktime(e.locktime);
+  for (let i = 0; i < e.ins.length; i++) {
+    const p = e.ins[i], l = t.prevouts[i];
+    if (!l)
+      throw new Error(`Missing prevout data for input ${i}`);
+    const f = {
+      hash: p.hash,
+      index: p.index,
+      sequence: p.sequence,
+      witnessUtxo: {
+        script: a.from(d(h(l.script_pubkey))),
+        value: l.value
+      }
+    };
+    i === 0 && (f.tapLeafScript = [
+      {
+        leafVersion: 192,
+        script: a.from(s),
+        controlBlock: a.from(u)
+      }
+    ], f.tapInternalKey = a.from(k)), c.addInput(f);
+  }
+  for (const i of e.outs)
+    c.addOutput({
+      script: i.script,
+      value: i.value
+    });
+  return c.toHex();
+}
+async function Ht(t) {
+  const n = h(t.challengeAssertTxHex), e = y.fromHex(n);
+  if (t.connectorParamsPerInput.length !== e.ins.length)
+    throw new Error(
+      `Expected ${e.ins.length} connector params, got ${t.connectorParamsPerInput.length}`
+    );
+  const o = await Promise.all(
+    t.connectorParamsPerInput.map((s) => z(s))
+  ), r = new w();
+  r.setVersion(e.version), r.setLocktime(e.locktime);
+  for (let s = 0; s < e.ins.length; s++) {
+    const u = e.ins[s], c = t.prevouts[s];
+    if (!c)
+      throw new Error(`Missing prevout data for input ${s}`);
+    const { script: i, controlBlock: p } = o[s], l = d(i), f = d(p);
+    r.addInput({
+      hash: u.hash,
+      index: u.index,
+      sequence: u.sequence,
+      witnessUtxo: {
+        script: a.from(d(h(c.script_pubkey))),
+        value: c.value
+      },
+      tapLeafScript: [
+        {
+          leafVersion: 192,
+          script: a.from(l),
+          controlBlock: a.from(f)
+        }
+      ],
+      tapInternalKey: a.from(k)
+    });
+  }
+  for (const s of e.outs)
+    r.addOutput({
+      script: s.script,
+      value: s.value
+    });
+  return r.toHex();
+}
+export {
+  G as B,
+  Z as D,
+  Pt as F,
+  j as L,
+  dt as M,
+  ht as P,
+  xt as S,
+  gt as T,
+  J as W,
+  vt as a,
+  wt as b,
+  ft as c,
+  bt as d,
+  mt as e,
+  St as f,
+  Et as g,
+  Tt as h,
+  It as i,
+  Ht as j,
+  et as k,
+  Q as l,
+  Y as m,
+  d as n,
+  pt as o,
+  at as p,
+  ut as q,
+  $ as r,
+  h as s,
+  D as t,
+  x as u,
+  lt as v,
+  yt as w,
+  R as x,
+  kt as y,
+  V as z
+};
+//# sourceMappingURL=challengeAssert-ZXE00zkT.js.map