pmxt-core 2.7.0 → 2.9.0

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

@@ -1,4 +1,3 @@
 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 fetchEvents(params: EventFetchParams, callApi: (operationId: string, params?: Record<string, any>) => Promise<any>): Promise<UnifiedEvent[]>;

package/dist/exchanges/limitless/fetchEvents.js

@@ -32,18 +32,14 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchEvents = fetchEvents;
-const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
-async function fetchEventBySlug(slug, http) {
+async function fetchEventBySlug(slug) {
     const { HttpClient, MarketFetcher } = await Promise.resolve().then(() => __importStar(require('@limitless-exchange/sdk')));
     const httpClient = new HttpClient({ baseURL: utils_1.LIMITLESS_API_URL });
-    // TODO: Ideally inject 'http' into HttpClient if supported, but SDK abstracts it.
+    // TODO: Ideally inject http into HttpClient if supported, but SDK abstracts it.
     // For now, single market fetch uses SDK's internal client.
     const marketFetcher = new MarketFetcher(httpClient);
     const market = await marketFetcher.getMarket(slug);
@@ -72,25 +68,23 @@ async function fetchEventBySlug(slug, http) {
         tags: market.tags || []
     };
 }
-async function fetchEvents(params, http = axios_1.default) {
+async function fetchEvents(params, callApi) {
     try {
         // Handle eventId/slug lookup (same thing for Limitless)
         if (params.eventId || params.slug) {
             const slug = params.eventId || params.slug;
-            const event = await fetchEventBySlug(slug, http);
+            const event = await fetchEventBySlug(slug);
             return event ? [event] : [];
         }
         // 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 http.get(`${utils_1.LIMITLESS_API_URL}/markets/search`, {
-            params: {
-                query: params.query,
-                limit: params?.limit || 10000,
-                similarityThreshold: 0.5
-            }
+        const data = await callApi('MarketSearchController_search', {
+            query: params.query,
+            limit: params?.limit || 10000,
+            similarityThreshold: 0.5,
         });
-        let markets = response.data?.markets || [];
+        let markets = data?.markets || [];
         // Filter by status based on expired/resolved state
         // Active: not expired and not resolved
         // Inactive: expired OR resolved (has winningOutcomeIndex)

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

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

package/dist/exchanges/limitless/fetchMarkets.js

@@ -32,15 +32,11 @@ var __importStar = (this && this.__importStar) || (function () {
         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 axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
-async function fetchMarkets(params, apiKey, http = axios_1.default) {
+async function fetchMarkets(params, apiKey, callApi) {
     // Limitless API currently only supports fetching active markets for lists
     // Early return to avoid SDK initialization in tests
     if (params?.status === 'inactive' || params?.status === 'closed') {
@@ -74,7 +70,7 @@ async function fetchMarkets(params, apiKey, http = axios_1.default) {
         }
         // Handle query-based search
         if (params?.query) {
-            return await searchMarkets(params.query, params, http);
+            return await searchMarkets(params.query, params, callApi);
         }
         // Default: fetch active markets
         return await fetchMarketsDefault(marketFetcher, params);
@@ -90,19 +86,16 @@ async function fetchMarketsBySlug(marketFetcher, slug) {
     const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
     return unifiedMarket ? [unifiedMarket] : [];
 }
-async function searchMarkets(query, params, http) {
-    // SDK doesn't have a search method yet, use axios directly
+async function searchMarkets(query, params, callApi) {
     // 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 http.get(`${utils_1.LIMITLESS_API_URL}/markets/search`, {
-        params: {
-            query: query,
-            limit: params?.limit || 10000,
-            page: params?.page || 1,
-            similarityThreshold: params?.similarityThreshold || 0.5
-        }
+    const data = await callApi('MarketSearchController_search', {
+        query: query,
+        limit: params?.limit || 250000,
+        page: params?.page || 1,
+        similarityThreshold: params?.similarityThreshold || 0.5,
     });
-    const rawResults = response?.data?.markets || [];
+    const rawResults = data?.markets || [];
     const allMarkets = [];
     for (const res of rawResults) {
         if (res.markets && Array.isArray(res.markets)) {
@@ -121,10 +114,10 @@ async function searchMarkets(query, params, http) {
     }
     return allMarkets
         .filter((m) => m !== null && m.outcomes.length > 0)
-        .slice(0, params?.limit || 10000);
+        .slice(0, params?.limit || 250000);
 }
 async function fetchMarketsDefault(marketFetcher, params) {
-    const limit = params?.limit || 10000;
+    const limit = params?.limit || 250000;
     const offset = params?.offset || 0;
     // Map sort parameter to SDK's sortBy
     let sortBy = 'lp_rewards';

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

@@ -1,8 +1,7 @@
-import { AxiosInstance } from 'axios';
 import { HistoryFilterParams, OHLCVParams } from '../../BaseExchange';
 import { PriceCandle } from '../../types';
 /**
  * Fetch historical price data (candles) for a specific market.
  * @param id - The market slug
  */
-export declare function fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams, http?: AxiosInstance): Promise<PriceCandle[]>;
+export declare function fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams, callApi: (operationId: string, params?: Record<string, any>) => Promise<any>): Promise<PriceCandle[]>;

package/dist/exchanges/limitless/fetchOHLCV.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchOHLCV = fetchOHLCV;
-const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const validation_1 = require("../../utils/validation");
 const errors_1 = require("./errors");
@@ -12,7 +8,7 @@ const errors_1 = require("./errors");
  * Fetch historical price data (candles) for a specific market.
  * @param id - The market slug
  */
-async function fetchOHLCV(id, params, http = axios_1.default) {
+async function fetchOHLCV(id, params, callApi) {
     (0, validation_1.validateIdFormat)(id, 'OHLCV');
     // Validate resolution is provided
     if (!params.resolution) {
@@ -20,12 +16,7 @@ async function fetchOHLCV(id, params, http = axios_1.default) {
     }
     try {
         const fidelity = (0, utils_1.mapIntervalToFidelity)(params.resolution);
-        // New API endpoint: /markets/{slug}/historical-price
-        const url = `${utils_1.LIMITLESS_API_URL}/markets/${id}/historical-price`;
-        const response = await http.get(url, {
-            params: { fidelity }
-        });
-        const data = response.data;
+        const data = await callApi('MarketOrderbookController_getHistoricalPrice', { slug: id, fidelity });
         const prices = data.prices || [];
         // Map price points to pmxt PriceCandle format
         // The API returns price points, so we treat each point as a candle

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

@@ -1,7 +1,6 @@
-import { AxiosInstance } from 'axios';
 import { OrderBook } from '../../types';
 /**
  * Fetch the current order book for a specific market.
  * @param id - The market slug (preferred) or CLOB token ID
  */
-export declare function fetchOrderBook(id: string, http?: AxiosInstance): Promise<OrderBook>;
+export declare function fetchOrderBook(id: string, callApi: (operationId: string, params?: Record<string, any>) => Promise<any>): Promise<OrderBook>;

package/dist/exchanges/limitless/fetchOrderBook.js

@@ -1,11 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchOrderBook = fetchOrderBook;
-const axios_1 = __importDefault(require("axios"));
-const utils_1 = require("./utils");
 const validation_1 = require("../../utils/validation");
 // Limitless uses USDC with 6 decimals
 const USDC_DECIMALS = 6;
@@ -20,14 +15,10 @@ function convertSize(rawSize) {
  * Fetch the current order book for a specific market.
  * @param id - The market slug (preferred) or CLOB token ID
  */
-async function fetchOrderBook(id, http = axios_1.default) {
+async function fetchOrderBook(id, callApi) {
     (0, validation_1.validateIdFormat)(id, 'OrderBook');
     try {
-        // New API uses slugs: /markets/{slug}/orderbook
-        // If 'id' is a numeric token ID, this might fail unless we look up the slug.
-        const url = `${utils_1.LIMITLESS_API_URL}/markets/${id}/orderbook`;
-        const response = await http.get(url);
-        const data = response.data;
+        const data = await callApi('MarketOrderbookController_getOrderbook', { slug: id });
         // Response format: { bids: [{price: 0.52, size: 100000000}], asks: [...] }
         // Sizes are in smallest unit (USDC with 6 decimals), convert to human-readable
         const bids = (data.bids || []).map((level) => ({

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

@@ -27,6 +27,7 @@ export declare class LimitlessExchange extends PredictionMarketExchange {
     private wsConfig?;
     constructor(options?: ExchangeCredentials | LimitlessExchangeOptions);
     get name(): string;
+    protected mapImplicitApiError(error: any): any;
     protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
     fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams): Promise<PriceCandle[]>;

package/dist/exchanges/limitless/index.js

@@ -7,7 +7,6 @@ const fetchEvents_1 = require("./fetchEvents");
 const fetchOHLCV_1 = require("./fetchOHLCV");
 const fetchOrderBook_1 = require("./fetchOrderBook");
 const fetchTrades_1 = require("./fetchTrades");
-const fetchPositions_1 = require("./fetchPositions");
 const auth_1 = require("./auth");
 const client_1 = require("./client");
 const websocket_1 = require("./websocket");
@@ -15,6 +14,8 @@ const errors_1 = require("./errors");
 const errors_2 = require("../../errors");
 const sdk_1 = require("@limitless-exchange/sdk");
 const ethers_1 = require("ethers");
+const openapi_1 = require("../../utils/openapi");
+const api_1 = require("./api");
 class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
     has = {
         fetchMarkets: true,
@@ -70,26 +71,35 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
                 console.warn('Failed to initialize Limitless auth:', error);
             }
         }
+        // Register implicit API for Limitless REST endpoints
+        const apiDescriptor = (0, openapi_1.parseOpenApiSpec)(api_1.limitlessApiSpec);
+        this.defineImplicitApi(apiDescriptor);
     }
     get name() {
         return 'Limitless';
     }
     // ----------------------------------------------------------------------------
+    // Implicit API Error Mapping
+    // ----------------------------------------------------------------------------
+    mapImplicitApiError(error) {
+        throw errors_1.limitlessErrorMapper.mapError(error);
+    }
+    // ----------------------------------------------------------------------------
     // Implementation methods for CCXT-style API
     // ----------------------------------------------------------------------------
     async fetchMarketsImpl(params) {
         // Pass API key if available for authenticated requests
         const apiKey = this.auth?.getApiKey();
-        return (0, fetchMarkets_1.fetchMarkets)(params, apiKey, this.http);
+        return (0, fetchMarkets_1.fetchMarkets)(params, apiKey, this.callApi.bind(this));
     }
     async fetchEventsImpl(params) {
-        return (0, fetchEvents_1.fetchEvents)(params, this.http);
+        return (0, fetchEvents_1.fetchEvents)(params, this.callApi.bind(this));
     }
     async fetchOHLCV(id, params) {
-        return (0, fetchOHLCV_1.fetchOHLCV)(id, params, this.http);
+        return (0, fetchOHLCV_1.fetchOHLCV)(id, params, this.callApi.bind(this));
     }
     async fetchOrderBook(id) {
-        return (0, fetchOrderBook_1.fetchOrderBook)(id, this.http);
+        return (0, fetchOrderBook_1.fetchOrderBook)(id, this.callApi.bind(this));
     }
     async fetchTrades(id, params) {
         // Deprecation warning
@@ -218,7 +228,18 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
     async fetchPositions() {
         const auth = this.ensureAuth();
         const address = auth.getAddress();
-        return (0, fetchPositions_1.fetchPositions)(address);
+        const result = await this.callApi('PublicPortfolioController_getPositions', { account: address });
+        const data = result?.data || result || [];
+        return data.map((p) => ({
+            marketId: p.market?.slug || p.conditionId,
+            outcomeId: p.asset,
+            outcomeLabel: p.outcome || 'Unknown',
+            size: parseFloat(p.size || '0'),
+            entryPrice: parseFloat(p.avgPrice || '0'),
+            currentPrice: parseFloat(p.curPrice || '0'),
+            unrealizedPnL: parseFloat(p.cashPnl || '0'),
+            realizedPnL: parseFloat(p.realizedPnl || '0'),
+        }));
     }
     async fetchBalance() {
         const auth = this.ensureAuth();
@@ -262,7 +283,7 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
                 ...this.wsConfig,
                 apiKey: this.auth?.getApiKey(),
             };
-            this.ws = new websocket_1.LimitlessWebSocket(wsConfig);
+            this.ws = new websocket_1.LimitlessWebSocket(this.callApi.bind(this), wsConfig);
         }
         return this.ws;
     }

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

@@ -19,12 +19,13 @@ export interface LimitlessWebSocketConfig extends Partial<WebSocketConfig> {
 export declare class LimitlessWebSocket {
     private client;
     private config;
+    private callApi;
     private orderbookCallbacks;
     private priceCallbacks;
     private orderbookResolvers;
     private orderbookBuffers;
     private lastOrderbookTimestamps;
-    constructor(config?: LimitlessWebSocketConfig);
+    constructor(callApi: (operationId: string, params?: Record<string, any>) => Promise<any>, config?: LimitlessWebSocketConfig);
     private setupEventHandlers;
     /**
      * Watch orderbook updates for a CLOB market.

package/dist/exchanges/limitless/websocket.js

@@ -23,12 +23,14 @@ function convertSize(rawSize) {
 class LimitlessWebSocket {
     client;
     config;
+    callApi;
     orderbookCallbacks = new Map();
     priceCallbacks = new Map();
     orderbookResolvers = new Map();
     orderbookBuffers = new Map();
     lastOrderbookTimestamps = new Map();
-    constructor(config = {}) {
+    constructor(callApi, config = {}) {
+        this.callApi = callApi;
         this.config = config;
         // Initialize SDK WebSocket client
         const wsConfig = {
@@ -122,7 +124,7 @@ class LimitlessWebSocket {
         if (!this.lastOrderbookTimestamps.has(marketSlug)) {
             this.lastOrderbookTimestamps.set(marketSlug, Date.now());
             try {
-                return await (0, fetchOrderBook_1.fetchOrderBook)(marketSlug);
+                return await (0, fetchOrderBook_1.fetchOrderBook)(marketSlug, this.callApi);
             }
             catch (err) {
                 console.warn(`[LimitlessWS] Failed to fetch initial snapshot:`, err);
@@ -139,7 +141,7 @@ class LimitlessWebSocket {
         if (timeSinceLastUpdate > SNAPSHOT_REFRESH_INTERVAL) {
             this.lastOrderbookTimestamps.set(marketSlug, Date.now());
             try {
-                return await (0, fetchOrderBook_1.fetchOrderBook)(marketSlug);
+                return await (0, fetchOrderBook_1.fetchOrderBook)(marketSlug, this.callApi);
             }
             catch (err) {
                 console.warn(`[LimitlessWS] Failed to fetch refresh snapshot:`, err);
@@ -158,7 +160,7 @@ class LimitlessWebSocket {
                     // Timeout: fetch REST snapshot as fallback
                     try {
                         this.lastOrderbookTimestamps.set(marketSlug, Date.now());
-                        const snapshot = await (0, fetchOrderBook_1.fetchOrderBook)(marketSlug);
+                        const snapshot = await (0, fetchOrderBook_1.fetchOrderBook)(marketSlug, this.callApi);
                         resolve(snapshot);
                     }
                     catch (err) {

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

@@ -0,0 +1,294 @@
+/**
+ * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/myriad/myriad.yaml
+ * Generated at: 2026-02-18T15:48:13.507Z
+ * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
+ */
+export declare const myriadApiSpec: {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+    };
+    servers: {
+        url: string;
+    }[];
+    components: {
+        securitySchemes: {
+            ApiKeyHeader: {
+                type: string;
+                in: string;
+                name: string;
+            };
+            ApiKeyQuery: {
+                type: string;
+                in: string;
+                name: string;
+            };
+        };
+    };
+    security: ({
+        ApiKeyHeader: never[];
+        ApiKeyQuery?: undefined;
+    } | {
+        ApiKeyQuery: never[];
+        ApiKeyHeader?: undefined;
+    })[];
+    paths: {
+        "/questions": {
+            get: {
+                summary: string;
+                parameters: ({
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                        default: number;
+                        maximum?: undefined;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                        default: number;
+                        maximum: number;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                        default?: undefined;
+                        maximum?: undefined;
+                    };
+                })[];
+            };
+        };
+        "/questions/{id}": {
+            get: {
+                summary: string;
+                parameters: {
+                    name: string;
+                    in: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                }[];
+            };
+        };
+        "/markets": {
+            get: {
+                summary: string;
+                parameters: ({
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                        default: number;
+                        enum?: undefined;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                        enum: string[];
+                        default: string;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                        default?: undefined;
+                        enum?: undefined;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                        enum: string[];
+                        default?: undefined;
+                    };
+                })[];
+            };
+        };
+        "/markets/{id}": {
+            get: {
+                summary: string;
+                parameters: ({
+                    name: string;
+                    in: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                    };
+                    required?: undefined;
+                })[];
+            };
+        };
+        "/markets/{id}/events": {
+            get: {
+                summary: string;
+                parameters: ({
+                    name: string;
+                    in: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                    };
+                    required?: undefined;
+                })[];
+            };
+        };
+        "/markets/{id}/referrals": {
+            get: {
+                summary: string;
+                parameters: ({
+                    name: string;
+                    in: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                    };
+                    required?: undefined;
+                })[];
+            };
+        };
+        "/markets/{id}/holders": {
+            get: {
+                summary: string;
+                parameters: ({
+                    name: string;
+                    in: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                    };
+                    required?: undefined;
+                })[];
+            };
+        };
+        "/markets/quote": {
+            post: {
+                summary: string;
+            };
+        };
+        "/markets/quote_with_fee": {
+            post: {
+                summary: string;
+            };
+        };
+        "/markets/claim": {
+            post: {
+                summary: string;
+            };
+        };
+        "/users/{address}/events": {
+            get: {
+                summary: string;
+                parameters: ({
+                    name: string;
+                    in: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                    };
+                    required?: undefined;
+                })[];
+            };
+        };
+        "/users/{address}/referrals": {
+            get: {
+                summary: string;
+                parameters: ({
+                    name: string;
+                    in: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                    };
+                    required?: undefined;
+                })[];
+            };
+        };
+        "/users/{address}/portfolio": {
+            get: {
+                summary: string;
+                parameters: ({
+                    name: string;
+                    in: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                    };
+                    required?: undefined;
+                })[];
+            };
+        };
+        "/users/{address}/markets": {
+            get: {
+                summary: string;
+                parameters: ({
+                    name: string;
+                    in: string;
+                    required: boolean;
+                    schema: {
+                        type: string;
+                    };
+                } | {
+                    name: string;
+                    in: string;
+                    schema: {
+                        type: string;
+                    };
+                    required?: undefined;
+                })[];
+            };
+        };
+    };
+};