pmxt-core 2.10.0 → 2.12.0

package/dist/BaseExchange.d.ts

@@ -1,4 +1,4 @@
-import { UnifiedMarket, UnifiedEvent, PriceCandle, CandleInterval, OrderBook, Trade, Order, Position, Balance, CreateOrderParams } from './types';
+import { UnifiedMarket, UnifiedEvent, PriceCandle, CandleInterval, OrderBook, Trade, UserTrade, Order, Position, Balance, CreateOrderParams } from './types';
 import { ExecutionPriceResult } from './utils/math';
 import { AxiosInstance } from 'axios';
 export interface ApiEndpoint {
@@ -59,6 +59,21 @@ export interface TradesParams {
     end?: Date;
     limit?: number;
 }
+export interface MyTradesParams {
+    outcomeId?: string;
+    marketId?: string;
+    since?: Date;
+    until?: Date;
+    limit?: number;
+    cursor?: string;
+}
+export interface OrderHistoryParams {
+    marketId?: string;
+    since?: Date;
+    until?: Date;
+    limit?: number;
+    cursor?: string;
+}
 export type MarketFilterCriteria = {
     text?: string;
     searchIn?: ('title' | 'description' | 'category' | 'tags' | 'outcomes')[];
@@ -126,6 +141,9 @@ export interface ExchangeHas {
     fetchBalance: ExchangeCapability;
     watchOrderBook: ExchangeCapability;
     watchTrades: ExchangeCapability;
+    fetchMyTrades: ExchangeCapability;
+    fetchClosedOrders: ExchangeCapability;
+    fetchAllOrders: ExchangeCapability;
 }
 export interface ExchangeCredentials {
     apiKey?: string;
@@ -135,18 +153,39 @@ export interface ExchangeCredentials {
     signatureType?: number | string;
     funderAddress?: string;
 }
+export interface ExchangeOptions {
+    /**
+     * How long (ms) a market snapshot created by `fetchMarketsPaginated` remains valid
+     * before being discarded and re-fetched from the API on the next call.
+     * Defaults to 0 (no TTL — the snapshot is re-fetched on every initial call).
+     */
+    snapshotTTL?: number;
+}
+/** Shape returned by fetchMarketsPaginated */
+export interface PaginatedMarketsResult {
+    data: UnifiedMarket[];
+    total: number;
+    nextCursor?: string;
+}
 export declare abstract class PredictionMarketExchange {
     [key: string]: any;
     protected credentials?: ExchangeCredentials;
     verbose: boolean;
     http: AxiosInstance;
+    enableRateLimit: boolean;
+    private _rateLimit;
+    private _throttler;
+    private _snapshotTTL;
+    private _snapshot?;
+    get rateLimit(): number;
+    set rateLimit(value: number);
     markets: Record<string, UnifiedMarket>;
     marketsBySlug: Record<string, UnifiedMarket>;
     loadedMarkets: boolean;
     protected apiDescriptor?: ApiDescriptor;
     private apiDescriptors;
     readonly has: ExchangeHas;
-    constructor(credentials?: ExchangeCredentials);
+    constructor(credentials?: ExchangeCredentials, options?: ExchangeOptions);
     abstract get name(): string;
     /**
      * Load and cache all markets from the exchange into `this.markets` and `this.marketsBySlug`.
@@ -208,6 +247,25 @@ export declare abstract class PredictionMarketExchange {
      * markets = exchange.fetch_markets(slug='will-trump-win')
      */
     fetchMarkets(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
+    /**
+     * Fetch markets with cursor-based pagination backed by a stable in-memory snapshot.
+     *
+     * On the first call (or when no cursor is supplied), fetches all markets once and
+     * caches them. Subsequent calls with a cursor returned from a previous call slice
+     * directly from the cached snapshot — no additional API calls are made.
+     *
+     * The snapshot is invalidated after `snapshotTTL` ms (configured via `ExchangeOptions`
+     * in the constructor). A request using a cursor from an expired snapshot throws
+     * `'Cursor has expired'`.
+     *
+     * @param params.limit      - Page size (default: return all markets)
+     * @param params.cursor     - Opaque cursor returned by a previous call
+     * @returns PaginatedMarketsResult with data, total, and optional nextCursor
+     */
+    fetchMarketsPaginated(params?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<PaginatedMarketsResult>;
     /**
      * Fetch events with optional keyword search.
      * Events group related markets together (e.g., "Who will be Fed Chair?" contains multiple candidate markets).
@@ -445,6 +503,9 @@ export declare abstract class PredictionMarketExchange {
      * orders = exchange.fetch_open_orders('FED-25JAN')
      */
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
+    fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
+    fetchClosedOrders(params?: OrderHistoryParams): Promise<Order[]>;
+    fetchAllOrders(params?: OrderHistoryParams): Promise<Order[]>;
     /**
      * Fetch current user positions across all markets.
      *

package/dist/BaseExchange.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PredictionMarketExchange = void 0;
 const math_1 = require("./utils/math");
 const errors_1 = require("./errors");
+const throttler_1 = require("./utils/throttler");
 const axios_1 = __importDefault(require("axios"));
 // ----------------------------------------------------------------------------
 // Base Exchange Class
@@ -14,6 +15,23 @@ class PredictionMarketExchange {
     credentials;
     verbose = false;
     http;
+    enableRateLimit = true;
+    _rateLimit = 1000;
+    _throttler;
+    // Snapshot state for cursor-based pagination
+    _snapshotTTL;
+    _snapshot;
+    get rateLimit() {
+        return this._rateLimit;
+    }
+    set rateLimit(value) {
+        this._rateLimit = value;
+        this._throttler = new throttler_1.Throttler({
+            refillRate: 1 / value,
+            capacity: 1,
+            delay: 1,
+        });
+    }
     // Market Cache
     markets = {};
     marketsBySlug = {};
@@ -35,10 +53,26 @@ class PredictionMarketExchange {
         fetchBalance: false,
         watchOrderBook: false,
         watchTrades: false,
+        fetchMyTrades: false,
+        fetchClosedOrders: false,
+        fetchAllOrders: false,
     };
-    constructor(credentials) {
+    constructor(credentials, options) {
         this.credentials = credentials;
+        this._snapshotTTL = options?.snapshotTTL ?? 0;
         this.http = axios_1.default.create();
+        this._throttler = new throttler_1.Throttler({
+            refillRate: 1 / this._rateLimit,
+            capacity: 1,
+            delay: 1,
+        });
+        // Rate Limit Interceptor
+        this.http.interceptors.request.use(async (config) => {
+            if (this.enableRateLimit) {
+                await this._throttler.throttle();
+            }
+            return config;
+        });
         // Request Interceptor
         this.http.interceptors.request.use((config) => {
             if (this.verbose) {
@@ -150,6 +184,59 @@ class PredictionMarketExchange {
     async fetchMarkets(params) {
         return this.fetchMarketsImpl(params);
     }
+    /**
+     * Fetch markets with cursor-based pagination backed by a stable in-memory snapshot.
+     *
+     * On the first call (or when no cursor is supplied), fetches all markets once and
+     * caches them. Subsequent calls with a cursor returned from a previous call slice
+     * directly from the cached snapshot — no additional API calls are made.
+     *
+     * The snapshot is invalidated after `snapshotTTL` ms (configured via `ExchangeOptions`
+     * in the constructor). A request using a cursor from an expired snapshot throws
+     * `'Cursor has expired'`.
+     *
+     * @param params.limit      - Page size (default: return all markets)
+     * @param params.cursor     - Opaque cursor returned by a previous call
+     * @returns PaginatedMarketsResult with data, total, and optional nextCursor
+     */
+    async fetchMarketsPaginated(params) {
+        const limit = params?.limit;
+        const cursor = params?.cursor;
+        if (cursor) {
+            // Cursor encodes: snapshotId:offset
+            const sep = cursor.indexOf(':');
+            const snapshotId = cursor.substring(0, sep);
+            const offset = parseInt(cursor.substring(sep + 1), 10);
+            if (!this._snapshot ||
+                this._snapshot.id !== snapshotId ||
+                (this._snapshotTTL > 0 && Date.now() - this._snapshot.takenAt > this._snapshotTTL)) {
+                throw new Error('Cursor has expired');
+            }
+            const markets = this._snapshot.markets;
+            const slice = limit !== undefined ? markets.slice(offset, offset + limit) : markets.slice(offset);
+            const nextOffset = offset + slice.length;
+            const nextCursor = nextOffset < markets.length ? `${snapshotId}:${nextOffset}` : undefined;
+            return { data: slice, total: markets.length, nextCursor };
+        }
+        // No cursor — (re)fetch snapshot
+        if (!this._snapshot ||
+            this._snapshotTTL === 0 ||
+            Date.now() - this._snapshot.takenAt > this._snapshotTTL) {
+            const markets = await this.fetchMarketsImpl();
+            this._snapshot = {
+                markets,
+                takenAt: Date.now(),
+                id: Math.random().toString(36).slice(2),
+            };
+        }
+        const markets = this._snapshot.markets;
+        if (!limit) {
+            return { data: markets, total: markets.length, nextCursor: undefined };
+        }
+        const slice = markets.slice(0, limit);
+        const nextCursor = limit < markets.length ? `${this._snapshot.id}:${limit}` : undefined;
+        return { data: slice, total: markets.length, nextCursor };
+    }
     /**
      * Fetch events with optional keyword search.
      * Events group related markets together (e.g., "Who will be Fed Chair?" contains multiple candidate markets).
@@ -444,6 +531,15 @@ class PredictionMarketExchange {
     async fetchOpenOrders(marketId) {
         throw new Error("Method fetchOpenOrders not implemented.");
     }
+    async fetchMyTrades(params) {
+        throw new Error("Method fetchMyTrades not implemented.");
+    }
+    async fetchClosedOrders(params) {
+        throw new Error("Method fetchClosedOrders not implemented.");
+    }
+    async fetchAllOrders(params) {
+        throw new Error("Method fetchAllOrders not implemented.");
+    }
     /**
      * Fetch current user positions across all markets.
      *

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

@@ -19,6 +19,9 @@ export declare class BaoziExchange extends PredictionMarketExchange {
         fetchBalance: true;
         watchOrderBook: true;
         watchTrades: false;
+        fetchMyTrades: false;
+        fetchClosedOrders: false;
+        fetchAllOrders: false;
     };
     private auth?;
     private connection;

package/dist/exchanges/baozi/index.js

@@ -28,6 +28,9 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchBalance: true,
         watchOrderBook: true,
         watchTrades: false,
+        fetchMyTrades: false,
+        fetchClosedOrders: false,
+        fetchAllOrders: false,
     };
     auth;
     connection;
@@ -43,6 +46,7 @@ class BaoziExchange extends BaseExchange_1.PredictionMarketExchange {
             credentials = options;
         }
         super(credentials);
+        this.rateLimit = 500;
         rpcUrl = rpcUrl
             || process.env.BAOZI_RPC_URL
             || process.env.HELIUS_RPC_URL

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-02-19T11:56:56.608Z
+ * Generated at: 2026-02-22T14:48:41.786Z
  * 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-02-19T11:56:56.608Z
+ * Generated at: 2026-02-22T14:48:41.786Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.kalshiApiSpec = {

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

@@ -1,5 +1,5 @@
-import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, OHLCVParams, TradesParams, ExchangeCredentials, EventFetchParams } from '../../BaseExchange';
-import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, Balance, Order, Position, CreateOrderParams } from '../../types';
+import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, OHLCVParams, TradesParams, ExchangeCredentials, EventFetchParams, MyTradesParams, OrderHistoryParams } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, UserTrade, Balance, Order, Position, CreateOrderParams } from '../../types';
 import { KalshiWebSocketConfig } from './websocket';
 export type { KalshiWebSocketConfig };
 export interface KalshiExchangeOptions {
@@ -21,6 +21,9 @@ export declare class KalshiExchange extends PredictionMarketExchange {
         fetchBalance: true;
         watchOrderBook: true;
         watchTrades: true;
+        fetchMyTrades: true;
+        fetchClosedOrders: true;
+        fetchAllOrders: true;
     };
     private auth?;
     private wsConfig?;
@@ -39,7 +42,11 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     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(): Promise<Position[]>;
+    private mapKalshiOrder;
     private mapKalshiOrderStatus;
     private ws?;
     watchOrderBook(id: string, limit?: number): Promise<OrderBook>;

package/dist/exchanges/kalshi/index.js

@@ -27,6 +27,9 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchBalance: true,
         watchOrderBook: true,
         watchTrades: true,
+        fetchMyTrades: true,
+        fetchClosedOrders: true,
+        fetchAllOrders: true,
     };
     auth;
     wsConfig;
@@ -44,6 +47,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             credentials = options;
         }
         super(credentials);
+        this.rateLimit = 100;
         this.wsConfig = wsConfig;
         if (credentials?.apiKey && credentials?.privateKey) {
             this.auth = new auth_1.KalshiAuth(credentials);
@@ -205,20 +209,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
     }
     async fetchOrder(orderId) {
         const data = await this.callApi('GetOrder', { order_id: orderId });
-        const order = data.order;
-        return {
-            id: order.order_id,
-            marketId: order.ticker,
-            outcomeId: order.ticker,
-            side: order.side === 'yes' ? 'buy' : 'sell',
-            type: order.type === 'limit' ? 'limit' : 'market',
-            price: order.yes_price ? order.yes_price / 100 : undefined,
-            amount: order.count,
-            status: this.mapKalshiOrderStatus(order.status),
-            filled: order.count - (order.remaining_count || 0),
-            remaining: order.remaining_count || 0,
-            timestamp: new Date(order.created_time).getTime(),
-        };
+        return this.mapKalshiOrder(data.order);
     }
     async fetchOpenOrders(marketId) {
         const queryParams = { status: 'resting' };
@@ -227,20 +218,70 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         const data = await this.callApi('GetOrders', queryParams);
         const orders = data.orders || [];
-        return orders.map((order) => ({
-            id: order.order_id,
-            marketId: order.ticker,
-            outcomeId: order.ticker,
-            side: order.side === 'yes' ? 'buy' : 'sell',
-            type: order.type === 'limit' ? 'limit' : 'market',
-            price: order.yes_price ? order.yes_price / 100 : undefined,
-            amount: order.count,
-            status: 'open',
-            filled: order.count - (order.remaining_count || 0),
-            remaining: order.remaining_count || 0,
-            timestamp: new Date(order.created_time).getTime(),
+        return orders.map((order) => this.mapKalshiOrder(order));
+    }
+    async fetchMyTrades(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.callApi('GetFills', queryParams);
+        return (data.fills || []).map((f) => ({
+            id: f.fill_id,
+            timestamp: new Date(f.created_time).getTime(),
+            price: f.yes_price / 100,
+            amount: f.count,
+            side: f.side === 'yes' ? 'buy' : 'sell',
+            orderId: f.order_id,
         }));
     }
+    async fetchClosedOrders(params) {
+        const queryParams = {};
+        if (params?.marketId)
+            queryParams.ticker = params.marketId;
+        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.callApi('GetHistoricalOrders', queryParams);
+        return (data.orders || []).map((o) => this.mapKalshiOrder(o));
+    }
+    async fetchAllOrders(params) {
+        const queryParams = {};
+        if (params?.marketId)
+            queryParams.ticker = params.marketId;
+        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;
+        const historicalParams = { ...queryParams };
+        delete historicalParams.min_ts; // GetHistoricalOrders only supports max_ts
+        const [liveData, historicalData] = await Promise.all([
+            this.callApi('GetOrders', queryParams),
+            this.callApi('GetHistoricalOrders', historicalParams),
+        ]);
+        const seen = new Set();
+        const all = [];
+        for (const o of [...(liveData.orders || []), ...(historicalData.orders || [])]) {
+            if (!seen.has(o.order_id)) {
+                seen.add(o.order_id);
+                all.push(this.mapKalshiOrder(o));
+            }
+        }
+        return all.sort((a, b) => b.timestamp - a.timestamp);
+    }
     async fetchPositions() {
         const data = await this.callApi('GetPositions');
         const positions = data.market_positions || [];
@@ -259,9 +300,25 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             };
         });
     }
+    // Helper to map a raw Kalshi order object to a unified Order
+    mapKalshiOrder(order) {
+        return {
+            id: order.order_id,
+            marketId: order.ticker,
+            outcomeId: order.ticker,
+            side: order.side === 'yes' ? 'buy' : 'sell',
+            type: order.type === 'limit' ? 'limit' : 'market',
+            price: order.yes_price ? order.yes_price / 100 : undefined,
+            amount: order.count,
+            status: this.mapKalshiOrderStatus(order.status),
+            filled: order.count - (order.remaining_count || 0),
+            remaining: order.remaining_count || 0,
+            timestamp: new Date(order.created_time).getTime(),
+        };
+    }
     // Helper to map Kalshi order status to unified status
     mapKalshiOrderStatus(status) {
-        switch (status.toLowerCase()) {
+        switch ((status ?? '').toLowerCase()) {
             case 'resting':
                 return 'open';
             case 'canceled':

package/dist/exchanges/kalshi/kalshi.test.js

@@ -318,6 +318,186 @@ describe('KalshiExchange', () => {
             });
         });
     });
+    describe('Trading History Methods', () => {
+        beforeEach(() => {
+            exchange = new kalshi_1.KalshiExchange(mockCredentials);
+        });
+        describe('fetchMyTrades', () => {
+            it('should map GetFills response to UserTrade array', async () => {
+                const mockResponse = {
+                    data: {
+                        fills: [
+                            {
+                                fill_id: 'fill-abc',
+                                order_id: 'order-123',
+                                created_time: '2026-01-13T12:00:00Z',
+                                yes_price: 55,
+                                count: 10,
+                                side: 'yes',
+                            },
+                            {
+                                fill_id: 'fill-def',
+                                order_id: 'order-456',
+                                created_time: '2026-01-13T13:00:00Z',
+                                yes_price: 45,
+                                count: 5,
+                                side: 'no',
+                            },
+                        ],
+                    },
+                };
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
+                const trades = await exchange.fetchMyTrades();
+                expect(Array.isArray(trades)).toBe(true);
+                expect(trades).toHaveLength(2);
+                expect(trades[0].id).toBe('fill-abc');
+                expect(trades[0].orderId).toBe('order-123');
+                expect(trades[0].price).toBe(0.55); // 55 / 100
+                expect(trades[0].amount).toBe(10);
+                expect(trades[0].side).toBe('buy'); // 'yes' => 'buy'
+                expect(trades[1].id).toBe('fill-def');
+                expect(trades[1].side).toBe('sell'); // 'no' => 'sell'
+                expect(trades[1].price).toBe(0.45); // 45 / 100
+            });
+            it('should pass outcomeId as ticker (stripping -NO suffix) and date params', async () => {
+                const mockResponse = { data: { fills: [] } };
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
+                await exchange.fetchMyTrades({
+                    outcomeId: 'TEST-MARKET-NO',
+                    since: new Date('2026-01-01T00:00:00Z'),
+                    until: new Date('2026-01-31T00:00:00Z'),
+                    limit: 50,
+                });
+                expect(mockAxiosInstance.request).toHaveBeenCalledWith(expect.objectContaining({
+                    params: expect.objectContaining({
+                        ticker: 'TEST-MARKET', // -NO stripped
+                        min_ts: Math.floor(new Date('2026-01-01T00:00:00Z').getTime() / 1000),
+                        max_ts: Math.floor(new Date('2026-01-31T00:00:00Z').getTime() / 1000),
+                        limit: 50,
+                    }),
+                }));
+            });
+            it('should return empty array when fills is missing', async () => {
+                mockAxiosInstance.request.mockResolvedValue({ data: {} });
+                const trades = await exchange.fetchMyTrades();
+                expect(trades).toHaveLength(0);
+            });
+        });
+        describe('fetchClosedOrders', () => {
+            it('should map GetHistoricalOrders response to Order array', async () => {
+                const mockResponse = {
+                    data: {
+                        orders: [
+                            {
+                                order_id: 'hist-order-1',
+                                ticker: 'TEST-MARKET',
+                                side: 'yes',
+                                type: 'limit',
+                                yes_price: 60,
+                                count: 8,
+                                remaining_count: 0,
+                                status: 'executed',
+                                created_time: '2026-01-10T10:00:00Z',
+                            },
+                        ],
+                    },
+                };
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
+                const orders = await exchange.fetchClosedOrders();
+                expect(orders).toHaveLength(1);
+                expect(orders[0].id).toBe('hist-order-1');
+                expect(orders[0].marketId).toBe('TEST-MARKET');
+                expect(orders[0].side).toBe('buy'); // 'yes' => 'buy'
+                expect(orders[0].price).toBe(0.60); // 60 / 100
+                expect(orders[0].amount).toBe(8);
+                expect(orders[0].filled).toBe(8); // count - remaining_count (0)
+                expect(orders[0].remaining).toBe(0);
+                expect(orders[0].status).toBe('filled'); // 'executed' => 'filled'
+            });
+            it('should pass marketId as ticker and limit', async () => {
+                const mockResponse = { data: { orders: [] } };
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
+                await exchange.fetchClosedOrders({ marketId: 'TEST-MARKET', limit: 25 });
+                expect(mockAxiosInstance.request).toHaveBeenCalledWith(expect.objectContaining({
+                    params: expect.objectContaining({
+                        ticker: 'TEST-MARKET',
+                        limit: 25,
+                    }),
+                }));
+            });
+        });
+        describe('fetchAllOrders', () => {
+            it('should merge live and historical orders, dedup, and sort descending by timestamp', async () => {
+                const liveResponse = {
+                    data: {
+                        orders: [
+                            {
+                                order_id: 'order-live-1',
+                                ticker: 'TEST',
+                                side: 'yes',
+                                type: 'limit',
+                                yes_price: 50,
+                                count: 5,
+                                remaining_count: 5,
+                                status: 'resting',
+                                created_time: '2026-01-15T10:00:00Z',
+                            },
+                            {
+                                // duplicate that also appears in historical
+                                order_id: 'order-hist-1',
+                                ticker: 'TEST',
+                                side: 'no',
+                                type: 'limit',
+                                yes_price: 40,
+                                count: 3,
+                                remaining_count: 0,
+                                status: 'executed',
+                                created_time: '2026-01-10T08:00:00Z',
+                            },
+                        ],
+                    },
+                };
+                const historicalResponse = {
+                    data: {
+                        orders: [
+                            {
+                                order_id: 'order-hist-1', // duplicate
+                                ticker: 'TEST',
+                                side: 'no',
+                                type: 'limit',
+                                yes_price: 40,
+                                count: 3,
+                                remaining_count: 0,
+                                status: 'executed',
+                                created_time: '2026-01-10T08:00:00Z',
+                            },
+                            {
+                                order_id: 'order-hist-2',
+                                ticker: 'TEST',
+                                side: 'yes',
+                                type: 'limit',
+                                yes_price: 55,
+                                count: 10,
+                                remaining_count: 0,
+                                status: 'executed',
+                                created_time: '2026-01-05T06:00:00Z',
+                            },
+                        ],
+                    },
+                };
+                mockAxiosInstance.request
+                    .mockResolvedValueOnce(liveResponse)
+                    .mockResolvedValueOnce(historicalResponse);
+                const orders = await exchange.fetchAllOrders();
+                // 3 unique orders (order-hist-1 deduped)
+                expect(orders).toHaveLength(3);
+                // sorted descending: order-live-1, order-hist-1, order-hist-2
+                expect(orders[0].id).toBe('order-live-1');
+                expect(orders[1].id).toBe('order-hist-1');
+                expect(orders[2].id).toBe('order-hist-2');
+            });
+        });
+    }); // Trading History Methods
     describe('Order Status Mapping', () => {
         beforeEach(() => {
             exchange = new kalshi_1.KalshiExchange(mockCredentials);

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-02-19T11:56:56.657Z
+ * Generated at: 2026-02-22T14:48:41.831Z
  * 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-02-19T11:56:56.657Z
+ * Generated at: 2026-02-22T14:48:41.831Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.limitlessApiSpec = {

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

@@ -1,5 +1,5 @@
-import { PredictionMarketExchange, MarketFetchParams, HistoryFilterParams, OHLCVParams, TradesParams, ExchangeCredentials, EventFetchParams } from '../../BaseExchange';
-import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, Order, Position, Balance, CreateOrderParams } from '../../types';
+import { PredictionMarketExchange, MarketFetchParams, HistoryFilterParams, OHLCVParams, TradesParams, ExchangeCredentials, EventFetchParams, MyTradesParams, OrderHistoryParams } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, UserTrade, Order, Position, Balance, CreateOrderParams } from '../../types';
 import { LimitlessWebSocketConfig } from './websocket';
 export type { LimitlessWebSocketConfig };
 export interface LimitlessExchangeOptions {
@@ -21,6 +21,9 @@ export declare class LimitlessExchange extends PredictionMarketExchange {
         fetchBalance: true;
         watchOrderBook: true;
         watchTrades: true;
+        fetchMyTrades: true;
+        fetchClosedOrders: true;
+        fetchAllOrders: true;
     };
     private auth?;
     private client?;
@@ -42,6 +45,9 @@ export declare class LimitlessExchange extends PredictionMarketExchange {
     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(): Promise<Position[]>;
     fetchBalance(): Promise<Balance[]>;
     private ws?;

package/dist/exchanges/limitless/index.js

@@ -31,6 +31,9 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchBalance: true,
         watchOrderBook: true,
         watchTrades: true,
+        fetchMyTrades: true,
+        fetchClosedOrders: true,
+        fetchAllOrders: true,
     };
     auth;
     client;
@@ -53,6 +56,7 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             credentials = options;
         }
         super(credentials);
+        this.rateLimit = 200;
         this.wsConfig = wsConfig;
         // Initialize auth if API key or private key are provided
         // API key is now the primary authentication method
@@ -225,6 +229,68 @@ class LimitlessExchange extends BaseExchange_1.PredictionMarketExchange {
             throw errors_1.limitlessErrorMapper.mapError(error);
         }
     }
+    async fetchMyTrades(params) {
+        const auth = this.ensureAuth();
+        try {
+            const response = await this.http.get('https://api.limitless.exchange/portfolio/trades', {
+                headers: { Authorization: `Bearer ${auth.getApiKey()}` },
+            });
+            const trades = Array.isArray(response.data) ? response.data : (response.data?.data || []);
+            return trades.map((t) => ({
+                id: t.id || String(t.timestamp),
+                timestamp: t.createdAt ? new Date(t.createdAt).getTime() : (t.timestamp || 0),
+                price: parseFloat(t.price || '0'),
+                amount: parseFloat(t.quantity || t.amount || '0'),
+                side: (t.side || '').toLowerCase() === 'buy' ? 'buy' : 'sell',
+                orderId: t.orderId,
+            }));
+        }
+        catch (error) {
+            throw errors_1.limitlessErrorMapper.mapError(error);
+        }
+    }
+    async fetchClosedOrders(params) {
+        const client = this.ensureClient();
+        if (!params?.marketId) {
+            console.warn('Limitless: fetchClosedOrders requires marketId (slug). Returning [].');
+            return [];
+        }
+        const orders = await client.getOrders(params.marketId, ['MATCHED']);
+        return orders.map((o) => ({
+            id: o.id,
+            marketId: params.marketId,
+            outcomeId: o.tokenId || 'unknown',
+            side: o.side.toLowerCase(),
+            type: 'limit',
+            price: parseFloat(o.price),
+            amount: parseFloat(o.quantity),
+            status: 'filled',
+            filled: parseFloat(o.quantity),
+            remaining: 0,
+            timestamp: o.createdAt ? new Date(o.createdAt).getTime() : Date.now(),
+        }));
+    }
+    async fetchAllOrders(params) {
+        const client = this.ensureClient();
+        if (!params?.marketId) {
+            console.warn('Limitless: fetchAllOrders requires marketId (slug). Returning [].');
+            return [];
+        }
+        const orders = await client.getOrders(params.marketId, ['LIVE', 'MATCHED']);
+        return orders.map((o) => ({
+            id: o.id,
+            marketId: params.marketId,
+            outcomeId: o.tokenId || 'unknown',
+            side: o.side.toLowerCase(),
+            type: 'limit',
+            price: parseFloat(o.price),
+            amount: parseFloat(o.quantity),
+            status: o.status === 'LIVE' ? 'open' : 'filled',
+            filled: o.status === 'MATCHED' ? parseFloat(o.quantity) : 0,
+            remaining: o.status === 'LIVE' ? parseFloat(o.quantity) : 0,
+            timestamp: o.createdAt ? new Date(o.createdAt).getTime() : Date.now(),
+        }));
+    }
     async fetchPositions() {
         const auth = this.ensureAuth();
         const address = auth.getAddress();

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

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/myriad/myriad.yaml
- * Generated at: 2026-02-19T11:56:56.675Z
+ * Generated at: 2026-02-22T14:48:41.842Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const myriadApiSpec: {

package/dist/exchanges/myriad/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.myriadApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/myriad/myriad.yaml
- * Generated at: 2026-02-19T11:56:56.675Z
+ * Generated at: 2026-02-22T14:48:41.842Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.myriadApiSpec = {

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

@@ -1,5 +1,5 @@
-import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, OHLCVParams, TradesParams, ExchangeCredentials, EventFetchParams } from '../../BaseExchange';
-import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, Balance, Order, Position, CreateOrderParams } from '../../types';
+import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, OHLCVParams, TradesParams, ExchangeCredentials, EventFetchParams, MyTradesParams } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, UserTrade, Balance, Order, Position, CreateOrderParams } from '../../types';
 export declare class MyriadExchange extends PredictionMarketExchange {
     readonly has: {
         fetchMarkets: true;
@@ -15,6 +15,9 @@ export declare class MyriadExchange extends PredictionMarketExchange {
         fetchBalance: "emulated";
         watchOrderBook: "emulated";
         watchTrades: "emulated";
+        fetchMyTrades: true;
+        fetchClosedOrders: false;
+        fetchAllOrders: false;
     };
     private auth?;
     private ws?;
@@ -29,6 +32,7 @@ export declare class MyriadExchange extends PredictionMarketExchange {
     fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams): 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>;

package/dist/exchanges/myriad/index.js

@@ -28,11 +28,15 @@ class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchBalance: 'emulated',
         watchOrderBook: 'emulated',
         watchTrades: 'emulated',
+        fetchMyTrades: true,
+        fetchClosedOrders: false,
+        fetchAllOrders: false,
     };
     auth;
     ws;
     constructor(credentials) {
         super(credentials);
+        this.rateLimit = 500;
         if (credentials?.apiKey) {
             this.auth = new auth_1.MyriadAuth(credentials);
         }
@@ -118,6 +122,34 @@ class MyriadExchange extends BaseExchange_1.PredictionMarketExchange {
             side: t.action === 'buy' ? 'buy' : 'sell',
         }));
     }
+    async fetchMyTrades(params) {
+        const walletAddress = this.ensureAuth().walletAddress;
+        if (!walletAddress) {
+            throw new errors_2.AuthenticationError('fetchMyTrades requires a wallet address. Pass privateKey as the wallet address in credentials.', 'Myriad');
+        }
+        const queryParams = { address: walletAddress };
+        if (params?.marketId) {
+            const parts = params.marketId.split(':');
+            if (parts.length >= 2)
+                queryParams.market_id = parts[1];
+        }
+        if (params?.since)
+            queryParams.since = Math.floor(params.since.getTime() / 1000);
+        if (params?.until)
+            queryParams.until = Math.floor(params.until.getTime() / 1000);
+        if (params?.limit)
+            queryParams.limit = params.limit;
+        const data = await this.callApi('getUsersEvents', queryParams);
+        const events = data.data || data.events || [];
+        const tradeEvents = events.filter((e) => e.action === 'buy' || e.action === 'sell');
+        return tradeEvents.map((t, i) => ({
+            id: `${t.blockNumber || t.timestamp}-${i}`,
+            timestamp: (t.timestamp || 0) * 1000,
+            price: t.shares > 0 ? Number(t.value) / Number(t.shares) : 0,
+            amount: Number(t.shares || 0),
+            side: t.action === 'buy' ? 'buy' : 'sell',
+        }));
+    }
     // ------------------------------------------------------------------------
     // Trading
     // ------------------------------------------------------------------------

package/dist/exchanges/polymarket/api-clob.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-02-19T11:56:56.616Z
+ * Generated at: 2026-02-22T14:48:41.794Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketClobSpec: {

package/dist/exchanges/polymarket/api-clob.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketClobSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketClobAPI.yaml
- * Generated at: 2026-02-19T11:56:56.616Z
+ * Generated at: 2026-02-22T14:48:41.794Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketClobSpec = {

package/dist/exchanges/polymarket/api-data.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-02-19T11:56:56.634Z
+ * Generated at: 2026-02-22T14:48:41.812Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketDataSpec: {

package/dist/exchanges/polymarket/api-data.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketDataSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/Polymarket_Data_API.yaml
- * Generated at: 2026-02-19T11:56:56.634Z
+ * Generated at: 2026-02-22T14:48:41.812Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketDataSpec = {

package/dist/exchanges/polymarket/api-gamma.d.ts

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-02-19T11:56:56.631Z
+ * Generated at: 2026-02-22T14:48:41.808Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const polymarketGammaSpec: {

package/dist/exchanges/polymarket/api-gamma.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.polymarketGammaSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/polymarket/PolymarketGammaAPI.yaml
- * Generated at: 2026-02-19T11:56:56.631Z
+ * Generated at: 2026-02-22T14:48:41.808Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.polymarketGammaSpec = {

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 } from '../../types';
 import { PolymarketWebSocketConfig } from './websocket';
 export type { PolymarketWebSocketConfig };
 export interface PolymarketExchangeOptions {
@@ -21,6 +21,9 @@ export declare class PolymarketExchange extends PredictionMarketExchange {
         fetchBalance: true;
         watchOrderBook: true;
         watchTrades: true;
+        fetchMyTrades: true;
+        fetchClosedOrders: false;
+        fetchAllOrders: false;
     };
     private auth?;
     private wsConfig?;
@@ -71,6 +74,7 @@ export declare class PolymarketExchange extends PredictionMarketExchange {
     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,9 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchBalance: true,
         watchOrderBook: true,
         watchTrades: true,
+        fetchMyTrades: true,
+        fetchClosedOrders: false,
+        fetchAllOrders: false,
     };
     auth;
     wsConfig;
@@ -52,6 +55,7 @@ class PolymarketExchange extends BaseExchange_1.PredictionMarketExchange {
             credentials = options;
         }
         super(credentials);
+        this.rateLimit = 200;
         this.wsConfig = wsConfig;
         // Initialize auth if credentials are provided
         if (credentials?.privateKey) {
@@ -341,6 +345,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/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-19T11:56:56.667Z
+ * Generated at: 2026-02-22T14:48:41.835Z
  * 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-19T11:56:56.667Z
+ * Generated at: 2026-02-22T14:48:41.835Z
  * 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,9 @@ export declare class ProbableExchange extends PredictionMarketExchange {
         fetchBalance: true;
         watchOrderBook: true;
         watchTrades: false;
+        fetchMyTrades: true;
+        fetchClosedOrders: false;
+        fetchAllOrders: false;
     };
     private auth?;
     private ws?;
@@ -66,6 +69,7 @@ export declare class ProbableExchange extends PredictionMarketExchange {
     getEventBySlug(slug: string): Promise<UnifiedEvent | null>;
     fetchOrderBook(id: string): Promise<OrderBook>;
     fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams): Promise<PriceCandle[]>;
+    fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
     createOrder(params: CreateOrderParams): Promise<Order>;
     /**
      * Cancel an order.

package/dist/exchanges/probable/index.js

@@ -47,12 +47,16 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchBalance: true,
         watchOrderBook: true,
         watchTrades: false,
+        fetchMyTrades: true,
+        fetchClosedOrders: false,
+        fetchAllOrders: false,
     };
     auth;
     ws;
     wsConfig;
     constructor(credentials, wsConfig) {
         super(credentials);
+        this.rateLimit = 500;
         this.wsConfig = wsConfig;
         if (credentials?.privateKey && credentials?.apiKey && credentials?.apiSecret && credentials?.passphrase) {
             this.auth = new auth_1.ProbableAuth(credentials);
@@ -178,6 +182,25 @@ class ProbableExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         return candles;
     }
+    async fetchMyTrades(params) {
+        const auth = this.ensureAuth();
+        const address = auth.getAddress();
+        const queryParams = { user: address };
+        if (params?.limit)
+            queryParams.limit = params.limit;
+        const data = await this.callApi('getPublicApiV1Trades', queryParams);
+        const trades = Array.isArray(data) ? data : (data.data || []);
+        return trades.map((t) => ({
+            id: String(t.tradeId || t.id || t.timestamp),
+            timestamp: typeof t.time === 'number'
+                ? (t.time > 1e12 ? t.time : t.time * 1000)
+                : Date.now(),
+            price: parseFloat(t.price || '0'),
+            amount: parseFloat(t.qty || t.size || t.amount || '0'),
+            side: (t.side || '').toLowerCase() === 'buy' ? 'buy' : 'sell',
+            orderId: t.orderId,
+        }));
+    }
     // --------------------------------------------------------------------------
     // Trading Methods
     // --------------------------------------------------------------------------

package/dist/types.d.ts

@@ -66,6 +66,9 @@ export interface Trade {
     amount: number;
     side: 'buy' | 'sell' | 'unknown';
 }
+export interface UserTrade extends Trade {
+    orderId?: string;
+}
 export interface Order {
     id: string;
     marketId: string;

package/dist/utils/throttler.d.ts

@@ -0,0 +1,17 @@
+export declare class Throttler {
+    private tokens;
+    private queue;
+    private running;
+    private lastTimestamp;
+    private refillRate;
+    private capacity;
+    private delay;
+    constructor(config: {
+        refillRate: number;
+        capacity: number;
+        delay: number;
+    });
+    throttle(cost?: number): Promise<void>;
+    private loop;
+    private sleep;
+}

package/dist/utils/throttler.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Throttler = void 0;
+class Throttler {
+    tokens = 0;
+    queue = [];
+    running = false;
+    lastTimestamp = 0;
+    refillRate;
+    capacity;
+    delay;
+    constructor(config) {
+        this.refillRate = config.refillRate;
+        this.capacity = config.capacity;
+        this.delay = config.delay;
+    }
+    async throttle(cost = 1) {
+        return new Promise((resolve) => {
+            this.queue.push({ resolve, cost });
+            if (!this.running) {
+                this.running = true;
+                this.loop();
+            }
+        });
+    }
+    async loop() {
+        while (this.queue.length > 0) {
+            const now = Date.now();
+            if (this.lastTimestamp > 0) {
+                const elapsed = now - this.lastTimestamp;
+                this.tokens = Math.min(this.tokens + elapsed * this.refillRate, this.capacity);
+            }
+            this.lastTimestamp = now;
+            const head = this.queue[0];
+            if (this.tokens >= 0) {
+                this.tokens -= head.cost;
+                head.resolve();
+                this.queue.shift();
+            }
+            else {
+                await this.sleep(this.delay);
+            }
+        }
+        this.running = false;
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.Throttler = Throttler;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmxt-core",
-  "version": "2.10.0",
+  "version": "2.12.0",
   "description": "pmxt is a unified prediction market data API. The ccxt for prediction markets.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,8 +29,8 @@
     "test": "jest -c jest.config.js",
     "server": "tsx watch src/server/index.ts",
     "server:prod": "node dist/server/index.js",
-    "generate:sdk:python": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g python -o ../sdks/python/generated --package-name pmxt_internal --additional-properties=projectName=pmxt-internal,packageVersion=2.10.0,library=urllib3",
-    "generate:sdk:typescript": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g typescript-fetch -o ../sdks/typescript/generated --additional-properties=npmName=pmxtjs,npmVersion=2.10.0,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.js",
+    "generate:sdk:python": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g python -o ../sdks/python/generated --package-name pmxt_internal --additional-properties=projectName=pmxt-internal,packageVersion=2.12.0,library=urllib3",
+    "generate:sdk:typescript": "npx @openapitools/openapi-generator-cli generate -i src/server/openapi.yaml -g typescript-fetch -o ../sdks/typescript/generated --additional-properties=npmName=pmxtjs,npmVersion=2.12.0,supportsES6=true,typescriptThreePlus=true && node ../sdks/typescript/scripts/fix-generated.js",
     "fetch:openapi": "node scripts/fetch-openapi-specs.js",
     "extract:jsdoc": "node ../scripts/extract-jsdoc.js",
     "generate:docs": "npm run extract:jsdoc && node ../scripts/generate-api-docs.js",