pmxt-core 2.8.0 → 2.9.0

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

@@ -1,4 +1,5 @@
 import { EventFetchParams } from '../../BaseExchange';
 import { UnifiedEvent } from '../../types';
-import { AxiosInstance } from 'axios';
-export declare function fetchEvents(params: EventFetchParams, http?: AxiosInstance): Promise<UnifiedEvent[]>;
+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

@@ -1,19 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchEvents = fetchEvents;
-const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
-async function fetchEventByTicker(eventTicker, http) {
+async function fetchEventByTicker(eventTicker, callApi) {
     const normalizedTicker = eventTicker.toUpperCase();
-    const url = `https://api.elections.kalshi.com/trade-api/v2/events/${normalizedTicker}`;
-    const response = await http.get(url, {
-        params: { with_nested_markets: true }
-    });
-    const event = response.data.event;
+    const data = await callApi('GetEvent', { event_ticker: normalizedTicker, with_nested_markets: true });
+    const event = data.event;
     if (!event)
         return [];
     const markets = [];
@@ -38,15 +31,15 @@ async function fetchEventByTicker(eventTicker, http) {
     };
     return [unifiedEvent];
 }
-async function fetchEvents(params, http = axios_1.default) {
+async function fetchEvents(params, callApi) {
     try {
         // Handle eventId lookup (direct API call)
         if (params.eventId) {
-            return await fetchEventByTicker(params.eventId, http);
+            return await fetchEventByTicker(params.eventId, callApi);
         }
         // Handle slug lookup (slug IS the event ticker on Kalshi)
         if (params.slug) {
-            return await fetchEventByTicker(params.slug, http);
+            return await fetchEventByTicker(params.slug, callApi);
         }
         const status = params?.status || 'active';
         const limit = params?.limit || 10000;
@@ -65,12 +58,12 @@ async function fetchEvents(params, http = axios_1.default) {
                 };
                 if (cursor)
                     queryParams.cursor = cursor;
-                const response = await http.get(utils_1.KALSHI_API_URL, { params: queryParams });
-                const events = response.data.events || [];
+                const data = await callApi('GetEvents', queryParams);
+                const events = data.events || [];
                 if (events.length === 0)
                     break;
                 allEvents = allEvents.concat(events);
-                cursor = response.data.cursor;
+                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) {

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

@@ -1,5 +1,6 @@
-import { AxiosInstance } from 'axios';
 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, http?: AxiosInstance): Promise<UnifiedMarket[]>;
+export declare function fetchMarkets(params: MarketFetchParams | undefined, callApi: CallApi): Promise<UnifiedMarket[]>;
+export {};

package/dist/exchanges/kalshi/fetchMarkets.js

@@ -1,14 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetCache = resetCache;
 exports.fetchMarkets = fetchMarkets;
-const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
-async function fetchActiveEvents(http, targetMarketCount, status = 'open') {
+async function fetchActiveEvents(callApi, targetMarketCount, status = 'open') {
     let allEvents = [];
     let totalMarketCount = 0;
     let cursor = null;
@@ -27,8 +23,8 @@ async function fetchActiveEvents(http, targetMarketCount, status = 'open') {
             };
             if (cursor)
                 queryParams.cursor = cursor;
-            const response = await http.get(utils_1.KALSHI_API_URL, { params: queryParams });
-            const events = response.data.events || [];
+            const data = await callApi('GetEvents', queryParams);
+            const events = data.events || [];
             if (events.length === 0)
                 break;
             allEvents = allEvents.concat(events);
@@ -43,7 +39,7 @@ async function fetchActiveEvents(http, targetMarketCount, status = 'open') {
                     break;
                 }
             }
-            cursor = response.data.cursor;
+            cursor = data.cursor;
             page++;
             // Additional safety: if no target specified, limit to reasonable number of pages
             if (!targetMarketCount && page >= 10) {
@@ -56,10 +52,10 @@ async function fetchActiveEvents(http, targetMarketCount, status = 'open') {
     } while (cursor && page < MAX_PAGES);
     return allEvents;
 }
-async function fetchSeriesMap(http) {
+async function fetchSeriesMap(callApi) {
     try {
-        const response = await http.get(utils_1.KALSHI_SERIES_URL);
-        const seriesList = response.data.series || [];
+        const data = await callApi('GetSeriesList');
+        const seriesList = data.series || [];
         const map = new Map();
         for (const series of seriesList) {
             if (series.tags && series.tags.length > 0) {
@@ -83,52 +79,48 @@ function resetCache() {
     cachedSeriesMap = null;
     lastCacheTime = 0;
 }
-async function fetchMarkets(params, http = axios_1.default) {
+async function fetchMarkets(params, callApi) {
     try {
         // Handle marketId lookup (Kalshi marketId is the ticker)
         if (params?.marketId) {
-            return await fetchMarketsBySlug(params.marketId, http);
+            return await fetchMarketsBySlug(params.marketId, callApi);
         }
         // Handle slug-based lookup (event ticker)
         if (params?.slug) {
-            return await fetchMarketsBySlug(params.slug, http);
+            return await fetchMarketsBySlug(params.slug, callApi);
         }
         // Handle outcomeId lookup (strip -NO suffix, use as ticker)
         if (params?.outcomeId) {
             const ticker = params.outcomeId.replace(/-NO$/, '');
-            return await fetchMarketsBySlug(ticker, http);
+            return await fetchMarketsBySlug(ticker, callApi);
         }
         // Handle eventId lookup (event ticker works the same way)
         if (params?.eventId) {
-            return await fetchMarketsBySlug(params.eventId, http);
+            return await fetchMarketsBySlug(params.eventId, callApi);
         }
         // Handle query-based search
         if (params?.query) {
-            return await searchMarkets(params.query, params, http);
+            return await searchMarkets(params.query, params, callApi);
         }
         // Default: fetch markets
-        return await fetchMarketsDefault(params, http);
+        return await fetchMarketsDefault(params, callApi);
     }
     catch (error) {
         throw errors_1.kalshiErrorMapper.mapError(error);
     }
 }
-async function fetchMarketsBySlug(eventTicker, http) {
+async function fetchMarketsBySlug(eventTicker, callApi) {
     // Kalshi API expects uppercase tickers, but URLs use lowercase
     const normalizedTicker = eventTicker.toUpperCase();
-    const url = `https://api.elections.kalshi.com/trade-api/v2/events/${normalizedTicker}`;
-    const response = await http.get(url, {
-        params: { with_nested_markets: true }
-    });
-    const event = response.data.event;
+    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 seriesUrl = `${utils_1.KALSHI_SERIES_URL}/${event.series_ticker}`;
-            const seriesResponse = await http.get(seriesUrl);
-            const series = seriesResponse.data.series;
+            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) {
                     event.tags = series.tags;
@@ -149,10 +141,10 @@ async function fetchMarketsBySlug(eventTicker, http) {
     }
     return unifiedMarkets;
 }
-async function searchMarkets(query, params, http) {
+async function searchMarkets(query, params, callApi) {
     // We must fetch ALL markets to search them locally since we don't have server-side search
     const searchLimit = 250000;
-    const markets = await fetchMarketsDefault({ ...params, limit: searchLimit }, http);
+    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 => {
@@ -167,7 +159,7 @@ async function searchMarkets(query, params, http) {
     const limit = params?.limit || 250000;
     return filtered.slice(0, limit);
 }
-async function fetchMarketsDefault(params, http) {
+async function fetchMarketsDefault(params, callApi) {
     const limit = params?.limit || 250000;
     const offset = params?.offset || 0;
     const now = Date.now();
@@ -196,8 +188,8 @@ async function fetchMarketsDefault(params, http) {
             const isSorted = params?.sort && (params.sort === 'volume' || params.sort === 'liquidity');
             const fetchLimit = isSorted ? 1000 : limit;
             const [allEvents, fetchedSeriesMap] = await Promise.all([
-                fetchActiveEvents(http, fetchLimit, apiStatus),
-                fetchSeriesMap(http)
+                fetchActiveEvents(callApi, fetchLimit, apiStatus),
+                fetchSeriesMap(callApi)
             ]);
             events = allEvents;
             seriesMap = fetchedSeriesMap;

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

@@ -1,4 +1,3 @@
-import { AxiosInstance } from 'axios';
 import { HistoryFilterParams, OHLCVParams } from '../../BaseExchange';
 import { PriceCandle } from '../../types';
-export declare function fetchOHLCV(id: string, params: OHLCVParams | HistoryFilterParams, http?: AxiosInstance): Promise<PriceCandle[]>;
+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

@@ -1,14 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchOHLCV = fetchOHLCV;
-const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const validation_1 = require("../../utils/validation");
 const errors_1 = require("./errors");
-async function fetchOHLCV(id, params, http = axios_1.default) {
+async function fetchOHLCV(id, params, callApi) {
     (0, validation_1.validateIdFormat)(id, 'OHLCV');
     // Validate resolution is provided
     if (!params.resolution) {
@@ -26,8 +22,6 @@ async function fetchOHLCV(id, params, http = axios_1.default) {
             throw new Error(`Invalid Kalshi Ticker format: "${id}". Expected format like "FED-25JAN29-B4.75".`);
         }
         const seriesTicker = parts.slice(0, -1).join('-');
-        const url = `https://api.elections.kalshi.com/trade-api/v2/series/${seriesTicker}/markets/${normalizedId}/candlesticks`;
-        const queryParams = { period_interval: interval };
         const now = Math.floor(Date.now() / 1000);
         let startTs = now - (24 * 60 * 60);
         let endTs = now;
@@ -55,10 +49,14 @@ async function fetchOHLCV(id, params, http = axios_1.default) {
                 startTs = endTs - (24 * 60 * 60);
             }
         }
-        queryParams.start_ts = startTs;
-        queryParams.end_ts = endTs;
-        const response = await http.get(url, { params: queryParams });
-        const candles = response.data.candlesticks || [];
+        const data = await callApi('GetMarketCandlesticks', {
+            series_ticker: seriesTicker,
+            ticker: normalizedId,
+            period_interval: interval,
+            start_ts: startTs,
+            end_ts: endTs,
+        });
+        const candles = data.candlesticks || [];
         const mappedCandles = candles.map((c) => {
             // Priority:
             // 1. Transaction price (close)

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

@@ -26,7 +26,8 @@ export declare class KalshiExchange extends PredictionMarketExchange {
     private wsConfig?;
     constructor(options?: ExchangeCredentials | KalshiExchangeOptions);
     get name(): string;
-    private getBaseUrl;
+    protected sign(method: string, path: string, _params: Record<string, any>): Record<string, string>;
+    protected mapImplicitApiError(error: any): any;
     private ensureAuth;
     protected fetchMarketsImpl(params?: MarketFilterParams): Promise<UnifiedMarket[]>;
     protected fetchEventsImpl(params: EventFetchParams): Promise<UnifiedEvent[]>;