perp-cli 0.4.11 → 0.5.0

package/dist/commands/market.js

@@ -8,47 +8,55 @@ export function registerMarketCommands(program, getAdapter, isJson, getAdapterFo
     market
         .command("list")
         .description("List all available markets")
-        .action(async () => {
+        .option("--hip3", "Include HIP-3 dex markets (Hyperliquid)")
+        .action(async (opts) => {
         const explicitExchange = program.getOptionValueSource?.("exchange") === "cli";
+        const HEADERS = ["Symbol", "Mark", "Index", "Funding", "24h Vol", "OI", "Max Lev"];
+        const marketRow = (m) => [
+            chalk.white.bold(m.symbol),
+            `$${formatUsd(m.markPrice)}`,
+            `$${formatUsd(m.indexPrice)}`,
+            formatPercent(m.fundingRate),
+            `$${formatUsd(m.volume24h)}`,
+            `$${formatUsd(m.openInterest)}`,
+            String(m.maxLeverage) + "x",
+        ];
         // Multi-exchange mode
         if (!explicitExchange && getAdapterForExchange) {
-            const allRows = [];
+            const grouped = {};
             const errors = {};
             await Promise.all(EXCHANGES.map(async (ex) => {
                 try {
                     const adapter = await getAdapterForExchange(ex);
-                    const markets = await adapter.getMarkets();
-                    for (const m of markets) {
-                        allRows.push([
-                            chalk.white.bold(m.symbol),
-                            chalk.gray(ex.slice(0, 3).toUpperCase()),
-                            `$${formatUsd(m.markPrice)}`,
-                            `$${formatUsd(m.indexPrice)}`,
-                            formatPercent(m.fundingRate),
-                            `$${formatUsd(m.volume24h)}`,
-                            `$${formatUsd(m.openInterest)}`,
-                            String(m.maxLeverage) + "x",
-                        ]);
+                    grouped[ex] = await adapter.getMarkets();
+                    // --hip3: fetch HIP-3 dex markets
+                    if (opts.hip3 && ex === "hyperliquid" && adapter instanceof HyperliquidAdapter) {
+                        const dexes = await adapter.listDeployedDexes();
+                        await Promise.allSettled(dexes.map(async (d) => {
+                            const dexAdapter = Object.create(adapter);
+                            dexAdapter.setDex(d.name);
+                            const markets = await dexAdapter.getMarkets();
+                            if (markets.length > 0)
+                                grouped[`hip3:${d.name}`] = markets;
+                        }));
                     }
                 }
                 catch (err) {
                     errors[ex] = err instanceof Error ? err.message : String(err);
                 }
             }));
-            // Sort by symbol name
-            allRows.sort((a, b) => a[0].localeCompare(b[0]));
             if (isJson()) {
-                const grouped = {};
-                await Promise.all(EXCHANGES.map(async (ex) => {
-                    try {
-                        const adapter = await getAdapterForExchange(ex);
-                        grouped[ex] = await adapter.getMarkets();
-                    }
-                    catch { /* skip */ }
-                }));
                 return printJson(jsonOk({ exchanges: grouped, errors: Object.keys(errors).length > 0 ? errors : undefined }));
             }
-            console.log(makeTable(["Symbol", "Exch", "Mark", "Index", "Funding", "24h Vol", "OI", "Max Lev"], allRows));
+            // Per-exchange tables
+            for (const [ex, markets] of Object.entries(grouped)) {
+                if (markets.length === 0)
+                    continue;
+                const isHip3 = ex.startsWith("hip3:");
+                const label = isHip3 ? chalk.magenta.bold(`  HIP-3: ${ex.slice(5)}`) : chalk.cyan.bold(`  ${ex.toUpperCase()}`);
+                console.log(`\n${label} ${chalk.gray(`(${markets.length} markets)`)}`);
+                console.log(makeTable(HEADERS, markets.map(marketRow)));
+            }
             for (const [ex, msg] of Object.entries(errors)) {
                 console.log(chalk.gray(`  ${ex}: ${msg}`));
             }
@@ -57,58 +65,63 @@ export function registerMarketCommands(program, getAdapter, isJson, getAdapterFo
         // Single exchange mode
         const adapter = await getAdapter();
         const markets = await adapter.getMarkets();
-        if (isJson())
+        // --hip3: fetch HIP-3 dex markets
+        const hip3 = {};
+        if (opts.hip3 && adapter instanceof HyperliquidAdapter) {
+            const dexes = await adapter.listDeployedDexes();
+            await Promise.allSettled(dexes.map(async (d) => {
+                const dexAdapter = Object.create(adapter);
+                dexAdapter.setDex(d.name);
+                const m = await dexAdapter.getMarkets();
+                if (m.length > 0)
+                    hip3[d.name] = m;
+            }));
+        }
+        if (isJson()) {
+            if (Object.keys(hip3).length > 0) {
+                return printJson(jsonOk({ main: markets, hip3 }));
+            }
             return printJson(jsonOk(markets));
-        const rows = markets.map((m) => [
-            chalk.white.bold(m.symbol),
-            `$${formatUsd(m.markPrice)}`,
-            `$${formatUsd(m.indexPrice)}`,
-            formatPercent(m.fundingRate),
-            `$${formatUsd(m.volume24h)}`,
-            `$${formatUsd(m.openInterest)}`,
-            String(m.maxLeverage) + "x",
-        ]);
-        console.log(makeTable(["Symbol", "Mark", "Index", "Funding", "24h Vol", "OI", "Max Lev"], rows));
+        }
+        console.log(makeTable(HEADERS, markets.map(marketRow)));
+        for (const [dex, m] of Object.entries(hip3)) {
+            console.log(chalk.magenta.bold(`\n  HIP-3: ${dex}`) + chalk.gray(` (${m.length} markets)`));
+            console.log(makeTable(HEADERS, m.map(marketRow)));
+        }
     });
     market
         .command("prices")
         .description("Get current prices for all markets")
         .action(async () => {
         const explicitExchange = program.getOptionValueSource?.("exchange") === "cli";
+        const PRICE_HEADERS = ["Symbol", "Mark", "Index", "Funding"];
+        const priceRow = (m) => [
+            chalk.white.bold(m.symbol),
+            `$${formatUsd(m.markPrice)}`,
+            `$${formatUsd(m.indexPrice)}`,
+            formatPercent(m.fundingRate),
+        ];
         if (!explicitExchange && getAdapterForExchange) {
-            const allRows = [];
+            const grouped = {};
             const errors = {};
             await Promise.all(EXCHANGES.map(async (ex) => {
                 try {
                     const adapter = await getAdapterForExchange(ex);
-                    const markets = await adapter.getMarkets();
-                    for (const m of markets) {
-                        allRows.push([
-                            chalk.white.bold(m.symbol),
-                            chalk.gray(ex.slice(0, 3).toUpperCase()),
-                            `$${formatUsd(m.markPrice)}`,
-                            `$${formatUsd(m.indexPrice)}`,
-                            formatPercent(m.fundingRate),
-                        ]);
-                    }
+                    grouped[ex] = await adapter.getMarkets();
                 }
                 catch (err) {
                     errors[ex] = err instanceof Error ? err.message : String(err);
                 }
             }));
-            allRows.sort((a, b) => a[0].localeCompare(b[0]));
             if (isJson()) {
-                const grouped = {};
-                await Promise.all(EXCHANGES.map(async (ex) => {
-                    try {
-                        const adapter = await getAdapterForExchange(ex);
-                        grouped[ex] = await adapter.getMarkets();
-                    }
-                    catch { /* skip */ }
-                }));
                 return printJson(jsonOk({ exchanges: grouped, errors: Object.keys(errors).length > 0 ? errors : undefined }));
             }
-            console.log(makeTable(["Symbol", "Exch", "Mark", "Index", "Funding"], allRows));
+            for (const [ex, markets] of Object.entries(grouped)) {
+                if (markets.length === 0)
+                    continue;
+                console.log(chalk.cyan.bold(`\n  ${ex.toUpperCase()}`) + chalk.gray(` (${markets.length} markets)`));
+                console.log(makeTable(PRICE_HEADERS, markets.map(priceRow)));
+            }
             for (const [ex, msg] of Object.entries(errors))
                 console.log(chalk.gray(`  ${ex}: ${msg}`));
             return;
@@ -128,17 +141,10 @@ export function registerMarketCommands(program, getAdapter, isJson, getAdapterFo
             console.log(makeTable(["Symbol", "Mark", "Mid", "Oracle", "Funding"], rows));
         }
         else {
-            // Generic: use getMarkets as price source
             const markets = await adapter.getMarkets();
             if (isJson())
                 return printJson(jsonOk(markets));
-            const rows = markets.map((m) => [
-                chalk.white.bold(m.symbol),
-                `$${formatUsd(m.markPrice)}`,
-                `$${formatUsd(m.indexPrice)}`,
-                formatPercent(m.fundingRate),
-            ]);
-            console.log(makeTable(["Symbol", "Mark", "Index", "Funding"], rows));
+            console.log(makeTable(PRICE_HEADERS, markets.map(priceRow)));
         }
     });
     market
@@ -148,7 +154,11 @@ export function registerMarketCommands(program, getAdapter, isJson, getAdapterFo
         const adapter = await getAdapter();
         const markets = await adapter.getMarkets();
         const sym = symbol.toUpperCase();
-        const m = markets.find((mk) => mk.symbol === sym || mk.symbol === `${sym}-PERP` || mk.symbol.replace(/-PERP$/, "") === sym);
+        const m = markets.find((mk) => {
+            const s = mk.symbol.toUpperCase();
+            return s === sym || s === `${sym}-PERP` || s.replace(/-PERP$/, "") === sym
+                || s.split(":").pop() === sym; // HIP-3: "km:US500" matches "US500"
+        });
         if (!m) {
             if (isJson())
                 return printJson(jsonError("SYMBOL_NOT_FOUND", `Market ${sym} not found`));
@@ -178,15 +188,40 @@ export function registerMarketCommands(program, getAdapter, isJson, getAdapterFo
         const depth = parseInt(opts.depth);
         const asks = book.asks.slice(0, depth).reverse();
         const bids = book.bids.slice(0, depth);
+        // Compute spread
+        const bestBid = bids[0] ? Number(bids[0][0]) : 0;
+        const bestAsk = asks[asks.length - 1] ? Number(asks[asks.length - 1][0]) : 0;
+        const midPrice = bestBid && bestAsk ? (bestBid + bestAsk) / 2 : bestBid || bestAsk;
+        const spreadAbs = bestBid && bestAsk ? bestAsk - bestBid : 0;
+        const spreadPct = midPrice > 0 ? (spreadAbs / midPrice) * 100 : 0;
+        // Compute cumulative sizes + max for bar scaling
+        let askCum = 0;
+        const askCums = asks.map(([, a]) => { askCum += Number(a); return askCum; });
+        let bidCum = 0;
+        const bidCums = bids.map(([, a]) => { bidCum += Number(a); return bidCum; });
+        const maxCum = Math.max(askCums[askCums.length - 1] || 0, bidCums[bidCums.length - 1] || 0);
+        const BAR_WIDTH = 20;
+        const bar = (cum) => {
+            const len = maxCum > 0 ? Math.round((cum / maxCum) * BAR_WIDTH) : 0;
+            return "█".repeat(len);
+        };
         console.log(chalk.cyan.bold(`\n  Orderbook: ${symbol.toUpperCase()} (${adapter.name})\n`));
-        console.log(chalk.gray("  Price          Size"));
-        console.log(chalk.gray("  ─────────────────────"));
-        asks.forEach(([p, a]) => {
-            console.log(chalk.red(`  ${formatUsd(p).padStart(12)}  ${a}`));
+        console.log(chalk.gray("  Price          Size          Cum$              Depth"));
+        console.log(chalk.gray("  " + "─".repeat(60)));
+        asks.forEach(([p, a], i) => {
+            const cumUsd = askCums[i] * (Number(p));
+            console.log(chalk.red(`  ${formatUsd(p).padStart(12)}  ${String(a).padEnd(12)}  $${formatUsd(cumUsd).padEnd(14)}`) +
+                chalk.red.dim(bar(askCums[i])));
         });
-        console.log(chalk.gray("  ─── spread ───"));
-        bids.forEach(([p, a]) => {
-            console.log(chalk.green(`  ${formatUsd(p).padStart(12)}  ${a}`));
+        // Spread line
+        const spreadStr = spreadAbs > 0
+            ? `$${formatUsd(spreadAbs)} (${spreadPct.toFixed(3)}%)`
+            : "─";
+        console.log(chalk.gray(`  ${"─".repeat(16)} spread: ${spreadStr} ${"─".repeat(10)}`));
+        bids.forEach(([p, a], i) => {
+            const cumUsd = bidCums[i] * (Number(p));
+            console.log(chalk.green(`  ${formatUsd(p).padStart(12)}  ${String(a).padEnd(12)}  $${formatUsd(cumUsd).padEnd(14)}`) +
+                chalk.green.dim(bar(bidCums[i])));
         });
         console.log();
     });

package/dist/exchanges/hyperliquid.d.ts

@@ -69,8 +69,8 @@ export declare class HyperliquidAdapter implements ExchangeAdapter {
         reduceOnly?: boolean;
         tif?: string;
     }): Promise<unknown>;
-    cancelOrder(symbol: string, orderId: string): Promise<import("hyperliquid").CancelOrderResponse>;
-    cancelAllOrders(symbol?: string): Promise<import("hyperliquid").CancelOrderResponse[]>;
+    cancelOrder(symbol: string, orderId: string): Promise<unknown>;
+    cancelAllOrders(symbol?: string): Promise<unknown[]>;
     editOrder(symbol: string, orderId: string, price: string, size: string): Promise<unknown>;
     setLeverage(symbol: string, leverage: number, marginMode?: "cross" | "isolated"): Promise<any>;
     stopOrder(symbol: string, side: "buy" | "sell", size: string, triggerPrice: string, opts?: {

package/dist/exchanges/hyperliquid.js

@@ -72,17 +72,38 @@ export class HyperliquidAdapter {
     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 });
+                // HIP-3 deployed dex: asset indices use global offset scheme
+                // offset = 110000 + dexListIndex * 10000 (per Python SDK convention)
+                const [meta, dexList] = await Promise.all([
+                    this._infoPost({ type: "meta", dex: this._dex }),
+                    this._infoPost({ type: "perpDexs" }),
+                ]);
+                // Find this dex's position in the list (index 0 is native/null)
+                let dexOffset = 0;
+                for (let i = 1; i < dexList.length; i++) {
+                    if (dexList[i]?.name === this._dex) {
+                        dexOffset = 110000 + (i - 1) * 10000;
+                        break;
+                    }
+                }
+                if (dexOffset === 0) {
+                    console.error(`[hyperliquid] Dex "${this._dex}" not found in perpDexs list`);
+                }
                 if (meta?.universe) {
                     meta.universe.forEach((asset, idx) => {
+                        const globalIdx = dexOffset + 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);
+                        this._assetMap.set(fullName, globalIdx);
+                        this._assetMap.set(baseName, globalIdx);
+                        this._assetMapReverse.set(globalIdx, fullName);
+                        // Cache szDecimals for dex assets (critical for order sizing)
+                        if (asset.szDecimals !== undefined) {
+                            this._szDecimalsMap.set(fullName, asset.szDecimals);
+                            this._szDecimalsMap.set(baseName, asset.szDecimals);
+                        }
                     });
                 }
             }
@@ -168,8 +189,8 @@ export class HyperliquidAdapter {
             ctxs = meta[1] ?? [];
             mids = allMids;
         }
-        // Rebuild asset map if empty
-        if (this._assetMap.size === 0) {
+        // Rebuild asset map if empty (fallback — normally populated by init/_loadAssetMap)
+        if (this._assetMap.size === 0 && !this._dex) {
             universe.forEach((asset, i) => {
                 const sym = String(asset.name);
                 this._assetMap.set(sym, i);
@@ -191,8 +212,24 @@ export class HyperliquidAdapter {
         });
     }
     async getOrderbook(symbol) {
-        const book = await this.sdk.info.getL2Book(symbol.toUpperCase());
-        const levels = book?.levels ?? [[], []];
+        let levels;
+        if (this._dex) {
+            // HIP-3 dex: SDK's getL2Book() doesn't support dex parameter
+            // Resolve symbol to full dex-prefixed name (e.g. "US500" → "km:US500")
+            const resolved = this.resolveSymbol(symbol.toUpperCase());
+            // Ensure dex prefix is present (API requires it)
+            const coin = resolved.includes(":") ? resolved : `${this._dex}:${resolved}`;
+            const book = await this._infoPost({
+                type: "l2Book",
+                coin,
+                dex: this._dex,
+            });
+            levels = book?.levels ?? [[], []];
+        }
+        else {
+            const book = await this.sdk.info.getL2Book(symbol.toUpperCase());
+            levels = book?.levels ?? [[], []];
+        }
         return {
             bids: (levels[0] ?? []).map((l) => [
                 String(l.px ?? "0"),
@@ -291,6 +328,22 @@ export class HyperliquidAdapter {
     }
     async getOpenOrders() {
         this.ensureAddress();
+        if (this._dex) {
+            // HIP-3 dex: use frontendOpenOrders with dex parameter
+            const orders = await this._infoPost({
+                type: "frontendOpenOrders", user: this._address, dex: this._dex,
+            });
+            return (orders ?? []).map((o) => ({
+                orderId: String(o.oid ?? ""),
+                symbol: String(o.coin ?? ""),
+                side: String(o.side) === "B" ? "buy" : String(o.side) === "A" ? "sell" : String(o.side).toLowerCase(),
+                price: String(o.limitPx ?? "0"),
+                size: String(o.sz ?? "0"),
+                filled: "0",
+                status: "open",
+                type: "limit",
+            }));
+        }
         const orders = await this.sdk.info.getUserOpenOrders(this._address);
         return (orders ?? []).map((o) => ({
             orderId: String(o.oid ?? ""),
@@ -337,16 +390,20 @@ export class HyperliquidAdapter {
      */
     async _dexMarketOrder(symbol, side, size) {
         const assetIndex = await this.getAssetIndex(symbol.toUpperCase());
-        // Get current mark price + szDecimals from dex meta
+        const szDec = this.getSzDecimals(symbol);
+        // Get current mark price from dex meta (lookup by coin name, not array index)
+        const resolved = this.resolveSymbol(symbol.toUpperCase());
+        const coin = resolved.includes(":") ? resolved : `${this._dex}:${resolved}`;
         const meta = await this._infoPost({
             type: "metaAndAssetCtxs",
             dex: this._dex,
         });
-        const ctx = (meta[1] ?? [])[assetIndex];
+        // Find local index by matching coin name in universe
+        const localIdx = meta[0]?.universe?.findIndex(a => a.name === coin) ?? -1;
+        const ctx = localIdx >= 0 ? (meta[1] ?? [])[localIdx] : undefined;
         const midPrice = Number(ctx?.markPx ?? 0);
         if (midPrice <= 0)
             throw new Error(`Cannot get price for ${symbol} on dex ${this._dex}`);
-        const szDec = meta[0]?.universe?.[assetIndex]?.szDecimals ?? 2;
         // HL official rounding: 5 significant figures, max 6 decimals for perps
         const MAX_DECIMALS_PERP = 6;
         const slippage = 0.05;
@@ -419,7 +476,14 @@ export class HyperliquidAdapter {
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify(payload),
         });
-        const result = await res.json();
+        const text = await res.text();
+        let result;
+        try {
+            result = JSON.parse(text);
+        }
+        catch {
+            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));
         }
@@ -450,10 +514,7 @@ export class HyperliquidAdapter {
             orders: [orderWire],
             grouping: "na",
         };
-        // Add dex field for HIP-3 deployed perps
-        if (this._dex) {
-            action.dex = this._dex;
-        }
+        // No "dex" field needed — the global asset index (110000+) encodes the dex
         return this._signAndSendAction(action);
     }
     async limitOrder(symbol, side, price, size, opts) {
@@ -480,6 +541,16 @@ export class HyperliquidAdapter {
     }
     async cancelOrder(symbol, orderId) {
         this.ensureSigner();
+        if (this._dex) {
+            // HIP-3 dex: use raw cancel action with global asset index
+            const assetIndex = await this.getAssetIndex(symbol.toUpperCase());
+            const result = await this._signAndSendAction({
+                type: "cancel",
+                cancels: [{ a: assetIndex, o: parseInt(orderId) }],
+            });
+            await this._invalidateAccountCache();
+            return result;
+        }
         // HL SDK expects coin in "ETH-PERP" format (internal symbol convention)
         const resolved = this.resolveSymbol(symbol);
         const result = await this.sdk.exchange.cancelOrder({
@@ -494,16 +565,25 @@ export class HyperliquidAdapter {
         const orders = await this.getOpenOrders();
         const toCancel = symbol
             ? orders.filter((o) => {
-                const norm = (s) => s.toUpperCase().replace(/-PERP$/, "");
+                const norm = (s) => s.toUpperCase().replace(/-PERP$/, "").replace(/^[^:]+:/, "");
                 return norm(o.symbol) === norm(symbol);
             })
             : orders;
         const results = [];
         for (const o of toCancel) {
-            results.push(await this.sdk.exchange.cancelOrder({
-                coin: o.symbol,
-                o: parseInt(o.orderId),
-            }));
+            if (this._dex) {
+                const assetIndex = await this.getAssetIndex(o.symbol);
+                results.push(await this._signAndSendAction({
+                    type: "cancel",
+                    cancels: [{ a: assetIndex, o: parseInt(o.orderId) }],
+                }));
+            }
+            else {
+                results.push(await this.sdk.exchange.cancelOrder({
+                    coin: o.symbol,
+                    o: parseInt(o.orderId),
+                }));
+            }
         }
         return results;
     }
@@ -608,22 +688,37 @@ export class HyperliquidAdapter {
      */
     async triggerOrder(symbol, side, size, triggerPrice, tpsl, opts) {
         this.ensureSigner();
-        const orderParams = {
-            coin: symbol.toUpperCase(),
-            is_buy: side === "buy",
-            sz: parseFloat(size),
-            limit_px: parseFloat(triggerPrice),
-            order_type: {
+        const assetIndex = await this.getAssetIndex(symbol.toUpperCase());
+        const szDec = this.getSzDecimals(symbol);
+        const roundedSize = Number(size).toFixed(szDec);
+        const roundedTrigger = this._hlRoundPrice(Number(triggerPrice), szDec);
+        // 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: assetIndex,
+            b: side === "buy",
+            p: trimZeros(roundedTrigger),
+            s: trimZeros(roundedSize),
+            r: opts?.reduceOnly ?? true,
+            t: {
                 trigger: {
-                    triggerPx: triggerPrice,
+                    triggerPx: trimZeros(roundedTrigger),
                     isMarket: opts?.isMarket ?? true,
                     tpsl,
                 },
             },
-            reduce_only: opts?.reduceOnly ?? true,
+        };
+        const action = {
+            type: "order",
+            orders: [orderWire],
             grouping: opts?.grouping ?? "positionTpsl",
         };
-        return this.sdk.exchange.placeOrder(orderParams);
+        return this._signAndSendAction(action);
     }
     /**
      * Place a TWAP order.

package/dist/exchanges/lighter-spot.js

@@ -140,30 +140,15 @@ export class LighterSpotAdapter {
                 ?? res.accounts?.[0];
             if (!acct)
                 return [];
-            // Perp USDC balance (collateral / available for perp trading)
-            balances.push({
-                token: "USDC",
-                total: String(acct.collateral ?? 0),
-                available: String(acct.available_balance ?? 0),
-                held: String(Math.max(0, Number(acct.collateral ?? 0) - Number(acct.available_balance ?? 0))),
-            });
-            // Spot token balances from the assets array
+            // Spot token balances from the assets array only.
+            // Perp USDC (collateral) is already reported by getBalance() — don't duplicate here.
             if (acct.assets && acct.assets.length > 0) {
                 for (const asset of acct.assets) {
                     const bal = parseFloat(asset.balance || "0");
                     const locked = parseFloat(asset.locked_balance || "0");
-                    if (asset.symbol === "USDC") {
-                        // Add spot USDC as separate entry so caller can distinguish
-                        balances.push({
-                            token: "USDC_SPOT",
-                            total: asset.balance,
-                            available: String(bal - locked),
-                            held: asset.locked_balance,
-                        });
-                    }
-                    else if (bal > 0) {
+                    if (bal > 0) {
                         balances.push({
-                            token: asset.symbol,
+                            token: asset.symbol === "USDC" ? "USDC_SPOT" : asset.symbol,
                             total: asset.balance,
                             available: String(bal - locked),
                             held: asset.locked_balance,

package/dist/exchanges/lighter.js

@@ -240,10 +240,19 @@ export class LighterAdapter {
         if (!dec) {
             throw new Error(`No market decimals loaded for ${symbol}. Market data may not be initialized.`);
         }
-        return {
-            baseAmount: Math.round(size * Math.pow(10, dec.size)),
-            priceTicks: Math.round(price * Math.pow(10, dec.price)),
-        };
+        const baseAmount = Math.round(size * Math.pow(10, dec.size));
+        const priceTicks = Math.round(price * Math.pow(10, dec.price));
+        // Validate: size too small for this market's precision → baseAmount rounds to 0
+        if (size > 0 && baseAmount <= 0) {
+            const minSize = 1 / Math.pow(10, dec.size);
+            throw new Error(`Order size ${size} too small for ${symbol} (sizeDecimals=${dec.size}, min=${minSize}). ` +
+                `Increase size or use a different market.`);
+        }
+        if (price > 0 && priceTicks <= 0) {
+            const minPrice = 1 / Math.pow(10, dec.price);
+            throw new Error(`Order price ${price} too small for ${symbol} (priceDecimals=${dec.price}, min=${minPrice}).`);
+        }
+        return { baseAmount, priceTicks };
     }
     async getMarkets() {
         const markets = [];
@@ -338,9 +347,14 @@ export class LighterAdapter {
                     : "0"),
                 liquidationPrice: String(p.liquidation_price || "N/A"),
                 unrealizedPnl: String(p.unrealized_pnl || "0"),
-                leverage: Number(p.initial_margin_fraction || 0) > 0
-                    ? Math.round(10000 / Number(p.initial_margin_fraction))
-                    : 1,
+                // Compute actual leverage = notional / account equity (not max leverage from IMF)
+                leverage: (() => {
+                    const notional = Math.abs(Number(p.position_value || 0));
+                    const equity = Number(acct.total_asset_value || 0);
+                    if (equity > 0 && notional > 0)
+                        return Math.round(notional / equity * 10) / 10;
+                    return 1;
+                })(),
             };
         });
     }

package/dist/liquidity.js

@@ -41,13 +41,15 @@ export function computeExecutableSize(levels, requestedSizeUsd, maxSlippagePct =
     const avgFillPrice = filledSize > 0 ? filledNotional / filledSize : bestPrice;
     const slippagePct = bestPrice > 0 ? ((avgFillPrice - bestPrice) / bestPrice) * 100 : 0;
     const canFillFull = filledNotional >= requestedSizeUsd * 0.95; // 95% fill = close enough
+    // 10% safety buffer — avoid filling at the very edge of liquidity
+    const bufferedSize = filledSize * 0.9;
     return {
         maxSize: filledSize,
         avgFillPrice,
         slippagePct: Math.abs(slippagePct),
         depthUsd: totalDepthUsd,
         canFillFull,
-        recommendedSize: filledSize,
+        recommendedSize: bufferedSize,
     };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perp-cli",
-  "version": "0.4.11",
+  "version": "0.5.0",
   "description": "Multi-DEX Perpetual Futures CLI - Pacifica, Hyperliquid, Lighter",
   "bin": {
     "perp": "dist/index.js",