pmxtjs 0.1.0 → 0.1.2

package/{src/BaseExchange.ts → dist/BaseExchange.d.ts}

@@ -1,57 +1,39 @@
 import { UnifiedMarket, PriceCandle, CandleInterval, OrderBook, Trade } from './types';
-
 export interface MarketFilterParams {
     limit?: number;
     offset?: number;
     sort?: 'volume' | 'liquidity' | 'newest';
 }
-
 export interface HistoryFilterParams {
     resolution: CandleInterval;
     start?: Date;
     end?: Date;
     limit?: number;
 }
-
-// ----------------------------------------------------------------------------
-// Base Exchange Class
-// ----------------------------------------------------------------------------
-
-export abstract class PredictionMarketExchange {
+export declare abstract class PredictionMarketExchange {
     abstract get name(): string;
-
     /**
      * Fetch all relevant markets from the source.
      */
     abstract fetchMarkets(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
-
     /**
      * Search for markets matching a keyword query.
      * Searches across title and description fields.
      */
     abstract searchMarkets(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]>;
-
     /**
      * Fetch historical price data for a specific market or outcome.
      * @param id - The market ID or specific outcome ID/Token ID depending on the exchange
      */
-    async getMarketHistory(id: string, params: HistoryFilterParams): Promise<PriceCandle[]> {
-        throw new Error("Method getMarketHistory not implemented.");
-    }
-
+    getMarketHistory(id: string, params: HistoryFilterParams): Promise<PriceCandle[]>;
     /**
      * Fetch the current order book (bids/asks) for a specific outcome.
      * Essential for calculating localized spread and depth.
      */
-    async getOrderBook(id: string): Promise<OrderBook> {
-        throw new Error("Method getOrderBook not implemented.");
-    }
-
+    getOrderBook(id: string): Promise<OrderBook>;
     /**
      * Fetch raw trade history.
      * Useful for generating synthetic OHLCV candles if the exchange doesn't provide them natively.
      */
-    async getTradeHistory(id: string, params: HistoryFilterParams): Promise<Trade[]> {
-        throw new Error("Method getTradeHistory not implemented.");
-    }
+    getTradeHistory(id: string, params: HistoryFilterParams): Promise<Trade[]>;
 }

package/dist/BaseExchange.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredictionMarketExchange = void 0;
+// ----------------------------------------------------------------------------
+// Base Exchange Class
+// ----------------------------------------------------------------------------
+class PredictionMarketExchange {
+    /**
+     * Fetch historical price data for a specific market or outcome.
+     * @param id - The market ID or specific outcome ID/Token ID depending on the exchange
+     */
+    async getMarketHistory(id, params) {
+        throw new Error("Method getMarketHistory not implemented.");
+    }
+    /**
+     * Fetch the current order book (bids/asks) for a specific outcome.
+     * Essential for calculating localized spread and depth.
+     */
+    async getOrderBook(id) {
+        throw new Error("Method getOrderBook not implemented.");
+    }
+    /**
+     * Fetch raw trade history.
+     * Useful for generating synthetic OHLCV candles if the exchange doesn't provide them natively.
+     */
+    async getTradeHistory(id, params) {
+        throw new Error("Method getTradeHistory not implemented.");
+    }
+}
+exports.PredictionMarketExchange = PredictionMarketExchange;

package/dist/exchanges/Kalshi.d.ts

@@ -0,0 +1,20 @@
+import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams } from '../BaseExchange';
+import { UnifiedMarket, PriceCandle, OrderBook, Trade } from '../types';
+export declare class KalshiExchange extends PredictionMarketExchange {
+    get name(): string;
+    private baseUrl;
+    fetchMarkets(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
+    private fetchActiveEvents;
+    private mapMarketToUnified;
+    searchMarkets(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]>;
+    /**
+     * Fetch specific markets by their event ticker.
+     * Useful for looking up a specific event from a URL.
+     * @param eventTicker - The event ticker (e.g. "FED-25JAN" or "PRES-2024")
+     */
+    getMarketsBySlug(eventTicker: string): Promise<UnifiedMarket[]>;
+    private mapIntervalToKalshi;
+    getMarketHistory(id: string, params: HistoryFilterParams): Promise<PriceCandle[]>;
+    getOrderBook(id: string): Promise<OrderBook>;
+    getTradeHistory(id: string, params: HistoryFilterParams): Promise<Trade[]>;
+}

package/{src/exchanges/Kalshi.ts → dist/exchanges/Kalshi.js}

@@ -1,24 +1,27 @@
-import axios from 'axios';
-import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams } from '../BaseExchange';
-import { UnifiedMarket, MarketOutcome, PriceCandle, CandleInterval, OrderBook, Trade } from '../types';
-
-export class KalshiExchange extends PredictionMarketExchange {
-    get name(): string {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KalshiExchange = void 0;
+const axios_1 = __importDefault(require("axios"));
+const BaseExchange_1 = require("../BaseExchange");
+class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
+    constructor() {
+        super(...arguments);
+        this.baseUrl = "https://api.elections.kalshi.com/trade-api/v2/events";
+    }
+    get name() {
         return "Kalshi";
     }
-    private baseUrl = "https://api.elections.kalshi.com/trade-api/v2/events";
-
-    async fetchMarkets(params?: MarketFilterParams): Promise<UnifiedMarket[]> {
+    async fetchMarkets(params) {
         const limit = params?.limit || 50;
-
         try {
             // Fetch active events with nested markets
             // For small limits, we can optimize by fetching fewer pages
             const allEvents = await this.fetchActiveEvents(limit);
-
             // Extract ALL markets from all events
-            const allMarkets: UnifiedMarket[] = [];
-
+            const allMarkets = [];
             for (const event of allEvents) {
                 const markets = event.markets || [];
                 for (const market of markets) {
@@ -28,112 +31,90 @@ export class KalshiExchange extends PredictionMarketExchange {
                     }
                 }
             }
-
-            console.log(`Extracted ${allMarkets.length} markets from ${allEvents.length} events.`);
-
             // Sort by 24h volume
             if (params?.sort === 'volume') {
                 allMarkets.sort((a, b) => b.volume24h - a.volume24h);
-            } else if (params?.sort === 'liquidity') {
+            }
+            else if (params?.sort === 'liquidity') {
                 allMarkets.sort((a, b) => b.liquidity - a.liquidity);
             }
-
             return allMarkets.slice(0, limit);
-
-        } catch (error) {
+        }
+        catch (error) {
             console.error("Error fetching Kalshi data:", error);
             return [];
         }
     }
-
-    private async fetchActiveEvents(targetMarketCount?: number): Promise<any[]> {
-        let allEvents: any[] = [];
+    async fetchActiveEvents(targetMarketCount) {
+        let allEvents = [];
         let totalMarketCount = 0;
         let cursor = null;
         let page = 0;
-
         // Note: Kalshi API uses cursor-based pagination which requires sequential fetching.
         // We cannot parallelize requests for a single list because we need the cursor from page N to fetch page N+1.
         // To optimize, we use the maximum allowed limit (200) and fetch until exhaustion.
-
         const MAX_PAGES = 1000; // Safety cap against infinite loops
         const BATCH_SIZE = 200; // Max limit per Kalshi API docs
-
         do {
             try {
                 // console.log(`Fetching Kalshi page ${page + 1}...`);
-                const queryParams: any = {
+                const queryParams = {
                     limit: BATCH_SIZE,
                     with_nested_markets: true,
                     status: 'open' // Filter to open markets to improve relevance and speed
                 };
-                if (cursor) queryParams.cursor = cursor;
-
-                const response = await axios.get(this.baseUrl, { params: queryParams });
+                if (cursor)
+                    queryParams.cursor = cursor;
+                const response = await axios_1.default.get(this.baseUrl, { params: queryParams });
                 const events = response.data.events || [];
-
-                if (events.length === 0) break;
-
+                if (events.length === 0)
+                    break;
                 allEvents = allEvents.concat(events);
-
                 // Count markets in this batch for early termination
                 if (targetMarketCount) {
                     for (const event of events) {
                         totalMarketCount += (event.markets || []).length;
                     }
-
                     // Early termination: if we have enough markets, stop fetching
-                    // Add a buffer (2x) to ensure we have enough after filtering/sorting
                     if (totalMarketCount >= targetMarketCount * 2) {
-                        console.log(`Early termination: collected ${totalMarketCount} markets (target: ${targetMarketCount})`);
                         break;
                     }
                 }
-
                 cursor = response.data.cursor;
                 page++;
-
-                // Log progress every few pages to avoid spam
-                if (page % 5 === 0) {
-                    console.log(`Fetched ${page} pages (${allEvents.length} events) from Kalshi...`);
-                }
-
-            } catch (e) {
+            }
+            catch (e) {
                 console.error(`Error fetching Kalshi page ${page}:`, e);
                 break;
             }
         } while (cursor && page < MAX_PAGES);
-
-        console.log(`Finished fetching Kalshi: ${allEvents.length} total events across ${page} pages.`);
         return allEvents;
     }
-
-    private mapMarketToUnified(event: any, market: any): UnifiedMarket | null {
-        if (!market) return null;
-
+    mapMarketToUnified(event, market) {
+        if (!market)
+            return null;
         // Calculate price
         let price = 0.5;
         if (market.last_price) {
             price = market.last_price / 100;
-        } else if (market.yes_ask && market.yes_bid) {
+        }
+        else if (market.yes_ask && market.yes_bid) {
             price = (market.yes_ask + market.yes_bid) / 200;
-        } else if (market.yes_ask) {
+        }
+        else if (market.yes_ask) {
             price = market.yes_ask / 100;
         }
-
         // Extract candidate name
-        let candidateName: string | null = null;
+        let candidateName = null;
         if (market.subtitle || market.yes_sub_title) {
             candidateName = market.subtitle || market.yes_sub_title;
         }
-
         // Calculate 24h change
         let priceChange = 0;
         if (market.previous_price_dollars !== undefined && market.last_price_dollars !== undefined) {
             priceChange = market.last_price_dollars - market.previous_price_dollars;
         }
-
-        const outcomes: MarketOutcome[] = [
+        const outcomes = [
             {
                 id: 'yes',
                 label: candidateName || 'Yes',
@@ -147,7 +128,6 @@ export class KalshiExchange extends PredictionMarketExchange {
                 priceChange24h: -priceChange // Inverse change for No? simplified assumption
             }
         ];
-
         return {
             id: market.ticker,
             title: event.title,
@@ -163,56 +143,50 @@ export class KalshiExchange extends PredictionMarketExchange {
             tags: event.tags || []
         };
     }
-
-    async searchMarkets(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]> {
+    async searchMarkets(query, params) {
         // We must fetch ALL markets to search them locally since we don't have server-side search
         const fetchLimit = 100000;
         try {
             const markets = await this.fetchMarkets({ ...params, limit: fetchLimit });
             const lowerQuery = query.toLowerCase();
-            const filtered = markets.filter(market =>
-                market.title.toLowerCase().includes(lowerQuery) ||
-                market.description.toLowerCase().includes(lowerQuery)
-            );
+            const filtered = markets.filter(market => market.title.toLowerCase().includes(lowerQuery) ||
+                market.description.toLowerCase().includes(lowerQuery));
             const limit = params?.limit || 20;
             return filtered.slice(0, limit);
-        } catch (error) {
+        }
+        catch (error) {
             console.error("Error searching Kalshi data:", error);
             return [];
         }
     }
-
     /**
      * Fetch specific markets by their event ticker.
      * Useful for looking up a specific event from a URL.
      * @param eventTicker - The event ticker (e.g. "FED-25JAN" or "PRES-2024")
      */
-    async getMarketsBySlug(eventTicker: string): Promise<UnifiedMarket[]> {
+    async getMarketsBySlug(eventTicker) {
         try {
             // Kalshi API expects uppercase tickers, but URLs use lowercase
             const normalizedTicker = eventTicker.toUpperCase();
             const url = `https://api.elections.kalshi.com/trade-api/v2/events/${normalizedTicker}`;
-            const response = await axios.get(url, {
+            const response = await axios_1.default.get(url, {
                 params: { with_nested_markets: true }
             });
-
             const event = response.data.event;
-            if (!event) return [];
-
-            const unifiedMarkets: UnifiedMarket[] = [];
+            if (!event)
+                return [];
+            const unifiedMarkets = [];
             const markets = event.markets || [];
-
             for (const market of markets) {
                 const unifiedMarket = this.mapMarketToUnified(event, market);
                 if (unifiedMarket) {
                     unifiedMarkets.push(unifiedMarket);
                 }
             }
-
             return unifiedMarkets;
-
-        } catch (error: any) {
-            if (axios.isAxiosError(error) && error.response) {
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error) && error.response) {
                 if (error.response.status === 404) {
                     throw new Error(`Kalshi event not found: "${eventTicker}". Check that the event ticker is correct.`);
                 }
@@ -223,9 +197,8 @@ export class KalshiExchange extends PredictionMarketExchange {
             throw error;
         }
     }
-
-    private mapIntervalToKalshi(interval: CandleInterval): number {
-        const mapping: Record<CandleInterval, number> = {
+    mapIntervalToKalshi(interval) {
+        const mapping = {
             '1m': 1,
             '5m': 1,
             '15m': 1,
@@ -235,13 +208,11 @@ export class KalshiExchange extends PredictionMarketExchange {
         };
         return mapping[interval];
     }
-
-    async getMarketHistory(id: string, params: HistoryFilterParams): Promise<PriceCandle[]> {
+    async getMarketHistory(id, params) {
         try {
             // Kalshi API expects uppercase tickers
             const normalizedId = id.toUpperCase();
             const interval = this.mapIntervalToKalshi(params.resolution);
-
             // Heuristic for series_ticker
             const parts = normalizedId.split('-');
             if (parts.length < 2) {
@@ -249,13 +220,10 @@ export class KalshiExchange extends PredictionMarketExchange {
             }
             const seriesTicker = parts.slice(0, -1).join('-');
             const url = `https://api.elections.kalshi.com/trade-api/v2/series/${seriesTicker}/markets/${normalizedId}/candlesticks`;
-
-            const queryParams: any = { period_interval: interval };
-
+            const queryParams = { period_interval: interval };
             const now = Math.floor(Date.now() / 1000);
             let startTs = now - (24 * 60 * 60);
             let endTs = now;
-
             if (params.start) {
                 startTs = Math.floor(params.start.getTime() / 1000);
             }
@@ -265,14 +233,11 @@ export class KalshiExchange extends PredictionMarketExchange {
                     startTs = endTs - (24 * 60 * 60);
                 }
             }
-
             queryParams.start_ts = startTs;
             queryParams.end_ts = endTs;
-
-            const response = await axios.get(url, { params: queryParams });
+            const response = await axios_1.default.get(url, { params: queryParams });
             const candles = response.data.candlesticks || [];
-
-            const mappedCandles: PriceCandle[] = candles.map((c: any) => ({
+            const mappedCandles = candles.map((c) => ({
                 timestamp: c.end_period_ts * 1000,
                 open: (c.price.open || 0) / 100,
                 high: (c.price.high || 0) / 100,
@@ -280,13 +245,13 @@ export class KalshiExchange extends PredictionMarketExchange {
                 close: (c.price.close || 0) / 100,
                 volume: c.volume
             }));
-
             if (params.limit && mappedCandles.length > params.limit) {
                 return mappedCandles.slice(-params.limit);
             }
             return mappedCandles;
-        } catch (error: any) {
-            if (axios.isAxiosError(error) && error.response) {
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error) && error.response) {
                 const apiError = error.response.data?.error || error.response.data?.message || "Unknown API Error";
                 throw new Error(`Kalshi History API Error (${error.response.status}): ${apiError}. Used Ticker: ${id}`);
             }
@@ -294,56 +259,52 @@ export class KalshiExchange extends PredictionMarketExchange {
             throw error;
         }
     }
-
-    async getOrderBook(id: string): Promise<OrderBook> {
+    async getOrderBook(id) {
         try {
             const url = `https://api.elections.kalshi.com/trade-api/v2/markets/${id}/orderbook`;
-            const response = await axios.get(url);
+            const response = await axios_1.default.get(url);
             const data = response.data.orderbook;
-
             // Structure: { yes: [[price, qty], ...], no: [[price, qty], ...] }
-            const bids = (data.yes || []).map((level: number[]) => ({
+            const bids = (data.yes || []).map((level) => ({
                 price: level[0] / 100,
                 size: level[1]
             }));
-
-            const asks = (data.no || []).map((level: number[]) => ({
+            const asks = (data.no || []).map((level) => ({
                 price: (100 - level[0]) / 100,
                 size: level[1]
             }));
-
             // Sort bids desc, asks asc
-            bids.sort((a: any, b: any) => b.price - a.price);
-            asks.sort((a: any, b: any) => a.price - b.price);
-
+            bids.sort((a, b) => b.price - a.price);
+            asks.sort((a, b) => a.price - b.price);
             return { bids, asks, timestamp: Date.now() };
-        } catch (error) {
+        }
+        catch (error) {
             console.error(`Error fetching Kalshi orderbook for ${id}:`, error);
             return { bids: [], asks: [] };
         }
     }
-
-    async getTradeHistory(id: string, params: HistoryFilterParams): Promise<Trade[]> {
+    async getTradeHistory(id, params) {
         try {
             const url = `https://api.elections.kalshi.com/trade-api/v2/markets/trades`;
-            const response = await axios.get(url, {
+            const response = await axios_1.default.get(url, {
                 params: {
                     ticker: id,
                     limit: params.limit || 100
                 }
             });
             const trades = response.data.trades || [];
-
-            return trades.map((t: any) => ({
+            return trades.map((t) => ({
                 id: t.trade_id,
                 timestamp: new Date(t.created_time).getTime(),
                 price: t.yes_price / 100,
                 amount: t.count,
                 side: t.taker_side === 'yes' ? 'buy' : 'sell'
             }));
-        } catch (error) {
+        }
+        catch (error) {
             console.error(`Error fetching Kalshi trades for ${id}:`, error);
             return [];
         }
     }
 }
+exports.KalshiExchange = KalshiExchange;

package/dist/exchanges/Polymarket.d.ts

@@ -0,0 +1,38 @@
+import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams } from '../BaseExchange';
+import { UnifiedMarket, PriceCandle, OrderBook, Trade } from '../types';
+export declare class PolymarketExchange extends PredictionMarketExchange {
+    get name(): string;
+    private readonly baseUrl;
+    private readonly clobUrl;
+    fetchMarkets(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
+    searchMarkets(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]>;
+    /**
+     * Fetch specific markets by their URL slug.
+     * Useful for looking up a specific event from a URL.
+     * @param slug - The event slug (e.g. "will-fed-cut-rates-in-march")
+     */
+    getMarketsBySlug(slug: string): Promise<UnifiedMarket[]>;
+    /**
+     * Map our generic CandleInterval to Polymarket's fidelity (in minutes)
+     */
+    private mapIntervalToFidelity;
+    /**
+     * Fetch historical price data (OHLCV candles) for a specific token.
+     * @param id - The CLOB token ID (e.g., outcome token ID)
+     */
+    getMarketHistory(id: string, params: HistoryFilterParams): Promise<PriceCandle[]>;
+    /**
+     * Fetch the current order book for a specific token.
+     * @param id - The CLOB token ID
+     */
+    getOrderBook(id: string): Promise<OrderBook>;
+    /**
+     * Fetch raw trade history for a specific token.
+     * @param id - The CLOB token ID
+     *
+     * NOTE: Polymarket's /trades endpoint currently requires L2 Authentication (API Key).
+     * This method will return an empty array if an API key is not provided in headers.
+     * Use getMarketHistory for public historical price data instead.
+     */
+    getTradeHistory(id: string, params: HistoryFilterParams): Promise<Trade[]>;
+}