pmxt-core 2.6.0 → 2.8.0

package/dist/BaseExchange.d.ts

@@ -1,5 +1,6 @@
 import { UnifiedMarket, UnifiedEvent, PriceCandle, CandleInterval, OrderBook, Trade, Order, Position, Balance, CreateOrderParams } from './types';
 import { ExecutionPriceResult } from './utils/math';
+import { AxiosInstance } from 'axios';
 export interface MarketFilterParams {
     limit?: number;
     offset?: number;
@@ -120,9 +121,22 @@ export interface ExchangeCredentials {
 }
 export declare abstract class PredictionMarketExchange {
     protected credentials?: ExchangeCredentials;
+    verbose: boolean;
+    http: AxiosInstance;
+    markets: Record<string, UnifiedMarket>;
+    marketsBySlug: Record<string, UnifiedMarket>;
+    loadedMarkets: boolean;
     readonly has: ExchangeHas;
     constructor(credentials?: ExchangeCredentials);
     abstract get name(): string;
+    /**
+     * Load and cache markets from the exchange.
+     * This method populates `this.markets` and `this.marketsBySlug`.
+     *
+     * @param reload - Force a reload of markets from the API even if already loaded
+     * @returns Dictionary of markets indexed by marketId
+     */
+    loadMarkets(reload?: boolean): Promise<Record<string, UnifiedMarket>>;
     /**
      * Fetch markets with optional filtering, search, or slug lookup.
      * This is the primary method for retrieving markets.

package/dist/BaseExchange.js

@@ -1,13 +1,23 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PredictionMarketExchange = void 0;
 const math_1 = require("./utils/math");
 const errors_1 = require("./errors");
+const axios_1 = __importDefault(require("axios"));
 // ----------------------------------------------------------------------------
 // Base Exchange Class
 // ----------------------------------------------------------------------------
 class PredictionMarketExchange {
     credentials;
+    verbose = false;
+    http;
+    // Market Cache
+    markets = {};
+    marketsBySlug = {};
+    loadedMarkets = false;
     has = {
         fetchMarkets: false,
         fetchEvents: false,
@@ -25,6 +35,63 @@ class PredictionMarketExchange {
     };
     constructor(credentials) {
         this.credentials = credentials;
+        this.http = axios_1.default.create();
+        // Request Interceptor
+        this.http.interceptors.request.use((config) => {
+            if (this.verbose) {
+                console.log(`\n[pmxt] → ${config.method?.toUpperCase()} ${config.url}`);
+                if (config.params)
+                    console.log('[pmxt] params:', config.params);
+                if (config.data)
+                    console.log('[pmxt] body:', JSON.stringify(config.data, null, 2));
+            }
+            return config;
+        });
+        // Response Interceptor
+        this.http.interceptors.response.use((response) => {
+            if (this.verbose) {
+                console.log(`\n[pmxt] ← ${response.status} ${response.statusText} ${response.config.url}`);
+                // console.log('[pmxt] response:', JSON.stringify(response.data, null, 2)); 
+                // Commented out full body log to avoid spam, but headers might be useful
+            }
+            return response;
+        }, (error) => {
+            if (this.verbose) {
+                console.log(`\n[pmxt] ✖ REQUEST FAILED: ${error.config?.url}`);
+                console.log('[pmxt] error:', error.message);
+                if (error.response) {
+                    console.log('[pmxt] status:', error.response.status);
+                    console.log('[pmxt] data:', JSON.stringify(error.response.data, null, 2));
+                }
+            }
+            return Promise.reject(error);
+        });
+    }
+    /**
+     * Load and cache markets from the exchange.
+     * This method populates `this.markets` and `this.marketsBySlug`.
+     *
+     * @param reload - Force a reload of markets from the API even if already loaded
+     * @returns Dictionary of markets indexed by marketId
+     */
+    async loadMarkets(reload = false) {
+        if (this.loadedMarkets && !reload) {
+            return this.markets;
+        }
+        // Fetch all markets (implementation dependent, usually fetches active markets)
+        const markets = await this.fetchMarkets();
+        // Reset caches
+        this.markets = {};
+        this.marketsBySlug = {};
+        for (const market of markets) {
+            this.markets[market.marketId] = market;
+            // Some exchanges provide slugs, if so cache them
+            if (market.slug) {
+                this.marketsBySlug[market.slug] = market;
+            }
+        }
+        this.loadedMarkets = true;
+        return this.markets;
     }
     /**
      * Fetch markets with optional filtering, search, or slug lookup.
@@ -105,6 +172,15 @@ class PredictionMarketExchange {
      * market = exchange.fetch_market(market_id='663583')
      */
     async fetchMarket(params) {
+        // Try to fetch from cache first if we have loaded markets and have an ID/slug
+        if (this.loadedMarkets) {
+            if (params?.marketId && this.markets[params.marketId]) {
+                return this.markets[params.marketId];
+            }
+            if (params?.slug && this.marketsBySlug[params.slug]) {
+                return this.marketsBySlug[params.slug];
+            }
+        }
         const markets = await this.fetchMarkets(params);
         if (markets.length === 0) {
             const identifier = params?.marketId || params?.outcomeId || params?.slug || params?.eventId || params?.query || 'unknown';

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

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

package/dist/exchanges/kalshi/fetchEvents.js

@@ -7,10 +7,10 @@ exports.fetchEvents = fetchEvents;
 const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
-async function fetchEventByTicker(eventTicker) {
+async function fetchEventByTicker(eventTicker, http) {
     const normalizedTicker = eventTicker.toUpperCase();
     const url = `https://api.elections.kalshi.com/trade-api/v2/events/${normalizedTicker}`;
-    const response = await axios_1.default.get(url, {
+    const response = await http.get(url, {
         params: { with_nested_markets: true }
     });
     const event = response.data.event;
@@ -38,15 +38,15 @@ async function fetchEventByTicker(eventTicker) {
     };
     return [unifiedEvent];
 }
-async function fetchEvents(params) {
+async function fetchEvents(params, http = axios_1.default) {
     try {
         // Handle eventId lookup (direct API call)
         if (params.eventId) {
-            return await fetchEventByTicker(params.eventId);
+            return await fetchEventByTicker(params.eventId, http);
         }
         // Handle slug lookup (slug IS the event ticker on Kalshi)
         if (params.slug) {
-            return await fetchEventByTicker(params.slug);
+            return await fetchEventByTicker(params.slug, http);
         }
         const status = params?.status || 'active';
         const limit = params?.limit || 10000;
@@ -65,7 +65,7 @@ async function fetchEvents(params) {
                 };
                 if (cursor)
                     queryParams.cursor = cursor;
-                const response = await axios_1.default.get(utils_1.KALSHI_API_URL, { params: queryParams });
+                const response = await http.get(utils_1.KALSHI_API_URL, { params: queryParams });
                 const events = response.data.events || [];
                 if (events.length === 0)
                     break;

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

@@ -1,4 +1,5 @@
+import { AxiosInstance } from 'axios';
 import { MarketFetchParams } from '../../BaseExchange';
 import { UnifiedMarket } from '../../types';
 export declare function resetCache(): void;
-export declare function fetchMarkets(params?: MarketFetchParams): Promise<UnifiedMarket[]>;
+export declare function fetchMarkets(params?: MarketFetchParams, http?: AxiosInstance): Promise<UnifiedMarket[]>;

package/dist/exchanges/kalshi/fetchMarkets.js

@@ -8,7 +8,7 @@ exports.fetchMarkets = fetchMarkets;
 const axios_1 = __importDefault(require("axios"));
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
-async function fetchActiveEvents(targetMarketCount, status = 'open') {
+async function fetchActiveEvents(http, targetMarketCount, status = 'open') {
     let allEvents = [];
     let totalMarketCount = 0;
     let cursor = null;
@@ -27,7 +27,7 @@ async function fetchActiveEvents(targetMarketCount, status = 'open') {
             };
             if (cursor)
                 queryParams.cursor = cursor;
-            const response = await axios_1.default.get(utils_1.KALSHI_API_URL, { params: queryParams });
+            const response = await http.get(utils_1.KALSHI_API_URL, { params: queryParams });
             const events = response.data.events || [];
             if (events.length === 0)
                 break;
@@ -56,9 +56,9 @@ async function fetchActiveEvents(targetMarketCount, status = 'open') {
     } while (cursor && page < MAX_PAGES);
     return allEvents;
 }
-async function fetchSeriesMap() {
+async function fetchSeriesMap(http) {
     try {
-        const response = await axios_1.default.get(utils_1.KALSHI_SERIES_URL);
+        const response = await http.get(utils_1.KALSHI_SERIES_URL);
         const seriesList = response.data.series || [];
         const map = new Map();
         for (const series of seriesList) {
@@ -83,41 +83,41 @@ function resetCache() {
     cachedSeriesMap = null;
     lastCacheTime = 0;
 }
-async function fetchMarkets(params) {
+async function fetchMarkets(params, http = axios_1.default) {
     try {
         // Handle marketId lookup (Kalshi marketId is the ticker)
         if (params?.marketId) {
-            return await fetchMarketsBySlug(params.marketId);
+            return await fetchMarketsBySlug(params.marketId, http);
         }
         // Handle slug-based lookup (event ticker)
         if (params?.slug) {
-            return await fetchMarketsBySlug(params.slug);
+            return await fetchMarketsBySlug(params.slug, http);
         }
         // Handle outcomeId lookup (strip -NO suffix, use as ticker)
         if (params?.outcomeId) {
             const ticker = params.outcomeId.replace(/-NO$/, '');
-            return await fetchMarketsBySlug(ticker);
+            return await fetchMarketsBySlug(ticker, http);
         }
         // Handle eventId lookup (event ticker works the same way)
         if (params?.eventId) {
-            return await fetchMarketsBySlug(params.eventId);
+            return await fetchMarketsBySlug(params.eventId, http);
         }
         // Handle query-based search
         if (params?.query) {
-            return await searchMarkets(params.query, params);
+            return await searchMarkets(params.query, params, http);
         }
         // Default: fetch markets
-        return await fetchMarketsDefault(params);
+        return await fetchMarketsDefault(params, http);
     }
     catch (error) {
         throw errors_1.kalshiErrorMapper.mapError(error);
     }
 }
-async function fetchMarketsBySlug(eventTicker) {
+async function fetchMarketsBySlug(eventTicker, http) {
     // 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 axios_1.default.get(url, {
+    const response = await http.get(url, {
         params: { with_nested_markets: true }
     });
     const event = response.data.event;
@@ -127,7 +127,7 @@ async function fetchMarketsBySlug(eventTicker) {
     if (event.series_ticker) {
         try {
             const seriesUrl = `${utils_1.KALSHI_SERIES_URL}/${event.series_ticker}`;
-            const seriesResponse = await axios_1.default.get(seriesUrl);
+            const seriesResponse = await http.get(seriesUrl);
             const series = seriesResponse.data.series;
             if (series && series.tags && series.tags.length > 0) {
                 if (!event.tags || event.tags.length === 0) {
@@ -149,10 +149,10 @@ async function fetchMarketsBySlug(eventTicker) {
     }
     return unifiedMarkets;
 }
-async function searchMarkets(query, params) {
+async function searchMarkets(query, params, http) {
     // We must fetch ALL markets to search them locally since we don't have server-side search
-    const searchLimit = 10000;
-    const markets = await fetchMarketsDefault({ ...params, limit: searchLimit });
+    const searchLimit = 250000;
+    const markets = await fetchMarketsDefault({ ...params, limit: searchLimit }, http);
     const lowerQuery = query.toLowerCase();
     const searchIn = params?.searchIn || 'title'; // Default to title-only search
     const filtered = markets.filter(market => {
@@ -164,11 +164,11 @@ async function searchMarkets(query, params) {
             return descMatch;
         return titleMatch || descMatch; // 'both'
     });
-    const limit = params?.limit || 10000;
+    const limit = params?.limit || 250000;
     return filtered.slice(0, limit);
 }
-async function fetchMarketsDefault(params) {
-    const limit = params?.limit || 10000;
+async function fetchMarketsDefault(params, http) {
+    const limit = params?.limit || 250000;
     const offset = params?.offset || 0;
     const now = Date.now();
     const status = params?.status || 'active'; // Default to 'active'
@@ -196,13 +196,11 @@ async function fetchMarketsDefault(params) {
             const isSorted = params?.sort && (params.sort === 'volume' || params.sort === 'liquidity');
             const fetchLimit = isSorted ? 1000 : limit;
             const [allEvents, fetchedSeriesMap] = await Promise.all([
-                fetchActiveEvents(fetchLimit, apiStatus),
-                fetchSeriesMap()
+                fetchActiveEvents(http, fetchLimit, apiStatus),
+                fetchSeriesMap(http)
             ]);
             events = allEvents;
             seriesMap = fetchedSeriesMap;
-            events = allEvents;
-            seriesMap = fetchedSeriesMap;
             // Cache the dataset ONLY if:
             // 1. We fetched a comprehensive set (>= 1000)
             // 2. It's the standard 'open' status query

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

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

package/dist/exchanges/kalshi/fetchOHLCV.js

@@ -8,7 +8,7 @@ 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) {
+async function fetchOHLCV(id, params, http = axios_1.default) {
     (0, validation_1.validateIdFormat)(id, 'OHLCV');
     // Validate resolution is provided
     if (!params.resolution) {
@@ -57,7 +57,7 @@ async function fetchOHLCV(id, params) {
         }
         queryParams.start_ts = startTs;
         queryParams.end_ts = endTs;
-        const response = await axios_1.default.get(url, { params: queryParams });
+        const response = await http.get(url, { params: queryParams });
         const candles = response.data.candlesticks || [];
         const mappedCandles = candles.map((c) => {
             // Priority:

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

@@ -1,2 +1,3 @@
+import { AxiosInstance } from 'axios';
 import { OrderBook } from '../../types';
-export declare function fetchOrderBook(id: string): Promise<OrderBook>;
+export declare function fetchOrderBook(id: string, http?: AxiosInstance): Promise<OrderBook>;

package/dist/exchanges/kalshi/fetchOrderBook.js

@@ -7,14 +7,14 @@ exports.fetchOrderBook = fetchOrderBook;
 const axios_1 = __importDefault(require("axios"));
 const validation_1 = require("../../utils/validation");
 const errors_1 = require("./errors");
-async function fetchOrderBook(id) {
+async function fetchOrderBook(id, http = axios_1.default) {
     (0, validation_1.validateIdFormat)(id, 'OrderBook');
     try {
         // Check if this is a NO outcome request
         const isNoOutcome = id.endsWith('-NO');
         const ticker = id.replace(/-NO$/, '');
         const url = `https://api.elections.kalshi.com/trade-api/v2/markets/${ticker}/orderbook`;
-        const response = await axios_1.default.get(url);
+        const response = await http.get(url);
         const data = response.data.orderbook;
         // Structure: { yes: [[price, qty], ...], no: [[price, qty], ...] }
         // Kalshi returns bids at their actual prices (not inverted)

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

@@ -1,3 +1,4 @@
+import { AxiosInstance } from 'axios';
 import { HistoryFilterParams, TradesParams } from '../../BaseExchange';
 import { Trade } from '../../types';
-export declare function fetchTrades(id: string, params: TradesParams | HistoryFilterParams): Promise<Trade[]>;
+export declare function fetchTrades(id: string, params: TradesParams | HistoryFilterParams, http?: AxiosInstance): Promise<Trade[]>;

package/dist/exchanges/kalshi/fetchTrades.js

@@ -6,11 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchTrades = fetchTrades;
 const axios_1 = __importDefault(require("axios"));
 const errors_1 = require("./errors");
-async function fetchTrades(id, params) {
+async function fetchTrades(id, params, http = axios_1.default) {
     try {
         const ticker = id.replace(/-NO$/, '');
         const url = `https://api.elections.kalshi.com/trade-api/v2/markets/trades`;
-        const response = await axios_1.default.get(url, {
+        const response = await http.get(url, {
             params: {
                 ticker: ticker,
                 limit: params.limit || 100

package/dist/exchanges/kalshi/index.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KalshiExchange = void 0;
-const axios_1 = __importDefault(require("axios"));
 const BaseExchange_1 = require("../../BaseExchange");
 const fetchMarkets_1 = require("./fetchMarkets");
 const fetchEvents_1 = require("./fetchEvents");
@@ -72,16 +68,16 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
     // Market Data Methods - Implementation for CCXT-style API
     // ----------------------------------------------------------------------------
     async fetchMarketsImpl(params) {
-        return (0, fetchMarkets_1.fetchMarkets)(params);
+        return (0, fetchMarkets_1.fetchMarkets)(params, this.http);
     }
     async fetchEventsImpl(params) {
-        return (0, fetchEvents_1.fetchEvents)(params);
+        return (0, fetchEvents_1.fetchEvents)(params, this.http);
     }
     async fetchOHLCV(id, params) {
-        return (0, fetchOHLCV_1.fetchOHLCV)(id, params);
+        return (0, fetchOHLCV_1.fetchOHLCV)(id, params, this.http);
     }
     async fetchOrderBook(id) {
-        return (0, fetchOrderBook_1.fetchOrderBook)(id);
+        return (0, fetchOrderBook_1.fetchOrderBook)(id, this.http);
     }
     async fetchTrades(id, params) {
         // Deprecation warning
@@ -89,7 +85,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             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.');
         }
-        return (0, fetchTrades_1.fetchTrades)(id, params);
+        return (0, fetchTrades_1.fetchTrades)(id, params, this.http);
     }
     // ----------------------------------------------------------------------------
     // User Data Methods
@@ -103,7 +99,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             // TODO: Make base URL configurable in credentials
             const baseUrl = this.getBaseUrl();
             const headers = auth.getHeaders('GET', path);
-            const response = await axios_1.default.get(`${baseUrl}${path}`, { headers });
+            const response = await this.http.get(`${baseUrl}${path}`, { headers });
             // Kalshi response structure:
             // - balance: Available balance in cents (for trading)
             // - portfolio_value: Total portfolio value in cents (includes positions)
@@ -154,7 +150,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
                     kalshiOrder.no_price = priceInCents;
                 }
             }
-            const response = await axios_1.default.post(`${baseUrl}${path}`, kalshiOrder, { headers });
+            const response = await this.http.post(`${baseUrl}${path}`, kalshiOrder, { headers });
             const order = response.data.order;
             return {
                 id: order.order_id,
@@ -180,7 +176,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             const path = `/trade-api/v2/portfolio/orders/${orderId}`;
             const baseUrl = this.getBaseUrl();
             const headers = auth.getHeaders('DELETE', path);
-            const response = await axios_1.default.delete(`${baseUrl}${path}`, { headers });
+            const response = await this.http.delete(`${baseUrl}${path}`, { headers });
             const order = response.data.order;
             return {
                 id: order.order_id,
@@ -205,7 +201,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             const path = `/trade-api/v2/portfolio/orders/${orderId}`;
             const baseUrl = this.getBaseUrl();
             const headers = auth.getHeaders('GET', path);
-            const response = await axios_1.default.get(`${baseUrl}${path}`, { headers });
+            const response = await this.http.get(`${baseUrl}${path}`, { headers });
             const order = response.data.order;
             return {
                 id: order.order_id,
@@ -237,7 +233,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             const baseUrl = this.getBaseUrl();
             // Sign only the base path, not the query parameters
             const headers = auth.getHeaders('GET', basePath);
-            const response = await axios_1.default.get(`${baseUrl}${basePath}${queryParams}`, { headers });
+            const response = await this.http.get(`${baseUrl}${basePath}${queryParams}`, { headers });
             const orders = response.data.orders || [];
             return orders.map((order) => ({
                 id: order.order_id,
@@ -263,7 +259,7 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
             const path = '/trade-api/v2/portfolio/positions';
             const baseUrl = this.getBaseUrl();
             const headers = auth.getHeaders('GET', path);
-            const response = await axios_1.default.get(`${baseUrl}${path}`, { headers });
+            const response = await this.http.get(`${baseUrl}${path}`, { headers });
             const positions = response.data.market_positions || [];
             return positions.map((pos) => {
                 const absPosition = Math.abs(pos.position);

package/dist/exchanges/kalshi/kalshi.test.js

@@ -6,8 +6,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const kalshi_1 = require("../kalshi");
 const axios_1 = __importDefault(require("axios"));
 const auth_1 = require("./auth");
-// Mock axios
-jest.mock('axios');
+// Jest hoisting means we can't use outer variables in jest.mock factory
+// unless they start with 'mock'. However, let's just define it inline to be safe and simple.
+// To access the inner methods, we'll grab the instance returned by axios.create().
+jest.mock('axios', () => {
+    const mockInstance = {
+        interceptors: {
+            request: { use: jest.fn() },
+            response: { use: jest.fn() },
+        },
+        get: jest.fn(),
+        post: jest.fn(),
+        delete: jest.fn(),
+        defaults: { headers: { common: {} } },
+    };
+    const mockAxios = {
+        create: jest.fn(() => mockInstance),
+    };
+    // Support both default and named exports
+    return {
+        __esModule: true,
+        ...mockAxios,
+        default: mockAxios,
+    };
+});
+// Access the mocked instance for assertions
+// Since our factory returns the same object reference, this works.
+const mockAxiosInstance = axios_1.default.create();
 const mockedAxios = axios_1.default;
 // Mock KalshiAuth
 jest.mock('./auth');
@@ -20,6 +45,10 @@ describe('KalshiExchange', () => {
     };
     beforeEach(() => {
         jest.clearAllMocks();
+        // Reset the mock instance methods to ensure clean state
+        mockAxiosInstance.get.mockReset();
+        mockAxiosInstance.post.mockReset();
+        mockAxiosInstance.delete.mockReset();
         // Mock the getHeaders method
         MockedKalshiAuth.prototype.getHeaders = jest.fn().mockReturnValue({
             'KALSHI-ACCESS-KEY': 'test-api-key',
@@ -56,7 +85,7 @@ describe('KalshiExchange', () => {
                     ]
                 }
             };
-            mockedAxios.get.mockResolvedValue(mockResponse);
+            mockAxiosInstance.get.mockResolvedValue(mockResponse);
             const markets = await exchange.fetchMarkets();
             expect(markets).toBeDefined();
         });
@@ -88,9 +117,9 @@ describe('KalshiExchange', () => {
                         }
                     }
                 };
-                mockedAxios.post.mockResolvedValue(mockResponse);
+                mockAxiosInstance.post.mockResolvedValue(mockResponse);
                 const order = await exchange.createOrder(orderParams);
-                expect(mockedAxios.post).toHaveBeenCalledWith('https://api.elections.kalshi.com/trade-api/v2/portfolio/orders', expect.objectContaining({
+                expect(mockAxiosInstance.post).toHaveBeenCalledWith('https://api.elections.kalshi.com/trade-api/v2/portfolio/orders', expect.objectContaining({
                     ticker: 'TEST-MARKET',
                     side: 'yes',
                     action: 'buy',
@@ -123,9 +152,9 @@ describe('KalshiExchange', () => {
                         }
                     }
                 };
-                mockedAxios.post.mockResolvedValue(mockResponse);
+                mockAxiosInstance.post.mockResolvedValue(mockResponse);
                 await exchange.createOrder(orderParams);
-                expect(mockedAxios.post).toHaveBeenCalledWith('https://api.elections.kalshi.com/trade-api/v2/portfolio/orders', expect.objectContaining({
+                expect(mockAxiosInstance.post).toHaveBeenCalledWith('https://api.elections.kalshi.com/trade-api/v2/portfolio/orders', expect.objectContaining({
                     ticker: 'TEST-MARKET',
                     side: 'no',
                     action: 'sell',
@@ -153,18 +182,18 @@ describe('KalshiExchange', () => {
                         ]
                     }
                 };
-                mockedAxios.get.mockResolvedValue(mockResponse);
+                mockAxiosInstance.get.mockResolvedValue(mockResponse);
                 await exchange.fetchOpenOrders();
                 // Verify the request URL includes query params
-                expect(mockedAxios.get).toHaveBeenCalledWith('https://api.elections.kalshi.com/trade-api/v2/portfolio/orders?status=resting', expect.any(Object));
+                expect(mockAxiosInstance.get).toHaveBeenCalledWith('https://api.elections.kalshi.com/trade-api/v2/portfolio/orders?status=resting', expect.any(Object));
                 // Verify getHeaders was called with base path only (no query params)
                 expect(MockedKalshiAuth.prototype.getHeaders).toHaveBeenCalledWith('GET', '/trade-api/v2/portfolio/orders');
             });
             it('should include ticker in query params when marketId provided', async () => {
                 const mockResponse = { data: { orders: [] } };
-                mockedAxios.get.mockResolvedValue(mockResponse);
+                mockAxiosInstance.get.mockResolvedValue(mockResponse);
                 await exchange.fetchOpenOrders('TEST-MARKET');
-                expect(mockedAxios.get).toHaveBeenCalledWith('https://api.elections.kalshi.com/trade-api/v2/portfolio/orders?status=resting&ticker=TEST-MARKET', expect.any(Object));
+                expect(mockAxiosInstance.get).toHaveBeenCalledWith('https://api.elections.kalshi.com/trade-api/v2/portfolio/orders?status=resting&ticker=TEST-MARKET', expect.any(Object));
             });
         });
         describe('fetchPositions', () => {
@@ -182,7 +211,7 @@ describe('KalshiExchange', () => {
                         ]
                     }
                 };
-                mockedAxios.get.mockResolvedValue(mockResponse);
+                mockAxiosInstance.get.mockResolvedValue(mockResponse);
                 const positions = await exchange.fetchPositions();
                 expect(positions).toHaveLength(1);
                 expect(positions[0].size).toBe(0);
@@ -202,7 +231,7 @@ describe('KalshiExchange', () => {
                         ]
                     }
                 };
-                mockedAxios.get.mockResolvedValue(mockResponse);
+                mockAxiosInstance.get.mockResolvedValue(mockResponse);
                 const positions = await exchange.fetchPositions();
                 expect(positions).toHaveLength(1);
                 expect(positions[0].size).toBe(10);
@@ -224,7 +253,7 @@ describe('KalshiExchange', () => {
                         ]
                     }
                 };
-                mockedAxios.get.mockResolvedValue(mockResponse);
+                mockAxiosInstance.get.mockResolvedValue(mockResponse);
                 const positions = await exchange.fetchPositions();
                 expect(positions[0].size).toBe(-5); // Negative for short
                 expect(Math.abs(positions[0].size)).toBe(5); // Absolute value
@@ -238,7 +267,7 @@ describe('KalshiExchange', () => {
                         portfolio_value: 15000 // $150.00 total
                     }
                 };
-                mockedAxios.get.mockResolvedValue(mockResponse);
+                mockAxiosInstance.get.mockResolvedValue(mockResponse);
                 const balances = await exchange.fetchBalance();
                 expect(balances).toHaveLength(1);
                 expect(balances[0].currency).toBe('USD');
@@ -261,7 +290,7 @@ describe('KalshiExchange', () => {
                         }
                     }
                 };
-                mockedAxios.delete.mockResolvedValue(mockResponse);
+                mockAxiosInstance.delete.mockResolvedValue(mockResponse);
                 const order = await exchange.cancelOrder('order-123');
                 expect(order.status).toBe('cancelled');
                 expect(order.filled).toBe(5); // count - remaining_count
@@ -285,7 +314,7 @@ describe('KalshiExchange', () => {
                     }
                 }
             };
-            mockedAxios.get.mockResolvedValue(mockResponse);
+            mockAxiosInstance.get.mockResolvedValue(mockResponse);
             const order = await exchange.fetchOrder('order-123');
             expect(order.status).toBe('open');
         });
@@ -301,7 +330,7 @@ describe('KalshiExchange', () => {
                     }
                 }
             };
-            mockedAxios.get.mockResolvedValue(mockResponse);
+            mockAxiosInstance.get.mockResolvedValue(mockResponse);
             const order = await exchange.fetchOrder('order-123');
             expect(order.status).toBe('filled');
         });