pmxt-core 2.9.2 → 2.9.3

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

@@ -6,10 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const kalshi_1 = require("../kalshi");
 const axios_1 = __importDefault(require("axios"));
 const auth_1 = require("./auth");
+const config_1 = require("./config");
 // 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', () => {
+jest.mock("axios", () => {
     const mockInstance = {
         interceptors: {
             request: { use: jest.fn() },
@@ -21,7 +22,7 @@ jest.mock('axios', () => {
         request: jest.fn(),
         defaults: { headers: { common: {} } },
     };
-    const actualAxios = jest.requireActual('axios');
+    const actualAxios = jest.requireActual("axios");
     const mockAxios = {
         create: jest.fn(() => mockInstance),
         isAxiosError: actualAxios.isAxiosError,
@@ -38,13 +39,13 @@ jest.mock('axios', () => {
 const mockAxiosInstance = axios_1.default.create();
 const mockedAxios = axios_1.default;
 // Mock KalshiAuth
-jest.mock('./auth');
+jest.mock("./auth");
 const MockedKalshiAuth = auth_1.KalshiAuth;
-describe('KalshiExchange', () => {
+describe("KalshiExchange", () => {
     let exchange;
     const mockCredentials = {
-        apiKey: 'test-api-key',
-        privateKey: 'mock-private-key'
+        apiKey: "test-api-key",
+        privateKey: "mock-private-key",
     };
     beforeEach(() => {
         jest.clearAllMocks();
@@ -55,181 +56,184 @@ describe('KalshiExchange', () => {
         mockAxiosInstance.request.mockReset();
         // Mock the getHeaders method
         MockedKalshiAuth.prototype.getHeaders = jest.fn().mockReturnValue({
-            'KALSHI-ACCESS-KEY': 'test-api-key',
-            'KALSHI-ACCESS-TIMESTAMP': '1234567890',
-            'KALSHI-ACCESS-SIGNATURE': 'mock-signature',
-            'Content-Type': 'application/json'
+            "KALSHI-ACCESS-KEY": "test-api-key",
+            "KALSHI-ACCESS-TIMESTAMP": "1234567890",
+            "KALSHI-ACCESS-SIGNATURE": "mock-signature",
+            "Content-Type": "application/json",
         });
     });
-    describe('Authentication', () => {
-        it('should throw error when trading without credentials', async () => {
+    describe("Authentication", () => {
+        it("should throw error when trading without credentials", async () => {
             exchange = new kalshi_1.KalshiExchange();
-            await expect(exchange.fetchBalance()).rejects.toThrow('Trading operations require authentication');
+            await expect(exchange.fetchBalance()).rejects.toThrow("Trading operations require authentication");
         });
-        it('should initialize with credentials', () => {
+        it("should initialize with credentials", () => {
             exchange = new kalshi_1.KalshiExchange(mockCredentials);
             expect(exchange).toBeDefined();
         });
     });
-    describe('Market Data Methods', () => {
+    describe("Market Data Methods", () => {
         beforeEach(() => {
             exchange = new kalshi_1.KalshiExchange();
         });
-        it('should fetch markets', async () => {
+        it("should fetch markets", async () => {
             const mockResponse = {
                 data: {
                     markets: [
                         {
-                            ticker: 'TEST-MARKET',
-                            title: 'Test Market',
+                            ticker: "TEST-MARKET",
+                            title: "Test Market",
                             yes_bid: 50,
                             yes_ask: 52,
-                            volume: 1000
-                        }
-                    ]
-                }
+                            volume: 1000,
+                        },
+                    ],
+                },
             };
             mockAxiosInstance.request.mockResolvedValue(mockResponse);
             const markets = await exchange.fetchMarkets();
             expect(markets).toBeDefined();
         });
     });
-    describe('Trading Methods', () => {
+    describe("Trading Methods", () => {
         beforeEach(() => {
             exchange = new kalshi_1.KalshiExchange(mockCredentials);
         });
-        describe('createOrder', () => {
-            it('should create buy order with yes_price for buy side', async () => {
+        describe("createOrder", () => {
+            it("should create buy order with yes_price for buy side", async () => {
                 const orderParams = {
-                    marketId: 'TEST-MARKET',
-                    outcomeId: 'yes',
-                    side: 'buy',
-                    type: 'limit',
+                    marketId: "TEST-MARKET",
+                    outcomeId: "yes",
+                    side: "buy",
+                    type: "limit",
                     amount: 10,
-                    price: 0.55
+                    price: 0.55,
                 };
                 const mockResponse = {
                     data: {
                         order: {
-                            order_id: 'order-123',
-                            ticker: 'TEST-MARKET',
-                            status: 'resting',
+                            order_id: "order-123",
+                            ticker: "TEST-MARKET",
+                            status: "resting",
                             count: 10,
                             remaining_count: 10,
-                            created_time: '2026-01-13T12:00:00Z',
-                            queue_position: 1
-                        }
-                    }
+                            created_time: "2026-01-13T12:00:00Z",
+                            queue_position: 1,
+                        },
+                    },
                 };
                 mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 const order = await exchange.createOrder(orderParams);
                 expect(mockAxiosInstance.request).toHaveBeenCalledWith(expect.objectContaining({
-                    method: 'POST',
-                    url: 'https://api.elections.kalshi.com/trade-api/v2/portfolio/orders',
+                    method: "POST",
+                    url: "https://api.elections.kalshi.com/trade-api/v2/portfolio/orders",
                     data: expect.objectContaining({
-                        ticker: 'TEST-MARKET',
-                        side: 'yes',
-                        action: 'buy',
+                        ticker: "TEST-MARKET",
+                        side: "yes",
+                        action: "buy",
                         count: 10,
-                        type: 'limit',
-                        yes_price: 55 // 0.55 * 100
+                        type: "limit",
+                        yes_price: 55, // 0.55 * 100
                     }),
                 }));
-                expect(order.id).toBe('order-123');
-                expect(order.status).toBe('open');
+                expect(order.id).toBe("order-123");
+                expect(order.status).toBe("open");
             });
-            it('should create sell order with no_price for sell side', async () => {
+            it("should create sell order with no_price for sell side", async () => {
                 const orderParams = {
-                    marketId: 'TEST-MARKET',
-                    outcomeId: 'no',
-                    side: 'sell',
-                    type: 'limit',
+                    marketId: "TEST-MARKET",
+                    outcomeId: "no",
+                    side: "sell",
+                    type: "limit",
                     amount: 5,
-                    price: 0.45
+                    price: 0.45,
                 };
                 const mockResponse = {
                     data: {
                         order: {
-                            order_id: 'order-456',
-                            ticker: 'TEST-MARKET',
-                            status: 'resting',
+                            order_id: "order-456",
+                            ticker: "TEST-MARKET",
+                            status: "resting",
                             count: 5,
                             remaining_count: 5,
-                            created_time: '2026-01-13T12:00:00Z',
-                            queue_position: 1
-                        }
-                    }
+                            created_time: "2026-01-13T12:00:00Z",
+                            queue_position: 1,
+                        },
+                    },
                 };
                 mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 await exchange.createOrder(orderParams);
                 expect(mockAxiosInstance.request).toHaveBeenCalledWith(expect.objectContaining({
-                    method: 'POST',
-                    url: 'https://api.elections.kalshi.com/trade-api/v2/portfolio/orders',
+                    method: "POST",
+                    url: "https://api.elections.kalshi.com/trade-api/v2/portfolio/orders",
                     data: expect.objectContaining({
-                        ticker: 'TEST-MARKET',
-                        side: 'no',
-                        action: 'sell',
+                        ticker: "TEST-MARKET",
+                        side: "no",
+                        action: "sell",
                         count: 5,
-                        type: 'limit',
-                        no_price: 45 // 0.45 * 100
+                        type: "limit",
+                        no_price: 45, // 0.45 * 100
                     }),
                 }));
             });
         });
-        describe('fetchOpenOrders', () => {
-            it('should sign request without query parameters', async () => {
+        describe("fetchOpenOrders", () => {
+            it("should sign request without query parameters", async () => {
                 const mockResponse = {
                     data: {
                         orders: [
                             {
-                                order_id: 'order-123',
-                                ticker: 'TEST-MARKET',
-                                side: 'yes',
-                                type: 'limit',
+                                order_id: "order-123",
+                                ticker: "TEST-MARKET",
+                                side: "yes",
+                                type: "limit",
                                 yes_price: 55,
                                 count: 10,
                                 remaining_count: 10,
-                                created_time: '2026-01-13T12:00:00Z'
-                            }
-                        ]
-                    }
+                                created_time: "2026-01-13T12:00:00Z",
+                            },
+                        ],
+                    },
                 };
                 mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 await exchange.fetchOpenOrders();
                 // 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' }),
+                    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');
+                expect(MockedKalshiAuth.prototype.getHeaders).toHaveBeenCalledWith("GET", (0, config_1.getApiPath)("/portfolio/orders"));
             });
-            it('should include ticker in query params when marketId provided', async () => {
+            it("should include ticker in query params when marketId provided", async () => {
                 const mockResponse = { data: { orders: [] } };
                 mockAxiosInstance.request.mockResolvedValue(mockResponse);
-                await exchange.fetchOpenOrders('TEST-MARKET');
+                await exchange.fetchOpenOrders("TEST-MARKET");
                 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' }),
+                    method: "GET",
+                    url: "https://api.elections.kalshi.com/trade-api/v2/portfolio/orders",
+                    params: expect.objectContaining({
+                        status: "resting",
+                        ticker: "TEST-MARKET",
+                    }),
                 }));
             });
         });
-        describe('fetchPositions', () => {
-            it('should handle positions with zero contracts', async () => {
+        describe("fetchPositions", () => {
+            it("should handle positions with zero contracts", async () => {
                 const mockResponse = {
                     data: {
                         market_positions: [
                             {
-                                ticker: 'TEST-MARKET',
+                                ticker: "TEST-MARKET",
                                 position: 0,
                                 total_cost: 0,
                                 market_exposure: 0,
-                                realized_pnl: 0
-                            }
-                        ]
-                    }
+                                realized_pnl: 0,
+                            },
+                        ],
+                    },
                 };
                 mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 const positions = await exchange.fetchPositions();
@@ -237,41 +241,41 @@ describe('KalshiExchange', () => {
                 expect(positions[0].size).toBe(0);
                 expect(positions[0].entryPrice).toBe(0); // Should not throw division by zero
             });
-            it('should correctly calculate average price and PnL', async () => {
+            it("should correctly calculate average price and PnL", async () => {
                 const mockResponse = {
                     data: {
                         market_positions: [
                             {
-                                ticker: 'TEST-MARKET',
+                                ticker: "TEST-MARKET",
                                 position: 10,
                                 total_cost: 550, // 10 contracts at $0.55 each = $5.50 = 550 cents
                                 market_exposure: 100, // $1.00 unrealized PnL
-                                realized_pnl: 50 // $0.50 realized PnL
-                            }
-                        ]
-                    }
+                                realized_pnl: 50, // $0.50 realized PnL
+                            },
+                        ],
+                    },
                 };
                 mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 const positions = await exchange.fetchPositions();
                 expect(positions).toHaveLength(1);
                 expect(positions[0].size).toBe(10);
                 expect(positions[0].entryPrice).toBe(0.55); // 550 / 10 / 100
-                expect(positions[0].unrealizedPnL).toBe(1.00); // 100 / 100
-                expect(positions[0].realizedPnL).toBe(0.50); // 50 / 100
+                expect(positions[0].unrealizedPnL).toBe(1.0); // 100 / 100
+                expect(positions[0].realizedPnL).toBe(0.5); // 50 / 100
             });
-            it('should handle short positions', async () => {
+            it("should handle short positions", async () => {
                 const mockResponse = {
                     data: {
                         market_positions: [
                             {
-                                ticker: 'TEST-MARKET',
+                                ticker: "TEST-MARKET",
                                 position: -5, // Short position
                                 total_cost: 250,
                                 market_exposure: -50,
-                                realized_pnl: 25
-                            }
-                        ]
-                    }
+                                realized_pnl: 25,
+                            },
+                        ],
+                    },
                 };
                 mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 const positions = await exchange.fetchPositions();
@@ -279,80 +283,359 @@ describe('KalshiExchange', () => {
                 expect(Math.abs(positions[0].size)).toBe(5); // Absolute value
             });
         });
-        describe('fetchBalance', () => {
-            it('should correctly convert cents to dollars', async () => {
+        describe("fetchBalance", () => {
+            it("should correctly convert cents to dollars", async () => {
                 const mockResponse = {
                     data: {
                         balance: 10000, // $100.00 available
-                        portfolio_value: 15000 // $150.00 total
-                    }
+                        portfolio_value: 15000, // $150.00 total
+                    },
                 };
                 mockAxiosInstance.request.mockResolvedValue(mockResponse);
                 const balances = await exchange.fetchBalance();
                 expect(balances).toHaveLength(1);
-                expect(balances[0].currency).toBe('USD');
-                expect(balances[0].available).toBe(100.00);
-                expect(balances[0].total).toBe(150.00);
-                expect(balances[0].locked).toBe(50.00); // 150 - 100
+                expect(balances[0].currency).toBe("USD");
+                expect(balances[0].available).toBe(100.0);
+                expect(balances[0].total).toBe(150.0);
+                expect(balances[0].locked).toBe(50.0); // 150 - 100
             });
         });
-        describe('cancelOrder', () => {
-            it('should cancel order successfully', async () => {
+        describe("cancelOrder", () => {
+            it("should cancel order successfully", async () => {
                 const mockResponse = {
                     data: {
                         order: {
-                            order_id: 'order-123',
-                            ticker: 'TEST-MARKET',
-                            side: 'yes',
+                            order_id: "order-123",
+                            ticker: "TEST-MARKET",
+                            side: "yes",
                             count: 10,
                             remaining_count: 5,
-                            created_time: '2026-01-13T12:00:00Z'
-                        }
-                    }
+                            created_time: "2026-01-13T12:00:00Z",
+                        },
+                    },
                 };
                 mockAxiosInstance.request.mockResolvedValue(mockResponse);
-                const order = await exchange.cancelOrder('order-123');
-                expect(order.status).toBe('cancelled');
+                const order = await exchange.cancelOrder("order-123");
+                expect(order.status).toBe("cancelled");
                 expect(order.filled).toBe(5); // count - remaining_count
                 expect(order.remaining).toBe(0);
             });
         });
-    });
-    describe('Order Status Mapping', () => {
-        beforeEach(() => {
-            exchange = new kalshi_1.KalshiExchange(mockCredentials);
+        describe("Trading History Methods", () => {
+            it("should map GetFills response to UserTrade array", async () => {
+                const mockResponse = {
+                    data: {
+                        fills: [
+                            {
+                                fill_id: "fill-abc",
+                                order_id: "order-123",
+                                created_time: "2026-01-13T12:00:00Z",
+                                yes_price: 55,
+                                count: 10,
+                                side: "yes",
+                            },
+                            {
+                                fill_id: "fill-def",
+                                order_id: "order-456",
+                                created_time: "2026-01-13T13:00:00Z",
+                                yes_price: 45,
+                                count: 5,
+                                side: "no",
+                            },
+                        ],
+                    },
+                };
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
+                const trades = await exchange.fetchMyTrades();
+                expect(Array.isArray(trades)).toBe(true);
+                expect(trades).toHaveLength(2);
+                expect(trades[0].id).toBe("fill-abc");
+                expect(trades[0].orderId).toBe("order-123");
+                expect(trades[0].price).toBe(0.55); // 55 / 100
+                expect(trades[0].amount).toBe(10);
+                expect(trades[0].side).toBe("buy"); // 'yes' => 'buy'
+                expect(trades[1].id).toBe("fill-def");
+                expect(trades[1].side).toBe("sell"); // 'no' => 'sell'
+                expect(trades[1].price).toBe(0.45); // 45 / 100
+            });
+            it("should pass outcomeId as ticker (stripping -NO suffix) and date params", async () => {
+                const mockResponse = { data: { fills: [] } };
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
+                await exchange.fetchMyTrades({
+                    outcomeId: "TEST-MARKET-NO",
+                    since: new Date("2026-01-01T00:00:00Z"),
+                    until: new Date("2026-01-31T00:00:00Z"),
+                    limit: 50,
+                });
+                expect(mockAxiosInstance.request).toHaveBeenCalledWith(expect.objectContaining({
+                    params: expect.objectContaining({
+                        ticker: "TEST-MARKET", // -NO stripped
+                        min_ts: Math.floor(new Date("2026-01-01T00:00:00Z").getTime() / 1000),
+                        max_ts: Math.floor(new Date("2026-01-31T00:00:00Z").getTime() / 1000),
+                        limit: 50,
+                    }),
+                }));
+            });
+            it("should return empty array when fills is missing", async () => {
+                mockAxiosInstance.request.mockResolvedValue({ data: {} });
+                const trades = await exchange.fetchMyTrades();
+                expect(trades).toHaveLength(0);
+            });
+            describe("fetchClosedOrders", () => {
+                it("should map GetHistoricalOrders response to Order array", async () => {
+                    const mockResponse = {
+                        data: {
+                            orders: [
+                                {
+                                    order_id: "hist-order-1",
+                                    ticker: "TEST-MARKET",
+                                    side: "yes",
+                                    type: "limit",
+                                    yes_price: 60,
+                                    count: 8,
+                                    remaining_count: 0,
+                                    status: "executed",
+                                    created_time: "2026-01-10T10:00:00Z",
+                                },
+                            ],
+                        },
+                    };
+                    mockAxiosInstance.request.mockResolvedValue(mockResponse);
+                    const orders = await exchange.fetchClosedOrders();
+                    expect(orders).toHaveLength(1);
+                    expect(orders[0].id).toBe("hist-order-1");
+                    expect(orders[0].marketId).toBe("TEST-MARKET");
+                    expect(orders[0].side).toBe("buy"); // 'yes' => 'buy'
+                    expect(orders[0].price).toBe(0.6); // 60 / 100
+                    expect(orders[0].amount).toBe(8);
+                    expect(orders[0].filled).toBe(8); // count - remaining_count (0)
+                    expect(orders[0].remaining).toBe(0);
+                    expect(orders[0].status).toBe("filled"); // 'executed' => 'filled'
+                });
+                it("should pass marketId as ticker and limit", async () => {
+                    const mockResponse = { data: { orders: [] } };
+                    mockAxiosInstance.request.mockResolvedValue(mockResponse);
+                    await exchange.fetchClosedOrders({
+                        marketId: "TEST-MARKET",
+                        limit: 25,
+                    });
+                    expect(mockAxiosInstance.request).toHaveBeenCalledWith(expect.objectContaining({
+                        params: expect.objectContaining({
+                            ticker: "TEST-MARKET",
+                            limit: 25,
+                        }),
+                    }));
+                });
+            });
+            describe("fetchAllOrders", () => {
+                it("should merge live and historical orders, dedup, and sort descending by timestamp", async () => {
+                    const liveResponse = {
+                        data: {
+                            orders: [
+                                {
+                                    order_id: "order-live-1",
+                                    ticker: "TEST",
+                                    side: "yes",
+                                    type: "limit",
+                                    yes_price: 50,
+                                    count: 5,
+                                    remaining_count: 5,
+                                    status: "resting",
+                                    created_time: "2026-01-15T10:00:00Z",
+                                },
+                                {
+                                    // duplicate that also appears in historical
+                                    order_id: "order-hist-1",
+                                    ticker: "TEST",
+                                    side: "no",
+                                    type: "limit",
+                                    yes_price: 40,
+                                    count: 3,
+                                    remaining_count: 0,
+                                    status: "executed",
+                                    created_time: "2026-01-10T08:00:00Z",
+                                },
+                            ],
+                        },
+                    };
+                    const historicalResponse = {
+                        data: {
+                            orders: [
+                                {
+                                    order_id: "order-hist-1", // duplicate
+                                    ticker: "TEST",
+                                    side: "no",
+                                    type: "limit",
+                                    yes_price: 40,
+                                    count: 3,
+                                    remaining_count: 0,
+                                    status: "executed",
+                                    created_time: "2026-01-10T08:00:00Z",
+                                },
+                                {
+                                    order_id: "order-hist-2",
+                                    ticker: "TEST",
+                                    side: "yes",
+                                    type: "limit",
+                                    yes_price: 55,
+                                    count: 10,
+                                    remaining_count: 0,
+                                    status: "executed",
+                                    created_time: "2026-01-05T06:00:00Z",
+                                },
+                            ],
+                        },
+                    };
+                    mockAxiosInstance.request
+                        .mockResolvedValueOnce(liveResponse)
+                        .mockResolvedValueOnce(historicalResponse);
+                    const orders = await exchange.fetchAllOrders();
+                    // 3 unique orders (order-hist-1 deduped)
+                    expect(orders).toHaveLength(3);
+                    // sorted descending: order-live-1, order-hist-1, order-hist-2
+                    expect(orders[0].id).toBe("order-live-1");
+                    expect(orders[1].id).toBe("order-hist-1");
+                    expect(orders[2].id).toBe("order-hist-2");
+                });
+            });
         });
-        it('should map resting to open', async () => {
-            const mockResponse = {
-                data: {
-                    order: {
-                        order_id: 'order-123',
-                        ticker: 'TEST',
-                        status: 'resting',
-                        count: 10,
-                        created_time: '2026-01-13T12:00:00Z'
-                    }
-                }
-            };
-            mockAxiosInstance.request.mockResolvedValue(mockResponse);
-            const order = await exchange.fetchOrder('order-123');
-            expect(order.status).toBe('open');
+        describe("buildOrder", () => {
+            it("should return correct raw body for a buy limit order without making HTTP call", async () => {
+                const params = {
+                    marketId: "TEST-MARKET",
+                    outcomeId: "yes",
+                    side: "buy",
+                    type: "limit",
+                    amount: 10,
+                    price: 0.55,
+                };
+                const built = await exchange.buildOrder(params);
+                expect(mockAxiosInstance.request).not.toHaveBeenCalled();
+                expect(built.exchange).toBe("Kalshi");
+                expect(built.params).toBe(params);
+                expect(built.raw).toEqual(expect.objectContaining({
+                    ticker: "TEST-MARKET",
+                    side: "yes",
+                    action: "buy",
+                    count: 10,
+                    type: "limit",
+                    yes_price: 55,
+                }));
+            });
+            it("should return correct raw body for a sell limit order", async () => {
+                const params = {
+                    marketId: "TEST-MARKET",
+                    outcomeId: "no",
+                    side: "sell",
+                    type: "limit",
+                    amount: 5,
+                    price: 0.45,
+                };
+                const built = await exchange.buildOrder(params);
+                expect(mockAxiosInstance.request).not.toHaveBeenCalled();
+                expect(built.exchange).toBe("Kalshi");
+                expect(built.raw).toEqual(expect.objectContaining({
+                    ticker: "TEST-MARKET",
+                    side: "no",
+                    action: "sell",
+                    count: 5,
+                    type: "limit",
+                    no_price: 45,
+                }));
+            });
+            it("should mirror input params in built.params", async () => {
+                const params = {
+                    marketId: "SOME-MARKET",
+                    outcomeId: "yes",
+                    side: "buy",
+                    type: "market",
+                    amount: 3,
+                };
+                const built = await exchange.buildOrder(params);
+                expect(built.params).toBe(params);
+            });
         });
-        it('should map executed to filled', async () => {
-            const mockResponse = {
-                data: {
-                    order: {
-                        order_id: 'order-123',
-                        ticker: 'TEST',
-                        status: 'executed',
+        describe("submitOrder", () => {
+            it("should POST built.raw to CreateOrder and return mapped order", async () => {
+                const params = {
+                    marketId: "TEST-MARKET",
+                    outcomeId: "yes",
+                    side: "buy",
+                    type: "limit",
+                    amount: 10,
+                    price: 0.55,
+                };
+                const built = await exchange.buildOrder(params);
+                const mockResponse = {
+                    data: {
+                        order: {
+                            order_id: "order-789",
+                            ticker: "TEST-MARKET",
+                            side: "yes",
+                            type: "limit",
+                            yes_price: 55,
+                            count: 10,
+                            remaining_count: 10,
+                            status: "resting",
+                            created_time: "2026-01-13T12:00:00Z",
+                        },
+                    },
+                };
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
+                const order = await exchange.submitOrder(built);
+                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,
-                        created_time: '2026-01-13T12:00:00Z'
-                    }
-                }
-            };
-            mockAxiosInstance.request.mockResolvedValue(mockResponse);
-            const order = await exchange.fetchOrder('order-123');
-            expect(order.status).toBe('filled');
+                        type: "limit",
+                        yes_price: 55,
+                    }),
+                }));
+                expect(order.id).toBe("order-789");
+                expect(order.status).toBe("open");
+                expect(order.price).toBe(0.55);
+            });
+        });
+        describe("Order Status Mapping", () => {
+            beforeEach(() => {
+                exchange = new kalshi_1.KalshiExchange(mockCredentials);
+            });
+            it("should map resting to open", async () => {
+                const mockResponse = {
+                    data: {
+                        order: {
+                            order_id: "order-123",
+                            ticker: "TEST",
+                            status: "resting",
+                            count: 10,
+                            created_time: "2026-01-13T12:00:00Z",
+                        },
+                    },
+                };
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
+                const order = await exchange.fetchOrder("order-123");
+                expect(order.status).toBe("open");
+            });
+            it("should map executed to filled", async () => {
+                const mockResponse = {
+                    data: {
+                        order: {
+                            order_id: "order-123",
+                            ticker: "TEST",
+                            status: "executed",
+                            count: 10,
+                            created_time: "2026-01-13T12:00:00Z",
+                        },
+                    },
+                };
+                mockAxiosInstance.request.mockResolvedValue(mockResponse);
+                const order = await exchange.fetchOrder("order-123");
+                expect(order.status).toBe("filled");
+            });
         });
     });
 });