pmxtjs 2.35.30 → 2.35.32

package/dist/generated/src/models/WatchOrderBooksRequestArgsInner.js

@@ -0,0 +1,53 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * PMXT Sidecar API
+ * A unified local sidecar API for prediction markets (Polymarket, Kalshi, Limitless). This API acts as a JSON-RPC-style gateway. Each endpoint corresponds to a specific method on the generic exchange implementation.
+ *
+ * The version of the OpenAPI document: 0.4.4
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchOrderBooksRequestArgsInnerFromJSON = WatchOrderBooksRequestArgsInnerFromJSON;
+exports.WatchOrderBooksRequestArgsInnerFromJSONTyped = WatchOrderBooksRequestArgsInnerFromJSONTyped;
+exports.WatchOrderBooksRequestArgsInnerToJSON = WatchOrderBooksRequestArgsInnerToJSON;
+exports.WatchOrderBooksRequestArgsInnerToJSONTyped = WatchOrderBooksRequestArgsInnerToJSONTyped;
+function WatchOrderBooksRequestArgsInnerFromJSON(json) {
+    return WatchOrderBooksRequestArgsInnerFromJSONTyped(json, false);
+}
+function WatchOrderBooksRequestArgsInnerFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    if (typeof json === 'number') {
+        return json;
+    }
+    if (Array.isArray(json)) {
+        if (json.every(item => typeof item === 'string')) {
+            return json;
+        }
+    }
+    return {};
+}
+function WatchOrderBooksRequestArgsInnerToJSON(json) {
+    return WatchOrderBooksRequestArgsInnerToJSONTyped(json, false);
+}
+function WatchOrderBooksRequestArgsInnerToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        if (value.every(item => typeof item === 'string')) {
+            return value;
+        }
+    }
+    return {};
+}

package/dist/generated/src/models/index.d.ts

@@ -91,4 +91,7 @@ export * from './WatchAddressRequest';
 export * from './WatchAddressRequestArgsInner';
 export * from './WatchOrderBookRequest';
 export * from './WatchOrderBookRequestArgsInner';
+export * from './WatchOrderBooks200Response';
+export * from './WatchOrderBooksRequest';
+export * from './WatchOrderBooksRequestArgsInner';
 export * from './WatchTradesRequest';

package/dist/generated/src/models/index.js

@@ -109,4 +109,7 @@ __exportStar(require("./WatchAddressRequest"), exports);
 __exportStar(require("./WatchAddressRequestArgsInner"), exports);
 __exportStar(require("./WatchOrderBookRequest"), exports);
 __exportStar(require("./WatchOrderBookRequestArgsInner"), exports);
+__exportStar(require("./WatchOrderBooks200Response"), exports);
+__exportStar(require("./WatchOrderBooksRequest"), exports);
+__exportStar(require("./WatchOrderBooksRequestArgsInner"), exports);
 __exportStar(require("./WatchTradesRequest"), exports);

package/dist/pmxt/client.d.ts

@@ -75,6 +75,10 @@ export declare abstract class Exchange {
      * POST directly and skip the GET probe for the lifetime of this client.
      */
     private _getReadsUnsupported;
+    /** Shared WebSocket client for streaming methods (lazy). */
+    private _wsClient;
+    /** Sticky flag: true if the sidecar /ws endpoint is unavailable. */
+    private _wsUnsupported;
     constructor(exchangeName: string, options?: ExchangeOptions);
     private initializeServer;
     protected handleResponse(response: any): any;
@@ -96,6 +100,18 @@ export declare abstract class Exchange {
      * attempts to restart the sidecar.
      */
     private fetchWithRetry;
+    /**
+     * Return the shared WebSocket client, creating it on first use.
+     *
+     * Returns `null` if the sidecar /ws endpoint was previously found
+     * to be unavailable, letting callers fall back to HTTP.
+     */
+    private getOrCreateWs;
+    /**
+     * Attempt to use the WS transport for a watch method.
+     * Returns the raw data on success, or `null` if WS is unavailable.
+     */
+    private watchViaWs;
     /**
      * Call an exchange-specific REST endpoint by its operationId.
      * This provides direct access to all implicit API methods defined in
@@ -207,6 +223,32 @@ export declare abstract class Exchange {
      * ```
      */
     watchOrderBook(outcomeId: string | MarketOutcome, limit?: number): Promise<OrderBook>;
+    /**
+     * Watch real-time order book updates for multiple outcomes at once.
+     *
+     * Returns a record mapping each outcome ID (ticker) to its latest
+     * order book snapshot. Call repeatedly in a loop to stream updates
+     * (CCXT Pro pattern).
+     *
+     * Prefers the sidecar WebSocket transport when available, falling
+     * back to HTTP POST for older sidecars.
+     *
+     * @param outcomeIds - Array of outcome IDs (or MarketOutcome objects)
+     * @param limit - Optional depth limit for each order book
+     * @returns Record mapping ticker to OrderBook
+     *
+     * @example
+     * ```typescript
+     * const ids = markets.slice(0, 3).map(m => m.outcomes[0].outcomeId);
+     * while (true) {
+     *   const books = await exchange.watchOrderBooks(ids);
+     *   for (const [ticker, ob] of Object.entries(books)) {
+     *     console.log(`${ticker}: bid=${ob.bids[0]?.price}`);
+     *   }
+     * }
+     * ```
+     */
+    watchOrderBooks(outcomeIds: (string | MarketOutcome)[], limit?: number): Promise<Record<string, OrderBook>>;
     /**
      * Watch real-time trade updates via WebSocket.
      *

package/dist/pmxt/client.js

@@ -12,6 +12,7 @@ const models_js_1 = require("./models.js");
 const server_manager_js_1 = require("./server-manager.js");
 const errors_js_1 = require("./errors.js");
 const constants_js_1 = require("./constants.js");
+const ws_client_js_1 = require("./ws-client.js");
 /**
  * Resolve a MarketOutcome shorthand to a plain outcome ID string.
  * Accepts either a raw string ID or a MarketOutcome object.
@@ -248,6 +249,10 @@ class Exchange {
      * POST directly and skip the GET probe for the lifetime of this client.
      */
     _getReadsUnsupported = false;
+    /** Shared WebSocket client for streaming methods (lazy). */
+    _wsClient = null;
+    /** Sticky flag: true if the sidecar /ws endpoint is unavailable. */
+    _wsUnsupported = false;
     constructor(exchangeName, options = {}) {
         this.exchangeName = exchangeName.toLowerCase();
         this.apiKey = options.apiKey;
@@ -383,6 +388,58 @@ class Exchange {
         }
         throw lastError;
     }
+    /**
+     * Return the shared WebSocket client, creating it on first use.
+     *
+     * Returns `null` if the sidecar /ws endpoint was previously found
+     * to be unavailable, letting callers fall back to HTTP.
+     */
+    async getOrCreateWs() {
+        if (this._wsUnsupported)
+            return null;
+        if (this._wsClient?.connected)
+            return this._wsClient;
+        const host = this.resolveBaseUrl();
+        const accessToken = this.serverManager.getAccessToken();
+        const client = new ws_client_js_1.SidecarWsClient(host, accessToken || undefined);
+        try {
+            // Trigger connection to validate the endpoint exists.
+            // subscribe() calls ensureConnected internally, but we want
+            // to detect failure eagerly so we can set _wsUnsupported.
+            await client.subscribe(this.exchangeName, "_ping", [], undefined, 3000).catch(() => {
+                // Expected -- no _ping method. The connection itself
+                // succeeded if we got a WS error frame back. If the
+                // connection itself failed, we'll catch below.
+            });
+            // If we got here without the connect promise rejecting,
+            // the WS endpoint exists.
+            if (!client.connected) {
+                throw new Error("WS handshake failed");
+            }
+        }
+        catch {
+            this._wsUnsupported = true;
+            client.close();
+            return null;
+        }
+        this._wsClient = client;
+        return this._wsClient;
+    }
+    /**
+     * Attempt to use the WS transport for a watch method.
+     * Returns the raw data on success, or `null` if WS is unavailable.
+     */
+    async watchViaWs(method, args) {
+        const ws = await this.getOrCreateWs();
+        if (!ws)
+            return null;
+        try {
+            return await ws.subscribe(this.exchangeName, method, args, this.getCredentials());
+        }
+        catch {
+            return null;
+        }
+    }
     // Low-Level API Access
     /**
      * Call an exchange-specific REST endpoint by its operationId.
@@ -1328,11 +1385,17 @@ class Exchange {
     async watchOrderBook(outcomeId, limit) {
         await this.initPromise;
         const resolvedOutcomeId = resolveOutcomeId(outcomeId);
+        const args = [resolvedOutcomeId];
+        if (limit !== undefined) {
+            args.push(limit);
+        }
+        // Try WebSocket transport first
+        const wsData = await this.watchViaWs("watchOrderBook", args);
+        if (wsData !== null) {
+            return convertOrderBook(wsData);
+        }
+        // HTTP fallback
         try {
-            const args = [resolvedOutcomeId];
-            if (limit !== undefined) {
-                args.push(limit);
-            }
             const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/watchOrderBook`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -1355,6 +1418,88 @@ class Exchange {
             throw new errors_js_1.PmxtError(`Failed to watch order book: ${error}`);
         }
     }
+    /**
+     * Watch real-time order book updates for multiple outcomes at once.
+     *
+     * Returns a record mapping each outcome ID (ticker) to its latest
+     * order book snapshot. Call repeatedly in a loop to stream updates
+     * (CCXT Pro pattern).
+     *
+     * Prefers the sidecar WebSocket transport when available, falling
+     * back to HTTP POST for older sidecars.
+     *
+     * @param outcomeIds - Array of outcome IDs (or MarketOutcome objects)
+     * @param limit - Optional depth limit for each order book
+     * @returns Record mapping ticker to OrderBook
+     *
+     * @example
+     * ```typescript
+     * const ids = markets.slice(0, 3).map(m => m.outcomes[0].outcomeId);
+     * while (true) {
+     *   const books = await exchange.watchOrderBooks(ids);
+     *   for (const [ticker, ob] of Object.entries(books)) {
+     *     console.log(`${ticker}: bid=${ob.bids[0]?.price}`);
+     *   }
+     * }
+     * ```
+     */
+    async watchOrderBooks(outcomeIds, limit) {
+        await this.initPromise;
+        const resolvedIds = outcomeIds.map(resolveOutcomeId);
+        const args = [resolvedIds];
+        if (limit !== undefined) {
+            args.push(limit);
+        }
+        // Try WebSocket transport first
+        const ws = await this.getOrCreateWs();
+        if (ws) {
+            try {
+                const rawResult = await ws.subscribeBatch(this.exchangeName, "watchOrderBooks", args, this.getCredentials());
+                if (rawResult && typeof rawResult === "object") {
+                    const result = {};
+                    for (const [k, v] of Object.entries(rawResult)) {
+                        if (v && typeof v === "object") {
+                            result[k] = convertOrderBook(v);
+                        }
+                    }
+                    return result;
+                }
+            }
+            catch {
+                // fall through to HTTP
+            }
+        }
+        // HTTP fallback
+        try {
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/watchOrderBooks`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+                body: JSON.stringify({ args, credentials: this.getCredentials() }),
+            });
+            if (!response.ok) {
+                const body = await response.json().catch(() => ({}));
+                if (body.error && typeof body.error === "object") {
+                    throw (0, errors_js_1.fromServerError)(body.error);
+                }
+                throw new errors_js_1.PmxtError(body.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            const data = this.handleResponse(json);
+            if (data && typeof data === "object") {
+                const result = {};
+                for (const [k, v] of Object.entries(data)) {
+                    result[k] = convertOrderBook(v);
+                }
+                return result;
+            }
+            return {};
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.PmxtError)
+                throw error;
+            throw new errors_js_1.PmxtError(`Failed to watch order books: ${error}`);
+        }
+    }
     /**
      * Watch real-time trade updates via WebSocket.
      *

package/dist/pmxt/ws-client.d.ts

@@ -0,0 +1,37 @@
+/**
+ * WebSocket client for streaming methods.
+ *
+ * Provides a multiplexed WebSocket connection to the sidecar server,
+ * used by watchOrderBook and watchOrderBooks as an alternative to
+ * HTTP long-polling. Falls back to HTTP transparently when the sidecar
+ * does not support the /ws endpoint.
+ */
+/**
+ * Multiplexed WebSocket client for the pmxt sidecar.
+ *
+ * Lazily connects to ws://{host}/ws?token={accessToken}. A single
+ * WebSocket connection is shared across all streaming subscriptions.
+ */
+export declare class SidecarWsClient {
+    private ws;
+    private host;
+    private accessToken;
+    private closed;
+    /** requestId -> latest data payload */
+    private dataStore;
+    /** requestId -> subscription metadata */
+    private subscriptions;
+    /** (method:symbolKey) -> requestId -- avoids duplicate subscribes */
+    private activeSubs;
+    private connectPromise;
+    constructor(host: string, accessToken?: string);
+    private ensureConnected;
+    private connect;
+    private getWebSocketConstructor;
+    private dispatch;
+    subscribe(exchange: string, method: string, args: any[], credentials?: Record<string, any>, timeoutMs?: number): Promise<any>;
+    subscribeBatch(exchange: string, method: string, args: any[], credentials?: Record<string, any>, timeoutMs?: number): Promise<Record<string, any>>;
+    close(): void;
+    get connected(): boolean;
+    private waitForData;
+}

package/dist/pmxt/ws-client.js

@@ -0,0 +1,276 @@
+"use strict";
+/**
+ * WebSocket client for streaming methods.
+ *
+ * Provides a multiplexed WebSocket connection to the sidecar server,
+ * used by watchOrderBook and watchOrderBooks as an alternative to
+ * HTTP long-polling. Falls back to HTTP transparently when the sidecar
+ * does not support the /ws endpoint.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SidecarWsClient = void 0;
+const errors_js_1 = require("./errors.js");
+/**
+ * Multiplexed WebSocket client for the pmxt sidecar.
+ *
+ * Lazily connects to ws://{host}/ws?token={accessToken}. A single
+ * WebSocket connection is shared across all streaming subscriptions.
+ */
+class SidecarWsClient {
+    ws = null;
+    host;
+    accessToken;
+    closed = false;
+    /** requestId -> latest data payload */
+    dataStore = new Map();
+    /** requestId -> subscription metadata */
+    subscriptions = new Map();
+    /** (method:symbolKey) -> requestId -- avoids duplicate subscribes */
+    activeSubs = new Map();
+    connectPromise = null;
+    constructor(host, accessToken) {
+        this.host = host;
+        this.accessToken = accessToken;
+    }
+    // ------------------------------------------------------------------
+    // Connection lifecycle
+    // ------------------------------------------------------------------
+    async ensureConnected() {
+        if (this.ws && !this.closed)
+            return;
+        if (this.connectPromise)
+            return this.connectPromise;
+        this.connectPromise = this.connect();
+        try {
+            await this.connectPromise;
+        }
+        finally {
+            this.connectPromise = null;
+        }
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            let hostPart = this.host;
+            let scheme = "ws";
+            if (hostPart.startsWith("https://")) {
+                hostPart = hostPart.slice("https://".length);
+                scheme = "wss";
+            }
+            else if (hostPart.startsWith("http://")) {
+                hostPart = hostPart.slice("http://".length);
+            }
+            let url = `${scheme}://${hostPart}/ws`;
+            if (this.accessToken) {
+                url = `${url}?token=${this.accessToken}`;
+            }
+            // Use the ws package in Node.js, native WebSocket in browsers
+            const WsConstructor = this.getWebSocketConstructor();
+            if (!WsConstructor) {
+                reject(new errors_js_1.PmxtError("No WebSocket implementation available"));
+                return;
+            }
+            const ws = new WsConstructor(url);
+            this.closed = false;
+            ws.onopen = () => {
+                this.ws = ws;
+                resolve();
+            };
+            ws.onerror = (err) => {
+                if (!this.ws) {
+                    // Connection failed during handshake
+                    reject(new errors_js_1.PmxtError(`WebSocket connection failed: ${err.message || err}`));
+                }
+            };
+            ws.onclose = () => {
+                this.closed = true;
+                this.ws = null;
+            };
+            ws.onmessage = (event) => {
+                try {
+                    const data = typeof event.data === "string"
+                        ? event.data
+                        : event.data.toString();
+                    const msg = JSON.parse(data);
+                    this.dispatch(msg);
+                }
+                catch {
+                    // Ignore unparseable frames
+                }
+            };
+        });
+    }
+    getWebSocketConstructor() {
+        // Browser / Deno / Bun
+        if (typeof globalThis !== "undefined" && globalThis.WebSocket) {
+            return globalThis.WebSocket;
+        }
+        // Node.js -- try to require ws
+        try {
+            // Dynamic require to avoid bundler issues
+            const wsModule = require("ws");
+            return wsModule.default || wsModule;
+        }
+        catch {
+            return null;
+        }
+    }
+    dispatch(msg) {
+        const eventType = msg.event;
+        const requestId = msg.id;
+        if (eventType === "error" && requestId) {
+            const sub = this.subscriptions.get(requestId);
+            if (sub?.reject) {
+                sub.reject(new errors_js_1.PmxtError(msg.error?.message || "WebSocket subscription error"));
+                sub.reject = null;
+                sub.resolve = null;
+            }
+            return;
+        }
+        if (eventType === "subscribed") {
+            // Acknowledgement -- nothing to do
+            return;
+        }
+        if (eventType === "data" && requestId) {
+            const symbol = msg.symbol || "";
+            const data = msg.data || {};
+            // Store by (requestId:symbol) for batch methods
+            this.dataStore.set(`${requestId}:${symbol}`, data);
+            // Store by requestId alone for single-symbol methods
+            this.dataStore.set(requestId, data);
+            const sub = this.subscriptions.get(requestId);
+            if (sub?.resolve) {
+                sub.resolve(data);
+                sub.resolve = null;
+                sub.reject = null;
+            }
+        }
+    }
+    // ------------------------------------------------------------------
+    // Public API
+    // ------------------------------------------------------------------
+    async subscribe(exchange, method, args, credentials, timeoutMs = 30000) {
+        const firstArg = args[0] ?? "";
+        const subKey = Array.isArray(firstArg)
+            ? `${method}:${[...firstArg].sort().join(",")}`
+            : `${method}:${firstArg}`;
+        // Reuse existing subscription
+        const existingId = this.activeSubs.get(subKey);
+        if (existingId && this.subscriptions.has(existingId)) {
+            return this.waitForData(existingId, timeoutMs);
+        }
+        await this.ensureConnected();
+        const requestId = `req-${Math.random().toString(36).slice(2, 14)}`;
+        const symbols = Array.isArray(firstArg) ? firstArg : firstArg ? [firstArg] : [];
+        const sub = {
+            requestId,
+            method,
+            symbols,
+            resolve: null,
+            reject: null,
+        };
+        this.subscriptions.set(requestId, sub);
+        this.activeSubs.set(subKey, requestId);
+        const message = {
+            id: requestId,
+            action: "subscribe",
+            exchange,
+            method,
+            args,
+        };
+        if (credentials) {
+            message.credentials = credentials;
+        }
+        this.ws.send(JSON.stringify(message));
+        return this.waitForData(requestId, timeoutMs);
+    }
+    async subscribeBatch(exchange, method, args, credentials, timeoutMs = 30000) {
+        const symbols = Array.isArray(args[0]) ? args[0] : [];
+        await this.ensureConnected();
+        const requestId = `req-${Math.random().toString(36).slice(2, 14)}`;
+        const sub = {
+            requestId,
+            method,
+            symbols,
+            resolve: null,
+            reject: null,
+        };
+        this.subscriptions.set(requestId, sub);
+        const message = {
+            id: requestId,
+            action: "subscribe",
+            exchange,
+            method,
+            args,
+        };
+        if (credentials) {
+            message.credentials = credentials;
+        }
+        this.ws.send(JSON.stringify(message));
+        // Wait for first data event
+        await this.waitForData(requestId, timeoutMs);
+        // Collect per-symbol data
+        const result = {};
+        for (const symbol of symbols) {
+            const storeKey = `${requestId}:${symbol}`;
+            const data = this.dataStore.get(storeKey);
+            if (data !== undefined) {
+                result[symbol] = data;
+            }
+        }
+        // If no per-symbol data, return the single data event as-is
+        if (Object.keys(result).length === 0) {
+            const data = this.dataStore.get(requestId);
+            if (data && typeof data === "object") {
+                return data;
+            }
+        }
+        return result;
+    }
+    close() {
+        this.closed = true;
+        if (this.ws) {
+            try {
+                this.ws.close();
+            }
+            catch {
+                // ignore
+            }
+            this.ws = null;
+        }
+    }
+    get connected() {
+        return this.ws !== null && !this.closed;
+    }
+    // ------------------------------------------------------------------
+    // Internal
+    // ------------------------------------------------------------------
+    waitForData(requestId, timeoutMs) {
+        // Check if data is already available
+        const existing = this.dataStore.get(requestId);
+        if (existing !== undefined) {
+            this.dataStore.delete(requestId);
+            return Promise.resolve(existing);
+        }
+        return new Promise((resolve, reject) => {
+            const sub = this.subscriptions.get(requestId);
+            if (!sub) {
+                reject(new errors_js_1.PmxtError("Subscription not found"));
+                return;
+            }
+            const timer = setTimeout(() => {
+                sub.resolve = null;
+                sub.reject = null;
+                reject(new errors_js_1.PmxtError(`Timeout waiting for WebSocket data (method=${sub.method})`));
+            }, timeoutMs);
+            sub.resolve = (data) => {
+                clearTimeout(timer);
+                resolve(data);
+            };
+            sub.reject = (err) => {
+                clearTimeout(timer);
+                reject(err);
+            };
+        });
+    }
+}
+exports.SidecarWsClient = SidecarWsClient;

package/generated/.openapi-generator/FILES

@@ -96,6 +96,9 @@ docs/WatchAddressRequest.md
 docs/WatchAddressRequestArgsInner.md
 docs/WatchOrderBookRequest.md
 docs/WatchOrderBookRequestArgsInner.md
+docs/WatchOrderBooks200Response.md
+docs/WatchOrderBooksRequest.md
+docs/WatchOrderBooksRequestArgsInner.md
 docs/WatchTradesRequest.md
 package.json
 src/apis/DefaultApi.ts
@@ -194,6 +197,9 @@ src/models/WatchAddressRequest.ts
 src/models/WatchAddressRequestArgsInner.ts
 src/models/WatchOrderBookRequest.ts
 src/models/WatchOrderBookRequestArgsInner.ts
+src/models/WatchOrderBooks200Response.ts
+src/models/WatchOrderBooksRequest.ts
+src/models/WatchOrderBooksRequestArgsInner.ts
 src/models/WatchTradesRequest.ts
 src/models/index.ts
 src/runtime.ts