pmxt-core 2.20.1 → 2.20.3

package/dist/exchanges/polymarket/fetchEvents.js

@@ -1,135 +0,0 @@
-"use strict";
-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");
-function mapRawEventToUnified(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);
-            }
-        }
-    }
-    const unifiedEvent = {
-        id: event.id || event.slug,
-        title: event.title,
-        description: event.description || '',
-        slug: event.slug,
-        markets: markets,
-        volume24h: markets.reduce((sum, m) => sum + m.volume24h, 0),
-        volume: markets.some(m => m.volume !== undefined) ? markets.reduce((sum, m) => sum + (m.volume ?? 0), 0) : undefined,
-        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 unifiedEvent;
-}
-async function fetchEvents(params, http = axios_1.default) {
-    try {
-        const limit = params.limit || 10000;
-        // Handle eventId or slug lookup (direct API call)
-        if (params.eventId || params.slug) {
-            const queryParams = params.eventId ? { id: params.eventId } : { slug: params.slug };
-            const response = await http.get(utils_1.GAMMA_API_URL, { params: queryParams });
-            const events = response.data;
-            if (!events || events.length === 0)
-                return [];
-            return events.map(mapRawEventToUnified).slice(0, limit);
-        }
-        // Handle query-based search (uses the /public-search endpoint)
-        if (params.query) {
-            return await searchEvents(params, limit, http);
-        }
-        // Default: fetch top events list from the Gamma /events endpoint (no query required)
-        return await fetchEventsDefault(params, limit, http);
-    }
-    catch (error) {
-        throw errors_1.polymarketErrorMapper.mapError(error);
-    }
-}
-async function searchEvents(params, limit, http) {
-    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, 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';
-    const filteredEvents = 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;
-    });
-    return filteredEvents.map(mapRawEventToUnified).slice(0, limit);
-}
-async function fetchEventsDefault(params, limit, http) {
-    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';
-    }
-    // 'all' — no status filter applied
-    const events = await (0, utils_1.paginateParallel)(utils_1.GAMMA_API_URL, queryParams, http, limit);
-    return events.map(mapRawEventToUnified).slice(0, limit);
-}

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

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

package/dist/exchanges/polymarket/fetchMarkets.js

@@ -1,214 +0,0 @@
-"use strict";
-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, http = axios_1.default) {
-    try {
-        // Handle marketId lookup (Gamma market condition ID)
-        if (params?.marketId) {
-            return await fetchMarketById(params.marketId, http);
-        }
-        // Handle slug-based lookup
-        if (params?.slug) {
-            return await fetchMarketsBySlug(params.slug, http);
-        }
-        // Handle outcomeId lookup (CLOB token ID -- no direct API, fetch and filter)
-        if (params?.outcomeId) {
-            const markets = await fetchMarketsDefault(params, http);
-            return markets.filter(m => m.outcomes.some(o => o.outcomeId === params.outcomeId));
-        }
-        // Handle eventId lookup (Gamma event ID)
-        if (params?.eventId) {
-            return await fetchMarketsByEventId(params.eventId, http);
-        }
-        // Handle query-based search
-        if (params?.query) {
-            return await searchMarkets(params.query, params, http);
-        }
-        // Default: fetch markets
-        return await fetchMarketsDefault(params, http);
-    }
-    catch (error) {
-        throw errors_1.polymarketErrorMapper.mapError(error);
-    }
-}
-async function fetchMarketById(marketId, http) {
-    const GAMMA_MARKETS_URL = 'https://gamma-api.polymarket.com/markets';
-    const response = await http.get(GAMMA_MARKETS_URL, {
-        params: { id: marketId }
-    });
-    const markets = response.data;
-    if (!markets || markets.length === 0)
-        return [];
-    const unifiedMarkets = [];
-    for (const market of markets) {
-        // The /markets endpoint returns markets with an embedded 'events' array
-        const event = market.events?.[0] || market;
-        const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market, { useQuestionAsCandidateFallback: true });
-        if (unifiedMarket) {
-            unifiedMarkets.push(unifiedMarket);
-        }
-    }
-    return unifiedMarkets;
-}
-async function fetchMarketsByEventId(eventId, http) {
-    const response = await http.get(utils_1.GAMMA_API_URL, {
-        params: { id: eventId }
-    });
-    const events = response.data;
-    if (!events || events.length === 0)
-        return [];
-    const unifiedMarkets = [];
-    for (const event of events) {
-        if (!event.markets)
-            continue;
-        for (const market of event.markets) {
-            const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market, { useQuestionAsCandidateFallback: true });
-            if (unifiedMarket) {
-                unifiedMarkets.push(unifiedMarket);
-            }
-        }
-    }
-    return unifiedMarkets;
-}
-async function fetchMarketsBySlug(slug, http) {
-    const response = await http.get(utils_1.GAMMA_API_URL, {
-        params: { slug: slug }
-    });
-    const events = response.data;
-    if (!events || events.length === 0)
-        return [];
-    const unifiedMarkets = [];
-    for (const event of events) {
-        if (!event.markets)
-            continue;
-        for (const market of event.markets) {
-            const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market, { useQuestionAsCandidateFallback: true });
-            if (unifiedMarket) {
-                unifiedMarkets.push(unifiedMarket);
-            }
-        }
-    }
-    return unifiedMarkets;
-}
-async function searchMarkets(query, params, http) {
-    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 = {
-        q: query,
-        limit_per_type: 50, // Fetch 50 events per page
-        events_status: params?.status === 'all' ? undefined : (params?.status === 'inactive' || params?.status === 'closed' ? 'closed' : 'active'),
-        sort: 'volume',
-        ascending: false
-    };
-    // Fetch events with parallel pagination
-    const events = await (0, utils_1.paginateSearchParallel)(utils_1.GAMMA_SEARCH_URL, queryParams, limit * 5, http);
-    const unifiedMarkets = [];
-    const lowerQuery = query.toLowerCase();
-    const searchIn = params?.searchIn || 'title';
-    // Flatten events into markets
-    for (const event of events) {
-        if (!event.markets)
-            continue;
-        for (const market of event.markets) {
-            const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market, { useQuestionAsCandidateFallback: true });
-            if (!unifiedMarket)
-                continue;
-            // Apply client-side filtering on market title
-            const titleMatch = (unifiedMarket.title || '').toLowerCase().includes(lowerQuery);
-            const descMatch = (unifiedMarket.description || '').toLowerCase().includes(lowerQuery);
-            let matches = false;
-            if (searchIn === 'title')
-                matches = titleMatch;
-            else if (searchIn === 'description')
-                matches = descMatch;
-            else
-                matches = titleMatch || descMatch;
-            if (matches) {
-                unifiedMarkets.push(unifiedMarket);
-            }
-        }
-    }
-    return unifiedMarkets.slice(0, limit);
-}
-async function fetchMarketsDefault(params, http) {
-    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 = {
-        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';
-    }
-    else {
-        // 'all' - don't filter by status
-    }
-    // Gamma API uses 'order' and 'ascending' for sorting
-    if (params?.sort === 'volume') {
-        queryParams.order = 'volume';
-        queryParams.ascending = 'false';
-    }
-    else if (params?.sort === 'newest') {
-        queryParams.order = 'startDate';
-        queryParams.ascending = 'false';
-    }
-    else if (params?.sort === 'liquidity') {
-        // queryParams.order = 'liquidity';
-    }
-    else {
-        // Default to volume sort to ensure we get active markets
-        queryParams.order = 'volume';
-        queryParams.ascending = 'false';
-    }
-    try {
-        // Fetch active events from Gamma using parallel pagination
-        const events = await (0, utils_1.paginateParallel)(utils_1.GAMMA_API_URL, queryParams, http);
-        const unifiedMarkets = [];
-        for (const event of events) {
-            // Each event is a container (e.g. "US Election").
-            // It contains specific "markets" (e.g. "Winner", "Pop Vote").
-            if (!event.markets)
-                continue;
-            for (const market of event.markets) {
-                const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market);
-                if (unifiedMarket) {
-                    unifiedMarkets.push(unifiedMarket);
-                }
-            }
-        }
-        // Client-side Sort capability to ensure contract fulfillment
-        // Often API filters are "good effort" or apply to the 'event' but not the 'market'
-        if (params?.sort === 'volume') {
-            unifiedMarkets.sort((a, b) => b.volume24h - a.volume24h);
-        }
-        else if (params?.sort === 'newest') {
-            // unifiedMarkets.sort((a, b) => b.resolutionDate.getTime() - a.resolutionDate.getTime()); // Not quite 'newest'
-        }
-        else if (params?.sort === 'liquidity') {
-            unifiedMarkets.sort((a, b) => b.liquidity - a.liquidity);
-        }
-        else {
-            // Default volume sort
-            unifiedMarkets.sort((a, b) => b.volume24h - a.volume24h);
-        }
-        // Respect limit strictly after flattening
-        return unifiedMarkets.slice(0, limit);
-    }
-    catch (error) {
-        throw errors_1.polymarketErrorMapper.mapError(error);
-    }
-}

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

@@ -1,7 +0,0 @@
-import { 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, callApi: (operationId: string, params?: Record<string, any>) => Promise<any>): Promise<PriceCandle[]>;

package/dist/exchanges/polymarket/fetchOHLCV.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchOHLCV = fetchOHLCV;
-const utils_1 = require("./utils");
-const validation_1 = require("../../utils/validation");
-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, callApi) {
-    (0, validation_1.validateIdFormat)(id, 'OHLCV');
-    (0, validation_1.validateOutcomeId)(id, 'OHLCV');
-    // Validate resolution is provided
-    if (!params.resolution) {
-        throw new Error('fetchOHLCV requires a resolution parameter. Use OHLCVParams with resolution specified.');
-    }
-    try {
-        const fidelity = (0, utils_1.mapIntervalToFidelity)(params.resolution);
-        const nowTs = Math.floor(Date.now() / 1000);
-        // 1. Smart Lookback Calculation
-        // If start/end not provided, calculate window based on limit * resolution
-        // Helper to handle string dates (from JSON)
-        // IMPORTANT: Python sends naive datetimes as ISO strings without 'Z' suffix.
-        // We must treat these as UTC, not local time.
-        const ensureDate = (d) => {
-            if (typeof d === 'string') {
-                // If string doesn't end with 'Z' and doesn't have timezone offset, append 'Z'
-                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;
-        let endTs = pEnd ? Math.floor(pEnd.getTime() / 1000) : nowTs;
-        if (!pStart) {
-            // 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.
-            const durationSeconds = count * fidelity * 60;
-            startTs = endTs - durationSeconds;
-        }
-        const queryParams = {
-            market: id,
-            fidelity: fidelity,
-            startTs: startTs,
-            endTs: endTs
-        };
-        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).
-        const resolutionMs = fidelity * 60 * 1000;
-        // 2. Client-side Aggregation
-        // Polymarket returns tick data. We must group by time bucket to create true candles.
-        const buckets = new Map();
-        history.forEach((item) => {
-            const rawMs = item.t * 1000;
-            const snappedMs = Math.floor(rawMs / resolutionMs) * resolutionMs;
-            const price = Number(item.p);
-            const volume = Number(item.s || item.v || 0); // specific field depends on api, usually 's' for size
-            if (!buckets.has(snappedMs)) {
-                buckets.set(snappedMs, {
-                    timestamp: snappedMs,
-                    open: price,
-                    high: price,
-                    low: price,
-                    close: price,
-                    volume: volume
-                });
-            }
-            else {
-                const candle = buckets.get(snappedMs);
-                candle.high = Math.max(candle.high, price);
-                candle.low = Math.min(candle.low, price);
-                candle.close = price; // Assuming history is sorted by time. If not, we need to track timestamps.
-                candle.volume = (candle.volume || 0) + volume;
-                // If history is not guaranteed sorted, we should track first/last timestamps per bucket.
-                // But usually /prices-history is sorted. We'll assume sorted for efficiency.
-            }
-        });
-        const candles = Array.from(buckets.values()).sort((a, b) => a.timestamp - b.timestamp);
-        // Apply limit if specified
-        if (params.limit && candles.length > params.limit) {
-            return candles.slice(-params.limit);
-        }
-        return candles;
-    }
-    catch (error) {
-        throw errors_1.polymarketErrorMapper.mapError(error);
-    }
-}

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

@@ -1,6 +0,0 @@
-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, callApi: (operationId: string, params?: Record<string, any>) => Promise<any>): Promise<OrderBook>;

package/dist/exchanges/polymarket/fetchOrderBook.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchOrderBook = fetchOrderBook;
-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, callApi) {
-    (0, validation_1.validateIdFormat)(id, 'OrderBook');
-    (0, validation_1.validateOutcomeId)(id, 'OrderBook');
-    try {
-        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),
-            size: parseFloat(level.size)
-        })).sort((a, b) => b.price - a.price); // Sort Bids Descending (Best/Highest first)
-        const asks = (data.asks || []).map((level) => ({
-            price: parseFloat(level.price),
-            size: parseFloat(level.size)
-        })).sort((a, b) => a.price - b.price); // Sort Asks Ascending (Best/Lowest first)
-        return {
-            bids,
-            asks,
-            timestamp: data.timestamp ? new Date(data.timestamp).getTime() : Date.now()
-        };
-    }
-    catch (error) {
-        throw errors_1.polymarketErrorMapper.mapError(error);
-    }
-}

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

@@ -1,9 +0,0 @@
-import { HistoryFilterParams, TradesParams } from '../../BaseExchange';
-import { Trade } from '../../types';
-/**
- * Fetch raw trade history for a specific token.
- * @param id - The CLOB token ID
- *
- * NOTE: Uses Polymarket Data API (public) to fetch trades.
- */
-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,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchTrades = fetchTrades;
-const validation_1 = require("../../utils/validation");
-const errors_1 = require("./errors");
-/**
- * Fetch raw trade history for a specific token.
- * @param id - The CLOB token ID
- *
- * NOTE: Uses Polymarket Data API (public) to fetch trades.
- */
-async function fetchTrades(id, params, callApi) {
-    (0, validation_1.validateIdFormat)(id, 'Trades');
-    (0, validation_1.validateOutcomeId)(id, 'Trades');
-    try {
-        const queryParams = {
-            asset_id: id // Uses asset_id for Token ID on Data API
-        };
-        // Add time filters if provided
-        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 callApi('getTrades', queryParams) || [];
-        const mappedTrades = trades.map((trade) => ({
-            id: trade.id || `${trade.timestamp}-${trade.price}`,
-            timestamp: trade.timestamp * 1000, // Convert to milliseconds
-            price: parseFloat(trade.price),
-            amount: parseFloat(trade.size || trade.amount || 0),
-            side: trade.side === 'BUY' ? 'buy' : trade.side === 'SELL' ? 'sell' : 'unknown'
-        }));
-        // Apply limit if specified
-        if (params.limit && mappedTrades.length > params.limit) {
-            return mappedTrades.slice(0, params.limit); // Return most recent N trades
-        }
-        return mappedTrades;
-    }
-    catch (error) {
-        throw errors_1.polymarketErrorMapper.mapError(error);
-    }
-}

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

@@ -1,6 +0,0 @@
-import { EventFetchParams } from '../../BaseExchange';
-import { UnifiedEvent } from '../../types';
-import { AxiosInstance } from 'axios';
-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>;