pmxtjs 2.40.6 → 2.41.1

package/dist/esm/pmxt/client.js

@@ -131,6 +131,8 @@ export class Exchange {
     serverManager;
     initPromise;
     isHosted;
+    _hostedAccount;
+    _accountDiscoveryPromise;
     /**
      * Sticky flag: set to `true` the first time a GET read is rejected by
      * the sidecar with 404/405 (i.e. an older pmxt-core that only supports
@@ -188,9 +190,14 @@ export class Exchange {
                 this.api = new DefaultApi(this.config);
             }
             catch (error) {
-                throw new PmxtError(`Failed to start PMXT server: ${error}\n\n` +
+                const msg = `Failed to start PMXT server: ${error instanceof Error ? error.message : error}\n\n` +
                     `Please ensure 'pmxt-core' is installed: npm install -g pmxt-core\n` +
-                    `Or start the server manually: pmxt-server`);
+                    `Or start the server manually: pmxt-server`;
+                const pmxtError = new PmxtError(msg);
+                if (error instanceof Error) {
+                    pmxtError.cause = error;
+                }
+                throw pmxtError;
             }
         }
     }
@@ -289,8 +296,11 @@ export class Exchange {
         if (this._wsClient?.connected)
             return this._wsClient;
         const host = this.resolveBaseUrl();
-        const accessToken = this.serverManager.getAccessToken();
-        const client = new SidecarWsClient(host, accessToken || undefined);
+        const accessToken = this.isHosted
+            ? this.pmxtApiKey
+            : this.serverManager.getAccessToken();
+        const authParamName = this.isHosted ? "apiKey" : "token";
+        const client = new SidecarWsClient(host, accessToken || undefined, authParamName);
         try {
             // Trigger connection to validate the endpoint exists.
             // subscribe() calls ensureConnected internally, but we want
@@ -325,8 +335,12 @@ export class Exchange {
         try {
             return await ws.subscribe(this.exchangeName, method, args, this.getCredentials());
         }
-        catch {
-            return null;
+        catch (error) {
+            // Only fall back to HTTP for transport-level failures
+            if (error instanceof PmxtError && /connection failed|no websocket/i.test(error.message)) {
+                return null;
+            }
+            throw error;
         }
     }
     // Low-Level API Access
@@ -1423,8 +1437,11 @@ export class Exchange {
                     return result;
                 }
             }
-            catch {
-                // fall through to HTTP
+            catch (error) {
+                // Only fall through to HTTP for transport-level WS failures
+                if (!(error instanceof PmxtError) || !/connection failed|no websocket/i.test(error.message)) {
+                    throw error;
+                }
             }
         }
         // HTTP fallback
@@ -1450,7 +1467,7 @@ export class Exchange {
                 }
                 return result;
             }
-            return {};
+            throw new PmxtError("watchOrderBooks: unexpected response shape from server");
         }
         catch (error) {
             if (error instanceof PmxtError)
@@ -1458,6 +1475,45 @@ export class Exchange {
             throw new PmxtError(`Failed to watch order books: ${error}`);
         }
     }
+    /**
+     * Stream all orderbook updates across venues via the hosted WebSocket API.
+     *
+     * Returns a promise that resolves with the next book event.
+     * Call repeatedly in a loop to stream updates (CCXT Pro pattern).
+     * Requires hosted mode (`pmxtApiKey` set).
+     *
+     * @param venues - Optional venue filter (e.g. ["polymarket", "limitless"])
+     * @returns Next event with source, symbol, and orderbook
+     *
+     * @example
+     * ```typescript
+     * const poly = new Polymarket({ pmxtApiKey: "pmxt_xxx" });
+     * while (true) {
+     *   const event = await poly.watchAllOrderBooks();
+     *   console.log(event.source, event.symbol, event.orderbook.bids[0]);
+     * }
+     * ```
+     */
+    async watchAllOrderBooks(venues) {
+        await this.initPromise;
+        if (!this.isHosted) {
+            throw new PmxtError("watchAllOrderBooks() requires hosted mode (set pmxtApiKey)");
+        }
+        const args = venues ? [venues] : [];
+        const wsData = await this.watchViaWs("watchAllOrderBooks", args);
+        if (wsData !== null) {
+            return {
+                source: wsData._source || "",
+                symbol: wsData._symbol || "",
+                orderbook: convertOrderBook(wsData),
+            };
+        }
+        throw new PmxtError("watchAllOrderBooks() requires WebSocket transport — connection failed");
+    }
+    /** @deprecated Use {@link watchAllOrderBooks} instead. */
+    async firehose(venues) {
+        return this.watchAllOrderBooks(venues);
+    }
     /**
      * Watch real-time trade updates via WebSocket.
      *
@@ -1660,12 +1716,71 @@ export class Exchange {
             throw new PmxtError(`Failed to build order: ${error}`);
         }
     }
+    async _discoverHostedAccount() {
+        if (this._hostedAccount)
+            return;
+        if (!this._accountDiscoveryPromise) {
+            this._accountDiscoveryPromise = (async () => {
+                try {
+                    const res = await this.fetchWithRetry(`${this.resolveBaseUrl()}/v0/account`, { method: 'GET', headers: { ...this.getAuthHeaders() } });
+                    if (res.ok) {
+                        const body = await res.json();
+                        this._hostedAccount = { depositWallet: body.deposit_wallet, signatureType: body.signature_type };
+                    }
+                    else {
+                        this._hostedAccount = {};
+                    }
+                }
+                catch {
+                    this._hostedAccount = {};
+                }
+            })();
+        }
+        await this._accountDiscoveryPromise;
+    }
+    async _executeSorOrder(params) {
+        await this._discoverHostedAccount();
+        const buildRes = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/sor/buildOrder`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+            body: JSON.stringify({ args: [params] }),
+        });
+        if (!buildRes.ok)
+            throw new PmxtError(`buildOrder failed: ${await buildRes.text()}`);
+        const buildJson = await buildRes.json();
+        const { orderId, legs } = buildJson.data || buildJson;
+        const fills = [];
+        for (const leg of legs) {
+            try {
+                const { Polymarket, Limitless } = require('pmxt-core');
+                const VenueClass = leg.venue === 'polymarket' ? Polymarket : leg.venue === 'limitless' ? Limitless : null;
+                if (!VenueClass)
+                    throw new Error(`unsupported venue: ${leg.venue}`);
+                const venueOpts = { privateKey: this.privateKey };
+                if (leg.venue === 'polymarket' && this._hostedAccount?.depositWallet) {
+                    venueOpts.funderAddress = this._hostedAccount.depositWallet;
+                    venueOpts.signatureType = this._hostedAccount.signatureType || 3;
+                }
+                const venue = new VenueClass(venueOpts);
+                const order = await venue.createOrder({ outcomeId: leg.tokenId, side: leg.side, amount: leg.shares, price: leg.price });
+                const filledShares = order.filled || 0;
+                fills.push({ venue: leg.venue, venueOrderId: order.id, venueMarketId: leg.venueMarketId, venueOutcomeId: leg.venueOutcomeId, shares: filledShares > 0 ? filledShares : leg.shares, price: order.price || leg.price, status: filledShares > 0 ? 'filled' : 'open' });
+            }
+            catch (err) {
+                fills.push({ venue: leg.venue, venueMarketId: leg.venueMarketId, venueOutcomeId: leg.venueOutcomeId, shares: leg.shares, price: leg.price, status: 'failed', error: err.message });
+            }
+        }
+        const submitRes = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/sor/submitOrder`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
+            body: JSON.stringify({ args: [{ orderId, fills }] }),
+        });
+        if (!submitRes.ok)
+            throw new PmxtError(`submitOrder failed: ${await submitRes.text()}`);
+        const submitJson = await submitRes.json();
+        return convertOrder(submitJson.data || submitJson);
+    }
     /**
-     * Create a new order.
-     *
-     * @param params - Order parameters
-     * @returns Created order
-     *
      * @example
      * ```typescript
      * const order = await exchange.createOrder({
@@ -1680,6 +1795,9 @@ export class Exchange {
      */
     async createOrder(params) {
         if (this.isHosted) {
+            if (this.exchangeName === 'sor' && this.privateKey) {
+                return this._executeSorOrder(params);
+            }
             throw new PmxtError("Trade execution is not available through the hosted API. " +
                 "Use the local PMXT SDK with your venue credentials instead. " +
                 "See https://pmxt.dev/docs/quickstart for setup instructions.");

package/dist/esm/pmxt/models.d.ts

@@ -112,6 +112,17 @@ export interface OrderBook {
     /** Unix timestamp (milliseconds) */
     timestamp?: number;
 }
+/**
+ * A single event from the firehose stream.
+ */
+export interface FirehoseEvent {
+    /** The venue this event originated from (e.g. "polymarket", "limitless") */
+    source: string;
+    /** The outcome token id / asset id */
+    symbol: string;
+    /** The order book snapshot */
+    orderbook: OrderBook;
+}
 /**
  * Result of an execution price calculation.
  */

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

@@ -16,6 +16,7 @@ export declare class SidecarWsClient {
     private ws;
     private host;
     private accessToken;
+    private authParamName;
     private closed;
     /** requestId -> latest data payload */
     private dataStore;
@@ -24,7 +25,7 @@ export declare class SidecarWsClient {
     /** (method:symbolKey) -> requestId -- avoids duplicate subscribes */
     private activeSubs;
     private connectPromise;
-    constructor(host: string, accessToken?: string);
+    constructor(host: string, accessToken?: string, authParamName?: string);
     private ensureConnected;
     private connect;
     private getWebSocketConstructor;

package/dist/esm/pmxt/ws-client.js

@@ -17,6 +17,7 @@ export class SidecarWsClient {
     ws = null;
     host;
     accessToken;
+    authParamName;
     closed = false;
     /** requestId -> latest data payload */
     dataStore = new Map();
@@ -25,9 +26,10 @@ export class SidecarWsClient {
     /** (method:symbolKey) -> requestId -- avoids duplicate subscribes */
     activeSubs = new Map();
     connectPromise = null;
-    constructor(host, accessToken) {
+    constructor(host, accessToken, authParamName = "token") {
         this.host = host;
         this.accessToken = accessToken;
+        this.authParamName = authParamName;
     }
     // ------------------------------------------------------------------
     // Connection lifecycle
@@ -58,7 +60,7 @@ export class SidecarWsClient {
             }
             let url = `${scheme}://${hostPart}/ws`;
             if (this.accessToken) {
-                url = `${url}?token=${this.accessToken}`;
+                url = `${url}?${this.authParamName}=${this.accessToken}`;
             }
             // Use the ws package in Node.js, native WebSocket in browsers
             const WsConstructor = this.getWebSocketConstructor();
@@ -77,22 +79,30 @@ export class SidecarWsClient {
                     // Connection failed during handshake
                     reject(new PmxtError(`WebSocket connection failed: ${err.message || err}`));
                 }
+                else {
+                    // Post-handshake error — propagate to all pending subscribers
+                    const error = new PmxtError(`WebSocket error: ${err.message || err}`);
+                    for (const sub of this.subscriptions.values()) {
+                        if (sub.reject) {
+                            sub.reject(error);
+                            sub.reject = null;
+                            sub.resolve = null;
+                        }
+                    }
+                    this.closed = true;
+                    this.ws = null;
+                }
             };
             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
-                }
+                const raw = typeof event.data === "string"
+                    ? event.data
+                    : event.data.toString();
+                const msg = JSON.parse(raw);
+                this.dispatch(msg);
             };
         });
     }
@@ -101,14 +111,15 @@ export class SidecarWsClient {
         if (typeof globalThis !== "undefined" && globalThis.WebSocket) {
             return globalThis.WebSocket;
         }
-        // Node.js -- try to require ws
+        // Node.js -- require ws
         try {
             // Dynamic require to avoid bundler issues
             const wsModule = require("ws");
             return wsModule.default || wsModule;
         }
         catch {
-            return null;
+            throw new PmxtError("WebSocket support in Node.js requires the 'ws' package. " +
+                "Install it with: npm install ws");
         }
     }
     dispatch(msg) {

package/dist/generated/src/apis/DefaultApi.d.ts

@@ -647,63 +647,63 @@ export declare class DefaultApi extends runtime.BaseAPI {
      */
     testDummyMethod(requestParameters: TestDummyMethodOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TestDummyMethod200Response>;
     /**
-     * Stop watching a previously registered wallet address and release its resource updates.
-     * Unwatch Address
+     * Stop watching a previously registered wallet address and release its resource updates.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"unwatchAddress\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"unwatchAddress\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Unwatch Address (WebSocket)
      */
     unwatchAddressRaw(requestParameters: UnwatchAddressOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BaseResponse>>;
     /**
-     * Stop watching a previously registered wallet address and release its resource updates.
-     * Unwatch Address
+     * Stop watching a previously registered wallet address and release its resource updates.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"unwatchAddress\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"unwatchAddress\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Unwatch Address (WebSocket)
      */
     unwatchAddress(requestParameters: UnwatchAddressOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BaseResponse>;
     /**
-     * Unsubscribe from a previously watched order book stream.
-     * Unwatch Order Book
+     * Unsubscribe from a previously watched order book stream.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"unwatchOrderBook\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"unwatchOrderBook\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Unwatch Order Book (WebSocket)
      */
     unwatchOrderBookRaw(requestParameters: UnwatchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BaseResponse>>;
     /**
-     * Unsubscribe from a previously watched order book stream.
-     * Unwatch Order Book
+     * Unsubscribe from a previously watched order book stream.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"unwatchOrderBook\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"unwatchOrderBook\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Unwatch Order Book (WebSocket)
      */
     unwatchOrderBook(requestParameters: UnwatchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BaseResponse>;
     /**
-     * Stream activity for a public wallet address Returns a promise that resolves with the next activity snapshot whenever a change is detected. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
-     * Watch Address
+     * Stream activity for a public wallet address Returns a promise that resolves with the next activity snapshot whenever a change is detected. Call repeatedly in a loop to stream updates (CCXT Pro pattern).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchAddress\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchAddress\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Address (WebSocket)
      */
     watchAddressRaw(requestParameters: WatchAddressOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WatchAddress200Response>>;
     /**
-     * Stream activity for a public wallet address Returns a promise that resolves with the next activity snapshot whenever a change is detected. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
-     * Watch Address
+     * Stream activity for a public wallet address Returns a promise that resolves with the next activity snapshot whenever a change is detected. Call repeatedly in a loop to stream updates (CCXT Pro pattern).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchAddress\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchAddress\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Address (WebSocket)
      */
     watchAddress(requestParameters: WatchAddressOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WatchAddress200Response>;
     /**
-     * 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).
-     * Watch Order Book
+     * 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).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchOrderBook\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchOrderBook\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Order Book (WebSocket)
      */
     watchOrderBookRaw(requestParameters: WatchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchOrderBook200Response>>;
     /**
-     * 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).
-     * Watch Order Book
+     * 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).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchOrderBook\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchOrderBook\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Order Book (WebSocket)
      */
     watchOrderBook(requestParameters: WatchOrderBookOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchOrderBook200Response>;
     /**
-     * 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.
-     * Watch Order Books
+     * 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.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchOrderBooks\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchOrderBooks\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Order Books (WebSocket)
      */
     watchOrderBooksRaw(requestParameters: WatchOrderBooksOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WatchOrderBooks200Response>>;
     /**
-     * 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.
-     * Watch Order Books
+     * 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.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchOrderBooks\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchOrderBooks\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Order Books (WebSocket)
      */
     watchOrderBooks(requestParameters: WatchOrderBooksOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WatchOrderBooks200Response>;
     /**
-     * Watch trade executions in real-time via WebSocket. Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).
-     * Watch Trades
+     * Watch trade executions in real-time via WebSocket. Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchTrades\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchTrades\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Trades (WebSocket)
      */
     watchTradesRaw(requestParameters: WatchTradesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FetchTrades200Response>>;
     /**
-     * Watch trade executions in real-time via WebSocket. Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).
-     * Watch Trades
+     * Watch trade executions in real-time via WebSocket. Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchTrades\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchTrades\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Trades (WebSocket)
      */
     watchTrades(requestParameters: WatchTradesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FetchTrades200Response>;
 }

package/dist/generated/src/apis/DefaultApi.js

@@ -1505,8 +1505,8 @@ class DefaultApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * Stop watching a previously registered wallet address and release its resource updates.
-     * Unwatch Address
+     * Stop watching a previously registered wallet address and release its resource updates.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"unwatchAddress\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"unwatchAddress\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Unwatch Address (WebSocket)
      */
     async unwatchAddressRaw(requestParameters, initOverrides) {
         if (requestParameters['exchange'] == null) {
@@ -1527,16 +1527,16 @@ class DefaultApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.BaseResponseFromJSON)(jsonValue));
     }
     /**
-     * Stop watching a previously registered wallet address and release its resource updates.
-     * Unwatch Address
+     * Stop watching a previously registered wallet address and release its resource updates.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"unwatchAddress\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"unwatchAddress\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Unwatch Address (WebSocket)
      */
     async unwatchAddress(requestParameters, initOverrides) {
         const response = await this.unwatchAddressRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Unsubscribe from a previously watched order book stream.
-     * Unwatch Order Book
+     * Unsubscribe from a previously watched order book stream.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"unwatchOrderBook\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"unwatchOrderBook\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Unwatch Order Book (WebSocket)
      */
     async unwatchOrderBookRaw(requestParameters, initOverrides) {
         if (requestParameters['exchange'] == null) {
@@ -1557,16 +1557,16 @@ class DefaultApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.BaseResponseFromJSON)(jsonValue));
     }
     /**
-     * Unsubscribe from a previously watched order book stream.
-     * Unwatch Order Book
+     * Unsubscribe from a previously watched order book stream.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"unwatchOrderBook\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"unwatchOrderBook\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Unwatch Order Book (WebSocket)
      */
     async unwatchOrderBook(requestParameters, initOverrides) {
         const response = await this.unwatchOrderBookRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Stream activity for a public wallet address Returns a promise that resolves with the next activity snapshot whenever a change is detected. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
-     * Watch Address
+     * Stream activity for a public wallet address Returns a promise that resolves with the next activity snapshot whenever a change is detected. Call repeatedly in a loop to stream updates (CCXT Pro pattern).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchAddress\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchAddress\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Address (WebSocket)
      */
     async watchAddressRaw(requestParameters, initOverrides) {
         if (requestParameters['exchange'] == null) {
@@ -1587,16 +1587,16 @@ class DefaultApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.WatchAddress200ResponseFromJSON)(jsonValue));
     }
     /**
-     * Stream activity for a public wallet address Returns a promise that resolves with the next activity snapshot whenever a change is detected. Call repeatedly in a loop to stream updates (CCXT Pro pattern).
-     * Watch Address
+     * Stream activity for a public wallet address Returns a promise that resolves with the next activity snapshot whenever a change is detected. Call repeatedly in a loop to stream updates (CCXT Pro pattern).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchAddress\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchAddress\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Address (WebSocket)
      */
     async watchAddress(requestParameters, initOverrides) {
         const response = await this.watchAddressRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * 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).
-     * Watch Order Book
+     * 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).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchOrderBook\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchOrderBook\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Order Book (WebSocket)
      */
     async watchOrderBookRaw(requestParameters, initOverrides) {
         if (requestParameters['exchange'] == null) {
@@ -1617,16 +1617,16 @@ class DefaultApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FetchOrderBook200ResponseFromJSON)(jsonValue));
     }
     /**
-     * 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).
-     * Watch Order Book
+     * 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).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchOrderBook\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchOrderBook\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Order Book (WebSocket)
      */
     async watchOrderBook(requestParameters, initOverrides) {
         const response = await this.watchOrderBookRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * 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.
-     * Watch Order Books
+     * 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.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchOrderBooks\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchOrderBooks\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Order Books (WebSocket)
      */
     async watchOrderBooksRaw(requestParameters, initOverrides) {
         if (requestParameters['exchange'] == null) {
@@ -1647,16 +1647,16 @@ class DefaultApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.WatchOrderBooks200ResponseFromJSON)(jsonValue));
     }
     /**
-     * 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.
-     * Watch Order Books
+     * 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.  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchOrderBooks\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchOrderBooks\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Order Books (WebSocket)
      */
     async watchOrderBooks(requestParameters, initOverrides) {
         const response = await this.watchOrderBooksRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Watch trade executions in real-time via WebSocket. Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).
-     * Watch Trades
+     * Watch trade executions in real-time via WebSocket. Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchTrades\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchTrades\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Trades (WebSocket)
      */
     async watchTradesRaw(requestParameters, initOverrides) {
         if (requestParameters['exchange'] == null) {
@@ -1677,8 +1677,8 @@ class DefaultApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FetchTrades200ResponseFromJSON)(jsonValue));
     }
     /**
-     * Watch trade executions in real-time via WebSocket. Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).
-     * Watch Trades
+     * Watch trade executions in real-time via WebSocket. Returns a promise that resolves with the next trade(s). Call repeatedly in a loop to stream updates (CCXT Pro pattern).  **Transport:** WebSocket  | Environment | URL | |---|---| | Local sidecar | `ws://localhost:3847/ws` | | Hosted API | `wss://api.pmxt.dev/ws?apiKey=YOUR_KEY` |  **Subscribe:** ```json { \"id\": \"req-1\", \"action\": \"subscribe\", \"method\": \"watchTrades\", \"args\": [...] } ```  **Server response:** ```json { \"event\": \"data\", \"id\": \"req-1\", \"method\": \"watchTrades\", \"symbol\": \"...\", \"data\": { ... } } ```  **Unsubscribe:** ```json { \"id\": \"req-1\", \"action\": \"unsubscribe\" } ```
+     * Watch Trades (WebSocket)
      */
     async watchTrades(requestParameters, initOverrides) {
         const response = await this.watchTradesRaw(requestParameters, initOverrides);

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

@@ -21,7 +21,7 @@ export interface UnwatchAddressRequest {
      * @type {Array<string>}
      * @memberof UnwatchAddressRequest
      */
-    args: Array<string>;
+    args?: Array<string>;
     /**
      *
      * @type {ExchangeCredentials}

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

@@ -23,8 +23,6 @@ const ExchangeCredentials_1 = require("./ExchangeCredentials");
  * Check if a given object implements the UnwatchAddressRequest interface.
  */
 function instanceOfUnwatchAddressRequest(value) {
-    if (!('args' in value) || value['args'] === undefined)
-        return false;
     return true;
 }
 function UnwatchAddressRequestFromJSON(json) {
@@ -35,7 +33,7 @@ function UnwatchAddressRequestFromJSONTyped(json, ignoreDiscriminator) {
         return json;
     }
     return {
-        'args': json['args'],
+        'args': json['args'] == null ? undefined : json['args'],
         'credentials': json['credentials'] == null ? undefined : (0, ExchangeCredentials_1.ExchangeCredentialsFromJSON)(json['credentials']),
     };
 }

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

@@ -21,7 +21,7 @@ export interface UnwatchOrderBookRequest {
      * @type {Array<string>}
      * @memberof UnwatchOrderBookRequest
      */
-    args: Array<string>;
+    args?: Array<string>;
     /**
      *
      * @type {ExchangeCredentials}

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

@@ -23,8 +23,6 @@ const ExchangeCredentials_1 = require("./ExchangeCredentials");
  * Check if a given object implements the UnwatchOrderBookRequest interface.
  */
 function instanceOfUnwatchOrderBookRequest(value) {
-    if (!('args' in value) || value['args'] === undefined)
-        return false;
     return true;
 }
 function UnwatchOrderBookRequestFromJSON(json) {
@@ -35,7 +33,7 @@ function UnwatchOrderBookRequestFromJSONTyped(json, ignoreDiscriminator) {
         return json;
     }
     return {
-        'args': json['args'],
+        'args': json['args'] == null ? undefined : json['args'],
         'credentials': json['credentials'] == null ? undefined : (0, ExchangeCredentials_1.ExchangeCredentialsFromJSON)(json['credentials']),
     };
 }