pmxt-core 2.20.0 → 2.20.2

package/dist/exchanges/kalshi/normalizer.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KalshiNormalizer = void 0;
+exports.sortRawEvents = sortRawEvents;
+const market_utils_1 = require("../../utils/market-utils");
+const price_1 = require("./price");
+class KalshiNormalizer {
+    normalizeMarket(raw) {
+        // This normalizes a single-market event. For multi-market events, use normalizeMarketsFromEvent.
+        if (!raw || !raw.markets || raw.markets.length === 0)
+            return null;
+        return this.normalizeRawMarket(raw, raw.markets[0]);
+    }
+    normalizeMarketsFromEvent(rawEvent) {
+        const markets = rawEvent.markets || [];
+        const results = [];
+        for (const market of markets) {
+            const um = this.normalizeRawMarket(rawEvent, market);
+            if (um)
+                results.push(um);
+        }
+        return results;
+    }
+    normalizeRawMarket(event, market) {
+        if (!market)
+            return null;
+        let price = 0.5;
+        if (market.last_price) {
+            price = (0, price_1.fromKalshiCents)(market.last_price);
+        }
+        else if (market.yes_ask && market.yes_bid) {
+            price = ((0, price_1.fromKalshiCents)(market.yes_ask) + (0, price_1.fromKalshiCents)(market.yes_bid)) / 2;
+        }
+        else if (market.yes_ask) {
+            price = (0, price_1.fromKalshiCents)(market.yes_ask);
+        }
+        let candidateName = null;
+        if (market.subtitle || market.yes_sub_title) {
+            candidateName = (market.subtitle || market.yes_sub_title);
+        }
+        let priceChange = 0;
+        if (market.previous_price_dollars !== undefined && market.last_price_dollars !== undefined) {
+            priceChange = market.last_price_dollars - market.previous_price_dollars;
+        }
+        const outcomes = [
+            {
+                outcomeId: market.ticker,
+                marketId: market.ticker,
+                label: candidateName || 'Yes',
+                price,
+                priceChange24h: priceChange,
+            },
+            {
+                outcomeId: `${market.ticker}-NO`,
+                marketId: market.ticker,
+                label: candidateName ? `Not ${candidateName}` : 'No',
+                price: (0, price_1.invertKalshiUnified)(price),
+                priceChange24h: -priceChange,
+            },
+        ];
+        const unifiedTags = [];
+        if (event.category)
+            unifiedTags.push(event.category);
+        if (event.tags && Array.isArray(event.tags)) {
+            for (const tag of event.tags) {
+                if (!unifiedTags.includes(tag))
+                    unifiedTags.push(tag);
+            }
+        }
+        const um = {
+            id: market.ticker,
+            marketId: market.ticker,
+            eventId: event.event_ticker,
+            title: event.title,
+            description: market.rules_primary || market.rules_secondary || '',
+            outcomes,
+            resolutionDate: new Date(market.expiration_time),
+            volume24h: Number(market.volume_24h || market.volume || 0),
+            volume: Number(market.volume || 0),
+            liquidity: Number(market.liquidity || 0),
+            openInterest: Number(market.open_interest || 0),
+            url: `https://kalshi.com/events/${event.event_ticker}`,
+            category: event.category,
+            tags: unifiedTags,
+        };
+        (0, market_utils_1.addBinaryOutcomes)(um);
+        return um;
+    }
+    normalizeEvent(raw) {
+        if (!raw)
+            return null;
+        const markets = this.normalizeMarketsFromEvent(raw);
+        return {
+            id: raw.event_ticker,
+            title: raw.title,
+            description: raw.mututals_description || this.deriveEventDescription(raw.markets || []),
+            slug: raw.event_ticker,
+            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://kalshi.com/events/${raw.event_ticker}`,
+            image: raw.image_url,
+            category: raw.category,
+            tags: raw.tags || [],
+        };
+    }
+    normalizeOHLCV(rawCandles, params) {
+        const candles = rawCandles.map((c) => {
+            const p = c.price || {};
+            const ask = c.yes_ask || {};
+            const bid = c.yes_bid || {};
+            const getVal = (field) => {
+                const pf = p[field];
+                const af = ask[field];
+                const bf = bid[field];
+                if (pf !== null && pf !== undefined)
+                    return pf;
+                if (af !== null && af !== undefined && bf !== null && bf !== undefined) {
+                    return (af + bf) / 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 && candles.length > params.limit) {
+            return candles.slice(-params.limit);
+        }
+        return candles;
+    }
+    normalizeOrderBook(raw, id) {
+        const data = raw.orderbook_fp;
+        const isNoOutcome = id.endsWith('-NO');
+        let bids;
+        let asks;
+        if (isNoOutcome) {
+            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 {
+            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]),
+            }));
+        }
+        bids.sort((a, b) => b.price - a.price);
+        asks.sort((a, b) => a.price - b.price);
+        return { bids, asks, timestamp: Date.now() };
+    }
+    normalizeTrade(raw, _index) {
+        return {
+            id: raw.trade_id,
+            timestamp: new Date(raw.created_time).getTime(),
+            price: (0, price_1.fromKalshiCents)(raw.yes_price),
+            amount: raw.count,
+            side: raw.taker_side === 'yes' ? 'buy' : 'sell',
+        };
+    }
+    normalizeUserTrade(raw, _index) {
+        return {
+            id: raw.fill_id,
+            timestamp: new Date(raw.created_time).getTime(),
+            price: (0, price_1.fromKalshiCents)(raw.yes_price),
+            amount: raw.count,
+            side: raw.side === 'yes' ? 'buy' : 'sell',
+            orderId: raw.order_id,
+        };
+    }
+    normalizeOrder(raw) {
+        return {
+            id: raw.order_id,
+            marketId: raw.ticker,
+            outcomeId: raw.ticker,
+            side: raw.side === 'yes' ? 'buy' : 'sell',
+            type: raw.type === 'limit' ? 'limit' : 'market',
+            price: raw.yes_price ? raw.yes_price / 100 : undefined,
+            amount: raw.count,
+            status: this.mapOrderStatus(raw.status),
+            filled: raw.count - (raw.remaining_count || 0),
+            remaining: raw.remaining_count || 0,
+            timestamp: new Date(raw.created_time).getTime(),
+        };
+    }
+    normalizePosition(raw) {
+        const absPosition = Math.abs(raw.position);
+        const entryPrice = absPosition > 0 ? raw.total_cost / absPosition / 100 : 0;
+        return {
+            marketId: raw.ticker,
+            outcomeId: raw.ticker,
+            outcomeLabel: raw.ticker,
+            size: raw.position,
+            entryPrice,
+            currentPrice: raw.market_price ? raw.market_price / 100 : entryPrice,
+            unrealizedPnL: raw.market_exposure ? raw.market_exposure / 100 : 0,
+            realizedPnL: raw.realized_pnl ? raw.realized_pnl / 100 : 0,
+        };
+    }
+    normalizeBalance(raw) {
+        const available = raw.balance / 100;
+        const total = raw.portfolio_value / 100;
+        return [{
+                currency: 'USD',
+                total,
+                available,
+                locked: total - available,
+            }];
+    }
+    // -- Helpers ---------------------------------------------------------------
+    mapOrderStatus(status) {
+        switch ((status ?? '').toLowerCase()) {
+            case 'resting': return 'open';
+            case 'canceled':
+            case 'cancelled': return 'cancelled';
+            case 'executed':
+            case 'filled': return 'filled';
+            default: return 'open';
+        }
+    }
+    deriveEventDescription(markets) {
+        const texts = markets
+            .map((m) => m.rules_primary)
+            .filter((t) => typeof t === 'string' && t.length > 0);
+        if (texts.length === 0)
+            return '';
+        if (texts.length === 1)
+            return texts[0];
+        let prefix = texts[0];
+        for (const t of texts) {
+            while (!t.startsWith(prefix))
+                prefix = prefix.slice(0, -1);
+            if (!prefix)
+                break;
+        }
+        const suffixCandidates = texts.map((t) => t.slice(prefix.length));
+        let suffix = suffixCandidates[0];
+        for (const t of suffixCandidates) {
+            while (!t.endsWith(suffix))
+                suffix = suffix.slice(1);
+            if (!suffix)
+                break;
+        }
+        if (prefix.length + suffix.length < 20)
+            return texts[0];
+        const variables = texts.map((t) => t.slice(prefix.length, suffix.length ? t.length - suffix.length : undefined));
+        if (new Set(variables).size === 1)
+            return texts[0];
+        return prefix + '{x}' + suffix;
+    }
+}
+exports.KalshiNormalizer = KalshiNormalizer;
+// -- Event sorting utility (exported for fetchEvents) -------------------------
+function eventVolume(event) {
+    return (event.markets || []).reduce((sum, m) => sum + Number(m.volume || 0), 0);
+}
+function eventLiquidity(event) {
+    return (event.markets || []).reduce((sum, m) => sum + Number(m.open_interest || m.liquidity || 0), 0);
+}
+function eventNewest(event) {
+    const times = (event.markets || [])
+        .map((m) => (m.close_time ? new Date(m.close_time).getTime() : 0))
+        .filter((t) => t > 0);
+    return times.length > 0 ? Math.min(...times) : 0;
+}
+function sortRawEvents(events, sort) {
+    const copy = [...events];
+    if (sort === 'newest') {
+        copy.sort((a, b) => eventNewest(b) - eventNewest(a));
+    }
+    else if (sort === 'liquidity') {
+        copy.sort((a, b) => eventLiquidity(b) - eventLiquidity(a));
+    }
+    else {
+        copy.sort((a, b) => eventVolume(b) - eventVolume(a));
+    }
+    return copy;
+}

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

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

package/dist/exchanges/limitless/api.js

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

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

@@ -0,0 +1,81 @@
+import { AxiosInstance } from 'axios';
+import { MarketFetchParams, EventFetchParams, OHLCVParams, TradesParams, MyTradesParams } from '../../BaseExchange';
+import { IExchangeFetcher, FetcherContext } from '../interfaces';
+export interface LimitlessRawMarket {
+    slug: string;
+    title?: string;
+    question?: string;
+    description?: string;
+    tokens?: Record<string, string>;
+    prices?: number[];
+    expirationTimestamp?: string;
+    volumeFormatted?: number;
+    volume?: number;
+    logo?: string | null;
+    categories?: string[];
+    tags?: string[];
+    markets?: LimitlessRawMarket[];
+    expired?: boolean;
+    winningOutcomeIndex?: number | null;
+    tradeType?: string;
+    [key: string]: unknown;
+}
+export interface LimitlessRawEvent {
+    slug: string;
+    title?: string;
+    question?: string;
+    description?: string;
+    logo?: string | null;
+    categories?: string[];
+    tags?: string[];
+    markets?: LimitlessRawMarket[];
+    expired?: boolean;
+    winningOutcomeIndex?: number | null;
+    [key: string]: unknown;
+}
+export interface LimitlessRawPricePoint {
+    price: number | string;
+    timestamp: number | string;
+    [key: string]: unknown;
+}
+export interface LimitlessRawOrderBookLevel {
+    price: number | string;
+    size: number | string;
+    [key: string]: unknown;
+}
+export interface LimitlessRawOrderBook {
+    bids: LimitlessRawOrderBookLevel[];
+    asks: LimitlessRawOrderBookLevel[];
+    timestamp?: number;
+    [key: string]: unknown;
+}
+export interface LimitlessRawTrade {
+    id?: string;
+    timestamp?: number;
+    createdAt?: string;
+    price?: string;
+    quantity?: string;
+    amount?: string;
+    side?: string;
+    orderId?: string;
+    [key: string]: unknown;
+}
+export declare class LimitlessFetcher implements IExchangeFetcher<LimitlessRawMarket, LimitlessRawEvent> {
+    private readonly ctx;
+    private readonly http;
+    private readonly apiKey?;
+    constructor(ctx: FetcherContext, http: AxiosInstance, apiKey?: string);
+    fetchRawMarkets(params?: MarketFetchParams): Promise<LimitlessRawMarket[]>;
+    fetchRawEvents(params: EventFetchParams): Promise<LimitlessRawEvent[]>;
+    fetchRawOHLCV(id: string, params: OHLCVParams): Promise<LimitlessRawPricePoint[]>;
+    fetchRawOrderBook(id: string): Promise<LimitlessRawOrderBook>;
+    fetchRawTrades(_id: string, _params: TradesParams): Promise<LimitlessRawTrade[]>;
+    fetchRawMyTrades(_params: MyTradesParams, apiKey: string): Promise<LimitlessRawTrade[]>;
+    fetchRawPositions(account: string): Promise<unknown[]>;
+    private fetchRawMarketBySlug;
+    private searchRawMarkets;
+    private fetchRawMarketsDefault;
+    private fetchRawEventBySlug;
+    private searchRawEvents;
+    private fetchRawEventsDefault;
+}

package/dist/exchanges/limitless/fetcher.js

@@ -0,0 +1,238 @@
+"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.LimitlessFetcher = void 0;
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+const validation_1 = require("../../utils/validation");
+// ---------------------------------------------------------------------------
+// Fetcher
+// ---------------------------------------------------------------------------
+class LimitlessFetcher {
+    ctx;
+    http;
+    apiKey;
+    constructor(ctx, http, apiKey) {
+        this.ctx = ctx;
+        this.http = http;
+        this.apiKey = apiKey;
+    }
+    async fetchRawMarkets(params) {
+        if (params?.status === 'inactive' || params?.status === 'closed') {
+            return [];
+        }
+        const { HttpClient, MarketFetcher } = await Promise.resolve().then(() => __importStar(require('@limitless-exchange/sdk')));
+        try {
+            const httpClient = new HttpClient({
+                baseURL: utils_1.LIMITLESS_API_URL,
+                apiKey: this.apiKey,
+            });
+            const marketFetcher = new MarketFetcher(httpClient);
+            if (params?.marketId) {
+                return this.fetchRawMarketBySlug(marketFetcher, params.marketId);
+            }
+            if (params?.slug) {
+                return this.fetchRawMarketBySlug(marketFetcher, params.slug);
+            }
+            if (params?.eventId) {
+                return this.fetchRawMarketBySlug(marketFetcher, params.eventId);
+            }
+            if (params?.query) {
+                return this.searchRawMarkets(params.query, params);
+            }
+            return this.fetchRawMarketsDefault(marketFetcher, params);
+        }
+        catch (error) {
+            throw errors_1.limitlessErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawEvents(params) {
+        try {
+            if (params.eventId || params.slug) {
+                const slug = params.eventId || params.slug;
+                return this.fetchRawEventBySlug(slug);
+            }
+            if (params.query) {
+                return this.searchRawEvents(params);
+            }
+            return this.fetchRawEventsDefault(params);
+        }
+        catch (error) {
+            throw errors_1.limitlessErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawOHLCV(id, params) {
+        (0, validation_1.validateIdFormat)(id, 'OHLCV');
+        if (!params.resolution) {
+            throw new Error('fetchOHLCV requires a resolution parameter. Use OHLCVParams with resolution specified.');
+        }
+        try {
+            const { mapIntervalToFidelity } = await Promise.resolve().then(() => __importStar(require('./utils')));
+            const fidelity = mapIntervalToFidelity(params.resolution);
+            const data = await this.ctx.callApi('MarketOrderbookController_getHistoricalPrice', { slug: id, fidelity });
+            return data.prices || [];
+        }
+        catch (error) {
+            throw errors_1.limitlessErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawOrderBook(id) {
+        (0, validation_1.validateIdFormat)(id, 'OrderBook');
+        try {
+            const data = await this.ctx.callApi('MarketOrderbookController_getOrderbook', { slug: id });
+            return {
+                bids: data.bids || [],
+                asks: data.asks || [],
+                timestamp: data.timestamp,
+            };
+        }
+        catch (error) {
+            return { bids: [], asks: [] };
+        }
+    }
+    async fetchRawTrades(_id, _params) {
+        throw errors_1.limitlessErrorMapper.mapError(new Error('Limitless fetchTrades not implemented: No public market trades API available.'));
+    }
+    async fetchRawMyTrades(_params, apiKey) {
+        try {
+            const response = await this.http.get('https://api.limitless.exchange/portfolio/trades', {
+                headers: { Authorization: `Bearer ${apiKey}` },
+            });
+            const trades = Array.isArray(response.data) ? response.data : (response.data?.data || []);
+            return trades;
+        }
+        catch (error) {
+            throw errors_1.limitlessErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawPositions(account) {
+        const result = await this.ctx.callApi('PublicPortfolioController_getPositions', { account });
+        return result?.data || result || [];
+    }
+    // -- Private helpers -------------------------------------------------------
+    async fetchRawMarketBySlug(marketFetcher, slug) {
+        const market = await marketFetcher.getMarket(slug);
+        return market ? [market] : [];
+    }
+    async searchRawMarkets(query, params) {
+        const data = await this.ctx.callApi('MarketSearchController_search', {
+            query: query,
+            limit: params?.limit || 250000,
+            page: params?.page || 1,
+            similarityThreshold: params?.similarityThreshold || 0.5,
+        });
+        const rawResults = data?.markets || [];
+        const allRawMarkets = [];
+        for (const res of rawResults) {
+            if (res.markets && Array.isArray(res.markets)) {
+                for (const child of res.markets) {
+                    allRawMarkets.push(child);
+                }
+            }
+            else {
+                allRawMarkets.push(res);
+            }
+        }
+        return allRawMarkets;
+    }
+    async fetchRawMarketsDefault(marketFetcher, params) {
+        const limit = params?.limit || 250000;
+        const offset = params?.offset || 0;
+        let sortBy = 'lp_rewards';
+        if (params?.sort === 'volume') {
+            sortBy = 'high_value';
+        }
+        try {
+            const totalToFetch = limit + offset;
+            return await (0, utils_1.paginateLimitlessMarkets)(marketFetcher, totalToFetch, sortBy);
+        }
+        catch (error) {
+            throw errors_1.limitlessErrorMapper.mapError(error);
+        }
+    }
+    async fetchRawEventBySlug(slug) {
+        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);
+        return market ? [market] : [];
+    }
+    async searchRawEvents(params) {
+        const data = await this.ctx.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;
+    }
+    async fetchRawEventsDefault(params) {
+        const limit = params?.limit || 10000;
+        let page = 1;
+        const pageSize = 25;
+        const MAX_PAGES = 40;
+        const allGroups = [];
+        while (allGroups.length < limit && page <= MAX_PAGES) {
+            const response = await this.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;
+                allGroups.push(item);
+            }
+            if (items.length < pageSize)
+                break;
+            page++;
+        }
+        return allGroups;
+    }
+}
+exports.LimitlessFetcher = LimitlessFetcher;

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

@@ -37,16 +37,21 @@ export declare class LimitlessExchange extends PredictionMarketExchange {
     private client?;
     private wsConfig?;
     private ws?;
+    private readonly fetcher;
+    private readonly normalizer;
     constructor(options?: ExchangeCredentials | LimitlessExchangeOptions);
     get name(): string;
+    private getHeaders;
+    protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
+    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
     fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
     fetchOrderBook(id: string): Promise<OrderBook>;
     fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
+    fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
     createOrder(params: CreateOrderParams): Promise<Order>;
     cancelOrder(orderId: string): Promise<Order>;
     fetchOrder(orderId: string): Promise<Order>;
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
-    fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
     fetchClosedOrders(params?: OrderHistoryParams): Promise<Order[]>;
     fetchAllOrders(params?: OrderHistoryParams): Promise<Order[]>;
     fetchPositions(address?: string): Promise<Position[]>;
@@ -128,17 +133,9 @@ export declare class LimitlessExchange extends PredictionMarketExchange {
     unwatchAddress(address: string): Promise<void>;
     close(): Promise<void>;
     protected mapImplicitApiError(error: any): any;
-    protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
-    protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
     private getAddressOnChainBalance;
     private ensureClient;
-    /**
-     * Ensure authentication is initialized before trading operations.
-     */
     private ensureAuth;
-    /**
-     * Initialize WebSocket with API key if available.
-     */
     private ensureWs;
     /**
      * Fetch a composite activity snapshot for a Base-chain address from the Limitless