perp-cli 0.3.3

package/dist/exchanges/hyperliquid.js

@@ -0,0 +1,931 @@
+import { Hyperliquid } from "hyperliquid";
+export class HyperliquidAdapter {
+    name = "hyperliquid";
+    sdk;
+    _address;
+    _privateKey;
+    _testnet;
+    _assetMap = new Map();
+    _assetMapReverse = new Map();
+    /** HIP-3 deployed perp dex name. Empty string = native (validator) perps. */
+    _dex = "";
+    // In-memory cache removed — using file-based cache (src/cache.ts) for cross-process dedup
+    constructor(privateKey, testnet = false) {
+        this.sdk = new Hyperliquid({
+            privateKey,
+            testnet,
+            walletAddress: undefined,
+        });
+        this._address = "";
+        this._privateKey = privateKey;
+        this._testnet = testnet;
+    }
+    /** Set the HIP-3 deployed perp dex to query/trade on. */
+    setDex(dex) {
+        this._dex = dex;
+        // Rebuild asset map for the new dex
+        this._assetMap.clear();
+        this._assetMapReverse.clear();
+    }
+    get dex() {
+        return this._dex;
+    }
+    get client() {
+        return this.sdk;
+    }
+    get address() {
+        return this._address;
+    }
+    get isTestnet() {
+        return this._testnet;
+    }
+    async init() {
+        // Suppress "WebSocket connected" noise from hyperliquid SDK
+        const origLog = console.log;
+        console.log = () => { };
+        try {
+            await this.sdk.connect();
+        }
+        finally {
+            console.log = origLog;
+        }
+        // Derive address from SDK or from private key directly
+        const wallet = this.sdk.wallet;
+        if (wallet && typeof wallet === "object" && "address" in wallet) {
+            this._address = String(wallet.address);
+        }
+        if (!this._address) {
+            const { ethers } = await import("ethers");
+            this._address = new ethers.Wallet(this._privateKey).address;
+        }
+        // Build asset index map
+        await this._loadAssetMap();
+    }
+    /** Load asset index map — supports native and HIP-3 dex. */
+    async _loadAssetMap() {
+        try {
+            if (this._dex) {
+                // HIP-3 deployed dex: use raw info POST with dex param
+                const meta = await this._infoPost({ type: "meta", dex: this._dex });
+                if (meta?.universe) {
+                    meta.universe.forEach((asset, idx) => {
+                        // Store both with and without dex prefix for flexible lookup
+                        // API returns "km:GOOGL" but callers may use "GOOGL" or "KM:GOOGL"
+                        const fullName = asset.name; // e.g., "km:GOOGL"
+                        const baseName = fullName.includes(":") ? fullName.split(":").pop() : fullName;
+                        this._assetMap.set(fullName, idx);
+                        this._assetMap.set(baseName, idx);
+                        this._assetMapReverse.set(idx, fullName);
+                    });
+                }
+            }
+            else {
+                const meta = await this.sdk.info.perpetuals.getMeta();
+                if (meta && meta.universe) {
+                    meta.universe.forEach((asset, idx) => {
+                        this._assetMap.set(asset.name, idx);
+                        this._assetMapReverse.set(idx, asset.name);
+                    });
+                }
+            }
+        }
+        catch {
+            // non-critical
+        }
+    }
+    getAssetIndex(symbol) {
+        const sym = symbol.toUpperCase();
+        // Try exact match first (handles both "BTC" for native and "km:GOOGL" for dex)
+        let idx = this._assetMap.get(sym);
+        if (idx !== undefined)
+            return idx;
+        // For dex: try lowercase prefix (API returns "km:GOOGL" but input may be "KM:GOOGL")
+        if (sym.includes(":")) {
+            const [prefix, base] = sym.split(":");
+            idx = this._assetMap.get(`${prefix.toLowerCase()}:${base}`);
+            if (idx !== undefined)
+                return idx;
+            // Try base name only (e.g., "GOOGL")
+            idx = this._assetMap.get(base);
+            if (idx !== undefined)
+                return idx;
+        }
+        throw new Error(`Unknown symbol: ${symbol}`);
+    }
+    async getMarkets() {
+        let universe;
+        let ctxs;
+        let mids = {};
+        if (this._dex) {
+            // HIP-3: use raw info POST with dex param
+            const meta = await this._infoPost({ type: "metaAndAssetCtxs", dex: this._dex });
+            universe = meta[0]?.universe ?? [];
+            ctxs = meta[1] ?? [];
+        }
+        else {
+            const [meta, allMids] = await Promise.all([
+                this.sdk.info.perpetuals.getMetaAndAssetCtxs(),
+                this.sdk.info.getAllMids(),
+            ]);
+            universe = meta[0]?.universe ?? [];
+            ctxs = meta[1] ?? [];
+            mids = allMids;
+        }
+        // Rebuild asset map if empty
+        if (this._assetMap.size === 0) {
+            universe.forEach((asset, i) => {
+                const sym = String(asset.name);
+                this._assetMap.set(sym, i);
+                this._assetMapReverse.set(i, sym);
+            });
+        }
+        return universe.map((asset, i) => {
+            const ctx = (ctxs[i] ?? {});
+            const sym = String(asset.name);
+            return {
+                symbol: sym,
+                markPrice: String(ctx.markPx ?? mids[sym] ?? "0"),
+                indexPrice: String(ctx.oraclePx ?? "0"),
+                fundingRate: String(ctx.funding ?? "0"),
+                volume24h: String(ctx.dayNtlVlm ?? "0"),
+                openInterest: String(ctx.openInterest ?? "0"),
+                maxLeverage: Number(asset.maxLeverage ?? 50),
+            };
+        });
+    }
+    async getOrderbook(symbol) {
+        const book = await this.sdk.info.getL2Book(symbol.toUpperCase());
+        const levels = book?.levels ?? [[], []];
+        return {
+            bids: (levels[0] ?? []).map((l) => [
+                String(l.px ?? "0"),
+                String(l.sz ?? "0"),
+            ]),
+            asks: (levels[1] ?? []).map((l) => [
+                String(l.px ?? "0"),
+                String(l.sz ?? "0"),
+            ]),
+        };
+    }
+    /** Always fetches live clearinghouseState, writes result to shared cache for dashboard */
+    async _getClearinghouseState() {
+        const { fetchAndCache, TTL_ACCOUNT } = await import("../cache.js");
+        const key = this._dex ? `acct:hl:chs:${this._address}:${this._dex}` : `acct:hl:chs:${this._address}`;
+        return fetchAndCache(key, TTL_ACCOUNT, async () => {
+            const state = this._dex
+                ? await this._infoPost({ type: "clearinghouseState", user: this._address, dex: this._dex })
+                : await this.sdk.info.perpetuals.getClearinghouseState(this._address);
+            return state;
+        });
+    }
+    async getBalance() {
+        const state = await this._getClearinghouseState();
+        const s = state;
+        const margin = (s?.marginSummary ?? {});
+        const cross = (s?.crossMarginSummary ?? {});
+        const marginUsed = Number(margin.totalMarginUsed ?? cross.totalMarginUsed ?? 0);
+        // Sum unrealized PnL directly from positions (reliable for both main + dex accounts)
+        const positions = (s?.assetPositions ?? []);
+        let unrealizedPnl = 0;
+        for (const entry of positions) {
+            const pos = (entry.position ?? entry);
+            unrealizedPnl += Number(pos.unrealizedPnl ?? 0);
+        }
+        let equity;
+        let available;
+        if (!this._dex) {
+            // Unified account: spot USDC total IS the true equity (includes perp margin as "hold").
+            // perp accountValue is a subset — adding both double-counts.
+            try {
+                const spotState = await this.sdk.info.spot.getSpotClearinghouseState(this._address);
+                const balances = spotState?.balances ?? [];
+                const usdc = balances.find((b) => String(b.coin).startsWith("USDC"));
+                const spotTotal = Number(usdc?.total ?? 0);
+                const spotHold = Number(usdc?.hold ?? 0);
+                equity = spotTotal > 0 ? spotTotal : Number(margin.accountValue ?? cross.accountValue ?? 0);
+                available = spotTotal > 0 ? spotTotal - spotHold : Number(s?.withdrawable ?? 0);
+            }
+            catch {
+                // Spot API failed — fall back to perp-only values
+                equity = Number(margin.accountValue ?? cross.accountValue ?? 0);
+                available = Number(s?.withdrawable ?? 0);
+            }
+        }
+        else {
+            // Dex account: perp clearinghouse is the only source
+            equity = Number(margin.accountValue ?? cross.accountValue ?? 0);
+            available = Number(s?.withdrawable ?? 0);
+        }
+        return {
+            equity: String(equity),
+            available: String(available),
+            marginUsed: String(marginUsed),
+            unrealizedPnl: String(unrealizedPnl),
+        };
+    }
+    async getPositions() {
+        const state = await this._getClearinghouseState();
+        const positions = (state?.assetPositions ?? []);
+        return positions
+            .filter((p) => {
+            const pos = (p.position ?? p);
+            return Number(pos.szi ?? 0) !== 0;
+        })
+            .map((p) => {
+            const pos = (p.position ?? p);
+            const szi = Number(pos.szi ?? 0);
+            return {
+                symbol: String(pos.coin ?? ""),
+                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)).toFixed(2) : "0"),
+                liquidationPrice: String(pos.liquidationPx ?? "N/A"),
+                unrealizedPnl: String(pos.unrealizedPnl ?? "0"),
+                leverage: Number(pos.leverage?.value ?? 1),
+            };
+        });
+    }
+    async getOpenOrders() {
+        const orders = await this.sdk.info.getUserOpenOrders(this._address);
+        return (orders ?? []).map((o) => ({
+            orderId: String(o.oid ?? ""),
+            symbol: String(o.coin ?? ""),
+            side: o.side === "B" ? "buy" : "sell",
+            price: String(o.limitPx ?? "0"),
+            size: String(o.sz ?? "0"),
+            filled: "0",
+            status: "open",
+            type: "limit",
+        }));
+    }
+    async _invalidateAccountCache() {
+        try {
+            const { invalidateCache } = await import("../cache.js");
+            invalidateCache("acct");
+        }
+        catch { /* ignore */ }
+    }
+    async marketOrder(symbol, side, size) {
+        if (this._dex) {
+            const r = await this._dexMarketOrder(symbol, side, size);
+            await this._invalidateAccountCache();
+            return r;
+        }
+        // Suppress SDK console.log noise (slippage price, decimals, order details)
+        const origLog = console.log;
+        console.log = () => { };
+        try {
+            const result = await this.sdk.custom.marketOpen(symbol.toUpperCase(), side === "buy", parseFloat(size));
+            await this._invalidateAccountCache();
+            return result;
+        }
+        finally {
+            console.log = origLog;
+        }
+    }
+    /**
+     * Place a market order on a HIP-3 deployed dex.
+     * Bypasses SDK's symbolConversion (which only knows native perps)
+     * and constructs + signs the order action directly.
+     */
+    async _dexMarketOrder(symbol, side, size) {
+        const assetIndex = this.getAssetIndex(symbol.toUpperCase());
+        // Get current mark price from dex meta
+        const meta = await this._infoPost({
+            type: "metaAndAssetCtxs",
+            dex: this._dex,
+        });
+        const ctx = (meta[1] ?? [])[assetIndex];
+        const midPrice = Number(ctx?.markPx ?? 0);
+        if (midPrice <= 0)
+            throw new Error(`Cannot get price for ${symbol} on dex ${this._dex}`);
+        // Apply 5% slippage (same as SDK default)
+        const slippage = 0.05;
+        const isBuy = side === "buy";
+        const slippagePrice = isBuy ? midPrice * (1 + slippage) : midPrice * (1 - slippage);
+        const decimals = midPrice.toString().split(".")[1]?.length || 0;
+        const limitPrice = slippagePrice.toFixed(Math.max(0, decimals - 1));
+        return this._rawPlaceOrder({
+            assetIndex,
+            isBuy,
+            price: limitPrice,
+            size,
+            orderType: { limit: { tif: "Ioc" } },
+            reduceOnly: false,
+        });
+    }
+    /**
+     * Place an order via raw exchange API with EIP-712 signing.
+     * This bypasses the SDK's symbolConversion and supports dex-specific orders.
+     */
+    async _rawPlaceOrder(opts) {
+        const { encode } = await import("@msgpack/msgpack");
+        const { ethers, keccak256 } = await import("ethers");
+        const wallet = new ethers.Wallet(this._privateKey);
+        const isMainnet = !this._testnet;
+        const baseUrl = isMainnet
+            ? "https://api.hyperliquid.xyz"
+            : "https://api.hyperliquid-testnet.xyz";
+        // Remove trailing zeros (HL API requirement)
+        const trimZeros = (s) => {
+            if (!s.includes("."))
+                return s;
+            const n = s.replace(/\.?0+$/, "");
+            return n === "-0" ? "0" : n;
+        };
+        const orderWire = {
+            a: opts.assetIndex,
+            b: opts.isBuy,
+            p: trimZeros(opts.price),
+            s: trimZeros(opts.size),
+            r: opts.reduceOnly,
+            t: opts.orderType,
+        };
+        const action = {
+            type: "order",
+            orders: [orderWire],
+            grouping: "na",
+        };
+        // Add dex field for HIP-3 deployed perps
+        if (this._dex) {
+            action.dex = this._dex;
+        }
+        // Sign L1 action (replicates SDK's signL1Action)
+        const nonce = Date.now();
+        const msgPackBytes = encode(action);
+        const data = new Uint8Array(msgPackBytes.length + 9); // +8 nonce +1 vault flag
+        data.set(msgPackBytes);
+        const view = new DataView(data.buffer);
+        view.setBigUint64(msgPackBytes.length, BigInt(nonce), false);
+        view.setUint8(msgPackBytes.length + 8, 0); // no vault
+        const hash = keccak256(data);
+        const phantomDomain = {
+            name: "Exchange",
+            version: "1",
+            chainId: 1337,
+            verifyingContract: "0x0000000000000000000000000000000000000000",
+        };
+        const agentTypes = {
+            Agent: [
+                { name: "source", type: "string" },
+                { name: "connectionId", type: "bytes32" },
+            ],
+        };
+        const phantomAgent = {
+            source: isMainnet ? "a" : "b",
+            connectionId: hash,
+        };
+        const sig = await wallet.signTypedData(phantomDomain, agentTypes, phantomAgent);
+        const parsed = ethers.Signature.from(sig);
+        const payload = {
+            action,
+            nonce,
+            signature: { r: parsed.r, s: parsed.s, v: parsed.v },
+            vaultAddress: null,
+        };
+        const res = await fetch(`${baseUrl}/exchange`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+        });
+        const result = await res.json();
+        if (result?.status === "err") {
+            throw new Error(result.response ?? JSON.stringify(result));
+        }
+        return result;
+    }
+    async limitOrder(symbol, side, price, size, opts) {
+        const tif = (opts?.tif ?? "Gtc");
+        const reduceOnly = opts?.reduceOnly ?? false;
+        let result;
+        if (this._dex) {
+            result = await this._rawPlaceOrder({
+                assetIndex: this.getAssetIndex(symbol.toUpperCase()),
+                isBuy: side === "buy",
+                price,
+                size,
+                orderType: { limit: { tif } },
+                reduceOnly,
+            });
+        }
+        else {
+            result = await this.sdk.exchange.placeOrder({
+                coin: symbol.toUpperCase(),
+                is_buy: side === "buy",
+                sz: parseFloat(size),
+                limit_px: parseFloat(price),
+                order_type: { limit: { tif } },
+                reduce_only: reduceOnly,
+            });
+        }
+        await this._invalidateAccountCache();
+        return result;
+    }
+    async cancelOrder(symbol, orderId) {
+        const result = await this.sdk.exchange.cancelOrder({
+            coin: symbol.toUpperCase(),
+            o: parseInt(orderId),
+        });
+        await this._invalidateAccountCache();
+        return result;
+    }
+    async cancelAllOrders(symbol) {
+        const orders = await this.getOpenOrders();
+        const toCancel = symbol
+            ? orders.filter((o) => o.symbol.toUpperCase() === symbol.toUpperCase())
+            : orders;
+        const results = [];
+        for (const o of toCancel) {
+            results.push(await this.sdk.exchange.cancelOrder({
+                coin: o.symbol,
+                o: parseInt(o.orderId),
+            }));
+        }
+        return results;
+    }
+    // ── Interface methods ──
+    async editOrder(symbol, orderId, price, size) {
+        return this.modifyOrder(symbol, parseInt(orderId), "buy", price, size);
+    }
+    async setLeverage(symbol, leverage, marginMode = "cross") {
+        return this.updateLeverage(symbol, leverage, marginMode === "cross");
+    }
+    async stopOrder(symbol, side, size, triggerPrice, opts) {
+        return this.triggerOrder(symbol, side, size, triggerPrice, "sl", {
+            isMarket: !opts?.limitPrice,
+            reduceOnly: opts?.reduceOnly ?? true,
+        });
+    }
+    async getRecentTrades(symbol, limit = 20) {
+        const trades = await this._infoPost({ type: "recentTrades", coin: symbol.toUpperCase() });
+        return (trades ?? [])
+            .slice(0, limit)
+            .map((t) => ({
+            time: Number(t.time ?? 0),
+            symbol: String(t.coin ?? symbol.toUpperCase()),
+            side: String(t.side) === "B" ? "buy" : "sell",
+            price: String(t.px ?? "0"),
+            size: String(t.sz ?? ""),
+            fee: "0",
+        }));
+    }
+    async getKlines(symbol, interval, startTime, endTime) {
+        const candles = await this.client.info.getCandleSnapshot(symbol.toUpperCase(), interval, startTime, endTime);
+        return (candles ?? []).map((c) => ({
+            time: Number(c.t ?? 0),
+            open: String(c.o ?? "0"),
+            high: String(c.h ?? "0"),
+            low: String(c.l ?? "0"),
+            close: String(c.c ?? "0"),
+            volume: String(c.v ?? ""),
+            trades: Number(c.n ?? 0),
+        }));
+    }
+    async getOrderHistory(limit = 30) {
+        const fills = await this.client.info.getUserFills(this._address);
+        return (fills ?? []).slice(0, limit).map((f) => ({
+            orderId: String(f.oid ?? ""),
+            symbol: String(f.coin ?? ""),
+            side: String(f.side) === "B" ? "buy" : "sell",
+            price: String(f.px ?? "0"),
+            size: String(f.sz ?? ""),
+            filled: String(f.sz ?? ""),
+            status: "filled",
+            type: String(f.dir ?? ""),
+        }));
+    }
+    async getTradeHistory(limit = 30) {
+        const fills = await this.client.info.getUserFills(this._address);
+        return (fills ?? []).slice(0, limit).map((f) => ({
+            time: Number(f.time ?? 0),
+            symbol: String(f.coin ?? ""),
+            side: String(f.side) === "B" ? "buy" : "sell",
+            price: String(f.px ?? "0"),
+            size: String(f.sz ?? ""),
+            fee: String(f.fee ?? "0"),
+        }));
+    }
+    async getFundingPayments(limit = 30) {
+        const now = Date.now();
+        const history = await this.client.info.perpetuals.getUserFunding(this._address, now - 7 * 24 * 60 * 60 * 1000);
+        return (history ?? []).slice(0, limit).map((h) => {
+            const delta = (h.delta ?? {});
+            return {
+                time: Number(h.time ?? 0),
+                symbol: String(delta.coin ?? ""),
+                payment: String(delta.usdc ?? "0"),
+            };
+        });
+    }
+    async getFundingHistory(symbol, limit = 10) {
+        const now = Date.now();
+        const history = await this.client.info.perpetuals.getFundingHistory(symbol.toUpperCase(), now - 24 * 60 * 60 * 1000);
+        return (history ?? []).slice(-limit).map((h) => ({
+            time: Number(h.time ?? 0),
+            rate: String(h.fundingRate ?? "0"),
+            price: "-",
+        }));
+    }
+    // ────────────────────────────────────────────────────────────
+    //  Extended methods (from Python SDK / nktkas TS SDK analysis)
+    // ────────────────────────────────────────────────────────────
+    /**
+     * Place a trigger order (stop loss / take profit).
+     * Python SDK: order() with trigger type {"trigger": {triggerPx, isMarket, tpsl: "tp"|"sl"}}
+     */
+    async triggerOrder(symbol, side, size, triggerPrice, tpsl, opts) {
+        const orderParams = {
+            coin: symbol.toUpperCase(),
+            is_buy: side === "buy",
+            sz: parseFloat(size),
+            limit_px: parseFloat(triggerPrice),
+            order_type: {
+                trigger: {
+                    triggerPx: triggerPrice,
+                    isMarket: opts?.isMarket ?? true,
+                    tpsl,
+                },
+            },
+            reduce_only: opts?.reduceOnly ?? true,
+            grouping: opts?.grouping ?? "positionTpsl",
+        };
+        return this.sdk.exchange.placeOrder(orderParams);
+    }
+    /**
+     * Place a TWAP order.
+     * Python SDK: not available in old SDK, available via raw exchange action.
+     * nktkas TS SDK: twapOrder({twap: {a, b, s, r, m, t}})
+     */
+    async twapOrder(symbol, side, size, durationMinutes, opts) {
+        const assetIndex = this.getAssetIndex(symbol);
+        const action = {
+            type: "twapOrder",
+            twap: {
+                a: assetIndex,
+                b: side === "buy",
+                s: size,
+                r: opts?.reduceOnly ?? false,
+                m: durationMinutes,
+                t: opts?.randomize ?? true,
+            },
+        };
+        return this._sendExchangeAction(action);
+    }
+    /**
+     * Cancel a TWAP order.
+     */
+    async twapCancel(symbol, twapId) {
+        const assetIndex = this.getAssetIndex(symbol);
+        const action = {
+            type: "twapCancel",
+            a: assetIndex,
+            t: twapId,
+        };
+        return this._sendExchangeAction(action);
+    }
+    /**
+     * Update leverage for a symbol.
+     * Python SDK: update_leverage(leverage, name, is_cross)
+     */
+    async updateLeverage(symbol, leverage, isCross = true) {
+        const assetIndex = this.getAssetIndex(symbol);
+        const action = {
+            type: "updateLeverage",
+            asset: assetIndex,
+            isCross,
+            leverage,
+        };
+        return this._sendExchangeAction(action);
+    }
+    /**
+     * Update isolated margin for a position.
+     * amount > 0 to add margin, amount < 0 to remove
+     */
+    async updateIsolatedMargin(symbol, amount) {
+        const assetIndex = this.getAssetIndex(symbol);
+        const action = {
+            type: "updateIsolatedMargin",
+            asset: assetIndex,
+            isBuy: true,
+            ntli: Math.round(amount * 1e6), // USD to 6 decimals
+        };
+        return this._sendExchangeAction(action);
+    }
+    /**
+     * Withdraw from Hyperliquid L1 bridge.
+     * Python SDK: withdraw_from_bridge(amount, destination) → action type "withdraw3"
+     */
+    async withdraw(amount, destination) {
+        try {
+            return await this.sdk.exchange.initiateWithdrawal(destination, parseFloat(amount));
+        }
+        catch {
+            // Fallback: try raw action if SDK method signature changed
+            const action = {
+                type: "withdraw3",
+                hyperliquidChain: this._testnet ? "Testnet" : "Mainnet",
+                signatureChainId: this._testnet ? "0x66eee" : "0xa4b1",
+                destination,
+                amount,
+                time: Date.now(),
+            };
+            return this._sendExchangeAction(action);
+        }
+    }
+    /**
+     * Transfer USD between accounts on Hyperliquid L1.
+     * Python SDK: usd_transfer(amount, destination)
+     */
+    async usdTransfer(amount, destination) {
+        return this.sdk.exchange.usdTransfer(destination, amount);
+    }
+    /**
+     * Create a sub-account.
+     */
+    async createSubAccount(name) {
+        const action = {
+            type: "createSubAccount",
+            name,
+        };
+        return this._sendExchangeAction(action);
+    }
+    /**
+     * Transfer USD between main and sub-account.
+     */
+    async subAccountTransfer(subAccountUser, isDeposit, amount) {
+        const action = {
+            type: "subAccountTransfer",
+            subAccountUser,
+            isDeposit,
+            usd: Math.round(amount * 1e6), // 6 decimals
+        };
+        return this._sendExchangeAction(action);
+    }
+    /**
+     * Modify an existing order.
+     */
+    async modifyOrder(symbol, orderId, newSide, newPrice, newSize, opts) {
+        const assetIndex = this.getAssetIndex(symbol);
+        const action = {
+            type: "batchModify",
+            modifies: [{
+                    oid: orderId,
+                    order: {
+                        a: assetIndex,
+                        b: newSide === "buy",
+                        p: newPrice,
+                        s: newSize,
+                        r: opts?.reduceOnly ?? false,
+                        t: { limit: { tif: "Gtc" } },
+                    },
+                }],
+        };
+        return this._sendExchangeAction(action);
+    }
+    /**
+     * Schedule cancel: cancel all orders at a future time.
+     * Max 10 triggers per day.
+     */
+    async scheduleCancel(timeMs) {
+        const action = {
+            type: "scheduleCancel",
+            time: timeMs,
+        };
+        return this._sendExchangeAction(action);
+    }
+    /**
+     * Set referral code. Silent — does not throw.
+     */
+    async autoSetReferrer(code) {
+        const referralCode = code || process.env.HL_REFERRAL_CODE || "HYPERCASH";
+        try {
+            const exchange = this.sdk.exchange;
+            if (typeof exchange.setReferrer === "function") {
+                await exchange.setReferrer(referralCode);
+                return;
+            }
+        }
+        catch {
+            // Already referred or method not available — both OK
+        }
+    }
+    /**
+     * Get funding history for a symbol.
+     */
+    async getFundingHistoryRaw(symbol, startTime, endTime) {
+        const baseUrl = this._testnet
+            ? "https://api.hyperliquid-testnet.xyz"
+            : "https://api.hyperliquid.xyz";
+        const body = {
+            type: "fundingHistory",
+            coin: symbol.toUpperCase(),
+            startTime,
+        };
+        if (endTime)
+            body.endTime = endTime;
+        const res = await fetch(`${baseUrl}/info`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        return res.json();
+    }
+    /**
+     * Get user trade fills.
+     */
+    async getUserFills(startTime, endTime) {
+        const baseUrl = this._testnet
+            ? "https://api.hyperliquid-testnet.xyz"
+            : "https://api.hyperliquid.xyz";
+        const body = {
+            type: "userFillsByTime",
+            user: this._address,
+        };
+        if (startTime)
+            body.startTime = startTime;
+        if (endTime)
+            body.endTime = endTime;
+        const res = await fetch(`${baseUrl}/info`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        return res.json();
+    }
+    /**
+     * Get user portfolio analytics.
+     */
+    async getPortfolio() {
+        const baseUrl = this._testnet
+            ? "https://api.hyperliquid-testnet.xyz"
+            : "https://api.hyperliquid.xyz";
+        const res = await fetch(`${baseUrl}/info`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ type: "portfolio", user: this._address }),
+        });
+        return res.json();
+    }
+    /**
+     * Query a specific order by OID.
+     */
+    async queryOrder(orderId) {
+        const baseUrl = this._testnet
+            ? "https://api.hyperliquid-testnet.xyz"
+            : "https://api.hyperliquid.xyz";
+        const res = await fetch(`${baseUrl}/info`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ type: "orderStatus", user: this._address, oid: orderId }),
+        });
+        return res.json();
+    }
+    /**
+     * Approve a builder fee.
+     * Action type: approveBuilderFee
+     */
+    async approveBuilderFee(builder, maxFeeRate) {
+        const action = {
+            type: "approveBuilderFee",
+            hyperliquidChain: this._testnet ? "Testnet" : "Mainnet",
+            signatureChainId: this._testnet ? "0x66eee" : "0xa4b1",
+            maxFeeRate,
+            builder,
+        };
+        return this._sendExchangeAction(action);
+    }
+    /**
+     * Vault deposit/withdraw.
+     */
+    async vaultTransfer(vaultAddress, isDeposit, usd) {
+        const action = {
+            type: "vaultTransfer",
+            vaultAddress,
+            isDeposit,
+            usd: Math.round(usd * 1e6),
+        };
+        return this._sendExchangeAction(action);
+    }
+    /**
+     * Delegate/undelegate tokens for staking.
+     */
+    async tokenDelegate(validator, wei, isUndelegate = false) {
+        const action = {
+            type: "tokenDelegate",
+            hyperliquidChain: this._testnet ? "Testnet" : "Mainnet",
+            signatureChainId: this._testnet ? "0x66eee" : "0xa4b1",
+            validator,
+            isUndelegate,
+            wei,
+        };
+        return this._sendExchangeAction(action);
+    }
+    /**
+     * Claim staking rewards.
+     */
+    async claimRewards() {
+        return this._sendExchangeAction({ type: "claimRewards" });
+    }
+    /**
+     * List all available HIP-3 deployed perp dexes.
+     */
+    async listDeployedDexes() {
+        const allMetas = await this._infoPost({ type: "allPerpMetas" });
+        if (!Array.isArray(allMetas))
+            return [];
+        const dexes = [];
+        // allPerpMetas returns an array: [nativePerps, dex1, dex2, ...]
+        // Each entry has { universe, marginTables, collateralToken }
+        // Dex name is derived from the asset prefix (e.g., "xyz:TSLA" → "xyz")
+        // Skip index 0 (native/validator perps — no prefix)
+        for (let i = 1; i < allMetas.length; i++) {
+            const meta = allMetas[i];
+            const universe = (meta.universe ?? []);
+            if (universe.length === 0)
+                continue;
+            // Extract dex name from the first asset's prefix
+            const firstAsset = universe[0].name;
+            const colonIdx = firstAsset.indexOf(":");
+            const dexName = colonIdx > 0 ? firstAsset.slice(0, colonIdx) : `dex-${i}`;
+            dexes.push({
+                name: dexName,
+                deployer: "", // not exposed by API
+                assets: universe.map(a => a.name),
+            });
+        }
+        return dexes;
+    }
+    /**
+     * Get referral info.
+     */
+    async getReferralInfo() {
+        return this._infoPost({ type: "referral", user: this._address });
+    }
+    /**
+     * Get fee info.
+     */
+    async getUserFees() {
+        return this._infoPost({ type: "userFees", user: this._address });
+    }
+    /**
+     * Get sub-accounts.
+     */
+    async getSubAccounts() {
+        return this._infoPost({ type: "subAccounts", user: this._address });
+    }
+    /**
+     * Get historical orders (up to 2000).
+     */
+    async getHistoricalOrders() {
+        return this._infoPost({ type: "historicalOrders", user: this._address });
+    }
+    /**
+     * Get approved builders.
+     */
+    async getApprovedBuilders() {
+        return this._infoPost({ type: "approvedBuilders", user: this._address });
+    }
+    /**
+     * Get vault details.
+     */
+    async getVaultDetails(vaultAddress) {
+        return this._infoPost({ type: "vaultDetails", vaultAddress, user: this._address });
+    }
+    /**
+     * Get delegations (staking).
+     */
+    async getDelegations() {
+        return this._infoPost({ type: "delegations", user: this._address });
+    }
+    /**
+     * POST to /info endpoint.
+     */
+    async _infoPost(body) {
+        const baseUrl = this._testnet
+            ? "https://api.hyperliquid-testnet.xyz"
+            : "https://api.hyperliquid.xyz";
+        const res = await fetch(`${baseUrl}/info`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        return res.json();
+    }
+    /**
+     * Send a raw exchange action through the SDK.
+     * Used for methods not directly exposed by the SDK.
+     */
+    async _sendExchangeAction(action) {
+        const exchange = this.sdk.exchange;
+        // Try using the SDK's internal _postAction if available
+        if (typeof exchange.postAction === "function") {
+            return exchange.postAction(action);
+        }
+        // Fallback: direct POST to /exchange
+        // This requires signing which the SDK normally handles internally
+        // If we get here, the SDK doesn't expose the method we need
+        throw new Error(`Hyperliquid SDK does not expose postAction(). ` +
+            `Action "${action.type}" may need a newer SDK version.`);
+    }
+}