perp-cli 0.6.4 → 0.7.1

package/dist/exchanges/aster.js

@@ -0,0 +1,409 @@
+/**
+ * Aster DEX adapter — Binance Futures API compatible REST wrapper.
+ * Docs: https://docs.asterdex.com/product/aster-perpetuals/api/api-documentation
+ * Base: https://fapi.asterdex.com
+ */
+import { createHmac } from "node:crypto";
+export class AsterAdapter {
+    name = "aster";
+    chain = "bnb";
+    aliases = ["ast"];
+    _apiKey;
+    _apiSecret;
+    _baseUrl;
+    _testnet;
+    constructor(apiKey, apiSecret, testnet = false) {
+        this._apiKey = apiKey || process.env.ASTER_API_KEY || "";
+        this._apiSecret = apiSecret || process.env.ASTER_API_SECRET || "";
+        this._testnet = testnet;
+        this._baseUrl = testnet
+            ? (process.env.ASTER_TESTNET_URL || "https://testnet.asterdex.com")
+            : "https://fapi.asterdex.com";
+    }
+    get isReadOnly() {
+        return !this._apiKey || !this._apiSecret;
+    }
+    async init() {
+        // Verify connectivity by fetching server time
+        await this._publicGet("/fapi/v1/time");
+    }
+    // ── Market Data ──
+    async getMarkets() {
+        const [info, tickers] = await Promise.all([
+            this._publicGet("/fapi/v1/exchangeInfo"),
+            this._publicGet("/fapi/v1/ticker/24hr"),
+        ]);
+        const tickerMap = new Map();
+        for (const t of tickers ?? []) {
+            tickerMap.set(String(t.symbol), t);
+        }
+        // Also fetch premium index for mark/index/funding
+        let premiumMap = new Map();
+        try {
+            const premiums = await this._publicGet("/fapi/v1/premiumIndex");
+            premiumMap = new Map(premiums.map(p => [String(p.symbol), p]));
+        }
+        catch { /* non-critical */ }
+        const tradingSymbols = (info?.symbols ?? [])
+            .filter((s) => String(s.contractType) === "PERPETUAL" && String(s.status) === "TRADING");
+        // Fetch open interest per symbol in parallel (batched to avoid overwhelming the API).
+        // The /fapi/v1/ticker/24hr response does NOT include openInterest — need a separate endpoint.
+        const oiMap = new Map();
+        const OI_BATCH = 20;
+        for (let i = 0; i < tradingSymbols.length; i += OI_BATCH) {
+            const batch = tradingSymbols.slice(i, i + OI_BATCH);
+            const results = await Promise.allSettled(batch.map(async (s) => {
+                const sym = String(s.symbol);
+                const res = await this._publicGet("/fapi/v1/openInterest", { symbol: sym });
+                return { sym, oi: String(res?.openInterest ?? "0") };
+            }));
+            for (const r of results) {
+                if (r.status === "fulfilled")
+                    oiMap.set(r.value.sym, r.value.oi);
+            }
+        }
+        return tradingSymbols
+            .map((s) => {
+            const sym = String(s.symbol);
+            const ticker = tickerMap.get(sym);
+            const premium = premiumMap.get(sym);
+            // Extract max leverage from leverage brackets if available
+            const maxLev = Number(s.maxLeverage ?? 50);
+            return {
+                symbol: sym,
+                markPrice: String(premium?.markPrice ?? ticker?.lastPrice ?? "0"),
+                indexPrice: String(premium?.indexPrice ?? "0"),
+                fundingRate: String(premium?.lastFundingRate ?? "0"),
+                volume24h: String(ticker?.quoteVolume ?? ticker?.volume ?? "0"),
+                openInterest: oiMap.get(sym) ?? "0",
+                maxLeverage: maxLev,
+            };
+        });
+    }
+    async getOrderbook(symbol) {
+        const res = await this._publicGet("/fapi/v1/depth", { symbol: symbol.toUpperCase(), limit: "50" });
+        return {
+            bids: res?.bids ?? [],
+            asks: res?.asks ?? [],
+        };
+    }
+    async getRecentTrades(symbol, limit = 20) {
+        const trades = await this._publicGet("/fapi/v1/trades", {
+            symbol: symbol.toUpperCase(),
+            limit: String(limit),
+        });
+        return (trades ?? []).map((t) => ({
+            time: Number(t.time ?? 0),
+            symbol: symbol.toUpperCase(),
+            side: t.isBuyerMaker ? "sell" : "buy",
+            price: String(t.price ?? "0"),
+            size: String(t.qty ?? "0"),
+            fee: "0",
+        }));
+    }
+    async getFundingHistory(symbol, limit = 10) {
+        const data = await this._publicGet("/fapi/v1/fundingRate", {
+            symbol: symbol.toUpperCase(),
+            limit: String(limit),
+        });
+        return (data ?? []).map((d) => ({
+            time: Number(d.fundingTime ?? 0),
+            rate: String(d.fundingRate ?? "0"),
+            price: d.markPrice ? String(d.markPrice) : null,
+        }));
+    }
+    async getKlines(symbol, interval, startTime, endTime) {
+        const data = await this._publicGet("/fapi/v1/klines", {
+            symbol: symbol.toUpperCase(),
+            interval,
+            startTime: String(startTime),
+            endTime: String(endTime),
+            limit: "500",
+        });
+        return (data ?? []).map((k) => ({
+            time: Number(k[0]),
+            open: String(k[1]),
+            high: String(k[2]),
+            low: String(k[3]),
+            close: String(k[4]),
+            volume: String(k[5]),
+            trades: Number(k[8] ?? 0),
+        }));
+    }
+    // ── Account ──
+    async getBalance() {
+        const account = await this._signedGet("/fapi/v2/account");
+        const totalWallet = Number(account.totalWalletBalance ?? 0);
+        const unrealizedPnl = Number(account.totalUnrealizedProfit ?? 0);
+        const available = Number(account.availableBalance ?? 0);
+        const marginUsed = Number(account.totalInitialMargin ?? 0);
+        return {
+            equity: String(totalWallet + unrealizedPnl),
+            available: String(available),
+            marginUsed: String(marginUsed),
+            unrealizedPnl: String(unrealizedPnl),
+        };
+    }
+    async getPositions() {
+        const data = await this._signedGet("/fapi/v2/positionRisk");
+        return (data ?? [])
+            .filter((p) => Number(p.positionAmt ?? 0) !== 0)
+            .map((p) => {
+            const amt = Number(p.positionAmt ?? 0);
+            return {
+                symbol: String(p.symbol ?? ""),
+                side: amt > 0 ? "long" : "short",
+                size: String(Math.abs(amt)),
+                entryPrice: String(p.entryPrice ?? "0"),
+                markPrice: String(p.markPrice ?? "0"),
+                liquidationPrice: String(p.liquidationPrice ?? "0"),
+                unrealizedPnl: String(p.unRealizedProfit ?? "0"),
+                leverage: Number(p.leverage ?? 1),
+            };
+        });
+    }
+    async getOpenOrders() {
+        const orders = await this._signedGet("/fapi/v1/openOrders");
+        return (orders ?? []).map((o) => ({
+            orderId: String(o.orderId ?? ""),
+            symbol: String(o.symbol ?? ""),
+            side: String(o.side).toLowerCase(),
+            price: String(o.price ?? "0"),
+            size: String(o.origQty ?? "0"),
+            filled: String(o.executedQty ?? "0"),
+            status: String(o.status ?? ""),
+            type: String(o.type ?? ""),
+        }));
+    }
+    async getOrderHistory(limit = 30) {
+        // allOrders requires symbol — get from positions or recent trades
+        const positions = await this.getPositions();
+        const symbols = new Set(positions.map(p => p.symbol));
+        if (symbols.size === 0) {
+            // Fallback: query the most common perp symbols when no open positions exist
+            for (const s of ["BTCUSDT", "ETHUSDT", "SOLUSDT", "BNBUSDT", "XRPUSDT"]) {
+                symbols.add(s);
+            }
+        }
+        const allOrders = [];
+        for (const sym of symbols) {
+            try {
+                const orders = await this._signedGet("/fapi/v1/allOrders", {
+                    symbol: sym,
+                    limit: String(limit),
+                });
+                for (const o of orders ?? []) {
+                    allOrders.push({
+                        orderId: String(o.orderId ?? ""),
+                        symbol: String(o.symbol ?? ""),
+                        side: String(o.side).toLowerCase(),
+                        price: String(o.price ?? "0"),
+                        size: String(o.origQty ?? "0"),
+                        filled: String(o.executedQty ?? "0"),
+                        status: String(o.status ?? ""),
+                        type: String(o.type ?? ""),
+                    });
+                }
+            }
+            catch { /* skip */ }
+        }
+        return allOrders.slice(0, limit);
+    }
+    async getTradeHistory(limit = 30) {
+        const positions = await this.getPositions();
+        const symbols = new Set(positions.map(p => p.symbol));
+        if (symbols.size === 0)
+            symbols.add("BTCUSDT");
+        const allTrades = [];
+        for (const sym of symbols) {
+            try {
+                const trades = await this._signedGet("/fapi/v1/userTrades", {
+                    symbol: sym,
+                    limit: String(limit),
+                });
+                for (const t of trades ?? []) {
+                    allTrades.push({
+                        time: Number(t.time ?? 0),
+                        symbol: String(t.symbol ?? ""),
+                        side: t.buyer ? "buy" : "sell",
+                        price: String(t.price ?? "0"),
+                        size: String(t.qty ?? "0"),
+                        fee: String(t.commission ?? "0"),
+                    });
+                }
+            }
+            catch { /* skip */ }
+        }
+        return allTrades.sort((a, b) => b.time - a.time).slice(0, limit);
+    }
+    async getFundingPayments(limit = 200) {
+        const data = await this._signedGet("/fapi/v1/income", {
+            incomeType: "FUNDING_FEE",
+            limit: String(limit),
+        });
+        return (data ?? []).map((f) => ({
+            time: Number(f.time ?? 0),
+            symbol: String(f.symbol ?? ""),
+            payment: String(f.income ?? "0"),
+        }));
+    }
+    // ── Trading ──
+    async marketOrder(symbol, side, size) {
+        return this._signedPost("/fapi/v1/order", {
+            symbol: symbol.toUpperCase(),
+            side: side.toUpperCase(),
+            type: "MARKET",
+            quantity: size,
+        });
+    }
+    async limitOrder(symbol, side, price, size, opts) {
+        const params = {
+            symbol: symbol.toUpperCase(),
+            side: side.toUpperCase(),
+            type: "LIMIT",
+            price,
+            quantity: size,
+            timeInForce: opts?.tif?.toUpperCase() || "GTC",
+        };
+        if (opts?.reduceOnly)
+            params.reduceOnly = "true";
+        return this._signedPost("/fapi/v1/order", params);
+    }
+    async editOrder(symbol, orderId, price, size) {
+        // Aster has no atomic edit — cancel + replace
+        const openOrders = await this.getOpenOrders();
+        const existing = openOrders.find(o => o.orderId === orderId);
+        const side = existing?.side ?? "buy";
+        await this.cancelOrder(symbol, orderId);
+        return this.limitOrder(symbol, side, price, size);
+    }
+    async cancelOrder(symbol, orderId) {
+        return this._signedDelete("/fapi/v1/order", {
+            symbol: symbol.toUpperCase(),
+            orderId,
+        });
+    }
+    async cancelAllOrders(symbol) {
+        if (!symbol) {
+            // Cancel all for all symbols with open orders
+            const orders = await this.getOpenOrders();
+            const symbols = new Set(orders.map(o => o.symbol));
+            const results = [];
+            for (const sym of symbols) {
+                results.push(await this._signedDelete("/fapi/v1/allOpenOrders", { symbol: sym }));
+            }
+            return results;
+        }
+        return this._signedDelete("/fapi/v1/allOpenOrders", { symbol: symbol.toUpperCase() });
+    }
+    // ── Risk ──
+    async setLeverage(symbol, leverage, marginMode) {
+        // Set margin type first if specified
+        if (marginMode) {
+            try {
+                await this._signedPost("/fapi/v1/marginType", {
+                    symbol: symbol.toUpperCase(),
+                    marginType: marginMode === "cross" ? "CROSSED" : "ISOLATED",
+                });
+            }
+            catch {
+                // May fail if already set — non-critical
+            }
+        }
+        return this._signedPost("/fapi/v1/leverage", {
+            symbol: symbol.toUpperCase(),
+            leverage: String(leverage),
+        });
+    }
+    async stopOrder(symbol, side, size, triggerPrice, opts) {
+        const params = {
+            symbol: symbol.toUpperCase(),
+            side: side.toUpperCase(),
+            quantity: size,
+            stopPrice: triggerPrice,
+            type: opts?.limitPrice ? "STOP" : "STOP_MARKET",
+        };
+        if (opts?.limitPrice) {
+            params.price = opts.limitPrice;
+            params.timeInForce = "GTC";
+        }
+        if (opts?.reduceOnly)
+            params.reduceOnly = "true";
+        return this._signedPost("/fapi/v1/order", params);
+    }
+    // ── Withdraw (unified interface) ──
+    async withdraw(amount, _destination, _opts) {
+        // Aster withdrawal is via separate spot/wallet API, not futures API
+        throw new Error("Aster withdrawal requires the spot API (not available in futures mode). Use the Aster web UI to withdraw.");
+    }
+    // ── Internal HTTP helpers ──
+    _sign(params) {
+        params.timestamp = String(Date.now());
+        params.recvWindow = "5000";
+        const queryString = Object.entries(params)
+            .map(([k, v]) => `${k}=${encodeURIComponent(v)}`)
+            .join("&");
+        const signature = createHmac("sha256", this._apiSecret)
+            .update(queryString)
+            .digest("hex");
+        return `${queryString}&signature=${signature}`;
+    }
+    async _publicGet(path, params = {}) {
+        const qs = Object.entries(params)
+            .map(([k, v]) => `${k}=${encodeURIComponent(v)}`)
+            .join("&");
+        const url = `${this._baseUrl}${path}${qs ? `?${qs}` : ""}`;
+        const res = await fetch(url);
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`GET ${path} failed (${res.status}): ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+    async _signedGet(path, params = {}) {
+        if (this.isReadOnly)
+            throw new Error("No API key configured for Aster. Set ASTER_API_KEY and ASTER_API_SECRET in ~/.perp/.env");
+        const signed = this._sign({ ...params });
+        const url = `${this._baseUrl}${path}?${signed}`;
+        const res = await fetch(url, {
+            headers: { "X-MBX-APIKEY": this._apiKey },
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`GET ${path} failed (${res.status}): ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+    async _signedPost(path, params = {}) {
+        if (this.isReadOnly)
+            throw new Error("No API key configured for Aster. Set ASTER_API_KEY and ASTER_API_SECRET in ~/.perp/.env");
+        const signed = this._sign({ ...params });
+        const res = await fetch(`${this._baseUrl}${path}`, {
+            method: "POST",
+            headers: {
+                "X-MBX-APIKEY": this._apiKey,
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body: signed,
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`POST ${path} failed (${res.status}): ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+    async _signedDelete(path, params = {}) {
+        if (this.isReadOnly)
+            throw new Error("No API key configured for Aster. Set ASTER_API_KEY and ASTER_API_SECRET in ~/.perp/.env");
+        const signed = this._sign({ ...params });
+        const res = await fetch(`${this._baseUrl}${path}?${signed}`, {
+            method: "DELETE",
+            headers: { "X-MBX-APIKEY": this._apiKey },
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`DELETE ${path} failed (${res.status}): ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+}

package/dist/exchanges/capabilities.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Capability sub-interfaces for exchange-specific features.
+ * Use type guard functions (isTwapCapable, hasPacificaSdk, etc.) instead of instanceof checks.
+ */
+import type { ExchangeAdapter } from "./interface.js";
+export interface WithdrawCapable {
+    withdraw(amount: string, destination: string, opts?: {
+        assetId?: number;
+        routeType?: number;
+    }): Promise<unknown>;
+}
+export interface TwapCapable {
+    twapOrder(symbol: string, side: "buy" | "sell", size: string, duration: number, opts?: {
+        reduceOnly?: boolean;
+    }): Promise<unknown>;
+    twapCancel(symbol: string, twapId: number): Promise<unknown>;
+}
+export interface TpSlCapable {
+    setTpSl(symbol: string, side: "buy" | "sell", opts: {
+        tp?: string;
+        tpLimit?: string;
+        sl?: string;
+        size?: string;
+    }): Promise<unknown>;
+}
+export interface TriggerOrderCapable {
+    triggerOrder(symbol: string, side: "buy" | "sell", size: string, triggerPrice: string, type: string, opts?: Record<string, unknown>): Promise<unknown>;
+}
+export interface DexCapable {
+    readonly dex: string;
+    setDex(dex: string): void;
+    listDeployedDexes(): Promise<{
+        name: string;
+        deployer: string;
+        assets: string[];
+    }[]>;
+}
+export interface SubAccountCapable {
+    createSubAccount(name: string): Promise<unknown>;
+    subAccountTransfer(subAccountUser: string, isDeposit: boolean, amount: number): Promise<unknown>;
+}
+export interface PacificaSdkCapable {
+    readonly sdk: unknown;
+    readonly publicKey: string;
+    readonly signer: (msg: Uint8Array) => Promise<Uint8Array>;
+}
+export interface LighterAccountCapable {
+    readonly accountIndex: number;
+    readonly address: string;
+    setupApiKey(apiKeyIndex?: number): Promise<{
+        privateKey: string;
+        publicKey: string;
+    }>;
+}
+export interface EvmAddressCapable {
+    readonly address: string;
+}
+export interface QueryOrderCapable {
+    queryOrder(orderId: number): Promise<unknown>;
+}
+export interface UsdTransferCapable {
+    usdTransfer(amount: number, destination: string): Promise<unknown>;
+}
+export declare function isWithdrawCapable(adapter: ExchangeAdapter): adapter is ExchangeAdapter & WithdrawCapable;
+export declare function isTwapCapable(adapter: ExchangeAdapter): adapter is ExchangeAdapter & TwapCapable;
+export declare function isTpSlCapable(adapter: ExchangeAdapter): adapter is ExchangeAdapter & TpSlCapable;
+export declare function isTriggerOrderCapable(adapter: ExchangeAdapter): adapter is ExchangeAdapter & TriggerOrderCapable;
+export declare function isDexCapable(adapter: ExchangeAdapter): adapter is ExchangeAdapter & DexCapable;
+export declare function isSubAccountCapable(adapter: ExchangeAdapter): adapter is ExchangeAdapter & SubAccountCapable;
+export declare function hasPacificaSdk(adapter: ExchangeAdapter): adapter is ExchangeAdapter & PacificaSdkCapable;
+export declare function hasLighterAccount(adapter: ExchangeAdapter): adapter is ExchangeAdapter & LighterAccountCapable;
+export declare function hasEvmAddress(adapter: ExchangeAdapter): adapter is ExchangeAdapter & EvmAddressCapable;
+export declare function isQueryOrderCapable(adapter: ExchangeAdapter): adapter is ExchangeAdapter & QueryOrderCapable;
+export declare function isUsdTransferCapable(adapter: ExchangeAdapter): adapter is ExchangeAdapter & UsdTransferCapable;

package/dist/exchanges/capabilities.js

@@ -0,0 +1,44 @@
+/**
+ * Capability sub-interfaces for exchange-specific features.
+ * Use type guard functions (isTwapCapable, hasPacificaSdk, etc.) instead of instanceof checks.
+ */
+// ── Type Guards ──
+export function isWithdrawCapable(adapter) {
+    return typeof adapter.withdraw === "function";
+}
+export function isTwapCapable(adapter) {
+    return typeof adapter.twapOrder === "function"
+        && typeof adapter.twapCancel === "function";
+}
+export function isTpSlCapable(adapter) {
+    return typeof adapter.setTpSl === "function";
+}
+export function isTriggerOrderCapable(adapter) {
+    return typeof adapter.triggerOrder === "function";
+}
+export function isDexCapable(adapter) {
+    return typeof adapter.setDex === "function"
+        && typeof adapter.listDeployedDexes === "function";
+}
+export function isSubAccountCapable(adapter) {
+    return typeof adapter.createSubAccount === "function";
+}
+export function hasPacificaSdk(adapter) {
+    return adapter.name === "pacifica"
+        && adapter.sdk != null
+        && typeof adapter.sdk === "object"
+        && typeof adapter.publicKey === "string";
+}
+export function hasLighterAccount(adapter) {
+    return typeof adapter.accountIndex === "number"
+        && typeof adapter.setupApiKey === "function";
+}
+export function hasEvmAddress(adapter) {
+    return typeof adapter.address === "string";
+}
+export function isQueryOrderCapable(adapter) {
+    return typeof adapter.queryOrder === "function";
+}
+export function isUsdTransferCapable(adapter) {
+    return typeof adapter.usdTransfer === "function";
+}

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

@@ -41,7 +41,7 @@ export declare class HyperliquidSpotAdapter implements SpotAdapter {
     transferUsdcToPerp(amount: number): Promise<unknown>;
     /** Get the spot asset index (without the 10000 offset) */
     getSpotIndex(base: string): number | undefined;
-    /** Get spot size decimals for a base token */
+    /** Get spot size decimals for a base token — from API data, not hardcoded */
     getSpotDecimals(base: string): {
         size: number;
         price: number;

package/dist/exchanges/hyperliquid-spot.js

@@ -98,23 +98,28 @@ export class HyperliquidSpotAdapter {
                 if (t.szDecimals !== undefined)
                     tokenSzDec.set(t.index, t.szDecimals);
             }
-            const ctxs = metaCtx[1] ?? [];
+            // Fetch accurate mid prices from allMids (markPx in metaCtx is unreliable for spot)
+            const allMids = await this._infoPost({ type: "allMids" });
+            const usdcTokenIndex = metaCtx[0].tokens?.find(t => t.name === "USDC")?.index ?? 0;
             const markets = [];
-            for (let i = 0; i < metaCtx[0].universe.length; i++) {
-                const u = metaCtx[0].universe[i];
-                const ctx = ctxs[i] ?? {};
+            for (const u of metaCtx[0].universe) {
+                // Only USDC-quoted pairs
+                if (u.tokens[1] !== usdcTokenIndex)
+                    continue;
                 const baseToken = tokenNames.get(u.tokens[0]) ?? "";
-                const quoteToken = tokenNames.get(u.tokens[1]) ?? "USDC";
                 if (!baseToken)
                     continue;
+                // Price from allMids using universe.name (e.g., "PURR/USDC" or "@107")
+                const midPrice = allMids[u.name] ?? "0";
+                const spotDec = this._spotDecimals.get(baseToken.toUpperCase());
                 markets.push({
                     symbol: `${baseToken}/USDC`,
                     baseToken,
-                    quoteToken,
-                    markPrice: String(ctx.markPx ?? ctx.midPx ?? "0"),
-                    volume24h: String(ctx.dayNtlVlm ?? "0"),
-                    sizeDecimals: tokenSzDec.get(u.tokens[0]) ?? 2,
-                    priceDecimals: 6,
+                    quoteToken: "USDC",
+                    markPrice: midPrice,
+                    volume24h: "0",
+                    sizeDecimals: spotDec?.size ?? tokenSzDec.get(u.tokens[0]) ?? 2,
+                    priceDecimals: spotDec?.price ?? 6,
                 });
             }
             return markets;
@@ -230,9 +235,12 @@ export class HyperliquidSpotAdapter {
     getSpotIndex(base) {
         return this._spotAssetMap.get(base.toUpperCase());
     }
-    /** Get spot size decimals for a base token */
+    /** Get spot size decimals for a base token — from API data, not hardcoded */
     getSpotDecimals(base) {
-        return this._spotDecimals.get(base.toUpperCase()) ?? { size: 2, price: 6 };
+        const dec = this._spotDecimals.get(base.toUpperCase());
+        if (dec)
+            return dec;
+        throw new Error(`No decimal info for spot token ${base}. Ensure init() completed successfully.`);
     }
     /**
      * Resolve a symbol to its actual spot base token and index.

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)