pmxtjs 2.42.7 → 2.43.1

package/generated/src/models/OrderBook.ts

@@ -45,6 +45,12 @@ export interface OrderBook {
      * @memberof OrderBook
      */
     timestamp?: number;
+    /**
+     * ISO 8601 datetime string of the snapshot (CCXT-compatible).
+     * @type {string}
+     * @memberof OrderBook
+     */
+    datetime?: string;
 }
 
 /**
@@ -69,6 +75,7 @@ export function OrderBookFromJSONTyped(json: any, ignoreDiscriminator: boolean):
         'bids': ((json['bids'] as Array<any>).map(OrderLevelFromJSON)),
         'asks': ((json['asks'] as Array<any>).map(OrderLevelFromJSON)),
         'timestamp': json['timestamp'] == null ? undefined : json['timestamp'],
+        'datetime': json['datetime'] == null ? undefined : json['datetime'],
     };
 }
 
@@ -86,6 +93,7 @@ export function OrderBookToJSONTyped(value?: OrderBook | null, ignoreDiscriminat
         'bids': ((value['bids'] as Array<any>).map(OrderLevelToJSON)),
         'asks': ((value['asks'] as Array<any>).map(OrderLevelToJSON)),
         'timestamp': value['timestamp'],
+        'datetime': value['datetime'],
     };
 }
 

package/generated/src/models/index.ts

@@ -56,6 +56,8 @@ export * from './FetchMyTrades200Response';
 export * from './FetchOHLCV200Response';
 export * from './FetchOpenOrders200Response';
 export * from './FetchOrderBook200Response';
+export * from './FetchOrderBooks200Response';
+export * from './FetchOrderBooksRequest';
 export * from './FetchPositions200Response';
 export * from './FetchTrades200Response';
 export * from './FilterEventsRequest';

package/index.ts

@@ -19,13 +19,13 @@
  */
 
 
-import { Exchange, Polymarket, Kalshi, KalshiDemo, Limitless, Myriad, Probable, Baozi, Opinion, Metaculus, Smarkets, PolymarketUS } from "./pmxt/client.js";
+import { Exchange, Polymarket, Kalshi, KalshiDemo, Limitless, Myriad, Probable, Baozi, Opinion, Metaculus, Smarkets, PolymarketUS, GeminiTitan, Hyperliquid, Mock } from "./pmxt/client.js";
 import { Router } from "./pmxt/router.js";
 import { ServerManager } from "./pmxt/server-manager.js";
 import * as models from "./pmxt/models.js";
 import * as errors from "./pmxt/errors.js";
 
-export { Exchange, Polymarket, Kalshi, KalshiDemo, Limitless, Myriad, Probable, Baozi, Opinion, Metaculus, Smarkets, PolymarketUS, PolymarketOptions } from "./pmxt/client.js";
+export { Exchange, Polymarket, Kalshi, KalshiDemo, Limitless, Myriad, Probable, Baozi, Opinion, Metaculus, Smarkets, PolymarketUS, GeminiTitan, Hyperliquid, Mock, PolymarketOptions } from "./pmxt/client.js";
 export { Router } from "./pmxt/router.js";
 export { ServerManager } from "./pmxt/server-manager.js";
 export { MarketList } from "./pmxt/models.js";
@@ -79,6 +79,9 @@ const pmxt = {
     Metaculus,
     Smarkets,
     PolymarketUS,
+    GeminiTitan,
+    Hyperliquid,
+    Mock,
     Router,
     ServerManager,
     server,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmxtjs",
-  "version": "2.42.7",
+  "version": "2.43.1",
   "description": "Unified prediction market data API - The ccxt for prediction markets",
   "author": "PMXT Contributors",
   "repository": {
@@ -43,7 +43,7 @@
     "unified"
   ],
   "dependencies": {
-    "pmxt-core": "2.42.7",
+    "pmxt-core": "2.43.1",
     "ws": "^8.18.0"
   },
   "devDependencies": {

package/pmxt/client.ts

@@ -1,6 +1,6 @@
 /**
  * Exchange client implementations.
- * 
+ *
  * This module provides clean, TypeScript-friendly wrappers around the auto-generated
  * OpenAPI client, matching the Python API exactly.
  */
@@ -214,7 +214,7 @@ export interface ExchangeOptions {
 
 /**
  * Base class for prediction market exchanges.
- * 
+ *
  * This provides a unified interface for interacting with different
  * prediction market platforms (Polymarket, Kalshi, etc.).
  */
@@ -766,12 +766,16 @@ export abstract class Exchange {
         }
     }
 
-    async fetchOrderBook(outcomeId: string | MarketOutcome, side?: any): Promise<OrderBook> {
+    async fetchOrderBook(outcomeId: string | MarketOutcome, limit?: number, params?: Record<string, any>): Promise<OrderBook | OrderBook[]> {
         await this.initPromise;
         try {
             const args: any[] = [];
             args.push(resolveOutcomeId(outcomeId));
-            if (side !== undefined) args.push(side);
+            if (limit !== undefined) args.push(limit);
+            if (params !== undefined) {
+                if (limit === undefined) args.push(null);
+                args.push(params);
+            }
             const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchOrderBook`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json', ...this.getAuthHeaders() },
@@ -786,6 +790,9 @@ export abstract class Exchange {
             }
             const json = await response.json();
             const data = this.handleResponse(json);
+            if (Array.isArray(data)) {
+                return data.map(convertOrderBook);
+            }
             return convertOrderBook(data);
         } catch (error) {
             if (error instanceof PmxtError) throw error;
@@ -793,6 +800,36 @@ export abstract class Exchange {
         }
     }
 
+    async fetchOrderBooks(outcomeIds: (string | MarketOutcome)[]): Promise<Record<string, OrderBook>> {
+        await this.initPromise;
+        try {
+            const args: any[] = [];
+            args.push(outcomeIds.map(resolveOutcomeId));
+            const response = await this.fetchWithRetry(`${this.resolveBaseUrl()}/api/${this.exchangeName}/fetchOrderBooks`, {
+                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);
+            const result: Record<string, OrderBook> = {};
+            for (const [key, value] of Object.entries(data as any)) {
+                result[key] = convertOrderBook(value);
+            }
+            return result;
+        } catch (error) {
+            if (error instanceof PmxtError) throw error;
+            throw new PmxtError(`Failed to fetchOrderBooks: ${error}`);
+        }
+    }
+
     async submitOrder(built: BuiltOrder): Promise<Order> {
         await this.initPromise;
         try {
@@ -1359,7 +1396,7 @@ export abstract class Exchange {
      * @param outcomeId - Outcome ID (from market.outcomes[].outcomeId)
      * @param params - History filter parameters
      * @returns List of price candles
-     * 
+     *
      * @example
      * ```typescript
      * const markets = await exchange.fetchMarkets({ query: "Trump" });
@@ -1444,14 +1481,15 @@ export abstract class Exchange {
 
     /**
      * Watch real-time order book updates via WebSocket.
-     * 
+     *
      * Returns a promise that resolves with the next order book update.
      * Call repeatedly in a loop to stream updates (CCXT Pro pattern).
-     * 
+     *
      * @param outcomeId - Outcome ID to watch
      * @param limit - Optional depth limit for order book
+     * @param params - Optional exchange-specific parameters
      * @returns Next order book update
-     * 
+     *
      * @example
      * ```typescript
      * // Stream order book updates
@@ -1462,13 +1500,19 @@ export abstract class Exchange {
      * }
      * ```
      */
-    async watchOrderBook(outcomeId: string | MarketOutcome, limit?: number): Promise<OrderBook> {
+    async watchOrderBook(outcomeId: string | MarketOutcome, limit?: number, params: Record<string, any> = {}): Promise<OrderBook> {
         await this.initPromise;
         const resolvedOutcomeId = resolveOutcomeId(outcomeId);
         const args: any[] = [resolvedOutcomeId];
         if (limit !== undefined) {
             args.push(limit);
         }
+        if (Object.keys(params).length > 0) {
+            if (limit === undefined) {
+                args.push(undefined);
+            }
+            args.push(params);
+        }
 
         // Try WebSocket transport first
         const wsData = await this.watchViaWs("watchOrderBook", args);
@@ -1511,6 +1555,7 @@ export abstract class Exchange {
      *
      * @param outcomeIds - Array of outcome IDs (or MarketOutcome objects)
      * @param limit - Optional depth limit for each order book
+     * @param params - Optional exchange-specific parameters
      * @returns Record mapping ticker to OrderBook
      *
      * @example
@@ -1527,6 +1572,7 @@ export abstract class Exchange {
     async watchOrderBooks(
         outcomeIds: (string | MarketOutcome)[],
         limit?: number,
+        params: Record<string, any> = {},
     ): Promise<Record<string, OrderBook>> {
         await this.initPromise;
         const resolvedIds = outcomeIds.map(resolveOutcomeId);
@@ -1534,6 +1580,12 @@ export abstract class Exchange {
         if (limit !== undefined) {
             args.push(limit);
         }
+        if (Object.keys(params).length > 0) {
+            if (limit === undefined) {
+                args.push(undefined);
+            }
+            args.push(params);
+        }
 
         // Try WebSocket transport first
         const ws = await this.getOrCreateWs();
@@ -2009,7 +2061,7 @@ export abstract class Exchange {
     /**
      * Calculate the average execution price for a given amount by walking the order book.
      * Uses the sidecar server for calculation to ensure consistency.
-     * 
+     *
      * @param orderBook - The current order book
      * @param side - 'buy' or 'sell'
      * @param amount - The amount to execute
@@ -2023,7 +2075,7 @@ export abstract class Exchange {
     /**
      * Calculate detailed execution price information.
      * Uses the sidecar server for calculation to ensure consistency.
-     * 
+     *
      * @param orderBook - The current order book
      * @param side - 'buy' or 'sell'
      * @param amount - The amount to execute
@@ -2614,3 +2666,51 @@ export class PolymarketUS extends Exchange {
         super("polymarket_us", options);
     }
 }
+
+/**
+ * Gemini Titan exchange client.
+ *
+ * @example
+ * ```typescript
+ * const titan = new GeminiTitan();
+ * const markets = await titan.fetchMarkets();
+ * ```
+ */
+export class GeminiTitan extends Exchange {
+    constructor(options: ExchangeOptions = {}) {
+        super("gemini-titan", options);
+    }
+}
+
+/**
+ * Hyperliquid exchange client.
+ *
+ * @example
+ * ```typescript
+ * const hl = new Hyperliquid();
+ * const markets = await hl.fetchMarkets();
+ * ```
+ */
+export class Hyperliquid extends Exchange {
+    constructor(options: ExchangeOptions = {}) {
+        super("hyperliquid", options);
+    }
+}
+
+/**
+ * Mock exchange client.
+ *
+ * Offline deterministic exchange for testing and development.
+ * No credentials required.
+ *
+ * @example
+ * ```typescript
+ * const mock = new Mock();
+ * const markets = await mock.fetchMarkets();
+ * ```
+ */
+export class Mock extends Exchange {
+    constructor(options: ExchangeOptions = {}) {
+        super("mock", options);
+    }
+}

package/pmxt/models.ts

@@ -140,7 +140,7 @@ export interface OrderLevel {
 }
 
 /**
- * Current order book for an outcome.
+ * Order book for an outcome.
  */
 export interface OrderBook {
     /** Bid orders (sorted high to low) */
@@ -151,6 +151,9 @@ export interface OrderBook {
 
     /** Unix timestamp (milliseconds) */
     timestamp?: number;
+
+    /** ISO 8601 datetime string of the snapshot (CCXT-compatible) */
+    datetime?: string;
 }
 
 /**