pmxt-core 2.44.6 → 2.45.0

package/dist/router/Router.js

@@ -217,7 +217,10 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
         }
         // Lookup mode: find matches for a specific market.
         const response = await this.client.getMarketMatches(params);
-        const matches = response.matches ?? [];
+        if (!response || !Array.isArray(response.matches)) {
+            throw new Error('fetchMarketMatches returned an unexpected response shape: missing matches array');
+        }
+        const matches = response.matches;
         return matches.map((m) => ({
             market: m.market,
             relation: m.relation,
@@ -262,14 +265,20 @@ class Router extends BaseExchange_1.PredictionMarketExchange {
         const hasIdentifier = params.eventId || params.slug;
         if (!hasIdentifier) {
             const results = await this.client.browseEventMatches(params);
-            return Array.isArray(results) ? results : [];
+            if (!Array.isArray(results)) {
+                throw new Error(`browseEventMatches returned unexpected type '${typeof results}'`);
+            }
+            return results;
         }
         if (await this.resolveLocalMockEventLookup(params)) {
             return [];
         }
         // Lookup mode: find matches for a specific event.
         const response = await this.client.getEventMatches(params);
-        return response.matches ?? [];
+        if (!response || !Array.isArray(response.matches)) {
+            throw new Error('fetchEventMatches returned an unexpected response shape: missing matches array');
+        }
+        return response.matches;
     }
     // -----------------------------------------------------------------------
     // Price comparison: identity matches with live prices

package/dist/server/app.js

@@ -134,6 +134,80 @@ function queryToArgs(query, spec) {
     }
     return args;
 }
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function toDateParam(value, field, exchange) {
+    if (value instanceof Date) {
+        if (Number.isNaN(value.getTime())) {
+            throw new errors_1.ValidationError(`${field} must be a valid date-time value.`, field, exchange);
+        }
+        return value;
+    }
+    if (typeof value === "string" || typeof value === "number") {
+        const parsed = new Date(value);
+        if (!Number.isNaN(parsed.getTime())) {
+            return parsed;
+        }
+    }
+    throw new errors_1.ValidationError(`${field} must be a valid date-time string or timestamp.`, field, exchange);
+}
+function normalizeDateFields(params, fields, exchange) {
+    const normalized = { ...params };
+    for (const field of fields) {
+        const value = normalized[field];
+        if (value === undefined || value === null || value === "")
+            continue;
+        normalized[field] = toDateParam(value, field, exchange);
+    }
+    return normalized;
+}
+function isMissing(value) {
+    return value === undefined || value === null || value === "";
+}
+function assertFiniteNumber(params, field, exchange) {
+    const value = params[field];
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new errors_1.ValidationError(`createOrder params.${field} must be a finite number.`, field, exchange);
+    }
+}
+function validateCreateOrderParams(params, exchange) {
+    if (!isRecord(params)) {
+        throw new errors_1.ValidationError("createOrder requires an order parameter object.", "params", exchange);
+    }
+    const required = ["marketId", "outcomeId", "side", "type", "amount"];
+    const missing = required.filter((field) => isMissing(params[field]));
+    if (missing.length > 0) {
+        throw new errors_1.ValidationError(`createOrder requires ${missing.map((field) => `params.${field}`).join(", ")}.`, missing[0], exchange);
+    }
+    if (params.side !== "buy" && params.side !== "sell") {
+        throw new errors_1.ValidationError('createOrder params.side must be "buy" or "sell".', "side", exchange);
+    }
+    if (params.type !== "market" && params.type !== "limit") {
+        throw new errors_1.ValidationError('createOrder params.type must be "market" or "limit".', "type", exchange);
+    }
+    assertFiniteNumber(params, "amount", exchange);
+    if (params.type === "limit" && isMissing(params.price)) {
+        throw new errors_1.ValidationError("createOrder params.price is required for limit orders.", "price", exchange);
+    }
+    if (!isMissing(params.price)) {
+        assertFiniteNumber(params, "price", exchange);
+    }
+    if (!isMissing(params.fee)) {
+        assertFiniteNumber(params, "fee", exchange);
+    }
+    return params;
+}
+function normalizeDispatchArgs(methodName, args, exchange) {
+    const normalized = [...args];
+    if (methodName === "fetchOHLCV" && isRecord(normalized[1])) {
+        normalized[1] = normalizeDateFields(normalized[1], ["start", "end"], exchange);
+    }
+    if (methodName === "createOrder") {
+        normalized[0] = validateCreateOrderParams(normalized[0], exchange);
+    }
+    return normalized;
+}
 // Singleton instances for local usage (when no credentials provided)
 const defaultExchanges = {
     polymarket: null,
@@ -275,7 +349,8 @@ function createApp(options = {}) {
                 });
                 return;
             }
-            const result = await exchange[methodName](...args);
+            const normalizedArgs = normalizeDispatchArgs(methodName, args, exchangeName);
+            const result = await exchange[methodName](...normalizedArgs);
             res.json({ success: true, data: result });
         }
         catch (error) {

package/dist/server/exchange-factory.js

@@ -14,6 +14,7 @@ const smarkets_1 = require("../exchanges/smarkets");
 const polymarket_us_1 = require("../exchanges/polymarket_us");
 const hyperliquid_1 = require("../exchanges/hyperliquid");
 const gemini_titan_1 = require("../exchanges/gemini-titan");
+const suibets_1 = require("../exchanges/suibets");
 const mock_1 = require("../exchanges/mock");
 const router_1 = require("../router");
 function createExchange(name, credentials, bearerToken) {
@@ -103,6 +104,11 @@ function createExchange(name, credentials, bearerToken) {
                 apiKey: credentials?.apiKey || process.env.GEMINI_API_KEY,
                 apiSecret: credentials?.apiSecret || process.env.GEMINI_API_SECRET,
             });
+        case "suibets":
+            return new suibets_1.SuiBetsExchange({
+                walletAddress: credentials?.walletAddress || process.env.SUIBETS_WALLET_ADDRESS,
+                baseUrl: credentials?.baseUrl || process.env.SUIBETS_BASE_URL,
+            });
         case "mock":
             return new mock_1.MockExchange();
         case "router":

package/dist/server/openapi.yaml

@@ -4159,6 +4159,13 @@ x-sdk-constructors:
         tsName: apiSecret
         type: string
         description: API secret for authentication
+  suibets:
+    className: Suibets
+    params:
+      - name: pmxt_api_key
+        tsName: pmxtApiKey
+        type: string
+        description: PMXT API key for hosted access
   mock:
     className: Mock
     params:

package/dist/server/ws-handler.js

@@ -4,6 +4,7 @@ exports.createWebSocketHandler = createWebSocketHandler;
 const ws_1 = require("ws");
 const errors_1 = require("../errors");
 const exchange_factory_1 = require("./exchange-factory");
+const feed_factory_1 = require("./feed-factory");
 const logger_1 = require("../utils/logger");
 // ---------------------------------------------------------------------------
 // Streaming methods
@@ -14,6 +15,10 @@ const WATCH_METHODS = new Set([
     "watchOrderBooks",
     "watchTrades",
 ]);
+/** Data-feed methods that produce streaming data. */
+const FEED_WATCH_METHODS = new Set([
+    "watchTicker",
+]);
 /** Methods for unsubscribing. */
 const UNWATCH_METHODS = {
     unwatchOrderBook: "watchOrderBook",
@@ -30,7 +35,10 @@ function sendError(ws, id, message, code) {
  * Build a unique key for a subscription so we can cancel it.
  */
 function subscriptionKey(msg) {
-    return `${msg.exchange}:${msg.method}:${JSON.stringify(msg.args)}`;
+    const target = msg.targetKind === "feed"
+        ? `feed:${msg.feed}`
+        : `exchange:${msg.exchange}`;
+    return `${target}:${msg.method}:${JSON.stringify(msg.args)}`;
 }
 /**
  * Start a streaming loop for a single-ticker watch method
@@ -101,6 +109,78 @@ async function streamBatch(exchange, method, args, id, ws, signal) {
         }
     }
 }
+/**
+ * Start a streaming loop for feed watch methods.
+ *
+ * Data feeds expose callback-driven watch methods rather than the exchange
+ * layer's await-next-update methods, so lifecycle is tied to the returned
+ * unsubscribe callback and the client's AbortSignal.
+ */
+async function streamFeedSingle(feed, feedName, method, args, id, ws, signal) {
+    const symbol = typeof args[0] === "string" ? args[0] : String(args[0] ?? "");
+    let unsubscribe;
+    let settled = false;
+    let resolveDone = () => { };
+    const done = new Promise((resolve) => {
+        resolveDone = resolve;
+    });
+    const cleanup = () => {
+        if (settled)
+            return;
+        settled = true;
+        signal.removeEventListener("abort", cleanup);
+        ws.removeListener("close", cleanup);
+        if (unsubscribe) {
+            try {
+                unsubscribe();
+            }
+            catch (err) {
+                logger_1.logger.warn('ws-handler: feed unsubscribe failed', {
+                    feed: feedName,
+                    method,
+                    id,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        resolveDone();
+    };
+    signal.addEventListener("abort", cleanup, { once: true });
+    ws.once("close", cleanup);
+    try {
+        if (typeof feed.connect === "function") {
+            await feed.connect();
+        }
+        if (signal.aborted || ws.readyState !== ws_1.WebSocket.OPEN) {
+            cleanup();
+            return;
+        }
+        if (method !== "watchTicker" || typeof feed.watchTicker !== "function") {
+            sendError(ws, id, `Method '${method}' not found on ${feedName}`);
+            cleanup();
+            return;
+        }
+        unsubscribe = feed.watchTicker(symbol, (data) => {
+            if (!signal.aborted && ws.readyState === ws_1.WebSocket.OPEN) {
+                send(ws, { id, event: "data", method, symbol, source: feedName, data });
+            }
+        });
+        send(ws, { event: "subscribed", id });
+        await done;
+    }
+    catch (err) {
+        if (!signal.aborted) {
+            const message = err instanceof errors_1.BaseError
+                ? err.message
+                : err instanceof Error
+                    ? err.message
+                    : "Unknown streaming error";
+            const code = err instanceof errors_1.BaseError ? err.code : undefined;
+            sendError(ws, id, message, code);
+        }
+        cleanup();
+    }
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -158,32 +238,75 @@ function createWebSocketHandler(options = {}) {
             const id = parsed.id;
             const action = parsed.action;
             const exchange = parsed.exchange;
+            const feed = parsed.feed;
             const method = parsed.method;
-            if (!id || !action || !exchange || !method) {
-                sendError(ws, id, "Missing required fields: id, action, exchange, method");
+            if (!id || !action) {
+                sendError(ws, id, "Missing required fields: id, action");
+                return;
+            }
+            if (action === "unsubscribe" && !method && !exchange && !feed) {
+                handleUnsubscribeById(ws, state, id);
+                return;
+            }
+            if (!method) {
+                sendError(ws, id, "Missing required field: method");
+                return;
+            }
+            if ((exchange && feed) || (!exchange && !feed)) {
+                sendError(ws, id, "Missing required target: provide exactly one of exchange or feed");
                 return;
             }
-            const exchangeName = exchange.toLowerCase();
             if (action === "subscribe") {
-                const msg = {
-                    id,
-                    action: "subscribe",
-                    exchange: exchangeName,
-                    method,
-                    args: parsed.args || [],
-                    credentials: parsed.credentials,
-                };
-                handleSubscribe(ws, state, msg, exchangeName);
+                if (feed) {
+                    const feedName = feed.toLowerCase();
+                    const msg = {
+                        id,
+                        action: "subscribe",
+                        targetKind: "feed",
+                        feed: feedName,
+                        method,
+                        args: parsed.args || [],
+                    };
+                    handleFeedSubscribe(ws, state, msg, feedName);
+                }
+                else {
+                    const exchangeName = exchange.toLowerCase();
+                    const msg = {
+                        id,
+                        action: "subscribe",
+                        targetKind: "exchange",
+                        exchange: exchangeName,
+                        method,
+                        args: parsed.args || [],
+                        credentials: parsed.credentials,
+                    };
+                    handleSubscribe(ws, state, msg, exchangeName);
+                }
             }
             else if (action === "unsubscribe") {
-                const msg = {
-                    id,
-                    action: "unsubscribe",
-                    exchange: exchangeName,
-                    method,
-                    args: parsed.args || [],
-                };
-                handleUnsubscribe(ws, state, msg, exchangeName);
+                if (feed) {
+                    const msg = {
+                        id,
+                        action: "unsubscribe",
+                        targetKind: "feed",
+                        feed: feed.toLowerCase(),
+                        method,
+                        args: parsed.args || [],
+                    };
+                    handleUnsubscribe(ws, state, msg);
+                }
+                else {
+                    const exchangeName = exchange.toLowerCase();
+                    const msg = {
+                        id,
+                        action: "unsubscribe",
+                        targetKind: "exchange",
+                        exchange: exchangeName,
+                        method,
+                        args: parsed.args || [],
+                    };
+                    handleUnsubscribe(ws, state, msg);
+                }
             }
             else {
                 sendError(ws, id, `Unknown action: ${action}`);
@@ -257,7 +380,7 @@ function handleSubscribe(ws, state, msg, exchangeName) {
         return;
     }
     const abortController = new AbortController();
-    state.subscriptions.set(key, { abortController });
+    state.subscriptions.set(key, { id, abortController });
     const streamFn = method === "watchOrderBooks" ? streamBatch : streamSingle;
     // Fire and forget -- the loop runs until aborted or WS closes
     streamFn(exchange, method, args || [], id, ws, abortController.signal).catch((err) => {
@@ -270,10 +393,45 @@ function handleSubscribe(ws, state, msg, exchangeName) {
             error: err instanceof Error ? err.message : String(err),
         });
         sendError(ws, id, err instanceof Error ? err.message : 'Streaming error');
+    }).finally(() => {
         state.subscriptions.delete(key);
     });
 }
-function handleUnsubscribe(ws, state, msg, exchangeName) {
+function handleFeedSubscribe(ws, state, msg, feedName) {
+    const { id, method, args } = msg;
+    if (!FEED_WATCH_METHODS.has(method)) {
+        sendError(ws, id, `Method '${method}' is not a feed streaming method. Use the HTTP API for non-streaming calls.`);
+        return;
+    }
+    const key = subscriptionKey(msg);
+    if (state.subscriptions.has(key)) {
+        sendError(ws, id, `Already subscribed to ${key}`);
+        return;
+    }
+    let feed;
+    try {
+        feed = (0, feed_factory_1.getFeed)(feedName);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to create feed";
+        sendError(ws, id, message);
+        return;
+    }
+    const abortController = new AbortController();
+    state.subscriptions.set(key, { id, abortController });
+    streamFeedSingle(feed, feedName, method, args || [], id, ws, abortController.signal).catch((err) => {
+        logger_1.logger.warn('ws-handler: feed stream ended with unexpected error', {
+            feed: feedName,
+            method,
+            id,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        sendError(ws, id, err instanceof Error ? err.message : 'Streaming error');
+    }).finally(() => {
+        state.subscriptions.delete(key);
+    });
+}
+function handleUnsubscribe(ws, state, msg) {
     const { id } = msg;
     // Build the key of the subscription to cancel.
     // For unsubscribe actions, the corresponding subscribe key uses the watch method.
@@ -289,3 +447,18 @@ function handleUnsubscribe(ws, state, msg, exchangeName) {
     state.subscriptions.delete(key);
     send(ws, { event: "subscribed", id }); // Acknowledge unsubscribe
 }
+function handleUnsubscribeById(ws, state, id) {
+    let cancelled = false;
+    for (const [key, sub] of state.subscriptions) {
+        if (sub.id === id) {
+            sub.abortController.abort();
+            state.subscriptions.delete(key);
+            cancelled = true;
+        }
+    }
+    if (!cancelled) {
+        sendError(ws, id, `No active subscription for id ${id}`);
+        return;
+    }
+    send(ws, { event: "subscribed", id });
+}

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "pmxt-core",
-  "version": "2.44.6",
+  "version": "2.45.0",
   "description": "pmxt is a unified prediction market data API. The ccxt for prediction markets.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {
     "type": "git",
-    "url": "https://github.com/pmxt-dev/pmxt.git"
+    "url": "git+https://github.com/pmxt-dev/pmxt.git"
   },
   "bin": {
-    "pmxt-server": "./dist/server/index.js",
-    "pmxt-ensure-server": "./bin/pmxt-ensure-server"
+    "pmxt-server": "dist/server/index.js",
+    "pmxt-ensure-server": "bin/pmxt-ensure-server"
   },
   "files": [
     "dist",
@@ -29,8 +29,8 @@
     "test": "jest -c jest.config.js",
     "server": "tsx watch src/server/index.ts",
     "server:prod": "node dist/server/index.js",
-    "generate:sdk:python": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g python -o ../sdks/python/generated --package-name pmxt_internal --additional-properties=projectName=pmxt-internal,packageVersion=2.44.6,library=urllib3",
-    "generate:sdk:typescript": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g typescript-fetch -o ../sdks/typescript/generated --additional-properties=npmName=pmxtjs,npmVersion=2.44.6,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.js",
+    "generate:sdk:python": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g python -o ../sdks/python/generated --package-name pmxt_internal --additional-properties=projectName=pmxt-internal,packageVersion=2.45.0,library=urllib3",
+    "generate:sdk:typescript": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g typescript-fetch -o ../sdks/typescript/generated --additional-properties=npmName=pmxtjs,npmVersion=2.45.0,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.js",
     "fetch:openapi": "node scripts/fetch-openapi-specs.js",
     "extract:jsdoc": "node ../scripts/extract-jsdoc.js",
     "generate:docs": "npm run extract:jsdoc && node ../scripts/generate-api-docs.js",