pmxt-core 2.9.2 → 2.9.3

package/dist/exchanges/kalshi/config.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Kalshi runtime configuration.
+ *
+ * This file is hand-authored and is the single source of truth for:
+ *  - Base URL constants for production and demo environments
+ *  - API path constants (KALSHI_PATHS)
+ *  - URL helper functions used by fetch functions and the exchange class
+ *
+ * The OpenAPI spec lives in core/specs/kalshi/Kalshi.yaml and is compiled
+ * into core/src/exchanges/kalshi/api.ts by `npm run fetch:openapi`.
+ * Do NOT put runtime config into api.ts — it will be overwritten.
+ *
+ * Environment mapping (aligns with the `{env}` server variable in Kalshi.yaml):
+ *   env = "api"      → production:  https://api.elections.kalshi.com
+ *   env = "demo-api" → demo/paper:  https://demo-api.elections.kalshi.com
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KALSHI_PATHS = exports.KALSHI_DEMO_WS_URL = exports.KALSHI_PROD_WS_URL = exports.KALSHI_DEMO_API_URL = exports.KALSHI_PROD_API_URL = void 0;
+exports.getKalshiConfig = getKalshiConfig;
+exports.getApiPath = getApiPath;
+exports.getEventsUrl = getEventsUrl;
+exports.getSeriesUrl = getSeriesUrl;
+exports.getPortfolioUrl = getPortfolioUrl;
+exports.getMarketsUrl = getMarketsUrl;
+// ── Base URL constants ────────────────────────────────────────────────────────
+exports.KALSHI_PROD_API_URL = "https://api.elections.kalshi.com";
+exports.KALSHI_DEMO_API_URL = "https://demo-api.kalshi.co";
+exports.KALSHI_PROD_WS_URL = "wss://api.elections.kalshi.com/trade-api/ws/v2";
+exports.KALSHI_DEMO_WS_URL = "wss://demo-api.kalshi.co/trade-api/ws/v2";
+// ── Path constants ────────────────────────────────────────────────────────────
+exports.KALSHI_PATHS = {
+    TRADE_API: "/trade-api/v2",
+    EVENTS: "/events",
+    SERIES: "/series",
+    PORTFOLIO: "/portfolio",
+    MARKETS: "/markets",
+    BALANCE: "/balance",
+    ORDERS: "/orders",
+    POSITIONS: "/positions",
+};
+/**
+ * Return a typed config object for the requested environment.
+ *
+ * @param demoMode - Pass `true` to target demo-api.elections.kalshi.com.
+ *
+ * @example
+ * ```typescript
+ * const config = getKalshiConfig(true);
+ * // config.apiUrl === "https://demo-api.elections.kalshi.com"
+ * ```
+ */
+function getKalshiConfig(demoMode = false) {
+    return {
+        apiUrl: demoMode ? exports.KALSHI_DEMO_API_URL : exports.KALSHI_PROD_API_URL,
+        wsUrl: demoMode ? exports.KALSHI_DEMO_WS_URL : exports.KALSHI_PROD_WS_URL,
+        demoMode,
+    };
+}
+// ── URL builder helpers ───────────────────────────────────────────────────────
+/**
+ * Build a full URL from a base and an arbitrary list of path segments.
+ * Empty segments are filtered out; leading/trailing slashes are normalised.
+ */
+function buildApiUrl(baseUrl, ...segments) {
+    const flatSegments = segments.flat().filter(Boolean);
+    const path = flatSegments.map((s) => s.replace(/^\/+|\/+$/g, "")).join("/");
+    return path ? `${baseUrl}/${path}` : baseUrl;
+}
+/**
+ * Build the full path (including `/trade-api/v2` prefix) for use in
+ * `KalshiAuth.getHeaders()` signing.
+ *
+ * @example
+ * ```typescript
+ * getApiPath("/portfolio/balance")
+ * // → "/trade-api/v2/portfolio/balance"
+ * ```
+ */
+function getApiPath(operationPath) {
+    return exports.KALSHI_PATHS.TRADE_API + operationPath;
+}
+/**
+ * Build the full URL for the events endpoint.
+ *
+ * @example
+ * ```typescript
+ * getEventsUrl(baseUrl)              // .../events
+ * getEventsUrl(baseUrl, ['FED-25'])  // .../events/FED-25
+ * ```
+ */
+function getEventsUrl(baseUrl, pathSegments = []) {
+    return buildApiUrl(baseUrl, exports.KALSHI_PATHS.TRADE_API, exports.KALSHI_PATHS.EVENTS, pathSegments);
+}
+/**
+ * Build the full URL for the series endpoint, with optional nested segments.
+ *
+ * @example
+ * ```typescript
+ * getSeriesUrl(baseUrl)                                            // .../series
+ * getSeriesUrl(baseUrl, 'FED')                                    // .../series/FED
+ * getSeriesUrl(baseUrl, 'FED', ['markets', 'FED-B4.75', 'candlesticks'])
+ * // .../series/FED/markets/FED-B4.75/candlesticks
+ * ```
+ */
+function getSeriesUrl(baseUrl, seriesTicker, pathSegments = []) {
+    const segments = [
+        exports.KALSHI_PATHS.TRADE_API,
+        exports.KALSHI_PATHS.SERIES,
+        seriesTicker || "",
+        ...pathSegments,
+    ];
+    return buildApiUrl(baseUrl, ...segments);
+}
+/**
+ * Build the full URL for the portfolio endpoint.
+ *
+ * @example
+ * ```typescript
+ * getPortfolioUrl(baseUrl, '/balance')  // .../portfolio/balance
+ * ```
+ */
+function getPortfolioUrl(baseUrl, subPath) {
+    return buildApiUrl(baseUrl, exports.KALSHI_PATHS.TRADE_API, exports.KALSHI_PATHS.PORTFOLIO, subPath || "");
+}
+/**
+ * Build the full URL for the markets endpoint, with optional nested segments.
+ *
+ * @example
+ * ```typescript
+ * getMarketsUrl(baseUrl)                               // .../markets
+ * getMarketsUrl(baseUrl, 'FED-B4.75')                  // .../markets/FED-B4.75
+ * getMarketsUrl(baseUrl, 'FED-B4.75', ['orderbook'])   // .../markets/FED-B4.75/orderbook
+ * ```
+ */
+function getMarketsUrl(baseUrl, marketId, pathSegments = []) {
+    const segments = [
+        exports.KALSHI_PATHS.TRADE_API,
+        exports.KALSHI_PATHS.MARKETS,
+        marketId || "",
+        ...pathSegments,
+    ];
+    return buildApiUrl(baseUrl, ...segments);
+}

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

@@ -1,5 +1,5 @@
-import { EventFetchParams } from '../../BaseExchange';
-import { UnifiedEvent } from '../../types';
+import { EventFetchParams } from "../../BaseExchange";
+import { UnifiedEvent } from "../../types";
 type CallApi = (operationId: string, params?: Record<string, any>) => Promise<any>;
 export declare function fetchEvents(params: EventFetchParams, callApi: CallApi): Promise<UnifiedEvent[]>;
 export {};

package/dist/exchanges/kalshi/fetchEvents.js

@@ -5,7 +5,10 @@ const utils_1 = require("./utils");
 const errors_1 = require("./errors");
 async function fetchEventByTicker(eventTicker, callApi) {
     const normalizedTicker = eventTicker.toUpperCase();
-    const data = await callApi('GetEvent', { event_ticker: normalizedTicker, with_nested_markets: true });
+    const data = await callApi("GetEvent", {
+        event_ticker: normalizedTicker,
+        with_nested_markets: true,
+    });
     const event = data.event;
     if (!event)
         return [];
@@ -21,16 +24,102 @@ async function fetchEventByTicker(eventTicker, callApi) {
     const unifiedEvent = {
         id: event.event_ticker,
         title: event.title,
-        description: event.mututals_description || "",
+        description: event.mututals_description || deriveEventDescription(event.markets || []),
         slug: event.event_ticker,
         markets: markets,
+        volume24h: markets.reduce((sum, m) => sum + m.volume24h, 0),
+        volume: markets.some(m => m.volume !== undefined) ? markets.reduce((sum, m) => sum + (m.volume ?? 0), 0) : undefined,
         url: `https://kalshi.com/events/${event.event_ticker}`,
         image: event.image_url,
         category: event.category,
-        tags: event.tags || []
+        tags: event.tags || [],
     };
     return [unifiedEvent];
 }
+const PLACEHOLDERS = ["{x}", "{y}", "{z}"];
+function deriveEventDescription(markets) {
+    const texts = markets
+        .map((m) => m.rules_primary)
+        .filter((t) => typeof t === "string" && t.length > 0);
+    if (texts.length === 0)
+        return "";
+    if (texts.length === 1)
+        return texts[0];
+    // Find longest common prefix
+    let prefix = texts[0];
+    for (const t of texts) {
+        while (!t.startsWith(prefix))
+            prefix = prefix.slice(0, -1);
+        if (!prefix)
+            break;
+    }
+    // Find longest common suffix (on the part after the prefix)
+    const suffixCandidates = texts.map((t) => t.slice(prefix.length));
+    let suffix = suffixCandidates[0];
+    for (const t of suffixCandidates) {
+        while (!t.endsWith(suffix))
+            suffix = suffix.slice(1);
+        if (!suffix)
+            break;
+    }
+    // Require a meaningful template (at least 20 chars of fixed text)
+    if (prefix.length + suffix.length < 20)
+        return texts[0];
+    // Verify all variable regions are distinct (i.e. something actually varies)
+    const variables = texts.map((t) => t.slice(prefix.length, suffix.length ? t.length - suffix.length : undefined));
+    if (new Set(variables).size === 1)
+        return texts[0];
+    return prefix + PLACEHOLDERS[0] + suffix;
+}
+function rawEventToUnified(event) {
+    const markets = [];
+    if (event.markets) {
+        for (const market of event.markets) {
+            const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market);
+            if (unifiedMarket) {
+                markets.push(unifiedMarket);
+            }
+        }
+    }
+    const unifiedEvent = {
+        id: event.event_ticker,
+        title: event.title,
+        description: event.mututals_description || deriveEventDescription(event.markets || []),
+        slug: event.event_ticker,
+        markets: markets,
+        volume24h: markets.reduce((sum, m) => sum + m.volume24h, 0),
+        volume: markets.some(m => m.volume !== undefined) ? markets.reduce((sum, m) => sum + (m.volume ?? 0), 0) : undefined,
+        url: `https://kalshi.com/events/${event.event_ticker}`,
+        image: event.image_url,
+        category: event.category,
+        tags: event.tags || [],
+    };
+    return unifiedEvent;
+}
+async function fetchAllWithStatus(callApi, apiStatus) {
+    let allEvents = [];
+    let cursor = null;
+    let page = 0;
+    const MAX_PAGES = 1000;
+    const BATCH_SIZE = 200;
+    do {
+        const queryParams = {
+            limit: BATCH_SIZE,
+            with_nested_markets: true,
+            status: apiStatus,
+        };
+        if (cursor)
+            queryParams.cursor = cursor;
+        const data = await callApi("GetEvents", queryParams);
+        const events = data.events || [];
+        if (events.length === 0)
+            break;
+        allEvents = allEvents.concat(events);
+        cursor = data.cursor;
+        page++;
+    } while (cursor && page < MAX_PAGES);
+    return allEvents;
+}
 async function fetchEvents(params, callApi) {
     try {
         // Handle eventId lookup (direct API call)
@@ -41,85 +130,67 @@ async function fetchEvents(params, callApi) {
         if (params.slug) {
             return await fetchEventByTicker(params.slug, callApi);
         }
-        const status = params?.status || 'active';
+        const status = params?.status || "active";
         const limit = params?.limit || 10000;
-        const query = (params?.query || '').toLowerCase();
-        const fetchAllWithStatus = async (apiStatus) => {
-            let allEvents = [];
-            let cursor = null;
-            let page = 0;
-            const MAX_PAGES = 1000; // Safety cap against infinite loops
-            const BATCH_SIZE = 200; // Max limit per Kalshi API docs
-            do {
-                const queryParams = {
-                    limit: BATCH_SIZE,
-                    with_nested_markets: true,
-                    status: apiStatus
-                };
-                if (cursor)
-                    queryParams.cursor = cursor;
-                const data = await callApi('GetEvents', queryParams);
-                const events = data.events || [];
-                if (events.length === 0)
-                    break;
-                allEvents = allEvents.concat(events);
-                cursor = data.cursor;
-                page++;
-                // If we have no search query and have fetched enough events, we can stop early
-                if (!query && allEvents.length >= limit * 1.5) {
-                    break;
-                }
-            } while (cursor && page < MAX_PAGES);
-            return allEvents;
-        };
+        const query = (params?.query || "").toLowerCase();
         let events = [];
-        if (status === 'all') {
+        if (status === "all") {
             const [openEvents, closedEvents, settledEvents] = await Promise.all([
-                fetchAllWithStatus('open'),
-                fetchAllWithStatus('closed'),
-                fetchAllWithStatus('settled')
+                fetchAllWithStatus(callApi, "open"),
+                fetchAllWithStatus(callApi, "closed"),
+                fetchAllWithStatus(callApi, "settled"),
             ]);
             events = [...openEvents, ...closedEvents, ...settledEvents];
         }
-        else if (status === 'closed' || status === 'inactive') {
+        else if (status === "closed" || status === "inactive") {
             const [closedEvents, settledEvents] = await Promise.all([
-                fetchAllWithStatus('closed'),
-                fetchAllWithStatus('settled')
+                fetchAllWithStatus(callApi, "closed"),
+                fetchAllWithStatus(callApi, "settled"),
             ]);
             events = [...closedEvents, ...settledEvents];
         }
         else {
-            events = await fetchAllWithStatus('open');
+            events = await fetchAllWithStatus(callApi, "open");
         }
-        const filtered = events.filter((event) => {
-            return (event.title || '').toLowerCase().includes(query);
-        });
-        const unifiedEvents = filtered.map((event) => {
-            const markets = [];
-            if (event.markets) {
-                for (const market of event.markets) {
-                    const unifiedMarket = (0, utils_1.mapMarketToUnified)(event, market);
-                    if (unifiedMarket) {
-                        markets.push(unifiedMarket);
-                    }
-                }
-            }
-            const unifiedEvent = {
-                id: event.event_ticker,
-                title: event.title,
-                description: event.mututals_description || "",
-                slug: event.event_ticker,
-                markets: markets,
-                url: `https://kalshi.com/events/${event.event_ticker}`,
-                image: event.image_url,
-                category: event.category,
-                tags: event.tags || []
-            };
-            return unifiedEvent;
-        });
+        // Apply keyword filter if a query was provided
+        const filtered = query
+            ? events.filter((event) => (event.title || "").toLowerCase().includes(query))
+            : events;
+        // Client-side sort — Kalshi's /events endpoint has no sort param.
+        // We aggregate stats from nested markets and sort the full set before slicing.
+        const sort = params?.sort || "volume";
+        const sorted = sortRawEvents(filtered, sort);
+        const unifiedEvents = sorted.map(rawEventToUnified);
         return unifiedEvents.slice(0, limit);
     }
     catch (error) {
         throw errors_1.kalshiErrorMapper.mapError(error);
     }
 }
+function eventVolume(event) {
+    return (event.markets || []).reduce((sum, m) => sum + Number(m.volume || 0), 0);
+}
+function eventLiquidity(event) {
+    return (event.markets || []).reduce((sum, m) => sum + Number(m.open_interest || m.liquidity || 0), 0);
+}
+function eventNewest(event) {
+    // Use the earliest close_time across markets as a proxy for "newness"
+    const times = (event.markets || [])
+        .map((m) => (m.close_time ? new Date(m.close_time).getTime() : 0))
+        .filter((t) => t > 0);
+    return times.length > 0 ? Math.min(...times) : 0;
+}
+function sortRawEvents(events, sort) {
+    const copy = [...events];
+    if (sort === "newest") {
+        copy.sort((a, b) => eventNewest(b) - eventNewest(a));
+    }
+    else if (sort === "liquidity") {
+        copy.sort((a, b) => eventLiquidity(b) - eventLiquidity(a));
+    }
+    else {
+        // Default: volume
+        copy.sort((a, b) => eventVolume(b) - eventVolume(a));
+    }
+    return copy;
+}

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

@@ -1,5 +1,5 @@
-import { MarketFetchParams } from '../../BaseExchange';
-import { UnifiedMarket } from '../../types';
+import { MarketFetchParams } from "../../BaseExchange";
+import { UnifiedMarket } from "../../types";
 type CallApi = (operationId: string, params?: Record<string, any>) => Promise<any>;
 export declare function resetCache(): void;
 export declare function fetchMarkets(params: MarketFetchParams | undefined, callApi: CallApi): Promise<UnifiedMarket[]>;

package/dist/exchanges/kalshi/fetchMarkets.js

@@ -4,7 +4,7 @@ exports.resetCache = resetCache;
 exports.fetchMarkets = fetchMarkets;
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
-async function fetchActiveEvents(callApi, targetMarketCount, status = 'open') {
+async function fetchActiveEvents(callApi, targetMarketCount, status = "open") {
     let allEvents = [];
     let totalMarketCount = 0;
     let cursor = null;
@@ -19,11 +19,11 @@ async function fetchActiveEvents(callApi, targetMarketCount, status = 'open') {
             const queryParams = {
                 limit: BATCH_SIZE,
                 with_nested_markets: true,
-                status: status // Filter by status (default 'open')
+                status: status, // Filter by status (default 'open')
             };
             if (cursor)
                 queryParams.cursor = cursor;
-            const data = await callApi('GetEvents', queryParams);
+            const data = await callApi("GetEvents", queryParams);
             const events = data.events || [];
             if (events.length === 0)
                 break;
@@ -54,7 +54,7 @@ async function fetchActiveEvents(callApi, targetMarketCount, status = 'open') {
 }
 async function fetchSeriesMap(callApi) {
     try {
-        const data = await callApi('GetSeriesList');
+        const data = await callApi("GetSeriesList");
         const seriesList = data.series || [];
         const map = new Map();
         for (const series of seriesList) {
@@ -91,7 +91,7 @@ async function fetchMarkets(params, callApi) {
         }
         // Handle outcomeId lookup (strip -NO suffix, use as ticker)
         if (params?.outcomeId) {
-            const ticker = params.outcomeId.replace(/-NO$/, '');
+            const ticker = params.outcomeId.replace(/-NO$/, "");
             return await fetchMarketsBySlug(ticker, callApi);
         }
         // Handle eventId lookup (event ticker works the same way)
@@ -112,14 +112,19 @@ async function fetchMarkets(params, callApi) {
 async function fetchMarketsBySlug(eventTicker, callApi) {
     // Kalshi API expects uppercase tickers, but URLs use lowercase
     const normalizedTicker = eventTicker.toUpperCase();
-    const data = await callApi('GetEvent', { event_ticker: normalizedTicker, with_nested_markets: true });
+    const data = await callApi("GetEvent", {
+        event_ticker: normalizedTicker,
+        with_nested_markets: true,
+    });
     const event = data.event;
     if (!event)
         return [];
     // Enrichment: Fetch series tags if they exist
     if (event.series_ticker) {
         try {
-            const seriesData = await callApi('GetSeries', { series_ticker: event.series_ticker });
+            const seriesData = await callApi("GetSeries", {
+                series_ticker: event.series_ticker,
+            });
             const series = seriesData.series;
             if (series && series.tags && series.tags.length > 0) {
                 if (!event.tags || event.tags.length === 0) {
@@ -146,13 +151,15 @@ async function searchMarkets(query, params, callApi) {
     const searchLimit = 250000;
     const markets = await fetchMarketsDefault({ ...params, limit: searchLimit }, callApi);
     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')
+    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')
+        if (searchIn === "description")
             return descMatch;
         return titleMatch || descMatch; // 'both'
     });
@@ -163,21 +170,24 @@ async function fetchMarketsDefault(params, callApi) {
     const limit = params?.limit || 250000;
     const offset = params?.offset || 0;
     const now = Date.now();
-    const status = params?.status || 'active'; // Default to 'active'
+    const status = params?.status || "active"; // Default to 'active'
     // Map 'active' -> 'open', 'closed' -> 'closed'
     // Kalshi statuses: 'open', 'closed', 'settled'
-    let apiStatus = 'open';
-    if (status === 'closed' || status === 'inactive')
-        apiStatus = 'closed';
-    else if (status === 'all')
-        apiStatus = 'open'; // Fallback for all? Or loop? For now default to open.
+    let apiStatus = "open";
+    if (status === "closed" || status === "inactive")
+        apiStatus = "closed";
+    else if (status === "all")
+        apiStatus = "open"; // Fallback for all? Or loop? For now default to open.
     try {
         let events;
         let seriesMap;
         // Check if we have valid cached data
         // Only use global cache for the default 'active'/'open' case
-        const useCache = (status === 'active' || !params?.status);
-        if (useCache && cachedEvents && cachedSeriesMap && (now - lastCacheTime < CACHE_TTL)) {
+        const useCache = status === "active" || !params?.status;
+        if (useCache &&
+            cachedEvents &&
+            cachedSeriesMap &&
+            now - lastCacheTime < CACHE_TTL) {
             events = cachedEvents;
             seriesMap = cachedSeriesMap;
         }
@@ -185,11 +195,12 @@ async function fetchMarketsDefault(params, callApi) {
             // Optimize fetch limit based on request parameters
             // If sorting is required (e.g. by volume), we need to fetch a larger set (or all) to sort correctly.
             // If no sorting is requested, we only need to fetch enough to satisfy the limit.
-            const isSorted = params?.sort && (params.sort === 'volume' || params.sort === 'liquidity');
+            const isSorted = params?.sort &&
+                (params.sort === "volume" || params.sort === "liquidity");
             const fetchLimit = isSorted ? 1000 : limit;
             const [allEvents, fetchedSeriesMap] = await Promise.all([
                 fetchActiveEvents(callApi, fetchLimit, apiStatus),
-                fetchSeriesMap(callApi)
+                fetchSeriesMap(callApi),
             ]);
             events = allEvents;
             seriesMap = fetchedSeriesMap;
@@ -222,10 +233,10 @@ async function fetchMarketsDefault(params, callApi) {
             }
         }
         // Sort by 24h volume
-        if (params?.sort === 'volume') {
+        if (params?.sort === "volume") {
             allMarkets.sort((a, b) => b.volume24h - a.volume24h);
         }
-        else if (params?.sort === 'liquidity') {
+        else if (params?.sort === "liquidity") {
             allMarkets.sort((a, b) => b.liquidity - a.liquidity);
         }
         return allMarkets.slice(offset, offset + limit);

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

@@ -1,3 +1,3 @@
-import { HistoryFilterParams, OHLCVParams } from '../../BaseExchange';
-import { PriceCandle } from '../../types';
-export declare function fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams, callApi: (operationId: string, params?: Record<string, any>) => Promise<any>): Promise<PriceCandle[]>;
+import { OHLCVParams } from "../../BaseExchange";
+import { PriceCandle } from "../../types";
+export declare function fetchOHLCV(id: string, params: OHLCVParams, callApi: (operationId: string, params?: Record<string, any>) => Promise<any>): Promise<PriceCandle[]>;

package/dist/exchanges/kalshi/fetchOHLCV.js

@@ -5,34 +5,34 @@ const utils_1 = require("./utils");
 const validation_1 = require("../../utils/validation");
 const errors_1 = require("./errors");
 async function fetchOHLCV(id, params, callApi) {
-    (0, validation_1.validateIdFormat)(id, 'OHLCV');
+    (0, validation_1.validateIdFormat)(id, "OHLCV");
     // Validate resolution is provided
     if (!params.resolution) {
-        throw new Error('fetchOHLCV requires a resolution parameter. Use OHLCVParams with resolution specified.');
+        throw new Error("fetchOHLCV requires a resolution parameter. Use OHLCVParams with resolution specified.");
     }
     try {
         // Kalshi API expects uppercase tickers
         // Handle virtual "-NO" suffix by stripping it (fetching the underlying market history)
-        const cleanedId = id.replace(/-NO$/, '');
+        const cleanedId = id.replace(/-NO$/, "");
         const normalizedId = cleanedId.toUpperCase();
         const interval = (0, utils_1.mapIntervalToKalshi)(params.resolution);
         // Heuristic for series_ticker
-        const parts = normalizedId.split('-');
+        const parts = normalizedId.split("-");
         if (parts.length < 2) {
             throw new Error(`Invalid Kalshi Ticker format: "${id}". Expected format like "FED-25JAN29-B4.75".`);
         }
-        const seriesTicker = parts.slice(0, -1).join('-');
+        const seriesTicker = parts.slice(0, -1).join("-");
         const now = Math.floor(Date.now() / 1000);
-        let startTs = now - (24 * 60 * 60);
+        let startTs = now - 24 * 60 * 60;
         let endTs = now;
         // Helper to handle string dates (from JSON)
         // IMPORTANT: Python sends naive datetimes as ISO strings without 'Z' suffix.
         // We must treat these as UTC, not local time.
         const ensureDate = (d) => {
-            if (typeof d === 'string') {
+            if (typeof d === "string") {
                 // If string doesn't end with 'Z' and doesn't have timezone offset, append 'Z'
-                if (!d.endsWith('Z') && !d.match(/[+-]\d{2}:\d{2}$/)) {
-                    return new Date(d + 'Z');
+                if (!d.endsWith("Z") && !d.match(/[+-]\d{2}:\d{2}$/)) {
+                    return new Date(d + "Z");
                 }
                 return new Date(d);
             }
@@ -46,10 +46,10 @@ async function fetchOHLCV(id, params, callApi) {
         if (pEnd) {
             endTs = Math.floor(pEnd.getTime() / 1000);
             if (!pStart) {
-                startTs = endTs - (24 * 60 * 60);
+                startTs = endTs - 24 * 60 * 60;
             }
         }
-        const data = await callApi('GetMarketCandlesticks', {
+        const data = await callApi("GetMarketCandlesticks", {
             series_ticker: seriesTicker,
             ticker: normalizedId,
             period_interval: interval,
@@ -68,18 +68,21 @@ async function fetchOHLCV(id, params, callApi) {
             const getVal = (field) => {
                 if (p[field] !== null && p[field] !== undefined)
                     return p[field];
-                if (ask[field] !== null && bid[field] !== null && ask[field] !== undefined && bid[field] !== undefined) {
+                if (ask[field] !== null &&
+                    bid[field] !== null &&
+                    ask[field] !== undefined &&
+                    bid[field] !== undefined) {
                     return (ask[field] + bid[field]) / 2;
                 }
                 return p.previous || 0;
             };
             return {
                 timestamp: c.end_period_ts * 1000,
-                open: getVal('open') / 100,
-                high: getVal('high') / 100,
-                low: getVal('low') / 100,
-                close: getVal('close') / 100,
-                volume: c.volume || 0
+                open: getVal("open") / 100,
+                high: getVal("high") / 100,
+                low: getVal("low") / 100,
+                close: getVal("close") / 100,
+                volume: c.volume || 0,
             };
         });
         if (params.limit && mappedCandles.length > params.limit) {

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

@@ -0,0 +1,2 @@
+import { OrderBook } from "../../types";
+export declare function fetchOrderBook(baseUrl: string, id: string): Promise<OrderBook>;