pmxt-core 2.9.2 → 2.9.3

package/dist/exchanges/kalshi/fetchOrderBook.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOrderBook = fetchOrderBook;
+const axios_1 = __importDefault(require("axios"));
+const validation_1 = require("../../utils/validation");
+const errors_1 = require("./errors");
+const config_1 = require("./config");
+async function fetchOrderBook(baseUrl, id) {
+    (0, validation_1.validateIdFormat)(id, "OrderBook");
+    try {
+        // Check if this is a NO outcome request
+        const isNoOutcome = id.endsWith("-NO");
+        const ticker = id.replace(/-NO$/, "");
+        const url = (0, config_1.getMarketsUrl)(baseUrl, ticker, ["orderbook"]);
+        const response = await axios_1.default.get(url);
+        const data = response.data.orderbook;
+        // Structure: { yes: [[price, qty], ...], no: [[price, qty], ...] }
+        // Kalshi returns bids at their actual prices (not inverted)
+        // - yes: bids for buying YES at price X
+        // - no: bids for buying NO at price X
+        let bids;
+        let asks;
+        if (isNoOutcome) {
+            // NO outcome order book:
+            // - Bids: people buying NO (use data.no directly)
+            // - Asks: people selling NO = people buying YES (invert data.yes)
+            bids = (data.no || []).map((level) => ({
+                price: level[0] / 100,
+                size: level[1],
+            }));
+            asks = (data.yes || []).map((level) => ({
+                price: 1 - level[0] / 100, // Invert YES price to get NO ask price
+                size: level[1],
+            }));
+        }
+        else {
+            // YES outcome order book:
+            // - Bids: people buying YES (use data.yes directly)
+            // - Asks: people selling YES = people buying NO (invert data.no)
+            bids = (data.yes || []).map((level) => ({
+                price: level[0] / 100,
+                size: level[1],
+            }));
+            asks = (data.no || []).map((level) => ({
+                price: 1 - level[0] / 100, // Invert NO price to get YES ask price
+                size: level[1],
+            }));
+        }
+        // Sort bids desc, asks asc
+        bids.sort((a, b) => b.price - a.price);
+        asks.sort((a, b) => a.price - b.price);
+        return { bids, asks, timestamp: Date.now() };
+    }
+    catch (error) {
+        throw errors_1.kalshiErrorMapper.mapError(error);
+    }
+}

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

@@ -0,0 +1,3 @@
+import { HistoryFilterParams, TradesParams } from "../../BaseExchange";
+import { Trade } from "../../types";
+export declare function fetchTrades(baseUrl: string, id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;

package/dist/exchanges/kalshi/fetchTrades.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTrades = fetchTrades;
+const axios_1 = __importDefault(require("axios"));
+const errors_1 = require("./errors");
+const config_1 = require("./config");
+async function fetchTrades(baseUrl, id, params) {
+    try {
+        const ticker = id.replace(/-NO$/, "");
+        const url = (0, config_1.getMarketsUrl)(baseUrl, undefined, ["trades"]);
+        const response = await axios_1.default.get(url, {
+            params: {
+                ticker: ticker,
+                limit: params.limit || 100,
+            },
+        });
+        const trades = response.data.trades || [];
+        return trades.map((t) => ({
+            id: t.trade_id,
+            timestamp: new Date(t.created_time).getTime(),
+            price: t.yes_price / 100,
+            amount: t.count,
+            side: t.taker_side === "yes" ? "buy" : "sell",
+        }));
+    }
+    catch (error) {
+        throw errors_1.kalshiErrorMapper.mapError(error);
+    }
+}

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

@@ -1,11 +1,15 @@
-import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, OHLCVParams, TradesParams, ExchangeCredentials, EventFetchParams } from '../../BaseExchange';
-import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, Balance, Order, Position, CreateOrderParams } from '../../types';
-import { KalshiWebSocketConfig } from './websocket';
+import { PredictionMarketExchange, MarketFilterParams, HistoryFilterParams, OHLCVParams, TradesParams, ExchangeCredentials, EventFetchParams, MyTradesParams, OrderHistoryParams } from "../../BaseExchange";
+import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, UserTrade, Balance, Order, Position, CreateOrderParams, BuiltOrder } from "../../types";
+import { KalshiWebSocketConfig } from "./websocket";
 export type { KalshiWebSocketConfig };
 export interface KalshiExchangeOptions {
     credentials?: ExchangeCredentials;
     websocket?: KalshiWebSocketConfig;
 }
+/** @internal */
+export interface KalshiInternalOptions extends KalshiExchangeOptions {
+    demoMode?: boolean;
+}
 export declare class KalshiExchange extends PredictionMarketExchange {
     readonly has: {
         fetchMarkets: true;
@@ -21,9 +25,15 @@ export declare class KalshiExchange extends PredictionMarketExchange {
         fetchBalance: true;
         watchOrderBook: true;
         watchTrades: true;
+        fetchMyTrades: true;
+        fetchClosedOrders: true;
+        fetchAllOrders: true;
+        buildOrder: true;
+        submitOrder: true;
     };
     private auth?;
     private wsConfig?;
+    private config;
     constructor(options?: ExchangeCredentials | KalshiExchangeOptions);
     get name(): string;
     protected sign(method: string, path: string, _params: Record<string, any>): Record<string, string>;
@@ -31,15 +41,21 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     private ensureAuth;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;
-    fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams): Promise<PriceCandle[]>;
+    fetchOHLCV(id: string, params: OHLCVParams): Promise<PriceCandle[]>;
     fetchOrderBook(id: string): Promise<OrderBook>;
     fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
     fetchBalance(): Promise<Balance[]>;
+    buildOrder(params: CreateOrderParams): Promise<BuiltOrder>;
+    submitOrder(built: BuiltOrder): Promise<Order>;
     createOrder(params: CreateOrderParams): Promise<Order>;
     cancelOrder(orderId: string): Promise<Order>;
     fetchOrder(orderId: string): Promise<Order>;
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
+    fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
+    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

@@ -12,6 +12,7 @@ const errors_1 = require("./errors");
 const errors_2 = require("../../errors");
 const openapi_1 = require("../../utils/openapi");
 const api_1 = require("./api");
+const config_1 = require("./config");
 class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
     has = {
         fetchMarkets: true,
@@ -27,28 +28,38 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
         fetchBalance: true,
         watchOrderBook: true,
         watchTrades: true,
+        fetchMyTrades: true,
+        fetchClosedOrders: true,
+        fetchAllOrders: true,
+        buildOrder: true,
+        submitOrder: true,
     };
     auth;
     wsConfig;
+    config;
     constructor(options) {
         // Support both old signature (credentials only) and new signature (options object)
         let credentials;
         let wsConfig;
-        if (options && 'credentials' in options) {
-            // New signature: KalshiExchangeOptions
+        let demoMode = false;
+        if (options && "credentials" in options) {
+            // New signature: KalshiExchangeOptions / KalshiInternalOptions
             credentials = options.credentials;
             wsConfig = options.websocket;
+            demoMode = options.demoMode || false;
         }
         else {
             // Old signature: ExchangeCredentials directly
             credentials = options;
         }
         super(credentials);
+        this.rateLimit = 100;
         this.wsConfig = wsConfig;
+        this.config = (0, config_1.getKalshiConfig)(demoMode);
         if (credentials?.apiKey && credentials?.privateKey) {
             this.auth = new auth_1.KalshiAuth(credentials);
         }
-        const descriptor = (0, openapi_1.parseOpenApiSpec)(api_1.kalshiApiSpec);
+        const descriptor = (0, openapi_1.parseOpenApiSpec)(api_1.kalshiApiSpec, this.config.apiUrl + config_1.KALSHI_PATHS.TRADE_API);
         this.defineImplicitApi(descriptor);
     }
     get name() {
@@ -61,7 +72,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
         const auth = this.ensureAuth();
         // The implicit API passes just the spec path (e.g. /portfolio/balance),
         // but Kalshi's signature requires the full path including /trade-api/v2.
-        return auth.getHeaders(method, '/trade-api/v2' + path);
+        return auth.getHeaders(method, "/trade-api/v2" + path);
     }
     mapImplicitApiError(error) {
         throw errors_1.kalshiErrorMapper.mapError(error);
@@ -71,8 +82,8 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
     // ----------------------------------------------------------------------------
     ensureAuth() {
         if (!this.auth) {
-            throw new errors_2.AuthenticationError('Trading operations require authentication. ' +
-                'Initialize KalshiExchange with credentials (apiKey and privateKey).', 'Kalshi');
+            throw new errors_2.AuthenticationError("Trading operations require authentication. " +
+                "Initialize KalshiExchange with credentials (apiKey and privateKey).", "Kalshi");
         }
         return this.auth;
     }
@@ -89,10 +100,11 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
         return (0, fetchOHLCV_1.fetchOHLCV)(id, params, this.callApi.bind(this));
     }
     async fetchOrderBook(id) {
-        (0, validation_1.validateIdFormat)(id, 'OrderBook');
-        const isNoOutcome = id.endsWith('-NO');
-        const ticker = id.replace(/-NO$/, '');
-        const data = (await this.callApi('GetMarketOrderbook', { ticker })).orderbook;
+        (0, validation_1.validateIdFormat)(id, "OrderBook");
+        const isNoOutcome = id.endsWith("-NO");
+        const ticker = id.replace(/-NO$/, "");
+        const data = (await this.callApi("GetMarketOrderbook", { ticker }))
+            .orderbook;
         let bids;
         let asks;
         if (isNoOutcome) {
@@ -101,7 +113,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
                 size: level[1],
             }));
             asks = (data.yes || []).map((level) => ({
-                price: 1 - (level[0] / 100),
+                price: 1 - level[0] / 100,
                 size: level[1],
             }));
         }
@@ -111,7 +123,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
                 size: level[1],
             }));
             asks = (data.no || []).map((level) => ({
-                price: 1 - (level[0] / 100),
+                price: 1 - level[0] / 100,
                 size: level[1],
             }));
         }
@@ -120,129 +132,172 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
         return { bids, asks, timestamp: Date.now() };
     }
     async fetchTrades(id, params) {
-        if ('resolution' in params && params.resolution !== undefined) {
+        if ("resolution" in params && params.resolution !== undefined) {
             console.warn('[pmxt] Warning: The "resolution" parameter is deprecated for fetchTrades() and will be ignored. ' +
-                'It will be removed in v3.0.0. Please remove it from your code.');
+                "It will be removed in v3.0.0. Please remove it from your code.");
         }
-        const ticker = id.replace(/-NO$/, '');
-        const data = await this.callApi('GetTrades', { ticker, limit: params.limit || 100 });
+        const ticker = id.replace(/-NO$/, "");
+        const data = await this.callApi("GetTrades", {
+            ticker,
+            limit: params.limit || 100,
+        });
         const trades = data.trades || [];
         return trades.map((t) => ({
             id: t.trade_id,
             timestamp: new Date(t.created_time).getTime(),
             price: t.yes_price / 100,
             amount: t.count,
-            side: t.taker_side === 'yes' ? 'buy' : 'sell',
+            side: t.taker_side === "yes" ? "buy" : "sell",
         }));
     }
     // ----------------------------------------------------------------------------
     // User Data Methods
     // ----------------------------------------------------------------------------
     async fetchBalance() {
-        const data = await this.callApi('GetBalance');
+        const data = await this.callApi("GetBalance");
         const available = data.balance / 100;
         const total = data.portfolio_value / 100;
-        return [{
-                currency: 'USD',
+        return [
+            {
+                currency: "USD",
                 total,
                 available,
                 locked: total - available,
-            }];
+            },
+        ];
     }
     // ----------------------------------------------------------------------------
     // Trading Methods
     // ----------------------------------------------------------------------------
-    async createOrder(params) {
-        const isYesSide = params.side === 'buy';
-        const kalshiOrder = {
+    async buildOrder(params) {
+        const isYesSide = params.side === "buy";
+        const body = {
             ticker: params.marketId,
             client_order_id: `pmxt-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-            side: isYesSide ? 'yes' : 'no',
-            action: params.side === 'buy' ? 'buy' : 'sell',
+            side: isYesSide ? "yes" : "no",
+            action: params.side === "buy" ? "buy" : "sell",
             count: params.amount,
-            type: params.type === 'limit' ? 'limit' : 'market',
+            type: params.type === "limit" ? "limit" : "market",
         };
         if (params.price) {
             const priceInCents = Math.round(params.price * 100);
             if (isYesSide) {
-                kalshiOrder.yes_price = priceInCents;
+                body.yes_price = priceInCents;
             }
             else {
-                kalshiOrder.no_price = priceInCents;
+                body.no_price = priceInCents;
             }
         }
-        const data = await this.callApi('CreateOrder', kalshiOrder);
-        const order = 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(),
+            exchange: this.name,
+            params,
+            raw: body,
         };
     }
+    async submitOrder(built) {
+        const data = await this.callApi("CreateOrder", built.raw);
+        return this.mapKalshiOrder(data.order);
+    }
+    async createOrder(params) {
+        const built = await this.buildOrder(params);
+        return this.submitOrder(built);
+    }
     async cancelOrder(orderId) {
-        const data = await this.callApi('CancelOrder', { order_id: orderId });
+        const data = await this.callApi("CancelOrder", { 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: 'limit',
+            side: order.side === "yes" ? "buy" : "sell",
+            type: "limit",
             amount: order.count,
-            status: 'cancelled',
+            status: "cancelled",
             filled: order.count - (order.remaining_count || 0),
             remaining: 0,
             timestamp: new Date(order.created_time).getTime(),
         };
     }
     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(),
-        };
+        const data = await this.callApi("GetOrder", { order_id: orderId });
+        return this.mapKalshiOrder(data.order);
     }
     async fetchOpenOrders(marketId) {
-        const queryParams = { status: 'resting' };
+        const queryParams = { status: "resting" };
         if (marketId) {
             queryParams.ticker = marketId;
         }
-        const data = await this.callApi('GetOrders', queryParams);
+        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 data = await this.callApi("GetPositions");
         const positions = data.market_positions || [];
         return positions.map((pos) => {
             const absPosition = Math.abs(pos.position);
@@ -259,19 +314,35 @@ 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()) {
-            case 'resting':
-                return 'open';
-            case 'canceled':
-            case 'cancelled':
-                return 'cancelled';
-            case 'executed':
-            case 'filled':
-                return 'filled';
+        switch ((status ?? "").toLowerCase()) {
+            case "resting":
+                return "open";
+            case "canceled":
+            case "cancelled":
+                return "cancelled";
+            case "executed":
+            case "filled":
+                return "filled";
             default:
-                return 'open';
+                return "open";
         }
     }
     // ----------------------------------------------------------------------------
@@ -281,19 +352,29 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
     async watchOrderBook(id, limit) {
         const auth = this.ensureAuth();
         if (!this.ws) {
-            this.ws = new websocket_1.KalshiWebSocket(auth, this.wsConfig);
+            // Merge wsConfig with wsUrl from config
+            const wsConfigWithUrl = {
+                ...this.wsConfig,
+                wsUrl: this.wsConfig?.wsUrl || this.config.wsUrl,
+            };
+            this.ws = new websocket_1.KalshiWebSocket(auth, wsConfigWithUrl);
         }
         // Normalize ticker (strip -NO suffix if present)
-        const marketTicker = id.replace(/-NO$/, '');
+        const marketTicker = id.replace(/-NO$/, "");
         return this.ws.watchOrderBook(marketTicker);
     }
     async watchTrades(id, since, limit) {
         const auth = this.ensureAuth();
         if (!this.ws) {
-            this.ws = new websocket_1.KalshiWebSocket(auth, this.wsConfig);
+            // Merge wsConfig with wsUrl from config
+            const wsConfigWithUrl = {
+                ...this.wsConfig,
+                wsUrl: this.wsConfig?.wsUrl || this.config.wsUrl,
+            };
+            this.ws = new websocket_1.KalshiWebSocket(auth, wsConfigWithUrl);
         }
         // Normalize ticker (strip -NO suffix if present)
-        const marketTicker = id.replace(/-NO$/, '');
+        const marketTicker = id.replace(/-NO$/, "");
         return this.ws.watchTrades(marketTicker);
     }
     async close() {