pmxt-core 2.9.2 → 2.9.3

package/dist/exchanges/polymarket/fetchEvents.js

@@ -7,93 +7,129 @@ 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 {
-        if (!params.query) {
-            throw new Error("Query is required for Polymarket event search");
-        }
         const limit = params.limit || 10000;
-        const status = params.status || 'active';
-        const queryParams = {
-            q: params.query,
-            limit_per_type: 50,
-            sort: 'volume',
-            ascending: false
-        };
-        const fetchWithStatus = async (eventStatus) => {
-            const currentParams = { ...queryParams, events_status: eventStatus };
-            return (0, utils_1.paginateSearchParallel)(utils_1.GAMMA_SEARCH_URL, currentParams, limit * 10, http);
-        };
-        // Client-side filtering logic
-        // The API returns active events when querying for 'closed' status sometimes.
-        // We must strictly filter based on the event's `active` and `closed` properties.
-        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')
-            ]);
-            // Merge and de-duplicate by ID
-            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;
-            });
+        // 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);
         }
-        else if (status === 'active') {
-            const rawEvents = await fetchWithStatus('active');
-            events = rawEvents.filter(filterActive);
+        // Handle query-based search (uses the /public-search endpoint)
+        if (params.query) {
+            return await searchEvents(params, limit, http);
         }
-        else if (status === 'inactive' || status === 'closed') {
-            // Polymarket sometimes returns active events when querying for closed
-            // So we fetch 'closed' but strictly filter
-            const rawEvents = await fetchWithStatus('closed');
-            events = rawEvents.filter(filterClosed);
-        }
-        // Client-side filtering to ensure title matches (API does fuzzy search)
-        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; // 'both'
-        });
-        // Map events to UnifiedEvent
-        const unifiedEvents = filteredEvents.map((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,
-                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;
-        });
-        return unifiedEvents.slice(0, limit);
+        // 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/fetchOHLCV.d.ts

@@ -1,7 +1,7 @@
-import { HistoryFilterParams, OHLCVParams } from '../../BaseExchange';
+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 | HistoryFilterParams, callApi: (operationId: string, params?: Record<string, any>) => Promise<any>): Promise<PriceCandle[]>;
+export declare function fetchOHLCV(id: string, params: OHLCVParams, callApi: (operationId: string, params?: Record<string, any>) => Promise<any>): Promise<PriceCandle[]>;

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

@@ -1,5 +1,5 @@
-import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, OHLCVParams, TradesParams, ExchangeCredentials, EventFetchParams } from '../../BaseExchange';
-import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, Order, Position, Balance, CreateOrderParams } from '../../types';
+import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, OHLCVParams, TradesParams, ExchangeCredentials, EventFetchParams, MyTradesParams } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, UserTrade, Order, Position, Balance, CreateOrderParams, BuiltOrder } from '../../types';
 import { PolymarketWebSocketConfig } from './websocket';
 export type { PolymarketWebSocketConfig };
 export interface PolymarketExchangeOptions {
@@ -21,6 +21,11 @@ export declare class PolymarketExchange extends PredictionMarketExchange {
         fetchBalance: true;
         watchOrderBook: true;
         watchTrades: true;
+        fetchMyTrades: true;
+        fetchClosedOrders: false;
+        fetchAllOrders: false;
+        buildOrder: true;
+        submitOrder: true;
     };
     private auth?;
     private wsConfig?;
@@ -38,7 +43,7 @@ export declare class PolymarketExchange extends PredictionMarketExchange {
     protected mapImplicitApiError(error: any): any;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
-    fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams): Promise<PriceCandle[]>;
+    fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
     fetchOrderBook(id: string): Promise<OrderBook>;
     fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
     /**
@@ -46,15 +51,34 @@ export declare class PolymarketExchange extends PredictionMarketExchange {
      */
     private ensureAuth;
     /**
-     * Pre-warm the SDK's internal caches for a token by fetching tick size,
-     * fee rate, and neg-risk in parallel. Call this when you start watching
-     * a market so that subsequent createOrder calls hit only POST /order.
+     * Pre-warm the SDK's internal caches for a market outcome.
+     *
+     * Fetches tick size, fee rate, and neg-risk in parallel so that subsequent
+     * `createOrder` calls skip those lookups and hit only `POST /order`.
+     * Call this when you start watching a market.
+     *
+     * @param outcomeId - The CLOB Token ID for the outcome (use `outcome.outcomeId`)
+     *
+     * @example-ts Pre-warm before placing orders
+     * const markets = await exchange.fetchMarkets({ query: 'Trump' });
+     * const outcomeId = markets[0].outcomes[0].outcomeId;
+     * await exchange.preWarmMarket(outcomeId);
+     * // Subsequent createOrder calls are faster
+     *
+     * @example-python Pre-warm before placing orders
+     * markets = exchange.fetch_markets(query='Trump')
+     * outcome_id = markets[0].outcomes[0].outcome_id
+     * exchange.pre_warm_market(outcome_id)
+     * # Subsequent create_order calls are faster
      */
     preWarmMarket(outcomeId: string): Promise<void>;
+    buildOrder(params: CreateOrderParams): Promise<BuiltOrder>;
+    submitOrder(built: BuiltOrder): Promise<Order>;
     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[]>;
     fetchPositions(): Promise<Position[]>;
     fetchBalance(): Promise<Balance[]>;
     private ws?;

package/dist/exchanges/polymarket/index.js

@@ -33,6 +33,11 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchBalance: true,
         watchOrderBook: true,
         watchTrades: true,
+        fetchMyTrades: true,
+        fetchClosedOrders: false,
+        fetchAllOrders: false,
+        buildOrder: true,
+        submitOrder: true,
     };
     auth;
     wsConfig;
@@ -52,7 +57,18 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
             credentials = options;
         }
         super(credentials);
+        this.rateLimit = 200;
         this.wsConfig = wsConfig;
+        // Add browser-mimicking headers to help pass Cloudflare bot detection on the Gamma API.
+        // Origin/Referer make requests look like same-site CORS calls from the Polymarket frontend.
+        Object.assign(this.http.defaults.headers.common, {
+            'Accept': 'application/json, */*',
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Origin': 'https://polymarket.com',
+            'Referer': 'https://polymarket.com/',
+            'sec-fetch-mode': 'cors',
+            'sec-fetch-site': 'same-site',
+        });
         // Initialize auth if credentials are provided
         if (credentials?.privateKey) {
             this.auth = new auth_1.PolymarketAuth(credentials);
@@ -142,17 +158,20 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
                             markets.push(unified);
                     }
                 }
-                return {
+                const unifiedEvent = {
                     id: event.id || event.slug,
                     title: event.title,
                     description: event.description || '',
                     slug: event.slug,
                     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;
             });
         }
         return (0, fetchEvents_1.fetchEvents)(params, this.http);
@@ -185,9 +204,25 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
         return this.auth;
     }
     /**
-     * Pre-warm the SDK's internal caches for a token by fetching tick size,
-     * fee rate, and neg-risk in parallel. Call this when you start watching
-     * a market so that subsequent createOrder calls hit only POST /order.
+     * Pre-warm the SDK's internal caches for a market outcome.
+     *
+     * Fetches tick size, fee rate, and neg-risk in parallel so that subsequent
+     * `createOrder` calls skip those lookups and hit only `POST /order`.
+     * Call this when you start watching a market.
+     *
+     * @param outcomeId - The CLOB Token ID for the outcome (use `outcome.outcomeId`)
+     *
+     * @example-ts Pre-warm before placing orders
+     * const markets = await exchange.fetchMarkets({ query: 'Trump' });
+     * const outcomeId = markets[0].outcomes[0].outcomeId;
+     * await exchange.preWarmMarket(outcomeId);
+     * // Subsequent createOrder calls are faster
+     *
+     * @example-python Pre-warm before placing orders
+     * markets = exchange.fetch_markets(query='Trump')
+     * outcome_id = markets[0].outcomes[0].outcome_id
+     * exchange.pre_warm_market(outcome_id)
+     * # Subsequent create_order calls are faster
      */
     async preWarmMarket(outcomeId) {
         const auth = this.ensureAuth();
@@ -198,59 +233,71 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
             client.getNegRisk(outcomeId),
         ]);
     }
-    async createOrder(params) {
+    async buildOrder(params) {
         try {
             const auth = this.ensureAuth();
             const client = await auth.getClobClient();
-            // Map side to Polymarket enum
             const side = params.side.toUpperCase() === 'BUY' ? clob_client_1.Side.BUY : clob_client_1.Side.SELL;
-            // For limit orders, price is required
-            if (params.type === 'limit' && !params.price) {
-                throw new Error('Price is required for limit orders');
-            }
-            // For market orders, use max slippage: 0.99 for BUY (willing to pay up to 99%), 0.01 for SELL (willing to accept down to 1%)
             const price = params.price || (side === clob_client_1.Side.BUY ? 0.99 : 0.01);
-            // Use provided tickSize, or let the SDK resolve it from its own cache / API
             const tickSize = params.tickSize ? params.tickSize.toString() : undefined;
             const orderArgs = {
                 tokenID: params.outcomeId,
-                price: price,
-                side: side,
+                price,
+                side,
                 size: params.amount,
             };
-            if (params.fee !== undefined && params.fee !== null) {
+            if (params.fee != null)
                 orderArgs.feeRateBps = params.fee;
-            }
             const options = {};
-            if (tickSize) {
+            if (tickSize)
                 options.tickSize = tickSize;
-            }
-            if (params.negRisk !== undefined) {
+            if (params.negRisk !== undefined)
                 options.negRisk = params.negRisk;
-            }
-            const response = await client.createAndPostOrder(orderArgs, options);
+            const signedOrder = await client.createOrder(orderArgs, options);
+            return {
+                exchange: this.name,
+                params,
+                signedOrder: signedOrder,
+                raw: signedOrder,
+            };
+        }
+        catch (error) {
+            throw errors_1.polymarketErrorMapper.mapError(error);
+        }
+    }
+    async submitOrder(built) {
+        try {
+            const auth = this.ensureAuth();
+            const client = await auth.getClobClient();
+            const response = await client.postOrder(built.raw);
             if (!response || !response.success) {
-                throw new Error(`${response?.errorMsg || 'Order placement failed'} (Response: ${JSON.stringify(response)})`);
+                throw new Error(`${response?.errorMsg || 'Order submission failed'} (Response: ${JSON.stringify(response)})`);
             }
+            const side = built.params.side.toUpperCase() === 'BUY' ? clob_client_1.Side.BUY : clob_client_1.Side.SELL;
+            const price = built.params.price || (side === clob_client_1.Side.BUY ? 0.99 : 0.01);
             return {
                 id: response.orderID,
-                marketId: params.marketId,
-                outcomeId: params.outcomeId,
-                side: params.side,
-                type: params.type,
-                price: price,
-                amount: params.amount,
+                marketId: built.params.marketId,
+                outcomeId: built.params.outcomeId,
+                side: built.params.side,
+                type: built.params.type,
+                price,
+                amount: built.params.amount,
                 status: 'open',
                 filled: 0,
-                remaining: params.amount,
-                fee: params.fee,
-                timestamp: Date.now()
+                remaining: built.params.amount,
+                fee: built.params.fee,
+                timestamp: Date.now(),
             };
         }
         catch (error) {
             throw errors_1.polymarketErrorMapper.mapError(error);
         }
     }
+    async createOrder(params) {
+        const built = await this.buildOrder(params);
+        return this.submitOrder(built);
+    }
     async cancelOrder(orderId) {
         try {
             const auth = this.ensureAuth();
@@ -325,6 +372,29 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
             throw errors_1.polymarketErrorMapper.mapError(error);
         }
     }
+    async fetchMyTrades(params) {
+        const auth = this.ensureAuth();
+        const address = await auth.getEffectiveFunderAddress();
+        const queryParams = { user: address };
+        if (params?.marketId)
+            queryParams.market = params.marketId;
+        if (params?.limit)
+            queryParams.limit = params.limit;
+        if (params?.since)
+            queryParams.start = Math.floor(params.since.getTime() / 1000);
+        if (params?.until)
+            queryParams.end = Math.floor(params.until.getTime() / 1000);
+        const data = await this.callApi('getTrades', queryParams);
+        const trades = Array.isArray(data) ? data : (data.data || []);
+        return trades.map((t) => ({
+            id: t.id || t.transactionHash || String(t.timestamp),
+            timestamp: typeof t.timestamp === 'number' ? t.timestamp * 1000 : Date.now(),
+            price: parseFloat(t.price || '0'),
+            amount: parseFloat(t.size || t.amount || '0'),
+            side: t.side === 'BUY' ? 'buy' : t.side === 'SELL' ? 'sell' : 'unknown',
+            orderId: t.orderId,
+        }));
+    }
     async fetchPositions() {
         try {
             const auth = this.ensureAuth();

package/dist/exchanges/polymarket/utils.js

@@ -76,6 +76,7 @@ function mapMarketToUnified(event, market, options = {}) {
     const um = {
         id: market.id,
         marketId: market.id,
+        eventId: event.id || event.slug,
         title: market.question ? `${event.title} - ${market.question}` : event.title,
         description: market.description || event.description,
         outcomes: outcomes,

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

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-02-19T07:57:20.610Z
+ * Generated at: 2026-03-04T17:45:20.626Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const probableApiSpec: {

package/dist/exchanges/probable/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.probableApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/probable/probable.yaml
- * Generated at: 2026-02-19T07:57:20.610Z
+ * Generated at: 2026-03-04T17:45:20.626Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.probableApiSpec = {

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

@@ -1,5 +1,5 @@
-import { PredictionMarketExchange, MarketFetchParams, EventFetchParams, ExchangeCredentials, OHLCVParams, HistoryFilterParams, TradesParams } from '../../BaseExchange';
-import { UnifiedMarket, UnifiedEvent, OrderBook, PriceCandle, Trade, Order, Position, Balance, CreateOrderParams } from '../../types';
+import { PredictionMarketExchange, MarketFetchParams, EventFetchParams, ExchangeCredentials, OHLCVParams, HistoryFilterParams, TradesParams, MyTradesParams } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, OrderBook, PriceCandle, Trade, UserTrade, Order, Position, Balance, CreateOrderParams } from '../../types';
 import { ProbableWebSocketConfig } from './websocket';
 export declare class ProbableExchange extends PredictionMarketExchange {
     readonly has: {
@@ -16,6 +16,11 @@ export declare class ProbableExchange extends PredictionMarketExchange {
         fetchBalance: true;
         watchOrderBook: true;
         watchTrades: false;
+        fetchMyTrades: true;
+        fetchClosedOrders: false;
+        fetchAllOrders: false;
+        buildOrder: false;
+        submitOrder: false;
     };
     private auth?;
     private ws?;
@@ -26,10 +31,47 @@ export declare class ProbableExchange extends PredictionMarketExchange {
     private ensureAuth;
     protected fetchMarketsImpl(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
+    /**
+     * Fetch a single event by its numeric ID (Probable only).
+     *
+     * @param id - The numeric event ID
+     * @returns The UnifiedEvent, or null if not found
+     *
+     * @example-ts Get event by ID
+     * const event = await exchange.getEventById('42');
+     * if (event) {
+     *   console.log(event.title);
+     *   console.log(event.markets.length, 'markets');
+     * }
+     *
+     * @example-python Get event by ID
+     * event = exchange.get_event_by_id('42')
+     * if event:
+     *     print(event.title)
+     *     print(len(event.markets), 'markets')
+     */
     getEventById(id: string): Promise<UnifiedEvent | null>;
+    /**
+     * Fetch a single event by its URL slug (Probable only).
+     *
+     * @param slug - The event's URL slug (e.g. `"trump-2024-election"`)
+     * @returns The UnifiedEvent, or null if not found
+     *
+     * @example-ts Get event by slug
+     * const event = await exchange.getEventBySlug('trump-2024-election');
+     * if (event) {
+     *   console.log(event.title);
+     * }
+     *
+     * @example-python Get event by slug
+     * event = exchange.get_event_by_slug('trump-2024-election')
+     * if event:
+     *     print(event.title)
+     */
     getEventBySlug(slug: string): Promise<UnifiedEvent | null>;
     fetchOrderBook(id: string): Promise<OrderBook>;
-    fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams): Promise<PriceCandle[]>;
+    fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
+    fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
     createOrder(params: CreateOrderParams): Promise<Order>;
     /**
      * Cancel an order.