pmxt-core 2.8.0 → 2.9.1

package/dist/exchanges/kalshi/index.js

@@ -5,12 +5,13 @@ const BaseExchange_1 = require("../../BaseExchange");
 const fetchMarkets_1 = require("./fetchMarkets");
 const fetchEvents_1 = require("./fetchEvents");
 const fetchOHLCV_1 = require("./fetchOHLCV");
-const fetchOrderBook_1 = require("./fetchOrderBook");
-const fetchTrades_1 = require("./fetchTrades");
 const auth_1 = require("./auth");
+const validation_1 = require("../../utils/validation");
 const websocket_1 = require("./websocket");
 const errors_1 = require("./errors");
 const errors_2 = require("../../errors");
+const openapi_1 = require("../../utils/openapi");
+const api_1 = require("./api");
 class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
     has = {
         fetchMarkets: true,
@@ -47,12 +48,23 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
         if (credentials?.apiKey && credentials?.privateKey) {
             this.auth = new auth_1.KalshiAuth(credentials);
         }
+        const descriptor = (0, openapi_1.parseOpenApiSpec)(api_1.kalshiApiSpec);
+        this.defineImplicitApi(descriptor);
     }
     get name() {
         return "Kalshi";
     }
-    getBaseUrl() {
-        return 'https://api.elections.kalshi.com';
+    // ----------------------------------------------------------------------------
+    // Implicit API Auth & Error Mapping
+    // ----------------------------------------------------------------------------
+    sign(method, path, _params) {
+        const auth = this.ensureAuth();
+        // The implicit API passes just the spec path (e.g. /portfolio/balance),
+        // but Kalshi's signature requires the full path including /trade-api/v2.
+        return auth.getHeaders(method, '/trade-api/v2' + path);
+    }
+    mapImplicitApiError(error) {
+        throw errors_1.kalshiErrorMapper.mapError(error);
     }
     // ----------------------------------------------------------------------------
     // Helpers
@@ -68,218 +80,184 @@ class KalshiExchange extends BaseExchange_1.PredictionMarketExchange {
     // Market Data Methods - Implementation for CCXT-style API
     // ----------------------------------------------------------------------------
     async fetchMarketsImpl(params) {
-        return (0, fetchMarkets_1.fetchMarkets)(params, this.http);
+        return (0, fetchMarkets_1.fetchMarkets)(params, this.callApi.bind(this));
     }
     async fetchEventsImpl(params) {
-        return (0, fetchEvents_1.fetchEvents)(params, this.http);
+        return (0, fetchEvents_1.fetchEvents)(params, this.callApi.bind(this));
     }
     async fetchOHLCV(id, params) {
-        return (0, fetchOHLCV_1.fetchOHLCV)(id, params, this.http);
+        return (0, fetchOHLCV_1.fetchOHLCV)(id, params, this.callApi.bind(this));
     }
     async fetchOrderBook(id) {
-        return (0, fetchOrderBook_1.fetchOrderBook)(id, this.http);
+        (0, validation_1.validateIdFormat)(id, 'OrderBook');
+        const isNoOutcome = id.endsWith('-NO');
+        const ticker = id.replace(/-NO$/, '');
+        const data = (await this.callApi('GetMarketOrderbook', { ticker })).orderbook;
+        let bids;
+        let asks;
+        if (isNoOutcome) {
+            bids = (data.no || []).map((level) => ({
+                price: level[0] / 100,
+                size: level[1],
+            }));
+            asks = (data.yes || []).map((level) => ({
+                price: 1 - (level[0] / 100),
+                size: level[1],
+            }));
+        }
+        else {
+            bids = (data.yes || []).map((level) => ({
+                price: level[0] / 100,
+                size: level[1],
+            }));
+            asks = (data.no || []).map((level) => ({
+                price: 1 - (level[0] / 100),
+                size: level[1],
+            }));
+        }
+        bids.sort((a, b) => b.price - a.price);
+        asks.sort((a, b) => a.price - b.price);
+        return { bids, asks, timestamp: Date.now() };
     }
     async fetchTrades(id, params) {
-        // Deprecation warning
         if ('resolution' in params && params.resolution !== undefined) {
             console.warn('[pmxt] Warning: The "resolution" parameter is deprecated for fetchTrades() and will be ignored. ' +
                 'It will be removed in v3.0.0. Please remove it from your code.');
         }
-        return (0, fetchTrades_1.fetchTrades)(id, params, this.http);
+        const ticker = id.replace(/-NO$/, '');
+        const data = await this.callApi('GetTrades', { ticker, limit: params.limit || 100 });
+        const trades = data.trades || [];
+        return trades.map((t) => ({
+            id: t.trade_id,
+            timestamp: new Date(t.created_time).getTime(),
+            price: t.yes_price / 100,
+            amount: t.count,
+            side: t.taker_side === 'yes' ? 'buy' : 'sell',
+        }));
     }
     // ----------------------------------------------------------------------------
     // User Data Methods
     // ----------------------------------------------------------------------------
     async fetchBalance() {
-        try {
-            const auth = this.ensureAuth();
-            const path = '/trade-api/v2/portfolio/balance';
-            // Use demo-api if it's a sandbox key (usually indicated by config, but defaulting to prod for now)
-            // Or we could detect it. For now, let's assume Production unless specified.
-            // TODO: Make base URL configurable in credentials
-            const baseUrl = this.getBaseUrl();
-            const headers = auth.getHeaders('GET', path);
-            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)
-            // - updated_ts: Unix timestamp of last update
-            const balanceCents = response.data.balance;
-            const portfolioValueCents = response.data.portfolio_value;
-            const available = balanceCents / 100;
-            const total = portfolioValueCents / 100;
-            const locked = total - available;
-            return [{
-                    currency: 'USD',
-                    total: total, // Total portfolio value (cash + positions)
-                    available: available, // Available for trading
-                    locked: locked // Value locked in positions
-                }];
-        }
-        catch (error) {
-            throw errors_1.kalshiErrorMapper.mapError(error);
-        }
+        const data = await this.callApi('GetBalance');
+        const available = data.balance / 100;
+        const total = data.portfolio_value / 100;
+        return [{
+                currency: 'USD',
+                total,
+                available,
+                locked: total - available,
+            }];
     }
     // ----------------------------------------------------------------------------
     // Trading Methods
     // ----------------------------------------------------------------------------
     async createOrder(params) {
-        try {
-            const auth = this.ensureAuth();
-            const path = '/trade-api/v2/portfolio/orders';
-            const baseUrl = this.getBaseUrl();
-            const headers = auth.getHeaders('POST', path);
-            // Map unified params to Kalshi format
-            // Kalshi uses 'yes'/'no' for side and 'buy'/'sell' for action
-            const isYesSide = params.side === 'buy';
-            const kalshiOrder = {
-                ticker: params.marketId, // Kalshi uses ticker for market identification
-                client_order_id: `pmxt-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-                side: isYesSide ? 'yes' : 'no',
-                action: params.side === 'buy' ? 'buy' : 'sell',
-                count: params.amount, // Number of contracts
-                type: params.type === 'limit' ? 'limit' : 'market'
-            };
-            // Add price field based on side (yes_price for yes side, no_price for no side)
-            if (params.price) {
-                const priceInCents = Math.round(params.price * 100);
-                if (isYesSide) {
-                    kalshiOrder.yes_price = priceInCents;
-                }
-                else {
-                    kalshiOrder.no_price = priceInCents;
-                }
+        const isYesSide = params.side === 'buy';
+        const kalshiOrder = {
+            ticker: params.marketId,
+            client_order_id: `pmxt-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            side: isYesSide ? 'yes' : 'no',
+            action: params.side === 'buy' ? 'buy' : 'sell',
+            count: params.amount,
+            type: params.type === 'limit' ? 'limit' : 'market',
+        };
+        if (params.price) {
+            const priceInCents = Math.round(params.price * 100);
+            if (isYesSide) {
+                kalshiOrder.yes_price = priceInCents;
+            }
+            else {
+                kalshiOrder.no_price = priceInCents;
             }
-            const response = await this.http.post(`${baseUrl}${path}`, kalshiOrder, { headers });
-            const order = response.data.order;
-            return {
-                id: order.order_id,
-                marketId: params.marketId,
-                outcomeId: params.outcomeId,
-                side: params.side,
-                type: params.type,
-                price: params.price,
-                amount: params.amount,
-                status: this.mapKalshiOrderStatus(order.status),
-                filled: order.queue_position === 0 ? params.amount : 0,
-                remaining: order.remaining_count || params.amount,
-                timestamp: new Date(order.created_time).getTime()
-            };
-        }
-        catch (error) {
-            throw errors_1.kalshiErrorMapper.mapError(error);
         }
+        const data = await this.callApi('CreateOrder', kalshiOrder);
+        const order = data.order;
+        return {
+            id: order.order_id,
+            marketId: params.marketId,
+            outcomeId: params.outcomeId,
+            side: params.side,
+            type: params.type,
+            price: params.price,
+            amount: params.amount,
+            status: this.mapKalshiOrderStatus(order.status),
+            filled: order.queue_position === 0 ? params.amount : 0,
+            remaining: order.remaining_count || params.amount,
+            timestamp: new Date(order.created_time).getTime(),
+        };
     }
     async cancelOrder(orderId) {
-        try {
-            const auth = this.ensureAuth();
-            const path = `/trade-api/v2/portfolio/orders/${orderId}`;
-            const baseUrl = this.getBaseUrl();
-            const headers = auth.getHeaders('DELETE', path);
-            const response = await this.http.delete(`${baseUrl}${path}`, { headers });
-            const order = response.data.order;
-            return {
-                id: order.order_id,
-                marketId: order.ticker,
-                outcomeId: order.ticker,
-                side: order.side === 'yes' ? 'buy' : 'sell',
-                type: 'limit',
-                amount: order.count,
-                status: 'cancelled',
-                filled: order.count - (order.remaining_count || 0),
-                remaining: 0,
-                timestamp: new Date(order.created_time).getTime()
-            };
-        }
-        catch (error) {
-            throw errors_1.kalshiErrorMapper.mapError(error);
-        }
+        const data = await this.callApi('CancelOrder', { order_id: orderId });
+        const order = data.order;
+        return {
+            id: order.order_id,
+            marketId: order.ticker,
+            outcomeId: order.ticker,
+            side: order.side === 'yes' ? 'buy' : 'sell',
+            type: 'limit',
+            amount: order.count,
+            status: 'cancelled',
+            filled: order.count - (order.remaining_count || 0),
+            remaining: 0,
+            timestamp: new Date(order.created_time).getTime(),
+        };
     }
     async fetchOrder(orderId) {
-        try {
-            const auth = this.ensureAuth();
-            const path = `/trade-api/v2/portfolio/orders/${orderId}`;
-            const baseUrl = this.getBaseUrl();
-            const headers = auth.getHeaders('GET', path);
-            const response = await this.http.get(`${baseUrl}${path}`, { headers });
-            const order = response.data.order;
-            return {
-                id: order.order_id,
-                marketId: order.ticker,
-                outcomeId: order.ticker,
-                side: order.side === 'yes' ? 'buy' : 'sell',
-                type: order.type === 'limit' ? 'limit' : 'market',
-                price: order.yes_price ? order.yes_price / 100 : undefined,
-                amount: order.count,
-                status: this.mapKalshiOrderStatus(order.status),
-                filled: order.count - (order.remaining_count || 0),
-                remaining: order.remaining_count || 0,
-                timestamp: new Date(order.created_time).getTime()
-            };
-        }
-        catch (error) {
-            throw errors_1.kalshiErrorMapper.mapError(error);
-        }
+        const data = await this.callApi('GetOrder', { order_id: orderId });
+        const order = data.order;
+        return {
+            id: order.order_id,
+            marketId: order.ticker,
+            outcomeId: order.ticker,
+            side: order.side === 'yes' ? 'buy' : 'sell',
+            type: order.type === 'limit' ? 'limit' : 'market',
+            price: order.yes_price ? order.yes_price / 100 : undefined,
+            amount: order.count,
+            status: this.mapKalshiOrderStatus(order.status),
+            filled: order.count - (order.remaining_count || 0),
+            remaining: order.remaining_count || 0,
+            timestamp: new Date(order.created_time).getTime(),
+        };
     }
     async fetchOpenOrders(marketId) {
-        try {
-            const auth = this.ensureAuth();
-            // CRITICAL: Query parameters must NOT be included in the signature
-            const basePath = '/trade-api/v2/portfolio/orders';
-            let queryParams = '?status=resting';
-            if (marketId) {
-                queryParams += `&ticker=${marketId}`;
-            }
-            const baseUrl = this.getBaseUrl();
-            // Sign only the base path, not the query parameters
-            const headers = auth.getHeaders('GET', basePath);
-            const response = await this.http.get(`${baseUrl}${basePath}${queryParams}`, { headers });
-            const orders = response.data.orders || [];
-            return orders.map((order) => ({
-                id: order.order_id,
-                marketId: order.ticker,
-                outcomeId: order.ticker,
-                side: order.side === 'yes' ? 'buy' : 'sell',
-                type: order.type === 'limit' ? 'limit' : 'market',
-                price: order.yes_price ? order.yes_price / 100 : undefined,
-                amount: order.count,
-                status: 'open',
-                filled: order.count - (order.remaining_count || 0),
-                remaining: order.remaining_count || 0,
-                timestamp: new Date(order.created_time).getTime()
-            }));
-        }
-        catch (error) {
-            throw errors_1.kalshiErrorMapper.mapError(error);
+        const queryParams = { status: 'resting' };
+        if (marketId) {
+            queryParams.ticker = marketId;
         }
+        const data = await this.callApi('GetOrders', queryParams);
+        const orders = data.orders || [];
+        return orders.map((order) => ({
+            id: order.order_id,
+            marketId: order.ticker,
+            outcomeId: order.ticker,
+            side: order.side === 'yes' ? 'buy' : 'sell',
+            type: order.type === 'limit' ? 'limit' : 'market',
+            price: order.yes_price ? order.yes_price / 100 : undefined,
+            amount: order.count,
+            status: 'open',
+            filled: order.count - (order.remaining_count || 0),
+            remaining: order.remaining_count || 0,
+            timestamp: new Date(order.created_time).getTime(),
+        }));
     }
     async fetchPositions() {
-        try {
-            const auth = this.ensureAuth();
-            const path = '/trade-api/v2/portfolio/positions';
-            const baseUrl = this.getBaseUrl();
-            const headers = auth.getHeaders('GET', path);
-            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);
-                // Prevent division by zero
-                const entryPrice = absPosition > 0 ? pos.total_cost / absPosition / 100 : 0;
-                return {
-                    marketId: pos.ticker,
-                    outcomeId: pos.ticker,
-                    outcomeLabel: pos.ticker, // Kalshi uses ticker as the outcome label
-                    size: pos.position, // Positive for long, negative for short
-                    entryPrice: entryPrice,
-                    currentPrice: pos.market_price ? pos.market_price / 100 : entryPrice,
-                    unrealizedPnL: pos.market_exposure ? pos.market_exposure / 100 : 0,
-                    realizedPnL: pos.realized_pnl ? pos.realized_pnl / 100 : 0
-                };
-            });
-        }
-        catch (error) {
-            throw errors_1.kalshiErrorMapper.mapError(error);
-        }
+        const data = await this.callApi('GetPositions');
+        const positions = data.market_positions || [];
+        return positions.map((pos) => {
+            const absPosition = Math.abs(pos.position);
+            const entryPrice = absPosition > 0 ? pos.total_cost / absPosition / 100 : 0;
+            return {
+                marketId: pos.ticker,
+                outcomeId: pos.ticker,
+                outcomeLabel: pos.ticker,
+                size: pos.position,
+                entryPrice,
+                currentPrice: pos.market_price ? pos.market_price / 100 : entryPrice,
+                unrealizedPnL: pos.market_exposure ? pos.market_exposure / 100 : 0,
+                realizedPnL: pos.realized_pnl ? pos.realized_pnl / 100 : 0,
+            };
+        });
     }
     // Helper to map Kalshi order status to unified status
     mapKalshiOrderStatus(status) {

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

@@ -18,10 +18,13 @@ jest.mock('axios', () => {
         get: jest.fn(),
         post: jest.fn(),
         delete: jest.fn(),
+        request: jest.fn(),
         defaults: { headers: { common: {} } },
     };
+    const actualAxios = jest.requireActual('axios');
     const mockAxios = {
         create: jest.fn(() => mockInstance),
+        isAxiosError: actualAxios.isAxiosError,
     };
     // Support both default and named exports
     return {
@@ -49,6 +52,7 @@ describe('KalshiExchange', () => {
         mockAxiosInstance.get.mockReset();
         mockAxiosInstance.post.mockReset();
         mockAxiosInstance.delete.mockReset();
+        mockAxiosInstance.request.mockReset();
         // Mock the getHeaders method
         MockedKalshiAuth.prototype.getHeaders = jest.fn().mockReturnValue({
             'KALSHI-ACCESS-KEY': 'test-api-key',
@@ -85,7 +89,7 @@ describe('KalshiExchange', () => {
                     ]
                 }
             };
-            mockAxiosInstance.get.mockResolvedValue(mockResponse);
+            mockAxiosInstance.request.mockResolvedValue(mockResponse);
             const markets = await exchange.fetchMarkets();
             expect(markets).toBeDefined();
         });
@@ -117,16 +121,20 @@ describe('KalshiExchange', () => {
                         }
                     }
                 };
-                mockAxiosInstance.post.mockResolvedValue(mockResponse);
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 const order = await exchange.createOrder(orderParams);
-                expect(mockAxiosInstance.post).toHaveBeenCalledWith('https://api.elections.kalshi.com/trade-api/v2/portfolio/orders', expect.objectContaining({
-                    ticker: 'TEST-MARKET',
-                    side: 'yes',
-                    action: 'buy',
-                    count: 10,
-                    type: 'limit',
-                    yes_price: 55 // 0.55 * 100
-                }), expect.any(Object));
+                expect(mockAxiosInstance.request).toHaveBeenCalledWith(expect.objectContaining({
+                    method: 'POST',
+                    url: 'https://api.elections.kalshi.com/trade-api/v2/portfolio/orders',
+                    data: expect.objectContaining({
+                        ticker: 'TEST-MARKET',
+                        side: 'yes',
+                        action: 'buy',
+                        count: 10,
+                        type: 'limit',
+                        yes_price: 55 // 0.55 * 100
+                    }),
+                }));
                 expect(order.id).toBe('order-123');
                 expect(order.status).toBe('open');
             });
@@ -152,16 +160,20 @@ describe('KalshiExchange', () => {
                         }
                     }
                 };
-                mockAxiosInstance.post.mockResolvedValue(mockResponse);
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 await exchange.createOrder(orderParams);
-                expect(mockAxiosInstance.post).toHaveBeenCalledWith('https://api.elections.kalshi.com/trade-api/v2/portfolio/orders', expect.objectContaining({
-                    ticker: 'TEST-MARKET',
-                    side: 'no',
-                    action: 'sell',
-                    count: 5,
-                    type: 'limit',
-                    no_price: 45 // 0.45 * 100
-                }), expect.any(Object));
+                expect(mockAxiosInstance.request).toHaveBeenCalledWith(expect.objectContaining({
+                    method: 'POST',
+                    url: 'https://api.elections.kalshi.com/trade-api/v2/portfolio/orders',
+                    data: expect.objectContaining({
+                        ticker: 'TEST-MARKET',
+                        side: 'no',
+                        action: 'sell',
+                        count: 5,
+                        type: 'limit',
+                        no_price: 45 // 0.45 * 100
+                    }),
+                }));
             });
         });
         describe('fetchOpenOrders', () => {
@@ -182,18 +194,26 @@ describe('KalshiExchange', () => {
                         ]
                     }
                 };
-                mockAxiosInstance.get.mockResolvedValue(mockResponse);
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 await exchange.fetchOpenOrders();
-                // Verify the request URL includes query params
-                expect(mockAxiosInstance.get).toHaveBeenCalledWith('https://api.elections.kalshi.com/trade-api/v2/portfolio/orders?status=resting', expect.any(Object));
+                // Verify the request includes the correct params
+                expect(mockAxiosInstance.request).toHaveBeenCalledWith(expect.objectContaining({
+                    method: 'GET',
+                    url: 'https://api.elections.kalshi.com/trade-api/v2/portfolio/orders',
+                    params: expect.objectContaining({ status: 'resting' }),
+                }));
                 // 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: [] } };
-                mockAxiosInstance.get.mockResolvedValue(mockResponse);
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 await exchange.fetchOpenOrders('TEST-MARKET');
-                expect(mockAxiosInstance.get).toHaveBeenCalledWith('https://api.elections.kalshi.com/trade-api/v2/portfolio/orders?status=resting&ticker=TEST-MARKET', expect.any(Object));
+                expect(mockAxiosInstance.request).toHaveBeenCalledWith(expect.objectContaining({
+                    method: 'GET',
+                    url: 'https://api.elections.kalshi.com/trade-api/v2/portfolio/orders',
+                    params: expect.objectContaining({ status: 'resting', ticker: 'TEST-MARKET' }),
+                }));
             });
         });
         describe('fetchPositions', () => {
@@ -211,7 +231,7 @@ describe('KalshiExchange', () => {
                         ]
                     }
                 };
-                mockAxiosInstance.get.mockResolvedValue(mockResponse);
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 const positions = await exchange.fetchPositions();
                 expect(positions).toHaveLength(1);
                 expect(positions[0].size).toBe(0);
@@ -231,7 +251,7 @@ describe('KalshiExchange', () => {
                         ]
                     }
                 };
-                mockAxiosInstance.get.mockResolvedValue(mockResponse);
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 const positions = await exchange.fetchPositions();
                 expect(positions).toHaveLength(1);
                 expect(positions[0].size).toBe(10);
@@ -253,7 +273,7 @@ describe('KalshiExchange', () => {
                         ]
                     }
                 };
-                mockAxiosInstance.get.mockResolvedValue(mockResponse);
+                mockAxiosInstance.request.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
@@ -267,7 +287,7 @@ describe('KalshiExchange', () => {
                         portfolio_value: 15000 // $150.00 total
                     }
                 };
-                mockAxiosInstance.get.mockResolvedValue(mockResponse);
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 const balances = await exchange.fetchBalance();
                 expect(balances).toHaveLength(1);
                 expect(balances[0].currency).toBe('USD');
@@ -290,7 +310,7 @@ describe('KalshiExchange', () => {
                         }
                     }
                 };
-                mockAxiosInstance.delete.mockResolvedValue(mockResponse);
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 const order = await exchange.cancelOrder('order-123');
                 expect(order.status).toBe('cancelled');
                 expect(order.filled).toBe(5); // count - remaining_count
@@ -314,7 +334,7 @@ describe('KalshiExchange', () => {
                     }
                 }
             };
-            mockAxiosInstance.get.mockResolvedValue(mockResponse);
+            mockAxiosInstance.request.mockResolvedValue(mockResponse);
             const order = await exchange.fetchOrder('order-123');
             expect(order.status).toBe('open');
         });
@@ -330,7 +350,7 @@ describe('KalshiExchange', () => {
                     }
                 }
             };
-            mockAxiosInstance.get.mockResolvedValue(mockResponse);
+            mockAxiosInstance.request.mockResolvedValue(mockResponse);
             const order = await exchange.fetchOrder('order-123');
             expect(order.status).toBe('filled');
         });