perp-cli 0.6.4 → 0.7.2

package/dist/dashboard/server.js

@@ -318,7 +318,7 @@ export async function startDashboard(exchanges, opts = {}) {
         }, { once: true });
     }
     return new Promise((resolve) => {
-        server.listen(port, async () => {
+        server.listen(port, "127.0.0.1", async () => {
             // Start WS feeds (connects to exchange WS APIs)
             await feedMgr.start();
             // Start arb REST polling (30s cycle)

package/dist/dashboard/ws-feeds.d.ts

@@ -5,7 +5,7 @@
  * Falls back to REST polling if WS connection fails.
  * Arb/market data stays on REST (cross-exchange aggregation, no single WS covers it).
  */
-import type { ExchangeBalance, ExchangePosition, ExchangeOrder } from "../exchanges/interface.js";
+import type { ExchangeBalance, ExchangePosition, ExchangeOrder } from "../exchanges/index.js";
 import type { DashboardExchange } from "./server.js";
 export interface WsFeedState {
     balance: ExchangeBalance;

package/dist/event-stream.d.ts

@@ -4,7 +4,7 @@
  * Streams normalized account events as NDJSON (one JSON per line).
  * Uses poll-based diffing for cross-exchange compatibility.
  */
-import type { ExchangeAdapter } from "./exchanges/interface.js";
+import type { ExchangeAdapter } from "./exchanges/index.js";
 export type EventType = "position_opened" | "position_closed" | "position_updated" | "order_placed" | "order_filled" | "order_cancelled" | "balance_update" | "liquidation_warning" | "margin_call" | "heartbeat" | "error";
 export interface StreamEvent {
     type: EventType;

package/dist/exchanges/aster.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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 type { ExchangeAdapter, ExchangeMarketInfo, ExchangePosition, ExchangeOrder, ExchangeBalance, ExchangeTrade, ExchangeFundingPayment, ExchangeKline } from "./interface.js";
+export declare class AsterAdapter implements ExchangeAdapter {
+    readonly name = "aster";
+    readonly chain = "bnb";
+    readonly aliases: readonly ["ast"];
+    private _apiKey;
+    private _apiSecret;
+    private _baseUrl;
+    private _testnet;
+    constructor(apiKey?: string, apiSecret?: string, testnet?: boolean);
+    get isReadOnly(): boolean;
+    /** CLI symbol → Aster API symbol (ETH → ETHUSDT) */
+    private _toApi;
+    /** Aster API symbol → CLI symbol (ETHUSDT → ETH) */
+    private _fromApi;
+    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, _opts?: {
+        assetId?: number;
+        routeType?: number;
+    }): Promise<unknown>;
+    private _sign;
+    private _publicGet;
+    private _signedGet;
+    private _signedPost;
+    private _signedDelete;
+}

package/dist/exchanges/aster.js

@@ -0,0 +1,420 @@
+/**
+ * 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;
+    }
+    /** CLI symbol → Aster API symbol (ETH → ETHUSDT) */
+    _toApi(symbol) {
+        const s = symbol.toUpperCase().replace(/-PERP$/, "");
+        if (s.endsWith("USDT") || s.endsWith("BUSD"))
+            return s;
+        return `${s}USDT`;
+    }
+    /** Aster API symbol → CLI symbol (ETHUSDT → ETH) */
+    _fromApi(symbol) {
+        return symbol.replace(/USDT$/, "").replace(/BUSD$/, "");
+    }
+    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: this._fromApi(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: this._toApi(symbol), limit: "50" });
+        return {
+            bids: res?.bids ?? [],
+            asks: res?.asks ?? [],
+        };
+    }
+    async getRecentTrades(symbol, limit = 20) {
+        const trades = await this._publicGet("/fapi/v1/trades", {
+            symbol: this._toApi(symbol),
+            limit: String(limit),
+        });
+        return (trades ?? []).map((t) => ({
+            time: Number(t.time ?? 0),
+            symbol: this._fromApi(String(t.symbol ?? symbol)),
+            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: this._toApi(symbol),
+            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: this._toApi(symbol),
+            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: this._fromApi(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: this._fromApi(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 apiSymbols = new Set(positions.map(p => this._toApi(p.symbol)));
+        if (apiSymbols.size === 0) {
+            // Fallback: query the most common perp symbols when no open positions exist
+            for (const s of ["BTCUSDT", "ETHUSDT", "SOLUSDT", "BNBUSDT", "XRPUSDT"]) {
+                apiSymbols.add(s);
+            }
+        }
+        const allOrders = [];
+        for (const sym of apiSymbols) {
+            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: this._fromApi(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 apiSymbols = new Set(positions.map(p => this._toApi(p.symbol)));
+        if (apiSymbols.size === 0)
+            apiSymbols.add("BTCUSDT");
+        const allTrades = [];
+        for (const sym of apiSymbols) {
+            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: this._fromApi(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: this._fromApi(String(f.symbol ?? "")),
+            payment: String(f.income ?? "0"),
+        }));
+    }
+    // ── Trading ──
+    async marketOrder(symbol, side, size) {
+        return this._signedPost("/fapi/v1/order", {
+            symbol: this._toApi(symbol),
+            side: side.toUpperCase(),
+            type: "MARKET",
+            quantity: size,
+        });
+    }
+    async limitOrder(symbol, side, price, size, opts) {
+        const params = {
+            symbol: this._toApi(symbol),
+            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: this._toApi(symbol),
+            orderId,
+        });
+    }
+    async cancelAllOrders(symbol) {
+        if (!symbol) {
+            // Cancel all for all symbols with open orders
+            const orders = await this.getOpenOrders();
+            const apiSymbols = new Set(orders.map(o => this._toApi(o.symbol)));
+            const results = [];
+            for (const sym of apiSymbols) {
+                results.push(await this._signedDelete("/fapi/v1/allOpenOrders", { symbol: sym }));
+            }
+            return results;
+        }
+        return this._signedDelete("/fapi/v1/allOpenOrders", { symbol: this._toApi(symbol) });
+    }
+    // ── Risk ──
+    async setLeverage(symbol, leverage, marginMode) {
+        // Set margin type first if specified
+        if (marginMode) {
+            try {
+                await this._signedPost("/fapi/v1/marginType", {
+                    symbol: this._toApi(symbol),
+                    marginType: marginMode === "cross" ? "CROSSED" : "ISOLATED",
+                });
+            }
+            catch {
+                // May fail if already set — non-critical
+            }
+        }
+        return this._signedPost("/fapi/v1/leverage", {
+            symbol: this._toApi(symbol),
+            leverage: String(leverage),
+        });
+    }
+    async stopOrder(symbol, side, size, triggerPrice, opts) {
+        const params = {
+            symbol: this._toApi(symbol),
+            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";
+}