pmxtjs 0.4.3 → 1.0.0-b2

package/dist/exchanges/kalshi/index.js

@@ -1,273 +0,0 @@
-"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

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

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

@@ -1,309 +0,0 @@
-"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

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

package/dist/exchanges/kalshi/searchMarkets.js

@@ -1,28 +0,0 @@
-"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

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