perp-cli 0.6.4 → 0.7.2

package/dist/exchanges/hyperliquid.d.ts

@@ -1,8 +1,10 @@
 import { Hyperliquid } from "hyperliquid";
 import type { ExchangeAdapter, ExchangeMarketInfo, ExchangePosition, ExchangeOrder, ExchangeBalance, ExchangeTrade, ExchangeFundingPayment, ExchangeKline } from "./interface.js";
-import type { EvmSigner } from "../signer/interface.js";
+import type { EvmSigner } from "../signer/index.js";
 export declare class HyperliquidAdapter implements ExchangeAdapter {
     readonly name = "hyperliquid";
+    readonly chain = "evm";
+    readonly aliases: readonly ["hl"];
     private sdk;
     private _address;
     private _privateKey;
@@ -13,6 +15,7 @@ export declare class HyperliquidAdapter implements ExchangeAdapter {
     private _szDecimalsMap;
     /** HIP-3 deployed perp dex name. Empty string = native (validator) perps. */
     private _dex;
+    private static _lastNonce;
     constructor(privateKey?: string, testnet?: boolean);
     /** Set the HIP-3 deployed perp dex to query/trade on. */
     setDex(dex: string): void;
@@ -134,7 +137,10 @@ export declare class HyperliquidAdapter implements ExchangeAdapter {
      * Withdraw from Hyperliquid L1 bridge.
      * Python SDK: withdraw_from_bridge(amount, destination) → action type "withdraw3"
      */
-    withdraw(amount: string, destination: string): Promise<any>;
+    withdraw(amount: string, destination: string, _opts?: {
+        assetId?: number;
+        routeType?: number;
+    }): Promise<any>;
     /**
      * Transfer USD between accounts on Hyperliquid L1.
      * Python SDK: usd_transfer(amount, destination)

package/dist/exchanges/hyperliquid.js

@@ -1,7 +1,9 @@
 import { Hyperliquid } from "hyperliquid";
-import { LocalEvmSigner } from "../signer/evm-local.js";
+import { LocalEvmSigner } from "../signer/index.js";
 export class HyperliquidAdapter {
     name = "hyperliquid";
+    chain = "evm";
+    aliases = ["hl"];
     sdk;
     _address;
     _privateKey;
@@ -12,6 +14,7 @@ export class HyperliquidAdapter {
     _szDecimalsMap = new Map(); // symbol → szDecimals
     /** HIP-3 deployed perp dex name. Empty string = native (validator) perps. */
     _dex = "";
+    static _lastNonce = 0;
     // In-memory cache removed — using file-based cache (src/cache.ts) for cross-process dedup
     constructor(privateKey, testnet = false) {
         // Disable WebSocket in SDK — we use REST for all info calls and raw
@@ -149,7 +152,14 @@ export class HyperliquidAdapter {
     /** Get szDecimals for a symbol (cached from init/getMeta) */
     getSzDecimals(symbol) {
         const resolved = this.resolveSymbol(symbol.toUpperCase());
-        return this._szDecimalsMap.get(resolved) ?? 2; // 2 is safe middle ground
+        const dec = this._szDecimalsMap.get(resolved);
+        if (dec !== undefined)
+            return dec;
+        // Retry asset map load if empty
+        if (this._szDecimalsMap.size === 0) {
+            console.error(`[hyperliquid] szDecimals not loaded for ${symbol}, using fallback 2`);
+        }
+        return 2;
     }
     /** HL official price rounding: 5 significant figures */
     _hlRoundPrice(px, szDecimals, maxDecimals = 6) {
@@ -327,7 +337,9 @@ export class HyperliquidAdapter {
                 side: szi > 0 ? "long" : "short",
                 size: String(Math.abs(szi)),
                 entryPrice: String(pos.entryPx ?? "0"),
-                markPrice: String(pos.positionValue ? Number(pos.positionValue) / Math.abs(szi) : "0"),
+                markPrice: String(szi !== 0 && pos.positionValue && Number(pos.positionValue) !== 0
+                    ? Number(pos.positionValue) / Math.abs(szi)
+                    : pos.markPx ?? "0"),
                 liquidationPrice: String(pos.liquidationPx ?? "N/A"),
                 unrealizedPnl: String(pos.unrealizedPnl ?? "0"),
                 leverage: Number(pos.leverage?.value ?? 1),
@@ -485,7 +497,10 @@ export class HyperliquidAdapter {
         // recovered signer address is wrong → "User or API Wallet does not exist".
         const normalizedAction = HyperliquidAdapter._normalizeAction(action);
         // Sign L1 action (replicates SDK's signL1Action)
-        const nonce = Date.now();
+        // Monotonic nonce: ensures uniqueness even for rapid-fire requests in same millisecond
+        const now = Date.now();
+        HyperliquidAdapter._lastNonce = now > HyperliquidAdapter._lastNonce ? now : HyperliquidAdapter._lastNonce + 1;
+        const nonce = HyperliquidAdapter._lastNonce;
         const msgPackBytes = encode(normalizedAction);
         const data = new Uint8Array(msgPackBytes.length + 9); // +8 nonce +1 vault flag
         data.set(msgPackBytes);
@@ -531,7 +546,7 @@ export class HyperliquidAdapter {
             throw new Error(`HL exchange API error (${res.status}): ${text.slice(0, 200)}`);
         }
         if (result?.status === "err") {
-            throw new Error(result.response ?? JSON.stringify(result));
+            throw new Error(typeof result.response === "string" ? result.response : JSON.stringify(result));
         }
         return result;
     }
@@ -821,7 +836,7 @@ export class HyperliquidAdapter {
      * Withdraw from Hyperliquid L1 bridge.
      * Python SDK: withdraw_from_bridge(amount, destination) → action type "withdraw3"
      */
-    async withdraw(amount, destination) {
+    async withdraw(amount, destination, _opts) {
         this.ensureSigner();
         try {
             return await this.sdk.exchange.initiateWithdrawal(destination, parseFloat(amount));

package/dist/exchanges/index.d.ts

@@ -0,0 +1,11 @@
+export type { ExchangeMarketInfo, ExchangePosition, ExchangeOrder, ExchangeBalance, ExchangeTrade, ExchangeFundingPayment, ExchangeKline, ExchangeAdapter, } from "./interface.js";
+export type { SpotMarketInfo, SpotBalance, SpotAdapter } from "./spot-interface.js";
+export { SPOT_PERP_TOKEN_MAP, PERP_TO_SPOT_MAP, MAX_PRICE_DEVIATION_PCT } from "./spot-interface.js";
+export * from "./capabilities.js";
+export { registerAdapter, getAdapterRegistration, listExchanges, resolveExchangeName } from "./registry.js";
+export type { AdapterRegistration } from "./registry.js";
+export { PacificaAdapter } from "./pacifica.js";
+export { HyperliquidAdapter } from "./hyperliquid.js";
+export { LighterAdapter } from "./lighter.js";
+export { HyperliquidSpotAdapter } from "./hyperliquid-spot.js";
+export { LighterSpotAdapter } from "./lighter-spot.js";

package/dist/exchanges/index.js

@@ -0,0 +1,10 @@
+export { SPOT_PERP_TOKEN_MAP, PERP_TO_SPOT_MAP, MAX_PRICE_DEVIATION_PCT } from "./spot-interface.js";
+// Capability interfaces + type guards
+export * from "./capabilities.js";
+// Adapter registry
+export { registerAdapter, getAdapterRegistration, listExchanges, resolveExchangeName } from "./registry.js";
+export { PacificaAdapter } from "./pacifica.js";
+export { HyperliquidAdapter } from "./hyperliquid.js";
+export { LighterAdapter } from "./lighter.js";
+export { HyperliquidSpotAdapter } from "./hyperliquid-spot.js";
+export { LighterSpotAdapter } from "./lighter-spot.js";

package/dist/exchanges/interface.d.ts

@@ -61,6 +61,9 @@ export interface ExchangeKline {
 }
 export interface ExchangeAdapter {
     readonly name: string;
+    readonly chain?: string;
+    readonly aliases?: readonly string[];
+    init?(): Promise<void>;
     getMarkets(): Promise<ExchangeMarketInfo[]>;
     getOrderbook(symbol: string): Promise<{
         bids: [string, string][];

package/dist/exchanges/lighter-spot.d.ts

@@ -22,6 +22,8 @@ export declare class LighterSpotAdapter implements SpotAdapter {
     init(): Promise<void>;
     private _loadSpotMarkets;
     /** Resolve a symbol (e.g., "ETH" or "ETH/USDC") to the full spot symbol */
+    /** Get decimals for a symbol — always from API data, never hardcoded fallback */
+    private _getDecimals;
     private resolveSymbol;
     getSpotMarkets(): Promise<SpotMarketInfo[]>;
     getSpotOrderbook(symbol: string): Promise<{
@@ -51,6 +53,17 @@ export declare class LighterSpotAdapter implements SpotAdapter {
     getSpotMarketId(symbol: string): number | undefined;
     /** Check if a base token has a spot market */
     hasSpotMarket(base: string): boolean;
+    /** Query open orders across all spot markets (market_id ≥ 2048). */
+    getSpotOpenOrders(): Promise<Array<{
+        orderId: string;
+        symbol: string;
+        side: "buy" | "sell";
+        price: string;
+        size: string;
+        clientOrderIndex?: number;
+    }>>;
+    /** Cancel a spot order by clientOrderIndex (safe integer, avoids order_id overflow). */
+    spotCancelByClientIndex(symbol: string, clientOrderIndex: number): Promise<unknown>;
     private _placeOrder;
     /** Generate a unique client order index (uint48). Uses timestamp + counter. */
     private _nextClientOrderIndex;

package/dist/exchanges/lighter-spot.js

@@ -74,6 +74,19 @@ export class LighterSpotAdapter {
         }
     }
     /** Resolve a symbol (e.g., "ETH" or "ETH/USDC") to the full spot symbol */
+    /** Get decimals for a symbol — always from API data, never hardcoded fallback */
+    _getDecimals(symbol) {
+        const resolved = symbol.includes("/") ? symbol : symbol.toUpperCase();
+        const dec = this._spotDecimals.get(resolved);
+        if (dec)
+            return dec;
+        // Try base token lookup (e.g., "ETH" → "ETH/USDC")
+        for (const [key, val] of this._spotDecimals) {
+            if (key.split("/")[0] === symbol.toUpperCase())
+                return val;
+        }
+        throw new Error(`No decimal info for spot market ${symbol}. Ensure init() completed successfully.`);
+    }
     resolveSymbol(symbol) {
         const upper = symbol.toUpperCase();
         if (this._spotMarketMap.has(upper))
@@ -106,7 +119,7 @@ export class LighterSpotAdapter {
             const parts = symbol.split("/");
             const base = parts[0] ?? "";
             const quote = parts[1] ?? "USDC";
-            const dec = this._spotDecimals.get(symbol) ?? { size: 4, price: 2 };
+            const dec = this._getDecimals(symbol);
             return {
                 symbol, baseToken: base, quoteToken: quote,
                 markPrice: this._spotPrices.get(symbol) ?? "0", volume24h: "0",
@@ -207,10 +220,10 @@ export class LighterSpotAdapter {
             throw new Error(`Order value $${(sizeNum * refPrice).toFixed(2)} below min_quote_amount $${minSize.quote} for ${resolved}`);
         }
         const slippagePrice = side === "buy" ? refPrice * 1.05 : refPrice * 0.95;
-        const dec = this._spotDecimals.get(resolved) ?? { size: 2, price: 4 };
+        const dec = this._getDecimals(resolved);
         const baseAmount = Math.round(sizeNum * Math.pow(10, dec.size));
         const priceTicks = Math.round(slippagePrice * Math.pow(10, dec.price));
-        return this._placeOrder({
+        const result = await this._placeOrder({
             marketIndex: marketId,
             baseAmount,
             price: Math.max(priceTicks, 1),
@@ -218,6 +231,7 @@ export class LighterSpotAdapter {
             orderType: 1, // MARKET
             timeInForce: 0, // IOC
         });
+        return result;
     }
     async spotLimitOrder(symbol, side, price, size, opts) {
         await this.init();
@@ -226,23 +240,28 @@ export class LighterSpotAdapter {
         if (marketId === undefined) {
             throw new Error(`Unknown Lighter spot market: ${symbol}`);
         }
-        // Validate min order size
-        const sizeNum = parseFloat(size);
-        const priceNum = parseFloat(price);
+        const dec = this._getDecimals(resolved);
+        // Auto-round to exchange precision — caller doesn't need to know decimals
+        let sizeNum = Number(Number(size).toFixed(dec.size));
+        const priceNum = Number(Number(price).toFixed(dec.price));
+        // Auto-ceil size to min_base_amount if just below (within 10%)
         const minSize = this._spotMinSize.get(resolved);
+        if (minSize && sizeNum > 0 && sizeNum < minSize.base && sizeNum >= minSize.base * 0.9) {
+            sizeNum = minSize.base;
+        }
+        // Validate min order size
         if (minSize) {
             if (sizeNum < minSize.base) {
-                throw new Error(`Size ${size} below min_base_amount ${minSize.base} for ${resolved}`);
+                throw new Error(`Size ${sizeNum} below min_base_amount ${minSize.base} for ${resolved}`);
             }
             if (sizeNum * priceNum < minSize.quote) {
                 throw new Error(`Order value $${(sizeNum * priceNum).toFixed(2)} below min_quote_amount $${minSize.quote} for ${resolved}`);
             }
         }
-        const dec = this._spotDecimals.get(resolved) ?? { size: 2, price: 4 };
         const baseAmount = Math.round(sizeNum * Math.pow(10, dec.size));
         const priceTicks = Math.round(priceNum * Math.pow(10, dec.price));
         const isIoc = opts?.tif?.toUpperCase() === "IOC";
-        return this._placeOrder({
+        const result = await this._placeOrder({
             marketIndex: marketId,
             baseAmount,
             price: priceTicks,
@@ -250,6 +269,7 @@ export class LighterSpotAdapter {
             orderType: 0, // LIMIT
             timeInForce: isIoc ? 0 : 1,
         });
+        return result;
     }
     async spotCancelOrder(symbol, orderId) {
         await this.init();
@@ -258,24 +278,29 @@ export class LighterSpotAdapter {
         if (marketId === undefined) {
             throw new Error(`Unknown Lighter spot market: ${symbol}`);
         }
-        // Lighter order IDs can exceed Number.MAX_SAFE_INTEGER (2^53-1).
-        // The WASM signer only accepts JS number, so large IDs lose precision
-        // and the cancel silently targets the wrong order.
-        // Fall back to cancelAll for the market when the ID is unsafe.
         const idNum = Number(orderId);
-        if (!Number.isSafeInteger(idNum)) {
-            return this.spotCancelAllOrders(symbol);
+        // If order ID is safe integer, cancel directly
+        if (Number.isSafeInteger(idNum)) {
+            const signer = this._lt.signer;
+            const nonce = await this._getNextNonce();
+            const signed = await signer.signCancelOrder({
+                marketIndex: marketId,
+                orderIndex: idNum,
+                nonce,
+                apiKeyIndex: this._lt._apiKeyIndex,
+                accountIndex: this._lt.accountIndex,
+            });
+            return this._sendTx(signed);
         }
-        const signer = this._lt.signer;
-        const nonce = await this._getNextNonce();
-        const signed = await signer.signCancelOrder({
-            marketIndex: marketId,
-            orderIndex: idNum,
-            nonce,
-            apiKeyIndex: this._lt._apiKeyIndex,
-            accountIndex: this._lt.accountIndex,
-        });
-        return this._sendTx(signed);
+        // Order ID exceeds MAX_SAFE_INTEGER → try lookup from open orders
+        // Note: getSpotOpenOrders() can return empty due to block finality delay.
+        // Prefer spotCancelByClientIndex() with the clientOrderIndex from spotLimitOrder().
+        const openOrders = await this.getSpotOpenOrders();
+        const symbolOrders = openOrders.filter(o => o.symbol.split("/")[0].toUpperCase() === resolved.toUpperCase() && o.clientOrderIndex);
+        if (symbolOrders.length >= 1) {
+            return this.spotCancelByClientIndex(resolved, symbolOrders[0].clientOrderIndex);
+        }
+        throw new Error(`Cannot cancel Lighter spot order ${orderId}: exceeds MAX_SAFE_INTEGER and no clientOrderIndex found`);
     }
     /** Cancel all orders across all markets (spot + perp) */
     async spotCancelAllOrders(_symbol) {
@@ -363,6 +388,52 @@ export class LighterSpotAdapter {
         return this._spotBaseMap.has(base.toUpperCase()) ||
             this._spotMarketMap.has(`${base.toUpperCase()}/USDC`);
     }
+    /** Query open orders across all spot markets (market_id ≥ 2048). */
+    async getSpotOpenOrders() {
+        await this.init();
+        if (this._lt.isReadOnly)
+            return [];
+        const allOrders = [];
+        for (const [sym, marketId] of this._spotMarketMap) {
+            try {
+                const data = await this._restGetAuth("/accountActiveOrders", {
+                    account_index: String(this._lt.accountIndex),
+                    market_id: String(marketId),
+                });
+                for (const o of data.orders ?? []) {
+                    allOrders.push({
+                        orderId: String(o.order_id ?? o.order_index ?? ""),
+                        symbol: sym,
+                        side: o.is_ask ? "sell" : "buy",
+                        price: String(o.price ?? "0"),
+                        size: String(o.remaining_base_amount ?? o.initial_base_amount ?? "0"),
+                        clientOrderIndex: o.client_order_index != null ? Number(o.client_order_index) : undefined,
+                    });
+                }
+            }
+            catch { /* skip market on error */ }
+        }
+        return allOrders;
+    }
+    /** Cancel a spot order by clientOrderIndex (safe integer, avoids order_id overflow). */
+    async spotCancelByClientIndex(symbol, clientOrderIndex) {
+        await this.init();
+        const resolved = this.resolveSymbol(symbol);
+        const marketId = this._spotMarketMap.get(resolved);
+        if (marketId === undefined)
+            throw new Error(`Unknown spot market: ${symbol}`);
+        const signer = this._lt.signer;
+        const nonce = await this._getNextNonce();
+        const apiKeyIndex = this._lt._apiKeyIndex;
+        const signed = await signer.signCancelOrder({
+            marketIndex: marketId,
+            orderIndex: clientOrderIndex,
+            nonce,
+            apiKeyIndex,
+            accountIndex: this._lt.accountIndex,
+        });
+        return this._sendTx(signed);
+    }
     // ── Private helpers ──
     async _placeOrder(opts) {
         if (this._lt.isReadOnly) {
@@ -393,7 +464,8 @@ export class LighterSpotAdapter {
         if (signed.error) {
             throw new Error(`Signer: ${signed.error}`);
         }
-        return this._sendTx(signed);
+        const txResult = await this._sendTx(signed);
+        return { ...txResult, clientOrderIndex };
     }
     /** Generate a unique client order index (uint48). Uses timestamp + counter. */
     _nextClientOrderIndex() {

package/dist/exchanges/lighter.d.ts

@@ -1,8 +1,10 @@
 import type { ExchangeAdapter, ExchangeMarketInfo, ExchangePosition, ExchangeOrder, ExchangeBalance, ExchangeTrade, ExchangeFundingPayment, ExchangeKline } from "./interface.js";
-import type { EvmSigner } from "../signer/interface.js";
+import type { EvmSigner } from "../signer/index.js";
 import type { WasmSignerClient as WasmSignerClientType } from "lighter-ts-sdk";
 export declare class LighterAdapter implements ExchangeAdapter {
     readonly name = "lighter";
+    readonly chain = "ethereum";
+    readonly aliases: readonly ["lt"];
     private _signer;
     private _accountIndex;
     private _apiKeyIndex;
@@ -34,7 +36,7 @@ export declare class LighterAdapter implements ExchangeAdapter {
     } & WasmSignerClientType;
     get accountIndex(): number;
     get address(): string;
-    get evmKey(): string;
+    /** @internal — evmKey is intentionally not exposed publicly for security */
     get isReadOnly(): boolean;
     /** Inject an external EVM signer. Call before init() to skip LocalEvmSigner creation. */
     setSigner(signer: EvmSigner): void;
@@ -70,7 +72,11 @@ export declare class LighterAdapter implements ExchangeAdapter {
         reduceOnly?: boolean;
     }): Promise<unknown>;
     updateLeverage(symbol: string, leverage: number, marginMode?: "cross" | "isolated"): Promise<unknown>;
-    withdraw(amount: number, assetId?: number, routeType?: number): Promise<unknown>;
+    withdraw(amount: string, destination: string, opts?: {
+        assetId?: number;
+        routeType?: number;
+    }): Promise<unknown>;
+    private _withdrawRaw;
     editOrder(symbol: string, orderId: string, price: string, size: string): Promise<unknown>;
     setLeverage(symbol: string, leverage: number, marginMode?: "cross" | "isolated"): Promise<unknown>;
     getRecentTrades(symbol: string, limit?: number): Promise<ExchangeTrade[]>;

package/dist/exchanges/lighter.js

@@ -1,6 +1,8 @@
-import { LocalEvmSigner } from "../signer/evm-local.js";
+import { LocalEvmSigner } from "../signer/index.js";
 export class LighterAdapter {
     name = "lighter";
+    chain = "ethereum";
+    aliases = ["lt"];
     _signer;
     _accountIndex = -1;
     _apiKeyIndex;
@@ -53,9 +55,7 @@ export class LighterAdapter {
     get address() {
         return this._address;
     }
-    get evmKey() {
-        return this._evmKey;
-    }
+    /** @internal — evmKey is intentionally not exposed publicly for security */
     get isReadOnly() {
         return this._readOnly;
     }
@@ -347,9 +347,13 @@ export class LighterAdapter {
                 side: (Number(p.sign) > 0 ? "long" : "short"),
                 size: String(Math.abs(posSize)),
                 entryPrice: String(p.avg_entry_price || "0"),
-                markPrice: String(posSize !== 0
-                    ? (Number(p.position_value || 0) / Math.abs(posSize)).toFixed(this._marketDecimals.get(String(p.symbol || "").toUpperCase())?.price ?? 4)
-                    : "0"),
+                markPrice: (() => {
+                    if (posSize === 0)
+                        return "0";
+                    const rawMark = Number(p.position_value || 0) / Math.abs(posSize);
+                    const priceDec = this._marketDecimals.get(String(p.symbol || "").toUpperCase())?.price;
+                    return String(priceDec !== undefined ? rawMark.toFixed(priceDec) : rawMark);
+                })(),
                 liquidationPrice: String(p.liquidation_price || "N/A"),
                 unrealizedPnl: String(p.unrealized_pnl || "0"),
                 // Compute actual leverage = notional / account equity (not max leverage from IMF)
@@ -587,7 +591,10 @@ export class LighterAdapter {
         }
         return this.sendTx(signed);
     }
-    async withdraw(amount, assetId = 3, routeType = 0) {
+    async withdraw(amount, destination, opts) {
+        return this._withdrawRaw(parseFloat(amount), opts?.assetId ?? 3, opts?.routeType ?? 0);
+    }
+    async _withdrawRaw(amount, assetId = 3, routeType = 0) {
         this.ensureSigner();
         const nonce = await this.getNextNonce();
         const signed = await this._signer.signWithdraw({
@@ -1022,6 +1029,9 @@ export class LighterAdapter {
         if (!this._evmSigner) {
             throw new Error("No EVM private key configured. Run: perp init");
         }
+        if (this._accountIndex < 0) {
+            throw new Error("Account index not available. Call init() first or set LIGHTER_ACCOUNT_INDEX.");
+        }
         // 1. Generate key pair
         const { privateKey, publicKey } = await LighterAdapter.generateApiKey();
         // 2. Get nonce from API

package/dist/exchanges/nado.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Nado DEX adapter — Orderbook DEX on Ink L2.
+ * API: https://gateway.nado.xyz/v1 (mainnet) / https://gateway.test.nado.xyz/v1 (testnet)
+ * Docs: https://docs.nado.xyz/developer-resources/api/gateway
+ * Note: API documentation is incomplete — many endpoints are stubbed pending full docs.
+ */
+import type { ExchangeAdapter, ExchangeMarketInfo, ExchangePosition, ExchangeOrder, ExchangeBalance, ExchangeTrade, ExchangeFundingPayment, ExchangeKline } from "./interface.js";
+export declare class NadoAdapter implements ExchangeAdapter {
+    readonly name = "nado";
+    readonly chain = "ink";
+    readonly aliases: readonly ["nad"];
+    private _baseUrl;
+    private _apiKey;
+    constructor(apiKey?: string, testnet?: boolean);
+    init(): Promise<void>;
+    getMarkets(): Promise<ExchangeMarketInfo[]>;
+    getOrderbook(symbol: string): Promise<{
+        bids: [string, string][];
+        asks: [string, string][];
+    }>;
+    getRecentTrades(symbol: string, limit?: number): Promise<ExchangeTrade[]>;
+    getFundingHistory(symbol: string, _limit?: number): Promise<{
+        time: number;
+        rate: string;
+        price: string | null;
+    }[]>;
+    getKlines(symbol: string, interval: string, startTime: number, endTime: number): Promise<ExchangeKline[]>;
+    getBalance(): Promise<ExchangeBalance>;
+    getPositions(): Promise<ExchangePosition[]>;
+    getOpenOrders(): Promise<ExchangeOrder[]>;
+    getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;
+    getTradeHistory(limit?: number): Promise<ExchangeTrade[]>;
+    getFundingPayments(limit?: number): Promise<ExchangeFundingPayment[]>;
+    marketOrder(symbol: string, side: "buy" | "sell", size: string): Promise<unknown>;
+    limitOrder(symbol: string, side: "buy" | "sell", price: string, size: string, opts?: {
+        reduceOnly?: boolean;
+        tif?: string;
+    }): Promise<unknown>;
+    editOrder(symbol: string, orderId: string, price: string, size: string): Promise<unknown>;
+    cancelOrder(symbol: string, orderId: string): Promise<unknown>;
+    cancelAllOrders(symbol?: string): Promise<unknown>;
+    setLeverage(symbol: string, leverage: number, marginMode?: "cross" | "isolated"): Promise<unknown>;
+    stopOrder(symbol: string, side: "buy" | "sell", size: string, triggerPrice: string, opts?: {
+        limitPrice?: string;
+        reduceOnly?: boolean;
+    }): Promise<unknown>;
+    withdraw(amount: string, destination: string): Promise<unknown>;
+    private _get;
+    private _authGet;
+    private _authPost;
+    private _authDelete;
+}