pmxt-core 2.7.0 → 2.9.0

package/dist/exchanges/polymarket/fetchEvents.js

@@ -7,76 +7,8 @@ exports.fetchEvents = fetchEvents;
 const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
-async function fetchEventByGammaId(id, http) {
-    const response = await http.get(utils_1.GAMMA_API_URL, {
-        params: { id }
-    });
-    const events = response.data;
-    if (!events || events.length === 0)
-        return [];
-    return events.map((event) => {
-        const markets = [];
-        if (event.markets && Array.isArray(event.markets)) {
-            for (const market of event.markets) {
-                const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market, { useQuestionAsCandidateFallback: true });
-                if (unifiedMarket) {
-                    markets.push(unifiedMarket);
-                }
-            }
-        }
-        return {
-            id: event.id || event.slug,
-            title: event.title,
-            description: event.description || '',
-            slug: event.slug,
-            markets,
-            url: `https://polymarket.com/event/${event.slug}`,
-            image: event.image || `https://polymarket.com/api/og?slug=${event.slug}`,
-            category: event.category || event.tags?.[0]?.label,
-            tags: event.tags?.map((t) => t.label) || []
-        };
-    });
-}
-async function fetchEventBySlug(slug, http) {
-    const response = await http.get(utils_1.GAMMA_API_URL, {
-        params: { slug }
-    });
-    const events = response.data;
-    if (!events || events.length === 0)
-        return [];
-    return events.map((event) => {
-        const markets = [];
-        if (event.markets && Array.isArray(event.markets)) {
-            for (const market of event.markets) {
-                const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market, { useQuestionAsCandidateFallback: true });
-                if (unifiedMarket) {
-                    markets.push(unifiedMarket);
-                }
-            }
-        }
-        return {
-            id: event.id || event.slug,
-            title: event.title,
-            description: event.description || '',
-            slug: event.slug,
-            markets,
-            url: `https://polymarket.com/event/${event.slug}`,
-            image: event.image || `https://polymarket.com/api/og?slug=${event.slug}`,
-            category: event.category || event.tags?.[0]?.label,
-            tags: event.tags?.map((t) => t.label) || []
-        };
-    });
-}
 async function fetchEvents(params, http = axios_1.default) {
     try {
-        // Handle eventId lookup (Gamma event ID)
-        if (params.eventId) {
-            return await fetchEventByGammaId(params.eventId, http);
-        }
-        // Handle slug lookup
-        if (params.slug) {
-            return await fetchEventBySlug(params.slug, http);
-        }
         if (!params.query) {
             throw new Error("Query is required for Polymarket event search");
         }

package/dist/exchanges/polymarket/fetchMarkets.js

@@ -97,7 +97,7 @@ async function fetchMarketsBySlug(slug, http) {
     return unifiedMarkets;
 }
 async function searchMarkets(query, params, http) {
-    const limit = params?.limit || 10000;
+    const limit = params?.limit || 250000;
     // Use parallel pagination to fetch all matching events
     // Each event can contain multiple markets, so we need a larger pool
     const queryParams = {
@@ -138,7 +138,7 @@ async function searchMarkets(query, params, http) {
     return unifiedMarkets.slice(0, limit);
 }
 async function fetchMarketsDefault(params, http) {
-    const limit = params?.limit || 10000; // Higher default for better coverage
+    const limit = params?.limit || 250000; // Higher default for better coverage
     const offset = params?.offset || 0;
     // Map generic sort params to Polymarket Gamma API params
     let queryParams = {

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

@@ -1,8 +1,7 @@
-import { AxiosInstance } from 'axios';
 import { HistoryFilterParams, OHLCVParams } from '../../BaseExchange';
 import { PriceCandle } from '../../types';
 /**
  * Fetch historical price data (OHLCV candles) for a specific token.
  * @param id - The CLOB token ID (e.g., outcome token ID)
  */
-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/polymarket/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 (OHLCV candles) for a specific token.
  * @param id - The CLOB token ID (e.g., outcome token ID)
  */
-async function fetchOHLCV(id, params, http = axios_1.default) {
+async function fetchOHLCV(id, params, callApi) {
     (0, validation_1.validateIdFormat)(id, 'OHLCV');
     (0, validation_1.validateOutcomeId)(id, 'OHLCV');
     // Validate resolution is provided
@@ -45,7 +41,7 @@ async function fetchOHLCV(id, params, http = axios_1.default) {
             // Default limit is usually 20 in the example, but safety margin is good.
             // If limit is not set, we default to 100 candles.
             const count = params.limit || 100;
-            // fidelity is in minutes. 
+            // fidelity is in minutes.
             const durationSeconds = count * fidelity * 60;
             startTs = endTs - durationSeconds;
         }
@@ -55,10 +51,8 @@ async function fetchOHLCV(id, params, http = axios_1.default) {
             startTs: startTs,
             endTs: endTs
         };
-        const response = await http.get(`${utils_1.CLOB_API_URL}/prices-history`, {
-            params: queryParams
-        });
-        const history = response.data.history || [];
+        const data = await callApi('getPricesHistory', queryParams);
+        const history = data.history || [];
         // 2. Align Timestamps (Snap to Grid)
         // Polymarket returns random tick timestamps (e.g. 1:00:21).
         // We want to normalize this to the start of the bucket (1:00:00).

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

@@ -1,7 +1,6 @@
-import { AxiosInstance } from 'axios';
 import { OrderBook } from '../../types';
 /**
  * Fetch the current order book for a specific token.
  * @param id - The 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/polymarket/fetchOrderBook.js

@@ -1,25 +1,17 @@
 "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");
 const errors_1 = require("./errors");
 /**
  * Fetch the current order book for a specific token.
  * @param id - The CLOB token ID
  */
-async function fetchOrderBook(id, http = axios_1.default) {
+async function fetchOrderBook(id, callApi) {
     (0, validation_1.validateIdFormat)(id, 'OrderBook');
     (0, validation_1.validateOutcomeId)(id, 'OrderBook');
     try {
-        const response = await http.get(`${utils_1.CLOB_API_URL}/book`, {
-            params: { token_id: id }
-        });
-        const data = response.data;
+        const data = await callApi('getBook', { token_id: id });
         // Response format: { bids: [{price: "0.52", size: "100"}], asks: [...] }
         const bids = (data.bids || []).map((level) => ({
             price: parseFloat(level.price),

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

@@ -1,4 +1,3 @@
-import { AxiosInstance } from 'axios';
 import { HistoryFilterParams, TradesParams } from '../../BaseExchange';
 import { Trade } from '../../types';
 /**
@@ -7,4 +6,4 @@ import { Trade } from '../../types';
  *
  * NOTE: Uses Polymarket Data API (public) to fetch trades.
  */
-export declare function fetchTrades(id: string, params: TradesParams | HistoryFilterParams, http?: AxiosInstance): Promise<Trade[]>;
+export declare function fetchTrades(id: string, params: TradesParams | HistoryFilterParams, callApi: (operationId: string, params?: Record<string, any>) => Promise<any>): Promise<Trade[]>;

package/dist/exchanges/polymarket/fetchTrades.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.fetchTrades = fetchTrades;
-const axios_1 = __importDefault(require("axios"));
-const utils_1 = require("./utils");
 const validation_1 = require("../../utils/validation");
 const errors_1 = require("./errors");
 /**
@@ -14,7 +9,7 @@ const errors_1 = require("./errors");
  *
  * NOTE: Uses Polymarket Data API (public) to fetch trades.
  */
-async function fetchTrades(id, params, http = axios_1.default) {
+async function fetchTrades(id, params, callApi) {
     (0, validation_1.validateIdFormat)(id, 'Trades');
     (0, validation_1.validateOutcomeId)(id, 'Trades');
     try {
@@ -28,11 +23,7 @@ async function fetchTrades(id, params, http = axios_1.default) {
         if (params.end) {
             queryParams.before = Math.floor(params.end.getTime() / 1000);
         }
-        const response = await http.get(`${utils_1.DATA_API_URL}/trades`, {
-            params: queryParams
-        });
-        // Response is an array of trade objects
-        const trades = response.data || [];
+        const trades = await callApi('getTrades', queryParams) || [];
         const mappedTrades = trades.map((trade) => ({
             id: trade.id || `${trade.timestamp}-${trade.price}`,
             timestamp: trade.timestamp * 1000, // Convert to milliseconds

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

@@ -24,8 +24,18 @@ export declare class PolymarketExchange extends PredictionMarketExchange {
     };
     private auth?;
     private wsConfig?;
+    private cachedApiCreds?;
+    private cachedAddress?;
     constructor(options?: ExchangeCredentials | PolymarketExchangeOptions);
     get name(): string;
+    /**
+     * Initialize L2 API credentials for implicit API signing.
+     * Must be called before using private implicit API endpoints if only
+     * a privateKey was provided (not apiKey/apiSecret/passphrase).
+     */
+    initAuth(): Promise<void>;
+    protected sign(method: string, path: string, _params: Record<string, any>): Record<string, string>;
+    protected mapImplicitApiError(error: any): any;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
     fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams): Promise<PriceCandle[]>;

package/dist/exchanges/polymarket/index.js

@@ -1,18 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PolymarketExchange = void 0;
+const crypto_1 = require("crypto");
 const BaseExchange_1 = require("../../BaseExchange");
+const openapi_1 = require("../../utils/openapi");
 const fetchMarkets_1 = require("./fetchMarkets");
 const fetchEvents_1 = require("./fetchEvents");
+const utils_1 = require("./utils");
 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 clob_client_1 = require("@polymarket/clob-client");
 const websocket_1 = require("./websocket");
 const errors_1 = require("./errors");
 const errors_2 = require("../../errors");
+const api_clob_1 = require("./api-clob");
+const api_gamma_1 = require("./api-gamma");
+const api_data_1 = require("./api-data");
 class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
     has = {
         fetchMarkets: true,
@@ -31,6 +36,8 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
     };
     auth;
     wsConfig;
+    cachedApiCreds;
+    cachedAddress;
     constructor(options) {
         // Support both old signature (credentials only) and new signature (options object)
         let credentials;
@@ -50,24 +57,111 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
         if (credentials?.privateKey) {
             this.auth = new auth_1.PolymarketAuth(credentials);
         }
+        // If L2 API creds are provided directly, cache them for sync sign()
+        if (credentials?.apiKey && credentials?.apiSecret && credentials?.passphrase) {
+            this.cachedApiCreds = {
+                key: credentials.apiKey,
+                secret: credentials.apiSecret,
+                passphrase: credentials.passphrase,
+            };
+        }
+        // Register implicit APIs for all 3 Polymarket services
+        const clobDescriptor = (0, openapi_1.parseOpenApiSpec)(api_clob_1.polymarketClobSpec);
+        this.defineImplicitApi(clobDescriptor);
+        const gammaDescriptor = (0, openapi_1.parseOpenApiSpec)(api_gamma_1.polymarketGammaSpec);
+        this.defineImplicitApi(gammaDescriptor);
+        const dataDescriptor = (0, openapi_1.parseOpenApiSpec)(api_data_1.polymarketDataSpec);
+        this.defineImplicitApi(dataDescriptor);
     }
     get name() {
         return 'Polymarket';
     }
     // ----------------------------------------------------------------------------
+    // Implicit API Auth & Error Mapping
+    // ----------------------------------------------------------------------------
+    /**
+     * Initialize L2 API credentials for implicit API signing.
+     * Must be called before using private implicit API endpoints if only
+     * a privateKey was provided (not apiKey/apiSecret/passphrase).
+     */
+    async initAuth() {
+        const auth = this.ensureAuth();
+        const creds = await auth.getApiCredentials();
+        this.cachedApiCreds = {
+            key: creds.key,
+            secret: creds.secret,
+            passphrase: creds.passphrase,
+        };
+        this.cachedAddress = auth.getFunderAddress();
+    }
+    sign(method, path, _params) {
+        if (!this.cachedApiCreds) {
+            throw new errors_2.AuthenticationError('API credentials not initialized. Either provide apiKey/apiSecret/passphrase ' +
+                'in credentials, or call initAuth() before using private implicit API endpoints.', 'Polymarket');
+        }
+        const timestamp = Math.floor(Date.now() / 1000).toString();
+        const message = timestamp + method.toUpperCase() + path;
+        // Decode the base64url secret
+        const secretB64 = this.cachedApiCreds.secret
+            .replace(/-/g, '+')
+            .replace(/_/g, '/');
+        const secretBuffer = Buffer.from(secretB64, 'base64');
+        // HMAC-SHA256 -> base64url
+        const hmac = (0, crypto_1.createHmac)('sha256', secretBuffer);
+        hmac.update(message);
+        const signature = hmac.digest('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_');
+        return {
+            'POLY_ADDRESS': this.cachedAddress || (this.auth ? this.auth.getFunderAddress() : ''),
+            'POLY_SIGNATURE': signature,
+            'POLY_TIMESTAMP': timestamp,
+            'POLY_API_KEY': this.cachedApiCreds.key,
+            'POLY_PASSPHRASE': this.cachedApiCreds.passphrase,
+        };
+    }
+    mapImplicitApiError(error) {
+        throw errors_1.polymarketErrorMapper.mapError(error);
+    }
+    // ----------------------------------------------------------------------------
     // Implementation methods for CCXT-style API
     // ----------------------------------------------------------------------------
     async fetchMarketsImpl(params) {
         return (0, fetchMarkets_1.fetchMarkets)(params, this.http);
     }
     async fetchEventsImpl(params) {
+        if (params.eventId || params.slug) {
+            const queryParams = params.eventId ? { id: params.eventId } : { slug: params.slug };
+            const events = await this.callApi('listEvents', queryParams);
+            return (events || []).map((event) => {
+                const markets = [];
+                if (event.markets && Array.isArray(event.markets)) {
+                    for (const market of event.markets) {
+                        const unified = (0, utils_1.mapMarketToUnified)(event, market, { useQuestionAsCandidateFallback: true });
+                        if (unified)
+                            markets.push(unified);
+                    }
+                }
+                return {
+                    id: event.id || event.slug,
+                    title: event.title,
+                    description: event.description || '',
+                    slug: event.slug,
+                    markets,
+                    url: `https://polymarket.com/event/${event.slug}`,
+                    image: event.image || `https://polymarket.com/api/og?slug=${event.slug}`,
+                    category: event.category || event.tags?.[0]?.label,
+                    tags: event.tags?.map((t) => t.label) || [],
+                };
+            });
+        }
         return (0, fetchEvents_1.fetchEvents)(params, this.http);
     }
     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 (also in base class, but adding here for consistency)
@@ -75,7 +169,7 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
             console.warn('[pmxt] Warning: The "resolution" parameter is deprecated for fetchTrades() and will be ignored. ' +
                 'It will be removed in v3.0.0. Please remove it from your code.');
         }
-        return (0, fetchTrades_1.fetchTrades)(id, params, this.http);
+        return (0, fetchTrades_1.fetchTrades)(id, params, this.callApi.bind(this));
     }
     // ----------------------------------------------------------------------------
     // Trading Methods
@@ -235,7 +329,18 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
         try {
             const auth = this.ensureAuth();
             const address = await auth.getEffectiveFunderAddress();
-            return (0, fetchPositions_1.fetchPositions)(address);
+            const result = await this.callApi('getPositions', { user: address, limit: 100 });
+            const data = Array.isArray(result) ? result : [];
+            return data.map((p) => ({
+                marketId: p.conditionId,
+                outcomeId: p.asset,
+                outcomeLabel: p.outcome || 'Unknown',
+                size: parseFloat(p.size),
+                entryPrice: parseFloat(p.avgPrice),
+                currentPrice: parseFloat(p.curPrice || '0'),
+                unrealizedPnL: parseFloat(p.cashPnl || '0'),
+                realizedPnL: parseFloat(p.realizedPnl || '0'),
+            }));
         }
         catch (error) {
             throw errors_1.polymarketErrorMapper.mapError(error);