perp-cli 0.11.0 → 0.12.0

package/dist/__tests__/errors.test.js

@@ -1,110 +0,0 @@
-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

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

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

@@ -1,276 +0,0 @@
-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

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

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

@@ -1,132 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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[];