pmxt-core 2.20.0 → 2.20.2

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

@@ -36,6 +36,8 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     private auth?;
     private wsConfig?;
     private config;
+    private readonly fetcher;
+    private readonly normalizer;
     constructor(options?: ExchangeCredentials | KalshiExchangeOptions);
     get name(): string;
     protected sign(method: string, path: string, _params: Record<string, any>): Record<string, string>;
@@ -47,18 +49,16 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     fetchOrderBook(id: string): Promise<OrderBook>;
     fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
     fetchBalance(): Promise<Balance[]>;
+    fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
+    fetchPositions(): Promise<Position[]>;
+    fetchClosedOrders(params?: OrderHistoryParams): Promise<Order[]>;
+    fetchAllOrders(params?: OrderHistoryParams): Promise<Order[]>;
     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>;
     watchTrades(id: string, address?: string, since?: number, limit?: number): Promise<Trade[]>;

package/dist/exchanges/kalshi/index.js

@@ -2,9 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KalshiExchange = void 0;
 const BaseExchange_1 = require("../../BaseExchange");
-const fetchMarkets_1 = require("./fetchMarkets");
-const fetchEvents_1 = require("./fetchEvents");
-const fetchOHLCV_1 = require("./fetchOHLCV");
 const auth_1 = require("./auth");
 const validation_1 = require("../../utils/validation");
 const websocket_1 = require("./websocket");
@@ -13,7 +10,8 @@ const errors_2 = require("../../errors");
 const openapi_1 = require("../../utils/openapi");
 const api_1 = require("./api");
 const config_1 = require("./config");
-const price_1 = require("./price");
+const fetcher_1 = require("./fetcher");
+const normalizer_1 = require("./normalizer");
 class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
     has = {
         fetchMarkets: true,
@@ -40,19 +38,18 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
     auth;
     wsConfig;
     config;
+    fetcher;
+    normalizer;
     constructor(options) {
-        // Support both old signature (credentials only) and new signature (options object)
         let credentials;
         let wsConfig;
         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);
@@ -64,6 +61,13 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
         }
         const descriptor = (0, openapi_1.parseOpenApiSpec)(api_1.kalshiApiSpec, this.config.apiUrl + config_1.KALSHI_PATHS.TRADE_API);
         this.defineImplicitApi(descriptor);
+        const ctx = {
+            http: this.http,
+            callApi: this.callApi.bind(this),
+            getHeaders: () => ({}),
+        };
+        this.fetcher = new fetcher_1.KalshiFetcher(ctx);
+        this.normalizer = new normalizer_1.KalshiNormalizer();
     }
     get name() {
         return "Kalshi";
@@ -73,16 +77,11 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
     // ----------------------------------------------------------------------------
     sign(method, path, _params) {
         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);
     }
     mapImplicitApiError(error) {
         throw errors_1.kalshiErrorMapper.mapError(error);
     }
-    // ----------------------------------------------------------------------------
-    // Helpers
-    // ----------------------------------------------------------------------------
     ensureAuth() {
         if (!this.auth) {
             throw new errors_2.AuthenticationError("Trading operations require authentication. " +
@@ -91,86 +90,128 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
         return this.auth;
     }
     // ----------------------------------------------------------------------------
-    // Market Data Methods - Implementation for CCXT-style API
+    // Market Data  (fetcher -> normalizer)
     // ----------------------------------------------------------------------------
     async fetchMarketsImpl(params) {
-        return (0, fetchMarkets_1.fetchMarkets)(params, this.callApi.bind(this));
+        const rawEvents = await this.fetcher.fetchRawMarkets(params);
+        const allMarkets = [];
+        for (const event of rawEvents) {
+            const markets = this.normalizer.normalizeMarketsFromEvent(event);
+            allMarkets.push(...markets);
+        }
+        // Query-based search (client-side filtering)
+        if (params?.query) {
+            const lowerQuery = params.query.toLowerCase();
+            const searchIn = params?.searchIn || 'title';
+            const filtered = allMarkets.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;
+            });
+            return filtered.slice(0, params?.limit || 250000);
+        }
+        // Client-side sort
+        if (params?.sort === 'volume') {
+            allMarkets.sort((a, b) => b.volume24h - a.volume24h);
+        }
+        else if (params?.sort === 'liquidity') {
+            allMarkets.sort((a, b) => b.liquidity - a.liquidity);
+        }
+        const offset = params?.offset || 0;
+        const limit = params?.limit || 250000;
+        return allMarkets.slice(offset, offset + limit);
     }
     async fetchEventsImpl(params) {
-        return (0, fetchEvents_1.fetchEvents)(params, this.callApi.bind(this));
+        const rawEvents = await this.fetcher.fetchRawEvents(params);
+        const limit = params?.limit || 10000;
+        const query = (params?.query || '').toLowerCase();
+        const filtered = query
+            ? rawEvents.filter((event) => (event.title || '').toLowerCase().includes(query))
+            : rawEvents;
+        const sort = params?.sort || 'volume';
+        const sorted = (0, normalizer_1.sortRawEvents)(filtered, sort);
+        return sorted
+            .map((raw) => this.normalizer.normalizeEvent(raw))
+            .filter((e) => e !== null)
+            .slice(0, limit);
     }
     async fetchOHLCV(id, params) {
-        return (0, fetchOHLCV_1.fetchOHLCV)(id, params, this.callApi.bind(this));
+        const rawCandles = await this.fetcher.fetchRawOHLCV(id, params);
+        return this.normalizer.normalizeOHLCV(rawCandles, params);
     }
     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_fp;
-        let bids;
-        let asks;
-        if (isNoOutcome) {
-            bids = (data.no_dollars || []).map((level) => ({
-                price: parseFloat(level[0]),
-                size: parseFloat(level[1]),
-            }));
-            asks = (data.yes_dollars || []).map((level) => ({
-                price: Math.round((1 - parseFloat(level[0])) * 10000) / 10000,
-                size: parseFloat(level[1]),
-            }));
-        }
-        else {
-            bids = (data.yes_dollars || []).map((level) => ({
-                price: parseFloat(level[0]),
-                size: parseFloat(level[1]),
-            }));
-            asks = (data.no_dollars || []).map((level) => ({
-                price: Math.round((1 - parseFloat(level[0])) * 10000) / 10000,
-                size: parseFloat(level[1]),
-            }));
-        }
-        bids.sort((a, b) => b.price - a.price);
-        asks.sort((a, b) => a.price - b.price);
-        return { bids, asks, timestamp: Date.now() };
+        const raw = await this.fetcher.fetchRawOrderBook(id);
+        return this.normalizer.normalizeOrderBook(raw, id);
     }
     async fetchTrades(id, params) {
         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.");
         }
-        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: (0, price_1.fromKalshiCents)(t.yes_price),
-            amount: t.count,
-            side: t.taker_side === "yes" ? "buy" : "sell",
-        }));
+        const rawTrades = await this.fetcher.fetchRawTrades(id, params);
+        return rawTrades.map((raw, i) => this.normalizer.normalizeTrade(raw, i));
     }
     // ----------------------------------------------------------------------------
-    // User Data Methods
+    // User Data  (fetcher -> normalizer)
     // ----------------------------------------------------------------------------
     async fetchBalance() {
-        const data = await this.callApi("GetBalance");
-        const available = data.balance / 100;
-        const total = data.portfolio_value / 100;
-        return [
-            {
-                currency: "USD",
-                total,
-                available,
-                locked: total - available,
-            },
-        ];
+        const raw = await this.fetcher.fetchRawBalance();
+        return this.normalizer.normalizeBalance(raw);
+    }
+    async fetchMyTrades(params) {
+        const rawFills = await this.fetcher.fetchRawMyTrades(params || {});
+        return rawFills.map((raw, i) => this.normalizer.normalizeUserTrade(raw, i));
+    }
+    async fetchPositions() {
+        const rawPositions = await this.fetcher.fetchRawPositions();
+        return rawPositions.map((raw) => this.normalizer.normalizePosition(raw));
+    }
+    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 rawOrders = await this.fetcher.fetchRawHistoricalOrders(queryParams);
+        return rawOrders.map((o) => this.normalizer.normalizeOrder(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;
+        const [liveOrders, historicalOrders] = await Promise.all([
+            this.fetcher.fetchRawOrders(queryParams),
+            this.fetcher.fetchRawHistoricalOrders(historicalParams),
+        ]);
+        const seen = new Set();
+        const all = [];
+        for (const o of [...liveOrders, ...historicalOrders]) {
+            if (!seen.has(o.order_id)) {
+                seen.add(o.order_id);
+                all.push(this.normalizer.normalizeOrder(o));
+            }
+        }
+        return all.sort((a, b) => b.timestamp - a.timestamp);
     }
     // ----------------------------------------------------------------------------
-    // Trading Methods
+    // Trading
     // ----------------------------------------------------------------------------
     async buildOrder(params) {
         const isYesSide = params.side === "buy";
@@ -191,15 +232,11 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
                 body.no_price = priceInCents;
             }
         }
-        return {
-            exchange: this.name,
-            params,
-            raw: body,
-        };
+        return { exchange: this.name, params, raw: body };
     }
     async submitOrder(built) {
         const data = await this.callApi("CreateOrder", built.raw);
-        return this.mapKalshiOrder(data.order);
+        return this.normalizer.normalizeOrder(data.order);
     }
     async createOrder(params) {
         const built = await this.buildOrder(params);
@@ -223,160 +260,40 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
     }
     async fetchOrder(orderId) {
         const data = await this.callApi("GetOrder", { order_id: orderId });
-        return this.mapKalshiOrder(data.order);
+        return this.normalizer.normalizeOrder(data.order);
     }
     async fetchOpenOrders(marketId) {
         const queryParams = { status: "resting" };
-        if (marketId) {
+        if (marketId)
             queryParams.ticker = marketId;
-        }
-        const data = await this.callApi("GetOrders", queryParams);
-        const orders = data.orders || [];
-        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: (0, price_1.fromKalshiCents)(f.yes_price),
-            amount: f.count,
-            side: f.side === "yes" ? "buy" : "sell",
-            orderId: f.order_id,
-        }));
-    }
-    async fetchClosedOrders(params) {
-        const queryParams = {};
-        if (params?.marketId)
-            queryParams.ticker = params.marketId;
-        if (params?.until)
-            queryParams.max_ts = Math.floor(params.until.getTime() / 1000);
-        if (params?.limit)
-            queryParams.limit = params.limit;
-        if (params?.cursor)
-            queryParams.cursor = params.cursor;
-        const data = await this.callApi("GetHistoricalOrders", queryParams);
-        return (data.orders || []).map((o) => this.mapKalshiOrder(o));
-    }
-    async fetchAllOrders(params) {
-        const queryParams = {};
-        if (params?.marketId)
-            queryParams.ticker = params.marketId;
-        if (params?.since)
-            queryParams.min_ts = Math.floor(params.since.getTime() / 1000);
-        if (params?.until)
-            queryParams.max_ts = Math.floor(params.until.getTime() / 1000);
-        if (params?.limit)
-            queryParams.limit = params.limit;
-        const historicalParams = { ...queryParams };
-        delete historicalParams.min_ts; // GetHistoricalOrders only supports max_ts
-        const [liveData, historicalData] = await Promise.all([
-            this.callApi("GetOrders", queryParams),
-            this.callApi("GetHistoricalOrders", historicalParams),
-        ]);
-        const seen = new Set();
-        const all = [];
-        for (const o of [
-            ...(liveData.orders || []),
-            ...(historicalData.orders || []),
-        ]) {
-            if (!seen.has(o.order_id)) {
-                seen.add(o.order_id);
-                all.push(this.mapKalshiOrder(o));
-            }
-        }
-        return all.sort((a, b) => b.timestamp - a.timestamp);
-    }
-    async fetchPositions() {
-        const data = await this.callApi("GetPositions");
-        const positions = data.market_positions || [];
-        return positions.map((pos) => {
-            const absPosition = Math.abs(pos.position);
-            const entryPrice = absPosition > 0 ? pos.total_cost / absPosition / 100 : 0;
-            return {
-                marketId: pos.ticker,
-                outcomeId: pos.ticker,
-                outcomeLabel: pos.ticker,
-                size: pos.position,
-                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,
-            };
-        });
-    }
-    // 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";
-            default:
-                return "open";
-        }
+        const rawOrders = await this.fetcher.fetchRawOrders(queryParams);
+        return rawOrders.map((o) => this.normalizer.normalizeOrder(o));
     }
     // ----------------------------------------------------------------------------
-    // WebSocket Methods
+    // WebSocket
     // ----------------------------------------------------------------------------
     ws;
     async watchOrderBook(id, limit) {
         const auth = this.ensureAuth();
         if (!this.ws) {
-            // 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$/, "");
         return this.ws.watchOrderBook(marketTicker);
     }
     async watchTrades(id, address, since, limit) {
         const auth = this.ensureAuth();
         if (!this.ws) {
-            // 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$/, "");
         return this.ws.watchTrades(marketTicker);
     }

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

@@ -0,0 +1,25 @@
+import { OHLCVParams } from '../../BaseExchange';
+import { UnifiedMarket, UnifiedEvent, PriceCandle, OrderBook, Trade, UserTrade, Position, Balance } from '../../types';
+import { IExchangeNormalizer } from '../interfaces';
+import { KalshiRawEvent, KalshiRawMarket, KalshiRawCandlestick, KalshiRawTrade, KalshiRawFill, KalshiRawOrder, KalshiRawPosition, KalshiRawOrderBookFp } from './fetcher';
+export declare class KalshiNormalizer implements IExchangeNormalizer<KalshiRawEvent, KalshiRawEvent> {
+    normalizeMarket(raw: KalshiRawEvent): UnifiedMarket | null;
+    normalizeMarketsFromEvent(rawEvent: KalshiRawEvent): UnifiedMarket[];
+    normalizeRawMarket(event: KalshiRawEvent, market: KalshiRawMarket): UnifiedMarket | null;
+    normalizeEvent(raw: KalshiRawEvent): UnifiedEvent | null;
+    normalizeOHLCV(rawCandles: KalshiRawCandlestick[], params: OHLCVParams): PriceCandle[];
+    normalizeOrderBook(raw: {
+        orderbook_fp: KalshiRawOrderBookFp;
+    }, id: string): OrderBook;
+    normalizeTrade(raw: KalshiRawTrade, _index: number): Trade;
+    normalizeUserTrade(raw: KalshiRawFill, _index: number): UserTrade;
+    normalizeOrder(raw: KalshiRawOrder): import('../../types').Order;
+    normalizePosition(raw: KalshiRawPosition): Position;
+    normalizeBalance(raw: {
+        balance: number;
+        portfolio_value: number;
+    }): Balance[];
+    private mapOrderStatus;
+    private deriveEventDescription;
+}
+export declare function sortRawEvents(events: any[], sort: string): any[];