@babylonlabs-io/ts-sdk 0.12.0 → 0.13.1

package/dist/challengeAssert-CenzzhZU.js

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