pmxt-core 2.20.1 → 2.20.2

package/dist/exchanges/kalshi/fetchMarkets.js

@@ -1,247 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resetCache = resetCache;
-exports.fetchMarkets = fetchMarkets;
-const utils_1 = require("./utils");
-const errors_1 = require("./errors");
-async function fetchActiveEvents(callApi, targetMarketCount, status = "open") {
-    let allEvents = [];
-    let totalMarketCount = 0;
-    let cursor = null;
-    let page = 0;
-    // Note: Kalshi API uses cursor-based pagination which requires sequential fetching.
-    // We cannot parallelize requests for a single list because we need the cursor from page N to fetch page N+1.
-    // To optimize, we use the maximum allowed limit (200) and fetch until exhaustion.
-    const MAX_PAGES = 1000; // Safety cap against infinite loops
-    const BATCH_SIZE = 200; // Max limit per Kalshi API docs
-    do {
-        try {
-            const queryParams = {
-                limit: BATCH_SIZE,
-                with_nested_markets: true,
-                status: status, // Filter by status (default 'open')
-            };
-            if (cursor)
-                queryParams.cursor = cursor;
-            const data = await callApi("GetEvents", queryParams);
-            const events = data.events || [];
-            if (events.length === 0)
-                break;
-            allEvents = allEvents.concat(events);
-            // Count markets in this batch for early termination
-            if (targetMarketCount) {
-                for (const event of events) {
-                    totalMarketCount += (event.markets || []).length;
-                }
-                // Early termination: if we have enough markets, stop fetching
-                // Use 1.5x multiplier to ensure we have enough for sorting/filtering
-                if (totalMarketCount >= targetMarketCount * 1.5) {
-                    break;
-                }
-            }
-            cursor = data.cursor;
-            page++;
-            // Additional safety: if no target specified, limit to reasonable number of pages
-            if (!targetMarketCount && page >= 10) {
-                break;
-            }
-        }
-        catch (e) {
-            throw errors_1.kalshiErrorMapper.mapError(e);
-        }
-    } while (cursor && page < MAX_PAGES);
-    return allEvents;
-}
-async function fetchSeriesMap(callApi) {
-    try {
-        const data = await callApi("GetSeriesList");
-        const seriesList = data.series || [];
-        const map = new Map();
-        for (const series of seriesList) {
-            if (series.tags && series.tags.length > 0) {
-                map.set(series.ticker, series.tags);
-            }
-        }
-        return map;
-    }
-    catch (e) {
-        throw errors_1.kalshiErrorMapper.mapError(e);
-    }
-}
-// Simple in-memory cache to avoid redundant API calls within a short period
-let cachedEvents = null;
-let cachedSeriesMap = null;
-let lastCacheTime = 0;
-const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-// Export a function to reset the cache (useful for testing)
-function resetCache() {
-    cachedEvents = null;
-    cachedSeriesMap = null;
-    lastCacheTime = 0;
-}
-async function fetchMarkets(params, callApi) {
-    try {
-        // Handle marketId lookup (Kalshi marketId is the ticker)
-        if (params?.marketId) {
-            return await fetchMarketsBySlug(params.marketId, callApi);
-        }
-        // Handle slug-based lookup (event ticker)
-        if (params?.slug) {
-            return await fetchMarketsBySlug(params.slug, callApi);
-        }
-        // Handle outcomeId lookup (strip -NO suffix, use as ticker)
-        if (params?.outcomeId) {
-            const ticker = params.outcomeId.replace(/-NO$/, "");
-            return await fetchMarketsBySlug(ticker, callApi);
-        }
-        // Handle eventId lookup (event ticker works the same way)
-        if (params?.eventId) {
-            return await fetchMarketsBySlug(params.eventId, callApi);
-        }
-        // Handle query-based search
-        if (params?.query) {
-            return await searchMarkets(params.query, params, callApi);
-        }
-        // Default: fetch markets
-        return await fetchMarketsDefault(params, callApi);
-    }
-    catch (error) {
-        throw errors_1.kalshiErrorMapper.mapError(error);
-    }
-}
-async function fetchMarketsBySlug(eventTicker, callApi) {
-    // Kalshi API expects uppercase tickers, but URLs use lowercase
-    const normalizedTicker = eventTicker.toUpperCase();
-    const data = await callApi("GetEvent", {
-        event_ticker: normalizedTicker,
-        with_nested_markets: true,
-    });
-    const event = data.event;
-    if (!event)
-        return [];
-    // Enrichment: Fetch series tags if they exist
-    if (event.series_ticker) {
-        try {
-            const seriesData = await callApi("GetSeries", {
-                series_ticker: event.series_ticker,
-            });
-            const series = seriesData.series;
-            if (series && series.tags && series.tags.length > 0) {
-                if (!event.tags || event.tags.length === 0) {
-                    event.tags = series.tags;
-                }
-            }
-        }
-        catch (e) {
-            // Ignore errors fetching series info - non-critical
-        }
-    }
-    const unifiedMarkets = [];
-    const markets = event.markets || [];
-    for (const market of markets) {
-        const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market);
-        if (unifiedMarket) {
-            unifiedMarkets.push(unifiedMarket);
-        }
-    }
-    return unifiedMarkets;
-}
-async function searchMarkets(query, params, callApi) {
-    // We must fetch ALL markets to search them locally since we don't have server-side search
-    const searchLimit = 250000;
-    const markets = await fetchMarketsDefault({ ...params, limit: searchLimit }, callApi);
-    const lowerQuery = query.toLowerCase();
-    const searchIn = params?.searchIn || "title"; // Default to title-only search
-    const filtered = markets.filter((market) => {
-        const titleMatch = (market.title || "").toLowerCase().includes(lowerQuery);
-        const descMatch = (market.description || "")
-            .toLowerCase()
-            .includes(lowerQuery);
-        if (searchIn === "title")
-            return titleMatch;
-        if (searchIn === "description")
-            return descMatch;
-        return titleMatch || descMatch; // 'both'
-    });
-    const limit = params?.limit || 250000;
-    return filtered.slice(0, limit);
-}
-async function fetchMarketsDefault(params, callApi) {
-    const limit = params?.limit || 250000;
-    const offset = params?.offset || 0;
-    const now = Date.now();
-    const status = params?.status || "active"; // Default to 'active'
-    // Map 'active' -> 'open', 'closed' -> 'closed'
-    // Kalshi statuses: 'open', 'closed', 'settled'
-    let apiStatus = "open";
-    if (status === "closed" || status === "inactive")
-        apiStatus = "closed";
-    else if (status === "all")
-        apiStatus = "open"; // Fallback for all? Or loop? For now default to open.
-    try {
-        let events;
-        let seriesMap;
-        // Check if we have valid cached data
-        // Only use global cache for the default 'active'/'open' case
-        const useCache = status === "active" || !params?.status;
-        if (useCache &&
-            cachedEvents &&
-            cachedSeriesMap &&
-            now - lastCacheTime < CACHE_TTL) {
-            events = cachedEvents;
-            seriesMap = cachedSeriesMap;
-        }
-        else {
-            // Optimize fetch limit based on request parameters
-            // If sorting is required (e.g. by volume), we need to fetch a larger set (or all) to sort correctly.
-            // If no sorting is requested, we only need to fetch enough to satisfy the limit.
-            const isSorted = params?.sort &&
-                (params.sort === "volume" || params.sort === "liquidity");
-            const fetchLimit = isSorted ? 1000 : limit;
-            const [allEvents, fetchedSeriesMap] = await Promise.all([
-                fetchActiveEvents(callApi, fetchLimit, apiStatus),
-                fetchSeriesMap(callApi),
-            ]);
-            events = allEvents;
-            seriesMap = fetchedSeriesMap;
-            // Cache the dataset ONLY if:
-            // 1. We fetched a comprehensive set (>= 1000)
-            // 2. It's the standard 'open' status query
-            if (fetchLimit >= 1000 && useCache) {
-                cachedEvents = allEvents;
-                cachedSeriesMap = fetchedSeriesMap;
-                lastCacheTime = now;
-            }
-        }
-        // Extract ALL markets from all events
-        const allMarkets = [];
-        // ... rest of the logic
-        for (const event of events) {
-            // Enrich event with tags from Series
-            if (event.series_ticker && seriesMap.has(event.series_ticker)) {
-                // If event has no tags or empty tags, use series tags
-                if (!event.tags || event.tags.length === 0) {
-                    event.tags = seriesMap.get(event.series_ticker);
-                }
-            }
-            const markets = event.markets || [];
-            for (const market of markets) {
-                const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market);
-                if (unifiedMarket) {
-                    allMarkets.push(unifiedMarket);
-                }
-            }
-        }
-        // Sort by 24h volume
-        if (params?.sort === "volume") {
-            allMarkets.sort((a, b) => b.volume24h - a.volume24h);
-        }
-        else if (params?.sort === "liquidity") {
-            allMarkets.sort((a, b) => b.liquidity - a.liquidity);
-        }
-        return allMarkets.slice(offset, offset + limit);
-    }
-    catch (error) {
-        throw errors_1.kalshiErrorMapper.mapError(error);
-    }
-}

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

@@ -1,3 +0,0 @@
-import { OHLCVParams } from "../../BaseExchange";
-import { PriceCandle } from "../../types";
-export declare function fetchOHLCV(id: string, params: OHLCVParams, callApi: (operationId: string, params?: Record<string, any>) => Promise<any>): Promise<PriceCandle[]>;

package/dist/exchanges/kalshi/fetchOHLCV.js

@@ -1,97 +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");
-const price_1 = require("./price");
-async function fetchOHLCV(id, params, callApi) {
-    (0, validation_1.validateIdFormat)(id, "OHLCV");
-    // Validate resolution is provided
-    if (!params.resolution) {
-        throw new Error("fetchOHLCV requires a resolution parameter. Use OHLCVParams with resolution specified.");
-    }
-    try {
-        // Kalshi API expects uppercase tickers
-        // Handle virtual "-NO" suffix by stripping it (fetching the underlying market history)
-        const cleanedId = id.replace(/-NO$/, "");
-        const normalizedId = cleanedId.toUpperCase();
-        const interval = (0, utils_1.mapIntervalToKalshi)(params.resolution);
-        // Heuristic for series_ticker
-        const parts = normalizedId.split("-");
-        if (parts.length < 2) {
-            throw new Error(`Invalid Kalshi Ticker format: "${id}". Expected format like "FED-25JAN29-B4.75".`);
-        }
-        const seriesTicker = parts.slice(0, -1).join("-");
-        const now = Math.floor(Date.now() / 1000);
-        let startTs = now - 24 * 60 * 60;
-        let endTs = now;
-        // 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;
-        if (pStart) {
-            startTs = Math.floor(pStart.getTime() / 1000);
-        }
-        if (pEnd) {
-            endTs = Math.floor(pEnd.getTime() / 1000);
-            if (!pStart) {
-                startTs = endTs - 24 * 60 * 60;
-            }
-        }
-        const data = await callApi("GetMarketCandlesticks", {
-            series_ticker: seriesTicker,
-            ticker: normalizedId,
-            period_interval: interval,
-            start_ts: startTs,
-            end_ts: endTs,
-        });
-        const candles = data.candlesticks || [];
-        const mappedCandles = candles.map((c) => {
-            // Priority:
-            // 1. Transaction price (close)
-            // 2. Mid price (average of yes_ask and yes_bid close)
-            // 3. Fallback to 0 if everything is missing
-            const p = c.price || {};
-            const ask = c.yes_ask || {};
-            const bid = c.yes_bid || {};
-            const getVal = (field) => {
-                if (p[field] !== null && p[field] !== undefined)
-                    return p[field];
-                if (ask[field] !== null &&
-                    bid[field] !== null &&
-                    ask[field] !== undefined &&
-                    bid[field] !== undefined) {
-                    return (ask[field] + bid[field]) / 2;
-                }
-                return p.previous || 0;
-            };
-            return {
-                timestamp: c.end_period_ts * 1000,
-                open: (0, price_1.fromKalshiCents)(getVal("open")),
-                high: (0, price_1.fromKalshiCents)(getVal("high")),
-                low: (0, price_1.fromKalshiCents)(getVal("low")),
-                close: (0, price_1.fromKalshiCents)(getVal("close")),
-                volume: c.volume || 0,
-            };
-        });
-        if (params.limit && mappedCandles.length > params.limit) {
-            return mappedCandles.slice(-params.limit);
-        }
-        return mappedCandles;
-    }
-    catch (error) {
-        throw errors_1.kalshiErrorMapper.mapError(error);
-    }
-}

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

@@ -1,2 +0,0 @@
-import { OrderBook } from "../../types";
-export declare function fetchOrderBook(baseUrl: string, id: string): Promise<OrderBook>;

package/dist/exchanges/kalshi/fetchOrderBook.js

@@ -1,60 +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.fetchOrderBook = fetchOrderBook;
-const axios_1 = __importDefault(require("axios"));
-const validation_1 = require("../../utils/validation");
-const errors_1 = require("./errors");
-const config_1 = require("./config");
-async function fetchOrderBook(baseUrl, id) {
-    (0, validation_1.validateIdFormat)(id, "OrderBook");
-    try {
-        // Check if this is a NO outcome request
-        const isNoOutcome = id.endsWith("-NO");
-        const ticker = id.replace(/-NO$/, "");
-        const url = (0, config_1.getMarketsUrl)(baseUrl, ticker, ["orderbook"]);
-        const response = await axios_1.default.get(url);
-        const data = response.data.orderbook_fp;
-        // Structure: { yes_dollars: [["price", "qty"], ...], no_dollars: [["price", "qty"], ...] }
-        // Prices are dollar strings (e.g. "0.15"), quantities are fixed-point strings (e.g. "100.00")
-        // - yes_dollars: bids for buying YES at price X
-        // - no_dollars: bids for buying NO at price X
-        let bids;
-        let asks;
-        if (isNoOutcome) {
-            // NO outcome order book:
-            // - Bids: people buying NO (use data.no_dollars directly)
-            // - Asks: people selling NO = people buying YES (invert data.yes_dollars)
-            bids = (data.no_dollars || []).map((level) => ({
-                price: parseFloat(level[0]),
-                size: parseFloat(level[1]),
-            }));
-            asks = (data.yes_dollars || []).map((level) => ({
-                price: Math.round((1 - parseFloat(level[0])) * 10000) / 10000,
-                size: parseFloat(level[1]),
-            }));
-        }
-        else {
-            // YES outcome order book:
-            // - Bids: people buying YES (use data.yes_dollars directly)
-            // - Asks: people selling YES = people buying NO (invert data.no_dollars)
-            bids = (data.yes_dollars || []).map((level) => ({
-                price: parseFloat(level[0]),
-                size: parseFloat(level[1]),
-            }));
-            asks = (data.no_dollars || []).map((level) => ({
-                price: Math.round((1 - parseFloat(level[0])) * 10000) / 10000,
-                size: parseFloat(level[1]),
-            }));
-        }
-        // Sort bids desc, asks asc
-        bids.sort((a, b) => b.price - a.price);
-        asks.sort((a, b) => a.price - b.price);
-        return { bids, asks, timestamp: Date.now() };
-    }
-    catch (error) {
-        throw errors_1.kalshiErrorMapper.mapError(error);
-    }
-}

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

@@ -1,3 +0,0 @@
-import { HistoryFilterParams, TradesParams } from "../../BaseExchange";
-import { Trade } from "../../types";
-export declare function fetchTrades(baseUrl: string, id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;

package/dist/exchanges/kalshi/fetchTrades.js

@@ -1,33 +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.fetchTrades = fetchTrades;
-const axios_1 = __importDefault(require("axios"));
-const errors_1 = require("./errors");
-const config_1 = require("./config");
-const price_1 = require("./price");
-async function fetchTrades(baseUrl, id, params) {
-    try {
-        const ticker = id.replace(/-NO$/, "");
-        const url = (0, config_1.getMarketsUrl)(baseUrl, undefined, ["trades"]);
-        const response = await axios_1.default.get(url, {
-            params: {
-                ticker: ticker,
-                limit: params.limit || 100,
-            },
-        });
-        const trades = response.data.trades || [];
-        return trades.map((t) => ({
-            id: t.trade_id,
-            timestamp: new Date(t.created_time).getTime(),
-            price: (0, price_1.fromKalshiCents)(t.yes_price),
-            amount: t.count,
-            side: t.taker_side === "yes" ? "buy" : "sell",
-        }));
-    }
-    catch (error) {
-        throw errors_1.kalshiErrorMapper.mapError(error);
-    }
-}

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

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

package/dist/exchanges/limitless/fetchEvents.js

@@ -1,173 +0,0 @@
-"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;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchEvents = fetchEvents;
-const utils_1 = require("./utils");
-const errors_1 = require("./errors");
-const axios_1 = __importDefault(require("axios"));
-async function fetchEventBySlug(slug, http = axios_1.default) {
-    const { HttpClient, MarketFetcher } = await Promise.resolve().then(() => __importStar(require('@limitless-exchange/sdk')));
-    const httpClient = new HttpClient({ baseURL: utils_1.LIMITLESS_API_URL });
-    const marketFetcher = new MarketFetcher(httpClient);
-    const market = await marketFetcher.getMarket(slug);
-    if (!market)
-        return null;
-    let marketsList = [];
-    if (market.markets && Array.isArray(market.markets)) {
-        marketsList = market.markets
-            .map((child) => (0, utils_1.mapMarketToUnified)(child))
-            .filter((m) => m !== null);
-    }
-    else {
-        const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
-        if (unifiedMarket)
-            marketsList = [unifiedMarket];
-    }
-    const unifiedEvent = {
-        id: market.slug,
-        title: market.title || market.question,
-        description: market.description || '',
-        slug: market.slug,
-        markets: marketsList,
-        volume24h: marketsList.reduce((sum, m) => sum + m.volume24h, 0),
-        volume: marketsList.some(m => m.volume !== undefined) ? marketsList.reduce((sum, m) => sum + (m.volume ?? 0), 0) : undefined,
-        url: `https://limitless.exchange/markets/${market.slug}`,
-        image: market.logo || `https://limitless.exchange/api/og?slug=${market.slug}`,
-        category: market.categories?.[0],
-        tags: market.tags || []
-    };
-    return unifiedEvent;
-}
-function rawMarketToEvent(market) {
-    let marketsList = [];
-    if (market.markets && Array.isArray(market.markets)) {
-        marketsList = market.markets
-            .map((child) => (0, utils_1.mapMarketToUnified)(child))
-            .filter((m) => m !== null);
-    }
-    else {
-        const unifiedMarket = (0, utils_1.mapMarketToUnified)(market);
-        if (unifiedMarket)
-            marketsList = [unifiedMarket];
-    }
-    const unifiedEvent = {
-        id: market.slug,
-        title: market.title || market.question,
-        description: market.description || '',
-        slug: market.slug,
-        markets: marketsList,
-        volume24h: marketsList.reduce((sum, m) => sum + m.volume24h, 0),
-        volume: marketsList.some(m => m.volume !== undefined) ? marketsList.reduce((sum, m) => sum + (m.volume ?? 0), 0) : undefined,
-        url: `https://limitless.exchange/markets/${market.slug}`,
-        image: market.logo || `https://limitless.exchange/api/og?slug=${market.slug}`,
-        category: market.categories?.[0],
-        tags: market.tags || []
-    };
-    return unifiedEvent;
-}
-async function fetchEvents(params, callApi, http = axios_1.default) {
-    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);
-            return event ? [event] : [];
-        }
-        // Query-based search: use the /markets/search endpoint
-        if (params.query) {
-            return await searchEvents(params, callApi);
-        }
-        // Default: fetch active group markets from /markets/active
-        // On Limitless, "events" = group markets (tradeType === 'group')
-        return await fetchEventsDefault(params, http);
-    }
-    catch (error) {
-        throw errors_1.limitlessErrorMapper.mapError(error);
-    }
-}
-async function searchEvents(params, callApi) {
-    // NOTE: The Limitless /markets/search endpoint currently only returns active/funded markets.
-    const data = await callApi('MarketSearchController_search', {
-        query: params.query,
-        limit: params?.limit || 10000,
-        similarityThreshold: 0.5,
-    });
-    let markets = data?.markets || [];
-    const status = params?.status || 'active';
-    if (status === 'active') {
-        markets = markets.filter((m) => !m.expired && m.winningOutcomeIndex === null);
-    }
-    else if (status === 'inactive' || status === 'closed') {
-        markets = markets.filter((m) => m.expired === true || m.winningOutcomeIndex !== null);
-    }
-    return markets.map(rawMarketToEvent);
-}
-async function fetchEventsDefault(params, http = axios_1.default) {
-    // Limitless has no dedicated /events endpoint.
-    // Group markets (tradeType === 'group') are the semantic equivalent of events.
-    // We use GET /markets/active and filter for groups only.
-    const limit = params?.limit || 10000;
-    let page = 1;
-    const pageSize = 25; // Limitless API hard limit
-    const MAX_PAGES = 40; // Safety cap
-    const allGroups = [];
-    while (allGroups.length < limit && page <= MAX_PAGES) {
-        const response = await http.get(`${utils_1.LIMITLESS_API_URL}/markets/active`, {
-            params: {
-                page,
-                limit: pageSize,
-                tradeType: 'group',
-                sortBy: params?.sort === 'newest' ? 'newest' : params?.sort === 'liquidity' ? 'lp_rewards' : 'high_value',
-            }
-        });
-        const items = response.data?.data || response.data || [];
-        if (items.length === 0)
-            break;
-        for (const item of items) {
-            if (allGroups.length >= limit)
-                break;
-            const event = rawMarketToEvent(item);
-            allGroups.push(event);
-        }
-        // If the page returned fewer items than the page size, we've reached the end
-        if (items.length < pageSize)
-            break;
-        page++;
-    }
-    return allGroups;
-}

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

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