pmxt-core 2.8.0 → 2.9.1

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

@@ -1,6 +1,6 @@
 import { EventFetchParams } from '../../BaseExchange';
 import { UnifiedEvent } from '../../types';
 import { AxiosInstance } from 'axios';
-export declare function fetchEvents(params: EventFetchParams, http?: AxiosInstance): Promise<UnifiedEvent[]>;
-export declare function fetchEventById(id: string, http?: AxiosInstance): Promise<UnifiedEvent | null>;
-export declare function fetchEventBySlug(slug: string, http?: AxiosInstance): Promise<UnifiedEvent | null>;
+export declare function fetchEvents(params: EventFetchParams, http?: AxiosInstance, callMidpoint?: (tokenId: string) => Promise<any>, callSearch?: (params: any) => Promise<any>): Promise<UnifiedEvent[]>;
+export declare function fetchEventById(id: string, http?: AxiosInstance, callMidpoint?: (tokenId: string) => Promise<any>): Promise<UnifiedEvent | null>;
+export declare function fetchEventBySlug(slug: string, http?: AxiosInstance, callMidpoint?: (tokenId: string) => Promise<any>): Promise<UnifiedEvent | null>;

package/dist/exchanges/probable/fetchEvents.js

@@ -9,38 +9,38 @@ exports.fetchEventBySlug = fetchEventBySlug;
 const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
-async function fetchEvents(params, http = axios_1.default) {
+async function fetchEvents(params, http = axios_1.default, callMidpoint, callSearch) {
     try {
         // Handle eventId lookup
         if (params.eventId) {
-            const event = await fetchEventById(params.eventId, http);
+            const event = await fetchEventById(params.eventId, http, callMidpoint);
             return event ? [event] : [];
         }
         // Handle slug lookup
         if (params.slug) {
-            const event = await fetchEventBySlug(params.slug, http);
+            const event = await fetchEventBySlug(params.slug, http, callMidpoint);
             return event ? [event] : [];
         }
         // Query-based search: use the search endpoint (only endpoint with text search)
         if (params.query) {
-            return await searchEvents(params, http);
+            return await searchEvents(params, http, callMidpoint, callSearch);
         }
         // Default: use the dedicated events API for listing
-        return await fetchEventsList(params, http);
+        return await fetchEventsList(params, http, callMidpoint);
     }
     catch (error) {
         throw errors_1.probableErrorMapper.mapError(error);
     }
 }
-async function fetchEventById(id, http = axios_1.default) {
+async function fetchEventById(id, http = axios_1.default, callMidpoint) {
     try {
         const numericId = Number(id);
         if (isNaN(numericId))
             return null;
         const response = await http.get(`${utils_1.BASE_URL}${utils_1.EVENTS_PATH}${numericId}`);
         const event = (0, utils_1.mapEventToUnified)(response.data);
-        if (event)
-            await (0, utils_1.enrichMarketsWithPrices)(event.markets);
+        if (event && callMidpoint)
+            await (0, utils_1.enrichMarketsWithPrices)(event.markets, callMidpoint);
         return event;
     }
     catch (error) {
@@ -49,12 +49,12 @@ async function fetchEventById(id, http = axios_1.default) {
         throw errors_1.probableErrorMapper.mapError(error);
     }
 }
-async function fetchEventBySlug(slug, http = axios_1.default) {
+async function fetchEventBySlug(slug, http = axios_1.default, callMidpoint) {
     try {
         const response = await http.get(`${utils_1.BASE_URL}${utils_1.EVENTS_PATH}slug/${slug}`);
         const event = (0, utils_1.mapEventToUnified)(response.data);
-        if (event)
-            await (0, utils_1.enrichMarketsWithPrices)(event.markets);
+        if (event && callMidpoint)
+            await (0, utils_1.enrichMarketsWithPrices)(event.markets, callMidpoint);
         return event;
     }
     catch (error) {
@@ -63,7 +63,7 @@ async function fetchEventBySlug(slug, http = axios_1.default) {
         throw errors_1.probableErrorMapper.mapError(error);
     }
 }
-async function fetchEventsList(params, http) {
+async function fetchEventsList(params, http, callMidpoint) {
     const limit = params.limit || 20;
     const page = params.offset ? Math.floor(params.offset / limit) + 1 : 1;
     const queryParams = {
@@ -99,27 +99,30 @@ async function fetchEventsList(params, http) {
         .map((event) => (0, utils_1.mapEventToUnified)(event))
         .filter((e) => e !== null);
     const allMarkets = result.flatMap((e) => e.markets);
-    await (0, utils_1.enrichMarketsWithPrices)(allMarkets);
+    if (callMidpoint)
+        await (0, utils_1.enrichMarketsWithPrices)(allMarkets, callMidpoint);
     return result;
 }
-async function searchEvents(params, http) {
+async function searchEvents(params, http, callMidpoint, callSearch) {
     const limit = params.limit || 20;
     const page = params.offset ? Math.floor(params.offset / limit) + 1 : 1;
-    const response = await http.get(`${utils_1.BASE_URL}${utils_1.SEARCH_PATH}`, {
-        params: {
-            q: params.query,
-            page,
-            limit,
-            events_status: mapStatus(params.status),
-            keep_closed_markets: params.status === 'all' || params.status === 'inactive' || params.status === 'closed' ? 1 : 0,
-        },
-    });
-    const events = response.data?.events || [];
+    const queryParams = {
+        q: params.query,
+        page,
+        limit,
+        events_status: mapStatus(params.status),
+        keep_closed_markets: params.status === 'all' || params.status === 'inactive' || params.status === 'closed' ? 1 : 0,
+    };
+    const searchData = callSearch
+        ? await callSearch(queryParams)
+        : (await http.get(`${utils_1.BASE_URL}${utils_1.SEARCH_PATH}`, { params: queryParams })).data;
+    const events = searchData?.events || [];
     const result = events
         .map((event) => (0, utils_1.mapEventToUnified)(event))
         .filter((e) => e !== null);
     const allMarkets = result.flatMap((e) => e.markets);
-    await (0, utils_1.enrichMarketsWithPrices)(allMarkets);
+    if (callMidpoint)
+        await (0, utils_1.enrichMarketsWithPrices)(allMarkets, callMidpoint);
     return result;
 }
 function isNotFoundError(error) {

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

@@ -1,4 +1,4 @@
 import { MarketFetchParams } from '../../BaseExchange';
 import { UnifiedMarket } from '../../types';
 import { AxiosInstance } from 'axios';
-export declare function fetchMarkets(params?: MarketFetchParams, http?: AxiosInstance): Promise<UnifiedMarket[]>;
+export declare function fetchMarkets(params?: MarketFetchParams, http?: AxiosInstance, callMidpoint?: (tokenId: string) => Promise<any>, callSearch?: (params: any) => Promise<any>): Promise<UnifiedMarket[]>;

package/dist/exchanges/probable/fetchMarkets.js

@@ -7,37 +7,37 @@ exports.fetchMarkets = fetchMarkets;
 const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
-async function fetchMarkets(params, http = axios_1.default) {
+async function fetchMarkets(params, http = axios_1.default, callMidpoint, callSearch) {
     try {
         // Handle marketId lookup (numeric ID or slug)
         if (params?.marketId) {
-            return await fetchMarketByIdOrSlug(params.marketId, http);
+            return await fetchMarketByIdOrSlug(params.marketId, http, callMidpoint, callSearch);
         }
         // Slug-based lookup: try market ID or slug via dedicated endpoint
         if (params?.slug) {
-            return await fetchMarketByIdOrSlug(params.slug, http);
+            return await fetchMarketByIdOrSlug(params.slug, http, callMidpoint, callSearch);
         }
         // Handle outcomeId lookup (no direct API, fetch and filter client-side)
         if (params?.outcomeId) {
-            const markets = await fetchMarketsList(params, http);
+            const markets = await fetchMarketsList(params, http, callMidpoint);
             return markets.filter(m => m.outcomes.some(o => o.outcomeId === params.outcomeId));
         }
         // Handle eventId lookup (use markets list with eventId param)
         if (params?.eventId) {
-            return await fetchMarketsList(params, http);
+            return await fetchMarketsList(params, http, callMidpoint);
         }
         // Query-based search: use the search endpoint (only endpoint with text search)
         if (params?.query) {
-            return await searchAndExtractMarkets(params.query, params, http);
+            return await searchAndExtractMarkets(params.query, params, http, callMidpoint, callSearch);
         }
         // Default: use the dedicated markets API for listing
-        return await fetchMarketsList(params, http);
+        return await fetchMarketsList(params, http, callMidpoint);
     }
     catch (error) {
         throw errors_1.probableErrorMapper.mapError(error);
     }
 }
-async function fetchMarketByIdOrSlug(slug, http) {
+async function fetchMarketByIdOrSlug(slug, http, callMidpoint, callSearch) {
     let cleanSlug = slug;
     let marketIdFromQuery = null;
     // Handle URLs or partial URLs with query params (e.g., opinion-...-launch?market=584)
@@ -50,7 +50,7 @@ async function fetchMarketByIdOrSlug(slug, http) {
             marketIdFromQuery = params.get('market');
             // If we have a market ID from the query, try that first
             if (marketIdFromQuery) {
-                const result = await fetchMarketByIdOrSlug(marketIdFromQuery, http);
+                const result = await fetchMarketByIdOrSlug(marketIdFromQuery, http, callMidpoint);
                 if (result.length > 0)
                     return result;
             }
@@ -66,13 +66,14 @@ async function fetchMarketByIdOrSlug(slug, http) {
             const response = await http.get(`${utils_1.BASE_URL}${utils_1.MARKETS_PATH}${numericId}`);
             const mapped = (0, utils_1.mapMarketToUnified)(response.data, response.data?.event);
             const results = mapped ? [mapped] : [];
-            await (0, utils_1.enrichMarketsWithPrices)(results);
+            if (callMidpoint)
+                await (0, utils_1.enrichMarketsWithPrices)(results, callMidpoint);
             return results;
         }
         catch (error) {
             if (isMarketNotFoundError(error)) {
                 // Individual market endpoint returned 500/404; fall back to list and filter
-                const allMarkets = await fetchMarketsList({ limit: 100 }, http);
+                const allMarkets = await fetchMarketsList({ limit: 100 }, http, callMidpoint);
                 const match = allMarkets.filter(m => m.marketId === cleanSlug);
                 if (match.length > 0)
                     return match;
@@ -83,9 +84,9 @@ async function fetchMarketByIdOrSlug(slug, http) {
         }
     }
     // Fall back to search for slug-based matching
-    return await searchAndExtractMarkets(cleanSlug, { slug: cleanSlug }, http);
+    return await searchAndExtractMarkets(cleanSlug, { slug: cleanSlug }, http, callMidpoint, callSearch);
 }
-async function fetchMarketsList(params, http) {
+async function fetchMarketsList(params, http, callMidpoint) {
     const limit = params?.limit || 20;
     const page = params?.offset ? Math.floor(params.offset / limit) + 1 : 1;
     const queryParams = {
@@ -124,10 +125,11 @@ async function fetchMarketsList(params, http) {
         if (mapped)
             allMarkets.push(mapped);
     }
-    await (0, utils_1.enrichMarketsWithPrices)(allMarkets);
+    if (callMidpoint)
+        await (0, utils_1.enrichMarketsWithPrices)(allMarkets, callMidpoint);
     return allMarkets;
 }
-async function searchAndExtractMarkets(query, params, http) {
+async function searchAndExtractMarkets(query, params, http, callMidpoint, callSearch) {
     const limit = params?.limit || 20;
     const page = params?.offset ? Math.floor(params.offset / limit) + 1 : 1;
     // Improve search for slugs: if the query looks like a slug (has dashes), 
@@ -184,10 +186,10 @@ async function searchAndExtractMarkets(query, params, http) {
                 break;
         }
     }
-    const response = await http.get(`${utils_1.BASE_URL}${utils_1.SEARCH_PATH}`, {
-        params: queryParams,
-    });
-    const events = response.data?.events || [];
+    const searchData = callSearch
+        ? await callSearch(queryParams)
+        : (await http.get(`${utils_1.BASE_URL}${utils_1.SEARCH_PATH}`, { params: queryParams })).data;
+    const events = searchData?.events || [];
     const allMarkets = [];
     for (const event of events) {
         if (event.markets && Array.isArray(event.markets)) {
@@ -211,7 +213,8 @@ async function searchAndExtractMarkets(query, params, http) {
             delete m._eventSlug;
         }
         if (exact.length > 0) {
-            await (0, utils_1.enrichMarketsWithPrices)(exact);
+            if (callMidpoint)
+                await (0, utils_1.enrichMarketsWithPrices)(exact, callMidpoint);
             return exact;
         }
     }
@@ -219,7 +222,8 @@ async function searchAndExtractMarkets(query, params, http) {
     for (const m of allMarkets) {
         delete m._eventSlug;
     }
-    await (0, utils_1.enrichMarketsWithPrices)(allMarkets);
+    if (callMidpoint)
+        await (0, utils_1.enrichMarketsWithPrices)(allMarkets, callMidpoint);
     return allMarkets;
 }
 function isMarketNotFoundError(error) {

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

@@ -22,6 +22,7 @@ export declare class ProbableExchange extends PredictionMarketExchange {
     private wsConfig?;
     constructor(credentials?: ExchangeCredentials, wsConfig?: ProbableWebSocketConfig);
     get name(): string;
+    protected mapImplicitApiError(error: any): any;
     private ensureAuth;
     protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;

package/dist/exchanges/probable/index.js

@@ -4,16 +4,34 @@ exports.ProbableExchange = void 0;
 const BaseExchange_1 = require("../../BaseExchange");
 const fetchMarkets_1 = require("./fetchMarkets");
 const fetchEvents_1 = require("./fetchEvents");
-const fetchOrderBook_1 = require("./fetchOrderBook");
-const fetchOHLCV_1 = require("./fetchOHLCV");
-const fetchPositions_1 = require("./fetchPositions");
 const fetchTrades_1 = require("./fetchTrades");
 const auth_1 = require("./auth");
 const websocket_1 = require("./websocket");
 const errors_1 = require("./errors");
 const errors_2 = require("../../errors");
 const clob_1 = require("@prob/clob");
+const openapi_1 = require("../../utils/openapi");
+const api_1 = require("./api");
+const utils_1 = require("./utils");
 const BSC_USDT_ADDRESS = '0x55d398326f99059fF775485246999027B3197955';
+function aggregateCandles(candles, intervalMs) {
+    if (candles.length === 0)
+        return [];
+    const buckets = new Map();
+    for (const c of candles) {
+        const key = Math.floor(c.timestamp / intervalMs) * intervalMs;
+        const existing = buckets.get(key);
+        if (!existing) {
+            buckets.set(key, { ...c, timestamp: key });
+        }
+        else {
+            existing.high = Math.max(existing.high, c.high);
+            existing.low = Math.min(existing.low, c.low);
+            existing.close = c.close;
+        }
+    }
+    return Array.from(buckets.values()).sort((a, b) => a.timestamp - b.timestamp);
+}
 class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
     has = {
         fetchMarkets: true,
@@ -39,10 +57,15 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
         if (credentials?.privateKey && credentials?.apiKey && credentials?.apiSecret && credentials?.passphrase) {
             this.auth = new auth_1.ProbableAuth(credentials);
         }
+        const descriptor = (0, openapi_1.parseOpenApiSpec)(api_1.probableApiSpec, utils_1.BASE_URL);
+        this.defineImplicitApi(descriptor);
     }
     get name() {
         return 'Probable';
     }
+    mapImplicitApiError(error) {
+        throw errors_1.probableErrorMapper.mapError(error);
+    }
     ensureAuth() {
         if (!this.auth) {
             throw new errors_2.AuthenticationError('Trading operations require authentication. ' +
@@ -54,22 +77,70 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
     // Market Data (read-only, no auth needed)
     // --------------------------------------------------------------------------
     async fetchMarketsImpl(params) {
-        return (0, fetchMarkets_1.fetchMarkets)(params, this.http);
+        return (0, fetchMarkets_1.fetchMarkets)(params, this.http, (tokenId) => this.callApi('getPublicApiV1Midpoint', { token_id: tokenId }), (queryParams) => this.callApi('getPublicApiV1PublicSearch', queryParams));
     }
     async fetchEventsImpl(params) {
-        return (0, fetchEvents_1.fetchEvents)(params, this.http);
+        return (0, fetchEvents_1.fetchEvents)(params, this.http, (tokenId) => this.callApi('getPublicApiV1Midpoint', { token_id: tokenId }), (queryParams) => this.callApi('getPublicApiV1PublicSearch', queryParams));
     }
     async getEventById(id) {
-        return (0, fetchEvents_1.fetchEventById)(id, this.http);
+        return (0, fetchEvents_1.fetchEventById)(id, this.http, (tokenId) => this.callApi('getPublicApiV1Midpoint', { token_id: tokenId }));
     }
     async getEventBySlug(slug) {
-        return (0, fetchEvents_1.fetchEventBySlug)(slug, this.http);
+        return (0, fetchEvents_1.fetchEventBySlug)(slug, this.http, (tokenId) => this.callApi('getPublicApiV1Midpoint', { token_id: tokenId }));
     }
     async fetchOrderBook(id) {
-        return (0, fetchOrderBook_1.fetchOrderBook)(id, this.http);
+        const data = await this.callApi('getPublicApiV1Book', { token_id: id });
+        const bids = (data.bids || [])
+            .map((level) => ({ price: parseFloat(level.price), size: parseFloat(level.size) }))
+            .sort((a, b) => b.price - a.price);
+        const asks = (data.asks || [])
+            .map((level) => ({ price: parseFloat(level.price), size: parseFloat(level.size) }))
+            .sort((a, b) => a.price - b.price);
+        return {
+            bids,
+            asks,
+            timestamp: data.timestamp ? new Date(data.timestamp).getTime() : Date.now(),
+        };
     }
     async fetchOHLCV(id, params) {
-        return (0, fetchOHLCV_1.fetchOHLCV)(id, params, this.http);
+        if (!params.resolution) {
+            throw new Error('fetchOHLCV requires a resolution parameter.');
+        }
+        const INTERVAL_MAP = {
+            '1m': '1m',
+            '5m': '1m',
+            '15m': '1m',
+            '1h': '1h',
+            '6h': '6h',
+            '1d': '1d',
+        };
+        const queryParams = {
+            market: id,
+            interval: INTERVAL_MAP[params.resolution] || '1h',
+        };
+        if (params.start)
+            queryParams.startTs = Math.floor(params.start.getTime() / 1000);
+        if (params.end)
+            queryParams.endTs = Math.floor(params.end.getTime() / 1000);
+        const data = await this.callApi('getPublicApiV1PricesHistory', queryParams);
+        const points = data?.history || data || [];
+        let candles = points
+            .map((p) => {
+            const price = Number(p.p);
+            const ts = Number(p.t) * 1000;
+            return { timestamp: ts, open: price, high: price, low: price, close: price, volume: 0 };
+        })
+            .sort((a, b) => a.timestamp - b.timestamp);
+        if (params.resolution === '5m') {
+            candles = aggregateCandles(candles, 5 * 60 * 1000);
+        }
+        else if (params.resolution === '15m') {
+            candles = aggregateCandles(candles, 15 * 60 * 1000);
+        }
+        if (params.limit) {
+            candles = candles.slice(-params.limit);
+        }
+        return candles;
     }
     // --------------------------------------------------------------------------
     // Trading Methods
@@ -231,7 +302,18 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
         try {
             const auth = this.ensureAuth();
             const address = auth.getAddress();
-            return (0, fetchPositions_1.fetchPositions)(address);
+            const result = await this.callApi('getPublicApiV1PositionCurrent', { user: address, limit: 500 });
+            const data = Array.isArray(result) ? result : (result?.data || []);
+            return data.map((p) => ({
+                marketId: String(p.conditionId || p.condition_id || ''),
+                outcomeId: String(p.asset || p.token_id || ''),
+                outcomeLabel: p.outcome || p.title || 'Unknown',
+                size: parseFloat(p.size || '0'),
+                entryPrice: parseFloat(p.avgPrice || p.avg_price || '0'),
+                currentPrice: parseFloat(p.curPrice || p.cur_price || '0'),
+                unrealizedPnL: parseFloat(p.cashPnl || p.cash_pnl || '0'),
+                realizedPnL: parseFloat(p.realizedPnl || p.realized_pnl || '0'),
+            }));
         }
         catch (error) {
             throw errors_1.probableErrorMapper.mapError(error);

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

@@ -1,9 +1,8 @@
 import { UnifiedMarket, UnifiedEvent } from '../../types';
 export declare const BASE_URL = "https://market-api.probable.markets";
-export declare const CLOB_BASE_URL = "https://api.probable.markets/public/api/v1";
 export declare const SEARCH_PATH = "/public/api/v1/public-search/";
 export declare const EVENTS_PATH = "/public/api/v1/events/";
 export declare const MARKETS_PATH = "/public/api/v1/markets/";
 export declare function mapMarketToUnified(market: any, event?: any): UnifiedMarket | null;
 export declare function mapEventToUnified(event: any): UnifiedEvent | null;
-export declare function enrichMarketsWithPrices(markets: UnifiedMarket[]): Promise<void>;
+export declare function enrichMarketsWithPrices(markets: UnifiedMarket[], callMidpoint: (tokenId: string) => Promise<any>): Promise<void>;

package/dist/exchanges/probable/utils.js

@@ -1,16 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MARKETS_PATH = exports.EVENTS_PATH = exports.SEARCH_PATH = exports.CLOB_BASE_URL = exports.BASE_URL = void 0;
+exports.MARKETS_PATH = exports.EVENTS_PATH = exports.SEARCH_PATH = exports.BASE_URL = void 0;
 exports.mapMarketToUnified = mapMarketToUnified;
 exports.mapEventToUnified = mapEventToUnified;
 exports.enrichMarketsWithPrices = enrichMarketsWithPrices;
 const market_utils_1 = require("../../utils/market-utils");
-const axios_1 = __importDefault(require("axios"));
 exports.BASE_URL = 'https://market-api.probable.markets';
-exports.CLOB_BASE_URL = 'https://api.probable.markets/public/api/v1';
 exports.SEARCH_PATH = '/public/api/v1/public-search/';
 exports.EVENTS_PATH = '/public/api/v1/events/';
 exports.MARKETS_PATH = '/public/api/v1/markets/';
@@ -73,7 +68,7 @@ function mapEventToUnified(event) {
         tags: event.tags || [],
     };
 }
-async function enrichMarketsWithPrices(markets) {
+async function enrichMarketsWithPrices(markets, callMidpoint) {
     const outcomes = [];
     for (const market of markets) {
         for (const outcome of market.outcomes) {
@@ -84,10 +79,8 @@ async function enrichMarketsWithPrices(markets) {
     if (outcomes.length === 0)
         return;
     const results = await Promise.allSettled(outcomes.map(async (outcome) => {
-        const response = await axios_1.default.get(`${exports.CLOB_BASE_URL}/midpoint`, {
-            params: { token_id: outcome.outcomeId },
-        });
-        return { outcomeId: outcome.outcomeId, mid: Number(response.data?.mid ?? 0) };
+        const response = await callMidpoint(outcome.outcomeId);
+        return { outcomeId: outcome.outcomeId, mid: Number(response?.mid ?? 0) };
     }));
     const priceMap = {};
     for (const result of results) {

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from './BaseExchange';
 export * from './types';
 export * from './utils/math';
+export { parseOpenApiSpec } from './utils/openapi';
 export * from './errors';
 export * from './exchanges/polymarket';
 export * from './exchanges/limitless';

package/dist/index.js

@@ -14,10 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Myriad = exports.Baozi = exports.Probable = exports.Kalshi = exports.Limitless = exports.Polymarket = void 0;
+exports.Myriad = exports.Baozi = exports.Probable = exports.Kalshi = exports.Limitless = exports.Polymarket = exports.parseOpenApiSpec = void 0;
 __exportStar(require("./BaseExchange"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils/math"), exports);
+var openapi_1 = require("./utils/openapi");
+Object.defineProperty(exports, "parseOpenApiSpec", { enumerable: true, get: function () { return openapi_1.parseOpenApiSpec; } });
 __exportStar(require("./errors"), exports);
 __exportStar(require("./exchanges/polymarket"), exports);
 __exportStar(require("./exchanges/limitless"), exports);

package/dist/utils/openapi.d.ts

@@ -0,0 +1,9 @@
+import { ApiDescriptor } from '../BaseExchange';
+/**
+ * Parses an OpenAPI 3.x-shaped spec object into a simplified ApiDescriptor.
+ *
+ * @param spec - An OpenAPI-like spec object with `paths` and optionally `servers`
+ * @param baseUrl - The base URL for the API. If omitted, extracted from spec.servers[0].url
+ * @returns A simplified ApiDescriptor with method names mapped to endpoints
+ */
+export declare function parseOpenApiSpec(spec: any, baseUrl?: string): ApiDescriptor;

package/dist/utils/openapi.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOpenApiSpec = parseOpenApiSpec;
+/**
+ * Converts a path segment like "orderbook" or "market-trades" to PascalCase.
+ * e.g. "orderbook" -> "Orderbook", "market-trades" -> "MarketTrades"
+ */
+function toPascalCase(segment) {
+    return segment
+        .split(/[-_]/)
+        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+/**
+ * Generates a method name from an HTTP method and path.
+ * e.g. GET /markets/{ticker}/orderbook -> getMarketsOrderbook
+ */
+function generateMethodName(httpMethod, path) {
+    const segments = path
+        .split('/')
+        .filter(s => s && !s.startsWith('{'));
+    const pascalPath = segments.map(toPascalCase).join('');
+    return httpMethod.toLowerCase() + pascalPath;
+}
+/**
+ * Parses an OpenAPI 3.x-shaped spec object into a simplified ApiDescriptor.
+ *
+ * @param spec - An OpenAPI-like spec object with `paths` and optionally `servers`
+ * @param baseUrl - The base URL for the API. If omitted, extracted from spec.servers[0].url
+ * @returns A simplified ApiDescriptor with method names mapped to endpoints
+ */
+function parseOpenApiSpec(spec, baseUrl) {
+    const resolvedBaseUrl = baseUrl
+        || (spec.servers && spec.servers[0] && spec.servers[0].url)
+        || '';
+    const endpoints = {};
+    // Inherit top-level security when operations don't define their own
+    const topLevelSecurity = !!(spec.security && spec.security.length > 0);
+    const paths = spec.paths || {};
+    for (const [path, methods] of Object.entries(paths)) {
+        for (const [httpMethod, operation] of Object.entries(methods)) {
+            // Skip non-HTTP-method keys like "parameters"
+            if (!['get', 'post', 'put', 'patch', 'delete'].includes(httpMethod.toLowerCase())) {
+                continue;
+            }
+            const name = operation.operationId || generateMethodName(httpMethod, path);
+            const isPrivate = operation.security !== undefined
+                ? !!(operation.security && operation.security.length > 0)
+                : topLevelSecurity;
+            endpoints[name] = {
+                method: httpMethod.toUpperCase(),
+                path,
+                isPrivate,
+                operationId: operation.operationId,
+            };
+        }
+    }
+    return { baseUrl: resolvedBaseUrl, endpoints };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmxt-core",
-  "version": "2.8.0",
+  "version": "2.9.1",
   "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,9 @@
     "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.8.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.8.0,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.9.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.9.1,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",
     "generate:sdk:all": "npm run generate:sdk:python && npm run generate:sdk:typescript && npm run generate:docs"

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

@@ -1,3 +0,0 @@
-import { AxiosInstance } from 'axios';
-import { OrderBook } from '../../types';
-export declare function fetchOrderBook(id: string, http?: AxiosInstance): Promise<OrderBook>;