@agenticmail/enterprise 0.5.442 → 0.5.443

package/dist/chunk-E5H64U5H.js

@@ -0,0 +1,472 @@
+// src/polymarket-engines/shared.ts
+var CLOB_API = "https://clob.polymarket.com";
+var GAMMA_API = "https://gamma-api.polymarket.com";
+var DATA_API = "https://data-api.polymarket.com";
+var POLYGON_RPC = "https://polygon-bor-rpc.publicnode.com";
+var CTF_ADDRESS = "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045";
+var USDC_ADDRESS = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+var responseCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_ENTRIES = 500;
+function getCached(key, ttlMs) {
+  const entry = responseCache.get(key);
+  if (entry && Date.now() - entry.ts < ttlMs) return entry.data;
+  if (entry) responseCache.delete(key);
+  return null;
+}
+function setCache(key, data) {
+  if (responseCache.size > MAX_CACHE_ENTRIES) {
+    const oldest = responseCache.keys().next().value;
+    if (oldest) responseCache.delete(oldest);
+  }
+  responseCache.set(key, { data, ts: Date.now() });
+}
+var rateLimits = /* @__PURE__ */ new Map();
+var DOMAIN_LIMITS = {
+  "clob.polymarket.com": 80,
+  "gamma-api.polymarket.com": 60,
+  "data-api.polymarket.com": 60
+};
+function checkRateLimit(domain, maxPerMinute = 30) {
+  const now = Date.now();
+  const limit = DOMAIN_LIMITS[domain] || maxPerMinute;
+  const times = rateLimits.get(domain) || [];
+  const recent = times.filter((t) => now - t < 6e4);
+  if (recent.length >= limit) return false;
+  recent.push(now);
+  rateLimits.set(domain, recent);
+  return true;
+}
+var _proxyFetchHook = null;
+function setProxyFetchHook(hook) {
+  _proxyFetchHook = hook;
+}
+async function apiFetch(url, timeoutMs = 1e4) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const fetchOpts = { signal: ctrl.signal, headers: { Accept: "application/json" } };
+    const isClobApi = url.includes("clob.polymarket.com");
+    const res = isClobApi && _proxyFetchHook ? await _proxyFetchHook(url, fetchOpts) : await fetch(url, fetchOpts);
+    if (!res.ok) throw new Error(`API ${res.status}: ${await res.text().catch(() => res.statusText)}`);
+    const ct = res.headers.get("content-type") || "";
+    return ct.includes("json") ? res.json() : res.text();
+  } finally {
+    clearTimeout(t);
+  }
+}
+async function cachedFetchJSON(url, ttlMs = 3e4, timeoutMs = 1e4) {
+  const cached = getCached(url, ttlMs);
+  if (cached !== null) return cached;
+  const domain = new URL(url).hostname;
+  if (!checkRateLimit(domain)) throw new Error(`Rate limited: ${domain}`);
+  const data = await apiFetch(url, timeoutMs);
+  setCache(url, data);
+  return data;
+}
+async function cachedFetchText(url, ttlMs = 6e4, timeoutMs = 1e4) {
+  const cacheKey = "txt:" + url;
+  const cached = getCached(cacheKey, ttlMs);
+  if (cached !== null) return cached;
+  const domain = new URL(url).hostname;
+  if (!checkRateLimit(domain)) throw new Error(`Rate limited: ${domain}`);
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, { signal: ctrl.signal, headers: { "User-Agent": "PolymarketBot/1.0" } });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const text = await res.text();
+    setCache(cacheKey, text);
+    return text;
+  } finally {
+    clearTimeout(t);
+  }
+}
+async function parallelFetch(items, fn, concurrency = 5) {
+  const results = [];
+  for (let i = 0; i < items.length; i += concurrency) {
+    const batch = items.slice(i, i + concurrency);
+    const batchResults = await Promise.allSettled(batch.map(fn));
+    for (const r of batchResults) {
+      if (r.status === "fulfilled") results.push(r.value);
+    }
+  }
+  return results;
+}
+function normalCDF(x) {
+  const a1 = 0.254829592, a2 = -0.284496736, a3 = 1.421413741;
+  const a4 = -1.453152027, a5 = 1.061405429, p = 0.3275911;
+  const sign = x < 0 ? -1 : 1;
+  x = Math.abs(x) / Math.SQRT2;
+  const t = 1 / (1 + p * x);
+  const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-x * x);
+  return 0.5 * (1 + sign * y);
+}
+function normalPDF(x) {
+  return Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI);
+}
+function normalInv(p) {
+  if (p <= 0) return -Infinity;
+  if (p >= 1) return Infinity;
+  if (p === 0.5) return 0;
+  const a = [
+    -39.69683028665376,
+    220.9460984245205,
+    -275.9285104469687,
+    138.357751867269,
+    -30.66479806614716,
+    2.506628277459239
+  ];
+  const b = [
+    -54.47609879822406,
+    161.5858368580409,
+    -155.6989798598866,
+    66.80131188771972,
+    -13.28068155288572
+  ];
+  const c = [
+    -0.007784894002430293,
+    -0.3223964580411365,
+    -2.400758277161838,
+    -2.549732539343734,
+    4.374664141464968,
+    2.938163982698783
+  ];
+  const d = [0.007784695709041462, 0.3224671290700398, 2.445134137142996, 3.754408661907416];
+  const pLow = 0.02425, pHigh = 1 - pLow;
+  let q, r;
+  if (p < pLow) {
+    q = Math.sqrt(-2 * Math.log(p));
+    return (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+  } else if (p <= pHigh) {
+    q = p - 0.5;
+    r = q * q;
+    return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);
+  } else {
+    q = Math.sqrt(-2 * Math.log(1 - p));
+    return -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+  }
+}
+function linearRegression(xs, ys) {
+  const n = xs.length;
+  let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += xs[i];
+    sumY += ys[i];
+    sumXY += xs[i] * ys[i];
+    sumX2 += xs[i] * xs[i];
+  }
+  const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
+  const intercept = (sumY - slope * sumX) / n;
+  const ssRes = ys.reduce((s, y, i) => s + Math.pow(y - (slope * xs[i] + intercept), 2), 0);
+  const ssTot = ys.reduce((s, y) => s + Math.pow(y - sumY / n, 2), 0);
+  const r2 = ssTot > 0 ? 1 - ssRes / ssTot : 0;
+  return { slope, intercept, r2 };
+}
+function ewma(data, span) {
+  const alpha = 2 / (span + 1);
+  const result = [data[0]];
+  for (let i = 1; i < data.length; i++) {
+    result.push(alpha * data[i] + (1 - alpha) * result[i - 1]);
+  }
+  return result;
+}
+function sma(data, window) {
+  const result = [];
+  for (let i = 0; i < data.length; i++) {
+    if (i < window - 1) {
+      result.push(NaN);
+      continue;
+    }
+    let sum = 0;
+    for (let j = i - window + 1; j <= i; j++) sum += data[j];
+    result.push(sum / window);
+  }
+  return result;
+}
+function std(data) {
+  const n = data.length;
+  if (n < 2) return 0;
+  const mean = data.reduce((s, v) => s + v, 0) / n;
+  const variance = data.reduce((s, v) => s + Math.pow(v - mean, 2), 0) / (n - 1);
+  return Math.sqrt(variance);
+}
+function pearsonCorrelation(x, y) {
+  const n = Math.min(x.length, y.length);
+  if (n < 5) return 0;
+  const xs = x.slice(-n), ys = y.slice(-n);
+  const mx = xs.reduce((s, v) => s + v, 0) / n;
+  const my = ys.reduce((s, v) => s + v, 0) / n;
+  let num = 0, dx = 0, dy = 0;
+  for (let i = 0; i < n; i++) {
+    const a = xs[i] - mx, b = ys[i] - my;
+    num += a * b;
+    dx += a * a;
+    dy += b * b;
+  }
+  const denom = Math.sqrt(dx * dy);
+  return denom > 0 ? parseFloat((num / denom).toFixed(4)) : 0;
+}
+function calculateHurst(prices) {
+  if (prices.length < 20) return 0.5;
+  const returns = prices.slice(1).map((p, i) => Math.log(p / prices[i]));
+  const n = returns.length;
+  const mean = returns.reduce((s, r) => s + r, 0) / n;
+  const deviations = returns.map((r) => r - mean);
+  const cumDev = [];
+  let sum = 0;
+  for (const d of deviations) {
+    sum += d;
+    cumDev.push(sum);
+  }
+  const R = Math.max(...cumDev) - Math.min(...cumDev);
+  const S = Math.sqrt(deviations.reduce((s, d) => s + d * d, 0) / n);
+  if (S === 0) return 0.5;
+  const RS = R / S;
+  const H = Math.log(RS) / Math.log(n);
+  return parseFloat(Math.max(0, Math.min(1, H)).toFixed(4));
+}
+function calculateVolatility(prices) {
+  if (prices.length < 2) return 0;
+  const returns = prices.slice(1).map((p, i) => Math.log(p / prices[i]));
+  const mean = returns.reduce((s, r) => s + r, 0) / returns.length;
+  const variance = returns.reduce((s, r) => s + (r - mean) ** 2, 0) / returns.length;
+  return parseFloat(Math.sqrt(variance * 252).toFixed(4));
+}
+function parseMarket(m) {
+  const prices = (() => {
+    try {
+      return JSON.parse(m.outcomePrices || "[]").map(Number);
+    } catch {
+      return [0.5, 0.5];
+    }
+  })();
+  const outcomes = (() => {
+    try {
+      return JSON.parse(m.outcomes || "[]");
+    } catch {
+      return ["Yes", "No"];
+    }
+  })();
+  const tokens = (() => {
+    try {
+      return JSON.parse(m.clobTokenIds || "[]");
+    } catch {
+      return [];
+    }
+  })();
+  return {
+    id: m.conditionId || m.id,
+    question: m.question || "",
+    slug: m.slug || "",
+    category: m.tags?.[0] || m.category || "unknown",
+    outcomes,
+    outcomePrices: prices,
+    clobTokenIds: tokens,
+    volume: parseFloat(m.volume || "0"),
+    liquidity: parseFloat(m.liquidity || "0"),
+    endDate: m.endDate || null,
+    active: m.active !== false,
+    negRisk: !!m.negRisk,
+    tickSize: m.minimumTickSize || "0.01",
+    description: m.description,
+    startDate: m.startDate
+  };
+}
+async function fetchPriceSeries(tokenId, limit = 200) {
+  try {
+    const trades = await apiFetch(`${CLOB_API}/trades?asset_id=${tokenId}&limit=${limit}`);
+    if (!Array.isArray(trades) || trades.length === 0) return [];
+    return trades.reverse().map((t) => parseFloat(t.price || "0")).filter((p) => p > 0);
+  } catch {
+    return [];
+  }
+}
+var priceHistoryCache = /* @__PURE__ */ new Map();
+async function fetchPriceHistory(tokenId) {
+  const cached = priceHistoryCache.get(tokenId);
+  if (cached && Date.now() - cached.ts < 5 * 6e4) return cached.data;
+  try {
+    const data = await cachedFetchJSON(`${CLOB_API}/prices-history?market=${tokenId}&interval=1h&fidelity=60`);
+    const prices = (data?.history || []).map((p) => parseFloat(p.p || p.price || "0")).filter((p) => p > 0);
+    priceHistoryCache.set(tokenId, { data: prices, ts: Date.now() });
+    return prices;
+  } catch {
+    return [];
+  }
+}
+function parseRSSItems(xml) {
+  const items = [];
+  const itemRegex = /<item>([\s\S]*?)<\/item>/g;
+  let match;
+  while ((match = itemRegex.exec(xml)) !== null) {
+    const get = (tag) => {
+      const m = match[1].match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`));
+      return m ? m[1].replace(/<!\[CDATA\[|\]\]>/g, "").trim() : "";
+    };
+    items.push({
+      title: get("title"),
+      link: get("link"),
+      pubDate: get("pubDate"),
+      description: get("description").replace(/<[^>]+>/g, "").slice(0, 300),
+      source: get("source")
+    });
+  }
+  return items;
+}
+var POSITIVE_WORDS = {
+  "bullish": 3,
+  "surge": 3,
+  "rally": 3,
+  "soar": 3,
+  "winning": 2,
+  "gain": 2,
+  "positive": 2,
+  "strong": 2,
+  "confident": 2,
+  "optimistic": 3,
+  "breakthrough": 3,
+  "success": 2,
+  "support": 1,
+  "lead": 2,
+  "ahead": 2,
+  "up": 1,
+  "rise": 2,
+  "good": 1,
+  "great": 2,
+  "excellent": 3,
+  "profit": 2,
+  "growth": 2,
+  "boom": 3,
+  "likely": 2,
+  "certain": 3,
+  "confirmed": 3,
+  "approved": 2,
+  "passed": 2,
+  "win": 2,
+  "victory": 3,
+  "dominate": 2,
+  "crush": 2,
+  "landslide": 3,
+  "definitely": 2,
+  "absolutely": 2,
+  "obvious": 2,
+  "clearly": 2,
+  "guaranteed": 3,
+  "huge": 2,
+  "massive": 2,
+  "pump": 2,
+  "lock": 2,
+  "locked": 2,
+  "moon": 3,
+  "yes": 1,
+  "agree": 1,
+  "amazing": 2,
+  "love": 2
+};
+var NEGATIVE_WORDS = {
+  "bearish": -3,
+  "crash": -3,
+  "plunge": -3,
+  "collapse": -3,
+  "losing": -2,
+  "negative": -2,
+  "weak": -2,
+  "fear": -2,
+  "pessimistic": -3,
+  "failure": -3,
+  "risk": -1,
+  "down": -1,
+  "fall": -2,
+  "decline": -2,
+  "drop": -2,
+  "loss": -2,
+  "bad": -1,
+  "terrible": -3,
+  "crisis": -3,
+  "panic": -3,
+  "dump": -3,
+  "unlikely": -2,
+  "doubt": -2,
+  "uncertain": -1,
+  "rejected": -2,
+  "failed": -3,
+  "lose": -2,
+  "defeat": -3,
+  "scandal": -3,
+  "fraud": -3,
+  "manipulation": -3,
+  "no": -1,
+  "impossible": -3,
+  "never": -3,
+  "scam": -3,
+  "rug": -3,
+  "fake": -3,
+  "wrong": -2,
+  "fail": -3,
+  "short": -1,
+  "hate": -2,
+  "disagree": -2,
+  "risky": -2,
+  "behind": -1
+};
+function scoreSentiment(text) {
+  const words = text.toLowerCase().split(/\s+/);
+  let score = 0;
+  for (const w of words) {
+    const clean = w.replace(/[^a-z]/g, "");
+    if (POSITIVE_WORDS[clean]) score += POSITIVE_WORDS[clean];
+    if (NEGATIVE_WORDS[clean]) score += NEGATIVE_WORDS[clean];
+  }
+  return Math.max(-1, Math.min(1, score / Math.max(words.length * 0.1, 1)));
+}
+function extractTopics(text) {
+  const patterns = [
+    /\b(trump|biden|harris|election|vote|poll)\b/gi,
+    /\b(fed|rate|inflation|gdp|jobs|unemployment)\b/gi,
+    /\b(bitcoin|btc|eth|crypto|solana)\b/gi,
+    /\b(war|conflict|peace|treaty|sanctions)\b/gi,
+    /\b(ai|openai|google|microsoft|apple|nvidia)\b/gi,
+    /\b(polymarket|prediction|odds|probability)\b/gi
+  ];
+  const topics = /* @__PURE__ */ new Set();
+  for (const p of patterns) {
+    const matches = text.match(p) || [];
+    for (const m of matches) topics.add(m.toLowerCase());
+  }
+  return Array.from(topics);
+}
+
+export {
+  CLOB_API,
+  GAMMA_API,
+  DATA_API,
+  POLYGON_RPC,
+  CTF_ADDRESS,
+  USDC_ADDRESS,
+  getCached,
+  setCache,
+  checkRateLimit,
+  setProxyFetchHook,
+  apiFetch,
+  cachedFetchJSON,
+  cachedFetchText,
+  parallelFetch,
+  normalCDF,
+  normalPDF,
+  normalInv,
+  linearRegression,
+  ewma,
+  sma,
+  std,
+  pearsonCorrelation,
+  calculateHurst,
+  calculateVolatility,
+  parseMarket,
+  fetchPriceSeries,
+  fetchPriceHistory,
+  parseRSSItems,
+  POSITIVE_WORDS,
+  NEGATIVE_WORDS,
+  scoreSentiment,
+  extractTopics
+};