pmxt-core 2.0.10 → 2.1.0

package/dist/BaseExchange.d.ts

@@ -4,6 +4,7 @@ export interface MarketFilterParams {
     limit?: number;
     offset?: number;
     sort?: 'volume' | 'liquidity' | 'newest';
+    status?: 'active' | 'closed' | 'all';
     searchIn?: 'title' | 'description' | 'both';
     query?: string;
     slug?: string;
@@ -16,6 +17,7 @@ export interface EventFetchParams {
     query?: string;
     limit?: number;
     offset?: number;
+    status?: 'active' | 'closed' | 'all';
     searchIn?: 'title' | 'description' | 'both';
 }
 export interface HistoryFilterParams {

package/dist/exchanges/kalshi/fetchEvents.js

@@ -9,10 +9,14 @@ const utils_1 = require("./utils");
 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: 'open'
+            status: apiStatus
         };
         const response = await axios_1.default.get(utils_1.KALSHI_API_URL, { params: queryParams });
         const events = response.data.events || [];

package/dist/exchanges/kalshi/fetchMarkets.js

@@ -8,7 +8,7 @@ exports.fetchMarkets = fetchMarkets;
 const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
-async function fetchActiveEvents(targetMarketCount) {
+async function fetchActiveEvents(targetMarketCount, status = 'open') {
     let allEvents = [];
     let totalMarketCount = 0;
     let cursor = null;
@@ -23,7 +23,7 @@ async function fetchActiveEvents(targetMarketCount) {
             const queryParams = {
                 limit: BATCH_SIZE,
                 with_nested_markets: true,
-                status: 'open' // Filter to open markets to improve relevance and speed
+                status: status // Filter by status (default 'open')
             };
             if (cursor)
                 queryParams.cursor = cursor;
@@ -158,11 +158,21 @@ async function fetchMarketsDefault(params) {
     const limit = params?.limit || 50;
     const offset = params?.offset || 0;
     const now = Date.now();
+    const status = params?.status || 'active'; // Default to 'active'
+    // Map 'active' -> 'open', 'closed' -> 'closed'
+    // Kalshi statuses: 'open', 'closed', 'settled'
+    let apiStatus = 'open';
+    if (status === 'closed')
+        apiStatus = 'closed';
+    else if (status === 'all')
+        apiStatus = 'open'; // Fallback for all? Or loop? For now default to open.
     try {
         let events;
         let seriesMap;
         // Check if we have valid cached data
-        if (cachedEvents && cachedSeriesMap && (now - lastCacheTime < CACHE_TTL)) {
+        // Only use global cache for the default 'active'/'open' case
+        const useCache = (status === 'active' || !params?.status);
+        if (useCache && cachedEvents && cachedSeriesMap && (now - lastCacheTime < CACHE_TTL)) {
             events = cachedEvents;
             seriesMap = cachedSeriesMap;
         }
@@ -173,16 +183,17 @@ async function fetchMarketsDefault(params) {
             const isSorted = params?.sort && (params.sort === 'volume' || params.sort === 'liquidity');
             const fetchLimit = isSorted ? 1000 : limit;
             const [allEvents, fetchedSeriesMap] = await Promise.all([
-                fetchActiveEvents(fetchLimit),
+                fetchActiveEvents(fetchLimit, apiStatus),
                 fetchSeriesMap()
             ]);
             events = allEvents;
             seriesMap = fetchedSeriesMap;
             events = allEvents;
             seriesMap = fetchedSeriesMap;
-            // Cache the dataset ONLY if we fetched a comprehensive set (intended for global sorting/pagination)
-            // If we only fetched a partial set (e.g. limit=5), we shouldn't cache it as the "full" logic assumes we have everything.
-            if (fetchLimit >= 1000) {
+            // Cache the dataset ONLY if:
+            // 1. We fetched a comprehensive set (>= 1000)
+            // 2. It's the standard 'open' status query
+            if (fetchLimit >= 1000 && useCache) {
                 cachedEvents = allEvents;
                 cachedSeriesMap = fetchedSeriesMap;
                 lastCacheTime = now;

package/dist/exchanges/limitless/fetchEvents.js

@@ -8,6 +8,9 @@ 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 {
         const response = await axios_1.default.get(`${utils_1.LIMITLESS_API_URL}/markets/search`, {
             params: {

package/dist/exchanges/limitless/fetchMarkets.js

@@ -9,6 +9,10 @@ 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') {
+        return [];
+    }
     try {
         // Create HTTP client (no auth needed for market data)
         const httpClient = new sdk_1.HttpClient({
@@ -77,18 +81,14 @@ async function fetchMarketsDefault(marketFetcher, params) {
     if (params?.sort === 'volume') {
         sortBy = 'high_value';
     }
-    // Calculate page number from offset
-    const page = Math.floor(offset / limit) + 1;
     try {
-        // Use SDK's getActiveMarkets method
-        const response = await marketFetcher.getActiveMarkets({
-            limit: limit,
-            page: page,
-            sortBy: sortBy,
-        });
-        const markets = response.data || [];
+        // Use pagination utility to handle limits > 25
+        // The utility over-fetches to account for markets that get filtered out
+        const totalToFetch = limit + offset;
+        const rawMarkets = await (0, utils_1.paginateLimitlessMarkets)(marketFetcher, totalToFetch, sortBy);
+        // Map and filter markets
         const unifiedMarkets = [];
-        for (const market of markets) {
+        for (const market of rawMarkets) {
             const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
             // Only include markets that are valid and have outcomes (compliance requirement)
             if (unifiedMarket && unifiedMarket.outcomes.length > 0) {
@@ -99,7 +99,9 @@ async function fetchMarketsDefault(marketFetcher, params) {
         if (params?.sort === 'volume') {
             unifiedMarkets.sort((a, b) => (b.volume ?? 0) - (a.volume ?? 0));
         }
-        return unifiedMarkets;
+        // Apply offset and limit to the FILTERED results
+        const marketsAfterOffset = offset > 0 ? unifiedMarkets.slice(offset) : unifiedMarkets;
+        return marketsAfterOffset.slice(0, limit);
     }
     catch (error) {
         throw errors_1.limitlessErrorMapper.mapError(error);

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

@@ -2,3 +2,12 @@ import { UnifiedMarket, CandleInterval } from '../../types';
 export declare const LIMITLESS_API_URL = "https://api.limitless.exchange";
 export declare function mapMarketToUnified(market: any): UnifiedMarket | null;
 export declare function mapIntervalToFidelity(interval: CandleInterval): number;
+/**
+ * Fetch paginated results from Limitless API.
+ * The API has a hard limit of 25 items per request, so this function
+ * handles automatic pagination when more items are requested.
+ *
+ * This function fetches all available markets up to a reasonable limit
+ * to ensure the caller can filter and still get the requested number.
+ */
+export declare function paginateLimitlessMarkets(fetcher: any, requestedLimit: number, sortBy: 'lp_rewards' | 'ending_soon' | 'newest' | 'high_value'): Promise<any[]>;

package/dist/exchanges/limitless/utils.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LIMITLESS_API_URL = void 0;
 exports.mapMarketToUnified = mapMarketToUnified;
 exports.mapIntervalToFidelity = mapIntervalToFidelity;
+exports.paginateLimitlessMarkets = paginateLimitlessMarkets;
 const market_utils_1 = require("../../utils/market-utils");
 exports.LIMITLESS_API_URL = 'https://api.limitless.exchange';
 function mapMarketToUnified(market) {
@@ -60,3 +61,50 @@ function mapIntervalToFidelity(interval) {
     };
     return mapping[interval];
 }
+/**
+ * Fetch paginated results from Limitless API.
+ * The API has a hard limit of 25 items per request, so this function
+ * handles automatic pagination when more items are requested.
+ *
+ * This function fetches all available markets up to a reasonable limit
+ * to ensure the caller can filter and still get the requested number.
+ */
+async function paginateLimitlessMarkets(fetcher, requestedLimit, sortBy) {
+    const PAGE_SIZE = 25;
+    const targetLimit = requestedLimit || PAGE_SIZE;
+    const MAX_PAGES = 20; // Safety limit to prevent infinite loops
+    if (targetLimit <= PAGE_SIZE) {
+        const response = await fetcher.getActiveMarkets({
+            limit: targetLimit,
+            page: 1,
+            sortBy: sortBy,
+        });
+        return response.data || [];
+    }
+    // Fetch more pages than theoretically needed to account for filtering
+    // ~33% of markets lack tokens and get filtered out, so we over-fetch
+    // by 70% to ensure we get enough valid markets after filtering
+    const estimatedPages = Math.ceil(targetLimit / PAGE_SIZE);
+    const pagesWithBuffer = Math.min(Math.ceil(estimatedPages * 1.7), MAX_PAGES);
+    const pageNumbers = [];
+    for (let i = 1; i <= pagesWithBuffer; i++) {
+        pageNumbers.push(i);
+    }
+    const pages = await Promise.all(pageNumbers.map(async (page) => {
+        try {
+            const response = await fetcher.getActiveMarkets({
+                limit: PAGE_SIZE,
+                page: page,
+                sortBy: sortBy,
+            });
+            return response.data || [];
+        }
+        catch (e) {
+            return [];
+        }
+    }));
+    const allMarkets = pages.flat();
+    // Don't slice here - let the caller handle limiting after filtering
+    // This ensures we return enough raw markets for the caller to filter
+    return allMarkets;
+}

package/dist/exchanges/polymarket/fetchEvents.js

@@ -6,12 +6,23 @@ const errors_1 = require("./errors");
 async function fetchEvents(params) {
     const searchLimit = 100000; // Fetch all events for comprehensive search
     try {
-        // Fetch events from Gamma API using parallel pagination
-        const events = await (0, utils_1.paginateParallel)(utils_1.GAMMA_API_URL, {
-            active: 'true',
-            closed: 'false',
+        const status = params?.status || 'active';
+        const queryParams = {
             limit: searchLimit
-        });
+        };
+        if (status === 'active') {
+            queryParams.active = 'true';
+            queryParams.closed = 'false';
+        }
+        else if (status === 'closed') {
+            queryParams.active = 'false';
+            queryParams.closed = 'true';
+        }
+        else {
+            // 'all' - no filter, maybe handled by default or API behavior
+        }
+        // Fetch events from Gamma API using parallel pagination
+        const events = await (0, utils_1.paginateParallel)(utils_1.GAMMA_API_URL, queryParams);
         // Client-side text filtering
         const lowerQuery = (params?.query || '').toLowerCase();
         const searchIn = params?.searchIn || 'title';

package/dist/exchanges/polymarket/fetchMarkets.js

@@ -72,11 +72,21 @@ async function fetchMarketsDefault(params) {
     const offset = params?.offset || 0;
     // Map generic sort params to Polymarket Gamma API params
     let queryParams = {
-        active: 'true',
-        closed: 'false',
         limit: limit,
         offset: offset,
     };
+    const status = params?.status || 'active';
+    if (status === 'active') {
+        queryParams.active = 'true';
+        queryParams.closed = 'false';
+    }
+    else if (status === 'closed') {
+        queryParams.active = 'false';
+        queryParams.closed = 'true';
+    }
+    else {
+        // 'all' - don't filter by status
+    }
     // Gamma API uses 'order' and 'ascending' for sorting
     if (params?.sort === 'volume') {
         queryParams.order = 'volume';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmxt-core",
-  "version": "2.0.10",
+  "version": "2.1.0",
   "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.0.10,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.0.10,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.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.1.0,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"