pmxtjs 0.3.0 → 0.4.0

package/dist/exchanges/kalshi/index.js

@@ -0,0 +1,273 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KalshiExchange = void 0;
+const axios_1 = __importDefault(require("axios"));
+const BaseExchange_1 = require("../../BaseExchange");
+const fetchMarkets_1 = require("./fetchMarkets");
+const searchMarkets_1 = require("./searchMarkets");
+const getMarketsBySlug_1 = require("./getMarketsBySlug");
+const fetchOHLCV_1 = require("./fetchOHLCV");
+const fetchOrderBook_1 = require("./fetchOrderBook");
+const fetchTrades_1 = require("./fetchTrades");
+const auth_1 = require("./auth");
+class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
+    constructor(credentials) {
+        super(credentials);
+        if (credentials?.apiKey && credentials?.privateKey) {
+            this.auth = new auth_1.KalshiAuth(credentials);
+        }
+    }
+    get name() {
+        return "Kalshi";
+    }
+    // ----------------------------------------------------------------------------
+    // Helpers
+    // ----------------------------------------------------------------------------
+    ensureAuth() {
+        if (!this.auth) {
+            throw new Error('Trading operations require authentication. ' +
+                'Initialize KalshiExchange with credentials (apiKey and privateKey).');
+        }
+        return this.auth;
+    }
+    // ----------------------------------------------------------------------------
+    // Market Data Methods
+    // ----------------------------------------------------------------------------
+    async fetchMarkets(params) {
+        return (0, fetchMarkets_1.fetchMarkets)(params);
+    }
+    async searchMarkets(query, params) {
+        return (0, searchMarkets_1.searchMarkets)(query, params);
+    }
+    async getMarketsBySlug(slug) {
+        return (0, getMarketsBySlug_1.getMarketsBySlug)(slug);
+    }
+    async fetchOHLCV(id, params) {
+        return (0, fetchOHLCV_1.fetchOHLCV)(id, params);
+    }
+    async fetchOrderBook(id) {
+        return (0, fetchOrderBook_1.fetchOrderBook)(id);
+    }
+    async fetchTrades(id, params) {
+        return (0, fetchTrades_1.fetchTrades)(id, params);
+    }
+    // ----------------------------------------------------------------------------
+    // User Data Methods
+    // ----------------------------------------------------------------------------
+    async fetchBalance() {
+        const auth = this.ensureAuth();
+        const path = '/trade-api/v2/portfolio/balance';
+        // Use demo-api if it's a sandbox key (usually indicated by config, but defaulting to prod for now)
+        // Or we could detect it. For now, let's assume Production unless specified.
+        // TODO: Make base URL configurable in credentials
+        const baseUrl = 'https://trading-api.kalshi.com';
+        const headers = auth.getHeaders('GET', path);
+        try {
+            const response = await axios_1.default.get(`${baseUrl}${path}`, { headers });
+            // Kalshi response structure:
+            // - balance: Available balance in cents (for trading)
+            // - portfolio_value: Total portfolio value in cents (includes positions)
+            // - updated_ts: Unix timestamp of last update
+            const balanceCents = response.data.balance;
+            const portfolioValueCents = response.data.portfolio_value;
+            const available = balanceCents / 100;
+            const total = portfolioValueCents / 100;
+            const locked = total - available;
+            return [{
+                    currency: 'USD',
+                    total: total, // Total portfolio value (cash + positions)
+                    available: available, // Available for trading
+                    locked: locked // Value locked in positions
+                }];
+        }
+        catch (error) {
+            console.error("Kalshi fetchBalance error:", error?.response?.data || error.message);
+            throw error;
+        }
+    }
+    // ----------------------------------------------------------------------------
+    // Trading Methods
+    // ----------------------------------------------------------------------------
+    async createOrder(params) {
+        const auth = this.ensureAuth();
+        const path = '/trade-api/v2/portfolio/orders';
+        const baseUrl = 'https://trading-api.kalshi.com';
+        const headers = auth.getHeaders('POST', path);
+        // Map unified params to Kalshi format
+        // Kalshi uses 'yes'/'no' for side and 'buy'/'sell' for action
+        const isYesSide = params.side === 'buy';
+        const kalshiOrder = {
+            ticker: params.marketId, // Kalshi uses ticker for market identification
+            client_order_id: `pmxt-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            side: isYesSide ? 'yes' : 'no',
+            action: params.side === 'buy' ? 'buy' : 'sell',
+            count: params.amount, // Number of contracts
+            type: params.type === 'limit' ? 'limit' : 'market'
+        };
+        // Add price field based on side (yes_price for yes side, no_price for no side)
+        if (params.price) {
+            const priceInCents = Math.round(params.price * 100);
+            if (isYesSide) {
+                kalshiOrder.yes_price = priceInCents;
+            }
+            else {
+                kalshiOrder.no_price = priceInCents;
+            }
+        }
+        try {
+            const response = await axios_1.default.post(`${baseUrl}${path}`, kalshiOrder, { headers });
+            const order = response.data.order;
+            return {
+                id: order.order_id,
+                marketId: params.marketId,
+                outcomeId: params.outcomeId,
+                side: params.side,
+                type: params.type,
+                price: params.price,
+                amount: params.amount,
+                status: this.mapKalshiOrderStatus(order.status),
+                filled: order.queue_position === 0 ? params.amount : 0,
+                remaining: order.remaining_count || params.amount,
+                timestamp: new Date(order.created_time).getTime()
+            };
+        }
+        catch (error) {
+            console.error("Kalshi createOrder error:", error?.response?.data || error.message);
+            throw error;
+        }
+    }
+    async cancelOrder(orderId) {
+        const auth = this.ensureAuth();
+        const path = `/trade-api/v2/portfolio/orders/${orderId}`;
+        const baseUrl = 'https://trading-api.kalshi.com';
+        const headers = auth.getHeaders('DELETE', path);
+        try {
+            const response = await axios_1.default.delete(`${baseUrl}${path}`, { headers });
+            const order = response.data.order;
+            return {
+                id: order.order_id,
+                marketId: order.ticker,
+                outcomeId: order.ticker,
+                side: order.side === 'yes' ? 'buy' : 'sell',
+                type: 'limit',
+                amount: order.count,
+                status: 'cancelled',
+                filled: order.count - (order.remaining_count || 0),
+                remaining: 0,
+                timestamp: new Date(order.created_time).getTime()
+            };
+        }
+        catch (error) {
+            console.error("Kalshi cancelOrder error:", error?.response?.data || error.message);
+            throw error;
+        }
+    }
+    async fetchOrder(orderId) {
+        const auth = this.ensureAuth();
+        const path = `/trade-api/v2/portfolio/orders/${orderId}`;
+        const baseUrl = 'https://trading-api.kalshi.com';
+        const headers = auth.getHeaders('GET', path);
+        try {
+            const response = await axios_1.default.get(`${baseUrl}${path}`, { headers });
+            const order = response.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()
+            };
+        }
+        catch (error) {
+            console.error("Kalshi fetchOrder error:", error?.response?.data || error.message);
+            throw error;
+        }
+    }
+    async fetchOpenOrders(marketId) {
+        const auth = this.ensureAuth();
+        // CRITICAL: Query parameters must NOT be included in the signature
+        const basePath = '/trade-api/v2/portfolio/orders';
+        let queryParams = '?status=resting';
+        if (marketId) {
+            queryParams += `&ticker=${marketId}`;
+        }
+        const baseUrl = 'https://trading-api.kalshi.com';
+        // Sign only the base path, not the query parameters
+        const headers = auth.getHeaders('GET', basePath);
+        try {
+            const response = await axios_1.default.get(`${baseUrl}${basePath}${queryParams}`, { headers });
+            const orders = response.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()
+            }));
+        }
+        catch (error) {
+            console.error("Kalshi fetchOpenOrders error:", error?.response?.data || error.message);
+            return [];
+        }
+    }
+    async fetchPositions() {
+        const auth = this.ensureAuth();
+        const path = '/trade-api/v2/portfolio/positions';
+        const baseUrl = 'https://trading-api.kalshi.com';
+        const headers = auth.getHeaders('GET', path);
+        try {
+            const response = await axios_1.default.get(`${baseUrl}${path}`, { headers });
+            const positions = response.data.market_positions || [];
+            return positions.map((pos) => {
+                const absPosition = Math.abs(pos.position);
+                // Prevent division by zero
+                const entryPrice = absPosition > 0 ? pos.total_cost / absPosition / 100 : 0;
+                return {
+                    marketId: pos.ticker,
+                    outcomeId: pos.ticker,
+                    outcomeLabel: pos.ticker, // Kalshi uses ticker as the outcome label
+                    size: pos.position, // Positive for long, negative for short
+                    entryPrice: entryPrice,
+                    currentPrice: pos.market_price ? pos.market_price / 100 : entryPrice,
+                    unrealizedPnL: pos.market_exposure ? pos.market_exposure / 100 : 0,
+                    realizedPnL: pos.realized_pnl ? pos.realized_pnl / 100 : 0
+                };
+            });
+        }
+        catch (error) {
+            console.error("Kalshi fetchPositions error:", error?.response?.data || error.message);
+            return [];
+        }
+    }
+    // Helper to map Kalshi order status to unified status
+    mapKalshiOrderStatus(status) {
+        switch (status.toLowerCase()) {
+            case 'resting':
+                return 'open';
+            case 'canceled':
+            case 'cancelled':
+                return 'cancelled';
+            case 'executed':
+            case 'filled':
+                return 'filled';
+            default:
+                return 'open';
+        }
+    }
+}
+exports.KalshiExchange = KalshiExchange;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,309 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const kalshi_1 = require("../kalshi");
+const axios_1 = __importDefault(require("axios"));
+const auth_1 = require("./auth");
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+// Mock KalshiAuth
+jest.mock('./auth');
+const MockedKalshiAuth = auth_1.KalshiAuth;
+describe('KalshiExchange', () => {
+    let exchange;
+    const mockCredentials = {
+        apiKey: 'test-api-key',
+        privateKey: 'mock-private-key'
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock the getHeaders method
+        MockedKalshiAuth.prototype.getHeaders = jest.fn().mockReturnValue({
+            'KALSHI-ACCESS-KEY': 'test-api-key',
+            'KALSHI-ACCESS-TIMESTAMP': '1234567890',
+            'KALSHI-ACCESS-SIGNATURE': 'mock-signature',
+            'Content-Type': 'application/json'
+        });
+    });
+    describe('Authentication', () => {
+        it('should throw error when trading without credentials', async () => {
+            exchange = new kalshi_1.KalshiExchange();
+            await expect(exchange.fetchBalance()).rejects.toThrow('Trading operations require authentication');
+        });
+        it('should initialize with credentials', () => {
+            exchange = new kalshi_1.KalshiExchange(mockCredentials);
+            expect(exchange).toBeDefined();
+        });
+    });
+    describe('Market Data Methods', () => {
+        beforeEach(() => {
+            exchange = new kalshi_1.KalshiExchange();
+        });
+        it('should fetch markets', async () => {
+            const mockResponse = {
+                data: {
+                    markets: [
+                        {
+                            ticker: 'TEST-MARKET',
+                            title: 'Test Market',
+                            yes_bid: 50,
+                            yes_ask: 52,
+                            volume: 1000
+                        }
+                    ]
+                }
+            };
+            mockedAxios.get.mockResolvedValue(mockResponse);
+            const markets = await exchange.fetchMarkets();
+            expect(markets).toBeDefined();
+        });
+    });
+    describe('Trading Methods', () => {
+        beforeEach(() => {
+            exchange = new kalshi_1.KalshiExchange(mockCredentials);
+        });
+        describe('createOrder', () => {
+            it('should create buy order with yes_price for buy side', async () => {
+                const orderParams = {
+                    marketId: 'TEST-MARKET',
+                    outcomeId: 'yes',
+                    side: 'buy',
+                    type: 'limit',
+                    amount: 10,
+                    price: 0.55
+                };
+                const mockResponse = {
+                    data: {
+                        order: {
+                            order_id: 'order-123',
+                            ticker: 'TEST-MARKET',
+                            status: 'resting',
+                            count: 10,
+                            remaining_count: 10,
+                            created_time: '2026-01-13T12:00:00Z',
+                            queue_position: 1
+                        }
+                    }
+                };
+                mockedAxios.post.mockResolvedValue(mockResponse);
+                const order = await exchange.createOrder(orderParams);
+                expect(mockedAxios.post).toHaveBeenCalledWith('https://trading-api.kalshi.com/trade-api/v2/portfolio/orders', expect.objectContaining({
+                    ticker: 'TEST-MARKET',
+                    side: 'yes',
+                    action: 'buy',
+                    count: 10,
+                    type: 'limit',
+                    yes_price: 55 // 0.55 * 100
+                }), expect.any(Object));
+                expect(order.id).toBe('order-123');
+                expect(order.status).toBe('open');
+            });
+            it('should create sell order with no_price for sell side', async () => {
+                const orderParams = {
+                    marketId: 'TEST-MARKET',
+                    outcomeId: 'no',
+                    side: 'sell',
+                    type: 'limit',
+                    amount: 5,
+                    price: 0.45
+                };
+                const mockResponse = {
+                    data: {
+                        order: {
+                            order_id: 'order-456',
+                            ticker: 'TEST-MARKET',
+                            status: 'resting',
+                            count: 5,
+                            remaining_count: 5,
+                            created_time: '2026-01-13T12:00:00Z',
+                            queue_position: 1
+                        }
+                    }
+                };
+                mockedAxios.post.mockResolvedValue(mockResponse);
+                await exchange.createOrder(orderParams);
+                expect(mockedAxios.post).toHaveBeenCalledWith('https://trading-api.kalshi.com/trade-api/v2/portfolio/orders', expect.objectContaining({
+                    ticker: 'TEST-MARKET',
+                    side: 'no',
+                    action: 'sell',
+                    count: 5,
+                    type: 'limit',
+                    no_price: 45 // 0.45 * 100
+                }), expect.any(Object));
+            });
+        });
+        describe('fetchOpenOrders', () => {
+            it('should sign request without query parameters', async () => {
+                const mockResponse = {
+                    data: {
+                        orders: [
+                            {
+                                order_id: 'order-123',
+                                ticker: 'TEST-MARKET',
+                                side: 'yes',
+                                type: 'limit',
+                                yes_price: 55,
+                                count: 10,
+                                remaining_count: 10,
+                                created_time: '2026-01-13T12:00:00Z'
+                            }
+                        ]
+                    }
+                };
+                mockedAxios.get.mockResolvedValue(mockResponse);
+                await exchange.fetchOpenOrders();
+                // Verify the request URL includes query params
+                expect(mockedAxios.get).toHaveBeenCalledWith('https://trading-api.kalshi.com/trade-api/v2/portfolio/orders?status=resting', expect.any(Object));
+                // Verify getHeaders was called with base path only (no query params)
+                expect(MockedKalshiAuth.prototype.getHeaders).toHaveBeenCalledWith('GET', '/trade-api/v2/portfolio/orders');
+            });
+            it('should include ticker in query params when marketId provided', async () => {
+                const mockResponse = { data: { orders: [] } };
+                mockedAxios.get.mockResolvedValue(mockResponse);
+                await exchange.fetchOpenOrders('TEST-MARKET');
+                expect(mockedAxios.get).toHaveBeenCalledWith('https://trading-api.kalshi.com/trade-api/v2/portfolio/orders?status=resting&ticker=TEST-MARKET', expect.any(Object));
+            });
+        });
+        describe('fetchPositions', () => {
+            it('should handle positions with zero contracts', async () => {
+                const mockResponse = {
+                    data: {
+                        market_positions: [
+                            {
+                                ticker: 'TEST-MARKET',
+                                position: 0,
+                                total_cost: 0,
+                                market_exposure: 0,
+                                realized_pnl: 0
+                            }
+                        ]
+                    }
+                };
+                mockedAxios.get.mockResolvedValue(mockResponse);
+                const positions = await exchange.fetchPositions();
+                expect(positions).toHaveLength(1);
+                expect(positions[0].size).toBe(0);
+                expect(positions[0].entryPrice).toBe(0); // Should not throw division by zero
+            });
+            it('should correctly calculate average price and PnL', async () => {
+                const mockResponse = {
+                    data: {
+                        market_positions: [
+                            {
+                                ticker: 'TEST-MARKET',
+                                position: 10,
+                                total_cost: 550, // 10 contracts at $0.55 each = $5.50 = 550 cents
+                                market_exposure: 100, // $1.00 unrealized PnL
+                                realized_pnl: 50 // $0.50 realized PnL
+                            }
+                        ]
+                    }
+                };
+                mockedAxios.get.mockResolvedValue(mockResponse);
+                const positions = await exchange.fetchPositions();
+                expect(positions).toHaveLength(1);
+                expect(positions[0].size).toBe(10);
+                expect(positions[0].entryPrice).toBe(0.55); // 550 / 10 / 100
+                expect(positions[0].unrealizedPnL).toBe(1.00); // 100 / 100
+                expect(positions[0].realizedPnL).toBe(0.50); // 50 / 100
+            });
+            it('should handle short positions', async () => {
+                const mockResponse = {
+                    data: {
+                        market_positions: [
+                            {
+                                ticker: 'TEST-MARKET',
+                                position: -5, // Short position
+                                total_cost: 250,
+                                market_exposure: -50,
+                                realized_pnl: 25
+                            }
+                        ]
+                    }
+                };
+                mockedAxios.get.mockResolvedValue(mockResponse);
+                const positions = await exchange.fetchPositions();
+                expect(positions[0].size).toBe(-5); // Negative for short
+                expect(Math.abs(positions[0].size)).toBe(5); // Absolute value
+            });
+        });
+        describe('fetchBalance', () => {
+            it('should correctly convert cents to dollars', async () => {
+                const mockResponse = {
+                    data: {
+                        balance: 10000, // $100.00 available
+                        portfolio_value: 15000 // $150.00 total
+                    }
+                };
+                mockedAxios.get.mockResolvedValue(mockResponse);
+                const balances = await exchange.fetchBalance();
+                expect(balances).toHaveLength(1);
+                expect(balances[0].currency).toBe('USD');
+                expect(balances[0].available).toBe(100.00);
+                expect(balances[0].total).toBe(150.00);
+                expect(balances[0].locked).toBe(50.00); // 150 - 100
+            });
+        });
+        describe('cancelOrder', () => {
+            it('should cancel order successfully', async () => {
+                const mockResponse = {
+                    data: {
+                        order: {
+                            order_id: 'order-123',
+                            ticker: 'TEST-MARKET',
+                            side: 'yes',
+                            count: 10,
+                            remaining_count: 5,
+                            created_time: '2026-01-13T12:00:00Z'
+                        }
+                    }
+                };
+                mockedAxios.delete.mockResolvedValue(mockResponse);
+                const order = await exchange.cancelOrder('order-123');
+                expect(order.status).toBe('cancelled');
+                expect(order.filled).toBe(5); // count - remaining_count
+                expect(order.remaining).toBe(0);
+            });
+        });
+    });
+    describe('Order Status Mapping', () => {
+        beforeEach(() => {
+            exchange = new kalshi_1.KalshiExchange(mockCredentials);
+        });
+        it('should map resting to open', async () => {
+            const mockResponse = {
+                data: {
+                    order: {
+                        order_id: 'order-123',
+                        ticker: 'TEST',
+                        status: 'resting',
+                        count: 10,
+                        created_time: '2026-01-13T12:00:00Z'
+                    }
+                }
+            };
+            mockedAxios.get.mockResolvedValue(mockResponse);
+            const order = await exchange.fetchOrder('order-123');
+            expect(order.status).toBe('open');
+        });
+        it('should map executed to filled', async () => {
+            const mockResponse = {
+                data: {
+                    order: {
+                        order_id: 'order-123',
+                        ticker: 'TEST',
+                        status: 'executed',
+                        count: 10,
+                        created_time: '2026-01-13T12:00:00Z'
+                    }
+                }
+            };
+            mockedAxios.get.mockResolvedValue(mockResponse);
+            const order = await exchange.fetchOrder('order-123');
+            expect(order.status).toBe('filled');
+        });
+    });
+});

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

@@ -0,0 +1,3 @@
+import { MarketFilterParams } from '../../BaseExchange';
+import { UnifiedMarket } from '../../types';
+export declare function searchMarkets(query: string, params?: MarketFilterParams): Promise<UnifiedMarket[]>;

package/dist/exchanges/kalshi/searchMarkets.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchMarkets = searchMarkets;
+const fetchMarkets_1 = require("./fetchMarkets");
+async function searchMarkets(query, params) {
+    // We must fetch ALL markets to search them locally since we don't have server-side search
+    const fetchLimit = 100000;
+    try {
+        const markets = await (0, fetchMarkets_1.fetchMarkets)({ ...params, limit: fetchLimit });
+        const lowerQuery = query.toLowerCase();
+        const searchIn = params?.searchIn || 'title'; // Default to title-only search
+        const filtered = markets.filter(market => {
+            const titleMatch = (market.title || '').toLowerCase().includes(lowerQuery);
+            const descMatch = (market.description || '').toLowerCase().includes(lowerQuery);
+            if (searchIn === 'title')
+                return titleMatch;
+            if (searchIn === 'description')
+                return descMatch;
+            return titleMatch || descMatch; // 'both'
+        });
+        const limit = params?.limit || 20;
+        return filtered.slice(0, limit);
+    }
+    catch (error) {
+        console.error("Error searching Kalshi data:", error);
+        return [];
+    }
+}

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

@@ -0,0 +1,4 @@
+import { UnifiedMarket, CandleInterval } from '../../types';
+export declare const KALSHI_API_URL = "https://api.elections.kalshi.com/trade-api/v2/events";
+export declare function mapMarketToUnified(event: any, market: any): UnifiedMarket | null;
+export declare function mapIntervalToKalshi(interval: CandleInterval): number;