pmxt-core 1.0.4 → 1.1.0

package/dist/BaseExchange.d.ts

@@ -71,4 +71,50 @@ export declare abstract class PredictionMarketExchange {
      * Fetch account balances.
      */
     fetchBalance(): Promise<Balance[]>;
+    /**
+     * Watch orderbook updates in real-time via WebSocket.
+     * Returns a promise that resolves with the latest orderbook state.
+     * The orderbook is maintained internally with incremental updates.
+     *
+     * Usage (async iterator pattern):
+     * ```typescript
+     * while (true) {
+     *     const orderbook = await exchange.watchOrderBook(outcomeId);
+     *     console.log(orderbook);
+     * }
+     * ```
+     *
+     * @param id - The Outcome ID to watch
+     * @param limit - Optional limit for orderbook depth
+     * @returns Promise that resolves with the current orderbook state
+     */
+    watchOrderBook(id: string, limit?: number): Promise<OrderBook>;
+    /**
+     * Watch trade executions in real-time via WebSocket.
+     * Returns a promise that resolves with an array of recent trades.
+     *
+     * Usage (async iterator pattern):
+     * ```typescript
+     * while (true) {
+     *     const trades = await exchange.watchTrades(outcomeId);
+     *     console.log(trades);
+     * }
+     * ```
+     *
+     * @param id - The Outcome ID to watch
+     * @param since - Optional timestamp to filter trades from
+     * @param limit - Optional limit for number of trades
+     * @returns Promise that resolves with recent trades
+     */
+    watchTrades(id: string, since?: number, limit?: number): Promise<Trade[]>;
+    /**
+     * Close all WebSocket connections and clean up resources.
+     * Should be called when done with real-time data to prevent memory leaks.
+     *
+     * Usage:
+     * ```typescript
+     * await exchange.close();
+     * ```
+     */
+    close(): Promise<void>;
 }

package/dist/BaseExchange.js

@@ -68,5 +68,61 @@ class PredictionMarketExchange {
     async fetchBalance() {
         throw new Error("Method fetchBalance not implemented.");
     }
+    // ----------------------------------------------------------------------------
+    // WebSocket Streaming Methods
+    // ----------------------------------------------------------------------------
+    /**
+     * Watch orderbook updates in real-time via WebSocket.
+     * Returns a promise that resolves with the latest orderbook state.
+     * The orderbook is maintained internally with incremental updates.
+     *
+     * Usage (async iterator pattern):
+     * ```typescript
+     * while (true) {
+     *     const orderbook = await exchange.watchOrderBook(outcomeId);
+     *     console.log(orderbook);
+     * }
+     * ```
+     *
+     * @param id - The Outcome ID to watch
+     * @param limit - Optional limit for orderbook depth
+     * @returns Promise that resolves with the current orderbook state
+     */
+    async watchOrderBook(id, limit) {
+        throw new Error(`watchOrderBook() is not supported by ${this.name}`);
+    }
+    /**
+     * Watch trade executions in real-time via WebSocket.
+     * Returns a promise that resolves with an array of recent trades.
+     *
+     * Usage (async iterator pattern):
+     * ```typescript
+     * while (true) {
+     *     const trades = await exchange.watchTrades(outcomeId);
+     *     console.log(trades);
+     * }
+     * ```
+     *
+     * @param id - The Outcome ID to watch
+     * @param since - Optional timestamp to filter trades from
+     * @param limit - Optional limit for number of trades
+     * @returns Promise that resolves with recent trades
+     */
+    async watchTrades(id, since, limit) {
+        throw new Error(`watchTrades() is not supported by ${this.name}`);
+    }
+    /**
+     * Close all WebSocket connections and clean up resources.
+     * Should be called when done with real-time data to prevent memory leaks.
+     *
+     * Usage:
+     * ```typescript
+     * await exchange.close();
+     * ```
+     */
+    async close() {
+        // Default implementation: no-op
+        // Exchanges with WebSocket support should override this
+    }
 }
 exports.PredictionMarketExchange = PredictionMarketExchange;

package/dist/exchanges/kalshi/fetchOrderBook.js

@@ -7,19 +7,44 @@ exports.fetchOrderBook = fetchOrderBook;
 const axios_1 = __importDefault(require("axios"));
 async function fetchOrderBook(id) {
     try {
+        // Check if this is a NO outcome request
+        const isNoOutcome = id.endsWith('-NO');
         const ticker = id.replace(/-NO$/, '');
         const url = `https://api.elections.kalshi.com/trade-api/v2/markets/${ticker}/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]
-        }));
+        // Kalshi returns bids at their actual prices (not inverted)
+        // - yes: bids for buying YES at price X
+        // - no: bids for buying NO at price X
+        let bids;
+        let asks;
+        if (isNoOutcome) {
+            // NO outcome order book:
+            // - Bids: people buying NO (use data.no directly)
+            // - Asks: people selling NO = people buying YES (invert data.yes)
+            bids = (data.no || []).map((level) => ({
+                price: level[0] / 100,
+                size: level[1]
+            }));
+            asks = (data.yes || []).map((level) => ({
+                price: 1 - (level[0] / 100), // Invert YES price to get NO ask price
+                size: level[1]
+            }));
+        }
+        else {
+            // YES outcome order book:
+            // - Bids: people buying YES (use data.yes directly)
+            // - Asks: people selling YES = people buying NO (invert data.no)
+            bids = (data.yes || []).map((level) => ({
+                price: level[0] / 100,
+                size: level[1]
+            }));
+            asks = (data.no || []).map((level) => ({
+                price: 1 - (level[0] / 100), // Invert NO price to get YES ask price
+                size: level[1]
+            }));
+        }
         // Sort bids desc, asks asc
         bids.sort((a, b) => b.price - a.price);
         asks.sort((a, b) => a.price - b.price);

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

@@ -1,8 +1,15 @@
 import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, ExchangeCredentials } from '../../BaseExchange';
 import { UnifiedMarket, PriceCandle, OrderBook, Trade, Balance, Order, Position, CreateOrderParams } from '../../types';
+import { KalshiWebSocketConfig } from './websocket';
+export { KalshiWebSocketConfig };
+export interface KalshiExchangeOptions {
+    credentials?: ExchangeCredentials;
+    websocket?: KalshiWebSocketConfig;
+}
 export declare class KalshiExchange extends PredictionMarketExchange {
     private auth?;
-    constructor(credentials?: ExchangeCredentials);
+    private wsConfig?;
+    constructor(options?: ExchangeCredentials | KalshiExchangeOptions);
     get name(): string;
     private ensureAuth;
     fetchMarkets(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
@@ -18,4 +25,8 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
     fetchPositions(): Promise<Position[]>;
     private mapKalshiOrderStatus;
+    private ws?;
+    watchOrderBook(id: string, limit?: number): Promise<OrderBook>;
+    watchTrades(id: string, since?: number, limit?: number): Promise<Trade[]>;
+    close(): Promise<void>;
 }

package/dist/exchanges/kalshi/index.js

@@ -13,9 +13,23 @@ const fetchOHLCV_1 = require("./fetchOHLCV");
 const fetchOrderBook_1 = require("./fetchOrderBook");
 const fetchTrades_1 = require("./fetchTrades");
 const auth_1 = require("./auth");
+const websocket_1 = require("./websocket");
 class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
-    constructor(credentials) {
+    constructor(options) {
+        // Support both old signature (credentials only) and new signature (options object)
+        let credentials;
+        let wsConfig;
+        if (options && 'credentials' in options) {
+            // New signature: KalshiExchangeOptions
+            credentials = options.credentials;
+            wsConfig = options.websocket;
+        }
+        else {
+            // Old signature: ExchangeCredentials directly
+            credentials = options;
+        }
         super(credentials);
+        this.wsConfig = wsConfig;
         if (credentials?.apiKey && credentials?.privateKey) {
             this.auth = new auth_1.KalshiAuth(credentials);
         }
@@ -84,7 +98,6 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
                 }];
         }
         catch (error) {
-            console.error("Kalshi fetchBalance error:", error?.response?.data || error.message);
             throw error;
         }
     }
@@ -135,7 +148,6 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             };
         }
         catch (error) {
-            console.error("Kalshi createOrder error:", error?.response?.data || error.message);
             throw error;
         }
     }
@@ -161,7 +173,6 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             };
         }
         catch (error) {
-            console.error("Kalshi cancelOrder error:", error?.response?.data || error.message);
             throw error;
         }
     }
@@ -188,7 +199,6 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             };
         }
         catch (error) {
-            console.error("Kalshi fetchOrder error:", error?.response?.data || error.message);
             throw error;
         }
     }
@@ -221,7 +231,6 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             }));
         }
         catch (error) {
-            console.error("Kalshi fetchOpenOrders error:", error?.response?.data || error.message);
             return [];
         }
     }
@@ -250,7 +259,6 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             });
         }
         catch (error) {
-            console.error("Kalshi fetchPositions error:", error?.response?.data || error.message);
             return [];
         }
     }
@@ -269,5 +277,25 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
                 return 'open';
         }
     }
+    async watchOrderBook(id, limit) {
+        const auth = this.ensureAuth();
+        if (!this.ws) {
+            this.ws = new websocket_1.KalshiWebSocket(auth, this.wsConfig);
+        }
+        return this.ws.watchOrderBook(id);
+    }
+    async watchTrades(id, since, limit) {
+        const auth = this.ensureAuth();
+        if (!this.ws) {
+            this.ws = new websocket_1.KalshiWebSocket(auth, this.wsConfig);
+        }
+        return this.ws.watchTrades(id);
+    }
+    async close() {
+        if (this.ws) {
+            await this.ws.close();
+            this.ws = undefined;
+        }
+    }
 }
 exports.KalshiExchange = KalshiExchange;

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

@@ -0,0 +1,39 @@
+import { OrderBook, Trade } from '../../types';
+import { KalshiAuth } from './auth';
+export interface KalshiWebSocketConfig {
+    /** WebSocket URL (default: wss://api.elections.kalshi.com/trade-api/ws/v2) */
+    wsUrl?: string;
+    /** Reconnection interval in milliseconds (default: 5000) */
+    reconnectIntervalMs?: number;
+}
+/**
+ * Kalshi WebSocket implementation for real-time order book and trade streaming.
+ * Follows CCXT Pro-style async iterator pattern.
+ */
+export declare class KalshiWebSocket {
+    private ws?;
+    private auth;
+    private config;
+    private orderBookResolvers;
+    private tradeResolvers;
+    private orderBooks;
+    private subscribedTickers;
+    private messageIdCounter;
+    private isConnecting;
+    private isConnected;
+    private reconnectTimer?;
+    constructor(auth: KalshiAuth, config?: KalshiWebSocketConfig);
+    private connect;
+    private scheduleReconnect;
+    private subscribeToOrderbook;
+    private subscribeToTrades;
+    private handleMessage;
+    private handleOrderbookSnapshot;
+    private handleOrderbookDelta;
+    private applyDelta;
+    private handleTrade;
+    private resolveOrderBook;
+    watchOrderBook(ticker: string): Promise<OrderBook>;
+    watchTrades(ticker: string): Promise<Trade[]>;
+    close(): Promise<void>;
+}

package/dist/exchanges/kalshi/websocket.js

@@ -0,0 +1,316 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KalshiWebSocket = void 0;
+const ws_1 = __importDefault(require("ws"));
+/**
+ * Kalshi WebSocket implementation for real-time order book and trade streaming.
+ * Follows CCXT Pro-style async iterator pattern.
+ */
+class KalshiWebSocket {
+    constructor(auth, config = {}) {
+        this.orderBookResolvers = new Map();
+        this.tradeResolvers = new Map();
+        this.orderBooks = new Map();
+        this.subscribedTickers = new Set();
+        this.messageIdCounter = 1;
+        this.isConnecting = false;
+        this.isConnected = false;
+        this.auth = auth;
+        this.config = {
+            wsUrl: config.wsUrl || 'wss://api.elections.kalshi.com/trade-api/ws/v2',
+            reconnectIntervalMs: config.reconnectIntervalMs || 5000
+        };
+    }
+    async connect() {
+        if (this.isConnected || this.isConnecting) {
+            return;
+        }
+        this.isConnecting = true;
+        return new Promise((resolve, reject) => {
+            try {
+                // Extract path from URL for signature
+                const url = new URL(this.config.wsUrl);
+                const path = url.pathname;
+                console.log(`Kalshi WS: Connecting to ${this.config.wsUrl} (using path ${path} for signature)`);
+                // Get authentication headers
+                const headers = this.auth.getHeaders('GET', path);
+                this.ws = new ws_1.default(this.config.wsUrl, { headers });
+                this.ws.on('open', () => {
+                    this.isConnected = true;
+                    this.isConnecting = false;
+                    console.log('Kalshi WebSocket connected');
+                    // Resubscribe to all tickers if reconnecting
+                    if (this.subscribedTickers.size > 0) {
+                        this.subscribeToOrderbook(Array.from(this.subscribedTickers));
+                    }
+                    resolve();
+                });
+                this.ws.on('message', (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        this.handleMessage(message);
+                    }
+                    catch (error) {
+                        console.error('Error parsing Kalshi WebSocket message:', error);
+                    }
+                });
+                this.ws.on('error', (error) => {
+                    console.error('Kalshi WebSocket error:', error);
+                    this.isConnecting = false;
+                    reject(error);
+                });
+                this.ws.on('close', () => {
+                    console.log('Kalshi WebSocket closed');
+                    this.isConnected = false;
+                    this.isConnecting = false;
+                    this.scheduleReconnect();
+                });
+            }
+            catch (error) {
+                this.isConnecting = false;
+                reject(error);
+            }
+        });
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+        }
+        this.reconnectTimer = setTimeout(() => {
+            console.log('Attempting to reconnect Kalshi WebSocket...');
+            this.connect().catch(console.error);
+        }, this.config.reconnectIntervalMs);
+    }
+    subscribeToOrderbook(marketTickers) {
+        if (!this.ws || !this.isConnected) {
+            return;
+        }
+        const subscription = {
+            id: this.messageIdCounter++,
+            cmd: 'subscribe',
+            params: {
+                channels: ['orderbook_delta'],
+                market_tickers: marketTickers
+            }
+        };
+        this.ws.send(JSON.stringify(subscription));
+    }
+    subscribeToTrades(marketTickers) {
+        if (!this.ws || !this.isConnected) {
+            return;
+        }
+        const subscription = {
+            id: this.messageIdCounter++,
+            cmd: 'subscribe',
+            params: {
+                channels: ['trade'],
+                market_tickers: marketTickers
+            }
+        };
+        this.ws.send(JSON.stringify(subscription));
+    }
+    handleMessage(message) {
+        const msgType = message.type;
+        // Kalshi V2 uses 'data' field for payloads
+        const data = message.data || message.msg;
+        if (!data && msgType !== 'subscribed' && msgType !== 'pong') {
+            return;
+        }
+        // Add message-level timestamp as a fallback for handlers
+        if (data && typeof data === 'object' && !data.ts && !data.created_time) {
+            data.message_ts = message.ts || message.time;
+        }
+        switch (msgType) {
+            case 'orderbook_snapshot':
+                this.handleOrderbookSnapshot(data);
+                break;
+            case 'orderbook_delta':
+            case 'orderbook_update': // Some versions use update
+                this.handleOrderbookDelta(data);
+                break;
+            case 'trade':
+                this.handleTrade(data);
+                break;
+            case 'error':
+                console.error('Kalshi WebSocket error:', message.msg || message.error || message.data);
+                break;
+            case 'subscribed':
+                console.log('Kalshi subscription confirmed:', JSON.stringify(message));
+                break;
+            case 'pong':
+                // Ignore keep-alive
+                break;
+            default:
+                // Ignore unknown message types
+                break;
+        }
+    }
+    handleOrderbookSnapshot(data) {
+        const ticker = data.market_ticker;
+        // Kalshi orderbook structure:
+        // yes: [{ price: number (cents), quantity: number }, ...]
+        // no: [{ price: number (cents), quantity: number }, ...]
+        const bids = (data.yes || []).map((level) => {
+            const price = (level.price || level[0]) / 100;
+            const size = (level.quantity !== undefined ? level.quantity : (level.size !== undefined ? level.size : level[1])) || 0;
+            return { price, size };
+        }).sort((a, b) => b.price - a.price);
+        const asks = (data.no || []).map((level) => {
+            const price = (100 - (level.price || level[0])) / 100;
+            const size = (level.quantity !== undefined ? level.quantity : (level.size !== undefined ? level.size : level[1])) || 0;
+            return { price, size };
+        }).sort((a, b) => a.price - b.price);
+        const orderBook = {
+            bids,
+            asks,
+            timestamp: Date.now()
+        };
+        this.orderBooks.set(ticker, orderBook);
+        this.resolveOrderBook(ticker, orderBook);
+    }
+    handleOrderbookDelta(data) {
+        const ticker = data.market_ticker;
+        const existing = this.orderBooks.get(ticker);
+        if (!existing) {
+            // No snapshot yet, skip delta
+            return;
+        }
+        // Apply delta updates
+        // Kalshi sends: { price: number, delta: number, side: 'yes' | 'no' }
+        const price = (data.price) / 100;
+        const delta = data.delta !== undefined ? data.delta : (data.quantity !== undefined ? data.quantity : 0);
+        const side = data.side;
+        if (side === 'yes') {
+            this.applyDelta(existing.bids, price, delta, 'desc');
+        }
+        else {
+            const yesPrice = (100 - data.price) / 100;
+            this.applyDelta(existing.asks, yesPrice, delta, 'asc');
+        }
+        existing.timestamp = Date.now();
+        this.resolveOrderBook(ticker, existing);
+    }
+    applyDelta(levels, price, delta, sortOrder) {
+        const existingIndex = levels.findIndex(l => Math.abs(l.price - price) < 0.001);
+        if (delta === 0) {
+            // Remove level
+            if (existingIndex !== -1) {
+                levels.splice(existingIndex, 1);
+            }
+        }
+        else {
+            // Update or add level
+            if (existingIndex !== -1) {
+                levels[existingIndex].size += delta;
+                if (levels[existingIndex].size <= 0) {
+                    levels.splice(existingIndex, 1);
+                }
+            }
+            else {
+                levels.push({ price, size: delta });
+                // Re-sort
+                if (sortOrder === 'desc') {
+                    levels.sort((a, b) => b.price - a.price);
+                }
+                else {
+                    levels.sort((a, b) => a.price - b.price);
+                }
+            }
+        }
+    }
+    handleTrade(data) {
+        const ticker = data.market_ticker;
+        // Kalshi trade structure:
+        // { trade_id, market_ticker, yes_price, no_price, count, created_time, taker_side }
+        // The timestamp could be in created_time, created_at, or ts.
+        let timestamp = Date.now();
+        const rawTime = data.created_time || data.created_at || data.ts || data.time || data.message_ts;
+        if (rawTime) {
+            const parsed = new Date(rawTime).getTime();
+            if (!isNaN(parsed)) {
+                timestamp = parsed;
+                // If the timestamp is too small, it might be in seconds
+                if (timestamp < 10000000000) {
+                    timestamp *= 1000;
+                }
+            }
+            else if (typeof rawTime === 'number') {
+                // If it's already a number but new Date() failed (maybe it's a large timestamp)
+                timestamp = rawTime;
+                if (timestamp < 10000000000) {
+                    timestamp *= 1000;
+                }
+            }
+        }
+        const trade = {
+            id: data.trade_id || `${timestamp}-${Math.random()}`,
+            timestamp,
+            price: (data.yes_price || data.price) ? (data.yes_price || data.price) / 100 : 0.5,
+            amount: data.count || data.size || 0,
+            side: data.taker_side === 'yes' || data.side === 'buy' ? 'buy' : data.taker_side === 'no' || data.side === 'sell' ? 'sell' : 'unknown'
+        };
+        const resolvers = this.tradeResolvers.get(ticker);
+        if (resolvers && resolvers.length > 0) {
+            resolvers.forEach(r => r.resolve([trade]));
+            this.tradeResolvers.set(ticker, []);
+        }
+    }
+    resolveOrderBook(ticker, orderBook) {
+        const resolvers = this.orderBookResolvers.get(ticker);
+        if (resolvers && resolvers.length > 0) {
+            resolvers.forEach(r => r.resolve(orderBook));
+            this.orderBookResolvers.set(ticker, []);
+        }
+    }
+    async watchOrderBook(ticker) {
+        // Ensure connection
+        if (!this.isConnected) {
+            await this.connect();
+        }
+        // Subscribe if not already subscribed
+        if (!this.subscribedTickers.has(ticker)) {
+            this.subscribedTickers.add(ticker);
+            this.subscribeToOrderbook([ticker]);
+        }
+        // Return a promise that resolves on the next orderbook update
+        return new Promise((resolve, reject) => {
+            if (!this.orderBookResolvers.has(ticker)) {
+                this.orderBookResolvers.set(ticker, []);
+            }
+            this.orderBookResolvers.get(ticker).push({ resolve, reject });
+        });
+    }
+    async watchTrades(ticker) {
+        // Ensure connection
+        if (!this.isConnected) {
+            await this.connect();
+        }
+        // Subscribe if not already subscribed
+        if (!this.subscribedTickers.has(ticker)) {
+            this.subscribedTickers.add(ticker);
+            this.subscribeToTrades([ticker]);
+        }
+        // Return a promise that resolves on the next trade
+        return new Promise((resolve, reject) => {
+            if (!this.tradeResolvers.has(ticker)) {
+                this.tradeResolvers.set(ticker, []);
+            }
+            this.tradeResolvers.get(ticker).push({ resolve, reject });
+        });
+    }
+    async close() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = undefined;
+        }
+        this.isConnected = false;
+        this.isConnecting = false;
+    }
+}
+exports.KalshiWebSocket = KalshiWebSocket;

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

@@ -1,8 +1,15 @@
 import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, ExchangeCredentials } from '../../BaseExchange';
 import { UnifiedMarket, PriceCandle, OrderBook, Trade, Order, Position, Balance, CreateOrderParams } from '../../types';
+import { PolymarketWebSocketConfig } from './websocket';
+export { PolymarketWebSocketConfig };
+export interface PolymarketExchangeOptions {
+    credentials?: ExchangeCredentials;
+    websocket?: PolymarketWebSocketConfig;
+}
 export declare class PolymarketExchange extends PredictionMarketExchange {
     private auth?;
-    constructor(credentials?: ExchangeCredentials);
+    private wsConfig?;
+    constructor(options?: ExchangeCredentials | PolymarketExchangeOptions);
     get name(): string;
     fetchMarkets(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     searchMarkets(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]>;
@@ -20,4 +27,8 @@ export declare class PolymarketExchange extends PredictionMarketExchange {
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
     fetchPositions(): Promise<Position[]>;
     fetchBalance(): Promise<Balance[]>;
+    private ws?;
+    watchOrderBook(id: string, limit?: number): Promise<OrderBook>;
+    watchTrades(id: string, since?: number, limit?: number): Promise<Trade[]>;
+    close(): Promise<void>;
 }

package/dist/exchanges/polymarket/index.js

@@ -11,9 +11,23 @@ const fetchTrades_1 = require("./fetchTrades");
 const fetchPositions_1 = require("./fetchPositions");
 const auth_1 = require("./auth");
 const clob_client_1 = require("@polymarket/clob-client");
+const websocket_1 = require("./websocket");
 class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
-    constructor(credentials) {
+    constructor(options) {
+        // Support both old signature (credentials only) and new signature (options object)
+        let credentials;
+        let wsConfig;
+        if (options && 'credentials' in options) {
+            // New signature: PolymarketExchangeOptions
+            credentials = options.credentials;
+            wsConfig = options.websocket;
+        }
+        else {
+            // Old signature: ExchangeCredentials directly
+            credentials = options;
+        }
         super(credentials);
+        this.wsConfig = wsConfig;
         // Initialize auth if credentials are provided
         if (credentials?.privateKey) {
             this.auth = new auth_1.PolymarketAuth(credentials);
@@ -93,7 +107,6 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
             };
         }
         catch (error) {
-            console.error("Polymarket createOrder error:", error);
             throw error;
         }
     }
@@ -116,7 +129,6 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
             };
         }
         catch (error) {
-            console.error("Polymarket cancelOrder error:", error);
             throw error;
         }
     }
@@ -140,7 +152,6 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
             };
         }
         catch (error) {
-            console.error("Polymarket fetchOrder error:", error);
             throw error;
         }
     }
@@ -166,7 +177,7 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
             }));
         }
         catch (error) {
-            console.error("Polymarket fetchOpenOrders error:", error);
+            console.error('Error fetching Polymarket open orders:', error);
             return [];
         }
     }
@@ -208,9 +219,26 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
                 }];
         }
         catch (error) {
-            console.error("Polymarket fetchBalance error:", error);
             throw error;
         }
     }
+    async watchOrderBook(id, limit) {
+        if (!this.ws) {
+            this.ws = new websocket_1.PolymarketWebSocket(this.wsConfig);
+        }
+        return this.ws.watchOrderBook(id);
+    }
+    async watchTrades(id, since, limit) {
+        if (!this.ws) {
+            this.ws = new websocket_1.PolymarketWebSocket(this.wsConfig);
+        }
+        return this.ws.watchTrades(id);
+    }
+    async close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = undefined;
+        }
+    }
 }
 exports.PolymarketExchange = PolymarketExchange;

package/dist/exchanges/polymarket/websocket.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Polymarket WebSocket implementation for pmxt.
+ *
+ * NOTICE: This implementation depends on "@nevuamarkets/poly-websockets",
+ * which is licensed under the AGPL-3.0 License.
+ *
+ * While pmxt is licensed under MIT, using these specific WebSocket methods
+ * may subject your application to the terms of the AGPL-3.0.
+ *
+ * If you must avoid AGPL-3.0, do not use the watchOrderBook() or
+ * watchTrades() methods for Polymarket.
+ */
+import { OrderBook, Trade } from '../../types';
+export interface PolymarketWebSocketConfig {
+    /** Reconnection check interval in milliseconds (default: 5000) */
+    reconnectIntervalMs?: number;
+    /** Pending subscription flush interval in milliseconds (default: 100) */
+    flushIntervalMs?: number;
+}
+/**
+ * Wrapper around @nevuamarkets/poly-websockets that provides CCXT Pro-style
+ * watchOrderBook() and watchTrades() methods.
+ */
+export declare class PolymarketWebSocket {
+    private manager;
+    private orderBookResolvers;
+    private tradeResolvers;
+    private orderBooks;
+    private config;
+    private initializationPromise?;
+    constructor(config?: PolymarketWebSocketConfig);
+    private ensureInitialized;
+    watchOrderBook(id: string): Promise<OrderBook>;
+    watchTrades(id: string): Promise<Trade[]>;
+    private handleBookSnapshot;
+    private handlePriceChange;
+    private handleTrade;
+    private resolveOrderBook;
+    close(): Promise<void>;
+}

package/dist/exchanges/polymarket/websocket.js

@@ -0,0 +1,219 @@
+"use strict";
+/**
+ * @license
+ * Polymarket WebSocket implementation for pmxt.
+ *
+ * NOTICE: This implementation depends on "@nevuamarkets/poly-websockets",
+ * which is licensed under the AGPL-3.0 License.
+ *
+ * While pmxt is licensed under MIT, using these specific WebSocket methods
+ * may subject your application to the terms of the AGPL-3.0.
+ *
+ * If you must avoid AGPL-3.0, do not use the watchOrderBook() or
+ * watchTrades() methods for Polymarket.
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolymarketWebSocket = void 0;
+/**
+ * Wrapper around @nevuamarkets/poly-websockets that provides CCXT Pro-style
+ * watchOrderBook() and watchTrades() methods.
+ */
+class PolymarketWebSocket {
+    constructor(config = {}) {
+        this.orderBookResolvers = new Map();
+        this.tradeResolvers = new Map();
+        this.orderBooks = new Map();
+        this.config = config;
+    }
+    async ensureInitialized() {
+        if (this.initializationPromise)
+            return this.initializationPromise;
+        this.initializationPromise = (async () => {
+            try {
+                // Dynamic import to handle AGPL dependency optionally
+                const poly = await Promise.resolve().then(() => __importStar(require('@nevuamarkets/poly-websockets')));
+                this.manager = new poly.WSSubscriptionManager({
+                    onBook: async (events) => {
+                        for (const event of events) {
+                            this.handleBookSnapshot(event);
+                        }
+                    },
+                    onPriceChange: async (events) => {
+                        for (const event of events) {
+                            this.handlePriceChange(event);
+                        }
+                    },
+                    onLastTradePrice: async (events) => {
+                        for (const event of events) {
+                            this.handleTrade(event);
+                        }
+                    },
+                    onError: async (error) => {
+                        console.error('Polymarket WebSocket error:', error.message);
+                    },
+                }, {
+                    reconnectAndCleanupIntervalMs: this.config.reconnectIntervalMs ?? 5000,
+                    pendingFlushIntervalMs: this.config.flushIntervalMs ?? 100,
+                });
+            }
+            catch (e) {
+                const error = e;
+                if (error.message.includes('Cannot find module')) {
+                    throw new Error('Polymarket WebSocket support requires the "@nevuamarkets/poly-websockets" package (AGPL-3.0).\n' +
+                        'To use this feature, please install it: npm install @nevuamarkets/poly-websockets');
+                }
+                throw e;
+            }
+        })();
+        return this.initializationPromise;
+    }
+    async watchOrderBook(id) {
+        await this.ensureInitialized();
+        // Subscribe to the asset if not already subscribed
+        const currentAssets = this.manager.getAssetIds();
+        if (!currentAssets.includes(id)) {
+            await this.manager.addSubscriptions([id]);
+        }
+        // Return a promise that resolves on the next orderbook update
+        return new Promise((resolve, reject) => {
+            if (!this.orderBookResolvers.has(id)) {
+                this.orderBookResolvers.set(id, []);
+            }
+            this.orderBookResolvers.get(id).push({ resolve, reject });
+        });
+    }
+    async watchTrades(id) {
+        await this.ensureInitialized();
+        // Subscribe to the asset if not already subscribed
+        const currentAssets = this.manager.getAssetIds();
+        if (!currentAssets.includes(id)) {
+            await this.manager.addSubscriptions([id]);
+        }
+        // Return a promise that resolves on the next trade
+        return new Promise((resolve, reject) => {
+            if (!this.tradeResolvers.has(id)) {
+                this.tradeResolvers.set(id, []);
+            }
+            this.tradeResolvers.get(id).push({ resolve, reject });
+        });
+    }
+    handleBookSnapshot(event) {
+        const id = event.asset_id;
+        const bids = event.bids.map((b) => ({
+            price: parseFloat(b.price),
+            size: parseFloat(b.size),
+        })).sort((a, b) => b.price - a.price);
+        const asks = event.asks.map((a) => ({
+            price: parseFloat(a.price),
+            size: parseFloat(a.size),
+        })).sort((a, b) => a.price - b.price);
+        const orderBook = {
+            bids,
+            asks,
+            timestamp: event.timestamp ? (isNaN(Number(event.timestamp)) ? new Date(event.timestamp).getTime() : Number(event.timestamp)) : Date.now(),
+        };
+        this.orderBooks.set(id, orderBook);
+        this.resolveOrderBook(id, orderBook);
+    }
+    handlePriceChange(event) {
+        // Apply deltas to existing orderbook
+        for (const change of event.price_changes) {
+            const id = change.asset_id;
+            const existing = this.orderBooks.get(id);
+            if (!existing) {
+                // No snapshot yet, skip delta
+                continue;
+            }
+            const price = parseFloat(change.price);
+            const size = parseFloat(change.size);
+            const side = change.side.toUpperCase();
+            const levels = side === 'BUY' ? existing.bids : existing.asks;
+            const existingIndex = levels.findIndex((l) => l.price === price);
+            if (size === 0) {
+                // Remove level
+                if (existingIndex !== -1) {
+                    levels.splice(existingIndex, 1);
+                }
+            }
+            else {
+                // Update or add level
+                if (existingIndex !== -1) {
+                    levels[existingIndex].size = size;
+                }
+                else {
+                    levels.push({ price, size });
+                    // Re-sort
+                    if (side === 'BUY') {
+                        levels.sort((a, b) => b.price - a.price);
+                    }
+                    else {
+                        levels.sort((a, b) => a.price - b.price);
+                    }
+                }
+            }
+            existing.timestamp = event.timestamp ? (isNaN(Number(event.timestamp)) ? new Date(event.timestamp).getTime() : Number(event.timestamp)) : Date.now();
+            this.resolveOrderBook(id, existing);
+        }
+    }
+    handleTrade(event) {
+        const id = event.asset_id;
+        const trade = {
+            id: `${event.timestamp}-${Math.random()}`,
+            timestamp: event.timestamp ? (isNaN(Number(event.timestamp)) ? new Date(event.timestamp).getTime() : Number(event.timestamp)) : Date.now(),
+            price: parseFloat(event.price),
+            amount: parseFloat(event.size),
+            side: event.side.toLowerCase(),
+        };
+        const resolvers = this.tradeResolvers.get(id);
+        if (resolvers && resolvers.length > 0) {
+            resolvers.forEach((r) => r.resolve([trade]));
+            this.tradeResolvers.set(id, []);
+        }
+    }
+    resolveOrderBook(id, orderBook) {
+        const resolvers = this.orderBookResolvers.get(id);
+        if (resolvers && resolvers.length > 0) {
+            resolvers.forEach((r) => r.resolve(orderBook));
+            this.orderBookResolvers.set(id, []);
+        }
+    }
+    async close() {
+        if (this.manager) {
+            await this.manager.clearState();
+        }
+    }
+}
+exports.PolymarketWebSocket = PolymarketWebSocket;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmxt-core",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "pmxt is a unified prediction market data API. The ccxt for prediction markets.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,8 +29,8 @@
     "test": "jest -c jest.config.js",
     "server": "tsx watch src/server/index.ts",
     "server:prod": "node dist/server/index.js",
-    "generate:sdk:python": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g python -o ../sdks/python/generated --package-name pmxt_internal --additional-properties=projectName=pmxt-internal,packageVersion=1.0.4,library=urllib3",
-    "generate:sdk:typescript": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g typescript-fetch -o ../sdks/typescript/generated --additional-properties=npmName=pmxtjs,npmVersion=1.0.4,supportsES6=true,typescriptThreePlus=true",
+    "generate:sdk:python": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g python -o ../sdks/python/generated --package-name pmxt_internal --additional-properties=projectName=pmxt-internal,packageVersion=1.1.0,library=urllib3",
+    "generate:sdk:typescript": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g typescript-fetch -o ../sdks/typescript/generated --additional-properties=npmName=pmxtjs,npmVersion=1.1.0,supportsES6=true,typescriptThreePlus=true",
     "generate:docs": "node ../scripts/generate-api-docs.js",
     "generate:sdk:all": "npm run generate:sdk:python && npm run generate:sdk:typescript && npm run generate:docs"
   },
@@ -46,10 +46,13 @@
     "dotenv": "^17.2.3",
     "ethers": "^5.8.0",
     "express": "^5.2.1",
+    "isows": "^1.0.6",
     "jest": "^30.2.0",
-    "tsx": "^4.21.0"
+    "tsx": "^4.21.0",
+    "ws": "^8.18.0"
   },
   "devDependencies": {
+    "@nevuamarkets/poly-websockets": "^1.0.0",
     "@openapitools/openapi-generator-cli": "^2.27.0",
     "@types/cors": "^2.8.19",
     "@types/jest": "^30.0.0",
@@ -59,6 +62,15 @@
     "identity-obj-proxy": "^3.0.0",
     "js-yaml": "^3.14.2",
     "ts-jest": "^29.4.6",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "@types/ws": "^8.5.10"
+  },
+  "peerDependencies": {
+    "@nevuamarkets/poly-websockets": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@nevuamarkets/poly-websockets": {
+      "optional": true
+    }
   }
 }