pmxt-core 2.12.1 → 2.14.1

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

@@ -1,6 +1,6 @@
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-02-22T15:41:57.405Z
+ * Generated at: 2026-02-23T07:41:05.138Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 export declare const kalshiApiSpec: {
@@ -11,6 +11,12 @@ export declare const kalshiApiSpec: {
     };
     servers: {
         url: string;
+        variables: {
+            env: {
+                default: string;
+                enum: string[];
+            };
+        };
     }[];
     paths: {
         "/historical/cutoff": {

package/dist/exchanges/kalshi/api.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.kalshiApiSpec = void 0;
 /**
  * Auto-generated from /home/runner/work/pmxt/pmxt/core/specs/kalshi/Kalshi.yaml
- * Generated at: 2026-02-22T15:41:57.405Z
+ * Generated at: 2026-02-23T07:41:05.138Z
  * Do not edit manually -- run "npm run fetch:openapi" to regenerate.
  */
 exports.kalshiApiSpec = {
@@ -14,7 +14,16 @@ exports.kalshiApiSpec = {
     },
     "servers": [
         {
-            "url": "https://api.elections.kalshi.com/trade-api/v2"
+            "url": "https://{env}.elections.kalshi.com/trade-api/v2",
+            "variables": {
+                "env": {
+                    "default": "api",
+                    "enum": [
+                        "api",
+                        "demo-api"
+                    ]
+                }
+            }
         }
     ],
     "paths": {

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

@@ -0,0 +1,103 @@
+/**
+ * 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
+ */
+export declare const KALSHI_PROD_API_URL = "https://api.elections.kalshi.com";
+export declare const KALSHI_DEMO_API_URL = "https://demo-api.kalshi.co";
+export declare const KALSHI_PROD_WS_URL = "wss://api.elections.kalshi.com/trade-api/ws/v2";
+export declare const KALSHI_DEMO_WS_URL = "wss://demo-api.kalshi.co/trade-api/ws/v2";
+export declare const KALSHI_PATHS: {
+    TRADE_API: string;
+    EVENTS: string;
+    SERIES: string;
+    PORTFOLIO: string;
+    MARKETS: string;
+    BALANCE: string;
+    ORDERS: string;
+    POSITIONS: string;
+};
+export interface KalshiApiConfig {
+    /** Base REST API URL — production or demo */
+    apiUrl: string;
+    /** WebSocket URL — production or demo */
+    wsUrl?: string;
+    /** Whether the demo environment is active */
+    demoMode: boolean;
+}
+/**
+ * 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"
+ * ```
+ */
+export declare function getKalshiConfig(demoMode?: boolean): KalshiApiConfig;
+/**
+ * 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"
+ * ```
+ */
+export declare function getApiPath(operationPath: string): string;
+/**
+ * Build the full URL for the events endpoint.
+ *
+ * @example
+ * ```typescript
+ * getEventsUrl(baseUrl)              // .../events
+ * getEventsUrl(baseUrl, ['FED-25'])  // .../events/FED-25
+ * ```
+ */
+export declare function getEventsUrl(baseUrl: string, pathSegments?: string[]): string;
+/**
+ * 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
+ * ```
+ */
+export declare function getSeriesUrl(baseUrl: string, seriesTicker?: string, pathSegments?: string[]): string;
+/**
+ * Build the full URL for the portfolio endpoint.
+ *
+ * @example
+ * ```typescript
+ * getPortfolioUrl(baseUrl, '/balance')  // .../portfolio/balance
+ * ```
+ */
+export declare function getPortfolioUrl(baseUrl: string, subPath?: string): string;
+/**
+ * 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
+ * ```
+ */
+export declare function getMarketsUrl(baseUrl: string, marketId?: string, pathSegments?: string[]): string;

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 [];
@@ -27,7 +30,7 @@ async function fetchEventByTicker(eventTicker, callApi) {
         url: `https://kalshi.com/events/${event.event_ticker}`,
         image: event.image_url,
         category: event.category,
-        tags: event.tags || []
+        tags: event.tags || [],
     };
     return [unifiedEvent];
 }
@@ -41,9 +44,9 @@ 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 query = (params?.query || "").toLowerCase();
         const fetchAllWithStatus = async (apiStatus) => {
             let allEvents = [];
             let cursor = null;
@@ -54,11 +57,11 @@ async function fetchEvents(params, callApi) {
                 const queryParams = {
                     limit: BATCH_SIZE,
                     with_nested_markets: true,
-                    status: apiStatus
+                    status: apiStatus,
                 };
                 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;
@@ -73,26 +76,26 @@ async function fetchEvents(params, callApi) {
             return allEvents;
         };
         let events = [];
-        if (status === 'all') {
+        if (status === "all") {
             const [openEvents, closedEvents, settledEvents] = await Promise.all([
-                fetchAllWithStatus('open'),
-                fetchAllWithStatus('closed'),
-                fetchAllWithStatus('settled')
+                fetchAllWithStatus("open"),
+                fetchAllWithStatus("closed"),
+                fetchAllWithStatus("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("closed"),
+                fetchAllWithStatus("settled"),
             ]);
             events = [...closedEvents, ...settledEvents];
         }
         else {
-            events = await fetchAllWithStatus('open');
+            events = await fetchAllWithStatus("open");
         }
         const filtered = events.filter((event) => {
-            return (event.title || '').toLowerCase().includes(query);
+            return (event.title || "").toLowerCase().includes(query);
         });
         const unifiedEvents = filtered.map((event) => {
             const markets = [];
@@ -113,7 +116,7 @@ async function fetchEvents(params, callApi) {
                 url: `https://kalshi.com/events/${event.event_ticker}`,
                 image: event.image_url,
                 category: event.category,
-                tags: event.tags || []
+                tags: event.tags || [],
             };
             return unifiedEvent;
         });

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';
+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[]>;

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>;