perp-cli 0.3.3

package/dist/__tests__/strategies.test.js

@@ -0,0 +1,539 @@
+import { describe, it, expect, vi } from "vitest";
+// ══════════════════════════════════════════════
+// Strategy Calculators — Pure Logic Tests
+//
+// These tests focus on the calculation logic in the strategy modules,
+// not the I/O-heavy run loops. We test:
+// - TWAP: slice sizing, interval computation, last-slice remainder
+// - Grid: validation, grid line generation, step calculation
+// - DCA: parameter handling, state initialization
+// ══════════════════════════════════════════════
+// We import types and test the computational parts by exercising
+// the functions with mocked adapters, using short timeouts.
+// Mock jobs module to prevent file I/O
+vi.mock("../jobs.js", () => ({
+    updateJobState: vi.fn(),
+}));
+// ── Mock adapter factory ──
+function mockAdapter(overrides) {
+    return {
+        name: "test",
+        getMarkets: vi.fn().mockResolvedValue([
+            { symbol: "BTC", markPrice: "60000", indexPrice: "60000", fundingRate: "0.0001", volume24h: "1000000", openInterest: "500000", maxLeverage: 20 },
+        ]),
+        getBalance: vi.fn().mockResolvedValue({ equity: "10000", available: "8000", marginUsed: "2000", unrealizedPnl: "0" }),
+        getPositions: vi.fn().mockResolvedValue([]),
+        getOpenOrders: vi.fn().mockResolvedValue([]),
+        getOrderbook: vi.fn().mockResolvedValue({ bids: [["59990", "1"]], asks: [["60010", "1"]] }),
+        getOrderHistory: vi.fn().mockResolvedValue([]),
+        getTradeHistory: vi.fn().mockResolvedValue([]),
+        getRecentTrades: vi.fn().mockResolvedValue([]),
+        getFundingHistory: vi.fn().mockResolvedValue([]),
+        getFundingPayments: vi.fn().mockResolvedValue([]),
+        getKlines: vi.fn().mockResolvedValue([]),
+        marketOrder: vi.fn().mockResolvedValue({ orderId: "m1", price: "60000" }),
+        limitOrder: vi.fn().mockResolvedValue({ orderId: "l1" }),
+        editOrder: vi.fn().mockResolvedValue({}),
+        cancelOrder: vi.fn().mockResolvedValue({}),
+        cancelAllOrders: vi.fn().mockResolvedValue({}),
+        setLeverage: vi.fn().mockResolvedValue({}),
+        stopOrder: vi.fn().mockResolvedValue({}),
+        ...overrides,
+    };
+}
+// ══════════════════════════════════════════════
+// TWAP Strategy Tests
+// ══════════════════════════════════════════════
+describe("TWAP — runTWAP", () => {
+    it("computes correct totalSlices from duration (default: 1 slice per 30s)", async () => {
+        const { runTWAP } = await import("../strategies/twap.js");
+        const adapter = mockAdapter();
+        const log = vi.fn();
+        const result = await runTWAP(adapter, {
+            symbol: "BTC",
+            side: "buy",
+            totalSize: 1.0,
+            durationSec: 3, // 3 seconds / 30 = 0.1 → Math.max(floor, 2) = 2 slices
+        }, undefined, log);
+        expect(result.totalSlices).toBe(2);
+        expect(adapter.marketOrder).toHaveBeenCalledTimes(2);
+    });
+    it("uses custom slice count when provided", async () => {
+        const { runTWAP } = await import("../strategies/twap.js");
+        const adapter = mockAdapter();
+        const log = vi.fn();
+        const result = await runTWAP(adapter, {
+            symbol: "BTC",
+            side: "sell",
+            totalSize: 0.5,
+            durationSec: 5,
+            slices: 5,
+        }, undefined, log);
+        expect(result.totalSlices).toBe(5);
+        expect(adapter.marketOrder).toHaveBeenCalledTimes(5);
+    });
+    it("fills the exact total size across all slices (no dust)", async () => {
+        const { runTWAP } = await import("../strategies/twap.js");
+        const adapter = mockAdapter();
+        const log = vi.fn();
+        const result = await runTWAP(adapter, {
+            symbol: "BTC",
+            side: "buy",
+            totalSize: 1.0,
+            durationSec: 1,
+            slices: 3,
+        }, undefined, log);
+        expect(result.filled).toBeCloseTo(1.0);
+    });
+    it("last slice handles remainder correctly", async () => {
+        const { runTWAP } = await import("../strategies/twap.js");
+        const adapter = mockAdapter();
+        const log = vi.fn();
+        // 1.0 / 3 = 0.3333... per slice. Last slice should do remaining.
+        await runTWAP(adapter, {
+            symbol: "BTC",
+            side: "buy",
+            totalSize: 1.0,
+            durationSec: 1,
+            slices: 3,
+        }, undefined, log);
+        const calls = adapter.marketOrder.mock.calls;
+        expect(calls).toHaveLength(3);
+        // First two slices: 1/3 = 0.3333...
+        const slice1 = parseFloat(calls[0][2]);
+        const slice2 = parseFloat(calls[1][2]);
+        const slice3 = parseFloat(calls[2][2]);
+        expect(slice1).toBeCloseTo(1 / 3, 4);
+        expect(slice2).toBeCloseTo(1 / 3, 4);
+        // Last slice = remainder (handles dust)
+        expect(slice1 + slice2 + slice3).toBeCloseTo(1.0, 6);
+    });
+    it("handles order errors without aborting (continues other slices)", async () => {
+        const { runTWAP } = await import("../strategies/twap.js");
+        let callCount = 0;
+        const adapter = mockAdapter({
+            marketOrder: vi.fn().mockImplementation(() => {
+                callCount++;
+                if (callCount === 2)
+                    return Promise.reject(new Error("temporary error"));
+                return Promise.resolve({ orderId: "ok", price: "60000" });
+            }),
+        });
+        const log = vi.fn();
+        const result = await runTWAP(adapter, {
+            symbol: "BTC",
+            side: "buy",
+            totalSize: 1.0,
+            durationSec: 1,
+            slices: 4,
+        }, undefined, log);
+        expect(result.errors).toBe(1);
+        expect(result.slicesDone).toBe(3); // 4 attempts, 1 failed, 3 succeeded
+    });
+    it("aborts when too many errors (>50% of slices)", async () => {
+        const { runTWAP } = await import("../strategies/twap.js");
+        const adapter = mockAdapter({
+            marketOrder: vi.fn().mockRejectedValue(new Error("always fails")),
+        });
+        const log = vi.fn();
+        const result = await runTWAP(adapter, {
+            symbol: "BTC",
+            side: "buy",
+            totalSize: 1.0,
+            durationSec: 1,
+            slices: 4,
+        }, undefined, log);
+        // Should abort after 3rd error (3 > 4*0.5)
+        expect(result.errors).toBeGreaterThan(0);
+        expect(result.slicesDone).toBe(0);
+        expect(log).toHaveBeenCalledWith(expect.stringContaining("Too many errors"));
+    });
+    it("passes correct side to market orders", async () => {
+        const { runTWAP } = await import("../strategies/twap.js");
+        const adapter = mockAdapter();
+        const log = vi.fn();
+        await runTWAP(adapter, {
+            symbol: "ETH",
+            side: "sell",
+            totalSize: 2.0,
+            durationSec: 1,
+            slices: 2,
+        }, undefined, log);
+        for (const call of adapter.marketOrder.mock.calls) {
+            expect(call[0]).toBe("ETH");
+            expect(call[1]).toBe("sell");
+        }
+    });
+});
+// ══════════════════════════════════════════════
+// Grid Strategy Tests
+// ══════════════════════════════════════════════
+describe("Grid — runGrid validation", () => {
+    it("rejects upperPrice <= lowerPrice", async () => {
+        const { runGrid } = await import("../strategies/grid.js");
+        const adapter = mockAdapter();
+        await expect(runGrid(adapter, {
+            symbol: "BTC",
+            side: "neutral",
+            upperPrice: 100,
+            lowerPrice: 100,
+            grids: 5,
+            totalSize: 1,
+        })).rejects.toThrow("upperPrice must be > lowerPrice");
+    });
+    it("rejects fewer than 2 grid lines", async () => {
+        const { runGrid } = await import("../strategies/grid.js");
+        const adapter = mockAdapter();
+        await expect(runGrid(adapter, {
+            symbol: "BTC",
+            side: "neutral",
+            upperPrice: 200,
+            lowerPrice: 100,
+            grids: 1,
+            totalSize: 1,
+        })).rejects.toThrow("at least 2 grid lines");
+    });
+});
+describe("Grid — order placement", () => {
+    it("places correct number of grid orders", async () => {
+        const { runGrid } = await import("../strategies/grid.js");
+        const adapter = mockAdapter({
+            // Return no open orders to prevent fill-monitoring from running
+            getOpenOrders: vi.fn().mockResolvedValue(
+            // Return all grid order IDs as still open to prevent fill loop churn
+            Array.from({ length: 5 }, (_, i) => ({
+                orderId: "l1",
+                symbol: "BTC",
+                side: "buy",
+                price: String(59000 + i * 500),
+                size: "0.2",
+                filled: "0",
+                status: "open",
+                type: "limit",
+            }))),
+        });
+        const log = vi.fn();
+        // Use maxRuntime to stop quickly
+        const resultPromise = runGrid(adapter, {
+            symbol: "BTC",
+            side: "neutral",
+            upperPrice: 61000,
+            lowerPrice: 59000,
+            grids: 5,
+            totalSize: 1,
+            intervalSec: 0.01,
+            maxRuntime: 0.05, // stop after 50ms
+        }, undefined, log);
+        const result = await resultPromise;
+        // Should have placed 5 initial grid orders
+        expect(adapter.limitOrder).toHaveBeenCalledTimes(5);
+    });
+    it("computes correct step size", async () => {
+        const { runGrid } = await import("../strategies/grid.js");
+        const adapter = mockAdapter({
+            getOpenOrders: vi.fn().mockResolvedValue(Array.from({ length: 3 }, () => ({
+                orderId: "l1", symbol: "BTC", side: "buy", price: "60000", size: "0.1",
+                filled: "0", status: "open", type: "limit",
+            }))),
+        });
+        const log = vi.fn();
+        await runGrid(adapter, {
+            symbol: "BTC",
+            side: "neutral",
+            upperPrice: 62000,
+            lowerPrice: 60000,
+            grids: 3,
+            totalSize: 0.3,
+            intervalSec: 0.01,
+            maxRuntime: 0.05,
+        }, undefined, log);
+        // step = (62000 - 60000) / (3-1) = 1000
+        // Grid lines at: 60000, 61000, 62000
+        const calls = adapter.limitOrder.mock.calls;
+        expect(calls).toHaveLength(3);
+        const prices = calls.map((c) => parseFloat(c[2]));
+        prices.sort((a, b) => a - b);
+        expect(prices[0]).toBeCloseTo(60000);
+        expect(prices[1]).toBeCloseTo(61000);
+        expect(prices[2]).toBeCloseTo(62000);
+    });
+    it("distributes size equally across grid lines", async () => {
+        const { runGrid } = await import("../strategies/grid.js");
+        const adapter = mockAdapter({
+            getOpenOrders: vi.fn().mockResolvedValue(Array.from({ length: 4 }, () => ({
+                orderId: "l1", symbol: "BTC", side: "buy", price: "60000", size: "0.25",
+                filled: "0", status: "open", type: "limit",
+            }))),
+        });
+        const log = vi.fn();
+        await runGrid(adapter, {
+            symbol: "BTC",
+            side: "neutral",
+            upperPrice: 62000,
+            lowerPrice: 60000,
+            grids: 4,
+            totalSize: 2.0,
+            intervalSec: 0.01,
+            maxRuntime: 0.05,
+        }, undefined, log);
+        // Each grid line gets 2.0/4 = 0.5
+        for (const call of adapter.limitOrder.mock.calls) {
+            expect(parseFloat(call[3])).toBeCloseTo(0.5);
+        }
+    });
+    it("assigns buy below current price and sell above for neutral side", async () => {
+        const { runGrid } = await import("../strategies/grid.js");
+        const adapter = mockAdapter({
+            getMarkets: vi.fn().mockResolvedValue([
+                { symbol: "BTC", markPrice: "61000", indexPrice: "61000", fundingRate: "0", volume24h: "0", openInterest: "0", maxLeverage: 20 },
+            ]),
+            getOpenOrders: vi.fn().mockResolvedValue(Array.from({ length: 5 }, () => ({
+                orderId: "l1", symbol: "BTC", side: "buy", price: "60000", size: "0.1",
+                filled: "0", status: "open", type: "limit",
+            }))),
+        });
+        const log = vi.fn();
+        await runGrid(adapter, {
+            symbol: "BTC",
+            side: "neutral",
+            upperPrice: 63000,
+            lowerPrice: 59000,
+            grids: 5, // step = 1000. Lines: 59000, 60000, 61000, 62000, 63000
+            totalSize: 0.5,
+            intervalSec: 0.01,
+            maxRuntime: 0.05,
+        }, undefined, log);
+        // Current price = 61000
+        // 59000 → buy, 60000 → buy, 61000 → sell (>=61000), 62000 → sell, 63000 → sell
+        const calls = adapter.limitOrder.mock.calls;
+        const orders = calls.map((c) => ({ side: c[1], price: parseFloat(c[2]) }));
+        orders.sort((a, b) => a.price - b.price);
+        // Lines below current (59000, 60000) should be buy
+        expect(orders[0].side).toBe("buy");
+        expect(orders[1].side).toBe("buy");
+        // Lines at or above current (61000, 62000, 63000) should be sell
+        expect(orders[2].side).toBe("sell");
+        expect(orders[3].side).toBe("sell");
+        expect(orders[4].side).toBe("sell");
+    });
+    it("sets leverage if provided", async () => {
+        const { runGrid } = await import("../strategies/grid.js");
+        const adapter = mockAdapter({
+            getOpenOrders: vi.fn().mockResolvedValue([
+                { orderId: "l1", symbol: "BTC", side: "buy", price: "60000", size: "0.5", filled: "0", status: "open", type: "limit" },
+                { orderId: "l1", symbol: "BTC", side: "sell", price: "62000", size: "0.5", filled: "0", status: "open", type: "limit" },
+            ]),
+        });
+        const log = vi.fn();
+        await runGrid(adapter, {
+            symbol: "BTC",
+            side: "neutral",
+            upperPrice: 62000,
+            lowerPrice: 60000,
+            grids: 2,
+            totalSize: 1,
+            leverage: 5,
+            intervalSec: 0.01,
+            maxRuntime: 0.05,
+        }, undefined, log);
+        expect(adapter.setLeverage).toHaveBeenCalledWith("BTC", 5);
+    });
+});
+// ══════════════════════════════════════════════
+// DCA Strategy Tests
+// ══════════════════════════════════════════════
+describe("DCA — runDCA", () => {
+    it("places the specified number of orders then stops", async () => {
+        const { runDCA } = await import("../strategies/dca.js");
+        const adapter = mockAdapter();
+        const log = vi.fn();
+        const result = await runDCA(adapter, {
+            symbol: "BTC",
+            side: "buy",
+            amountPerOrder: 0.01,
+            intervalSec: 0.001, // 1ms intervals for fast test
+            totalOrders: 3,
+        }, undefined, log);
+        expect(result.ordersPlaced).toBe(3);
+        expect(adapter.marketOrder).toHaveBeenCalledTimes(3);
+    });
+    it("passes correct symbol, side, and size to each order", async () => {
+        const { runDCA } = await import("../strategies/dca.js");
+        const adapter = mockAdapter();
+        const log = vi.fn();
+        await runDCA(adapter, {
+            symbol: "ETH",
+            side: "sell",
+            amountPerOrder: 0.5,
+            intervalSec: 0.001,
+            totalOrders: 2,
+        }, undefined, log);
+        for (const call of adapter.marketOrder.mock.calls) {
+            expect(call[0]).toBe("ETH");
+            expect(call[1]).toBe("sell");
+            expect(call[2]).toBe("0.5");
+        }
+    });
+    it("tracks total filled amount", async () => {
+        const { runDCA } = await import("../strategies/dca.js");
+        const adapter = mockAdapter();
+        const log = vi.fn();
+        const result = await runDCA(adapter, {
+            symbol: "BTC",
+            side: "buy",
+            amountPerOrder: 0.1,
+            intervalSec: 0.001,
+            totalOrders: 5,
+        }, undefined, log);
+        expect(result.totalFilled).toBeCloseTo(0.5);
+    });
+    it("computes average price from fill prices", async () => {
+        const { runDCA } = await import("../strategies/dca.js");
+        let callNum = 0;
+        const prices = [59000, 60000, 61000];
+        const adapter = mockAdapter({
+            marketOrder: vi.fn().mockImplementation(() => {
+                const price = prices[callNum++];
+                return Promise.resolve({ orderId: `m${callNum}`, price: String(price) });
+            }),
+        });
+        const log = vi.fn();
+        const result = await runDCA(adapter, {
+            symbol: "BTC",
+            side: "buy",
+            amountPerOrder: 1,
+            intervalSec: 0.001,
+            totalOrders: 3,
+        }, undefined, log);
+        // avg = (1*59000 + 1*60000 + 1*61000) / 3 = 60000
+        expect(result.avgPrice).toBeCloseTo(60000);
+    });
+    it("continues on individual order errors", async () => {
+        const { runDCA } = await import("../strategies/dca.js");
+        // DCA keeps going until ordersPlaced reaches totalOrders.
+        // If one call fails, it retries on the next loop iteration.
+        // So with totalOrders=3, it needs 4 calls: succeed, fail, succeed, succeed → 3 placed.
+        const marketOrderMock = vi.fn()
+            .mockResolvedValueOnce({ orderId: "m1", price: "60000" })
+            .mockRejectedValueOnce(new Error("temporary"))
+            .mockResolvedValueOnce({ orderId: "m3", price: "60000" })
+            .mockResolvedValueOnce({ orderId: "m4", price: "60000" });
+        const adapter = mockAdapter({ marketOrder: marketOrderMock });
+        const log = vi.fn();
+        const result = await runDCA(adapter, {
+            symbol: "BTC",
+            side: "buy",
+            amountPerOrder: 0.1,
+            intervalSec: 0.001,
+            totalOrders: 3,
+        }, undefined, log);
+        // 4 marketOrder calls: 3 succeeded, 1 failed
+        expect(marketOrderMock).toHaveBeenCalledTimes(4);
+        expect(result.ordersPlaced).toBe(3);
+        // Verify an error was logged
+        expect(log).toHaveBeenCalledWith(expect.stringContaining("Order error"));
+    });
+    it("stops when too many errors (errors > ordersPlaced and errors > 10)", async () => {
+        const { runDCA } = await import("../strategies/dca.js");
+        const adapter = mockAdapter({
+            marketOrder: vi.fn().mockRejectedValue(new Error("always fails")),
+        });
+        const log = vi.fn();
+        const result = await runDCA(adapter, {
+            symbol: "BTC",
+            side: "buy",
+            amountPerOrder: 0.1,
+            intervalSec: 0.001,
+            totalOrders: 100, // high count but errors will stop it
+        }, undefined, log);
+        // Stops at 11 errors (>10 and >0 placed)
+        expect(result.ordersPlaced).toBe(0);
+        expect(log).toHaveBeenCalledWith(expect.stringContaining("Too many errors"));
+    });
+    it("skips order when buy price exceeds price limit", async () => {
+        const { runDCA } = await import("../strategies/dca.js");
+        const adapter = mockAdapter({
+            getMarkets: vi.fn().mockResolvedValue([
+                { symbol: "BTC", markPrice: "65000", indexPrice: "65000", fundingRate: "0", volume24h: "0", openInterest: "0", maxLeverage: 20 },
+            ]),
+        });
+        const log = vi.fn();
+        // Price limit of $60000, but market is at $65000 — should skip
+        // With totalOrders=0 this would loop forever, so we use maxRuntime
+        const result = await runDCA(adapter, {
+            symbol: "BTC",
+            side: "buy",
+            amountPerOrder: 0.1,
+            intervalSec: 0.001,
+            totalOrders: 2,
+            priceLimit: 60000,
+            maxRuntime: 0.1, // 100ms timeout
+        }, undefined, log);
+        expect(result.ordersPlaced).toBe(0);
+        expect(adapter.marketOrder).not.toHaveBeenCalled();
+    });
+    it("respects maxRuntime", async () => {
+        const { runDCA } = await import("../strategies/dca.js");
+        const adapter = mockAdapter();
+        const log = vi.fn();
+        const start = Date.now();
+        const result = await runDCA(adapter, {
+            symbol: "BTC",
+            side: "buy",
+            amountPerOrder: 0.01,
+            intervalSec: 0.01, // 10ms intervals (short enough to not block)
+            totalOrders: 0, // unlimited
+            maxRuntime: 0.1, // 100ms max
+        }, undefined, log);
+        const elapsed = Date.now() - start;
+        // Should stop within a reasonable time (definitely under 5s)
+        expect(elapsed).toBeLessThan(5000);
+        // With 10ms intervals and 100ms runtime, should place a handful of orders but not many
+        expect(result.ordersPlaced).toBeGreaterThanOrEqual(1);
+        expect(result.ordersPlaced).toBeLessThan(50); // sanity check
+    });
+});
+// ══════════════════════════════════════════════
+// TWAP Slice Calculation (unit-level)
+// ══════════════════════════════════════════════
+describe("TWAP — slice calculation edge cases", () => {
+    it("minimum 2 slices even for very short duration", async () => {
+        const { runTWAP } = await import("../strategies/twap.js");
+        const adapter = mockAdapter();
+        const log = vi.fn();
+        const result = await runTWAP(adapter, {
+            symbol: "BTC",
+            side: "buy",
+            totalSize: 0.1,
+            durationSec: 1, // 1s / 30 = 0.03 → floor = 0 → max(0, 2) = 2
+        }, undefined, log);
+        expect(result.totalSlices).toBe(2);
+    });
+    it("reports correct remaining after partial completion", async () => {
+        const { runTWAP } = await import("../strategies/twap.js");
+        const marketOrderMock = vi.fn()
+            .mockResolvedValueOnce({ orderId: "ok" })
+            .mockRejectedValueOnce(new Error("fail"))
+            .mockResolvedValueOnce({ orderId: "ok" });
+        const adapter = mockAdapter({ marketOrder: marketOrderMock });
+        const log = vi.fn();
+        const result = await runTWAP(adapter, {
+            symbol: "BTC",
+            side: "buy",
+            totalSize: 1.0,
+            durationSec: 1,
+            slices: 3,
+        }, undefined, log);
+        // 3 slices, each nominally 1/3. Slice 2 fails.
+        // Slice 1: filled += 1/3, remaining = 2/3
+        // Slice 2: fails, no change to filled/remaining
+        // Slice 3 is last slice: uses state.remaining = 2/3 as the size
+        // Slice 3: filled += 2/3, remaining = 0
+        // So final remaining = 0, filled = 1.0
+        expect(result.slicesDone).toBe(2);
+        expect(result.errors).toBe(1);
+        // Last slice picks up all remaining, so total filled = 1/3 + 2/3 = 1.0
+        expect(result.remaining).toBeCloseTo(0, 2);
+        expect(result.filled).toBeCloseTo(1.0, 2);
+    });
+});

package/dist/__tests__/trade-execution.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/trade-execution.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { MockAdapter, createMockPositions } from "./exchanges/mock-adapter.js";
+describe("Trade Execution", () => {
+    let adapter;
+    beforeEach(() => {
+        adapter = new MockAdapter("test-exchange");
+        adapter.orderResult = { status: "ok", orderId: "test-123" };
+    });
+    describe("Market Orders", () => {
+        it("should place a buy market order with correct params", async () => {
+            await adapter.marketOrder("BTC", "buy", "0.1");
+            const calls = adapter.getCallsFor("marketOrder");
+            expect(calls).toHaveLength(1);
+            expect(calls[0].args).toEqual(["BTC", "buy", "0.1"]);
+        });
+        it("should place a sell market order", async () => {
+            await adapter.marketOrder("ETH", "sell", "1.5");
+            const calls = adapter.getCallsFor("marketOrder");
+            expect(calls).toHaveLength(1);
+            expect(calls[0].args).toEqual(["ETH", "sell", "1.5"]);
+        });
+        it("should return order result", async () => {
+            const result = await adapter.marketOrder("BTC", "buy", "0.1");
+            expect(result).toEqual({ status: "ok", orderId: "test-123" });
+        });
+    });
+    describe("Limit Orders", () => {
+        it("should place limit order with price and size", async () => {
+            await adapter.limitOrder("BTC", "buy", "95000", "0.05");
+            const calls = adapter.getCallsFor("limitOrder");
+            expect(calls).toHaveLength(1);
+            expect(calls[0].args).toEqual(["BTC", "buy", "95000", "0.05"]);
+        });
+    });
+    describe("Stop Orders", () => {
+        it("should place stop order with trigger price", async () => {
+            await adapter.stopOrder("BTC", "sell", "0.1", "90000", { reduceOnly: true });
+            const calls = adapter.getCallsFor("stopOrder");
+            expect(calls).toHaveLength(1);
+            expect(calls[0].args).toEqual(["BTC", "sell", "0.1", "90000", { reduceOnly: true }]);
+        });
+        it("should place stop-limit order", async () => {
+            await adapter.stopOrder("ETH", "buy", "1.0", "4000", { limitPrice: "4050", reduceOnly: false });
+            const calls = adapter.getCallsFor("stopOrder");
+            expect(calls[0].args[4]).toEqual({ limitPrice: "4050", reduceOnly: false });
+        });
+    });
+    describe("Order Management", () => {
+        it("should cancel specific order", async () => {
+            await adapter.cancelOrder("BTC", "order-456");
+            expect(adapter.getCallsFor("cancelOrder")[0].args).toEqual(["BTC", "order-456"]);
+        });
+        it("should cancel all orders", async () => {
+            await adapter.cancelAllOrders();
+            expect(adapter.getCallsFor("cancelAllOrders")).toHaveLength(1);
+        });
+        it("should cancel orders for specific symbol", async () => {
+            await adapter.cancelAllOrders("ETH");
+            expect(adapter.getCallsFor("cancelAllOrders")[0].args).toEqual(["ETH"]);
+        });
+        it("should edit existing order", async () => {
+            await adapter.editOrder("BTC", "order-789", "96000", "0.2");
+            expect(adapter.getCallsFor("editOrder")[0].args).toEqual(["BTC", "order-789", "96000", "0.2"]);
+        });
+    });
+    describe("Position Close Logic", () => {
+        it("should close long position with sell order", async () => {
+            adapter.positionsResponse = createMockPositions(1); // long BTC 0.1
+            const positions = await adapter.getPositions();
+            expect(positions).toHaveLength(1);
+            expect(positions[0].side).toBe("long");
+            // Close: sell the same size
+            await adapter.marketOrder(positions[0].symbol, "sell", positions[0].size);
+            const calls = adapter.getCallsFor("marketOrder");
+            expect(calls).toHaveLength(1);
+            expect(calls[0].args).toEqual(["BTC", "sell", "0.1"]);
+        });
+        it("should close short position with buy order", async () => {
+            adapter.positionsResponse = [{
+                    symbol: "ETH", side: "short", size: "2.0",
+                    entryPrice: "3500", markPrice: "3400", liquidationPrice: "4500",
+                    unrealizedPnl: "200", leverage: 5,
+                }];
+            const positions = await adapter.getPositions();
+            await adapter.marketOrder(positions[0].symbol, "buy", positions[0].size);
+            const calls = adapter.getCallsFor("marketOrder");
+            expect(calls[0].args).toEqual(["ETH", "buy", "2.0"]);
+        });
+        it("should close all positions with opposite-side orders", async () => {
+            adapter.positionsResponse = [
+                { symbol: "BTC", side: "long", size: "0.1", entryPrice: "100000", markPrice: "101000", liquidationPrice: "90000", unrealizedPnl: "100", leverage: 10 },
+                { symbol: "ETH", side: "short", size: "1.5", entryPrice: "3500", markPrice: "3400", liquidationPrice: "4500", unrealizedPnl: "150", leverage: 5 },
+            ];
+            const positions = await adapter.getPositions();
+            for (const pos of positions) {
+                const closeSide = pos.side === "long" ? "sell" : "buy";
+                await adapter.marketOrder(pos.symbol, closeSide, pos.size);
+            }
+            const calls = adapter.getCallsFor("marketOrder");
+            expect(calls).toHaveLength(2);
+            expect(calls[0].args).toEqual(["BTC", "sell", "0.1"]);
+            expect(calls[1].args).toEqual(["ETH", "buy", "1.5"]);
+        });
+        it("should reduce position by percentage", async () => {
+            adapter.positionsResponse = [{
+                    symbol: "BTC", side: "long", size: "1.0",
+                    entryPrice: "100000", markPrice: "101000", liquidationPrice: "90000",
+                    unrealizedPnl: "1000", leverage: 10,
+                }];
+            const positions = await adapter.getPositions();
+            const pos = positions[0];
+            const reducePct = 50;
+            const reduceSize = (Number(pos.size) * reducePct / 100).toString();
+            await adapter.marketOrder(pos.symbol, "sell", reduceSize);
+            const calls = adapter.getCallsFor("marketOrder");
+            expect(calls[0].args).toEqual(["BTC", "sell", "0.5"]);
+        });
+    });
+    describe("Leverage Management", () => {
+        it("should set leverage with cross margin", async () => {
+            await adapter.setLeverage("BTC", 20, "cross");
+            expect(adapter.getCallsFor("setLeverage")[0].args).toEqual(["BTC", 20, "cross"]);
+        });
+        it("should set leverage with isolated margin", async () => {
+            await adapter.setLeverage("ETH", 5, "isolated");
+            expect(adapter.getCallsFor("setLeverage")[0].args).toEqual(["ETH", 5, "isolated"]);
+        });
+    });
+});

package/dist/__tests__/trade-validator.test.d.ts

@@ -0,0 +1 @@
+export {};