pmxt-core 2.1.1 → 2.1.3

package/dist/BaseExchange.d.ts

@@ -4,7 +4,7 @@ export interface MarketFilterParams {
     limit?: number;
     offset?: number;
     sort?: 'volume' | 'liquidity' | 'newest';
-    status?: 'active' | 'closed' | 'all';
+    status?: 'active' | 'inactive' | 'closed' | 'all';
     searchIn?: 'title' | 'description' | 'both';
     query?: string;
     slug?: string;
@@ -17,7 +17,7 @@ export interface EventFetchParams {
     query?: string;
     limit?: number;
     offset?: number;
-    status?: 'active' | 'closed' | 'all';
+    status?: 'active' | 'inactive' | 'closed' | 'all';
     searchIn?: 'title' | 'description' | 'both';
 }
 export interface HistoryFilterParams {
@@ -114,6 +114,8 @@ export declare abstract class PredictionMarketExchange {
      * @param params.searchIn - Where to search ('title' | 'description' | 'both')
      * @returns Array of unified markets
      *
+     * @note Some exchanges (like Limitless) may only support status 'active' for search results.
+     *
      * @example-ts Fetch markets
      * const markets = await exchange.fetchMarkets({ query: 'Trump', limit: 10000 });
      * console.log(markets[0].title);
@@ -140,6 +142,8 @@ export declare abstract class PredictionMarketExchange {
      * @param params.searchIn - Where to search ('title' | 'description' | 'both')
      * @returns Array of unified events
      *
+     * @note Some exchanges (like Limitless) may only support status 'active' for search results.
+     *
      * @example-ts Search events
      * const events = await exchange.fetchEvents({ query: 'Fed Chair' });
      * const fedEvent = events[0];

package/dist/BaseExchange.js

@@ -22,6 +22,8 @@ class PredictionMarketExchange {
      * @param params.searchIn - Where to search ('title' | 'description' | 'both')
      * @returns Array of unified markets
      *
+     * @note Some exchanges (like Limitless) may only support status 'active' for search results.
+     *
      * @example-ts Fetch markets
      * const markets = await exchange.fetchMarkets({ query: 'Trump', limit: 10000 });
      * console.log(markets[0].title);
@@ -50,6 +52,8 @@ class PredictionMarketExchange {
      * @param params.searchIn - Where to search ('title' | 'description' | 'both')
      * @returns Array of unified events
      *
+     * @note Some exchanges (like Limitless) may only support status 'active' for search results.
+     *
      * @example-ts Search events
      * const events = await exchange.fetchEvents({ query: 'Fed Chair' });
      * const fedEvent = events[0];

package/dist/exchanges/kalshi/fetchEvents.js

@@ -10,19 +10,57 @@ const errors_1 = require("./errors");
 async function fetchEvents(params) {
     try {
         const status = params?.status || 'active';
-        let apiStatus = 'open';
-        if (status === 'closed')
-            apiStatus = 'closed';
-        const queryParams = {
-            limit: 200, // Reasonable batch for search
-            with_nested_markets: true,
-            status: apiStatus
+        const limit = params?.limit || 10000;
+        const query = (params?.query || '').toLowerCase();
+        const fetchAllWithStatus = async (apiStatus) => {
+            let allEvents = [];
+            let cursor = null;
+            let page = 0;
+            const MAX_PAGES = 1000; // Safety cap against infinite loops
+            const BATCH_SIZE = 200; // Max limit per Kalshi API docs
+            do {
+                const queryParams = {
+                    limit: BATCH_SIZE,
+                    with_nested_markets: true,
+                    status: apiStatus
+                };
+                if (cursor)
+                    queryParams.cursor = cursor;
+                const response = await axios_1.default.get(utils_1.KALSHI_API_URL, { params: queryParams });
+                const events = response.data.events || [];
+                if (events.length === 0)
+                    break;
+                allEvents = allEvents.concat(events);
+                cursor = response.data.cursor;
+                page++;
+                // If we have no search query and have fetched enough events, we can stop early
+                if (!query && allEvents.length >= limit * 1.5) {
+                    break;
+                }
+            } while (cursor && page < MAX_PAGES);
+            return allEvents;
         };
-        const response = await axios_1.default.get(utils_1.KALSHI_API_URL, { params: queryParams });
-        const events = response.data.events || [];
-        const lowerQuery = (params?.query || '').toLowerCase();
+        let events = [];
+        if (status === 'all') {
+            const [openEvents, closedEvents, settledEvents] = await Promise.all([
+                fetchAllWithStatus('open'),
+                fetchAllWithStatus('closed'),
+                fetchAllWithStatus('settled')
+            ]);
+            events = [...openEvents, ...closedEvents, ...settledEvents];
+        }
+        else if (status === 'closed' || status === 'inactive') {
+            const [closedEvents, settledEvents] = await Promise.all([
+                fetchAllWithStatus('closed'),
+                fetchAllWithStatus('settled')
+            ]);
+            events = [...closedEvents, ...settledEvents];
+        }
+        else {
+            events = await fetchAllWithStatus('open');
+        }
         const filtered = events.filter((event) => {
-            return (event.title || '').toLowerCase().includes(lowerQuery);
+            return (event.title || '').toLowerCase().includes(query);
         });
         const unifiedEvents = filtered.map((event) => {
             const markets = [];
@@ -47,7 +85,6 @@ async function fetchEvents(params) {
             };
             return unifiedEvent;
         });
-        const limit = params?.limit || 10000;
         return unifiedEvents.slice(0, limit);
     }
     catch (error) {

package/dist/exchanges/kalshi/fetchMarkets.js

@@ -162,7 +162,7 @@ async function fetchMarketsDefault(params) {
     // Map 'active' -> 'open', 'closed' -> 'closed'
     // Kalshi statuses: 'open', 'closed', 'settled'
     let apiStatus = 'open';
-    if (status === 'closed')
+    if (status === 'closed' || status === 'inactive')
         apiStatus = 'closed';
     else if (status === 'all')
         apiStatus = 'open'; // Fallback for all? Or loop? For now default to open.

package/dist/exchanges/limitless/errors.js

@@ -25,14 +25,14 @@ class LimitlessErrorMapper extends error_mapper_1.ErrorMapper {
             const data = error.response.data;
             // Limitless uses errorMsg field (CLOB client)
             if (data.errorMsg) {
-                return data.errorMsg;
+                return typeof data.errorMsg === 'string' ? data.errorMsg : JSON.stringify(data.errorMsg);
             }
             // Also check standard error paths
             if (data.error?.message) {
-                return data.error.message;
+                return String(data.error.message);
             }
             if (data.message) {
-                return data.message;
+                return String(data.message);
             }
         }
         return super.extractErrorMessage(error);
@@ -41,7 +41,7 @@ class LimitlessErrorMapper extends error_mapper_1.ErrorMapper {
      * Override to detect Limitless-specific error patterns
      */
     mapBadRequestError(message, data) {
-        const lowerMessage = message.toLowerCase();
+        const lowerMessage = (message || '').toString().toLowerCase();
         // Limitless-specific authentication errors (400 status)
         if (lowerMessage.includes('api key') ||
             lowerMessage.includes('proxy') ||

package/dist/exchanges/limitless/fetchEvents.js

@@ -8,17 +8,29 @@ const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
 async function fetchEvents(params) {
-    if (params?.status === 'closed') {
-        return [];
-    }
     try {
+        // NOTE: The Limitless /markets/search endpoint currently only returns active/funded markets.
+        // It does not include expired or resolved markets in search results.
+        // Consequently, status 'inactive' will likely return 0 results and 'all' will only show active markets.
         const response = await axios_1.default.get(`${utils_1.LIMITLESS_API_URL}/markets/search`, {
             params: {
                 query: params.query,
-                limit: params?.limit || 10000
+                limit: params?.limit || 10000,
+                similarityThreshold: 0.5
             }
         });
-        const markets = response.data?.markets || [];
+        let markets = response.data?.markets || [];
+        // Filter by status based on expired/resolved state
+        // Active: not expired and not resolved
+        // Inactive: expired OR resolved (has winningOutcomeIndex)
+        const status = params?.status || 'active';
+        if (status === 'active') {
+            markets = markets.filter((m) => !m.expired && m.winningOutcomeIndex === null);
+        }
+        else if (status === 'inactive' || status === 'closed') {
+            markets = markets.filter((m) => m.expired === true || m.winningOutcomeIndex !== null);
+        }
+        // If status === 'all', don't filter
         return markets.map((market) => {
             let marketsList = [];
             if (market.markets && Array.isArray(market.markets)) {

package/dist/exchanges/limitless/fetchMarkets.js

@@ -1,25 +1,60 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchMarkets = fetchMarkets;
-const sdk_1 = require("@limitless-exchange/sdk");
 const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
 async function fetchMarkets(params, apiKey) {
     // Limitless API currently only supports fetching active markets for lists
-    if (params?.status === 'closed') {
+    // Early return to avoid SDK initialization in tests
+    if (params?.status === 'inactive' || params?.status === 'closed') {
         return [];
     }
+    // Lazy import SDK to avoid initialization when not needed
+    const { HttpClient, MarketFetcher } = await Promise.resolve().then(() => __importStar(require('@limitless-exchange/sdk')));
     try {
         // Create HTTP client (no auth needed for market data)
-        const httpClient = new sdk_1.HttpClient({
+        const httpClient = new HttpClient({
             baseURL: utils_1.LIMITLESS_API_URL,
             apiKey: apiKey, // Optional - not required for public market data
         });
-        const marketFetcher = new sdk_1.MarketFetcher(httpClient);
+        const marketFetcher = new MarketFetcher(httpClient);
         // Handle slug-based lookup
         if (params?.slug) {
             return await fetchMarketsBySlug(marketFetcher, params.slug);
@@ -44,6 +79,8 @@ async function fetchMarketsBySlug(marketFetcher, slug) {
 }
 async function searchMarkets(marketFetcher, query, params) {
     // SDK doesn't have a search method yet, use axios directly
+    // NOTE: The Limitless /markets/search endpoint currently only returns active/funded markets.
+    // It does not include expired or resolved markets in search results.
     const response = await axios_1.default.get(`${utils_1.LIMITLESS_API_URL}/markets/search`, {
         params: {
             query: query,

package/dist/exchanges/polymarket/fetchEvents.js

@@ -15,20 +15,45 @@ async function fetchEvents(params) {
         const status = params.status || 'active';
         const queryParams = {
             q: params.query,
-            limit_per_type: 50, // Fetch 50 per page for better efficiency
-            events_status: status === 'all' ? undefined : status,
+            limit_per_type: 50,
             sort: 'volume',
             ascending: false
         };
-        // If specific status requested
-        if (status === 'active') {
-            queryParams.events_status = 'active';
+        const fetchWithStatus = async (eventStatus) => {
+            const currentParams = { ...queryParams, events_status: eventStatus };
+            return (0, utils_1.paginateSearchParallel)(utils_1.GAMMA_SEARCH_URL, currentParams, limit * 10);
+        };
+        // Client-side filtering logic
+        // The API returns active events when querying for 'closed' status sometimes.
+        // We must strictly filter based on the event's `active` and `closed` properties.
+        const filterActive = (e) => e.active === true;
+        const filterClosed = (e) => e.closed === true;
+        let events = [];
+        if (status === 'all') {
+            const [activeEvents, closedEvents] = await Promise.all([
+                fetchWithStatus('active'),
+                fetchWithStatus('closed')
+            ]);
+            // Merge and de-duplicate by ID
+            const seenIds = new Set();
+            events = [...activeEvents, ...closedEvents].filter(event => {
+                const id = event.id || event.slug;
+                if (seenIds.has(id))
+                    return false;
+                seenIds.add(id);
+                return true;
+            });
+        }
+        else if (status === 'active') {
+            const rawEvents = await fetchWithStatus('active');
+            events = rawEvents.filter(filterActive);
         }
-        else if (status === 'closed') {
-            queryParams.events_status = 'closed';
+        else if (status === 'inactive' || status === 'closed') {
+            // Polymarket sometimes returns active events when querying for closed
+            // So we fetch 'closed' but strictly filter
+            const rawEvents = await fetchWithStatus('closed');
+            events = rawEvents.filter(filterClosed);
         }
-        // Use parallel pagination to fetch all matching events
-        const events = await (0, utils_1.paginateSearchParallel)(utils_1.GAMMA_SEARCH_URL, queryParams, limit * 10);
         // Client-side filtering to ensure title matches (API does fuzzy search)
         const lowerQuery = params.query.toLowerCase();
         const searchIn = params.searchIn || 'title';
@@ -65,7 +90,7 @@ async function fetchEvents(params) {
             };
             return unifiedEvent;
         });
-        return unifiedEvents;
+        return unifiedEvents.slice(0, limit);
     }
     catch (error) {
         throw errors_1.polymarketErrorMapper.mapError(error);

package/dist/exchanges/polymarket/fetchMarkets.js

@@ -51,7 +51,7 @@ async function searchMarkets(query, params) {
     const queryParams = {
         q: query,
         limit_per_type: 50, // Fetch 50 events per page
-        events_status: params?.status === 'all' ? undefined : (params?.status || 'active'),
+        events_status: params?.status === 'all' ? undefined : (params?.status === 'inactive' || params?.status === 'closed' ? 'closed' : 'active'),
         sort: 'volume',
         ascending: false
     };
@@ -98,7 +98,7 @@ async function fetchMarketsDefault(params) {
         queryParams.active = 'true';
         queryParams.closed = 'false';
     }
-    else if (status === 'closed') {
+    else if (status === 'closed' || status === 'inactive') {
         queryParams.active = 'false';
         queryParams.closed = 'true';
     }

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

@@ -20,12 +20,13 @@ export declare class PolymarketExchange extends PredictionMarketExchange {
      * Ensure authentication is initialized before trading operations.
      */
     private ensureAuth;
-    createOrder(params: CreateOrderParams): Promise<Order>;
     /**
-     * Infer the tick size from order book price levels.
-     * Analyzes the decimal precision of existing orders to determine the market's tick size.
+     * Pre-warm the SDK's internal caches for a token by fetching tick size,
+     * fee rate, and neg-risk in parallel. Call this when you start watching
+     * a market so that subsequent createOrder calls hit only POST /order.
      */
-    private inferTickSize;
+    preWarmMarket(outcomeId: string): Promise<void>;
+    createOrder(params: CreateOrderParams): Promise<Order>;
     cancelOrder(orderId: string): Promise<Order>;
     fetchOrder(orderId: string): Promise<Order>;
     fetchOpenOrders(marketId?: string): Promise<Order[]>;

package/dist/exchanges/polymarket/index.js

@@ -73,6 +73,20 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         return this.auth;
     }
+    /**
+     * Pre-warm the SDK's internal caches for a token by fetching tick size,
+     * fee rate, and neg-risk in parallel. Call this when you start watching
+     * a market so that subsequent createOrder calls hit only POST /order.
+     */
+    async preWarmMarket(outcomeId) {
+        const auth = this.ensureAuth();
+        const client = await auth.getClobClient();
+        await Promise.all([
+            client.getTickSize(outcomeId),
+            client.getFeeRateBps(outcomeId),
+            client.getNegRisk(outcomeId),
+        ]);
+    }
     async createOrder(params) {
         try {
             const auth = this.ensureAuth();
@@ -85,22 +99,8 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
             }
             // For market orders, use max slippage: 0.99 for BUY (willing to pay up to 99%), 0.01 for SELL (willing to accept down to 1%)
             const price = params.price || (side === clob_client_1.Side.BUY ? 0.99 : 0.01);
-            // Auto-detect tick size if not provided
-            let tickSize;
-            if (params.tickSize) {
-                tickSize = params.tickSize.toString();
-            }
-            else {
-                // Fetch the order book to infer tick size from price levels
-                try {
-                    const orderBook = await this.fetchOrderBook(params.outcomeId);
-                    tickSize = this.inferTickSize(orderBook);
-                }
-                catch (error) {
-                    // Fallback to 0.01 if order book fetch fails (standard for Polymarket)
-                    tickSize = "0.01";
-                }
-            }
+            // Use provided tickSize, or let the SDK resolve it from its own cache / API
+            const tickSize = params.tickSize ? params.tickSize.toString() : undefined;
             const orderArgs = {
                 tokenID: params.outcomeId,
                 price: price,
@@ -110,10 +110,14 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
             if (params.fee !== undefined && params.fee !== null) {
                 orderArgs.feeRateBps = params.fee;
             }
-            // We use createAndPostOrder which handles signing and posting
-            const response = await client.createAndPostOrder(orderArgs, {
-                tickSize: tickSize
-            });
+            const options = {};
+            if (tickSize) {
+                options.tickSize = tickSize;
+            }
+            if (params.negRisk !== undefined) {
+                options.negRisk = params.negRisk;
+            }
+            const response = await client.createAndPostOrder(orderArgs, options);
             if (!response || !response.success) {
                 throw new Error(`${response?.errorMsg || 'Order placement failed'} (Response: ${JSON.stringify(response)})`);
             }
@@ -136,40 +140,6 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
             throw errors_1.polymarketErrorMapper.mapError(error);
         }
     }
-    /**
-     * Infer the tick size from order book price levels.
-     * Analyzes the decimal precision of existing orders to determine the market's tick size.
-     */
-    inferTickSize(orderBook) {
-        const allPrices = [
-            ...orderBook.bids.map(b => b.price),
-            ...orderBook.asks.map(a => a.price)
-        ];
-        if (allPrices.length === 0) {
-            return "0.01"; // Default fallback for Polymarket
-        }
-        // Find the smallest non-zero decimal increment
-        let minIncrement = 1;
-        for (const price of allPrices) {
-            const priceStr = price.toString();
-            const decimalPart = priceStr.split('.')[1];
-            if (decimalPart) {
-                const decimals = decimalPart.length;
-                const increment = Math.pow(10, -decimals);
-                if (increment < minIncrement) {
-                    minIncrement = increment;
-                }
-            }
-        }
-        // Map to valid tick sizes: 0.1, 0.01, 0.001, 0.0001
-        if (minIncrement >= 0.1)
-            return "0.1";
-        if (minIncrement >= 0.01)
-            return "0.01";
-        if (minIncrement >= 0.001)
-            return "0.001";
-        return "0.0001";
-    }
     async cancelOrder(orderId) {
         try {
             const auth = this.ensureAuth();

package/dist/types.d.ts

@@ -102,4 +102,5 @@ export interface CreateOrderParams {
     price?: number;
     fee?: number;
     tickSize?: number;
+    negRisk?: boolean;
 }

package/dist/utils/error-mapper.js

@@ -231,6 +231,14 @@ class ErrorMapper {
             return error;
         }
         // Unknown error format
+        if (typeof error === 'object' && error !== null) {
+            try {
+                return JSON.stringify(error, Object.getOwnPropertyNames(error));
+            }
+            catch (e) {
+                return String(error);
+            }
+        }
         return String(error);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmxt-core",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "pmxt is a unified prediction market data API. The ccxt for prediction markets.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -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.1.1,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.1.1,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.1.3,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.1.3,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.js",
     "extract:jsdoc": "node ../scripts/extract-jsdoc.js",
     "generate:docs": "npm run extract:jsdoc && node ../scripts/generate-api-docs.js",
     "generate:sdk:all": "npm run generate:sdk:python && npm run generate:sdk:typescript && npm run generate:docs"