pmxtjs 2.44.5 → 2.45.0

package/pmxt/client.ts

@@ -52,6 +52,18 @@ import { PmxtError, fromServerError } from "./errors.js";
 import { LOCAL_URL, resolvePmxtBaseUrl } from "./constants.js";
 import { SidecarWsClient } from "./ws-client.js";
 
+interface RawWebSocketLike {
+    send(data: string): void;
+}
+
+interface SidecarWsClientInternals {
+    ensureConnected(): Promise<void>;
+    ws: RawWebSocketLike | null;
+    activeSubs: Map<string, string>;
+    subscriptions: Map<string, { reject: ((error: Error) => void) | null }>;
+    dataStore: Map<string, any>;
+}
+
 /**
  * Resolve a MarketOutcome shorthand to a plain outcome ID string.
  * Accepts either a raw string ID or a MarketOutcome object.
@@ -418,7 +430,7 @@ export abstract class Exchange {
      * 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.
+     * to be unavailable.
      */
     private async getOrCreateWs(): Promise<SidecarWsClient | null> {
         if (this._wsUnsupported) return null;
@@ -480,14 +492,79 @@ export abstract class Exchange {
                 this.getCredentials() as Record<string, any> | undefined,
             );
         } catch (error) {
-            // Only fall back to HTTP for transport-level failures
-            if (error instanceof PmxtError && /connection failed|no websocket/i.test(error.message)) {
+            if (this.isWsTransportUnavailableError(error)) {
                 return null;
             }
             throw error;
         }
     }
 
+    private wsTransportUnavailableError(method: string): PmxtError {
+        return new PmxtError(`${method}() requires WebSocket transport — connection failed`);
+    }
+
+    private isWsTransportUnavailableError(error: unknown): boolean {
+        return error instanceof PmxtError
+            && /connection failed|no websocket|websocket.*not connected/i.test(error.message);
+    }
+
+    private getWsInternals(ws: SidecarWsClient): SidecarWsClientInternals {
+        return ws as unknown as SidecarWsClientInternals;
+    }
+
+    private wsSubscriptionKey(method: string, args: any[]): string {
+        const firstArg = args[0] ?? "";
+        return Array.isArray(firstArg)
+            ? `${method}:${[...firstArg].sort().join(",")}`
+            : `${method}:${firstArg}`;
+    }
+
+    private getWsSubscriptionId(ws: SidecarWsClient, method: string, args: any[]): string | undefined {
+        const internals = this.getWsInternals(ws);
+        const subKey = this.wsSubscriptionKey(method, args);
+        return internals.activeSubs.get(subKey);
+    }
+
+    private clearWsSubscription(ws: SidecarWsClient, method: string, args: any[]): void {
+        const internals = this.getWsInternals(ws);
+        const subKey = this.wsSubscriptionKey(method, args);
+        const requestId = internals.activeSubs.get(subKey);
+        if (!requestId) return;
+
+        const sub = internals.subscriptions.get(requestId);
+        if (sub?.reject) {
+            sub.reject(new PmxtError(`${method} subscription cancelled`));
+        }
+
+        internals.activeSubs.delete(subKey);
+        internals.subscriptions.delete(requestId);
+        internals.dataStore.delete(requestId);
+
+        const firstArg = args[0] ?? "";
+        const symbols = Array.isArray(firstArg)
+            ? firstArg.map(String)
+            : firstArg
+                ? [String(firstArg)]
+                : [];
+        for (const symbol of symbols) {
+            internals.dataStore.delete(`${requestId}:${symbol}`);
+        }
+    }
+
+    private async sendWsMessage(
+        ws: SidecarWsClient,
+        message: Record<string, any>,
+    ): Promise<void> {
+        const internals = this.getWsInternals(ws);
+        await internals.ensureConnected();
+
+        const socket = internals.ws;
+        if (!socket) {
+            throw new PmxtError('[ws-client] Cannot send: WebSocket not connected');
+        }
+        socket.send(JSON.stringify(message));
+    }
+
     // Low-Level API Access
 
     /**
@@ -1122,24 +1199,32 @@ export abstract class Exchange {
 
     async unwatchOrderBook(outcomeId: string | MarketOutcome): Promise<void> {
         await this.initPromise;
+        const resolvedOutcomeId = resolveOutcomeId(outcomeId);
+        const args: any[] = [resolvedOutcomeId];
         try {
-            const args: any[] = [];
-            args.push(resolveOutcomeId(outcomeId));
-            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/unwatchOrderBook`, {
-                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 fromServerError(body.error);
-                }
-                throw new PmxtError(body.error?.message || response.statusText);
+            const ws = await this.getOrCreateWs();
+            if (!ws) {
+                throw this.wsTransportUnavailableError("unwatchOrderBook");
             }
-            const json = await response.json();
-            this.handleResponse(json);
+
+            const requestId = this.getWsSubscriptionId(ws, "watchOrderBook", args)
+                ?? `req-${Math.random().toString(36).slice(2, 14)}`;
+
+            await this.sendWsMessage(
+                ws,
+                {
+                    id: requestId,
+                    action: "unsubscribe",
+                    exchange: this.exchangeName,
+                    method: "unwatchOrderBook",
+                    args,
+                },
+            );
+            this.clearWsSubscription(ws, "watchOrderBook", args);
         } catch (error) {
+            if (this.isWsTransportUnavailableError(error)) {
+                throw this.wsTransportUnavailableError("unwatchOrderBook");
+            }
             if (error instanceof PmxtError) throw error;
             throw new PmxtError(`Failed to unwatchOrderBook: ${error}`);
         }
@@ -1545,33 +1630,12 @@ export abstract class Exchange {
             args.push(params);
         }
 
-        // Try WebSocket transport first
         const wsData = await this.watchViaWs("watchOrderBook", args);
         if (wsData !== null) {
             return convertOrderBook(wsData);
         }
 
-        // HTTP fallback
-        try {
-            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/watchOrderBook`, {
-                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 fromServerError(body.error);
-                }
-                throw new PmxtError(body.error?.message || response.statusText);
-            }
-            const json = await response.json();
-            const data = this.handleResponse(json);
-            return convertOrderBook(data);
-        } catch (error) {
-            if (error instanceof PmxtError) throw error;
-            throw new PmxtError(`Failed to watch order book: ${error}`);
-        }
+        throw this.wsTransportUnavailableError("watchOrderBook");
     }
 
     /**
@@ -1581,9 +1645,6 @@ export abstract class Exchange {
      * 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
      * @param params - Optional exchange-specific parameters
@@ -1618,61 +1679,33 @@ export abstract class Exchange {
             args.push(params);
         }
 
-        // Try WebSocket transport first
-        const ws = await this.getOrCreateWs();
-        if (ws) {
-            try {
-                const rawResult = await ws.subscribeBatch(
-                    this.exchangeName,
-                    "watchOrderBooks",
-                    args,
-                    this.getCredentials() as Record<string, any> | undefined,
-                );
-                if (rawResult && typeof rawResult === "object") {
-                    const result: Record<string, OrderBook> = {};
-                    for (const [k, v] of Object.entries(rawResult)) {
-                        if (v && typeof v === "object") {
-                            result[k] = convertOrderBook(v);
-                        }
-                    }
-                    return result;
-                }
-            } 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;
-                }
+        try {
+            const ws = await this.getOrCreateWs();
+            if (!ws) {
+                throw this.wsTransportUnavailableError("watchOrderBooks");
             }
-        }
 
-        // 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() }),
-                },
+            const rawResult = await ws.subscribeBatch(
+                this.exchangeName,
+                "watchOrderBooks",
+                args,
+                this.getCredentials() as Record<string, any> | undefined,
             );
-            if (!response.ok) {
-                const body = await response.json().catch(() => ({}));
-                if (body.error && typeof body.error === "object") {
-                    throw fromServerError(body.error);
-                }
-                throw new PmxtError(body.error?.message || response.statusText);
-            }
-            const json = await response.json();
-            const data = this.handleResponse(json);
-            if (data && typeof data === "object") {
+            if (rawResult && typeof rawResult === "object") {
                 const result: Record<string, OrderBook> = {};
-                for (const [k, v] of Object.entries(data as Record<string, any>)) {
-                    result[k] = convertOrderBook(v);
+                for (const [k, v] of Object.entries(rawResult)) {
+                    if (v && typeof v === "object") {
+                        result[k] = convertOrderBook(v);
+                    }
                 }
                 return result;
             }
+
             throw new PmxtError("watchOrderBooks: unexpected response shape from server");
         } catch (error) {
+            if (this.isWsTransportUnavailableError(error)) {
+                throw this.wsTransportUnavailableError("watchOrderBooks");
+            }
             if (error instanceof PmxtError) throw error;
             throw new PmxtError(`Failed to watch order books: ${error}`);
         }
@@ -1714,7 +1747,7 @@ export abstract class Exchange {
             };
         }
 
-        throw new PmxtError("watchAllOrderBooks() requires WebSocket transport — connection failed");
+        throw this.wsTransportUnavailableError("watchAllOrderBooks");
     }
 
     /** @deprecated Use {@link watchAllOrderBooks} instead. */
@@ -1753,37 +1786,23 @@ export abstract class Exchange {
     ): Promise<Trade[]> {
         await this.initPromise;
         const resolvedOutcomeId = resolveOutcomeId(outcomeId);
-        try {
-            const args: any[] = [resolvedOutcomeId];
-            if (address !== undefined) {
-                args.push(address);
-            }
-            if (since !== undefined) {
-                args.push(since);
-            }
-            if (limit !== undefined) {
-                args.push(limit);
-            }
+        const args: any[] = [resolvedOutcomeId];
+        if (address !== undefined) {
+            args.push(address);
+        }
+        if (since !== undefined) {
+            args.push(since);
+        }
+        if (limit !== undefined) {
+            args.push(limit);
+        }
 
-            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/watchTrades`, {
-                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 fromServerError(body.error);
-                }
-                throw new PmxtError(body.error?.message || response.statusText);
-            }
-            const json = await response.json();
-            const data = this.handleResponse(json);
-            return data.map(convertTrade);
-        } catch (error) {
-            if (error instanceof PmxtError) throw error;
-            throw new PmxtError(`Failed to watch trades: ${error}`);
+        const wsData = await this.watchViaWs("watchTrades", args);
+        if (wsData !== null) {
+            return wsData.map(convertTrade);
         }
+
+        throw this.wsTransportUnavailableError("watchTrades");
     }
 
     /**
@@ -2760,6 +2779,21 @@ export class Hyperliquid extends Exchange {
     }
 }
 
+/**
+ * SuiBets exchange client.
+ *
+ * @example
+ * ```typescript
+ * const suibets = new SuiBets();
+ * const markets = await suibets.fetchMarkets();
+ * ```
+ */
+export class SuiBets extends Exchange {
+    constructor(options: ExchangeOptions = {}) {
+        super("suibets", options);
+    }
+}
+
 /**
  * Mock exchange client.
  *

package/pmxt/router.ts

@@ -242,9 +242,9 @@ export class Router extends Exchange {
         const params = 'title' in marketOrParams ? { market: marketOrParams as UnifiedMarket } : marketOrParams;
         await this.initPromise;
         const query: Record<string, unknown> = {};
-        const marketId = params.marketId ?? params.market?.marketId;
+        const marketId = params.marketId ?? (!params.market?.slug ? params.market?.marketId : undefined);
         if (marketId) query.marketId = marketId;
-        if (params.slug) query.slug = params.slug;
+        if (params.slug ?? params.market?.slug) query.slug = params.slug ?? params.market?.slug;
         if (params.url) query.url = params.url;
         if (params.relation) query.relation = params.relation;
         if (params.minConfidence !== undefined) query.minConfidence = params.minConfidence;
@@ -255,6 +255,9 @@ export class Router extends Exchange {
             const json = await this.sidecarReadRequest('fetchMarketMatches', query, [query]);
             const data = this.handleResponse(json);
             if (!data) return [];
+            if (!Array.isArray(data)) {
+                throw new Error('fetchMarketMatches returned an unexpected response shape: expected an array');
+            }
             return (data as any[]).map(parseMatchResult);
         } catch (error) {
             if (error instanceof Error) throw error;
@@ -317,9 +320,9 @@ export class Router extends Exchange {
         const params = 'title' in eventOrParams && 'markets' in eventOrParams ? { event: eventOrParams as UnifiedEvent } : eventOrParams;
         await this.initPromise;
         const query: Record<string, unknown> = {};
-        const eventId = params.eventId ?? params.event?.id;
+        const eventId = params.eventId ?? (!params.event?.slug ? params.event?.id : undefined);
         if (eventId) query.eventId = eventId;
-        if (params.slug) query.slug = params.slug;
+        if (params.slug ?? params.event?.slug) query.slug = params.slug ?? params.event?.slug;
         if (params.relation) query.relation = params.relation;
         if (params.minConfidence !== undefined) query.minConfidence = params.minConfidence;
         if (params.limit !== undefined) query.limit = params.limit;
@@ -329,6 +332,9 @@ export class Router extends Exchange {
             const json = await this.sidecarReadRequest('fetchEventMatches', query, [query]);
             const data = this.handleResponse(json);
             if (!data) return [];
+            if (!Array.isArray(data)) {
+                throw new Error('fetchEventMatches returned an unexpected response shape: expected an array');
+            }
             return (data as any[]).map((entry) => {
                 const event = convertEvent(entry.event || {});
                 return {