perp-cli 0.3.3

package/dist/__tests__/errors.test.js

@@ -0,0 +1,110 @@
+import { describe, it, expect } from "vitest";
+import { classifyError, PerpError, ERROR_CODES } from "../errors.js";
+describe("classifyError — pattern matching", () => {
+    it("classifies insufficient balance errors", () => {
+        const r = classifyError(new Error("Insufficient balance for order"));
+        expect(r.code).toBe("INSUFFICIENT_BALANCE");
+        expect(r.status).toBe(400);
+        expect(r.retryable).toBe(false);
+    });
+    it("classifies margin-specific insufficient errors before generic balance", () => {
+        const r = classifyError(new Error("Margin insufficient for cross order"));
+        expect(r.code).toBe("MARGIN_INSUFFICIENT");
+        expect(r.status).toBe(400);
+    });
+    it("classifies rate limit errors", () => {
+        const r = classifyError(new Error("429 Too Many Requests"));
+        expect(r.code).toBe("RATE_LIMITED");
+        expect(r.retryable).toBe(true);
+        expect(r.retryAfterMs).toBe(1000);
+    });
+    it("classifies network errors", () => {
+        expect(classifyError(new Error("fetch failed")).code).toBe("EXCHANGE_UNREACHABLE");
+        expect(classifyError(new Error("ECONNREFUSED")).code).toBe("EXCHANGE_UNREACHABLE");
+        expect(classifyError(new Error("ENOTFOUND api.example.com")).code).toBe("EXCHANGE_UNREACHABLE");
+    });
+    it("classifies timeout errors", () => {
+        expect(classifyError(new Error("Request timed out")).code).toBe("TIMEOUT");
+        expect(classifyError(new Error("ETIMEDOUT")).code).toBe("TIMEOUT");
+        expect(classifyError("timeout").code).toBe("TIMEOUT");
+    });
+    it("classifies symbol not found", () => {
+        const r = classifyError(new Error("Symbol XYZABC not found"));
+        expect(r.code).toBe("SYMBOL_NOT_FOUND");
+    });
+    it("classifies order not found", () => {
+        const r = classifyError(new Error("Order #12345 not found"));
+        expect(r.code).toBe("ORDER_NOT_FOUND");
+    });
+    it("classifies position not found", () => {
+        const r = classifyError(new Error("Position not found for BTC"));
+        expect(r.code).toBe("POSITION_NOT_FOUND");
+    });
+    it("classifies size too small", () => {
+        expect(classifyError(new Error("Order size too small")).code).toBe("SIZE_TOO_SMALL");
+        expect(classifyError(new Error("Below minimum order size")).code).toBe("SIZE_TOO_SMALL");
+    });
+    it("classifies size too large", () => {
+        expect(classifyError(new Error("Order size too large")).code).toBe("SIZE_TOO_LARGE");
+        expect(classifyError(new Error("Exceeds max position size")).code).toBe("SIZE_TOO_LARGE");
+    });
+    it("classifies signature errors", () => {
+        expect(classifyError(new Error("Signature verification failed")).code).toBe("SIGNATURE_FAILED");
+    });
+    it("classifies duplicate order", () => {
+        expect(classifyError(new Error("Duplicate order ID")).code).toBe("DUPLICATE_ORDER");
+        expect(classifyError(new Error("Order already exists")).code).toBe("DUPLICATE_ORDER");
+    });
+    it("classifies risk violation", () => {
+        expect(classifyError(new Error("Risk limit violation")).code).toBe("RISK_VIOLATION");
+    });
+    it("returns EXCHANGE_ERROR when exchange is known but message is unrecognized", () => {
+        const r = classifyError(new Error("Something weird happened"), "hyperliquid");
+        expect(r.code).toBe("EXCHANGE_ERROR");
+        expect(r.exchange).toBe("hyperliquid");
+        expect(r.retryable).toBe(true);
+    });
+    it("returns UNKNOWN when no exchange and message is unrecognized", () => {
+        const r = classifyError(new Error("Something weird happened"));
+        expect(r.code).toBe("UNKNOWN");
+        expect(r.retryable).toBe(false);
+    });
+    it("handles non-Error inputs", () => {
+        const r = classifyError("rate limit exceeded");
+        expect(r.code).toBe("RATE_LIMITED");
+        expect(r.message).toBe("rate limit exceeded");
+    });
+});
+describe("PerpError class", () => {
+    it("creates error with structured fields", () => {
+        const err = new PerpError("INSUFFICIENT_BALANCE", "Not enough USDC", { required: 100, available: 50 });
+        expect(err).toBeInstanceOf(Error);
+        expect(err.name).toBe("PerpError");
+        expect(err.message).toBe("Not enough USDC");
+        expect(err.structured.code).toBe("INSUFFICIENT_BALANCE");
+        expect(err.structured.status).toBe(400);
+        expect(err.structured.retryable).toBe(false);
+        expect(err.structured.details?.required).toBe(100);
+    });
+    it("has correct prototype chain", () => {
+        const err = new PerpError("TIMEOUT", "Request timed out");
+        expect(err instanceof PerpError).toBe(true);
+        expect(err instanceof Error).toBe(true);
+    });
+});
+describe("ERROR_CODES coverage", () => {
+    it("all codes have required fields", () => {
+        for (const [key, val] of Object.entries(ERROR_CODES)) {
+            expect(val.code).toBe(key);
+            expect(typeof val.status).toBe("number");
+            expect(typeof val.retryable).toBe("boolean");
+        }
+    });
+    it("retryable codes are all 5xx or 429", () => {
+        for (const val of Object.values(ERROR_CODES)) {
+            if (val.retryable) {
+                expect(val.status).toBeGreaterThanOrEqual(429);
+            }
+        }
+    });
+});

package/dist/__tests__/event-stream.test.d.ts

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

package/dist/__tests__/event-stream.test.js

@@ -0,0 +1,276 @@
+import { describe, it, expect, vi } from "vitest";
+import { startEventStream } from "../event-stream.js";
+function mockAdapter(overrides) {
+    return {
+        name: "test",
+        getPositions: vi.fn().mockResolvedValue([]),
+        getOpenOrders: vi.fn().mockResolvedValue([]),
+        getBalance: vi.fn().mockResolvedValue({ equity: "1000", available: "800", marginUsed: "200", unrealizedPnl: "0" }),
+        ...overrides,
+    };
+}
+describe("startEventStream — basic polling", () => {
+    it("emits heartbeat after 12 cycles", async () => {
+        const events = [];
+        const controller = new AbortController();
+        let pollCount = 0;
+        const adapter = mockAdapter({
+            getPositions: vi.fn().mockImplementation(async () => {
+                pollCount++;
+                if (pollCount >= 13)
+                    controller.abort();
+                return [];
+            }),
+        });
+        await startEventStream(adapter, {
+            intervalMs: 1,
+            onEvent: (e) => events.push(e),
+            signal: controller.signal,
+        });
+        const heartbeats = events.filter(e => e.type === "heartbeat");
+        expect(heartbeats.length).toBeGreaterThanOrEqual(1);
+        expect(heartbeats[0].data.cycle).toBe(12);
+        expect(heartbeats[0].exchange).toBe("test");
+    });
+    it("emits position_opened when new position appears", async () => {
+        const events = [];
+        const controller = new AbortController();
+        let callNum = 0;
+        const adapter = mockAdapter({
+            getPositions: vi.fn().mockImplementation(async () => {
+                callNum++;
+                if (callNum === 1)
+                    return []; // first poll: no positions
+                controller.abort();
+                return [{ symbol: "BTC", side: "long", size: "0.1", entryPrice: "65000", unrealizedPnl: "50", liquidationPrice: "60000", markPrice: "65500" }];
+            }),
+        });
+        await startEventStream(adapter, {
+            intervalMs: 1,
+            onEvent: (e) => events.push(e),
+            signal: controller.signal,
+        });
+        const opened = events.filter(e => e.type === "position_opened");
+        expect(opened.length).toBe(1);
+        expect(opened[0].data.symbol).toBe("BTC");
+        expect(opened[0].data.side).toBe("long");
+    });
+    it("emits position_closed when position disappears", async () => {
+        const events = [];
+        const controller = new AbortController();
+        let callNum = 0;
+        const adapter = mockAdapter({
+            getPositions: vi.fn().mockImplementation(async () => {
+                callNum++;
+                if (callNum === 1)
+                    return [{ symbol: "ETH", side: "short", size: "5", entryPrice: "2000", unrealizedPnl: "-10", liquidationPrice: "2200", markPrice: "2010" }];
+                controller.abort();
+                return []; // position gone
+            }),
+        });
+        await startEventStream(adapter, {
+            intervalMs: 1,
+            onEvent: (e) => events.push(e),
+            signal: controller.signal,
+        });
+        const closed = events.filter(e => e.type === "position_closed");
+        expect(closed.length).toBe(1);
+        expect(closed[0].data.symbol).toBe("ETH");
+    });
+    it("emits position_updated when size changes", async () => {
+        const events = [];
+        const controller = new AbortController();
+        let callNum = 0;
+        const adapter = mockAdapter({
+            getPositions: vi.fn().mockImplementation(async () => {
+                callNum++;
+                if (callNum === 1)
+                    return [{ symbol: "SOL", side: "long", size: "10", entryPrice: "100", unrealizedPnl: "0", liquidationPrice: "80", markPrice: "100" }];
+                controller.abort();
+                return [{ symbol: "SOL", side: "long", size: "20", entryPrice: "100", unrealizedPnl: "0", liquidationPrice: "80", markPrice: "100" }];
+            }),
+        });
+        await startEventStream(adapter, {
+            intervalMs: 1,
+            onEvent: (e) => events.push(e),
+            signal: controller.signal,
+        });
+        const updated = events.filter(e => e.type === "position_updated");
+        expect(updated.length).toBe(1);
+        expect(updated[0].data.prevSize).toBe("10");
+        expect(updated[0].data.size).toBe("20");
+    });
+});
+describe("startEventStream — order diffs", () => {
+    it("emits order_placed for new orders", async () => {
+        const events = [];
+        const controller = new AbortController();
+        let callNum = 0;
+        const adapter = mockAdapter({
+            getOpenOrders: vi.fn().mockImplementation(async () => {
+                callNum++;
+                if (callNum === 1)
+                    return [];
+                controller.abort();
+                return [{ orderId: "o1", symbol: "BTC", side: "buy", price: "60000", size: "0.1", status: "open" }];
+            }),
+        });
+        await startEventStream(adapter, {
+            intervalMs: 1,
+            onEvent: (e) => events.push(e),
+            signal: controller.signal,
+        });
+        const placed = events.filter(e => e.type === "order_placed");
+        expect(placed.length).toBe(1);
+        expect(placed[0].data.orderId).toBe("o1");
+    });
+    it("emits order_cancelled when order disappears without position change", async () => {
+        const events = [];
+        const controller = new AbortController();
+        let callNum = 0;
+        const adapter = mockAdapter({
+            getOpenOrders: vi.fn().mockImplementation(async () => {
+                callNum++;
+                if (callNum === 1)
+                    return [{ orderId: "o1", symbol: "BTC", side: "buy", price: "60000", size: "0.1", status: "open" }];
+                controller.abort();
+                return []; // order gone
+            }),
+        });
+        await startEventStream(adapter, {
+            intervalMs: 1,
+            onEvent: (e) => events.push(e),
+            signal: controller.signal,
+        });
+        const cancelled = events.filter(e => e.type === "order_cancelled");
+        expect(cancelled.length).toBe(1);
+    });
+});
+describe("startEventStream — balance updates", () => {
+    it("emits balance_update when equity changes significantly", async () => {
+        const events = [];
+        const controller = new AbortController();
+        let callNum = 0;
+        const adapter = mockAdapter({
+            getBalance: vi.fn().mockImplementation(async () => {
+                callNum++;
+                if (callNum === 1)
+                    return { equity: "1000.00", available: "800.00", marginUsed: "200", unrealizedPnl: "0" };
+                controller.abort();
+                return { equity: "1050.50", available: "850.50", marginUsed: "200", unrealizedPnl: "50.50" };
+            }),
+        });
+        await startEventStream(adapter, {
+            intervalMs: 1,
+            onEvent: (e) => events.push(e),
+            signal: controller.signal,
+        });
+        const balanceUpdates = events.filter(e => e.type === "balance_update");
+        expect(balanceUpdates.length).toBe(1);
+        expect(balanceUpdates[0].data.equity).toBe("1050.50");
+        expect(balanceUpdates[0].data.prevEquity).toBe("1000.00");
+    });
+    it("does not emit balance_update for tiny changes", async () => {
+        const events = [];
+        const controller = new AbortController();
+        let callNum = 0;
+        const adapter = mockAdapter({
+            getBalance: vi.fn().mockImplementation(async () => {
+                callNum++;
+                if (callNum === 1)
+                    return { equity: "1000.00", available: "800.00", marginUsed: "200", unrealizedPnl: "0" };
+                controller.abort();
+                return { equity: "1000.005", available: "800.005", marginUsed: "200", unrealizedPnl: "0.005" };
+            }),
+        });
+        await startEventStream(adapter, {
+            intervalMs: 1,
+            onEvent: (e) => events.push(e),
+            signal: controller.signal,
+        });
+        const balanceUpdates = events.filter(e => e.type === "balance_update");
+        expect(balanceUpdates.length).toBe(0);
+    });
+});
+describe("startEventStream — liquidation warnings", () => {
+    it("emits liquidation_warning when within threshold", async () => {
+        const events = [];
+        const controller = new AbortController();
+        const adapter = mockAdapter({
+            getPositions: vi.fn().mockImplementation(async () => {
+                controller.abort();
+                // markPrice=100, liqPrice=92 → 8% distance
+                return [{ symbol: "SOL", side: "long", size: "10", entryPrice: "95", unrealizedPnl: "50", liquidationPrice: "92", markPrice: "100" }];
+            }),
+        });
+        await startEventStream(adapter, {
+            intervalMs: 1,
+            liquidationWarningPct: 10,
+            onEvent: (e) => events.push(e),
+            signal: controller.signal,
+        });
+        const warnings = events.filter(e => e.type === "liquidation_warning");
+        expect(warnings.length).toBe(1);
+        expect(warnings[0].riskLevel).toBe("warning");
+        expect(warnings[0].data.distancePct).toBe(8);
+    });
+    it("emits margin_call when critically close (<3%)", async () => {
+        const events = [];
+        const controller = new AbortController();
+        const adapter = mockAdapter({
+            getPositions: vi.fn().mockImplementation(async () => {
+                controller.abort();
+                // markPrice=100, liqPrice=98 → 2% distance
+                return [{ symbol: "SOL", side: "long", size: "10", entryPrice: "95", unrealizedPnl: "50", liquidationPrice: "98", markPrice: "100" }];
+            }),
+        });
+        await startEventStream(adapter, {
+            intervalMs: 1,
+            onEvent: (e) => events.push(e),
+            signal: controller.signal,
+        });
+        const calls = events.filter(e => e.type === "margin_call");
+        expect(calls.length).toBe(1);
+        expect(calls[0].riskLevel).toBe("critical");
+    });
+    it("skips liquidation check for N/A liquidation price", async () => {
+        const events = [];
+        const controller = new AbortController();
+        const adapter = mockAdapter({
+            getPositions: vi.fn().mockImplementation(async () => {
+                controller.abort();
+                return [{ symbol: "SOL", side: "long", size: "10", entryPrice: "95", unrealizedPnl: "50", liquidationPrice: "N/A", markPrice: "100" }];
+            }),
+        });
+        await startEventStream(adapter, {
+            intervalMs: 1,
+            onEvent: (e) => events.push(e),
+            signal: controller.signal,
+        });
+        const warnings = events.filter(e => e.type === "liquidation_warning" || e.type === "margin_call");
+        expect(warnings.length).toBe(0);
+    });
+});
+describe("startEventStream — error handling", () => {
+    it("emits error event when adapter throws", async () => {
+        const events = [];
+        const controller = new AbortController();
+        let callNum = 0;
+        const adapter = mockAdapter({
+            getPositions: vi.fn().mockImplementation(async () => {
+                callNum++;
+                if (callNum >= 2)
+                    controller.abort();
+                throw new Error("API unreachable");
+            }),
+        });
+        await startEventStream(adapter, {
+            intervalMs: 1,
+            onEvent: (e) => events.push(e),
+            signal: controller.signal,
+        });
+        const errors = events.filter(e => e.type === "error");
+        expect(errors.length).toBeGreaterThanOrEqual(1);
+        expect(errors[0].data.message).toContain("API unreachable");
+    });
+});

package/dist/__tests__/exchanges/interface.test.d.ts

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

package/dist/__tests__/exchanges/interface.test.js

@@ -0,0 +1,132 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { MockAdapter, createMockMarkets, createMockPositions, createMockOrders } from "./mock-adapter.js";
+describe("ExchangeAdapter interface compliance", () => {
+    let adapter;
+    beforeEach(() => {
+        adapter = new MockAdapter("test-exchange");
+    });
+    it("has a name property", () => {
+        expect(adapter.name).toBe("test-exchange");
+    });
+    describe("getMarkets", () => {
+        it("returns market info array", async () => {
+            adapter.marketsResponse = createMockMarkets(3);
+            const markets = await adapter.getMarkets();
+            expect(markets).toHaveLength(3);
+            expect(markets[0]).toHaveProperty("symbol");
+            expect(markets[0]).toHaveProperty("markPrice");
+            expect(markets[0]).toHaveProperty("fundingRate");
+            expect(markets[0]).toHaveProperty("maxLeverage");
+        });
+        it("market info has correct types", async () => {
+            adapter.marketsResponse = createMockMarkets(1);
+            const [market] = await adapter.getMarkets();
+            expect(typeof market.symbol).toBe("string");
+            expect(typeof market.markPrice).toBe("string");
+            expect(typeof market.indexPrice).toBe("string");
+            expect(typeof market.fundingRate).toBe("string");
+            expect(typeof market.volume24h).toBe("string");
+            expect(typeof market.openInterest).toBe("string");
+            expect(typeof market.maxLeverage).toBe("number");
+        });
+    });
+    describe("getOrderbook", () => {
+        it("returns bids and asks", async () => {
+            adapter.orderbookResponse = {
+                bids: [["99000", "1.5"], ["98900", "2.0"]],
+                asks: [["100100", "0.8"], ["100200", "1.2"]],
+            };
+            const book = await adapter.getOrderbook("BTC");
+            expect(book.bids).toHaveLength(2);
+            expect(book.asks).toHaveLength(2);
+            expect(book.bids[0]).toEqual(["99000", "1.5"]);
+            expect(adapter.getCallsFor("getOrderbook")[0].args).toEqual(["BTC"]);
+        });
+    });
+    describe("getBalance", () => {
+        it("returns balance info", async () => {
+            const balance = await adapter.getBalance();
+            expect(balance).toHaveProperty("equity");
+            expect(balance).toHaveProperty("available");
+            expect(balance).toHaveProperty("marginUsed");
+            expect(balance).toHaveProperty("unrealizedPnl");
+            expect(Number(balance.equity)).toBeGreaterThan(0);
+        });
+    });
+    describe("getPositions", () => {
+        it("returns positions array", async () => {
+            adapter.positionsResponse = createMockPositions(2);
+            const positions = await adapter.getPositions();
+            expect(positions).toHaveLength(2);
+            expect(positions[0].side).toBe("long");
+            expect(positions[1].side).toBe("short");
+        });
+        it("position has required fields", async () => {
+            adapter.positionsResponse = createMockPositions(1);
+            const [pos] = await adapter.getPositions();
+            expect(pos).toHaveProperty("symbol");
+            expect(pos).toHaveProperty("side");
+            expect(pos).toHaveProperty("size");
+            expect(pos).toHaveProperty("entryPrice");
+            expect(pos).toHaveProperty("markPrice");
+            expect(pos).toHaveProperty("liquidationPrice");
+            expect(pos).toHaveProperty("unrealizedPnl");
+            expect(pos).toHaveProperty("leverage");
+        });
+    });
+    describe("getOpenOrders", () => {
+        it("returns orders array", async () => {
+            adapter.ordersResponse = createMockOrders(2);
+            const orders = await adapter.getOpenOrders();
+            expect(orders).toHaveLength(2);
+            expect(orders[0].side).toBe("buy");
+            expect(orders[1].side).toBe("sell");
+        });
+    });
+    describe("marketOrder", () => {
+        it("places 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("records sell orders", async () => {
+            await adapter.marketOrder("ETH", "sell", "1.0");
+            const calls = adapter.getCallsFor("marketOrder");
+            expect(calls[0].args).toEqual(["ETH", "sell", "1.0"]);
+        });
+    });
+    describe("limitOrder", () => {
+        it("places limit order with correct params", 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("cancelOrder", () => {
+        it("cancels with symbol and orderId", async () => {
+            await adapter.cancelOrder("BTC", "12345");
+            const calls = adapter.getCallsFor("cancelOrder");
+            expect(calls[0].args).toEqual(["BTC", "12345"]);
+        });
+    });
+    describe("cancelAllOrders", () => {
+        it("cancels all for specific symbol", async () => {
+            await adapter.cancelAllOrders("BTC");
+            const calls = adapter.getCallsFor("cancelAllOrders");
+            expect(calls[0].args).toEqual(["BTC"]);
+        });
+        it("cancels all without symbol", async () => {
+            await adapter.cancelAllOrders();
+            const calls = adapter.getCallsFor("cancelAllOrders");
+            expect(calls[0].args).toEqual([undefined]);
+        });
+    });
+    describe("adapter type safety", () => {
+        it("satisfies ExchangeAdapter interface", () => {
+            const _check = adapter;
+            expect(_check).toBeDefined();
+        });
+    });
+});

package/dist/__tests__/exchanges/mock-adapter.d.ts

@@ -0,0 +1,69 @@
+import type { ExchangeAdapter, ExchangeMarketInfo, ExchangePosition, ExchangeOrder, ExchangeBalance, ExchangeTrade, ExchangeFundingPayment, ExchangeKline } from "../../exchanges/interface.js";
+/**
+ * Mock adapter for unit testing. Records all calls and returns configurable responses.
+ */
+export declare class MockAdapter implements ExchangeAdapter {
+    readonly name: string;
+    calls: {
+        method: string;
+        args: unknown[];
+    }[];
+    marketsResponse: ExchangeMarketInfo[];
+    orderbookResponse: {
+        bids: [string, string][];
+        asks: [string, string][];
+    };
+    balanceResponse: ExchangeBalance;
+    positionsResponse: ExchangePosition[];
+    ordersResponse: ExchangeOrder[];
+    orderResult: unknown;
+    constructor(name?: string);
+    private record;
+    getCallsFor(method: string): {
+        method: string;
+        args: unknown[];
+    }[];
+    reset(): void;
+    getMarkets(): Promise<ExchangeMarketInfo[]>;
+    getOrderbook(symbol: string): Promise<{
+        bids: [string, string][];
+        asks: [string, string][];
+    }>;
+    getBalance(): Promise<ExchangeBalance>;
+    getPositions(): Promise<ExchangePosition[]>;
+    getOpenOrders(): Promise<ExchangeOrder[]>;
+    marketOrder(symbol: string, side: "buy" | "sell", size: string): Promise<unknown>;
+    limitOrder(symbol: string, side: "buy" | "sell", price: string, size: string): Promise<unknown>;
+    editOrder(symbol: string, orderId: string, price: string, size: string): Promise<unknown>;
+    cancelOrder(symbol: string, orderId: string): Promise<{
+        status: string;
+    }>;
+    cancelAllOrders(symbol?: string): Promise<{
+        status: string;
+    }>;
+    setLeverage(symbol: string, leverage: number, marginMode?: "cross" | "isolated"): Promise<{
+        symbol: string;
+        leverage: number;
+        marginMode: "cross" | "isolated" | undefined;
+    }>;
+    stopOrder(symbol: string, side: "buy" | "sell", size: string, triggerPrice: string, opts?: {
+        limitPrice?: string;
+        reduceOnly?: boolean;
+    }): Promise<unknown>;
+    getRecentTrades(symbol: string, limit?: number): Promise<ExchangeTrade[]>;
+    getFundingHistory(symbol: string, limit?: number): Promise<{
+        time: number;
+        rate: string;
+        price: string;
+    }[]>;
+    getKlines(symbol: string, interval: string, startTime: number, endTime: number): Promise<ExchangeKline[]>;
+    getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;
+    getTradeHistory(limit?: number): Promise<ExchangeTrade[]>;
+    getFundingPayments(limit?: number): Promise<ExchangeFundingPayment[]>;
+}
+/** Factory to create mock markets data */
+export declare function createMockMarkets(count?: number): ExchangeMarketInfo[];
+/** Factory to create mock positions */
+export declare function createMockPositions(count?: number): ExchangePosition[];
+/** Factory to create mock orders */
+export declare function createMockOrders(count?: number): ExchangeOrder[];