pmxt-core 2.21.2 → 2.22.0

package/dist/exchanges/opinion/utils.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPINION_ORDER_STATUS = exports.OPINION_MARKET_STATUS = void 0;
+exports.mapStatusToOpinion = mapStatusToOpinion;
+exports.mapSortToOpinion = mapSortToOpinion;
+exports.mapIntervalToOpinion = mapIntervalToOpinion;
+exports.mapOrderStatus = mapOrderStatus;
+exports.parseNumStr = parseNumStr;
+exports.toMillis = toMillis;
+exports.intervalToMs = intervalToMs;
+// Opinion market status codes
+exports.OPINION_MARKET_STATUS = {
+    CREATED: 1,
+    ACTIVATED: 2,
+    RESOLVING: 3,
+    RESOLVED: 4,
+    FAILED: 5,
+    DELETED: 6,
+};
+// Opinion order status codes
+exports.OPINION_ORDER_STATUS = {
+    PENDING: 1,
+    FILLED: 2,
+    CANCELED: 3,
+    EXPIRED: 4,
+    FAILED: 5,
+};
+// Map pmxt status strings to Opinion API status filter values
+function mapStatusToOpinion(status) {
+    switch (status) {
+        case 'active': return 'activated';
+        case 'closed':
+        case 'inactive': return 'resolved';
+        default: return undefined; // 'all' -> no filter
+    }
+}
+// Map pmxt sort to Opinion sortBy integer
+function mapSortToOpinion(sort) {
+    switch (sort) {
+        case 'volume': return 5; // volume24h desc
+        case 'liquidity': return 3; // volume desc (closest proxy)
+        case 'newest': return 1; // new
+        default: return undefined;
+    }
+}
+// Map pmxt CandleInterval to Opinion interval string.
+// Opinion supports: 1m, 1h, 1d, 1w, max
+function mapIntervalToOpinion(interval) {
+    const mapping = {
+        '1m': '1m',
+        '5m': '1m', // closest available
+        '15m': '1h', // closest available
+        '1h': '1h',
+        '6h': '1d', // closest available
+        '1d': '1d',
+    };
+    return mapping[interval];
+}
+// Map Opinion order status code to pmxt status string
+function mapOrderStatus(status) {
+    switch (status) {
+        case exports.OPINION_ORDER_STATUS.PENDING: return 'pending';
+        case exports.OPINION_ORDER_STATUS.FILLED: return 'filled';
+        case exports.OPINION_ORDER_STATUS.CANCELED: return 'cancelled';
+        case exports.OPINION_ORDER_STATUS.EXPIRED: return 'cancelled'; // expired -> cancelled
+        case exports.OPINION_ORDER_STATUS.FAILED: return 'rejected'; // failed -> rejected
+        default: return 'pending';
+    }
+}
+// Parse string number safely, returning 0 for invalid/empty
+function parseNumStr(value) {
+    if (!value)
+        return 0;
+    const parsed = parseFloat(value);
+    return isNaN(parsed) ? 0 : parsed;
+}
+// Convert a raw timestamp to milliseconds.
+// If the value is under 10_000_000_000 it is assumed to be in seconds.
+function toMillis(ts) {
+    if (!ts)
+        return 0;
+    return ts < 10_000_000_000 ? ts * 1000 : ts;
+}
+// Return the bucket size in milliseconds for a given CandleInterval
+function intervalToMs(interval) {
+    const map = {
+        '1m': 60_000,
+        '5m': 300_000,
+        '15m': 900_000,
+        '1h': 3_600_000,
+        '6h': 21_600_000,
+        '1d': 86_400_000,
+    };
+    return map[interval];
+}

package/dist/exchanges/opinion/websocket.d.ts

@@ -0,0 +1,83 @@
+import { OrderBook, Trade } from "../../types";
+export interface OpinionWebSocketConfig {
+    /** Reconnection interval in milliseconds (default: 5000) */
+    reconnectIntervalMs?: number;
+}
+/**
+ * Opinion Trade WebSocket implementation for real-time order book and trade streaming.
+ * Follows CCXT Pro-style async iterator pattern.
+ *
+ * Connection: wss://ws.opinion.trade?apikey={API_KEY}
+ * Channels: market.depth.diff, market.last.trade
+ */
+export declare class OpinionWebSocket {
+    private ws?;
+    private readonly wsUrl;
+    private readonly config;
+    private readonly orderBookResolvers;
+    private readonly tradeResolvers;
+    private readonly orderBooks;
+    private readonly subscribedDepthMarketIds;
+    private readonly subscribedTradeMarketIds;
+    private isConnecting;
+    private isConnected;
+    private isTerminated;
+    private reconnectTimer?;
+    private connectionPromise?;
+    constructor(wsUrl: string, config?: OpinionWebSocketConfig);
+    private connect;
+    private scheduleReconnect;
+    private resubscribeAll;
+    private sendSubscribe;
+    private sendUnsubscribe;
+    private handleMessage;
+    /**
+     * Handle an incremental orderbook update from Opinion.
+     *
+     * Example message:
+     * {
+     *   "marketId": 2764,
+     *   "tokenId": "191204...",
+     *   "outcomeSide": 1,
+     *   "side": "bids",
+     *   "price": "0.2",
+     *   "size": "50",
+     *   "msgType": "market.depth.diff"
+     * }
+     *
+     * `side` is "bids" or "asks".
+     * `size` is the new absolute size at that price level (0 means remove).
+     */
+    private handleDepthDiff;
+    private resolveOrderBook;
+    /**
+     * Handle a last-trade message from Opinion.
+     *
+     * Example message:
+     * {
+     *   "tokenId": "191204...",
+     *   "side": "Buy",
+     *   "outcomeSide": 1,
+     *   "price": "0.85",
+     *   "shares": "10",
+     *   "amount": "8.5",
+     *   "marketId": 2764,
+     *   "msgType": "market.last.trade"
+     * }
+     */
+    private handleLastTrade;
+    /**
+     * Watch orderbook updates for a given binary market.
+     * Returns a promise that resolves on the next orderbook update.
+     */
+    watchOrderBook(marketId: number): Promise<OrderBook>;
+    /**
+     * Watch trade updates for a given binary market.
+     * Returns a promise that resolves on the next trade.
+     */
+    watchTrades(marketId: number): Promise<Trade[]>;
+    /**
+     * Close the WebSocket connection and reject all pending promises.
+     */
+    close(): Promise<void>;
+}

package/dist/exchanges/opinion/websocket.js

@@ -0,0 +1,365 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpinionWebSocket = void 0;
+const ws_1 = __importDefault(require("ws"));
+/**
+ * Opinion Trade WebSocket implementation for real-time order book and trade streaming.
+ * Follows CCXT Pro-style async iterator pattern.
+ *
+ * Connection: wss://ws.opinion.trade?apikey={API_KEY}
+ * Channels: market.depth.diff, market.last.trade
+ */
+class OpinionWebSocket {
+    ws;
+    wsUrl;
+    config;
+    orderBookResolvers = new Map();
+    tradeResolvers = new Map();
+    orderBooks = new Map();
+    subscribedDepthMarketIds = new Set();
+    subscribedTradeMarketIds = new Set();
+    isConnecting = false;
+    isConnected = false;
+    isTerminated = false;
+    reconnectTimer;
+    connectionPromise;
+    constructor(wsUrl, config = {}) {
+        this.wsUrl = wsUrl;
+        this.config = config;
+    }
+    // ---------------------------------------------------------------------------
+    // Connection management
+    // ---------------------------------------------------------------------------
+    async connect() {
+        if (this.isConnected) {
+            return;
+        }
+        if (this.isTerminated) {
+            return;
+        }
+        if (this.connectionPromise) {
+            return this.connectionPromise;
+        }
+        this.isConnecting = true;
+        this.connectionPromise = new Promise((resolve, reject) => {
+            try {
+                this.ws = new ws_1.default(this.wsUrl);
+                this.ws.on("open", () => {
+                    this.isConnected = true;
+                    this.isConnecting = false;
+                    this.connectionPromise = undefined;
+                    console.log("Opinion WebSocket connected");
+                    this.resubscribeAll();
+                    resolve();
+                });
+                this.ws.on("message", (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        this.handleMessage(message);
+                    }
+                    catch (error) {
+                        console.error("Error parsing Opinion WebSocket message:", error);
+                    }
+                });
+                this.ws.on("error", (error) => {
+                    console.error("Opinion WebSocket error:", error);
+                    this.isConnecting = false;
+                    this.connectionPromise = undefined;
+                    reject(error);
+                });
+                this.ws.on("close", () => {
+                    if (!this.isTerminated) {
+                        console.log("Opinion WebSocket closed, scheduling reconnect");
+                        this.scheduleReconnect();
+                    }
+                    this.isConnected = false;
+                    this.isConnecting = false;
+                    this.connectionPromise = undefined;
+                });
+            }
+            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(() => {
+            console.log("Attempting to reconnect Opinion WebSocket...");
+            this.connect().catch(console.error);
+        }, this.config.reconnectIntervalMs ?? 5000);
+    }
+    resubscribeAll() {
+        for (const marketId of this.subscribedDepthMarketIds) {
+            this.sendSubscribe("market.depth.diff", marketId);
+        }
+        for (const marketId of this.subscribedTradeMarketIds) {
+            this.sendSubscribe("market.last.trade", marketId);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Subscribe / Unsubscribe
+    // ---------------------------------------------------------------------------
+    sendSubscribe(channel, marketId) {
+        if (!this.ws || !this.isConnected) {
+            return;
+        }
+        this.ws.send(JSON.stringify({ action: "SUBSCRIBE", channel, marketId }));
+    }
+    sendUnsubscribe(channel, marketId) {
+        if (!this.ws || !this.isConnected) {
+            return;
+        }
+        this.ws.send(JSON.stringify({ action: "UNSUBSCRIBE", channel, marketId }));
+    }
+    // ---------------------------------------------------------------------------
+    // Message handling
+    // ---------------------------------------------------------------------------
+    handleMessage(message) {
+        const msgType = message.msgType;
+        if (!msgType) {
+            // Could be a subscription confirmation or unknown payload
+            return;
+        }
+        switch (msgType) {
+            case "market.depth.diff":
+                this.handleDepthDiff(message);
+                break;
+            case "market.last.trade":
+                this.handleLastTrade(message);
+                break;
+            default:
+                // Ignore unknown message types
+                break;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Orderbook depth diff
+    // ---------------------------------------------------------------------------
+    /**
+     * Handle an incremental orderbook update from Opinion.
+     *
+     * Example message:
+     * {
+     *   "marketId": 2764,
+     *   "tokenId": "191204...",
+     *   "outcomeSide": 1,
+     *   "side": "bids",
+     *   "price": "0.2",
+     *   "size": "50",
+     *   "msgType": "market.depth.diff"
+     * }
+     *
+     * `side` is "bids" or "asks".
+     * `size` is the new absolute size at that price level (0 means remove).
+     */
+    handleDepthDiff(data) {
+        const marketId = data.marketId;
+        if (marketId === undefined) {
+            return;
+        }
+        const price = parseFloat(data.price);
+        const size = parseFloat(data.size);
+        const side = data.side; // "bids" | "asks"
+        if (isNaN(price)) {
+            return;
+        }
+        const existing = this.orderBooks.get(marketId);
+        const book = existing
+            ? { ...existing }
+            : { bids: [], asks: [], timestamp: Date.now() };
+        if (side === "bids") {
+            book.bids = applyLevelUpdate(book.bids, price, size, "desc");
+        }
+        else if (side === "asks") {
+            book.asks = applyLevelUpdate(book.asks, price, size, "asc");
+        }
+        book.timestamp = Date.now();
+        this.orderBooks.set(marketId, book);
+        this.resolveOrderBook(marketId, book);
+    }
+    resolveOrderBook(marketId, orderBook) {
+        const resolvers = this.orderBookResolvers.get(marketId);
+        if (resolvers && resolvers.length > 0) {
+            const snapshot = {
+                bids: [...orderBook.bids],
+                asks: [...orderBook.asks],
+                timestamp: orderBook.timestamp,
+            };
+            resolvers.forEach((r) => r.resolve(snapshot));
+            this.orderBookResolvers.set(marketId, []);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Trade stream
+    // ---------------------------------------------------------------------------
+    /**
+     * Handle a last-trade message from Opinion.
+     *
+     * Example message:
+     * {
+     *   "tokenId": "191204...",
+     *   "side": "Buy",
+     *   "outcomeSide": 1,
+     *   "price": "0.85",
+     *   "shares": "10",
+     *   "amount": "8.5",
+     *   "marketId": 2764,
+     *   "msgType": "market.last.trade"
+     * }
+     */
+    handleLastTrade(data) {
+        const marketId = data.marketId;
+        if (marketId === undefined) {
+            return;
+        }
+        const timestamp = Date.now();
+        const price = parseFloat(data.price);
+        const shares = parseFloat(data.shares);
+        const trade = {
+            id: `${timestamp}-${Math.random().toString(36).slice(2, 10)}`,
+            timestamp,
+            price: isNaN(price) ? 0 : price,
+            amount: isNaN(shares) ? 0 : shares,
+            side: mapTradeSide(data.side),
+        };
+        const resolvers = this.tradeResolvers.get(marketId);
+        if (resolvers && resolvers.length > 0) {
+            resolvers.forEach((r) => r.resolve([trade]));
+            this.tradeResolvers.set(marketId, []);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Public API
+    // ---------------------------------------------------------------------------
+    /**
+     * Watch orderbook updates for a given binary market.
+     * Returns a promise that resolves on the next orderbook update.
+     */
+    async watchOrderBook(marketId) {
+        if (!this.isConnected) {
+            await this.connect();
+        }
+        if (!this.subscribedDepthMarketIds.has(marketId)) {
+            this.subscribedDepthMarketIds.add(marketId);
+            this.sendSubscribe("market.depth.diff", marketId);
+        }
+        return new Promise((resolve, reject) => {
+            if (!this.orderBookResolvers.has(marketId)) {
+                this.orderBookResolvers.set(marketId, []);
+            }
+            this.orderBookResolvers.get(marketId).push({ resolve, reject });
+        });
+    }
+    /**
+     * Watch trade updates for a given binary market.
+     * Returns a promise that resolves on the next trade.
+     */
+    async watchTrades(marketId) {
+        if (!this.isConnected) {
+            await this.connect();
+        }
+        if (!this.subscribedTradeMarketIds.has(marketId)) {
+            this.subscribedTradeMarketIds.add(marketId);
+            this.sendSubscribe("market.last.trade", marketId);
+        }
+        return new Promise((resolve, reject) => {
+            if (!this.tradeResolvers.has(marketId)) {
+                this.tradeResolvers.set(marketId, []);
+            }
+            this.tradeResolvers.get(marketId).push({ resolve, reject });
+        });
+    }
+    /**
+     * Close the WebSocket connection and reject all pending promises.
+     */
+    async close() {
+        this.isTerminated = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        // Unsubscribe from all channels before closing
+        for (const marketId of this.subscribedDepthMarketIds) {
+            this.sendUnsubscribe("market.depth.diff", marketId);
+        }
+        for (const marketId of this.subscribedTradeMarketIds) {
+            this.sendUnsubscribe("market.last.trade", marketId);
+        }
+        // Reject all pending resolvers
+        this.orderBookResolvers.forEach((resolvers, marketId) => {
+            resolvers.forEach((r) => r.reject(new Error(`WebSocket closed for market ${marketId}`)));
+        });
+        this.orderBookResolvers.clear();
+        this.tradeResolvers.forEach((resolvers, marketId) => {
+            resolvers.forEach((r) => r.reject(new Error(`WebSocket closed for market ${marketId}`)));
+        });
+        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.OpinionWebSocket = OpinionWebSocket;
+// ---------------------------------------------------------------------------
+// Pure helpers (module-private)
+// ---------------------------------------------------------------------------
+/**
+ * Apply an absolute-size level update to one side of the book.
+ * A size of 0 (or NaN) removes the level. Returns a new sorted array.
+ */
+function applyLevelUpdate(levels, price, size, sortOrder) {
+    const updated = levels.filter((l) => Math.abs(l.price - price) >= 0.0001);
+    if (!isNaN(size) && size > 0) {
+        updated.push({ price, size });
+    }
+    if (sortOrder === "desc") {
+        updated.sort((a, b) => b.price - a.price);
+    }
+    else {
+        updated.sort((a, b) => a.price - b.price);
+    }
+    return updated;
+}
+/**
+ * Map Opinion's trade side string to our unified type.
+ * Opinion uses "Buy" | "Sell" | "Split" | "Merge".
+ */
+function mapTradeSide(side) {
+    if (!side) {
+        return "unknown";
+    }
+    const lower = side.toLowerCase();
+    if (lower === "buy") {
+        return "buy";
+    }
+    if (lower === "sell") {
+        return "sell";
+    }
+    return "unknown";
+}

package/dist/exchanges/polymarket/api-clob.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-03-20T15:55:56.059Z
+ * Generated at: 2026-03-22T18:41:21.601Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketClobSpec: {

package/dist/exchanges/polymarket/api-clob.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketClobSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-03-20T15:55:56.059Z
+ * Generated at: 2026-03-22T18:41:21.601Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketClobSpec = {

package/dist/exchanges/polymarket/api-data.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-03-20T15:55:56.078Z
+ * Generated at: 2026-03-22T18:41:21.621Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketDataSpec: {

package/dist/exchanges/polymarket/api-data.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketDataSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-03-20T15:55:56.078Z
+ * Generated at: 2026-03-22T18:41:21.621Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketDataSpec = {

package/dist/exchanges/polymarket/api-gamma.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-03-20T15:55:56.075Z
+ * Generated at: 2026-03-22T18:41:21.617Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketGammaSpec: {

package/dist/exchanges/polymarket/api-gamma.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketGammaSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-03-20T15:55:56.075Z
+ * Generated at: 2026-03-22T18:41:21.617Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketGammaSpec = {

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

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-03-20T15:55:56.113Z
+ * Generated at: 2026-03-22T18:41:21.653Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const probableApiSpec: {

package/dist/exchanges/probable/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.probableApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-03-20T15:55:56.113Z
+ * Generated at: 2026-03-22T18:41:21.653Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.probableApiSpec = {

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export * from './exchanges/kalshi-demo';
 export * from './exchanges/probable';
 export * from './exchanges/baozi';
 export * from './exchanges/myriad';
+export * from './exchanges/opinion';
 export * from './server/app';
 export * from './server/utils/port-manager';
 export * from './server/utils/lock-file';
@@ -20,6 +21,7 @@ import { KalshiDemoExchange } from './exchanges/kalshi-demo';
 import { ProbableExchange } from './exchanges/probable';
 import { BaoziExchange } from './exchanges/baozi';
 import { MyriadExchange } from './exchanges/myriad';
+import { OpinionExchange } from './exchanges/opinion';
 declare const pmxt: {
     Polymarket: typeof PolymarketExchange;
     Limitless: typeof LimitlessExchange;
@@ -28,6 +30,7 @@ declare const pmxt: {
     Probable: typeof ProbableExchange;
     Baozi: typeof BaoziExchange;
     Myriad: typeof MyriadExchange;
+    Opinion: typeof OpinionExchange;
 };
 export declare const Polymarket: typeof PolymarketExchange;
 export declare const Limitless: typeof LimitlessExchange;
@@ -36,4 +39,5 @@ export declare const KalshiDemo: typeof KalshiDemoExchange;
 export declare const Probable: typeof ProbableExchange;
 export declare const Baozi: typeof BaoziExchange;
 export declare const Myriad: typeof MyriadExchange;
+export declare const Opinion: typeof OpinionExchange;
 export default pmxt;