pmxtjs 2.1.2 → 2.2.0

package/pmxt/client.js

@@ -0,0 +1,957 @@
+"use strict";
+/**
+ * Exchange client implementations.
+ *
+ * This module provides clean, TypeScript-friendly wrappers around the auto-generated
+ * OpenAPI client, matching the Python API exactly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Limitless = exports.Kalshi = exports.Polymarket = exports.Exchange = void 0;
+const index_js_1 = require("../generated/src/index.js");
+const models_js_1 = require("./models.js");
+const server_manager_js_1 = require("./server-manager.js");
+// Converter functions
+function convertMarket(raw) {
+    const outcomes = (raw.outcomes || []).map((o) => ({
+        outcomeId: o.outcomeId,
+        label: o.label,
+        price: o.price,
+        priceChange24h: o.priceChange24h,
+        metadata: o.metadata,
+    }));
+    const convertOutcome = (o) => o ? ({
+        outcomeId: o.outcomeId,
+        label: o.label,
+        price: o.price,
+        priceChange24h: o.priceChange24h,
+        metadata: o.metadata,
+    }) : undefined;
+    return {
+        marketId: raw.marketId,
+        title: raw.title,
+        outcomes,
+        volume24h: raw.volume24h || 0,
+        liquidity: raw.liquidity || 0,
+        url: raw.url,
+        description: raw.description,
+        resolutionDate: raw.resolutionDate ? new Date(raw.resolutionDate) : undefined,
+        volume: raw.volume,
+        openInterest: raw.openInterest,
+        image: raw.image,
+        category: raw.category,
+        tags: raw.tags,
+        yes: convertOutcome(raw.yes),
+        no: convertOutcome(raw.no),
+        up: convertOutcome(raw.up),
+        down: convertOutcome(raw.down),
+    };
+}
+function convertCandle(raw) {
+    return {
+        timestamp: raw.timestamp,
+        open: raw.open,
+        high: raw.high,
+        low: raw.low,
+        close: raw.close,
+        volume: raw.volume,
+    };
+}
+function convertOrderBook(raw) {
+    const bids = (raw.bids || []).map((b) => ({
+        price: b.price,
+        size: b.size,
+    }));
+    const asks = (raw.asks || []).map((a) => ({
+        price: a.price,
+        size: a.size,
+    }));
+    return {
+        bids,
+        asks,
+        timestamp: raw.timestamp,
+    };
+}
+function convertTrade(raw) {
+    return {
+        id: raw.id,
+        timestamp: raw.timestamp,
+        price: raw.price,
+        amount: raw.amount,
+        side: raw.side || "unknown",
+    };
+}
+function convertOrder(raw) {
+    return {
+        id: raw.id,
+        marketId: raw.marketId,
+        outcomeId: raw.outcomeId,
+        side: raw.side,
+        type: raw.type,
+        amount: raw.amount,
+        status: raw.status,
+        filled: raw.filled,
+        remaining: raw.remaining,
+        timestamp: raw.timestamp,
+        price: raw.price,
+        fee: raw.fee,
+    };
+}
+function convertPosition(raw) {
+    return {
+        marketId: raw.marketId,
+        outcomeId: raw.outcomeId,
+        outcomeLabel: raw.outcomeLabel,
+        size: raw.size,
+        entryPrice: raw.entryPrice,
+        currentPrice: raw.currentPrice,
+        unrealizedPnL: raw.unrealizedPnL,
+        realizedPnL: raw.realizedPnL,
+    };
+}
+function convertBalance(raw) {
+    return {
+        currency: raw.currency,
+        total: raw.total,
+        available: raw.available,
+        locked: raw.locked,
+    };
+}
+function convertEvent(raw) {
+    const markets = models_js_1.MarketList.from((raw.markets || []).map(convertMarket));
+    return {
+        id: raw.id,
+        title: raw.title,
+        description: raw.description,
+        slug: raw.slug,
+        markets,
+        url: raw.url,
+        image: raw.image,
+        category: raw.category,
+        tags: raw.tags,
+    };
+}
+/**
+ * Base class for prediction market exchanges.
+ *
+ * This provides a unified interface for interacting with different
+ * prediction market platforms (Polymarket, Kalshi, etc.).
+ */
+class Exchange {
+    constructor(exchangeName, options = {}) {
+        this.exchangeName = exchangeName.toLowerCase();
+        this.apiKey = options.apiKey;
+        this.privateKey = options.privateKey;
+        this.proxyAddress = options.proxyAddress;
+        this.signatureType = options.signatureType;
+        let baseUrl = options.baseUrl || "http://localhost:3847";
+        const autoStartServer = options.autoStartServer !== false;
+        // Initialize server manager
+        this.serverManager = new server_manager_js_1.ServerManager({ baseUrl });
+        // Configure the API client with the initial base URL (will be updated if port changes)
+        this.config = new index_js_1.Configuration({ basePath: baseUrl });
+        this.api = new index_js_1.DefaultApi(this.config);
+        // Initialize the server connection asynchronously
+        this.initPromise = this.initializeServer(autoStartServer);
+    }
+    async initializeServer(autoStartServer) {
+        if (autoStartServer) {
+            try {
+                await this.serverManager.ensureServerRunning();
+                // Get the actual port the server is running on
+                // (may differ from default if default port was busy)
+                const actualPort = this.serverManager.getRunningPort();
+                const newBaseUrl = `http://localhost:${actualPort}`;
+                const accessToken = this.serverManager.getAccessToken();
+                const headers = {};
+                if (accessToken) {
+                    headers['x-pmxt-access-token'] = accessToken;
+                }
+                // Update API client with actual base URL
+                this.config = new index_js_1.Configuration({
+                    basePath: newBaseUrl,
+                    headers
+                });
+                this.api = new index_js_1.DefaultApi(this.config);
+            }
+            catch (error) {
+                throw new Error(`Failed to start PMXT server: ${error}\n\n` +
+                    `Please ensure 'pmxt-core' is installed: npm install -g pmxt-core\n` +
+                    `Or start the server manually: pmxt-server`);
+            }
+        }
+    }
+    handleResponse(response) {
+        if (!response.success) {
+            const error = response.error || {};
+            throw new Error(error.message || "Unknown error");
+        }
+        return response.data;
+    }
+    getCredentials() {
+        if (!this.apiKey && !this.privateKey) {
+            return undefined;
+        }
+        return {
+            apiKey: this.apiKey,
+            privateKey: this.privateKey,
+            funderAddress: this.proxyAddress,
+            signatureType: this.signatureType,
+        };
+    }
+    // Market Data Methods
+    /**
+     * Get active markets from the exchange.
+     *
+     * @param params - Optional filter parameters
+     * @returns List of unified markets
+     *
+     * @example
+     * ```typescript
+     * const markets = await exchange.fetchMarkets({ limit: 20, sort: "volume" });
+     * ```
+     */
+    async fetchMarkets(params) {
+        await this.initPromise;
+        try {
+            const args = [];
+            if (params) {
+                args.push(params);
+            }
+            const requestBody = {
+                args,
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.fetchMarkets({
+                exchange: this.exchangeName,
+                fetchMarketsRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return data.map(convertMarket);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch markets: ${error}`);
+        }
+    }
+    /**
+     * Get historical price candles.
+     *
+     * @param outcomeId - Outcome ID (from market.outcomes[].outcomeId)
+     * @param params - History filter parameters
+     * @returns List of price candles
+     *
+     * @example
+     * ```typescript
+     * const markets = await exchange.fetchMarkets({ query: "Trump" });
+     * const outcomeId = markets[0].outcomes[0].outcomeId;
+     * const candles = await exchange.fetchOHLCV(outcomeId, {
+     *   resolution: "1h",
+     *   limit: 100
+     * });
+     * ```
+     */
+    async fetchOHLCV(outcomeId, params) {
+        await this.initPromise;
+        try {
+            const paramsDict = { resolution: params.resolution };
+            if (params.start) {
+                paramsDict.start = params.start.toISOString();
+            }
+            if (params.end) {
+                paramsDict.end = params.end.toISOString();
+            }
+            if (params.limit) {
+                paramsDict.limit = params.limit;
+            }
+            const requestBody = {
+                args: [outcomeId, paramsDict],
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.fetchOHLCV({
+                exchange: this.exchangeName,
+                fetchOHLCVRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return data.map(convertCandle);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch OHLCV: ${error}`);
+        }
+    }
+    /**
+     * Get current order book for an outcome.
+     *
+     * @param outcomeId - Outcome ID
+     * @returns Current order book
+     *
+     * @example
+     * ```typescript
+     * const orderBook = await exchange.fetchOrderBook(outcomeId);
+     * console.log(`Best bid: ${orderBook.bids[0].price}`);
+     * console.log(`Best ask: ${orderBook.asks[0].price}`);
+     * ```
+     */
+    async fetchOrderBook(outcomeId) {
+        await this.initPromise;
+        try {
+            const requestBody = {
+                args: [outcomeId],
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.fetchOrderBook({
+                exchange: this.exchangeName,
+                fetchOrderBookRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return convertOrderBook(data);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch order book: ${error}`);
+        }
+    }
+    /**
+     * Get trade history for an outcome.
+     *
+     * Note: Polymarket requires API key.
+     *
+     * @param outcomeId - Outcome ID
+     * @param params - History filter parameters
+     * @returns List of trades
+     */
+    async fetchTrades(outcomeId, params) {
+        await this.initPromise;
+        try {
+            const paramsDict = { resolution: params.resolution };
+            if (params.limit) {
+                paramsDict.limit = params.limit;
+            }
+            const requestBody = {
+                args: [outcomeId, paramsDict],
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.fetchTrades({
+                exchange: this.exchangeName,
+                fetchTradesRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return data.map(convertTrade);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch trades: ${error}`);
+        }
+    }
+    // WebSocket Streaming Methods
+    /**
+     * Watch real-time order book updates via WebSocket.
+     *
+     * Returns a promise that resolves with the next order book update.
+     * Call repeatedly in a loop to stream updates (CCXT Pro pattern).
+     *
+     * @param outcomeId - Outcome ID to watch
+     * @param limit - Optional depth limit for order book
+     * @returns Next order book update
+     *
+     * @example
+     * ```typescript
+     * // Stream order book updates
+     * while (true) {
+     *   const orderBook = await exchange.watchOrderBook(outcomeId);
+     *   console.log(`Best bid: ${orderBook.bids[0].price}`);
+     *   console.log(`Best ask: ${orderBook.asks[0].price}`);
+     * }
+     * ```
+     */
+    async watchOrderBook(outcomeId, limit) {
+        await this.initPromise;
+        try {
+            const args = [outcomeId];
+            if (limit !== undefined) {
+                args.push(limit);
+            }
+            const requestBody = {
+                args,
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.watchOrderBook({
+                exchange: this.exchangeName,
+                watchOrderBookRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return convertOrderBook(data);
+        }
+        catch (error) {
+            throw new Error(`Failed to watch order book: ${error}`);
+        }
+    }
+    /**
+     * Watch real-time trade updates via WebSocket.
+     *
+     * Returns a promise that resolves with the next trade(s).
+     * Call repeatedly in a loop to stream updates (CCXT Pro pattern).
+     *
+     * @param outcomeId - Outcome ID to watch
+     * @param since - Optional timestamp to filter trades from
+     * @param limit - Optional limit for number of trades
+     * @returns Next trade update(s)
+     *
+     * @example
+     * ```typescript
+     * // Stream trade updates
+     * while (true) {
+     *   const trades = await exchange.watchTrades(outcomeId);
+     *   for (const trade of trades) {
+     *     console.log(`Trade: ${trade.price} @ ${trade.amount}`);
+     *   }
+     * }
+     * ```
+     */
+    async watchTrades(outcomeId, since, limit) {
+        await this.initPromise;
+        try {
+            const args = [outcomeId];
+            if (since !== undefined) {
+                args.push(since);
+            }
+            if (limit !== undefined) {
+                args.push(limit);
+            }
+            const requestBody = {
+                args,
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.watchTrades({
+                exchange: this.exchangeName,
+                watchTradesRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return data.map(convertTrade);
+        }
+        catch (error) {
+            throw new Error(`Failed to watch trades: ${error}`);
+        }
+    }
+    // Trading Methods (require authentication)
+    /**
+     * Create a new order.
+     *
+     * @param params - Order parameters
+     * @returns Created order
+     *
+     * @example
+     * ```typescript
+     * const order = await exchange.createOrder({
+     *   marketId: "663583",
+     *   outcomeId: "10991849...",
+     *   side: "buy",
+     *   type: "limit",
+     *   amount: 10,
+     *   price: 0.55
+     * });
+     * ```
+     */
+    async createOrder(params) {
+        await this.initPromise;
+        try {
+            const paramsDict = {
+                marketId: params.marketId,
+                outcomeId: params.outcomeId,
+                side: params.side,
+                type: params.type,
+                amount: params.amount,
+            };
+            if (params.price !== undefined) {
+                paramsDict.price = params.price;
+            }
+            if (params.fee !== undefined) {
+                paramsDict.fee = params.fee;
+            }
+            const requestBody = {
+                args: [paramsDict],
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.createOrder({
+                exchange: this.exchangeName,
+                createOrderRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return convertOrder(data);
+        }
+        catch (error) {
+            throw new Error(`Failed to create order: ${error}`);
+        }
+    }
+    /**
+     * Cancel an open order.
+     *
+     * @param orderId - Order ID to cancel
+     * @returns Cancelled order
+     */
+    async cancelOrder(orderId) {
+        await this.initPromise;
+        try {
+            const requestBody = {
+                args: [orderId],
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.cancelOrder({
+                exchange: this.exchangeName,
+                cancelOrderRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return convertOrder(data);
+        }
+        catch (error) {
+            throw new Error(`Failed to cancel order: ${error}`);
+        }
+    }
+    /**
+     * Get details of a specific order.
+     *
+     * @param orderId - Order ID
+     * @returns Order details
+     */
+    async fetchOrder(orderId) {
+        await this.initPromise;
+        try {
+            const requestBody = {
+                args: [orderId],
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.fetchOrder({
+                exchange: this.exchangeName,
+                cancelOrderRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return convertOrder(data);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch order: ${error}`);
+        }
+    }
+    /**
+     * Get all open orders, optionally filtered by market.
+     *
+     * @param marketId - Optional market ID to filter by
+     * @returns List of open orders
+     */
+    async fetchOpenOrders(marketId) {
+        await this.initPromise;
+        try {
+            const args = [];
+            if (marketId) {
+                args.push(marketId);
+            }
+            const requestBody = {
+                args,
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.fetchOpenOrders({
+                exchange: this.exchangeName,
+                fetchOpenOrdersRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return data.map(convertOrder);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch open orders: ${error}`);
+        }
+    }
+    // Account Methods
+    /**
+     * Get current positions across all markets.
+     *
+     * @returns List of positions
+     */
+    async fetchPositions() {
+        await this.initPromise;
+        try {
+            const requestBody = {
+                args: [],
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.fetchPositions({
+                exchange: this.exchangeName,
+                fetchPositionsRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return data.map(convertPosition);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch positions: ${error}`);
+        }
+    }
+    /**
+     * Get account balance.
+     *
+     * @returns List of balances (by currency)
+     */
+    async fetchBalance() {
+        await this.initPromise;
+        try {
+            const requestBody = {
+                args: [],
+                credentials: this.getCredentials()
+            };
+            const response = await this.api.fetchBalance({
+                exchange: this.exchangeName,
+                fetchPositionsRequest: requestBody,
+            });
+            const data = this.handleResponse(response);
+            return data.map(convertBalance);
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch balance: ${error}`);
+        }
+    }
+    /**
+     * Calculate the average execution price for a given amount by walking the order book.
+     * Uses the sidecar server for calculation to ensure consistency.
+     *
+     * @param orderBook - The current order book
+     * @param side - 'buy' or 'sell'
+     * @param amount - The amount to execute
+     * @returns The volume-weighted average price, or 0 if insufficient liquidity
+     */
+    async getExecutionPrice(orderBook, side, amount) {
+        const result = await this.getExecutionPriceDetailed(orderBook, side, amount);
+        return result.fullyFilled ? result.price : 0;
+    }
+    /**
+     * Calculate detailed execution price information.
+     * Uses the sidecar server for calculation to ensure consistency.
+     *
+     * @param orderBook - The current order book
+     * @param side - 'buy' or 'sell'
+     * @param amount - The amount to execute
+     * @returns Detailed execution result
+     */
+    async getExecutionPriceDetailed(orderBook, side, amount) {
+        await this.initPromise;
+        try {
+            const body = {
+                args: [orderBook, side, amount]
+            };
+            const credentials = this.getCredentials();
+            if (credentials) {
+                body.credentials = credentials;
+            }
+            const url = `${this.config.basePath}/api/${this.exchangeName}/getExecutionPriceDetailed`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...this.config.headers
+                },
+                body: JSON.stringify(body)
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.error?.message || response.statusText);
+            }
+            const json = await response.json();
+            return this.handleResponse(json);
+        }
+        catch (error) {
+            throw new Error(`Failed to get execution price: ${error}`);
+        }
+    }
+    // ----------------------------------------------------------------------------
+    // Filtering Methods
+    // ----------------------------------------------------------------------------
+    /**
+     * Filter markets based on criteria or custom function.
+     *
+     * @param markets - Array of markets to filter
+     * @param criteria - Filter criteria object, string (simple text search), or predicate function
+     * @returns Filtered array of markets
+     *
+     * @example Simple text search
+     * api.filterMarkets(markets, 'Trump')
+     *
+     * @example Advanced filtering
+     * api.filterMarkets(markets, {
+     *   text: 'Trump',
+     *   searchIn: ['title', 'tags'],
+     *   volume24h: { min: 10000 },
+     *   category: 'Politics',
+     *   price: { outcome: 'yes', max: 0.5 }
+     * })
+     *
+     * @example Custom predicate
+     * api.filterMarkets(markets, m => m.liquidity > 5000 && m.yes?.price < 0.3)
+     */
+    filterMarkets(markets, criteria) {
+        // Handle predicate function
+        if (typeof criteria === 'function') {
+            return markets.filter(criteria);
+        }
+        // Handle simple string search
+        if (typeof criteria === 'string') {
+            const lowerQuery = criteria.toLowerCase();
+            return markets.filter(m => m.title.toLowerCase().includes(lowerQuery));
+        }
+        // Handle criteria object
+        return markets.filter(market => {
+            // Text search
+            if (criteria.text) {
+                const lowerQuery = criteria.text.toLowerCase();
+                const searchIn = criteria.searchIn || ['title'];
+                let textMatch = false;
+                for (const field of searchIn) {
+                    if (field === 'title' && market.title?.toLowerCase().includes(lowerQuery)) {
+                        textMatch = true;
+                        break;
+                    }
+                    if (field === 'description' && market.description?.toLowerCase().includes(lowerQuery)) {
+                        textMatch = true;
+                        break;
+                    }
+                    if (field === 'category' && market.category?.toLowerCase().includes(lowerQuery)) {
+                        textMatch = true;
+                        break;
+                    }
+                    if (field === 'tags' && market.tags?.some(tag => tag.toLowerCase().includes(lowerQuery))) {
+                        textMatch = true;
+                        break;
+                    }
+                    if (field === 'outcomes' && market.outcomes?.some(o => o.label.toLowerCase().includes(lowerQuery))) {
+                        textMatch = true;
+                        break;
+                    }
+                }
+                if (!textMatch)
+                    return false;
+            }
+            // Category filter
+            if (criteria.category && market.category !== criteria.category) {
+                return false;
+            }
+            // Tags filter (match ANY of the provided tags)
+            if (criteria.tags && criteria.tags.length > 0) {
+                const hasMatchingTag = criteria.tags.some(tag => market.tags?.some(marketTag => marketTag.toLowerCase() === tag.toLowerCase()));
+                if (!hasMatchingTag)
+                    return false;
+            }
+            // Volume24h filter
+            if (criteria.volume24h) {
+                if (criteria.volume24h.min !== undefined && market.volume24h < criteria.volume24h.min) {
+                    return false;
+                }
+                if (criteria.volume24h.max !== undefined && market.volume24h > criteria.volume24h.max) {
+                    return false;
+                }
+            }
+            // Volume filter
+            if (criteria.volume) {
+                if (criteria.volume.min !== undefined && (market.volume || 0) < criteria.volume.min) {
+                    return false;
+                }
+                if (criteria.volume.max !== undefined && (market.volume || 0) > criteria.volume.max) {
+                    return false;
+                }
+            }
+            // Liquidity filter
+            if (criteria.liquidity) {
+                if (criteria.liquidity.min !== undefined && market.liquidity < criteria.liquidity.min) {
+                    return false;
+                }
+                if (criteria.liquidity.max !== undefined && market.liquidity > criteria.liquidity.max) {
+                    return false;
+                }
+            }
+            // OpenInterest filter
+            if (criteria.openInterest) {
+                if (criteria.openInterest.min !== undefined && (market.openInterest || 0) < criteria.openInterest.min) {
+                    return false;
+                }
+                if (criteria.openInterest.max !== undefined && (market.openInterest || 0) > criteria.openInterest.max) {
+                    return false;
+                }
+            }
+            // ResolutionDate filter
+            if (criteria.resolutionDate && market.resolutionDate) {
+                const resDate = market.resolutionDate;
+                if (criteria.resolutionDate.before && resDate >= criteria.resolutionDate.before) {
+                    return false;
+                }
+                if (criteria.resolutionDate.after && resDate <= criteria.resolutionDate.after) {
+                    return false;
+                }
+            }
+            // Price filter (for binary markets)
+            if (criteria.price) {
+                const outcome = market[criteria.price.outcome];
+                if (!outcome)
+                    return false;
+                if (criteria.price.min !== undefined && outcome.price < criteria.price.min) {
+                    return false;
+                }
+                if (criteria.price.max !== undefined && outcome.price > criteria.price.max) {
+                    return false;
+                }
+            }
+            // Price change filter
+            if (criteria.priceChange24h) {
+                const outcome = market[criteria.priceChange24h.outcome];
+                if (!outcome || outcome.priceChange24h === undefined)
+                    return false;
+                if (criteria.priceChange24h.min !== undefined && outcome.priceChange24h < criteria.priceChange24h.min) {
+                    return false;
+                }
+                if (criteria.priceChange24h.max !== undefined && outcome.priceChange24h > criteria.priceChange24h.max) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    /**
+     * Filter events based on criteria or custom function.
+     *
+     * @param events - Array of events to filter
+     * @param criteria - Filter criteria object, string (simple text search), or predicate function
+     * @returns Filtered array of events
+     *
+     * @example Simple text search
+     * api.filterEvents(events, 'Trump')
+     *
+     * @example Advanced filtering
+     * api.filterEvents(events, {
+     *   text: 'Election',
+     *   searchIn: ['title', 'tags'],
+     *   category: 'Politics',
+     *   marketCount: { min: 5 }
+     * })
+     *
+     * @example Custom predicate
+     * api.filterEvents(events, e => e.markets.length > 10)
+     */
+    filterEvents(events, criteria) {
+        // Handle predicate function
+        if (typeof criteria === 'function') {
+            return events.filter(criteria);
+        }
+        // Handle simple string search
+        if (typeof criteria === 'string') {
+            const lowerQuery = criteria.toLowerCase();
+            return events.filter(e => e.title.toLowerCase().includes(lowerQuery));
+        }
+        // Handle criteria object
+        return events.filter(event => {
+            // Text search
+            if (criteria.text) {
+                const lowerQuery = criteria.text.toLowerCase();
+                const searchIn = criteria.searchIn || ['title'];
+                let textMatch = false;
+                for (const field of searchIn) {
+                    if (field === 'title' && event.title?.toLowerCase().includes(lowerQuery)) {
+                        textMatch = true;
+                        break;
+                    }
+                    if (field === 'description' && event.description?.toLowerCase().includes(lowerQuery)) {
+                        textMatch = true;
+                        break;
+                    }
+                    if (field === 'category' && event.category?.toLowerCase().includes(lowerQuery)) {
+                        textMatch = true;
+                        break;
+                    }
+                    if (field === 'tags' && event.tags?.some(tag => tag.toLowerCase().includes(lowerQuery))) {
+                        textMatch = true;
+                        break;
+                    }
+                }
+                if (!textMatch)
+                    return false;
+            }
+            // Category filter
+            if (criteria.category && event.category !== criteria.category) {
+                return false;
+            }
+            // Tags filter (match ANY of the provided tags)
+            if (criteria.tags && criteria.tags.length > 0) {
+                const hasMatchingTag = criteria.tags.some(tag => event.tags?.some(eventTag => eventTag.toLowerCase() === tag.toLowerCase()));
+                if (!hasMatchingTag)
+                    return false;
+            }
+            // Market count filter
+            if (criteria.marketCount) {
+                const count = event.markets.length;
+                if (criteria.marketCount.min !== undefined && count < criteria.marketCount.min) {
+                    return false;
+                }
+                if (criteria.marketCount.max !== undefined && count > criteria.marketCount.max) {
+                    return false;
+                }
+            }
+            // Total volume filter
+            if (criteria.totalVolume) {
+                const totalVolume = event.markets.reduce((sum, m) => sum + m.volume24h, 0);
+                if (criteria.totalVolume.min !== undefined && totalVolume < criteria.totalVolume.min) {
+                    return false;
+                }
+                if (criteria.totalVolume.max !== undefined && totalVolume > criteria.totalVolume.max) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+}
+exports.Exchange = Exchange;
+class Polymarket extends Exchange {
+    constructor(options = {}) {
+        // Default to gnosis-safe signature type
+        const polyOptions = {
+            signatureType: 'gnosis-safe',
+            ...options
+        };
+        super("polymarket", polyOptions);
+    }
+}
+exports.Polymarket = Polymarket;
+/**
+ * Kalshi exchange client.
+ *
+ * @example
+ * ```typescript
+ * // Public data (no auth)
+ * const kalshi = new Kalshi();
+ * const markets = await kalshi.fetchMarkets({ query: "Fed rates" });
+ *
+ * // Trading (requires auth)
+ * const kalshi = new Kalshi({
+ *   apiKey: process.env.KALSHI_API_KEY,
+ *   privateKey: process.env.KALSHI_PRIVATE_KEY
+ * });
+ * const balance = await kalshi.fetchBalance();
+ * ```
+ */
+class Kalshi extends Exchange {
+    constructor(options = {}) {
+        super("kalshi", options);
+    }
+}
+exports.Kalshi = Kalshi;
+/**
+ * Limitless exchange client.
+ *
+ * @example
+ * ```typescript
+ * // Public data (no auth)
+ * const limitless = new Limitless();
+ * const markets = await limitless.fetchMarkets({ query: "Trump" });
+ *
+ * // Trading (requires auth)
+ * const limitless = new Limitless({
+ *   apiKey: process.env.LIMITLESS_API_KEY,
+ *   privateKey: process.env.LIMITLESS_PRIVATE_KEY
+ * });
+ * const balance = await limitless.fetchBalance();
+ * ```
+ */
+class Limitless extends Exchange {
+    constructor(options = {}) {
+        super("limitless", options);
+    }
+}
+exports.Limitless = Limitless;