pmxt-core 2.20.1 → 2.20.3

package/dist/exchanges/kalshi/fetcher.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KalshiFetcher = void 0;
+const errors_1 = require("./errors");
+const validation_1 = require("../../utils/validation");
+const utils_1 = require("./utils");
+// ----------------------------------------------------------------------------
+// Fetcher
+// ----------------------------------------------------------------------------
+const BATCH_SIZE = 200;
+const MAX_PAGES = 1000;
+const CACHE_TTL = 5 * 60 * 1000;
+class KalshiFetcher {
+    ctx;
+    // Instance-level cache (moved from module-level)
+    cachedEvents = null;
+    cachedSeriesMap = null;
+    lastCacheTime = 0;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    resetCache() {
+        this.cachedEvents = null;
+        this.cachedSeriesMap = null;
+        this.lastCacheTime = 0;
+    }
+    // -- Markets (returns raw events containing nested markets) ----------------
+    async fetchRawMarkets(params) {
+        try {
+            if (params?.marketId) {
+                return this.fetchRawEventByTicker(params.marketId);
+            }
+            if (params?.slug) {
+                return this.fetchRawEventByTicker(params.slug);
+            }
+            if (params?.outcomeId) {
+                const ticker = params.outcomeId.replace(/-NO$/, '');
+                return this.fetchRawEventByTicker(ticker);
+            }
+            if (params?.eventId) {
+                return this.fetchRawEventByTicker(params.eventId);
+            }
+            // Default + query cases: fetch all events, caller does filtering
+            return this.fetchRawEventsDefault(params);
+        }
+        catch (error) {
+            throw errors_1.kalshiErrorMapper.mapError(error);
+        }
+    }
+    // -- Events ---------------------------------------------------------------
+    async fetchRawEvents(params) {
+        try {
+            if (params.eventId) {
+                return this.fetchRawEventByTicker(params.eventId);
+            }
+            if (params.slug) {
+                return this.fetchRawEventByTicker(params.slug);
+            }
+            const status = params?.status || 'active';
+            if (status === 'all') {
+                const [openEvents, closedEvents, settledEvents] = await Promise.all([
+                    this.fetchAllWithStatus('open'),
+                    this.fetchAllWithStatus('closed'),
+                    this.fetchAllWithStatus('settled'),
+                ]);
+                return [...openEvents, ...closedEvents, ...settledEvents];
+            }
+            else if (status === 'closed' || status === 'inactive') {
+                const [closedEvents, settledEvents] = await Promise.all([
+                    this.fetchAllWithStatus('closed'),
+                    this.fetchAllWithStatus('settled'),
+                ]);
+                return [...closedEvents, ...settledEvents];
+            }
+            return this.fetchAllWithStatus('open');
+        }
+        catch (error) {
+            throw errors_1.kalshiErrorMapper.mapError(error);
+        }
+    }
+    // -- OHLCV ----------------------------------------------------------------
+    async fetchRawOHLCV(id, params) {
+        (0, validation_1.validateIdFormat)(id, 'OHLCV');
+        if (!params.resolution) {
+            throw new Error('fetchOHLCV requires a resolution parameter.');
+        }
+        try {
+            const cleanedId = id.replace(/-NO$/, '');
+            const normalizedId = cleanedId.toUpperCase();
+            const interval = (0, utils_1.mapIntervalToKalshi)(params.resolution);
+            const parts = normalizedId.split('-');
+            if (parts.length < 2) {
+                throw new Error(`Invalid Kalshi Ticker format: "${id}". Expected format like "FED-25JAN29-B4.75".`);
+            }
+            const seriesTicker = parts.slice(0, -1).join('-');
+            const now = Math.floor(Date.now() / 1000);
+            let startTs = now - 24 * 60 * 60;
+            let endTs = now;
+            const ensureDate = (d) => {
+                if (typeof d === 'string') {
+                    if (!d.endsWith('Z') && !d.match(/[+-]\d{2}:\d{2}$/)) {
+                        return new Date(d + 'Z');
+                    }
+                    return new Date(d);
+                }
+                return d;
+            };
+            const pStart = params.start ? ensureDate(params.start) : undefined;
+            const pEnd = params.end ? ensureDate(params.end) : undefined;
+            if (pStart)
+                startTs = Math.floor(pStart.getTime() / 1000);
+            if (pEnd) {
+                endTs = Math.floor(pEnd.getTime() / 1000);
+                if (!pStart)
+                    startTs = endTs - 24 * 60 * 60;
+            }
+            const data = await this.ctx.callApi('GetMarketCandlesticks', {
+                series_ticker: seriesTicker,
+                ticker: normalizedId,
+                period_interval: interval,
+                start_ts: startTs,
+                end_ts: endTs,
+            });
+            return data.candlesticks || [];
+        }
+        catch (error) {
+            throw errors_1.kalshiErrorMapper.mapError(error);
+        }
+    }
+    // -- OrderBook -------------------------------------------------------------
+    async fetchRawOrderBook(id) {
+        (0, validation_1.validateIdFormat)(id, 'OrderBook');
+        const ticker = id.replace(/-NO$/, '');
+        const data = await this.ctx.callApi('GetMarketOrderbook', { ticker });
+        return data;
+    }
+    // -- Trades ----------------------------------------------------------------
+    async fetchRawTrades(id, params) {
+        const ticker = id.replace(/-NO$/, '');
+        const data = await this.ctx.callApi('GetTrades', {
+            ticker,
+            limit: params.limit || 100,
+        });
+        return data.trades || [];
+    }
+    // -- User data -------------------------------------------------------------
+    async fetchRawMyTrades(params) {
+        const queryParams = {};
+        if (params?.outcomeId || params?.marketId) {
+            queryParams.ticker = (params.outcomeId || params.marketId).replace(/-NO$/, '');
+        }
+        if (params?.since)
+            queryParams.min_ts = Math.floor(params.since.getTime() / 1000);
+        if (params?.until)
+            queryParams.max_ts = Math.floor(params.until.getTime() / 1000);
+        if (params?.limit)
+            queryParams.limit = params.limit;
+        if (params?.cursor)
+            queryParams.cursor = params.cursor;
+        const data = await this.ctx.callApi('GetFills', queryParams);
+        return data.fills || [];
+    }
+    async fetchRawPositions() {
+        const data = await this.ctx.callApi('GetPositions');
+        return data.market_positions || [];
+    }
+    async fetchRawBalance() {
+        return this.ctx.callApi('GetBalance');
+    }
+    async fetchRawOrders(queryParams) {
+        const data = await this.ctx.callApi('GetOrders', queryParams);
+        return data.orders || [];
+    }
+    async fetchRawHistoricalOrders(queryParams) {
+        const data = await this.ctx.callApi('GetHistoricalOrders', queryParams);
+        return data.orders || [];
+    }
+    async fetchRawSeriesMap() {
+        try {
+            const data = await this.ctx.callApi('GetSeriesList');
+            const seriesList = data.series || [];
+            const map = new Map();
+            for (const series of seriesList) {
+                if (series.tags && series.tags.length > 0) {
+                    map.set(series.ticker, series.tags);
+                }
+            }
+            return map;
+        }
+        catch (e) {
+            throw errors_1.kalshiErrorMapper.mapError(e);
+        }
+    }
+    // -- Private helpers -------------------------------------------------------
+    async fetchRawEventByTicker(eventTicker) {
+        const normalizedTicker = eventTicker.toUpperCase();
+        const data = await this.ctx.callApi('GetEvent', {
+            event_ticker: normalizedTicker,
+            with_nested_markets: true,
+        });
+        const event = data.event;
+        if (!event)
+            return [];
+        // Enrich with series tags
+        if (event.series_ticker) {
+            try {
+                const seriesData = await this.ctx.callApi('GetSeries', {
+                    series_ticker: event.series_ticker,
+                });
+                const series = seriesData.series;
+                if (series?.tags?.length > 0 && (!event.tags || event.tags.length === 0)) {
+                    event.tags = series.tags;
+                }
+            }
+            catch {
+                // Non-critical
+            }
+        }
+        return [event];
+    }
+    async fetchRawEventsDefault(params) {
+        const limit = params?.limit || 250000;
+        const now = Date.now();
+        const status = params?.status || 'active';
+        let apiStatus = 'open';
+        if (status === 'closed' || status === 'inactive')
+            apiStatus = 'closed';
+        const useCache = status === 'active' || !params?.status;
+        if (useCache && this.cachedEvents && this.cachedSeriesMap && now - this.lastCacheTime < CACHE_TTL) {
+            return this.cachedEvents;
+        }
+        const isSorted = params?.sort && (params.sort === 'volume' || params.sort === 'liquidity');
+        const fetchLimit = isSorted ? 1000 : limit;
+        const [allEvents, fetchedSeriesMap] = await Promise.all([
+            this.fetchActiveEvents(fetchLimit, apiStatus),
+            this.fetchRawSeriesMap(),
+        ]);
+        // Enrich events with series tags
+        for (const event of allEvents) {
+            if (event.series_ticker && fetchedSeriesMap.has(event.series_ticker)) {
+                if (!event.tags || event.tags.length === 0) {
+                    event.tags = fetchedSeriesMap.get(event.series_ticker);
+                }
+            }
+        }
+        if (fetchLimit >= 1000 && useCache) {
+            this.cachedEvents = allEvents;
+            this.cachedSeriesMap = fetchedSeriesMap;
+            this.lastCacheTime = now;
+        }
+        return allEvents;
+    }
+    async fetchActiveEvents(targetMarketCount, status = 'open') {
+        let allEvents = [];
+        let totalMarketCount = 0;
+        let cursor = null;
+        let page = 0;
+        do {
+            try {
+                const queryParams = {
+                    limit: BATCH_SIZE,
+                    with_nested_markets: true,
+                    status,
+                };
+                if (cursor)
+                    queryParams.cursor = cursor;
+                const data = await this.ctx.callApi('GetEvents', queryParams);
+                const events = data.events || [];
+                if (events.length === 0)
+                    break;
+                allEvents = allEvents.concat(events);
+                if (targetMarketCount) {
+                    for (const event of events) {
+                        totalMarketCount += (event.markets || []).length;
+                    }
+                    if (totalMarketCount >= targetMarketCount * 1.5)
+                        break;
+                }
+                cursor = data.cursor;
+                page++;
+                if (!targetMarketCount && page >= 10)
+                    break;
+            }
+            catch (e) {
+                throw errors_1.kalshiErrorMapper.mapError(e);
+            }
+        } while (cursor && page < MAX_PAGES);
+        return allEvents;
+    }
+    async fetchAllWithStatus(apiStatus) {
+        let allEvents = [];
+        let cursor = null;
+        let page = 0;
+        do {
+            const queryParams = {
+                limit: BATCH_SIZE,
+                with_nested_markets: true,
+                status: apiStatus,
+            };
+            if (cursor)
+                queryParams.cursor = cursor;
+            const data = await this.ctx.callApi('GetEvents', queryParams);
+            const events = data.events || [];
+            if (events.length === 0)
+                break;
+            allEvents = allEvents.concat(events);
+            cursor = data.cursor;
+            page++;
+        } while (cursor && page < MAX_PAGES);
+        return allEvents;
+    }
+}
+exports.KalshiFetcher = KalshiFetcher;

package/dist/exchanges/kalshi/index.d.ts

@@ -36,6 +36,8 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     private auth?;
     private wsConfig?;
     private config;
+    private readonly fetcher;
+    private readonly normalizer;
     constructor(options?: ExchangeCredentials | KalshiExchangeOptions);
     get name(): string;
     protected sign(method: string, path: string, _params: Record<string, any>): Record<string, string>;
@@ -47,18 +49,16 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     fetchOrderBook(id: string): Promise<OrderBook>;
     fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
     fetchBalance(): Promise<Balance[]>;
+    fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
+    fetchPositions(): Promise<Position[]>;
+    fetchClosedOrders(params?: OrderHistoryParams): Promise<Order[]>;
+    fetchAllOrders(params?: OrderHistoryParams): Promise<Order[]>;
     buildOrder(params: CreateOrderParams): Promise<BuiltOrder>;
     submitOrder(built: BuiltOrder): Promise<Order>;
     createOrder(params: CreateOrderParams): Promise<Order>;
     cancelOrder(orderId: string): Promise<Order>;
     fetchOrder(orderId: string): Promise<Order>;
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
-    fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
-    fetchClosedOrders(params?: OrderHistoryParams): Promise<Order[]>;
-    fetchAllOrders(params?: OrderHistoryParams): Promise<Order[]>;
-    fetchPositions(): Promise<Position[]>;
-    private mapKalshiOrder;
-    private mapKalshiOrderStatus;
     private ws?;
     watchOrderBook(id: string, limit?: number): Promise<OrderBook>;
     watchTrades(id: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;