pmxtjs 0.0.1 → 0.1.1

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.js

@@ -0,0 +1,318 @@
+"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";
+    }
+    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 = [];
+            for (const event of allEvents) {
+                const markets = event.markets || [];
+                for (const market of markets) {
+                    const unifiedMarket = this.mapMarketToUnified(event, market);
+                    if (unifiedMarket) {
+                        allMarkets.push(unifiedMarket);
+                    }
+                }
+            }
+            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') {
+                allMarkets.sort((a, b) => b.liquidity - a.liquidity);
+            }
+            return allMarkets.slice(0, limit);
+        }
+        catch (error) {
+            console.error("Error fetching Kalshi data:", error);
+            return [];
+        }
+    }
+    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 = {
+                    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_1.default.get(this.baseUrl, { params: queryParams });
+                const events = response.data.events || [];
+                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) {
+                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;
+    }
+    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) {
+            price = (market.yes_ask + market.yes_bid) / 200;
+        }
+        else if (market.yes_ask) {
+            price = market.yes_ask / 100;
+        }
+        // Extract candidate name
+        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 = [
+            {
+                id: 'yes',
+                label: candidateName || 'Yes',
+                price: price,
+                priceChange24h: priceChange
+            },
+            {
+                id: 'no',
+                label: candidateName ? `Not ${candidateName}` : 'No',
+                price: 1 - price,
+                priceChange24h: -priceChange // Inverse change for No? simplified assumption
+            }
+        ];
+        return {
+            id: market.ticker,
+            title: event.title,
+            description: event.sub_title || market.subtitle || "",
+            outcomes: outcomes,
+            resolutionDate: new Date(market.expiration_time),
+            volume24h: Number(market.volume_24h || market.volume || 0),
+            volume: Number(market.volume || 0),
+            liquidity: Number(market.liquidity || 0), // Kalshi 'liquidity' might need specific mapping if available, otherwise 0 to avoid conflation
+            openInterest: Number(market.open_interest || 0),
+            url: `https://kalshi.com/events/${event.event_ticker}`,
+            category: event.category,
+            tags: event.tags || []
+        };
+    }
+    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 limit = params?.limit || 20;
+            return filtered.slice(0, limit);
+        }
+        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) {
+        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_1.default.get(url, {
+                params: { with_nested_markets: true }
+            });
+            const event = response.data.event;
+            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) {
+            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.`);
+                }
+                const apiError = error.response.data?.error || error.response.data?.message || "Unknown API Error";
+                throw new Error(`Kalshi API Error (${error.response.status}): ${apiError}. Event Ticker: ${eventTicker}`);
+            }
+            console.error(`Unexpected error fetching Kalshi event ${eventTicker}:`, error);
+            throw error;
+        }
+    }
+    mapIntervalToKalshi(interval) {
+        const mapping = {
+            '1m': 1,
+            '5m': 1,
+            '15m': 1,
+            '1h': 60,
+            '6h': 60,
+            '1d': 1440
+        };
+        return mapping[interval];
+    }
+    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) {
+                throw new Error(`Invalid Kalshi Ticker format: "${id}". Expected format like "FED-25JAN29-B4.75".`);
+            }
+            const seriesTicker = parts.slice(0, -1).join('-');
+            const url = `https://api.elections.kalshi.com/trade-api/v2/series/${seriesTicker}/markets/${normalizedId}/candlesticks`;
+            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);
+            }
+            if (params.end) {
+                endTs = Math.floor(params.end.getTime() / 1000);
+                if (!params.start) {
+                    startTs = endTs - (24 * 60 * 60);
+                }
+            }
+            queryParams.start_ts = startTs;
+            queryParams.end_ts = endTs;
+            const response = await axios_1.default.get(url, { params: queryParams });
+            const candles = response.data.candlesticks || [];
+            const mappedCandles = candles.map((c) => ({
+                timestamp: c.end_period_ts * 1000,
+                open: (c.price.open || 0) / 100,
+                high: (c.price.high || 0) / 100,
+                low: (c.price.low || 0) / 100,
+                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) {
+            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}`);
+            }
+            console.error(`Unexpected error fetching Kalshi history for ${id}:`, error);
+            throw error;
+        }
+    }
+    async getOrderBook(id) {
+        try {
+            const url = `https://api.elections.kalshi.com/trade-api/v2/markets/${id}/orderbook`;
+            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) => ({
+                price: level[0] / 100,
+                size: level[1]
+            }));
+            const asks = (data.no || []).map((level) => ({
+                price: (100 - level[0]) / 100,
+                size: level[1]
+            }));
+            // Sort bids desc, asks asc
+            bids.sort((a, b) => b.price - a.price);
+            asks.sort((a, b) => a.price - b.price);
+            return { bids, asks, timestamp: Date.now() };
+        }
+        catch (error) {
+            console.error(`Error fetching Kalshi orderbook for ${id}:`, error);
+            return { bids: [], asks: [] };
+        }
+    }
+    async getTradeHistory(id, params) {
+        try {
+            const url = `https://api.elections.kalshi.com/trade-api/v2/markets/trades`;
+            const response = await axios_1.default.get(url, {
+                params: {
+                    ticker: id,
+                    limit: params.limit || 100
+                }
+            });
+            const trades = response.data.trades || [];
+            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) {
+            console.error(`Error fetching Kalshi trades for ${id}:`, error);
+            return [];
+        }
+    }
+}
+exports.KalshiExchange = KalshiExchange;

package/dist/exchanges/Polymarket.js

@@ -0,0 +1,420 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolymarketExchange = void 0;
+const axios_1 = __importDefault(require("axios"));
+const BaseExchange_1 = require("../BaseExchange");
+class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
+    constructor() {
+        super(...arguments);
+        // Utilizing the Gamma API for rich metadata and list view data
+        this.baseUrl = 'https://gamma-api.polymarket.com/events';
+        // CLOB API for orderbook, trades, and timeseries
+        this.clobUrl = 'https://clob.polymarket.com';
+    }
+    get name() {
+        return 'Polymarket';
+    }
+    async fetchMarkets(params) {
+        const limit = params?.limit || 200; // Higher default for better coverage
+        const offset = params?.offset || 0;
+        // Map generic sort params to Polymarket Gamma API params
+        let queryParams = {
+            active: 'true',
+            closed: 'false',
+            limit: limit,
+            offset: offset,
+        };
+        // Gamma API uses 'order' and 'ascending' for sorting
+        if (params?.sort === 'volume') {
+            queryParams.order = 'volume';
+            queryParams.ascending = 'false';
+        }
+        else if (params?.sort === 'newest') {
+            queryParams.order = 'startDate';
+            queryParams.ascending = 'false';
+        }
+        else if (params?.sort === 'liquidity') {
+            // queryParams.order = 'liquidity';
+        }
+        else {
+            // Default: do not send order param to avoid 422
+        }
+        try {
+            // Fetch active events from Gamma
+            const response = await axios_1.default.get(this.baseUrl, {
+                params: queryParams
+            });
+            const events = response.data;
+            const unifiedMarkets = [];
+            for (const event of events) {
+                // Each event is a container (e.g. "US Election"). 
+                // It contains specific "markets" (e.g. "Winner", "Pop Vote").
+                if (!event.markets)
+                    continue;
+                for (const market of event.markets) {
+                    const outcomes = [];
+                    // Polymarket Gamma often returns 'outcomes' and 'outcomePrices' as stringified JSON keys.
+                    let outcomeLabels = [];
+                    let outcomePrices = [];
+                    try {
+                        outcomeLabels = typeof market.outcomes === 'string' ? JSON.parse(market.outcomes) : (market.outcomes || []);
+                        outcomePrices = typeof market.outcomePrices === 'string' ? JSON.parse(market.outcomePrices) : (market.outcomePrices || []);
+                    }
+                    catch (e) {
+                        console.warn(`Failed to parse outcomes for market ${market.id}`, e);
+                    }
+                    // Extract CLOB token IDs for granular operations
+                    let clobTokenIds = [];
+                    try {
+                        clobTokenIds = typeof market.clobTokenIds === 'string' ? JSON.parse(market.clobTokenIds) : (market.clobTokenIds || []);
+                    }
+                    catch (e) {
+                        console.warn(`Failed to parse clobTokenIds for market ${market.id}`, e);
+                    }
+                    // Extract candidate/option name from market question for better outcome labels
+                    let candidateName = null;
+                    if (market.question && market.groupItemTitle) {
+                        candidateName = market.groupItemTitle;
+                    }
+                    if (outcomeLabels.length > 0) {
+                        outcomeLabels.forEach((label, index) => {
+                            const rawPrice = outcomePrices[index] || "0";
+                            // For Yes/No markets with specific candidates, use the candidate name
+                            let outcomeLabel = label;
+                            if (candidateName && label.toLowerCase() === 'yes') {
+                                outcomeLabel = candidateName;
+                            }
+                            else if (candidateName && label.toLowerCase() === 'no') {
+                                outcomeLabel = `Not ${candidateName}`;
+                            }
+                            // 24h Price Change
+                            // Polymarket API provides 'oneDayPriceChange' on the market object
+                            let priceChange = 0;
+                            if (index === 0 || label.toLowerCase() === 'yes' || (candidateName && label === candidateName)) {
+                                priceChange = Number(market.oneDayPriceChange || 0);
+                            }
+                            outcomes.push({
+                                id: String(index),
+                                label: outcomeLabel,
+                                price: parseFloat(rawPrice) || 0,
+                                priceChange24h: priceChange,
+                                metadata: {
+                                    clobTokenId: clobTokenIds[index]
+                                }
+                            });
+                        });
+                    }
+                    unifiedMarkets.push({
+                        id: market.id,
+                        title: market.question ? `${event.title} - ${market.question}` : event.title,
+                        description: market.description || event.description,
+                        outcomes: outcomes,
+                        resolutionDate: market.endDate ? new Date(market.endDate) : (market.end_date_iso ? new Date(market.end_date_iso) : new Date()),
+                        volume24h: Number(market.volume24hr || market.volume_24h || 0),
+                        volume: Number(market.volume || 0),
+                        liquidity: Number(market.liquidity || market.rewards?.liquidity || 0),
+                        openInterest: Number(market.openInterest || market.open_interest || 0),
+                        url: `https://polymarket.com/event/${event.slug}`,
+                        image: event.image || market.image || `https://polymarket.com/api/og?slug=${event.slug}`,
+                        category: event.category || event.tags?.[0]?.label,
+                        tags: event.tags?.map((t) => t.label) || []
+                    });
+                }
+            }
+            // Client-side Sort capability to ensure contract fulfillment
+            // Often API filters are "good effort" or apply to the 'event' but not the 'market'
+            if (params?.sort === 'volume') {
+                unifiedMarkets.sort((a, b) => b.volume24h - a.volume24h);
+            }
+            else if (params?.sort === 'newest') {
+                // unifiedMarkets.sort((a, b) => b.resolutionDate.getTime() - a.resolutionDate.getTime()); // Not quite 'newest'
+            }
+            else if (params?.sort === 'liquidity') {
+                unifiedMarkets.sort((a, b) => b.liquidity - a.liquidity);
+            }
+            else {
+                // Default volume sort
+                unifiedMarkets.sort((a, b) => b.volume24h - a.volume24h);
+            }
+            // Respect limit strictly after flattening 
+            return unifiedMarkets.slice(0, limit);
+        }
+        catch (error) {
+            console.error("Error fetching Polymarket data:", error);
+            return [];
+        }
+    }
+    async searchMarkets(query, params) {
+        // Polymarket Gamma API doesn't support native search
+        // Fetch a larger batch and filter client-side
+        const searchLimit = 100; // Fetch more markets to search through
+        try {
+            // Fetch markets with a higher limit
+            const markets = await this.fetchMarkets({
+                ...params,
+                limit: searchLimit
+            });
+            // Client-side text filtering
+            const lowerQuery = query.toLowerCase();
+            const filtered = markets.filter(market => market.title.toLowerCase().includes(lowerQuery) ||
+                market.description.toLowerCase().includes(lowerQuery));
+            // Apply limit to filtered results
+            const limit = params?.limit || 20;
+            return filtered.slice(0, limit);
+        }
+        catch (error) {
+            console.error("Error searching Polymarket data:", error);
+            return [];
+        }
+    }
+    /**
+     * 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")
+     */
+    async getMarketsBySlug(slug) {
+        try {
+            const response = await axios_1.default.get(this.baseUrl, {
+                params: { slug: slug }
+            });
+            const events = response.data;
+            if (!events || events.length === 0)
+                return [];
+            // We can reuse the logic from fetchMarkets if we extract it, 
+            // but for now I'll duplicate the extraction logic to keep it self-contained
+            // and avoid safe refactoring risks.
+            // Actually, fetchMarkets is built to work with the Gamma response structure.
+            // So we can manually map the response using the same logic.
+            const unifiedMarkets = [];
+            for (const event of events) {
+                if (!event.markets)
+                    continue;
+                for (const market of event.markets) {
+                    const outcomes = [];
+                    let outcomeLabels = [];
+                    let outcomePrices = [];
+                    let clobTokenIds = [];
+                    try {
+                        outcomeLabels = typeof market.outcomes === 'string' ? JSON.parse(market.outcomes) : (market.outcomes || []);
+                        outcomePrices = typeof market.outcomePrices === 'string' ? JSON.parse(market.outcomePrices) : (market.outcomePrices || []);
+                        clobTokenIds = typeof market.clobTokenIds === 'string' ? JSON.parse(market.clobTokenIds) : (market.clobTokenIds || []);
+                    }
+                    catch (e) {
+                        console.warn(`Parse error for market ${market.id}`, e);
+                    }
+                    let candidateName = market.groupItemTitle;
+                    if (!candidateName && market.question)
+                        candidateName = market.question;
+                    if (outcomeLabels.length > 0) {
+                        outcomeLabels.forEach((label, index) => {
+                            let outcomeLabel = label;
+                            // Clean up Yes/No labels if candidate name is available
+                            if (candidateName && label.toLowerCase() === 'yes')
+                                outcomeLabel = candidateName;
+                            else if (candidateName && label.toLowerCase() === 'no')
+                                outcomeLabel = `Not ${candidateName}`;
+                            // 24h Price Change Logic
+                            let priceChange = 0;
+                            if (index === 0 || label.toLowerCase() === 'yes' || (candidateName && label === candidateName)) {
+                                priceChange = Number(market.oneDayPriceChange || 0);
+                            }
+                            outcomes.push({
+                                id: String(index),
+                                label: outcomeLabel,
+                                price: parseFloat(outcomePrices[index] || "0") || 0,
+                                priceChange24h: priceChange,
+                                metadata: {
+                                    clobTokenId: clobTokenIds[index]
+                                }
+                            });
+                        });
+                    }
+                    unifiedMarkets.push({
+                        id: market.id,
+                        title: event.title,
+                        description: market.description || event.description,
+                        outcomes: outcomes,
+                        resolutionDate: market.endDate ? new Date(market.endDate) : new Date(),
+                        volume24h: Number(market.volume24hr || market.volume_24h || 0),
+                        volume: Number(market.volume || 0),
+                        liquidity: Number(market.liquidity || market.rewards?.liquidity || 0),
+                        openInterest: Number(market.openInterest || market.open_interest || 0),
+                        url: `https://polymarket.com/event/${event.slug}`,
+                        image: event.image || market.image,
+                        category: event.category || event.tags?.[0]?.label,
+                        tags: event.tags?.map((t) => t.label) || []
+                    });
+                }
+            }
+            return unifiedMarkets;
+        }
+        catch (error) {
+            console.error(`Error fetching Polymarket slug ${slug}:`, error);
+            return [];
+        }
+    }
+    /**
+     * Map our generic CandleInterval to Polymarket's fidelity (in minutes)
+     */
+    mapIntervalToFidelity(interval) {
+        const mapping = {
+            '1m': 1,
+            '5m': 5,
+            '15m': 15,
+            '1h': 60,
+            '6h': 360,
+            '1d': 1440
+        };
+        return mapping[interval];
+    }
+    /**
+     * Fetch historical price data (OHLCV candles) for a specific token.
+     * @param id - The CLOB token ID (e.g., outcome token ID)
+     */
+    async getMarketHistory(id, params) {
+        // ID Validation: Polymarket CLOB requires a Token ID (long numeric string) not a Market ID
+        if (id.length < 10 && /^\d+$/.test(id)) {
+            throw new Error(`Invalid ID for Polymarket history: "${id}". You provided a Market ID, but Polymarket's CLOB API requires a Token ID. Use outcome.metadata.clobTokenId instead.`);
+        }
+        try {
+            const fidelity = this.mapIntervalToFidelity(params.resolution);
+            const nowTs = Math.floor(Date.now() / 1000);
+            // 1. Smart Lookback Calculation
+            // If start/end not provided, calculate window based on limit * resolution
+            let startTs = params.start ? Math.floor(params.start.getTime() / 1000) : 0;
+            let endTs = params.end ? Math.floor(params.end.getTime() / 1000) : nowTs;
+            if (!params.start) {
+                // Default limit is usually 20 in the example, but safety margin is good.
+                // If limit is not set, we default to 100 candles.
+                const count = params.limit || 100;
+                // fidelity is in minutes. 
+                const durationSeconds = count * fidelity * 60;
+                startTs = endTs - durationSeconds;
+            }
+            const queryParams = {
+                market: id,
+                fidelity: fidelity,
+                startTs: startTs,
+                endTs: endTs
+            };
+            const response = await axios_1.default.get(`${this.clobUrl}/prices-history`, {
+                params: queryParams
+            });
+            const history = response.data.history || [];
+            // 2. Align Timestamps (Snap to Grid)
+            // Polymarket returns random tick timestamps (e.g. 1:00:21).
+            // We want to normalize this to the start of the bucket (1:00:00).
+            const resolutionMs = fidelity * 60 * 1000;
+            const candles = history.map((item) => {
+                const rawMs = item.t * 1000;
+                const snappedMs = Math.floor(rawMs / resolutionMs) * resolutionMs;
+                return {
+                    timestamp: snappedMs, // Aligned timestamp
+                    open: item.p,
+                    high: item.p,
+                    low: item.p,
+                    close: item.p,
+                    volume: undefined
+                };
+            });
+            // Apply limit if specified
+            if (params.limit && candles.length > params.limit) {
+                return candles.slice(-params.limit);
+            }
+            return candles;
+        }
+        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(`Polymarket History API Error (${error.response.status}): ${apiError}. Used ID: ${id}`);
+            }
+            console.error(`Unexpected error fetching Polymarket history for ${id}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Fetch the current order book for a specific token.
+     * @param id - The CLOB token ID
+     */
+    async getOrderBook(id) {
+        try {
+            const response = await axios_1.default.get(`${this.clobUrl}/book`, {
+                params: { token_id: id }
+            });
+            const data = response.data;
+            // Response format: { bids: [{price: "0.52", size: "100"}], asks: [...] }
+            const bids = (data.bids || []).map((level) => ({
+                price: parseFloat(level.price),
+                size: parseFloat(level.size)
+            })).sort((a, b) => b.price - a.price); // Sort Bids Descending (Best/Highest first)
+            const asks = (data.asks || []).map((level) => ({
+                price: parseFloat(level.price),
+                size: parseFloat(level.size)
+            })).sort((a, b) => a.price - b.price); // Sort Asks Ascending (Best/Lowest first)
+            return {
+                bids,
+                asks,
+                timestamp: data.timestamp ? new Date(data.timestamp).getTime() : Date.now()
+            };
+        }
+        catch (error) {
+            console.error(`Error fetching Polymarket orderbook for ${id}:`, error);
+            return { bids: [], asks: [] };
+        }
+    }
+    /**
+     * 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.
+     */
+    async getTradeHistory(id, params) {
+        // ID Validation
+        if (id.length < 10 && /^\d+$/.test(id)) {
+            throw new Error(`Invalid ID for Polymarket trades: "${id}". You provided a Market ID, but Polymarket's CLOB API requires a Token ID.`);
+        }
+        try {
+            const queryParams = {
+                market: id
+            };
+            // Add time filters if provided
+            if (params.start) {
+                queryParams.after = Math.floor(params.start.getTime() / 1000);
+            }
+            if (params.end) {
+                queryParams.before = Math.floor(params.end.getTime() / 1000);
+            }
+            const response = await axios_1.default.get(`${this.clobUrl}/trades`, {
+                params: queryParams
+            });
+            // Response is an array of trade objects
+            const trades = response.data || [];
+            const mappedTrades = trades.map((trade) => ({
+                id: trade.id || `${trade.timestamp}-${trade.price}`,
+                timestamp: trade.timestamp * 1000, // Convert to milliseconds
+                price: parseFloat(trade.price),
+                amount: parseFloat(trade.size || trade.amount || 0),
+                side: trade.side === 'BUY' ? 'buy' : trade.side === 'SELL' ? 'sell' : 'unknown'
+            }));
+            // Apply limit if specified
+            if (params.limit && mappedTrades.length > params.limit) {
+                return mappedTrades.slice(-params.limit); // Return most recent N trades
+            }
+            return mappedTrades;
+        }
+        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(`Polymarket Trades API Error (${error.response.status}): ${apiError}. Used ID: ${id}`);
+            }
+            console.error(`Unexpected error fetching Polymarket trades for ${id}:`, error);
+            throw error;
+        }
+    }
+}
+exports.PolymarketExchange = PolymarketExchange;

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./BaseExchange"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./exchanges/Polymarket"), exports);
+__exportStar(require("./exchanges/Kalshi"), exports);

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+// ----------------------------------------------------------------------------
+// Core Data Models
+// ----------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,23 +1,26 @@
 {
-    "name": "pmxtjs",
-    "version": "0.0.1",
-    "description": "The ccxt for Prediction Markets (Node.js bindings)",
-    "main": "index.js",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/samueltinnerholm/PMXT.git"
-    },
-    "keywords": [
-        "prediction-markets",
-        "trading",
-        "polymarket",
-        "kalshi",
-        "ccxt"
-    ],
-    "author": "PMXT Team",
-    "license": "MIT",
-    "bugs": {
-        "url": "https://github.com/samueltinnerholm/PMXT/issues"
-    },
-    "homepage": "https://github.com/samueltinnerholm/PMXT#readme"
+  "name": "pmxtjs",
+  "version": "0.1.1",
+  "description": "pmxt is a unified prediction market data API. The ccxt for prediction markets.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "directories": {
+    "example": "examples",
+    "test": "test"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest -c jest.config.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "axios": "^1.7.9",
+    "tsx": "^4.21.0"
+  }
 }

package/Cargo.toml

@@ -1,15 +0,0 @@
-[package]
-name = "pmxt-node"
-version = "0.0.1"
-edition = "2021"
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-napi = { version = "2.12", features = ["async"] }
-napi-derive = "2.12"
-pmxt-core = { path = "../../crates/core" }
-
-[build-dependencies]
-napi-build = "2.0"

package/README.md

@@ -1,47 +0,0 @@
-# PMXT: The ccxt for Prediction Markets
-
-PMXT is a unified endpoint for trading on prediction markets (Polymarket, Kalshi, etc.), written in Rust for performance with native bindings for Python and Node.js.
-
-## Architecture
-
-This project is organized as a Cargo Workspace:
-
-- **`crates/core`**: Defines the shared `Exchange` trait and data models (`Market`, `Order`, `Ticker`).
-- **`crates/polymarket`**: The implementation for Polymarket.
-- **`bindings/python`**: The native Python extension (using PyO3).
-
-## Development
-
-### Prerequisites
-
-- Rust (cargo)
-- Python 3.9+
-- `maturin` (for building Python bindings) -> `pip install maturin`
-
-### Building Python Bindings
-
-To build and install the python library into your current environment:
-
-```bash
-cd bindings/python
-maturin develop
-```
-
-### Usage (Python)
-
-```python
-import pmxt
-import asyncio
-
-async def main():
-    exchange = pmxt.Polymarket(api_key="your_key")
-    markets = await exchange.load_markets()
-    print(markets)
-
-asyncio.run(main())
-```
-
-## Contributing
-
-1. Implement `Exchange` trait for a new market in `crates/new_market`.
-2. Register it in `bindings/python/src/lib.rs`.

package/src/lib.rs

@@ -1,6 +0,0 @@
-use napi_derive::napi;
-
-#[napi]
-pub fn info() -> String {
-    "PMXT Node.js Bindings".to_string()
-}