pmxt-core 2.35.30 → 2.35.32

package/dist/BaseExchange.d.ts

@@ -217,6 +217,8 @@ export interface ExchangeHas {
     unwatchAddress: ExchangeCapability;
     /** Whether this exchange supports streaming order book updates. */
     watchOrderBook: ExchangeCapability;
+    /** Whether this exchange supports batch-subscribing to multiple order book streams. */
+    watchOrderBooks: ExchangeCapability;
     /** Whether this exchange supports unsubscribing from an order book stream. */
     unwatchOrderBook: ExchangeCapability;
     /** Whether this exchange supports streaming trade updates. */
@@ -574,6 +576,17 @@ export declare abstract class PredictionMarketExchange {
      * @returns Promise that resolves with the current orderbook state
      */
     watchOrderBook(id: string, limit?: number): Promise<OrderBook>;
+    /**
+     * Watch multiple order books simultaneously via WebSocket.
+     * Returns a promise that resolves with a record of order book snapshots keyed by ID.
+     * Exchanges with native batch support (e.g. Kalshi) send a single subscribe message
+     * for all tickers; others fall back to individual watchOrderBook calls.
+     *
+     * @param ids - Array of Outcome IDs to watch
+     * @param limit - Optional limit for orderbook depth
+     * @returns Promise that resolves with order books keyed by ID
+     */
+    watchOrderBooks(ids: string[], limit?: number): Promise<Record<string, OrderBook>>;
     /**
      * Unsubscribe from a previously watched order book stream.
      *

package/dist/BaseExchange.js

@@ -764,6 +764,30 @@ class PredictionMarketExchange {
     async watchOrderBook(id, limit) {
         throw new Error(`watchOrderBook() is not supported by ${this.name}`);
     }
+    /**
+     * Watch multiple order books simultaneously via WebSocket.
+     * Returns a promise that resolves with a record of order book snapshots keyed by ID.
+     * Exchanges with native batch support (e.g. Kalshi) send a single subscribe message
+     * for all tickers; others fall back to individual watchOrderBook calls.
+     *
+     * @param ids - Array of Outcome IDs to watch
+     * @param limit - Optional limit for orderbook depth
+     * @returns Promise that resolves with order books keyed by ID
+     */
+    async watchOrderBooks(ids, limit) {
+        // Default implementation: subscribe to each ID individually.
+        // Exchanges with native batch support (e.g. Kalshi) override this
+        // to send a single subscribe message for all tickers.
+        const entries = await Promise.all(ids.map(async (id) => {
+            const book = await this.watchOrderBook(id, limit);
+            return [id, book];
+        }));
+        const result = {};
+        for (const [id, book] of entries) {
+            result[id] = book;
+        }
+        return result;
+    }
     /**
      * Unsubscribe from a previously watched order book stream.
      *
@@ -1033,7 +1057,7 @@ class PredictionMarketExchange {
         'fetchMarkets', 'fetchEvents', 'fetchOHLCV', 'fetchOrderBook',
         'fetchTrades', 'createOrder', 'cancelOrder', 'fetchOrder',
         'fetchOpenOrders', 'fetchPositions', 'fetchBalance',
-        'watchAddress', 'unwatchAddress', 'watchOrderBook',
+        'watchAddress', 'unwatchAddress', 'watchOrderBook', 'watchOrderBooks',
         'unwatchOrderBook', 'watchTrades', 'fetchMyTrades',
         'fetchClosedOrders', 'fetchAllOrders', 'buildOrder', 'submitOrder',
         'fetchMarketMatches', 'fetchMatches', 'fetchEventMatches', 'compareMarketPrices',
@@ -1046,7 +1070,7 @@ class PredictionMarketExchange {
         fetchOrderBook: true, fetchTrades: true, createOrder: true,
         cancelOrder: true, fetchOrder: true, fetchOpenOrders: true,
         fetchPositions: true, fetchBalance: true, watchAddress: true,
-        unwatchAddress: true, watchOrderBook: true, unwatchOrderBook: true,
+        unwatchAddress: true, watchOrderBook: true, watchOrderBooks: true, unwatchOrderBook: true,
         watchTrades: true, fetchMyTrades: true, fetchClosedOrders: true,
         fetchAllOrders: true, buildOrder: true, submitOrder: true,
         fetchMarketMatches: true, fetchMatches: true, fetchEventMatches: true, compareMarketPrices: true,
@@ -1061,6 +1085,7 @@ class PredictionMarketExchange {
     static _capabilityDelegates = {
         fetchMarkets: 'fetchMarketsImpl',
         fetchEvents: 'fetchEventsImpl',
+        watchOrderBooks: 'watchOrderBook',
         fetchMatches: 'fetchMarketMatches',
         fetchHedges: 'fetchRelatedMarkets',
         fetchMatchedPrices: 'fetchMatchedMarkets',

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

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-04-30T15:51:55.936Z
+ * Generated at: 2026-05-01T12:04:30.287Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const kalshiApiSpec: {

package/dist/exchanges/kalshi/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.kalshiApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-04-30T15:51:55.936Z
+ * Generated at: 2026-05-01T12:04:30.287Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.kalshiApiSpec = {

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

@@ -39,6 +39,7 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
     private ws?;
     watchOrderBook(id: string, limit?: number): Promise<OrderBook>;
+    watchOrderBooks(ids: string[], limit?: number): Promise<Record<string, OrderBook>>;
     watchTrades(id: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;
     close(): Promise<void>;
 }

package/dist/exchanges/kalshi/index.js

@@ -263,6 +263,18 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
         const marketTicker = id.replace(/-NO$/, "");
         return this.ws.watchOrderBook(marketTicker);
     }
+    async watchOrderBooks(ids, limit) {
+        const auth = this.ensureAuth();
+        if (!this.ws) {
+            const wsConfigWithUrl = {
+                ...this.wsConfig,
+                wsUrl: this.wsConfig?.wsUrl || this.config.wsUrl,
+            };
+            this.ws = new websocket_1.KalshiWebSocket(auth, wsConfigWithUrl);
+        }
+        const marketTickers = ids.map((id) => id.replace(/-NO$/, ""));
+        return this.ws.watchOrderBooks(marketTickers);
+    }
     async watchTrades(id, address, since, limit) {
         const auth = this.ensureAuth();
         if (!this.ws) {

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

@@ -38,6 +38,7 @@ export declare class KalshiWebSocket {
     private handleTrade;
     private resolveOrderBook;
     watchOrderBook(ticker: string): Promise<OrderBook>;
+    watchOrderBooks(tickers: string[]): Promise<Record<string, OrderBook>>;
     watchTrades(ticker: string): Promise<Trade[]>;
     close(): Promise<void>;
 }

package/dist/exchanges/kalshi/websocket.js

@@ -324,7 +324,7 @@ class KalshiWebSocket {
         // Subscribe if not already subscribed
         if (!this.subscribedOrderBookTickers.has(ticker)) {
             this.subscribedOrderBookTickers.add(ticker);
-            this.subscribeToOrderbook(Array.from(this.subscribedOrderBookTickers));
+            this.subscribeToOrderbook([ticker]);
         }
         // Return a promise that resolves on the next orderbook update
         return new Promise((resolve, reject) => {
@@ -334,6 +334,40 @@ class KalshiWebSocket {
             this.orderBookResolvers.get(ticker).push({ resolve, reject });
         });
     }
+    async watchOrderBooks(tickers) {
+        // Ensure connection
+        if (!this.isConnected) {
+            await this.connect();
+        }
+        // Determine which tickers are actually new (not yet subscribed)
+        const newTickers = tickers.filter((t) => !this.subscribedOrderBookTickers.has(t));
+        // Add all new tickers to the subscription set
+        for (const t of newTickers) {
+            this.subscribedOrderBookTickers.add(t);
+        }
+        // Send ONE subscribe message with only the new tickers
+        if (newTickers.length > 0) {
+            this.subscribeToOrderbook(newTickers);
+        }
+        // Wait for all tickers to receive at least one snapshot/update
+        const entries = await Promise.all(tickers.map((ticker) => new Promise((resolve, reject) => {
+            if (!this.orderBookResolvers.has(ticker)) {
+                this.orderBookResolvers.set(ticker, []);
+            }
+            this.orderBookResolvers.get(ticker).push({
+                resolve: (book) => {
+                    // Unwrap PromiseLike if needed, but in practice it is always OrderBook
+                    Promise.resolve(book).then((b) => resolve([ticker, b]));
+                },
+                reject,
+            });
+        })));
+        const result = {};
+        for (const [ticker, book] of entries) {
+            result[ticker] = book;
+        }
+        return result;
+    }
     async watchTrades(ticker) {
         // Ensure connection
         if (!this.isConnected) {
@@ -342,7 +376,7 @@ class KalshiWebSocket {
         // Subscribe if not already subscribed
         if (!this.subscribedTradeTickers.has(ticker)) {
             this.subscribedTradeTickers.add(ticker);
-            this.subscribeToTrades(Array.from(this.subscribedTradeTickers));
+            this.subscribeToTrades([ticker]);
         }
         // Return a promise that resolves on the next trade
         return new Promise((resolve, reject) => {

package/dist/exchanges/limitless/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/limitless/Limitless.yaml
- * Generated at: 2026-04-30T15:51:55.979Z
+ * Generated at: 2026-05-01T12:04:30.324Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const limitlessApiSpec: {

package/dist/exchanges/limitless/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.limitlessApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/limitless/Limitless.yaml
- * Generated at: 2026-04-30T15:51:55.979Z
+ * Generated at: 2026-05-01T12:04:30.324Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.limitlessApiSpec = {

package/dist/exchanges/myriad/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/myriad/myriad.yaml
- * Generated at: 2026-04-30T15:51:55.991Z
+ * Generated at: 2026-05-01T12:04:30.336Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const myriadApiSpec: {

package/dist/exchanges/myriad/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.myriadApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/myriad/myriad.yaml
- * Generated at: 2026-04-30T15:51:55.991Z
+ * Generated at: 2026-05-01T12:04:30.336Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.myriadApiSpec = {

package/dist/exchanges/opinion/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/opinion/opinion-openapi.yaml
- * Generated at: 2026-04-30T15:51:55.994Z
+ * Generated at: 2026-05-01T12:04:30.340Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const opinionApiSpec: {

package/dist/exchanges/opinion/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.opinionApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/opinion/opinion-openapi.yaml
- * Generated at: 2026-04-30T15:51:55.994Z
+ * Generated at: 2026-05-01T12:04:30.340Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.opinionApiSpec = {

package/dist/exchanges/polymarket/api-clob.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-04-30T15:51:55.945Z
+ * Generated at: 2026-05-01T12:04:30.294Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketClobSpec: {

package/dist/exchanges/polymarket/api-clob.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketClobSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-04-30T15:51:55.945Z
+ * Generated at: 2026-05-01T12:04:30.294Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketClobSpec = {

package/dist/exchanges/polymarket/api-data.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-04-30T15:51:55.961Z
+ * Generated at: 2026-05-01T12:04:30.307Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketDataSpec: {

package/dist/exchanges/polymarket/api-data.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketDataSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-04-30T15:51:55.961Z
+ * Generated at: 2026-05-01T12:04:30.307Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketDataSpec = {

package/dist/exchanges/polymarket/api-gamma.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-04-30T15:51:55.956Z
+ * Generated at: 2026-05-01T12:04:30.304Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketGammaSpec: {

package/dist/exchanges/polymarket/api-gamma.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketGammaSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-04-30T15:51:55.956Z
+ * Generated at: 2026-05-01T12:04:30.304Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketGammaSpec = {

package/dist/exchanges/probable/api.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-04-30T15:51:55.985Z
+ * Generated at: 2026-05-01T12:04:30.329Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const probableApiSpec: {

package/dist/exchanges/probable/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.probableApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-04-30T15:51:55.985Z
+ * Generated at: 2026-05-01T12:04:30.329Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.probableApiSpec = {

package/dist/server/app.d.ts

@@ -1,4 +1,5 @@
 import { Express } from "express";
+import { createWebSocketHandler, CreateWebSocketHandlerOptions } from "./ws-handler";
 /**
  * Options accepted by {@link createApp}.
  */
@@ -54,5 +55,10 @@ export declare function createApp(options?: CreateAppOptions): Express;
  * Start the PMXT sidecar server on the given port with the built-in
  * access-token auth middleware enabled. Returns the underlying
  * {@link http.Server} once it is listening.
+ *
+ * Automatically attaches a WebSocket endpoint at `/ws` for streaming
+ * methods (watchOrderBook, watchOrderBooks, watchTrades).
  */
 export declare function startServer(port: number, accessToken: string): Promise<import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>>;
+export { createWebSocketHandler };
+export type { CreateWebSocketHandlerOptions };

package/dist/server/app.js

@@ -3,24 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebSocketHandler = void 0;
 exports.createApp = createApp;
 exports.startServer = startServer;
 const express_1 = __importDefault(require("express"));
 const cors_1 = __importDefault(require("cors"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const polymarket_1 = require("../exchanges/polymarket");
-const limitless_1 = require("../exchanges/limitless");
-const kalshi_1 = require("../exchanges/kalshi");
-const kalshi_demo_1 = require("../exchanges/kalshi-demo");
-const probable_1 = require("../exchanges/probable");
-const baozi_1 = require("../exchanges/baozi");
-const myriad_1 = require("../exchanges/myriad");
-const opinion_1 = require("../exchanges/opinion");
-const metaculus_1 = require("../exchanges/metaculus");
-const smarkets_1 = require("../exchanges/smarkets");
-const polymarket_us_1 = require("../exchanges/polymarket_us");
-const router_1 = require("../router");
+const ws_handler_1 = require("./ws-handler");
+Object.defineProperty(exports, "createWebSocketHandler", { enumerable: true, get: function () { return ws_handler_1.createWebSocketHandler; } });
+const exchange_factory_1 = require("./exchange-factory");
 const errors_1 = require("../errors");
 function loadMethodVerbs() {
     const candidates = [
@@ -220,17 +212,17 @@ function createApp(options = {}) {
                 // calls — not a server-side env var.  Each request may carry a
                 // different key, so Router is never cached as a singleton.
                 const bearer = req.headers.authorization?.replace(/^Bearer\s+/i, "") || "";
-                exchange = createExchange(exchangeName, undefined, bearer);
+                exchange = (0, exchange_factory_1.createExchange)(exchangeName, undefined, bearer);
             }
             else if (credentials &&
                 (credentials.privateKey ||
                     credentials.apiKey ||
                     credentials.apiToken)) {
-                exchange = createExchange(exchangeName, credentials);
+                exchange = (0, exchange_factory_1.createExchange)(exchangeName, credentials);
             }
             else {
                 if (!defaultExchanges[exchangeName]) {
-                    defaultExchanges[exchangeName] = createExchange(exchangeName);
+                    defaultExchanges[exchangeName] = (0, exchange_factory_1.createExchange)(exchangeName);
                 }
                 exchange = defaultExchanges[exchangeName];
             }
@@ -336,93 +328,15 @@ function createApp(options = {}) {
  * Start the PMXT sidecar server on the given port with the built-in
  * access-token auth middleware enabled. Returns the underlying
  * {@link http.Server} once it is listening.
+ *
+ * Automatically attaches a WebSocket endpoint at `/ws` for streaming
+ * methods (watchOrderBook, watchOrderBooks, watchTrades).
  */
 async function startServer(port, accessToken) {
     const app = createApp({ accessToken });
-    return app.listen(port, "127.0.0.1");
-}
-function createExchange(name, credentials, bearerToken) {
-    switch (name) {
-        case "polymarket":
-            return new polymarket_1.PolymarketExchange({
-                privateKey: credentials?.privateKey ||
-                    process.env.POLYMARKET_PK ||
-                    process.env.POLYMARKET_PRIVATE_KEY,
-                apiKey: credentials?.apiKey || process.env.POLYMARKET_API_KEY,
-                apiSecret: credentials?.apiSecret || process.env.POLYMARKET_API_SECRET,
-                passphrase: credentials?.passphrase || process.env.POLYMARKET_PASSPHRASE,
-                funderAddress: credentials?.funderAddress ||
-                    process.env.POLYMARKET_FUNDER_ADDRESS ||
-                    process.env.POLYMARKET_PROXY_ADDRESS,
-                signatureType: credentials?.signatureType ||
-                    process.env.POLYMARKET_SIGNATURE_TYPE,
-            });
-        case "limitless":
-            return new limitless_1.LimitlessExchange({
-                privateKey: credentials?.privateKey ||
-                    process.env.LIMITLESS_PK ||
-                    process.env.LIMITLESS_PRIVATE_KEY,
-                apiKey: credentials?.apiKey || process.env.LIMITLESS_API_KEY,
-                apiSecret: credentials?.apiSecret || process.env.LIMITLESS_API_SECRET,
-                passphrase: credentials?.passphrase || process.env.LIMITLESS_PASSPHRASE,
-            });
-        case "kalshi":
-            return new kalshi_1.KalshiExchange({
-                credentials: {
-                    apiKey: credentials?.apiKey || process.env.KALSHI_API_KEY,
-                    privateKey: credentials?.privateKey || process.env.KALSHI_PRIVATE_KEY,
-                },
-            });
-        case "kalshi-demo":
-            return new kalshi_demo_1.KalshiDemoExchange({
-                credentials: {
-                    apiKey: credentials?.apiKey || process.env.KALSHI_API_KEY,
-                    privateKey: credentials?.privateKey || process.env.KALSHI_PRIVATE_KEY,
-                },
-            });
-        case "probable":
-            return new probable_1.ProbableExchange({
-                apiKey: credentials?.apiKey || process.env.PROBABLE_API_KEY,
-                apiSecret: credentials?.apiSecret || process.env.PROBABLE_API_SECRET,
-                passphrase: credentials?.passphrase || process.env.PROBABLE_PASSPHRASE,
-                privateKey: credentials?.privateKey || process.env.PROBABLE_PRIVATE_KEY,
-            });
-        case "baozi":
-            return new baozi_1.BaoziExchange({
-                privateKey: credentials?.privateKey || process.env.BAOZI_PRIVATE_KEY,
-            });
-        case "myriad":
-            return new myriad_1.MyriadExchange({
-                apiKey: credentials?.apiKey ||
-                    process.env.MYRIAD_API_KEY ||
-                    process.env.MYRIAD_PROD,
-                privateKey: credentials?.privateKey || process.env.MYRIAD_WALLET_ADDRESS,
-            });
-        case "opinion":
-            return new opinion_1.OpinionExchange({
-                apiKey: credentials?.apiKey || process.env.OPINION_API_KEY,
-                privateKey: credentials?.privateKey || process.env.OPINION_PRIVATE_KEY,
-                funderAddress: credentials?.funderAddress,
-            });
-        case "metaculus":
-            return new metaculus_1.MetaculusExchange({
-                apiToken: credentials?.apiToken || process.env.METACULUS_API_TOKEN,
-            });
-        case "smarkets":
-            return new smarkets_1.SmarketsExchange({
-                apiKey: credentials?.apiKey || process.env.SMARKETS_EMAIL,
-                privateKey: credentials?.privateKey || process.env.SMARKETS_PASSWORD,
-            });
-        case "polymarket_us":
-            return new polymarket_us_1.PolymarketUSExchange({
-                apiKey: credentials?.apiKey || process.env.POLYMARKET_US_KEY_ID,
-                privateKey: credentials?.privateKey || process.env.POLYMARKET_US_SECRET_KEY,
-            });
-        case "router":
-            return new router_1.Router({
-                apiKey: bearerToken,
-            });
-        default:
-            throw new Error(`Unknown exchange: ${name}`);
-    }
+    const server = app.listen(port, "127.0.0.1");
+    // Attach WebSocket handler for streaming subscriptions
+    const wsHandler = (0, ws_handler_1.createWebSocketHandler)({ accessToken });
+    wsHandler.attach(server);
+    return server;
 }

package/dist/server/exchange-factory.d.ts

@@ -0,0 +1,2 @@
+import { ExchangeCredentials } from "../BaseExchange";
+export declare function createExchange(name: string, credentials?: ExchangeCredentials, bearerToken?: string): unknown;

package/dist/server/exchange-factory.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExchange = createExchange;
+const polymarket_1 = require("../exchanges/polymarket");
+const limitless_1 = require("../exchanges/limitless");
+const kalshi_1 = require("../exchanges/kalshi");
+const kalshi_demo_1 = require("../exchanges/kalshi-demo");
+const probable_1 = require("../exchanges/probable");
+const baozi_1 = require("../exchanges/baozi");
+const myriad_1 = require("../exchanges/myriad");
+const opinion_1 = require("../exchanges/opinion");
+const metaculus_1 = require("../exchanges/metaculus");
+const smarkets_1 = require("../exchanges/smarkets");
+const polymarket_us_1 = require("../exchanges/polymarket_us");
+const router_1 = require("../router");
+function createExchange(name, credentials, bearerToken) {
+    switch (name) {
+        case "polymarket":
+            return new polymarket_1.PolymarketExchange({
+                privateKey: credentials?.privateKey ||
+                    process.env.POLYMARKET_PK ||
+                    process.env.POLYMARKET_PRIVATE_KEY,
+                apiKey: credentials?.apiKey || process.env.POLYMARKET_API_KEY,
+                apiSecret: credentials?.apiSecret || process.env.POLYMARKET_API_SECRET,
+                passphrase: credentials?.passphrase || process.env.POLYMARKET_PASSPHRASE,
+                funderAddress: credentials?.funderAddress ||
+                    process.env.POLYMARKET_FUNDER_ADDRESS ||
+                    process.env.POLYMARKET_PROXY_ADDRESS,
+                signatureType: credentials?.signatureType ||
+                    process.env.POLYMARKET_SIGNATURE_TYPE,
+            });
+        case "limitless":
+            return new limitless_1.LimitlessExchange({
+                privateKey: credentials?.privateKey ||
+                    process.env.LIMITLESS_PK ||
+                    process.env.LIMITLESS_PRIVATE_KEY,
+                apiKey: credentials?.apiKey || process.env.LIMITLESS_API_KEY,
+                apiSecret: credentials?.apiSecret || process.env.LIMITLESS_API_SECRET,
+                passphrase: credentials?.passphrase || process.env.LIMITLESS_PASSPHRASE,
+            });
+        case "kalshi":
+            return new kalshi_1.KalshiExchange({
+                credentials: {
+                    apiKey: credentials?.apiKey || process.env.KALSHI_API_KEY,
+                    privateKey: credentials?.privateKey || process.env.KALSHI_PRIVATE_KEY,
+                },
+            });
+        case "kalshi-demo":
+            return new kalshi_demo_1.KalshiDemoExchange({
+                credentials: {
+                    apiKey: credentials?.apiKey || process.env.KALSHI_API_KEY,
+                    privateKey: credentials?.privateKey || process.env.KALSHI_PRIVATE_KEY,
+                },
+            });
+        case "probable":
+            return new probable_1.ProbableExchange({
+                apiKey: credentials?.apiKey || process.env.PROBABLE_API_KEY,
+                apiSecret: credentials?.apiSecret || process.env.PROBABLE_API_SECRET,
+                passphrase: credentials?.passphrase || process.env.PROBABLE_PASSPHRASE,
+                privateKey: credentials?.privateKey || process.env.PROBABLE_PRIVATE_KEY,
+            });
+        case "baozi":
+            return new baozi_1.BaoziExchange({
+                privateKey: credentials?.privateKey || process.env.BAOZI_PRIVATE_KEY,
+            });
+        case "myriad":
+            return new myriad_1.MyriadExchange({
+                apiKey: credentials?.apiKey ||
+                    process.env.MYRIAD_API_KEY ||
+                    process.env.MYRIAD_PROD,
+                privateKey: credentials?.privateKey || process.env.MYRIAD_WALLET_ADDRESS,
+            });
+        case "opinion":
+            return new opinion_1.OpinionExchange({
+                apiKey: credentials?.apiKey || process.env.OPINION_API_KEY,
+                privateKey: credentials?.privateKey || process.env.OPINION_PRIVATE_KEY,
+                funderAddress: credentials?.funderAddress,
+            });
+        case "metaculus":
+            return new metaculus_1.MetaculusExchange({
+                apiToken: credentials?.apiToken || process.env.METACULUS_API_TOKEN,
+            });
+        case "smarkets":
+            return new smarkets_1.SmarketsExchange({
+                apiKey: credentials?.apiKey || process.env.SMARKETS_EMAIL,
+                privateKey: credentials?.privateKey || process.env.SMARKETS_PASSWORD,
+            });
+        case "polymarket_us":
+            return new polymarket_us_1.PolymarketUSExchange({
+                apiKey: credentials?.apiKey || process.env.POLYMARKET_US_KEY_ID,
+                privateKey: credentials?.privateKey || process.env.POLYMARKET_US_SECRET_KEY,
+            });
+        case "router":
+            return new router_1.Router({
+                apiKey: bearerToken,
+            });
+        default:
+            throw new Error(`Unknown exchange: ${name}`);
+    }
+}

package/dist/server/method-verbs.json

@@ -304,6 +304,21 @@
       }
     ]
   },
+  "watchOrderBooks": {
+    "verb": "post",
+    "args": [
+      {
+        "name": "ids",
+        "kind": "unknown",
+        "optional": false
+      },
+      {
+        "name": "limit",
+        "kind": "number",
+        "optional": true
+      }
+    ]
+  },
   "unwatchOrderBook": {
     "verb": "post",
     "args": [

package/dist/server/openapi.yaml

@@ -1329,6 +1329,51 @@ paths:
       description: >-
         Watch order book updates in real-time via WebSocket. Returns a promise that resolves with the next order book
         update. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
+  '/api/{exchange}/watchOrderBooks':
+    post:
+      summary: Watch Order Books
+      operationId: watchOrderBooks
+      parameters:
+        - $ref: '#/components/parameters/ExchangeParam'
+      requestBody:
+        content:
+          application/json:
+            schema:
+              title: WatchOrderBooksRequest
+              type: object
+              properties:
+                args:
+                  type: array
+                  minItems: 1
+                  maxItems: 2
+                  items:
+                    oneOf:
+                      - type: array
+                        items:
+                          type: string
+                      - type: number
+                credentials:
+                  $ref: '#/components/schemas/ExchangeCredentials'
+              required:
+                - args
+      responses:
+        '200':
+          description: Watch Order Books response
+          content:
+            application/json:
+              schema:
+                allOf:
+                  - $ref: '#/components/schemas/BaseResponse'
+                  - type: object
+                    properties:
+                      data:
+                        type: object
+                        additionalProperties:
+                          $ref: '#/components/schemas/OrderBook'
+      description: >-
+        Watch multiple order books simultaneously via WebSocket. Returns a promise that resolves with a record of order
+        book snapshots keyed by ID. Exchanges with native batch support (e.g. Kalshi) send a single subscribe message
+        for all tickers; others fall back to individual watchOrderBook calls.
   '/api/{exchange}/unwatchOrderBook':
     post:
       summary: Unwatch Order Book

package/dist/server/ws-handler.d.ts

@@ -0,0 +1,20 @@
+import { WebSocketServer } from "ws";
+import { Server as HttpServer } from "http";
+export interface CreateWebSocketHandlerOptions {
+    /** Access token for authentication (same as x-pmxt-access-token). */
+    accessToken?: string;
+}
+/**
+ * Create a WebSocket handler that can be attached to an HTTP server.
+ *
+ * Usage:
+ * ```ts
+ * const server = app.listen(port);
+ * const wss = createWebSocketHandler({ accessToken });
+ * wss.attach(server);
+ * ```
+ */
+export declare function createWebSocketHandler(options?: CreateWebSocketHandlerOptions): {
+    wss: WebSocketServer;
+    attach: (server: HttpServer) => void;
+};

package/dist/server/ws-handler.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebSocketHandler = createWebSocketHandler;
+const ws_1 = require("ws");
+const errors_1 = require("../errors");
+const exchange_factory_1 = require("./exchange-factory");
+// ---------------------------------------------------------------------------
+// Streaming methods
+// ---------------------------------------------------------------------------
+/** Set of method names that produce streaming data. */
+const WATCH_METHODS = new Set([
+    "watchOrderBook",
+    "watchOrderBooks",
+    "watchTrades",
+]);
+/** Methods for unsubscribing. */
+const UNWATCH_METHODS = {
+    unwatchOrderBook: "watchOrderBook",
+};
+function send(ws, msg) {
+    if (ws.readyState === ws_1.WebSocket.OPEN) {
+        ws.send(JSON.stringify(msg));
+    }
+}
+function sendError(ws, id, message, code) {
+    send(ws, { event: "error", id, error: { message, code } });
+}
+/**
+ * Build a unique key for a subscription so we can cancel it.
+ */
+function subscriptionKey(msg) {
+    return `${msg.exchange}:${msg.method}:${JSON.stringify(msg.args)}`;
+}
+/**
+ * Start a streaming loop for a single-ticker watch method
+ * (watchOrderBook, watchTrades).
+ */
+async function streamSingle(exchange, method, args, id, ws, signal) {
+    const symbol = typeof args[0] === "string" ? args[0] : String(args[0]);
+    // Send subscribed acknowledgement
+    send(ws, { event: "subscribed", id });
+    while (!signal.aborted && ws.readyState === ws_1.WebSocket.OPEN) {
+        try {
+            const result = await exchange[method](...args);
+            if (signal.aborted)
+                break;
+            send(ws, { id, event: "data", method, symbol, data: result });
+        }
+        catch (err) {
+            if (signal.aborted)
+                break;
+            const message = err instanceof errors_1.BaseError
+                ? err.message
+                : err instanceof Error
+                    ? err.message
+                    : "Unknown streaming error";
+            const code = err instanceof errors_1.BaseError ? err.code : undefined;
+            sendError(ws, id, message, code);
+            // Brief pause before retry to avoid tight error loops
+            await new Promise((r) => setTimeout(r, 1000));
+        }
+    }
+}
+/**
+ * Start a streaming loop for the batch watchOrderBooks method.
+ * Each update is sent as an individual data message per symbol.
+ */
+async function streamBatch(exchange, method, args, id, ws, signal) {
+    const ids = Array.isArray(args[0]) ? args[0] : [];
+    send(ws, { event: "subscribed", id });
+    while (!signal.aborted && ws.readyState === ws_1.WebSocket.OPEN) {
+        try {
+            const result = await exchange[method](...args);
+            if (signal.aborted)
+                break;
+            for (const [symbol, data] of Object.entries(result)) {
+                send(ws, { id, event: "data", method, symbol, data });
+            }
+        }
+        catch (err) {
+            if (signal.aborted)
+                break;
+            const message = err instanceof errors_1.BaseError
+                ? err.message
+                : err instanceof Error
+                    ? err.message
+                    : "Unknown streaming error";
+            const code = err instanceof errors_1.BaseError ? err.code : undefined;
+            sendError(ws, id, message, code);
+            await new Promise((r) => setTimeout(r, 1000));
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Create a WebSocket handler that can be attached to an HTTP server.
+ *
+ * Usage:
+ * ```ts
+ * const server = app.listen(port);
+ * const wss = createWebSocketHandler({ accessToken });
+ * wss.attach(server);
+ * ```
+ */
+function createWebSocketHandler(options = {}) {
+    const { accessToken } = options;
+    const wss = new ws_1.WebSocketServer({ noServer: true });
+    function attach(server) {
+        server.on("upgrade", (request, socket, head) => {
+            const url = new URL(request.url || "/", `http://${request.headers.host}`);
+            // Only handle upgrades to /ws
+            if (url.pathname !== "/ws") {
+                socket.destroy();
+                return;
+            }
+            // Validate access token from query parameter if configured
+            if (accessToken) {
+                const token = url.searchParams.get("token") ||
+                    request.headers["x-pmxt-access-token"];
+                if (!token || token !== accessToken) {
+                    socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+                    socket.destroy();
+                    return;
+                }
+            }
+            wss.handleUpgrade(request, socket, head, (ws) => {
+                wss.emit("connection", ws, request);
+            });
+        });
+    }
+    wss.on("connection", (ws) => {
+        const state = {
+            subscriptions: new Map(),
+            exchanges: new Map(),
+            authenticated: !accessToken, // pre-authed if no token required
+        };
+        ws.on("message", (raw) => {
+            let parsed;
+            try {
+                parsed = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf8"));
+            }
+            catch {
+                sendError(ws, undefined, "Invalid JSON");
+                return;
+            }
+            const id = parsed.id;
+            const action = parsed.action;
+            const exchange = parsed.exchange;
+            if (!id || !action || !exchange) {
+                sendError(ws, id, "Missing required fields: id, action, exchange");
+                return;
+            }
+            const exchangeName = exchange.toLowerCase();
+            if (action === "subscribe") {
+                const msg = {
+                    id,
+                    action: "subscribe",
+                    exchange: exchangeName,
+                    method: parsed.method,
+                    args: parsed.args || [],
+                    credentials: parsed.credentials,
+                };
+                handleSubscribe(ws, state, msg, exchangeName);
+            }
+            else if (action === "unsubscribe") {
+                const msg = {
+                    id,
+                    action: "unsubscribe",
+                    exchange: exchangeName,
+                    method: parsed.method,
+                    args: parsed.args || [],
+                };
+                handleUnsubscribe(ws, state, msg, exchangeName);
+            }
+            else {
+                sendError(ws, id, `Unknown action: ${action}`);
+            }
+        });
+        ws.on("close", () => {
+            // Abort all active subscriptions
+            for (const [, sub] of state.subscriptions) {
+                sub.abortController.abort();
+            }
+            state.subscriptions.clear();
+            // Close all exchange instances
+            for (const [, exchange] of state.exchanges) {
+                if (typeof exchange.close === "function") {
+                    exchange.close().catch(() => { });
+                }
+            }
+            state.exchanges.clear();
+        });
+        ws.on("error", () => {
+            // Abort subscriptions on error too
+            for (const [, sub] of state.subscriptions) {
+                sub.abortController.abort();
+            }
+        });
+    });
+    return { wss, attach };
+}
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+function getOrCreateExchange(state, exchangeName, credentials) {
+    // Use credentials as part of the cache key to support multiple auths
+    const cacheKey = credentials && (credentials.apiKey || credentials.privateKey)
+        ? `${exchangeName}:${credentials.apiKey || ""}:${credentials.privateKey || ""}`
+        : exchangeName;
+    const existing = state.exchanges.get(cacheKey);
+    if (existing)
+        return existing;
+    const exchange = (0, exchange_factory_1.createExchange)(exchangeName, credentials);
+    state.exchanges.set(cacheKey, exchange);
+    return exchange;
+}
+function handleSubscribe(ws, state, msg, exchangeName) {
+    const { id, method, args, credentials } = msg;
+    if (!WATCH_METHODS.has(method)) {
+        sendError(ws, id, `Method '${method}' is not a streaming method. Use the HTTP API for non-streaming calls.`);
+        return;
+    }
+    const key = subscriptionKey(msg);
+    // Already subscribed
+    if (state.subscriptions.has(key)) {
+        sendError(ws, id, `Already subscribed to ${key}`);
+        return;
+    }
+    let exchange;
+    try {
+        exchange = getOrCreateExchange(state, exchangeName, credentials);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to create exchange";
+        sendError(ws, id, message);
+        return;
+    }
+    if (typeof exchange[method] !== "function") {
+        sendError(ws, id, `Method '${method}' not found on ${exchangeName}`);
+        return;
+    }
+    const abortController = new AbortController();
+    state.subscriptions.set(key, { abortController });
+    const streamFn = method === "watchOrderBooks" ? streamBatch : streamSingle;
+    // Fire and forget -- the loop runs until aborted or WS closes
+    streamFn(exchange, method, args || [], id, ws, abortController.signal).catch(() => {
+        // Stream ended -- clean up
+        state.subscriptions.delete(key);
+    });
+}
+function handleUnsubscribe(ws, state, msg, exchangeName) {
+    const { id } = msg;
+    // Build the key of the subscription to cancel.
+    // For unsubscribe actions, the corresponding subscribe key uses the watch method.
+    const watchMethod = UNWATCH_METHODS[msg.method] || msg.method;
+    const lookupMsg = { ...msg, method: watchMethod };
+    const key = subscriptionKey(lookupMsg);
+    const sub = state.subscriptions.get(key);
+    if (!sub) {
+        sendError(ws, id, `No active subscription for ${key}`);
+        return;
+    }
+    sub.abortController.abort();
+    state.subscriptions.delete(key);
+    send(ws, { event: "subscribed", id }); // Acknowledge unsubscribe
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmxt-core",
-  "version": "2.35.30",
+  "version": "2.35.32",
   "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=2.35.30,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=2.35.30,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.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=2.35.32,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=2.35.32,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.js",
     "fetch:openapi": "node scripts/fetch-openapi-specs.js",
     "extract:jsdoc": "node ../scripts/extract-jsdoc.js",
     "generate:docs": "npm run extract:jsdoc && node ../scripts/generate-api-docs.js",