pmxt-core 2.20.0 → 2.20.2

package/dist/exchanges/baozi/normalizer.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaoziNormalizer = void 0;
+const utils_1 = require("./utils");
+const fetcher_1 = require("./fetcher");
+// ---------------------------------------------------------------------------
+// Normalizer -- pure data mapping, no I/O
+// ---------------------------------------------------------------------------
+class BaoziNormalizer {
+    normalizeMarket(raw) {
+        if (!raw)
+            return null;
+        if ((0, fetcher_1.isRawBooleanMarket)(raw)) {
+            return (0, utils_1.mapBooleanToUnified)(raw.parsed, raw.pubkey);
+        }
+        if ((0, fetcher_1.isRawRaceMarket)(raw)) {
+            return (0, utils_1.mapRaceToUnified)(raw.parsed, raw.pubkey);
+        }
+        return null;
+    }
+    normalizeEvent(raw) {
+        const market = this.normalizeMarket(raw);
+        if (!market)
+            return null;
+        return {
+            id: market.marketId,
+            title: market.title,
+            description: market.description,
+            slug: market.marketId,
+            markets: [market],
+            volume24h: market.volume24h,
+            volume: market.volume,
+            url: market.url,
+            image: market.image,
+            category: market.category,
+            tags: market.tags,
+        };
+    }
+    normalizeMarkets(rawMarkets, params) {
+        const markets = [];
+        for (const raw of rawMarkets) {
+            const m = this.normalizeMarket(raw);
+            if (m)
+                markets.push(m);
+        }
+        return applyFilters(markets, params);
+    }
+    normalizeEvents(rawMarkets, params) {
+        const markets = this.normalizeMarkets(rawMarkets, params);
+        return markets.map(m => ({
+            id: m.marketId,
+            title: m.title,
+            description: m.description,
+            slug: m.marketId,
+            markets: [m],
+            volume24h: m.volume24h,
+            volume: m.volume,
+            url: m.url,
+            image: m.image,
+            category: m.category,
+            tags: m.tags,
+        }));
+    }
+    normalizeOrderBook(raw, outcomeId) {
+        if (!raw) {
+            throw new Error(`Market not found for outcome: ${outcomeId}`);
+        }
+        const market = this.normalizeMarket(raw);
+        if (!market) {
+            throw new Error(`Could not parse market for outcome: ${outcomeId}`);
+        }
+        const outcome = market.outcomes.find(o => o.outcomeId === outcomeId);
+        const price = outcome?.price ?? 0.5;
+        const totalLiquidity = market.liquidity;
+        return {
+            bids: [{ price, size: totalLiquidity }],
+            asks: [{ price, size: totalLiquidity }],
+            timestamp: Date.now(),
+        };
+    }
+    normalizeBooleanPositions(positions, marketLookup) {
+        const result = [];
+        for (const { parsed: pos } of positions) {
+            if (pos.claimed)
+                continue;
+            const marketPda = (0, utils_1.deriveMarketPda)(pos.marketId);
+            const marketPdaStr = marketPda.toString();
+            const market = marketLookup.get(marketPdaStr);
+            let currentYesPrice = 0;
+            let currentNoPrice = 0;
+            if (market) {
+                currentYesPrice = market.yes?.price ?? 0;
+                currentNoPrice = market.no?.price ?? 0;
+            }
+            const yesSOL = Number(pos.yesAmount) / utils_1.LAMPORTS_PER_SOL;
+            const noSOL = Number(pos.noAmount) / utils_1.LAMPORTS_PER_SOL;
+            if (yesSOL > 0) {
+                result.push({
+                    marketId: marketPdaStr,
+                    outcomeId: `${marketPdaStr}-YES`,
+                    outcomeLabel: 'Yes',
+                    size: yesSOL,
+                    entryPrice: 0,
+                    currentPrice: currentYesPrice,
+                    unrealizedPnL: 0,
+                });
+            }
+            if (noSOL > 0) {
+                result.push({
+                    marketId: marketPdaStr,
+                    outcomeId: `${marketPdaStr}-NO`,
+                    outcomeLabel: 'No',
+                    size: noSOL,
+                    entryPrice: 0,
+                    currentPrice: currentNoPrice,
+                    unrealizedPnL: 0,
+                });
+            }
+        }
+        return result;
+    }
+    normalizeRacePositions(positions, marketLookup) {
+        const result = [];
+        for (const { parsed: pos } of positions) {
+            if (pos.claimed)
+                continue;
+            const racePda = (0, utils_1.deriveRaceMarketPda)(pos.marketId);
+            const racePdaStr = racePda.toString();
+            const market = marketLookup.get(racePdaStr);
+            const outcomePrices = market ? market.outcomes.map(o => o.price) : [];
+            const outcomeLabels = market ? market.outcomes.map(o => o.label) : [];
+            for (let i = 0; i < pos.bets.length; i++) {
+                const betSOL = Number(pos.bets[i]) / utils_1.LAMPORTS_PER_SOL;
+                if (betSOL <= 0)
+                    continue;
+                result.push({
+                    marketId: racePdaStr,
+                    outcomeId: `${racePdaStr}-${i}`,
+                    outcomeLabel: outcomeLabels[i] || `Outcome ${i}`,
+                    size: betSOL,
+                    entryPrice: 0,
+                    currentPrice: outcomePrices[i] ?? 0,
+                    unrealizedPnL: 0,
+                });
+            }
+        }
+        return result;
+    }
+    normalizeBalance(raw) {
+        const solBalance = raw.lamports / utils_1.LAMPORTS_PER_SOL;
+        return [{
+                currency: 'SOL',
+                total: solBalance,
+                available: solBalance,
+                locked: 0,
+            }];
+    }
+}
+exports.BaoziNormalizer = BaoziNormalizer;
+// ---------------------------------------------------------------------------
+// Filtering / sorting (pure, no I/O)
+// ---------------------------------------------------------------------------
+function applyFilters(markets, params) {
+    let result = [...markets];
+    // Status filter
+    const status = params?.status || 'active';
+    if (status !== 'all') {
+        const now = Date.now();
+        if (status === 'active') {
+            result = result.filter(m => m.resolutionDate.getTime() > now);
+        }
+        else {
+            result = result.filter(m => m.resolutionDate.getTime() <= now);
+        }
+    }
+    // Text search
+    if (params?.query) {
+        const lowerQuery = params.query.toLowerCase();
+        const searchIn = params.searchIn || 'title';
+        result = result.filter(m => {
+            const titleMatch = m.title.toLowerCase().includes(lowerQuery);
+            const descMatch = (m.description || '').toLowerCase().includes(lowerQuery);
+            if (searchIn === 'title')
+                return titleMatch;
+            if (searchIn === 'description')
+                return descMatch;
+            return titleMatch || descMatch;
+        });
+    }
+    // Sort
+    if (params?.sort === 'volume') {
+        result.sort((a, b) => (b.volume || 0) - (a.volume || 0));
+    }
+    else if (params?.sort === 'liquidity') {
+        result.sort((a, b) => b.liquidity - a.liquidity);
+    }
+    else if (params?.sort === 'newest') {
+        result.sort((a, b) => b.resolutionDate.getTime() - a.resolutionDate.getTime());
+    }
+    else {
+        result.sort((a, b) => (b.volume || 0) - (a.volume || 0));
+    }
+    // Pagination
+    const offset = params?.offset || 0;
+    const limit = params?.limit || 10000;
+    result = result.slice(offset, offset + limit);
+    return result;
+}

package/dist/exchanges/interfaces.d.ts

@@ -0,0 +1,28 @@
+import { AxiosInstance } from 'axios';
+import { MarketFilterParams, EventFetchParams, OHLCVParams, TradesParams, MyTradesParams } from '../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, UserTrade, Position, Balance } from '../types';
+export interface FetcherContext {
+    readonly http: AxiosInstance;
+    callApi(operationId: string, params?: Record<string, any>): Promise<any>;
+    getHeaders(): Record<string, string>;
+}
+export interface IExchangeFetcher<TRawMarket = unknown, TRawEvent = unknown> {
+    fetchRawMarkets(params?: MarketFilterParams): Promise<TRawMarket[]>;
+    fetchRawEvents(params: EventFetchParams): Promise<TRawEvent[]>;
+    fetchRawOHLCV?(id: string, params: OHLCVParams): Promise<unknown>;
+    fetchRawOrderBook?(id: string): Promise<unknown>;
+    fetchRawTrades?(id: string, params: TradesParams): Promise<unknown[]>;
+    fetchRawMyTrades?(params: MyTradesParams, walletAddress: string): Promise<unknown[]>;
+    fetchRawPositions?(walletAddress: string): Promise<unknown[]>;
+    fetchRawBalance?(walletAddress: string): Promise<unknown>;
+}
+export interface IExchangeNormalizer<TRawMarket = unknown, TRawEvent = unknown> {
+    normalizeMarket(raw: TRawMarket): UnifiedMarket | null;
+    normalizeEvent(raw: TRawEvent): UnifiedEvent | null;
+    normalizeOHLCV?(raw: unknown, params: OHLCVParams): PriceCandle[];
+    normalizeOrderBook?(raw: unknown, id: string): OrderBook;
+    normalizeTrade?(raw: unknown, index: number): Trade;
+    normalizeUserTrade?(raw: unknown, index: number): UserTrade;
+    normalizePosition?(raw: unknown): Position;
+    normalizeBalance?(raw: unknown): Balance[];
+}

package/dist/exchanges/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/dist/exchanges/kalshi/api.js

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

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

@@ -0,0 +1,126 @@
+import { MarketFilterParams, EventFetchParams, OHLCVParams, TradesParams, MyTradesParams } from '../../BaseExchange';
+import { IExchangeFetcher, FetcherContext } from '../interfaces';
+export interface KalshiRawMarket {
+    ticker: string;
+    last_price?: number;
+    yes_ask?: number;
+    yes_bid?: number;
+    subtitle?: string;
+    yes_sub_title?: string;
+    previous_price_dollars?: number;
+    last_price_dollars?: number;
+    rules_primary?: string;
+    rules_secondary?: string;
+    expiration_time: string;
+    volume_24h?: number;
+    volume?: number;
+    liquidity?: number;
+    open_interest?: number;
+    close_time?: string;
+    [key: string]: unknown;
+}
+export interface KalshiRawEvent {
+    event_ticker: string;
+    title: string;
+    mututals_description?: string;
+    image_url?: string;
+    category?: string;
+    tags?: string[];
+    series_ticker?: string;
+    markets?: KalshiRawMarket[];
+    [key: string]: unknown;
+}
+export interface KalshiRawCandlestick {
+    end_period_ts: number;
+    volume?: number;
+    price?: {
+        open?: number;
+        high?: number;
+        low?: number;
+        close?: number;
+        previous?: number;
+    };
+    yes_ask?: {
+        open?: number;
+        high?: number;
+        low?: number;
+        close?: number;
+    };
+    yes_bid?: {
+        open?: number;
+        high?: number;
+        low?: number;
+        close?: number;
+    };
+    [key: string]: unknown;
+}
+export interface KalshiRawOrderBookFp {
+    yes_dollars?: string[][];
+    no_dollars?: string[][];
+}
+export interface KalshiRawTrade {
+    trade_id: string;
+    created_time: string;
+    yes_price: number;
+    count: number;
+    taker_side: string;
+    [key: string]: unknown;
+}
+export interface KalshiRawFill {
+    fill_id: string;
+    created_time: string;
+    yes_price: number;
+    count: number;
+    side: string;
+    order_id: string;
+    [key: string]: unknown;
+}
+export interface KalshiRawOrder {
+    order_id: string;
+    ticker: string;
+    side: string;
+    type?: string;
+    yes_price?: number;
+    count: number;
+    remaining_count?: number;
+    status?: string;
+    created_time: string;
+    [key: string]: unknown;
+}
+export interface KalshiRawPosition {
+    ticker: string;
+    position: number;
+    total_cost: number;
+    market_price?: number;
+    market_exposure?: number;
+    realized_pnl?: number;
+    [key: string]: unknown;
+}
+export declare class KalshiFetcher implements IExchangeFetcher<KalshiRawEvent, KalshiRawEvent> {
+    private readonly ctx;
+    private cachedEvents;
+    private cachedSeriesMap;
+    private lastCacheTime;
+    constructor(ctx: FetcherContext);
+    resetCache(): void;
+    fetchRawMarkets(params?: MarketFilterParams): Promise<KalshiRawEvent[]>;
+    fetchRawEvents(params: EventFetchParams): Promise<KalshiRawEvent[]>;
+    fetchRawOHLCV(id: string, params: OHLCVParams): Promise<KalshiRawCandlestick[]>;
+    fetchRawOrderBook(id: string): Promise<{
+        orderbook_fp: KalshiRawOrderBookFp;
+    }>;
+    fetchRawTrades(id: string, params: TradesParams): Promise<KalshiRawTrade[]>;
+    fetchRawMyTrades(params: MyTradesParams): Promise<KalshiRawFill[]>;
+    fetchRawPositions(): Promise<KalshiRawPosition[]>;
+    fetchRawBalance(): Promise<{
+        balance: number;
+        portfolio_value: number;
+    }>;
+    fetchRawOrders(queryParams: Record<string, any>): Promise<KalshiRawOrder[]>;
+    fetchRawHistoricalOrders(queryParams: Record<string, any>): Promise<KalshiRawOrder[]>;
+    fetchRawSeriesMap(): Promise<Map<string, string[]>>;
+    fetchRawEventByTicker(eventTicker: string): Promise<KalshiRawEvent[]>;
+    private fetchRawEventsDefault;
+    private fetchActiveEvents;
+    private fetchAllWithStatus;
+}

package/dist/exchanges/kalshi/fetcher.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KalshiFetcher = void 0;
+const errors_1 = require("./errors");
+const validation_1 = require("../../utils/validation");
+const utils_1 = require("./utils");
+// ----------------------------------------------------------------------------
+// Fetcher
+// ----------------------------------------------------------------------------
+const BATCH_SIZE = 200;
+const MAX_PAGES = 1000;
+const CACHE_TTL = 5 * 60 * 1000;
+class KalshiFetcher {
+    ctx;
+    // Instance-level cache (moved from module-level)
+    cachedEvents = null;
+    cachedSeriesMap = null;
+    lastCacheTime = 0;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    resetCache() {
+        this.cachedEvents = null;
+        this.cachedSeriesMap = null;
+        this.lastCacheTime = 0;
+    }
+    // -- Markets (returns raw events containing nested markets) ----------------
+    async fetchRawMarkets(params) {
+        try {
+            if (params?.marketId) {
+                return this.fetchRawEventByTicker(params.marketId);
+            }
+            if (params?.slug) {
+                return this.fetchRawEventByTicker(params.slug);
+            }
+            if (params?.outcomeId) {
+                const ticker = params.outcomeId.replace(/-NO$/, '');
+                return this.fetchRawEventByTicker(ticker);
+            }
+            if (params?.eventId) {
+                return this.fetchRawEventByTicker(params.eventId);
+            }
+            // Default + query cases: fetch all events, caller does filtering
+            return this.fetchRawEventsDefault(params);
+        }
+        catch (error) {
+            throw errors_1.kalshiErrorMapper.mapError(error);
+        }
+    }
+    // -- Events ---------------------------------------------------------------
+    async fetchRawEvents(params) {
+        try {
+            if (params.eventId) {
+                return this.fetchRawEventByTicker(params.eventId);
+            }
+            if (params.slug) {
+                return this.fetchRawEventByTicker(params.slug);
+            }
+            const status = params?.status || 'active';
+            if (status === 'all') {
+                const [openEvents, closedEvents, settledEvents] = await Promise.all([
+                    this.fetchAllWithStatus('open'),
+                    this.fetchAllWithStatus('closed'),
+                    this.fetchAllWithStatus('settled'),
+                ]);
+                return [...openEvents, ...closedEvents, ...settledEvents];
+            }
+            else if (status === 'closed' || status === 'inactive') {
+                const [closedEvents, settledEvents] = await Promise.all([
+                    this.fetchAllWithStatus('closed'),
+                    this.fetchAllWithStatus('settled'),
+                ]);
+                return [...closedEvents, ...settledEvents];
+            }
+            return this.fetchAllWithStatus('open');
+        }
+        catch (error) {
+            throw errors_1.kalshiErrorMapper.mapError(error);
+        }
+    }
+    // -- OHLCV ----------------------------------------------------------------
+    async fetchRawOHLCV(id, params) {
+        (0, validation_1.validateIdFormat)(id, 'OHLCV');
+        if (!params.resolution) {
+            throw new Error('fetchOHLCV requires a resolution parameter.');
+        }
+        try {
+            const cleanedId = id.replace(/-NO$/, '');
+            const normalizedId = cleanedId.toUpperCase();
+            const interval = (0, utils_1.mapIntervalToKalshi)(params.resolution);
+            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;
+            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;
+            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 this.ctx.callApi('GetMarketCandlesticks', {
+                series_ticker: seriesTicker,
+                ticker: normalizedId,
+                period_interval: interval,
+                start_ts: startTs,
+                end_ts: endTs,
+            });
+            return data.candlesticks || [];
+        }
+        catch (error) {
+            throw errors_1.kalshiErrorMapper.mapError(error);
+        }
+    }
+    // -- OrderBook -------------------------------------------------------------
+    async fetchRawOrderBook(id) {
+        (0, validation_1.validateIdFormat)(id, 'OrderBook');
+        const ticker = id.replace(/-NO$/, '');
+        const data = await this.ctx.callApi('GetMarketOrderbook', { ticker });
+        return data;
+    }
+    // -- Trades ----------------------------------------------------------------
+    async fetchRawTrades(id, params) {
+        const ticker = id.replace(/-NO$/, '');
+        const data = await this.ctx.callApi('GetTrades', {
+            ticker,
+            limit: params.limit || 100,
+        });
+        return data.trades || [];
+    }
+    // -- User data -------------------------------------------------------------
+    async fetchRawMyTrades(params) {
+        const queryParams = {};
+        if (params?.outcomeId || params?.marketId) {
+            queryParams.ticker = (params.outcomeId || params.marketId).replace(/-NO$/, '');
+        }
+        if (params?.since)
+            queryParams.min_ts = Math.floor(params.since.getTime() / 1000);
+        if (params?.until)
+            queryParams.max_ts = Math.floor(params.until.getTime() / 1000);
+        if (params?.limit)
+            queryParams.limit = params.limit;
+        if (params?.cursor)
+            queryParams.cursor = params.cursor;
+        const data = await this.ctx.callApi('GetFills', queryParams);
+        return data.fills || [];
+    }
+    async fetchRawPositions() {
+        const data = await this.ctx.callApi('GetPositions');
+        return data.market_positions || [];
+    }
+    async fetchRawBalance() {
+        return this.ctx.callApi('GetBalance');
+    }
+    async fetchRawOrders(queryParams) {
+        const data = await this.ctx.callApi('GetOrders', queryParams);
+        return data.orders || [];
+    }
+    async fetchRawHistoricalOrders(queryParams) {
+        const data = await this.ctx.callApi('GetHistoricalOrders', queryParams);
+        return data.orders || [];
+    }
+    async fetchRawSeriesMap() {
+        try {
+            const data = await this.ctx.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);
+        }
+    }
+    // -- Private helpers -------------------------------------------------------
+    async fetchRawEventByTicker(eventTicker) {
+        const normalizedTicker = eventTicker.toUpperCase();
+        const data = await this.ctx.callApi('GetEvent', {
+            event_ticker: normalizedTicker,
+            with_nested_markets: true,
+        });
+        const event = data.event;
+        if (!event)
+            return [];
+        // Enrich with series tags
+        if (event.series_ticker) {
+            try {
+                const seriesData = await this.ctx.callApi('GetSeries', {
+                    series_ticker: event.series_ticker,
+                });
+                const series = seriesData.series;
+                if (series?.tags?.length > 0 && (!event.tags || event.tags.length === 0)) {
+                    event.tags = series.tags;
+                }
+            }
+            catch {
+                // Non-critical
+            }
+        }
+        return [event];
+    }
+    async fetchRawEventsDefault(params) {
+        const limit = params?.limit || 250000;
+        const now = Date.now();
+        const status = params?.status || 'active';
+        let apiStatus = 'open';
+        if (status === 'closed' || status === 'inactive')
+            apiStatus = 'closed';
+        const useCache = status === 'active' || !params?.status;
+        if (useCache && this.cachedEvents && this.cachedSeriesMap && now - this.lastCacheTime < CACHE_TTL) {
+            return this.cachedEvents;
+        }
+        const isSorted = params?.sort && (params.sort === 'volume' || params.sort === 'liquidity');
+        const fetchLimit = isSorted ? 1000 : limit;
+        const [allEvents, fetchedSeriesMap] = await Promise.all([
+            this.fetchActiveEvents(fetchLimit, apiStatus),
+            this.fetchRawSeriesMap(),
+        ]);
+        // Enrich events with series tags
+        for (const event of allEvents) {
+            if (event.series_ticker && fetchedSeriesMap.has(event.series_ticker)) {
+                if (!event.tags || event.tags.length === 0) {
+                    event.tags = fetchedSeriesMap.get(event.series_ticker);
+                }
+            }
+        }
+        if (fetchLimit >= 1000 && useCache) {
+            this.cachedEvents = allEvents;
+            this.cachedSeriesMap = fetchedSeriesMap;
+            this.lastCacheTime = now;
+        }
+        return allEvents;
+    }
+    async fetchActiveEvents(targetMarketCount, status = 'open') {
+        let allEvents = [];
+        let totalMarketCount = 0;
+        let cursor = null;
+        let page = 0;
+        do {
+            try {
+                const queryParams = {
+                    limit: BATCH_SIZE,
+                    with_nested_markets: true,
+                    status,
+                };
+                if (cursor)
+                    queryParams.cursor = cursor;
+                const data = await this.ctx.callApi('GetEvents', queryParams);
+                const events = data.events || [];
+                if (events.length === 0)
+                    break;
+                allEvents = allEvents.concat(events);
+                if (targetMarketCount) {
+                    for (const event of events) {
+                        totalMarketCount += (event.markets || []).length;
+                    }
+                    if (totalMarketCount >= targetMarketCount * 1.5)
+                        break;
+                }
+                cursor = data.cursor;
+                page++;
+                if (!targetMarketCount && page >= 10)
+                    break;
+            }
+            catch (e) {
+                throw errors_1.kalshiErrorMapper.mapError(e);
+            }
+        } while (cursor && page < MAX_PAGES);
+        return allEvents;
+    }
+    async fetchAllWithStatus(apiStatus) {
+        let allEvents = [];
+        let cursor = null;
+        let page = 0;
+        do {
+            const queryParams = {
+                limit: BATCH_SIZE,
+                with_nested_markets: true,
+                status: apiStatus,
+            };
+            if (cursor)
+                queryParams.cursor = cursor;
+            const data = await this.ctx.callApi('GetEvents', queryParams);
+            const events = data.events || [];
+            if (events.length === 0)
+                break;
+            allEvents = allEvents.concat(events);
+            cursor = data.cursor;
+            page++;
+        } while (cursor && page < MAX_PAGES);
+        return allEvents;
+    }
+}
+exports.KalshiFetcher = KalshiFetcher;