@mostlyrightmd/markets 0.1.0-rc.7

package/dist/trades/index.mjs

@@ -0,0 +1,602 @@
+// src/trades/kalshi-client.ts
+import { fetchWithRetry } from "@mostlyrightmd/core";
+var KALSHI_API_BASE = "https://api.elections.kalshi.com/trade-api/v2";
+var DEFAULT_SLEEP_BETWEEN_MS = 100;
+var DEFAULT_USER_AGENT = "mostlyright-ts/0.2.0 (+https://github.com/helloiamvu/tradewinds)";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_TRADES_PAGE_LIMIT = 1e3;
+var DEFAULT_MAX_TRADES_PAGES = 1e4;
+async function sleep(ms, signal) {
+  if (ms <= 0) return;
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      cleanup();
+      reject(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    function cleanup() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
+    if (signal) {
+      if (signal.aborted) {
+        cleanup();
+        reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+        return;
+      }
+      signal.addEventListener("abort", onAbort);
+    }
+  });
+}
+function buildUrl(path, params) {
+  const url = new URL(`${KALSHI_API_BASE}${path}`);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0 || value === null) continue;
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+async function getJson(path, params, opts) {
+  const url = buildUrl(path, params);
+  const headers = {
+    "User-Agent": DEFAULT_USER_AGENT,
+    Accept: "application/json"
+  };
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  let resp;
+  if (opts.fetchFn !== void 0) {
+    const init = { method: "GET", headers };
+    if (opts.signal) init.signal = opts.signal;
+    resp = await opts.fetchFn(url, init);
+    if (!resp.ok) {
+      throw new Error(`kalshi GET ${url} failed: HTTP ${resp.status}`);
+    }
+  } else {
+    const retryOpts = {
+      method: "GET",
+      headers,
+      timeoutMs
+    };
+    if (opts.signal) retryOpts.signal = opts.signal;
+    resp = await fetchWithRetry(url, retryOpts);
+  }
+  const json = await resp.json();
+  const sleepMs = opts.sleepBetweenMs ?? DEFAULT_SLEEP_BETWEEN_MS;
+  if (sleepMs > 0) {
+    await sleep(sleepMs, opts.signal);
+  }
+  return json;
+}
+async function fetchCandlesticks(ticker, args, opts = {}) {
+  if (!ticker.includes("-")) {
+    throw new Error(
+      `kalshi ticker must contain '-' to derive series prefix; got ${JSON.stringify(ticker)}`
+    );
+  }
+  const series = ticker.split("-", 1)[0];
+  const path = `/series/${series}/markets/${ticker}/candlesticks`;
+  const payload = await getJson(
+    path,
+    {
+      start_ts: args.startTs,
+      end_ts: args.endTs,
+      period_interval: args.periodIntervalMinutes
+    },
+    opts
+  );
+  return payload?.candlesticks ?? [];
+}
+async function fetchTrades(ticker, args = {}, opts = {}) {
+  const limit = args.limit ?? DEFAULT_TRADES_PAGE_LIMIT;
+  const maxPages = args.maxPages ?? DEFAULT_MAX_TRADES_PAGES;
+  const out = [];
+  let cursor;
+  let pages = 0;
+  while (true) {
+    const params = {
+      ticker,
+      limit
+    };
+    if (args.minTs !== void 0) params.min_ts = args.minTs;
+    if (args.maxTs !== void 0) params.max_ts = args.maxTs;
+    if (cursor) params.cursor = cursor;
+    const payload = await getJson("/markets/trades", params, opts);
+    const trades = payload?.trades ?? [];
+    if (trades.length > 0) out.push(...trades);
+    cursor = payload?.cursor && payload.cursor.length > 0 ? payload.cursor : void 0;
+    pages += 1;
+    if (!cursor || trades.length === 0) break;
+    if (pages >= maxPages) {
+      throw new Error(
+        `kalshi fetchTrades(${ticker}) exceeded maxPages=${maxPages}; narrow the window or raise the cap`
+      );
+    }
+  }
+  return out;
+}
+async function fetchOrderbook(ticker, args = {}, opts = {}) {
+  const depth = args.depth ?? 50;
+  if (depth < 1 || depth > 1e3) {
+    throw new Error(`depth out of range [1, 1000]: ${depth}`);
+  }
+  const path = `/markets/${ticker}/orderbook`;
+  const payload = await getJson(path, { depth }, opts);
+  if (!payload || typeof payload !== "object") {
+    throw new Error(`kalshi orderbook for ${ticker}: bad payload`);
+  }
+  return payload;
+}
+
+// src/trades/types.ts
+var KALSHI_INTERVALS = ["1m", "1h", "1d"];
+
+// src/trades/kalshi.ts
+var SOURCE = "kalshi";
+var INTERVAL_TO_MINUTES = {
+  "1m": 1,
+  "1h": 60,
+  "1d": 1440
+};
+function validateDate(d, name) {
+  if (!(d instanceof Date) || Number.isNaN(d.getTime())) {
+    throw new TypeError(`${name} must be a valid Date; got ${String(d)}`);
+  }
+}
+function toIsoOrNull(epochSeconds) {
+  if (typeof epochSeconds === "number" && Number.isFinite(epochSeconds)) {
+    return new Date(epochSeconds * 1e3).toISOString();
+  }
+  return null;
+}
+function stringTsToIso(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return toIsoOrNull(value);
+  }
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    if (!Number.isNaN(parsed)) {
+      return new Date(parsed).toISOString();
+    }
+  }
+  return null;
+}
+function maybeNumber(v) {
+  if (v === null || v === void 0) return null;
+  const n = typeof v === "string" ? Number(v) : v;
+  return typeof n === "number" && Number.isFinite(n) ? n : null;
+}
+function maybeInt(v) {
+  const n = maybeNumber(v);
+  if (n === null) return null;
+  return Math.trunc(n);
+}
+function dollarsToCents(v) {
+  const n = maybeNumber(v);
+  if (n === null) return null;
+  return n * 100;
+}
+function fpStringToInt(v) {
+  const n = maybeNumber(v);
+  if (n === null) return null;
+  return Math.trunc(n);
+}
+function pickPrice(d, base) {
+  if (d === void 0) return null;
+  const dollarsKey = `${base}_dollars`;
+  if (Object.prototype.hasOwnProperty.call(d, dollarsKey)) {
+    return dollarsToCents(d[dollarsKey]);
+  }
+  return maybeNumber(d[base]);
+}
+function pickFp(d, base) {
+  if (d === void 0) return null;
+  const fpKey = `${base}_fp`;
+  if (Object.prototype.hasOwnProperty.call(d, fpKey)) {
+    return fpStringToInt(d[fpKey]);
+  }
+  return maybeInt(d[base]);
+}
+async function kalshiCandles(ticker, args, opts = {}) {
+  validateDate(args.from, "from");
+  validateDate(args.to, "to");
+  if (args.from.getTime() >= args.to.getTime()) {
+    throw new RangeError(
+      `from (${args.from.toISOString()}) must be < to (${args.to.toISOString()})`
+    );
+  }
+  if (!KALSHI_INTERVALS.includes(args.interval)) {
+    throw new RangeError(
+      `interval must be one of ${JSON.stringify([...KALSHI_INTERVALS])}; got ${JSON.stringify(args.interval)}`
+    );
+  }
+  const raw = await fetchCandlesticks(
+    ticker,
+    {
+      startTs: Math.trunc(args.from.getTime() / 1e3),
+      endTs: Math.trunc(args.to.getTime() / 1e3),
+      periodIntervalMinutes: INTERVAL_TO_MINUTES[args.interval]
+    },
+    opts
+  );
+  const rows = raw.map((c) => {
+    const priceObj = c.price;
+    const top = c;
+    return {
+      ts: toIsoOrNull(c.end_period_ts),
+      open: pickPrice(priceObj, "open"),
+      high: pickPrice(priceObj, "high"),
+      low: pickPrice(priceObj, "low"),
+      close: pickPrice(priceObj, "close"),
+      volume: pickFp(top, "volume"),
+      openInterest: pickFp(top, "open_interest"),
+      source: SOURCE
+    };
+  });
+  return Object.freeze({
+    rows: Object.freeze(rows),
+    source: SOURCE,
+    retrievedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ticker,
+    interval: args.interval
+  });
+}
+async function kalshiFills(ticker, args = {}, opts = {}) {
+  if (args.since !== void 0) validateDate(args.since, "since");
+  if (args.until !== void 0) validateDate(args.until, "until");
+  if (args.since !== void 0 && args.until !== void 0 && args.since.getTime() >= args.until.getTime()) {
+    throw new RangeError(
+      `since (${args.since.toISOString()}) must be < until (${args.until.toISOString()})`
+    );
+  }
+  const fetchArgs = {};
+  if (args.since) fetchArgs.minTs = Math.trunc(args.since.getTime() / 1e3);
+  if (args.until) fetchArgs.maxTs = Math.trunc(args.until.getTime() / 1e3);
+  if (args.maxPages !== void 0) fetchArgs.maxPages = args.maxPages;
+  const raw = await fetchTrades(ticker, fetchArgs, opts);
+  const rows = raw.map((t) => {
+    const obj = t;
+    const takerRaw = t.taker_outcome_side ?? t.taker_side;
+    const takerSide = takerRaw === "yes" || takerRaw === "no" ? takerRaw : null;
+    return {
+      tradeId: t.trade_id ?? null,
+      ts: stringTsToIso(t.created_time),
+      yesPrice: pickPrice(obj, "yes_price"),
+      noPrice: pickPrice(obj, "no_price"),
+      count: pickFp(obj, "count"),
+      takerSide,
+      source: SOURCE
+    };
+  });
+  return Object.freeze({
+    rows: Object.freeze(rows),
+    source: SOURCE,
+    retrievedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ticker
+  });
+}
+async function kalshiOrderbook(ticker, args = {}, opts = {}) {
+  const payload = await fetchOrderbook(ticker, args, opts);
+  let useFp;
+  let levelsBySide;
+  if (payload.orderbook_fp !== void 0) {
+    useFp = true;
+    levelsBySide = {
+      yes: payload.orderbook_fp.yes_dollars ?? [],
+      no: payload.orderbook_fp.no_dollars ?? []
+    };
+  } else {
+    useFp = false;
+    levelsBySide = {
+      yes: payload.orderbook?.yes ?? [],
+      no: payload.orderbook?.no ?? []
+    };
+  }
+  const rows = [];
+  for (const side of ["yes", "no"]) {
+    const levels = levelsBySide[side];
+    for (const level of levels) {
+      if (Array.isArray(level) && level.length >= 2) {
+        rows.push({
+          side,
+          price: useFp ? dollarsToCents(level[0]) : maybeNumber(level[0]),
+          size: useFp ? fpStringToInt(level[1]) : maybeInt(level[1]),
+          source: SOURCE
+        });
+      } else if (level !== null && typeof level === "object") {
+        const obj = level;
+        rows.push({
+          side,
+          price: useFp ? dollarsToCents(obj.price) : maybeNumber(obj.price),
+          size: useFp ? fpStringToInt(obj.size ?? obj.contracts) : maybeInt(obj.size ?? obj.contracts),
+          source: SOURCE
+        });
+      }
+    }
+  }
+  const snapshotAt = (/* @__PURE__ */ new Date()).toISOString();
+  return Object.freeze({
+    rows: Object.freeze(rows),
+    source: SOURCE,
+    retrievedAt: snapshotAt,
+    snapshotAt,
+    ticker
+  });
+}
+
+// src/trades/polymarket.ts
+import { fetchWithRetry as fetchWithRetry2 } from "@mostlyrightmd/core";
+var GAMMA_BASE = "https://gamma-api.polymarket.com";
+var CLOB_BASE = "https://clob.polymarket.com";
+var DEFAULT_USER_AGENT2 = "mostlyright-ts/0.2.0 (+https://github.com/helloiamvu/tradewinds)";
+var DEFAULT_SLEEP_BETWEEN_MS2 = 200;
+var SOURCE_SNAPSHOT = "polymarket.gamma";
+var SOURCE_HISTORY = "polymarket.clob";
+function validateDate2(d, name) {
+  if (!(d instanceof Date) || Number.isNaN(d.getTime())) {
+    throw new TypeError(`${name} must be a valid Date; got ${String(d)}`);
+  }
+}
+function maybeNumber2(v) {
+  if (v === null || v === void 0) return null;
+  const n = typeof v === "string" ? Number(v) : v;
+  return typeof n === "number" && Number.isFinite(n) ? n : null;
+}
+async function sleep2(ms, signal) {
+  if (ms <= 0) return;
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      cleanup();
+      reject(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    function cleanup() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
+    if (signal) {
+      if (signal.aborted) {
+        cleanup();
+        reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+        return;
+      }
+      signal.addEventListener("abort", onAbort);
+    }
+  });
+}
+function buildUrl2(baseUrl, path, params) {
+  const url = new URL(`${baseUrl}${path}`);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0 || value === null) continue;
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+async function getJson2(baseUrl, path, params, opts) {
+  const url = buildUrl2(baseUrl, path, params);
+  const headers = {
+    "User-Agent": DEFAULT_USER_AGENT2,
+    Accept: "application/json"
+  };
+  const timeoutMs = opts.timeoutMs ?? 3e4;
+  let resp;
+  if (opts.fetchFn !== void 0) {
+    const init = { method: "GET", headers };
+    if (opts.signal) init.signal = opts.signal;
+    resp = await opts.fetchFn(url, init);
+    if (!resp.ok) {
+      throw new Error(`polymarket GET ${url} failed: HTTP ${resp.status}`);
+    }
+  } else {
+    const retryOpts = {
+      method: "GET",
+      headers,
+      timeoutMs
+    };
+    if (opts.signal) retryOpts.signal = opts.signal;
+    resp = await fetchWithRetry2(url, retryOpts);
+  }
+  const json = await resp.json();
+  const sleepMs = opts.sleepBetweenMs ?? DEFAULT_SLEEP_BETWEEN_MS2;
+  if (sleepMs > 0) {
+    await sleep2(sleepMs, opts.signal);
+  }
+  return json;
+}
+function coerceStringList(v) {
+  if (v === null || v === void 0) return [];
+  if (Array.isArray(v)) return v.map((x) => String(x));
+  if (typeof v === "string") {
+    try {
+      const parsed = JSON.parse(v);
+      if (Array.isArray(parsed)) return parsed.map((x) => String(x));
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+async function polymarketHistory(tokenId, args, opts = {}) {
+  if (typeof tokenId !== "string" || tokenId.length === 0) {
+    throw new TypeError(`tokenId must be a non-empty string; got ${JSON.stringify(tokenId)}`);
+  }
+  validateDate2(args.from, "from");
+  validateDate2(args.to, "to");
+  if (args.from.getTime() >= args.to.getTime()) {
+    throw new RangeError(
+      `from (${args.from.toISOString()}) must be < to (${args.to.toISOString()})`
+    );
+  }
+  const fidelity = args.fidelityMinutes ?? 60;
+  if (fidelity < 1 || !Number.isInteger(fidelity)) {
+    throw new RangeError(`fidelityMinutes must be a positive integer; got ${fidelity}`);
+  }
+  const payload = await getJson2(
+    CLOB_BASE,
+    "/prices-history",
+    {
+      market: tokenId,
+      startTs: Math.trunc(args.from.getTime() / 1e3),
+      endTs: Math.trunc(args.to.getTime() / 1e3),
+      fidelity
+    },
+    opts
+  );
+  let points;
+  if (Array.isArray(payload)) {
+    points = payload;
+  } else if (payload !== null && typeof payload === "object") {
+    points = payload.history ?? [];
+  } else {
+    points = [];
+  }
+  const rows = [];
+  for (const p of points) {
+    if (p === null || typeof p !== "object") continue;
+    const tsEpoch = p.t;
+    const ts = typeof tsEpoch === "number" && Number.isFinite(tsEpoch) ? new Date(tsEpoch * 1e3).toISOString() : null;
+    rows.push({
+      ts,
+      price: maybeNumber2(p.p ?? p.price),
+      volume: maybeNumber2(p.v ?? p.volume),
+      source: SOURCE_HISTORY
+    });
+  }
+  return Object.freeze({
+    rows: Object.freeze(rows),
+    source: SOURCE_HISTORY,
+    retrievedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    tokenId,
+    fidelityMinutes: fidelity
+  });
+}
+async function polymarketSnapshot(eventId, opts = {}) {
+  if (typeof eventId !== "string" || eventId.length === 0) {
+    throw new TypeError(`eventId must be a non-empty string; got ${JSON.stringify(eventId)}`);
+  }
+  const payload = await getJson2(
+    GAMMA_BASE,
+    `/events/${encodeURIComponent(eventId)}`,
+    void 0,
+    opts
+  );
+  if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error(
+      `polymarket snapshot: bad event payload for ${JSON.stringify(eventId)}; expected object`
+    );
+  }
+  const event = payload;
+  const markets = event.markets ?? [];
+  const rows = [];
+  for (const m of markets) {
+    if (m === null || typeof m !== "object") continue;
+    const outcomes = coerceStringList(m.outcomes);
+    const prices = coerceStringList(m.outcomePrices);
+    const volume = maybeNumber2(m.volume);
+    const liquidity = maybeNumber2(m.liquidity);
+    const marketIdStr = m.id !== void 0 && m.id !== null ? String(m.id) : null;
+    for (let i = 0; i < outcomes.length; i++) {
+      const priceStr = i < prices.length ? prices[i] : null;
+      rows.push({
+        marketId: marketIdStr,
+        outcome: outcomes[i] ?? "",
+        lastPrice: maybeNumber2(priceStr),
+        volume,
+        liquidity,
+        source: SOURCE_SNAPSHOT
+      });
+    }
+  }
+  const snapshotAt = (/* @__PURE__ */ new Date()).toISOString();
+  return Object.freeze({
+    rows: Object.freeze(rows),
+    source: SOURCE_SNAPSHOT,
+    retrievedAt: snapshotAt,
+    snapshotAt,
+    eventId
+  });
+}
+
+// src/trades/cache.ts
+var ISSUER_RE = /^[a-z][a-z0-9._-]{0,31}$/;
+var TICKER_RE = /^(?!\.+$)[A-Za-z0-9._-]{1,128}$/;
+function tradesCacheKey(args) {
+  if (typeof args.issuer !== "string" || !ISSUER_RE.test(args.issuer)) {
+    throw new RangeError(
+      `invalid issuer for cache key: ${JSON.stringify(args.issuer)}; must match ${ISSUER_RE}`
+    );
+  }
+  if (typeof args.ticker !== "string" || !TICKER_RE.test(args.ticker)) {
+    throw new RangeError(
+      `invalid ticker for cache key: ${JSON.stringify(args.ticker)}; must match ${TICKER_RE}`
+    );
+  }
+  if (!Number.isInteger(args.year) || args.year < 2e3 || args.year > 2100) {
+    throw new RangeError(`year out of range [2000, 2100]: ${args.year}`);
+  }
+  if (!Number.isInteger(args.month) || args.month < 1 || args.month > 12) {
+    throw new RangeError(`month out of range [1, 12]: ${args.month}`);
+  }
+  const mm = args.month.toString().padStart(2, "0");
+  return `trades/${args.issuer}/${args.ticker}/${args.year}-${mm}`;
+}
+function isCurrentUtcMonth(year, month, now = /* @__PURE__ */ new Date()) {
+  return year === now.getUTCFullYear() && month === now.getUTCMonth() + 1;
+}
+function isFutureUtcMonth(year, month, now = /* @__PURE__ */ new Date()) {
+  const yNow = now.getUTCFullYear();
+  const mNow = now.getUTCMonth() + 1;
+  return year > yNow || year === yNow && month > mNow;
+}
+async function readTradesCache(cache, args, opts = {}) {
+  if (isCurrentUtcMonth(args.year, args.month, opts.now) || isFutureUtcMonth(args.year, args.month, opts.now)) {
+    return null;
+  }
+  const key = tradesCacheKey(args);
+  const value = await cache.get(key);
+  return value ?? null;
+}
+async function writeTradesCache(cache, args, rows, opts = {}) {
+  if (isCurrentUtcMonth(args.year, args.month, opts.now) || isFutureUtcMonth(args.year, args.month, opts.now)) {
+    return false;
+  }
+  if (rows.length === 0) return false;
+  const key = tradesCacheKey(args);
+  await cache.set(key, rows);
+  return true;
+}
+async function invalidateTradesCache(cache, args) {
+  const key = tradesCacheKey(args);
+  const before = await cache.get(key);
+  if (before === null) return false;
+  await cache.delete(key);
+  return true;
+}
+export {
+  KALSHI_API_BASE,
+  KALSHI_INTERVALS,
+  fetchCandlesticks,
+  fetchOrderbook,
+  fetchTrades,
+  invalidateTradesCache,
+  isCurrentUtcMonth,
+  isFutureUtcMonth,
+  kalshiCandles,
+  kalshiFills,
+  kalshiOrderbook,
+  polymarketHistory,
+  polymarketSnapshot,
+  readTradesCache,
+  tradesCacheKey,
+  writeTradesCache
+};
+//# sourceMappingURL=index.mjs.map