pmxt-core 2.7.0 → 2.9.0

package/dist/BaseExchange.d.ts

@@ -1,6 +1,22 @@
 import { UnifiedMarket, UnifiedEvent, PriceCandle, CandleInterval, OrderBook, Trade, Order, Position, Balance, CreateOrderParams } from './types';
 import { ExecutionPriceResult } from './utils/math';
 import { AxiosInstance } from 'axios';
+export interface ApiEndpoint {
+    method: string;
+    path: string;
+    isPrivate?: boolean;
+    operationId?: string;
+}
+export interface ApiDescriptor {
+    baseUrl: string;
+    endpoints: Record<string, ApiEndpoint>;
+}
+export interface ImplicitApiMethodInfo {
+    name: string;
+    method: string;
+    path: string;
+    isPrivate: boolean;
+}
 export interface MarketFilterParams {
     limit?: number;
     offset?: number;
@@ -120,12 +136,26 @@ export interface ExchangeCredentials {
     funderAddress?: string;
 }
 export declare abstract class PredictionMarketExchange {
+    [key: string]: any;
     protected credentials?: ExchangeCredentials;
     verbose: boolean;
     http: AxiosInstance;
+    markets: Record<string, UnifiedMarket>;
+    marketsBySlug: Record<string, UnifiedMarket>;
+    loadedMarkets: boolean;
+    protected apiDescriptor?: ApiDescriptor;
+    private apiDescriptors;
     readonly has: ExchangeHas;
     constructor(credentials?: ExchangeCredentials);
     abstract get name(): string;
+    /**
+     * Load and cache markets from the exchange.
+     * This method populates `this.markets` and `this.marketsBySlug`.
+     *
+     * @param reload - Force a reload of markets from the API even if already loaded
+     * @returns Dictionary of markets indexed by marketId
+     */
+    loadMarkets(reload?: boolean): Promise<Record<string, UnifiedMarket>>;
     /**
      * Fetch markets with optional filtering, search, or slug lookup.
      * This is the primary method for retrieving markets.
@@ -584,4 +614,33 @@ export declare abstract class PredictionMarketExchange {
      * exchange.close()
      */
     close(): Promise<void>;
+    /**
+     * Call an implicit API method by its operationId (or auto-generated name).
+     * Provides a typed entry point so unified methods can delegate to the implicit API
+     * without casting to `any` everywhere.
+     */
+    protected callApi(operationId: string, params?: Record<string, any>): Promise<any>;
+    /**
+     * Parse an API descriptor and generate callable methods on this instance.
+     * Existing methods (unified API) are never overwritten.
+     */
+    protected defineImplicitApi(descriptor: ApiDescriptor): void;
+    /**
+     * Creates an async function for an implicit API endpoint.
+     */
+    private createImplicitMethod;
+    /**
+     * Returns auth headers for a private API call.
+     * Exchanges should override this to provide authentication.
+     */
+    protected sign(_method: string, _path: string, _params: Record<string, any>): Record<string, string>;
+    /**
+     * Maps errors from implicit API calls through the exchange's error mapper.
+     * Exchanges should override this to use their specific error mapper.
+     */
+    protected mapImplicitApiError(error: any): any;
+    /**
+     * Introspection getter: returns info about all implicit API methods.
+     */
+    get implicitApi(): ImplicitApiMethodInfo[];
 }

package/dist/BaseExchange.js

@@ -14,6 +14,13 @@ class PredictionMarketExchange {
     credentials;
     verbose = false;
     http;
+    // Market Cache
+    markets = {};
+    marketsBySlug = {};
+    loadedMarkets = false;
+    // Implicit API (merged across multiple defineImplicitApi calls)
+    apiDescriptor;
+    apiDescriptors = [];
     has = {
         fetchMarkets: false,
         fetchEvents: false,
@@ -63,6 +70,32 @@ class PredictionMarketExchange {
             return Promise.reject(error);
         });
     }
+    /**
+     * Load and cache markets from the exchange.
+     * This method populates `this.markets` and `this.marketsBySlug`.
+     *
+     * @param reload - Force a reload of markets from the API even if already loaded
+     * @returns Dictionary of markets indexed by marketId
+     */
+    async loadMarkets(reload = false) {
+        if (this.loadedMarkets && !reload) {
+            return this.markets;
+        }
+        // Fetch all markets (implementation dependent, usually fetches active markets)
+        const markets = await this.fetchMarkets();
+        // Reset caches
+        this.markets = {};
+        this.marketsBySlug = {};
+        for (const market of markets) {
+            this.markets[market.marketId] = market;
+            // Some exchanges provide slugs, if so cache them
+            if (market.slug) {
+                this.marketsBySlug[market.slug] = market;
+            }
+        }
+        this.loadedMarkets = true;
+        return this.markets;
+    }
     /**
      * Fetch markets with optional filtering, search, or slug lookup.
      * This is the primary method for retrieving markets.
@@ -142,6 +175,15 @@ class PredictionMarketExchange {
      * market = exchange.fetch_market(market_id='663583')
      */
     async fetchMarket(params) {
+        // Try to fetch from cache first if we have loaded markets and have an ID/slug
+        if (this.loadedMarkets) {
+            if (params?.marketId && this.markets[params.marketId]) {
+                return this.markets[params.marketId];
+            }
+            if (params?.slug && this.marketsBySlug[params.slug]) {
+                return this.marketsBySlug[params.slug];
+            }
+        }
         const markets = await this.fetchMarkets(params);
         if (markets.length === 0) {
             const identifier = params?.marketId || params?.outcomeId || params?.slug || params?.eventId || params?.query || 'unknown';
@@ -786,5 +828,118 @@ class PredictionMarketExchange {
         // Default implementation: no-op
         // Exchanges with WebSocket support should override this
     }
+    // ----------------------------------------------------------------------------
+    // Implicit API (OpenAPI-driven method generation)
+    // ----------------------------------------------------------------------------
+    /**
+     * Call an implicit API method by its operationId (or auto-generated name).
+     * Provides a typed entry point so unified methods can delegate to the implicit API
+     * without casting to `any` everywhere.
+     */
+    async callApi(operationId, params) {
+        const method = this[operationId];
+        if (typeof method !== 'function') {
+            throw new Error(`Implicit API method "${operationId}" not found on ${this.name}`);
+        }
+        return method.call(this, params);
+    }
+    /**
+     * Parse an API descriptor and generate callable methods on this instance.
+     * Existing methods (unified API) are never overwritten.
+     */
+    defineImplicitApi(descriptor) {
+        this.apiDescriptors.push(descriptor);
+        // Merge into a single apiDescriptor for the implicitApi getter
+        if (!this.apiDescriptor) {
+            this.apiDescriptor = { baseUrl: descriptor.baseUrl, endpoints: { ...descriptor.endpoints } };
+        }
+        else {
+            Object.assign(this.apiDescriptor.endpoints, descriptor.endpoints);
+        }
+        for (const [name, endpoint] of Object.entries(descriptor.endpoints)) {
+            // Never overwrite existing methods (unified API wins)
+            if (name in this) {
+                continue;
+            }
+            this[name] = this.createImplicitMethod(name, endpoint, descriptor.baseUrl);
+        }
+    }
+    /**
+     * Creates an async function for an implicit API endpoint.
+     */
+    createImplicitMethod(name, endpoint, baseUrl) {
+        return async (params) => {
+            const allParams = { ...(params || {}) };
+            // Substitute path parameters like {ticker} from params
+            let resolvedPath = endpoint.path.replace(/\{([^}]+)\}/g, (_match, key) => {
+                const value = allParams[key];
+                if (value === undefined) {
+                    throw new Error(`Missing required path parameter "${key}" for ${name}(). ` +
+                        `Path: ${endpoint.path}`);
+                }
+                delete allParams[key];
+                return encodeURIComponent(String(value));
+            });
+            // Get auth headers for private endpoints
+            let headers = {};
+            if (endpoint.isPrivate) {
+                headers = this.sign(endpoint.method, resolvedPath, allParams);
+            }
+            const url = `${baseUrl}${resolvedPath}`;
+            const method = endpoint.method.toUpperCase();
+            try {
+                let response;
+                if (method === 'GET' || method === 'DELETE') {
+                    // Remaining params go to query string
+                    response = await this.http.request({
+                        method: method,
+                        url,
+                        params: Object.keys(allParams).length > 0 ? allParams : undefined,
+                        headers,
+                    });
+                }
+                else {
+                    // POST/PUT/PATCH: remaining params go to JSON body
+                    response = await this.http.request({
+                        method: method,
+                        url,
+                        data: Object.keys(allParams).length > 0 ? allParams : undefined,
+                        headers: { 'Content-Type': 'application/json', ...headers },
+                    });
+                }
+                return response.data;
+            }
+            catch (error) {
+                throw this.mapImplicitApiError(error);
+            }
+        };
+    }
+    /**
+     * Returns auth headers for a private API call.
+     * Exchanges should override this to provide authentication.
+     */
+    sign(_method, _path, _params) {
+        return {};
+    }
+    /**
+     * Maps errors from implicit API calls through the exchange's error mapper.
+     * Exchanges should override this to use their specific error mapper.
+     */
+    mapImplicitApiError(error) {
+        throw error;
+    }
+    /**
+     * Introspection getter: returns info about all implicit API methods.
+     */
+    get implicitApi() {
+        if (!this.apiDescriptor)
+            return [];
+        return Object.entries(this.apiDescriptor.endpoints).map(([name, endpoint]) => ({
+            name,
+            method: endpoint.method,
+            path: endpoint.path,
+            isPrivate: !!endpoint.isPrivate,
+        }));
+    }
 }
 exports.PredictionMarketExchange = PredictionMarketExchange;