@babylonlabs-io/ts-sdk 0.3.0 → 0.4.0

package/dist/challengeAssert-Dvcg38_y.js

@@ -0,0 +1,606 @@
+import { createPrePeginTransaction as R, buildPeginTxFromPrePegin as W, getPrePeginHtlcConnectorInfo as F, tapInternalPubkey as k, createPayoutConnector as K, getPeginPayoutScript as q, getAssertNoPayoutScriptInfo as N, getChallengeAssertScriptInfo as M } from "@babylonlabs-io/babylon-tbv-rust-wasm";
+import * as C from "bitcoinjs-lib";
+import { payments as b, networks as T, initEccLib as I, Transaction as y, Psbt as w } from "bitcoinjs-lib";
+import { Buffer as a } from "buffer";
+import * as H from "@bitcoin-js/tiny-secp256k1-asmjs";
+const ct = 58, ut = 43, at = 11, D = 546, z = BigInt(D), X = 30, Y = 2, lt = 1.1;
+function pt(t) {
+  return t <= Y ? X : 0;
+}
+const ft = 5;
+function h(t) {
+  return t.startsWith("0x") ? t.slice(2) : t;
+}
+function ht(t) {
+  return t.startsWith("0x") ? t : `0x${t}`;
+}
+function d(t) {
+  const n = h(t);
+  if (!A(n))
+    throw new Error(`Invalid hex string: ${t}`);
+  const e = new Uint8Array(n.length / 2);
+  for (let r = 0; r < n.length; r += 2)
+    e[r / 2] = parseInt(n.slice(r, r + 2), 16);
+  return e;
+}
+function x(t) {
+  return Array.from(t).map((n) => n.toString(16).padStart(2, "0")).join("");
+}
+function Q(t) {
+  return t.length === 32 ? t : t.slice(1, 33);
+}
+function A(t) {
+  return /^[0-9a-fA-F]*$/.test(t) && t.length % 2 === 0;
+}
+function _(t) {
+  const n = h(t);
+  if (!A(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(Q(e));
+}
+function dt(t) {
+  const n = h(t);
+  return A(n);
+}
+function gt(t, n) {
+  const e = _(t), r = n ?? e;
+  if (e.toLowerCase() !== r.toLowerCase())
+    throw new Error(
+      `Wallet public key does not match vault depositor. Expected: ${r}, Got: ${e}. Please connect the wallet that was used to create this vault.`
+    );
+  return { walletPubkeyRaw: t, walletPubkeyXOnly: e, depositorPubkey: r };
+}
+let U = !1;
+function G() {
+  U || (I(H), U = !0);
+}
+function O(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 Z(t, n) {
+  G();
+  const e = d(_(t)), { address: r } = b.p2tr({
+    internalPubkey: a.from(e),
+    network: O(n)
+  });
+  if (!r)
+    throw new Error("Failed to derive taproot address from public key");
+  return r;
+}
+function j(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: r } = b.p2wpkh({
+    pubkey: a.from(d(e)),
+    network: O(n)
+  });
+  if (!r)
+    throw new Error(
+      "Failed to derive native segwit address from public key"
+    );
+  return r;
+}
+function Pt(t, n, e) {
+  const r = h(n);
+  try {
+    if (t === Z(r, e))
+      return !0;
+  } catch {
+  }
+  const s = [];
+  r.length === 66 ? s.push(r) : r.length === 64 && s.push(`02${r}`, `03${r}`);
+  for (const o of s)
+    try {
+      if (t === j(o, e))
+        return !0;
+    } catch {
+    }
+  return !1;
+}
+function V(t) {
+  const e = t.substring(8, 12) === "0001" ? 12 : 8, r = parseInt(
+    t.substring(e, e + 2),
+    16
+  ), s = parseInt(
+    t.substring(e + 2, e + 4),
+    16
+  );
+  if (r !== 0)
+    throw new Error(`Expected 0 inputs from WASM, got ${r}`);
+  if (s === 0)
+    throw new Error("Expected at least 1 output from WASM, got 0");
+  const o = 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 < s; 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: o, locktime: u, outputs: c };
+}
+function yt(t) {
+  const { unfundedTxHex: n, selectedUTXOs: e, changeAddress: r, changeAmount: s, network: o } = t, { version: u, locktime: c, outputs: i } = V(n), p = new C.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 (s > z) {
+    const l = C.address.toOutputScript(r, o);
+    p.addOutput(l, Number(s));
+  }
+  return p.toHex();
+}
+async function xt(t) {
+  const n = await R({
+    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
+  }), r = V(n.txHex).outputs.reduce(
+    (s, o) => s + BigInt(o.value),
+    0n
+  );
+  return {
+    psbtHex: n.txHex,
+    totalOutputValue: r,
+    htlcValue: n.htlcValue,
+    htlcScriptPubKey: n.htlcScriptPubKey,
+    htlcAddress: n.htlcAddress,
+    peginAmount: n.peginAmount,
+    depositorClaimValue: n.depositorClaimValue
+  };
+}
+async function kt(t) {
+  const n = await W(
+    {
+      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 wt(t) {
+  const n = h(t.peginTxHex), e = h(t.fundedPrePeginTxHex), r = await F({
+    depositorPubkey: t.depositorPubkey,
+    vaultProviderPubkey: t.vaultProviderPubkey,
+    vaultKeeperPubkeys: t.vaultKeeperPubkeys,
+    universalChallengerPubkeys: t.universalChallengerPubkeys,
+    hashH: t.hashH,
+    timelockRefund: t.timelockRefund,
+    network: t.network
+  }), s = y.fromHex(n), o = y.fromHex(e);
+  if (s.ins.length !== 1)
+    throw new Error(
+      `PegIn transaction must have exactly 1 input, got ${s.ins.length}`
+    );
+  const u = s.ins[0], c = o.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 = o.outs[u.index];
+  if (!p)
+    throw new Error(
+      `Pre-PegIn output ${u.index} not found (Pre-PegIn has ${o.outs.length} outputs)`
+    );
+  const l = d(r.hashlockScript), f = d(r.hashlockControlBlock), g = new w();
+  g.setVersion(s.version), g.setLocktime(s.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 s.outs)
+    g.addOutput({
+      script: P.script,
+      value: P.value
+    });
+  return { psbtHex: g.toHex() };
+}
+function vt(t, n) {
+  const r = w.fromHex(t).data.inputs[0];
+  if (!r)
+    throw new Error("PegIn PSBT has no inputs");
+  if (r.tapScriptSig && r.tapScriptSig.length > 0) {
+    const s = a.from(
+      d(n)
+    );
+    for (const o of r.tapScriptSig)
+      if (o.pubkey.equals(s))
+        return J(o.signature);
+    throw new Error(
+      `No PegIn input signature found for depositor pubkey: ${n}`
+    );
+  }
+  throw r.finalScriptWitness && r.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 J(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 tt(t) {
+  const n = await K(
+    {
+      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
+  };
+}
+I(H);
+async function bt(t) {
+  const n = h(t.payoutTxHex), e = h(t.peginTxHex), r = h(t.assertTxHex), s = await tt({
+    depositor: t.depositorBtcPubkey,
+    vaultProvider: t.vaultProviderBtcPubkey,
+    vaultKeepers: t.vaultKeeperBtcPubkeys,
+    universalChallengers: t.universalChallengerBtcPubkeys,
+    timelockPegin: t.timelockPegin,
+    network: t.network
+  }), o = d(s.payoutScript), u = nt(k, o), c = y.fromHex(n), i = y.fromHex(e), p = y.fromHex(r), 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()
+  ), B = p.getId();
+  if (m !== B)
+    throw new Error(
+      `Input 1 does not reference assert transaction. Expected ${B}, 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(o),
+        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 $ of c.outs)
+    l.addOutput({
+      script: $.script,
+      value: $.value
+    });
+  return {
+    psbtHex: l.toHex()
+  };
+}
+function mt(t, n, e = 0) {
+  const r = w.fromHex(t);
+  if (e >= r.data.inputs.length)
+    throw new Error(
+      `Input index ${e} out of range (${r.data.inputs.length} inputs)`
+    );
+  const s = r.data.inputs[e];
+  if (s.tapScriptSig && s.tapScriptSig.length > 0) {
+    const o = d(n);
+    for (const u of s.tapScriptSig)
+      if (u.pubkey.equals(a.from(o)))
+        return L(u.signature, e);
+    throw new Error(
+      `No signature found for depositor pubkey: ${n} at input ${e}`
+    );
+  }
+  if (s.finalScriptWitness && s.finalScriptWitness.length > 0) {
+    const o = et(s.finalScriptWitness);
+    if (o.length >= 1)
+      return L(o[0], e);
+  }
+  throw new Error(
+    `No tapScriptSig or finalScriptWitness found in signed PSBT at input ${e}`
+  );
+}
+function L(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 et(t) {
+  const n = [];
+  let e = 0;
+  const r = () => {
+    const o = t[e++];
+    if (o < 253) return o;
+    if (o === 253) {
+      const u = t[e] | t[e + 1] << 8;
+      return e += 2, u;
+    }
+    if (o === 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;
+  }, s = r();
+  for (let o = 0; o < s; o++) {
+    const u = r();
+    n.push(t.subarray(e, e + u)), e += u;
+  }
+  return n;
+}
+function nt(t, n) {
+  const e = { output: a.from(n) }, s = b.p2tr({
+    internalPubkey: a.from(t),
+    scriptTree: e
+  }).pubkey;
+  if (!s)
+    throw new Error("Failed to compute output key");
+  const o = 192, u = s[0] === 3 ? 1 : 0, c = o | u, i = new Uint8Array(1 + t.length);
+  return i[0] = c, i.set(t, 1), i;
+}
+I(H);
+async function St(t) {
+  const n = h(t.payoutTxHex), e = y.fromHex(n), r = await q(t.connectorParams), s = d(r), o = rt(k, s), 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(s),
+        controlBlock: a.from(o)
+      }
+    ], 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) }, s = b.p2tr({
+    internalPubkey: a.from(t),
+    scriptTree: e
+  }).pubkey;
+  if (!s)
+    throw new Error("Failed to compute output key");
+  const o = 192, u = s[0] === 3 ? 1 : 0, c = o | u, i = new Uint8Array(1 + t.length);
+  return i[0] = c, i.set(t, 1), i;
+}
+async function Et(t) {
+  const n = h(t.noPayoutTxHex), e = y.fromHex(n), { noPayoutScript: r, noPayoutControlBlock: s } = await N(
+    t.connectorParams,
+    t.challengerPubkey
+  ), o = d(r), u = d(s), 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(o),
+        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 Tt(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 r = await Promise.all(
+    t.connectorParamsPerInput.map((o) => M(o))
+  ), s = new w();
+  s.setVersion(e.version), s.setLocktime(e.locktime);
+  for (let o = 0; o < e.ins.length; o++) {
+    const u = e.ins[o], c = t.prevouts[o];
+    if (!c)
+      throw new Error(`Missing prevout data for input ${o}`);
+    const { script: i, controlBlock: p } = r[o], l = d(i), f = d(p);
+    s.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 o of e.outs)
+    s.addOutput({
+      script: o.script,
+      value: o.value
+    });
+  return s.toHex();
+}
+export {
+  D as B,
+  z as D,
+  lt as F,
+  X as L,
+  ut as M,
+  ct as P,
+  ft as S,
+  at as T,
+  Y as W,
+  kt as a,
+  xt as b,
+  wt as c,
+  bt as d,
+  vt as e,
+  mt as f,
+  St as g,
+  Et as h,
+  Tt as i,
+  tt as j,
+  j as k,
+  Z as l,
+  d as m,
+  Pt as n,
+  dt as o,
+  ht as p,
+  _ as q,
+  pt as r,
+  h as s,
+  Q as t,
+  x as u,
+  gt as v,
+  V as w,
+  yt as x,
+  O as y
+};
+//# sourceMappingURL=challengeAssert-Dvcg38_y.js.map