pmxt-core 2.20.0 → 2.20.2

package/dist/exchanges/myriad/websocket.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MyriadWebSocket = void 0;
-const fetchOrderBook_1 = require("./fetchOrderBook");
 // Myriad API v2 does not expose a WebSocket endpoint.
 // We implement a poll-based fallback that resolves promises
 // on each polling interval, matching the CCXT Pro async pattern.
 const DEFAULT_POLL_INTERVAL = 5000; // 5 seconds
 class MyriadWebSocket {
     callApi;
+    fetchOrderBook;
     pollInterval;
     orderBookTimers = new Map();
     tradeTimers = new Map();
@@ -15,8 +15,9 @@ class MyriadWebSocket {
     tradeResolvers = new Map();
     lastTradeTimestamp = new Map();
     closed = false;
-    constructor(callApi, pollInterval) {
+    constructor(callApi, fetchOrderBook, pollInterval) {
         this.callApi = callApi;
+        this.fetchOrderBook = fetchOrderBook;
         this.pollInterval = pollInterval || DEFAULT_POLL_INTERVAL;
     }
     async watchOrderBook(id) {
@@ -61,7 +62,7 @@ class MyriadWebSocket {
     startOrderBookPolling(id) {
         const poll = async () => {
             try {
-                const book = await (0, fetchOrderBook_1.fetchOrderBook)(id, this.callApi);
+                const book = await this.fetchOrderBook(id);
                 const resolvers = this.orderBookResolvers.get(id) || [];
                 this.orderBookResolvers.set(id, []);
                 for (const resolve of resolvers) {

package/dist/exchanges/polymarket/api-clob.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-03-14T16:22:11.391Z
+ * Generated at: 2026-03-14T21:28:31.838Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketClobSpec: {

package/dist/exchanges/polymarket/api-clob.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketClobSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-03-14T16:22:11.391Z
+ * Generated at: 2026-03-14T21:28:31.838Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketClobSpec = {

package/dist/exchanges/polymarket/api-data.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-03-14T16:22:11.405Z
+ * Generated at: 2026-03-14T21:28:31.859Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketDataSpec: {

package/dist/exchanges/polymarket/api-data.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketDataSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-03-14T16:22:11.405Z
+ * Generated at: 2026-03-14T21:28:31.859Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketDataSpec = {

package/dist/exchanges/polymarket/api-gamma.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-03-14T16:22:11.402Z
+ * Generated at: 2026-03-14T21:28:31.854Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketGammaSpec: {

package/dist/exchanges/polymarket/api-gamma.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketGammaSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-03-14T16:22:11.402Z
+ * Generated at: 2026-03-14T21:28:31.854Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketGammaSpec = {

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

@@ -0,0 +1,99 @@
+import { AxiosInstance } from 'axios';
+import { MarketFilterParams, EventFetchParams, OHLCVParams, TradesParams, MyTradesParams } from '../../BaseExchange';
+import { IExchangeFetcher, FetcherContext } from '../interfaces';
+export interface PolymarketRawEvent {
+    id?: string;
+    slug?: string;
+    title?: string;
+    description?: string;
+    image?: string;
+    category?: string;
+    active?: boolean;
+    closed?: boolean;
+    tags?: Array<{
+        label: string;
+    }>;
+    markets?: PolymarketRawMarket[];
+    [key: string]: unknown;
+}
+export interface PolymarketRawMarket {
+    id?: string;
+    question?: string;
+    description?: string;
+    outcomes?: string | string[];
+    outcomePrices?: string | string[];
+    clobTokenIds?: string | string[];
+    groupItemTitle?: string;
+    endDate?: string;
+    end_date_iso?: string;
+    volume24hr?: number | string;
+    volume_24h?: number | string;
+    volume?: number | string;
+    liquidity?: number | string;
+    openInterest?: number | string;
+    open_interest?: number | string;
+    oneDayPriceChange?: number | string;
+    image?: string;
+    rewards?: {
+        liquidity?: number;
+    };
+    events?: PolymarketRawEvent[];
+    [key: string]: unknown;
+}
+export interface PolymarketRawOHLCVPoint {
+    t: number;
+    p: number;
+    s?: number;
+    v?: number;
+}
+export interface PolymarketRawOrderBookLevel {
+    price: string;
+    size: string;
+}
+export interface PolymarketRawOrderBook {
+    bids?: PolymarketRawOrderBookLevel[];
+    asks?: PolymarketRawOrderBookLevel[];
+    timestamp?: string | number;
+}
+export interface PolymarketRawTrade {
+    id?: string;
+    transactionHash?: string;
+    timestamp: number;
+    price: string;
+    size?: string;
+    amount?: string;
+    side?: string;
+    orderId?: string;
+    asset?: string;
+}
+export interface PolymarketRawPosition {
+    conditionId?: string;
+    asset?: string;
+    outcome?: string;
+    size: string;
+    avgPrice: string;
+    curPrice?: string;
+    cashPnl?: string;
+    realizedPnl?: string;
+}
+export declare class PolymarketFetcher implements IExchangeFetcher<PolymarketRawEvent, PolymarketRawEvent> {
+    private readonly ctx;
+    private readonly http;
+    constructor(ctx: FetcherContext, http: AxiosInstance);
+    fetchRawMarkets(params?: MarketFilterParams): Promise<PolymarketRawEvent[]>;
+    fetchRawEvents(params: EventFetchParams): Promise<PolymarketRawEvent[]>;
+    fetchRawOHLCV(id: string, params: OHLCVParams): Promise<{
+        history: PolymarketRawOHLCVPoint[];
+    }>;
+    fetchRawOrderBook(id: string): Promise<PolymarketRawOrderBook>;
+    fetchRawTrades(id: string, params: TradesParams): Promise<PolymarketRawTrade[]>;
+    fetchRawMyTrades(params: MyTradesParams, walletAddress: string): Promise<PolymarketRawTrade[]>;
+    fetchRawPositions(walletAddress: string): Promise<PolymarketRawPosition[]>;
+    private fetchRawMarketById;
+    private fetchRawMarketsByEventId;
+    private fetchRawMarketsBySlug;
+    private fetchRawMarketsSearch;
+    private fetchRawMarketsDefault;
+    private fetchRawEventsSearch;
+    private fetchRawEventsDefault;
+}

package/dist/exchanges/polymarket/fetcher.js

@@ -0,0 +1,335 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolymarketFetcher = void 0;
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+const GAMMA_MARKETS_URL = 'https://gamma-api.polymarket.com/markets';
+class PolymarketFetcher {
+    ctx;
+    http;
+    constructor(ctx, http) {
+        this.ctx = ctx;
+        this.http = http;
+    }
+    // ------------------------------------------------------------------------
+    // Markets
+    // ------------------------------------------------------------------------
+    async fetchRawMarkets(params) {
+        try {
+            if (params?.marketId) {
+                return this.fetchRawMarketById(params.marketId);
+            }
+            if (params?.slug) {
+                return this.fetchRawMarketsBySlug(params.slug);
+            }
+            if (params?.eventId) {
+                return this.fetchRawMarketsByEventId(params.eventId);
+            }
+            if (params?.query) {
+                return this.fetchRawMarketsSearch(params);
+            }
+            return this.fetchRawMarketsDefault(params);
+        }
+        catch (error) {
+            throw errors_1.polymarketErrorMapper.mapError(error);
+        }
+    }
+    // ------------------------------------------------------------------------
+    // Events
+    // ------------------------------------------------------------------------
+    async fetchRawEvents(params) {
+        try {
+            if (params.eventId || params.slug) {
+                const queryParams = params.eventId ? { id: params.eventId } : { slug: params.slug };
+                const response = await this.http.get(utils_1.GAMMA_API_URL, { params: queryParams });
+                const events = response.data;
+                if (!events || events.length === 0)
+                    return [];
+                return events.slice(0, params.limit || 10000);
+            }
+            if (params.query) {
+                return this.fetchRawEventsSearch(params);
+            }
+            return this.fetchRawEventsDefault(params);
+        }
+        catch (error) {
+            throw errors_1.polymarketErrorMapper.mapError(error);
+        }
+    }
+    // ------------------------------------------------------------------------
+    // OHLCV
+    // ------------------------------------------------------------------------
+    async fetchRawOHLCV(id, params) {
+        try {
+            const { mapIntervalToFidelity } = await Promise.resolve().then(() => __importStar(require('./utils')));
+            const fidelity = mapIntervalToFidelity(params.resolution);
+            const nowTs = Math.floor(Date.now() / 1000);
+            const ensureDate = (d) => {
+                if (typeof d === 'string') {
+                    if (!d.endsWith('Z') && !d.match(/[+-]\d{2}:\d{2}$/)) {
+                        return new Date(d + 'Z');
+                    }
+                    return new Date(d);
+                }
+                return d;
+            };
+            const pStart = params.start ? ensureDate(params.start) : undefined;
+            const pEnd = params.end ? ensureDate(params.end) : undefined;
+            let startTs = pStart ? Math.floor(pStart.getTime() / 1000) : 0;
+            const endTs = pEnd ? Math.floor(pEnd.getTime() / 1000) : nowTs;
+            if (!pStart) {
+                const count = params.limit || 100;
+                const durationSeconds = count * fidelity * 60;
+                startTs = endTs - durationSeconds;
+            }
+            const queryParams = {
+                market: id,
+                fidelity: fidelity,
+                startTs: startTs,
+                endTs: endTs,
+            };
+            const data = await this.ctx.callApi('getPricesHistory', queryParams);
+            return { history: data.history || [] };
+        }
+        catch (error) {
+            throw errors_1.polymarketErrorMapper.mapError(error);
+        }
+    }
+    // ------------------------------------------------------------------------
+    // Order Book
+    // ------------------------------------------------------------------------
+    async fetchRawOrderBook(id) {
+        try {
+            const data = await this.ctx.callApi('getBook', { token_id: id });
+            return data;
+        }
+        catch (error) {
+            throw errors_1.polymarketErrorMapper.mapError(error);
+        }
+    }
+    // ------------------------------------------------------------------------
+    // Trades
+    // ------------------------------------------------------------------------
+    async fetchRawTrades(id, params) {
+        try {
+            const queryParams = {
+                asset_id: id,
+            };
+            if (params.start) {
+                queryParams.after = Math.floor(params.start.getTime() / 1000);
+            }
+            if (params.end) {
+                queryParams.before = Math.floor(params.end.getTime() / 1000);
+            }
+            const trades = await this.ctx.callApi('getTrades', queryParams) || [];
+            return trades;
+        }
+        catch (error) {
+            throw errors_1.polymarketErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawMyTrades(params, walletAddress) {
+        const queryParams = { user: walletAddress };
+        if (params?.marketId)
+            queryParams.market = params.marketId;
+        if (params?.limit)
+            queryParams.limit = params.limit;
+        if (params?.since)
+            queryParams.start = Math.floor(params.since.getTime() / 1000);
+        if (params?.until)
+            queryParams.end = Math.floor(params.until.getTime() / 1000);
+        const data = await this.ctx.callApi('getTrades', queryParams);
+        const trades = Array.isArray(data) ? data : (data.data || []);
+        return trades;
+    }
+    // ------------------------------------------------------------------------
+    // Positions
+    // ------------------------------------------------------------------------
+    async fetchRawPositions(walletAddress) {
+        const result = await this.ctx.callApi('getPositions', { user: walletAddress, limit: 100 });
+        return Array.isArray(result) ? result : [];
+    }
+    // ------------------------------------------------------------------------
+    // Private helpers -- Markets
+    // ------------------------------------------------------------------------
+    async fetchRawMarketById(marketId) {
+        const response = await this.http.get(GAMMA_MARKETS_URL, {
+            params: { id: marketId },
+        });
+        const markets = response.data;
+        if (!markets || markets.length === 0)
+            return [];
+        // Wrap each market in an event-like shape for consistent normalizer input
+        return markets.map((market) => {
+            const event = market.events?.[0] || market;
+            return { ...event, markets: [market] };
+        });
+    }
+    async fetchRawMarketsByEventId(eventId) {
+        const response = await this.http.get(utils_1.GAMMA_API_URL, {
+            params: { id: eventId },
+        });
+        return response.data || [];
+    }
+    async fetchRawMarketsBySlug(slug) {
+        const response = await this.http.get(utils_1.GAMMA_API_URL, {
+            params: { slug },
+        });
+        return response.data || [];
+    }
+    async fetchRawMarketsSearch(params) {
+        const limit = params?.limit || 250000;
+        const queryParams = {
+            q: params.query,
+            limit_per_type: 50,
+            events_status: params?.status === 'all' ? undefined : (params?.status === 'inactive' || params?.status === 'closed' ? 'closed' : 'active'),
+            sort: 'volume',
+            ascending: false,
+        };
+        return (0, utils_1.paginateSearchParallel)(utils_1.GAMMA_SEARCH_URL, queryParams, limit * 5, this.http);
+    }
+    async fetchRawMarketsDefault(params) {
+        const limit = params?.limit || 250000;
+        const offset = params?.offset || 0;
+        const queryParams = {
+            limit: limit,
+            offset: offset,
+        };
+        const status = params?.status || 'active';
+        if (status === 'active') {
+            queryParams.active = 'true';
+            queryParams.closed = 'false';
+        }
+        else if (status === 'closed' || status === 'inactive') {
+            queryParams.active = 'false';
+            queryParams.closed = 'true';
+        }
+        if (params?.sort === 'volume') {
+            queryParams.order = 'volume';
+            queryParams.ascending = 'false';
+        }
+        else if (params?.sort === 'newest') {
+            queryParams.order = 'startDate';
+            queryParams.ascending = 'false';
+        }
+        else {
+            queryParams.order = 'volume';
+            queryParams.ascending = 'false';
+        }
+        return (0, utils_1.paginateParallel)(utils_1.GAMMA_API_URL, queryParams, this.http);
+    }
+    // ------------------------------------------------------------------------
+    // Private helpers -- Events
+    // ------------------------------------------------------------------------
+    async fetchRawEventsSearch(params) {
+        const limit = params.limit || 10000;
+        let sortParam = 'volume';
+        if (params.sort === 'newest')
+            sortParam = 'startDate';
+        if (params.sort === 'liquidity')
+            sortParam = 'liquidity';
+        const queryParams = {
+            q: params.query,
+            limit_per_type: 50,
+            sort: sortParam,
+            ascending: false,
+        };
+        const status = params.status || 'active';
+        const fetchWithStatus = async (eventStatus) => {
+            const currentParams = { ...queryParams, events_status: eventStatus };
+            return (0, utils_1.paginateSearchParallel)(utils_1.GAMMA_SEARCH_URL, currentParams, limit * 10, this.http);
+        };
+        const filterActive = (e) => e.active === true;
+        const filterClosed = (e) => e.closed === true;
+        let events = [];
+        if (status === 'all') {
+            const [activeEvents, closedEvents] = await Promise.all([
+                fetchWithStatus('active'),
+                fetchWithStatus('closed'),
+            ]);
+            const seenIds = new Set();
+            events = [...activeEvents, ...closedEvents].filter(event => {
+                const id = event.id || event.slug;
+                if (seenIds.has(id))
+                    return false;
+                seenIds.add(id);
+                return true;
+            });
+        }
+        else if (status === 'active') {
+            const rawEvents = await fetchWithStatus('active');
+            events = rawEvents.filter(filterActive);
+        }
+        else if (status === 'inactive' || status === 'closed') {
+            const rawEvents = await fetchWithStatus('closed');
+            events = rawEvents.filter(filterClosed);
+        }
+        const lowerQuery = params.query.toLowerCase();
+        const searchIn = params.searchIn || 'title';
+        return events.filter((event) => {
+            const titleMatch = (event.title || '').toLowerCase().includes(lowerQuery);
+            const descMatch = (event.description || '').toLowerCase().includes(lowerQuery);
+            if (searchIn === 'title')
+                return titleMatch;
+            if (searchIn === 'description')
+                return descMatch;
+            return titleMatch || descMatch;
+        }).slice(0, limit);
+    }
+    async fetchRawEventsDefault(params) {
+        const limit = params.limit || 10000;
+        const status = params.status || 'active';
+        let sortParam = 'volume';
+        if (params.sort === 'newest')
+            sortParam = 'startDate';
+        else if (params.sort === 'liquidity')
+            sortParam = 'liquidity';
+        const queryParams = {
+            order: sortParam,
+            ascending: false,
+        };
+        if (status === 'active') {
+            queryParams.active = 'true';
+            queryParams.closed = 'false';
+        }
+        else if (status === 'closed' || status === 'inactive') {
+            queryParams.active = 'false';
+            queryParams.closed = 'true';
+        }
+        return (0, utils_1.paginateParallel)(utils_1.GAMMA_API_URL, queryParams, this.http, limit);
+    }
+}
+exports.PolymarketFetcher = PolymarketFetcher;

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

@@ -38,6 +38,8 @@ export declare class PolymarketExchange extends PredictionMarketExchange {
     private cachedApiCreds?;
     private cachedAddress?;
     private ws?;
+    private readonly fetcher;
+    private readonly normalizer;
     constructor(options?: ExchangeCredentials | PolymarketExchangeOptions);
     get name(): string;
     /**