pmxt-core 2.39.1 → 2.40.1

package/dist/exchanges/gemini-titan/utils.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMarketId = toMarketId;
+exports.fromMarketId = fromMarketId;
+exports.toOutcomeId = toOutcomeId;
+exports.fromOutcomeId = fromOutcomeId;
+exports.isGeminiInstrument = isGeminiInstrument;
+const config_1 = require("./config");
+/**
+ * Build a unique market ID from a Gemini instrumentSymbol.
+ * Format: "gemi-{instrumentSymbol}"
+ *
+ * A market encompasses both YES and NO sides of a single contract.
+ */
+function toMarketId(instrumentSymbol) {
+    return `gemi-${instrumentSymbol}`;
+}
+/**
+ * Extract the instrumentSymbol from our market ID format.
+ */
+function fromMarketId(marketId) {
+    const prefix = 'gemi-';
+    if (!marketId.startsWith(prefix)) {
+        throw new Error(`Invalid Gemini Titan market ID: ${marketId}`);
+    }
+    return marketId.slice(prefix.length);
+}
+/**
+ * Build an outcome ID that encodes both the instrumentSymbol and side.
+ * Format: "GEMI:{instrumentSymbol}:{side}"
+ *
+ * The side is needed because Gemini orders require an explicit
+ * "outcome" field ("yes" or "no").
+ */
+function toOutcomeId(instrumentSymbol, side) {
+    return `GEMI:${instrumentSymbol}:${side}`;
+}
+/**
+ * Decode an outcome ID back into instrumentSymbol and side.
+ */
+function fromOutcomeId(outcomeId) {
+    const parts = outcomeId.split(':');
+    if (parts.length !== 3 || parts[0] !== 'GEMI') {
+        throw new Error(`Invalid Gemini Titan outcome ID: ${outcomeId}`);
+    }
+    const side = parts[2];
+    if (side !== 'yes' && side !== 'no') {
+        throw new Error(`Invalid side in outcome ID: ${outcomeId}`);
+    }
+    return { instrumentSymbol: parts[1], side };
+}
+/**
+ * Check if a string looks like a Gemini prediction market instrument symbol.
+ */
+function isGeminiInstrument(symbol) {
+    return symbol.startsWith(config_1.INSTRUMENT_PREFIX);
+}

package/dist/exchanges/gemini-titan/websocket.d.ts

@@ -0,0 +1,46 @@
+import { OrderBook, Trade } from '../../types';
+import { GeminiAuth } from './auth';
+export interface GeminiWebSocketConfig {
+    wsUrl: string;
+    reconnectIntervalMs?: number;
+    watchTimeoutMs?: number;
+}
+/**
+ * Gemini Titan WebSocket for real-time order book and trade streaming.
+ *
+ * Subscribes to:
+ *   - {symbol}@depth20  (L2 partial depth snapshots at 1s intervals)
+ *   - {symbol}@trade    (executed trades)
+ *
+ * Auth headers are sent during the handshake if credentials are provided
+ * (needed for account-scoped streams, optional for public data).
+ */
+export declare class GeminiWebSocket {
+    private ws?;
+    private readonly auth;
+    private readonly config;
+    private readonly orderBookResolvers;
+    private readonly tradeResolvers;
+    private readonly orderBooks;
+    private readonly subscribedDepthSymbols;
+    private readonly subscribedTradeSymbols;
+    private messageIdCounter;
+    private isConnecting;
+    private isConnected;
+    private reconnectTimer?;
+    private connectionPromise?;
+    private isTerminated;
+    constructor(auth: GeminiAuth | undefined, config: GeminiWebSocketConfig);
+    private connect;
+    private scheduleReconnect;
+    private sendSubscribe;
+    private handleMessage;
+    private handleDepthSnapshot;
+    private handleDepthUpdate;
+    private applyDelta;
+    private handleTrade;
+    private resolveOrderBook;
+    watchOrderBook(symbol: string): Promise<OrderBook>;
+    watchTrades(symbol: string): Promise<Trade[]>;
+    close(): Promise<void>;
+}

package/dist/exchanges/gemini-titan/websocket.js

@@ -0,0 +1,295 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiWebSocket = void 0;
+const ws_1 = __importDefault(require("ws"));
+const watch_timeout_1 = require("../../utils/watch-timeout");
+/**
+ * Gemini Titan WebSocket for real-time order book and trade streaming.
+ *
+ * Subscribes to:
+ *   - {symbol}@depth20  (L2 partial depth snapshots at 1s intervals)
+ *   - {symbol}@trade    (executed trades)
+ *
+ * Auth headers are sent during the handshake if credentials are provided
+ * (needed for account-scoped streams, optional for public data).
+ */
+class GeminiWebSocket {
+    ws;
+    auth;
+    config;
+    orderBookResolvers = new Map();
+    tradeResolvers = new Map();
+    orderBooks = new Map();
+    subscribedDepthSymbols = new Set();
+    subscribedTradeSymbols = new Set();
+    messageIdCounter = 1;
+    isConnecting = false;
+    isConnected = false;
+    reconnectTimer;
+    connectionPromise;
+    isTerminated = false;
+    constructor(auth, config) {
+        this.auth = auth;
+        this.config = config;
+    }
+    // -------------------------------------------------------------------------
+    // Connection
+    // -------------------------------------------------------------------------
+    async connect() {
+        if (this.isConnected || this.isTerminated)
+            return;
+        if (this.connectionPromise)
+            return this.connectionPromise;
+        this.isConnecting = true;
+        this.connectionPromise = new Promise((resolve, reject) => {
+            try {
+                const headers = this.auth
+                    ? this.auth.buildWsHeaders()
+                    : {};
+                this.ws = new ws_1.default(this.config.wsUrl, { headers });
+                this.ws.on('open', () => {
+                    this.isConnected = true;
+                    this.isConnecting = false;
+                    this.connectionPromise = undefined;
+                    // Resubscribe on reconnect
+                    const allStreams = [];
+                    for (const sym of this.subscribedDepthSymbols) {
+                        allStreams.push(`${sym}@depth20`);
+                    }
+                    for (const sym of this.subscribedTradeSymbols) {
+                        allStreams.push(`${sym}@trade`);
+                    }
+                    if (allStreams.length > 0) {
+                        this.sendSubscribe(allStreams);
+                    }
+                    resolve();
+                });
+                this.ws.on('message', (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        this.handleMessage(message);
+                    }
+                    catch {
+                        // Ignore unparseable messages
+                    }
+                });
+                this.ws.on('error', (error) => {
+                    this.isConnecting = false;
+                    this.connectionPromise = undefined;
+                    reject(error);
+                });
+                this.ws.on('close', () => {
+                    this.isConnected = false;
+                    this.isConnecting = false;
+                    this.connectionPromise = undefined;
+                    if (!this.isTerminated) {
+                        this.scheduleReconnect();
+                    }
+                });
+            }
+            catch (error) {
+                this.isConnecting = false;
+                this.connectionPromise = undefined;
+                reject(error);
+            }
+        });
+        return this.connectionPromise;
+    }
+    scheduleReconnect() {
+        if (this.isTerminated)
+            return;
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = setTimeout(() => {
+            this.connect().catch((err) => {
+                console.warn(`[gemini-titan] reconnect failed: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }, this.config.reconnectIntervalMs ?? 5000);
+    }
+    // -------------------------------------------------------------------------
+    // Subscription
+    // -------------------------------------------------------------------------
+    sendSubscribe(streams) {
+        if (!this.ws || !this.isConnected)
+            return;
+        this.ws.send(JSON.stringify({
+            id: String(this.messageIdCounter++),
+            method: 'subscribe',
+            params: streams,
+        }));
+    }
+    // -------------------------------------------------------------------------
+    // Message handling
+    // -------------------------------------------------------------------------
+    handleMessage(message) {
+        // Gemini sends flat objects, NOT wrapped in { stream, data }.
+        // Depth snapshots: { lastUpdateId, symbol, bids, asks }
+        // Depth deltas:    { e, E, s, U, u, b, a }
+        // Trades:          { E, s, t, p, q, m }
+        // Confirmations:   { id, status: 200 }
+        if (message.lastUpdateId !== undefined && message.bids) {
+            // Depth snapshot — symbol comes back lowercase
+            this.handleDepthSnapshot(message);
+        }
+        else if (message.e === 'depthUpdate' || (message.U !== undefined && message.b)) {
+            this.handleDepthUpdate(message);
+        }
+        else if (message.t !== undefined && message.p !== undefined && message.q !== undefined) {
+            this.handleTrade(message);
+        }
+        // Subscription confirmations ({ id, status }) are ignored
+    }
+    handleDepthSnapshot(data) {
+        // symbol comes back lowercase from the API, but we subscribed with
+        // uppercase. Normalize to uppercase for resolver lookup.
+        const symbol = data.symbol.toUpperCase();
+        const bids = (data.bids ?? []).map((level) => ({
+            price: parseFloat(level[0]),
+            size: parseFloat(level[1]),
+        }));
+        const asks = (data.asks ?? []).map((level) => ({
+            price: parseFloat(level[0]),
+            size: parseFloat(level[1]),
+        }));
+        bids.sort((a, b) => b.price - a.price);
+        asks.sort((a, b) => a.price - b.price);
+        const orderBook = { bids, asks, timestamp: Date.now() };
+        this.orderBooks.set(symbol, orderBook);
+        this.resolveOrderBook(symbol, orderBook);
+    }
+    handleDepthUpdate(data) {
+        const symbol = data.s.toUpperCase();
+        const existing = this.orderBooks.get(symbol);
+        if (!existing)
+            return; // No snapshot yet, discard delta
+        for (const [priceStr, sizeStr] of (data.b ?? [])) {
+            this.applyDelta(existing.bids, parseFloat(priceStr), parseFloat(sizeStr), 'desc');
+        }
+        for (const [priceStr, sizeStr] of (data.a ?? [])) {
+            this.applyDelta(existing.asks, parseFloat(priceStr), parseFloat(sizeStr), 'asc');
+        }
+        existing.timestamp = Date.now();
+        this.resolveOrderBook(symbol, existing);
+    }
+    applyDelta(levels, price, size, sortOrder) {
+        const idx = levels.findIndex(l => Math.abs(l.price - price) < 0.0001);
+        if (size === 0) {
+            if (idx !== -1)
+                levels.splice(idx, 1);
+        }
+        else if (idx !== -1) {
+            levels[idx] = { price, size };
+        }
+        else {
+            levels.push({ price, size });
+            if (sortOrder === 'desc') {
+                levels.sort((a, b) => b.price - a.price);
+            }
+            else {
+                levels.sort((a, b) => a.price - b.price);
+            }
+        }
+    }
+    handleTrade(data) {
+        const symbol = data.s.toUpperCase();
+        const trade = {
+            id: String(data.t ?? Date.now()),
+            timestamp: data.E ? Math.floor(data.E / 1_000_000) : Date.now(), // E is nanoseconds
+            price: parseFloat(data.p),
+            amount: parseFloat(data.q),
+            side: data.m ? 'sell' : 'buy', // m = true means buyer is maker (taker sold)
+        };
+        const resolvers = this.tradeResolvers.get(symbol);
+        if (resolvers && resolvers.length > 0) {
+            resolvers.forEach(r => r.resolve([trade]));
+            this.tradeResolvers.set(symbol, []);
+        }
+    }
+    resolveOrderBook(symbol, orderBook) {
+        const resolvers = this.orderBookResolvers.get(symbol);
+        if (resolvers && resolvers.length > 0) {
+            resolvers.forEach(r => r.resolve(orderBook));
+            this.orderBookResolvers.set(symbol, []);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Public API
+    // -------------------------------------------------------------------------
+    async watchOrderBook(symbol) {
+        if (this.isTerminated) {
+            throw new Error(`WebSocket terminated, cannot watch ${symbol}`);
+        }
+        this.subscribedDepthSymbols.add(symbol);
+        if (!this.isConnected) {
+            this.connect().catch((err) => {
+                console.warn(`[gemini-titan] connect failed during watchOrderBook('${symbol}'): ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }
+        else {
+            this.sendSubscribe([`${symbol}@depth20`]);
+        }
+        const dataPromise = new Promise((resolve, reject) => {
+            if (!this.orderBookResolvers.has(symbol)) {
+                this.orderBookResolvers.set(symbol, []);
+            }
+            this.orderBookResolvers.get(symbol).push({ resolve, reject });
+        });
+        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchOrderBook('${symbol}')`);
+    }
+    async watchTrades(symbol) {
+        if (this.isTerminated) {
+            throw new Error(`WebSocket terminated, cannot watch trades for ${symbol}`);
+        }
+        this.subscribedTradeSymbols.add(symbol);
+        if (!this.isConnected) {
+            this.connect().catch((err) => {
+                console.warn(`[gemini-titan] connect failed during watchTrades('${symbol}'): ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }
+        else {
+            this.sendSubscribe([`${symbol}@trade`]);
+        }
+        const dataPromise = new Promise((resolve, reject) => {
+            if (!this.tradeResolvers.has(symbol)) {
+                this.tradeResolvers.set(symbol, []);
+            }
+            this.tradeResolvers.get(symbol).push({ resolve, reject });
+        });
+        return (0, watch_timeout_1.withWatchTimeout)(dataPromise, this.config.watchTimeoutMs ?? watch_timeout_1.DEFAULT_WATCH_TIMEOUT_MS, `watchTrades('${symbol}')`);
+    }
+    async close() {
+        this.isTerminated = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        for (const [symbol, resolvers] of this.orderBookResolvers) {
+            resolvers.forEach(r => r.reject(new Error(`WebSocket closed for ${symbol}`)));
+        }
+        this.orderBookResolvers.clear();
+        for (const [symbol, resolvers] of this.tradeResolvers) {
+            resolvers.forEach(r => r.reject(new Error(`WebSocket closed for ${symbol}`)));
+        }
+        this.tradeResolvers.clear();
+        if (this.ws) {
+            const ws = this.ws;
+            this.ws = undefined;
+            if (ws.readyState !== ws_1.default.CLOSED && ws.readyState !== ws_1.default.CLOSING) {
+                return new Promise((resolve) => {
+                    ws.once('close', () => {
+                        this.isConnected = false;
+                        this.isConnecting = false;
+                        resolve();
+                    });
+                    ws.close();
+                });
+            }
+        }
+        this.isConnected = false;
+        this.isConnecting = false;
+    }
+}
+exports.GeminiWebSocket = GeminiWebSocket;

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

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-05-08T20:51:55.489Z
+ * Generated at: 2026-05-08T23:06:00.095Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const kalshiApiSpec: {

package/dist/exchanges/kalshi/api.js

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

package/dist/exchanges/kalshi/fetcher.js

@@ -217,8 +217,12 @@ class KalshiFetcher {
                     event.tags = series.tags;
                 }
             }
-            catch {
-                // Non-critical
+            catch (err) {
+                // Non-critical — tags are enrichment only.
+                console.warn('[kalshi] series tag fetch failed', {
+                    series_ticker: event.series_ticker,
+                    error: err instanceof Error ? err.message : String(err),
+                });
             }
         }
         return [event];

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

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/limitless/Limitless.yaml
- * Generated at: 2026-05-08T20:51:55.531Z
+ * Generated at: 2026-05-08T23:06:00.134Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const limitlessApiSpec: {

package/dist/exchanges/limitless/api.js

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

package/dist/exchanges/limitless/index.js

@@ -273,8 +273,7 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
         const client = this.ensureClient();
         try {
             if (!marketId) {
-                console.warn('Limitless: fetchOpenOrders requires marketId (slug) to be efficient. Returning [].');
-                return [];
+                throw new Error('Limitless: fetchOpenOrders requires marketId (slug).');
             }
             const orders = await client.getOrders(marketId, ['LIVE']);
             return orders.map((o) => ({
@@ -298,8 +297,7 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
     async fetchClosedOrders(params) {
         const client = this.ensureClient();
         if (!params?.marketId) {
-            console.warn('Limitless: fetchClosedOrders requires marketId (slug). Returning [].');
-            return [];
+            throw new Error('Limitless: fetchClosedOrders requires marketId (slug).');
         }
         const orders = await client.getOrders(params.marketId, ['MATCHED']);
         return orders.map((o) => ({
@@ -319,8 +317,7 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
     async fetchAllOrders(params) {
         const client = this.ensureClient();
         if (!params?.marketId) {
-            console.warn('Limitless: fetchAllOrders requires marketId (slug). Returning [].');
-            return [];
+            throw new Error('Limitless: fetchAllOrders requires marketId (slug).');
         }
         const orders = await client.getOrders(params.marketId, ['LIVE', 'MATCHED']);
         return orders.map((o) => ({

package/dist/exchanges/limitless/utils.js

@@ -36,6 +36,13 @@ function mapMarketToUnified(market) {
             metadata: { clobTokenId: market.tokens.no },
         });
     }
+    // Limitless returns status='FUNDED' for active markets and expired=true
+    // when the market has ended. Map to the same canonical values Polymarket uses.
+    let status;
+    if (market.expired === true)
+        status = 'closed';
+    else if (market.status === 'FUNDED')
+        status = 'active';
     const um = {
         id: market.slug,
         marketId: market.slug,
@@ -52,7 +59,8 @@ function mapMarketToUnified(market) {
         url: `https://limitless.exchange/markets/${market.slug}`,
         image: market.logo || `https://limitless.exchange/api/og?slug=${market.slug}`,
         category: market.categories?.[0],
-        tags: market.tags || []
+        tags: market.tags || [],
+        status,
     };
     (0, market_utils_1.addBinaryOutcomes)(um);
     return um;

package/dist/exchanges/metaculus/fetchEvents.js

@@ -120,8 +120,13 @@ async function fetchEventBySlug(slug, callApi) {
             ];
         }
     }
-    catch {
-        // fall through
+    catch (err) {
+        // A 404 means this slug is not a known tournament — fall through to
+        // the next lookup strategy. Any other error (network, auth, etc.)
+        // is a real failure and must propagate.
+        if (!(err instanceof Error) || !('status' in err) || err.status !== 404) {
+            throw err;
+        }
     }
     // Finally try slug match against post.slug / post.url_title
     const posts = await fetchPostPages(callApi, { with_cp: true, order_by: "-forecasts_count" }, 500);

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

@@ -0,0 +1,55 @@
+import { EventFetchParams, MarketFetchParams, OHLCVParams, PredictionMarketExchange, TradesParams } from '../../BaseExchange';
+import { Balance, BuiltOrder, CreateOrderParams, Order, OrderBook, Position, PriceCandle, Trade, UnifiedEvent, UnifiedMarket, UserTrade } from '../../types';
+export interface MockExchangeOptions {
+    marketCount?: number;
+    balance?: number;
+    orderLatencyMs?: number;
+    limitOrderMode?: 'immediate' | 'resting';
+}
+export declare class MockExchange extends PredictionMarketExchange {
+    private readonly _marketCount;
+    private readonly _initialBalance;
+    private readonly _orderLatencyMs;
+    private readonly _limitOrderMode;
+    private _generatedMarkets?;
+    private _generatedEvents?;
+    private _freeCash;
+    private _ordSeq;
+    private _orders;
+    private _lockedByBuy;
+    private _positions;
+    private _myTrades;
+    constructor(options?: MockExchangeOptions);
+    get name(): string;
+    private _locked;
+    private _bookMidPrice;
+    private _generateMarket;
+    private _buildMarkets;
+    private _buildEvents;
+    protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
+    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    fetchOrderBook(id: string): Promise<OrderBook>;
+    fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
+    fetchTrades(id: string, _params: TradesParams): Promise<Trade[]>;
+    fetchBalance(_address?: string): Promise<Balance[]>;
+    fetchPositions(_address?: string): Promise<Position[]>;
+    private _nextOrderId;
+    private _setPosition;
+    private _pushTrade;
+    private _applyInstantFill;
+    private _placeRestingLimit;
+    createOrder(params: CreateOrderParams): Promise<Order>;
+    fillOrder(orderId: string, amount?: number): Promise<Order>;
+    cancelOrder(orderId: string): Promise<Order>;
+    fetchOrder(orderId: string): Promise<Order>;
+    fetchOpenOrders(_marketId?: string): Promise<Order[]>;
+    fetchMyTrades(_params?: {
+        outcomeId?: string;
+        marketId?: string;
+    }): Promise<UserTrade[]>;
+    fetchClosedOrders(): Promise<Order[]>;
+    fetchAllOrders(): Promise<Order[]>;
+    buildOrder(params: CreateOrderParams): Promise<BuiltOrder>;
+    submitOrder(built: BuiltOrder): Promise<Order>;
+    reset(): void;
+}