perp-cli 0.5.2 → 0.5.3

package/dist/commands/account.js

@@ -987,6 +987,66 @@ export function registerAccountCommands(program, getAdapter, isJson, getAdapterF
                 else {
                     console.log(chalk.gray("\n  No open positions.\n"));
                 }
+                // ── Spot Holdings ──
+                const spotRows = [];
+                for (const exName of exchanges) {
+                    try {
+                        const adapter = await getAdapterForExchange(exName);
+                        if (exName === "hyperliquid") {
+                            const { HyperliquidSpotAdapter } = await import("../exchanges/hyperliquid-spot.js");
+                            const hlSpot = new HyperliquidSpotAdapter(adapter);
+                            await hlSpot.init();
+                            const bals = await hlSpot.getSpotBalances();
+                            const markets = await hlSpot.getSpotMarkets();
+                            const priceMap = new Map(markets.map(m => [m.baseToken.toUpperCase(), Number(m.markPrice)]));
+                            for (const b of bals) {
+                                const base = b.token.replace(/-SPOT$/i, "").toUpperCase();
+                                if (base === "USDC" || Number(b.total) <= 0)
+                                    continue;
+                                const price = priceMap.get(base) ?? 0;
+                                const value = price * Number(b.total);
+                                if (value < 1)
+                                    continue; // skip dust
+                                spotRows.push([
+                                    chalk.white.bold(base),
+                                    chalk.gray("hyperliquid"),
+                                    b.total,
+                                    `$${formatUsd(price)}`,
+                                    `$${formatUsd(value)}`,
+                                ]);
+                            }
+                        }
+                        else if (exName === "lighter") {
+                            const { LighterAdapter } = await import("../exchanges/lighter.js");
+                            const { LighterSpotAdapter } = await import("../exchanges/lighter-spot.js");
+                            const ltSpot = new LighterSpotAdapter(adapter);
+                            await ltSpot.init();
+                            const bals = await ltSpot.getSpotBalances();
+                            const markets = await ltSpot.getSpotMarkets();
+                            const priceMap = new Map(markets.map(m => [m.baseToken.toUpperCase(), Number(m.markPrice)]));
+                            for (const b of bals) {
+                                if (b.token === "USDC" || b.token === "USDC_SPOT" || Number(b.total) <= 0)
+                                    continue;
+                                const price = priceMap.get(b.token.toUpperCase()) ?? 0;
+                                const value = price * Number(b.total);
+                                if (value < 1)
+                                    continue;
+                                spotRows.push([
+                                    chalk.white.bold(b.token),
+                                    chalk.gray("lighter"),
+                                    b.total,
+                                    `$${formatUsd(price)}`,
+                                    `$${formatUsd(value)}`,
+                                ]);
+                            }
+                        }
+                    }
+                    catch { /* spot not available */ }
+                }
+                if (spotRows.length > 0) {
+                    console.log(chalk.white.bold("\n  Spot Holdings"));
+                    console.log(makeTable(["Token", "Exchange", "Amount", "Price", "Value"], spotRows));
+                }
                 // ── Risk Metrics ──
                 console.log(chalk.white.bold("\n  Risk Metrics"));
                 const levelColor = {

package/dist/commands/arb/index.js

@@ -224,9 +224,10 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
         // ── Spot-Perp position detection ──
         // Fetch spot balances from HL and LT, match with perp shorts
         const spotPerpPositions = [];
-        // Build reverse map: spot token → perp symbol (UETH→ETH, UBTC→BTC, etc.)
+        // Build reverse map: spot token → perp symbol (UETH→ETH, UBTC→BTC, PURR-SPOT→PURR, etc.)
         const spotToPerpSymbol = (token) => {
-            const upper = token.toUpperCase();
+            // Strip "-SPOT" suffix that HL SDK appends to spot token names
+            const upper = token.replace(/-SPOT$/i, "").toUpperCase();
             return SPOT_PERP_TOKEN_MAP[upper] ?? upper;
         };
         // Collect spot balances per exchange
@@ -240,7 +241,10 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                     const hlSpot = new HyperliquidSpotAdapter(adapter);
                     await hlSpot.init();
                     const balances = await hlSpot.getSpotBalances();
-                    spotBalancesByExchange.set(exName, balances.filter(b => b.token !== "USDC" && Number(b.total) > 0));
+                    spotBalancesByExchange.set(exName, balances.filter(b => {
+                        const base = b.token.replace(/-SPOT$/i, "").toUpperCase();
+                        return base !== "USDC" && Number(b.total) > 0;
+                    }));
                 }
                 else if (exName === "lighter") {
                     const { LighterSpotAdapter } = await import("../../exchanges/lighter-spot.js");
@@ -266,6 +270,10 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                     continue;
                 // Find matching perp short position (on any exchange)
                 const matchingShorts = allPositions.filter(p => p.symbol === perpSymbol && p.side === "short");
+                // Skip dust balances (< $1 at perp mark price)
+                const refPrice = matchingShorts[0]?.markPrice ?? 0;
+                if (refPrice > 0 && spotAmount * refPrice < 1)
+                    continue;
                 for (const shortPos of matchingShorts) {
                     // Check if this short is already used by a perp-perp pair
                     const usedByPerpPerp = arbPairs.some(ap => ap.symbol === perpSymbol && ap.shortExchange === shortPos.exchange);
@@ -311,7 +319,7 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                         mode: "spot-perp",
                         spotExchange: spotEx,
                         perpExchange: shortPos.exchange,
-                        spotToken: bal.token,
+                        spotToken: bal.token.replace(/-SPOT$/i, ""),
                         spotAmount,
                         spotValueUsd,
                         perpSide: "short",

package/dist/commands/arb-auto.js

@@ -1,6 +1,7 @@
 import chalk from "chalk";
 import { formatUsd, printJson, jsonOk, makeTable } from "../utils.js";
 import { computeExecutableSize } from "../liquidity.js";
+import { computeMatchedSize, computeSpotPerpMatchedSize } from "../arb/sizing.js";
 import { computeAnnualSpread, toHourlyRate } from "../funding.js";
 import { fetchPacificaPricesRaw, parsePacificaRaw, fetchHyperliquidMetaRaw, parseHyperliquidMetaRaw, fetchLighterOrderBookDetailsRaw, fetchLighterFundingRatesRaw, parseLighterRaw, } from "../shared-api.js";
 import { scanDexArb } from "../dex-asset-map.js";
@@ -1390,7 +1391,7 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
             return;
         }
         // 4. Compute matched size in base asset (use the smaller side)
-        // Round down to each exchange's lot size (inferred from orderbook)
+        // Uses computeMatchedSize which enforces exchange min order values
         const inferDecimals = (levels) => {
             for (const [, s] of levels) {
                 const dot = s.indexOf(".");
@@ -1401,11 +1402,19 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
         };
         const longDecimals = inferDecimals(longBook.asks);
         const shortDecimals = inferDecimals(shortBook.bids);
-        const decimals = Math.min(longDecimals, shortDecimals);
         const matchedBase = Math.min(longCheck.recommendedSize, shortCheck.recommendedSize);
-        const matchedSize = (Math.floor(matchedBase * 10 ** decimals) / 10 ** decimals).toFixed(decimals);
         const avgPrice = (longCheck.avgFillPrice + shortCheck.avgFillPrice) / 2;
-        const matchedUsd = matchedBase * avgPrice;
+        const matchedUsdRaw = matchedBase * avgPrice;
+        const sizing = computeMatchedSize(matchedUsdRaw, avgPrice, longExch, shortExch, { longSizeDecimals: longDecimals, shortSizeDecimals: shortDecimals });
+        if (!sizing) {
+            const msg = `Order too small: $${matchedUsdRaw.toFixed(2)} below exchange minimum. Request a larger size.`;
+            if (isJson())
+                return printJson(jsonOk({ error: msg, computedUsd: matchedUsdRaw }));
+            console.log(chalk.red(`\n  ${msg}`));
+            return;
+        }
+        const matchedSize = sizing.size;
+        const matchedUsd = sizing.notional;
         if (!isJson()) {
             console.log(chalk.cyan(`\n  Arb Exec: ${sym}${opts.smart ? " (smart order)" : ""}${dryRun ? " [DRY RUN]" : ""}`));
             console.log(chalk.gray(`    LONG  ${longExch}: buy  ${matchedSize} (~$${(matchedBase * longCheck.avgFillPrice).toFixed(2)}, slippage ${longCheck.slippagePct.toFixed(3)}%)`));
@@ -1689,22 +1698,35 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                 // Continue — spot order may still work if spot balance already exists
             }
         }
-        // 2b. Verify spot USDC balance is sufficient after transfer
+        // 2b. Verify balance is sufficient after transfer
         try {
-            const spotBalances = await spotAdapter.getSpotBalances();
-            const spotUsdc = spotBalances.find(b => b.token === "USDC_SPOT" || b.token === "USDC");
-            const spotUsdcAvail = Number(spotUsdc?.available ?? 0);
-            // Also check perp balance for the perp leg
+            // HL unified account: perp equity IS spot balance (shared)
+            const isUnified = spotExch === "hyperliquid";
+            let spotUsdcAvail;
+            if (isUnified) {
+                // Unified account: perp adapter's available balance = spot purchasing power
+                const hlBalance = await perpAdapter.getBalance();
+                spotUsdcAvail = Number(hlBalance?.available ?? 0);
+            }
+            else {
+                const spotBalances = await spotAdapter.getSpotBalances();
+                const spotUsdc = spotBalances.find(b => b.token === "USDC_SPOT" || b.token === "USDC");
+                spotUsdcAvail = Number(spotUsdc?.available ?? 0);
+            }
+            // Check perp balance (for perp leg margin)
             const perpBalance = await perpAdapter.getBalance();
             const perpAvail = Number(perpBalance?.available ?? 0);
-            if (spotUsdcAvail < sizeUsd * 0.9) {
-                const msg = `Insufficient spot USDC: have $${spotUsdcAvail.toFixed(2)}, need ~$${sizeUsd}. Transfer may have failed.`;
+            // For unified accounts (same exchange), total needed = spotSize + perpMargin from same pool
+            const totalNeeded = spotExch === perpExch ? sizeUsd * 1.5 : sizeUsd;
+            const checkBalance = spotExch === perpExch ? spotUsdcAvail : spotUsdcAvail;
+            if (checkBalance < totalNeeded * 0.9) {
+                const msg = `Insufficient balance: have $${spotUsdcAvail.toFixed(2)}, need ~$${totalNeeded.toFixed(0)} (spot + perp margin)`;
                 if (isJson())
-                    return printJson(jsonOk({ error: msg, spotUsdcAvail, required: sizeUsd }));
+                    return printJson(jsonOk({ error: msg, spotUsdcAvail, required: totalNeeded }));
                 console.log(chalk.red(`  ${msg}`));
                 return;
             }
-            if (perpAvail < sizeUsd * 0.5) {
+            if (spotExch !== perpExch && perpAvail < sizeUsd * 0.5) {
                 const msg = `Insufficient perp balance: have $${perpAvail.toFixed(2)} available on ${perpExch}, need margin for ~$${sizeUsd}`;
                 if (isJson())
                     return printJson(jsonOk({ error: msg, perpAvail, required: sizeUsd }));
@@ -1763,7 +1785,8 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
             console.log(chalk.gray(`    ${perpExch} perp bids: $${perpCheck.depthUsd.toFixed(0)}`));
             return;
         }
-        // 4. Compute matched size
+        // 4. Compute matched size (with min order value enforcement)
+        const avgPrice = (spotCheck.avgFillPrice + perpCheck.avgFillPrice) / 2;
         const inferDecimals = (levels) => {
             for (const [, s] of levels) {
                 const dot = s.indexOf(".");
@@ -1773,12 +1796,20 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
             return 0;
         };
         const spotDecimals = inferDecimals(spotBook.asks);
-        const perpDecimals = inferDecimals(perpBook.bids);
-        const decimals = Math.min(spotDecimals, perpDecimals);
         const matchedBase = Math.min(spotCheck.recommendedSize, perpCheck.recommendedSize);
-        const matchedSize = (Math.floor(matchedBase * 10 ** decimals) / 10 ** decimals).toFixed(decimals);
-        const avgPrice = (spotCheck.avgFillPrice + perpCheck.avgFillPrice) / 2;
-        const matchedUsd = matchedBase * avgPrice;
+        const matchedUsdRaw = matchedBase * avgPrice;
+        // Use computeSpotPerpMatchedSize which enforces exchange min order values
+        // (e.g. HL $10 min) — rounds UP if floor would drop below minimum
+        const sizing = computeSpotPerpMatchedSize(matchedUsdRaw, avgPrice, spotExch, perpExch, spotDecimals);
+        if (!sizing) {
+            const msg = `Order too small: $${matchedUsdRaw.toFixed(2)} below exchange minimum. Request a larger size.`;
+            if (isJson())
+                return printJson(jsonOk({ error: msg, computedUsd: matchedUsdRaw }));
+            console.log(chalk.red(`\n  ${msg}`));
+            return;
+        }
+        const matchedSize = sizing.size;
+        const matchedUsd = sizing.notional;
         if (!isJson()) {
             console.log(chalk.cyan(`\n  Spot+Perp Arb: ${sym}`));
             console.log(chalk.gray(`    SPOT  ${spotExch}: buy  ${matchedSize} (~$${(matchedBase * spotCheck.avgFillPrice).toFixed(2)})`));

package/dist/commands/arb.js

@@ -190,21 +190,50 @@ function printSnapshotTable(snapshot) {
         console.log(chalk.gray("  No funding rate data available.\n"));
         return;
     }
+    // Build 24h trend: arrow + change in annualized spread
+    const now = new Date();
+    const h24ago = new Date(now.getTime() - 24 * 3600_000);
+    const trendMap = new Map(); // symbol → "▲+12.3%" or "▼-5.1%"
+    for (const s of snapshot.symbols) {
+        const bestEx = s.rates.find(r => r.exchange === "hyperliquid")?.exchange
+            ?? s.rates.find(r => r.exchange === "pacifica")?.exchange
+            ?? s.rates[0]?.exchange ?? "hyperliquid";
+        const history = getHistoricalRates(s.symbol, bestEx, h24ago, now);
+        if (history.length >= 2) {
+            const oldRate = history[0].hourlyRate;
+            const newRate = history[history.length - 1].hourlyRate;
+            // Change in annualized rate (hourly × 8760)
+            const oldAnn = Math.abs(oldRate) * 8760 * 100;
+            const newAnn = Math.abs(newRate) * 8760 * 100;
+            const delta = newAnn - oldAnn;
+            const absDelta = Math.abs(delta);
+            if (absDelta < 1) {
+                trendMap.set(s.symbol, chalk.gray(`\u2500 ${absDelta.toFixed(1)}%`)); // ─ stable
+            }
+            else if (delta > 0) {
+                trendMap.set(s.symbol, chalk.red(`\u25B2+${absDelta.toFixed(1)}%`)); // ▲ rising
+            }
+            else {
+                trendMap.set(s.symbol, chalk.green(`\u25BC-${absDelta.toFixed(1)}%`)); // ▼ falling
+            }
+        }
+    }
     const rows = snapshot.symbols.map(s => {
         const pacRate = s.rates.find(r => r.exchange === "pacifica");
         const hlRate = s.rates.find(r => r.exchange === "hyperliquid");
         const ltRate = s.rates.find(r => r.exchange === "lighter");
         const spreadColor = s.maxSpreadAnnual >= 30 ? chalk.green : s.maxSpreadAnnual >= 10 ? chalk.yellow : chalk.white;
         const bestRate = hlRate ?? pacRate ?? ltRate;
+        const trend = trendMap.get(s.symbol) ?? chalk.gray("-");
         return [
             chalk.white.bold(s.symbol), pacRate ? formatPercent(pacRate.fundingRate) : chalk.gray("-"),
             hlRate ? formatPercent(hlRate.fundingRate) : chalk.gray("-"), ltRate ? formatPercent(ltRate.fundingRate) : chalk.gray("-"),
-            spreadColor(`${s.maxSpreadAnnual.toFixed(1)}%`),
+            spreadColor(`${s.maxSpreadAnnual.toFixed(1)}%`), trend,
             s.maxSpreadAnnual >= 5 ? `${exAbbr(s.shortExchange)}>${exAbbr(s.longExchange)}` : chalk.gray("-"),
             formatAvgRate(bestRate?.historicalAvg?.avg8h), formatAvgRate(bestRate?.historicalAvg?.avg24h), formatAvgRate(bestRate?.historicalAvg?.avg7d),
         ];
     });
-    console.log(makeTable(["Symbol", "Pacifica", "Hyperliquid", "Lighter", "Ann. Spread", "Direction", "Avg 8h", "Avg 24h", "Avg 7d"], rows));
+    console.log(makeTable(["Symbol", "Pacifica", "Hyperliquid", "Lighter", "Spread", "24h", "Direction", "Avg 8h", "Avg 24h", "Avg 7d"], rows));
     console.log(chalk.gray(`\n  ${snapshot.symbols.length} symbols compared across exchanges.\n`));
 }
 function printFundingExchangeStatus(snapshot) {
@@ -250,9 +279,19 @@ export async function handleRates(isJson, opts) {
     }
     catch { /* non-critical */ }
     if (isJson()) {
+        // Enrich with 24h rate history for each symbol
+        const now = new Date();
+        const h24ago = new Date(now.getTime() - 24 * 3600_000);
+        const enriched = snapshot.symbols.map(s => {
+            const bestEx = s.rates.find(r => r.exchange === "hyperliquid")?.exchange
+                ?? s.rates.find(r => r.exchange === "pacifica")?.exchange
+                ?? s.rates[0]?.exchange ?? "hyperliquid";
+            const history = getHistoricalRates(s.symbol, bestEx, h24ago, now);
+            return { ...s, rateHistory: history.map(h => ({ ts: h.ts, hourlyRate: h.hourlyRate })) };
+        });
         if (process.argv.includes("--ndjson") || process.argv.includes("--fields"))
-            return printJson(jsonOk(snapshot.symbols));
-        return printJson(jsonOk(snapshot));
+            return printJson(jsonOk(enriched));
+        return printJson(jsonOk({ ...snapshot, symbols: enriched }));
     }
     printSnapshotTable(snapshot);
     printFundingExchangeStatus(snapshot);

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

@@ -14,6 +14,7 @@ export declare class HyperliquidSpotAdapter implements SpotAdapter {
     private _spotAssetMap;
     private _spotAssetReverse;
     private _spotDecimals;
+    private _spotCanonical;
     private _initialized;
     private _cachedMetaCtx;
     constructor(hlAdapter: HyperliquidAdapter);

package/dist/exchanges/hyperliquid-spot.js

@@ -26,6 +26,7 @@ export class HyperliquidSpotAdapter {
     _spotAssetMap = new Map(); // "ETH" → spotIndex (not +10000)
     _spotAssetReverse = new Map(); // spotIndex → "ETH"
     _spotDecimals = new Map();
+    _spotCanonical = new Map(); // "PURR" → true, "UBTC" → false
     _initialized = false;
     _cachedMetaCtx = null;
     constructor(hlAdapter) {
@@ -46,27 +47,36 @@ export class HyperliquidSpotAdapter {
                 return;
             this._cachedMetaCtx = metaCtx;
             const meta = metaCtx[0];
-            // Token index → name map
+            // Token index → name + szDecimals map (szDecimals lives on tokens, not universe)
             const tokenNames = new Map();
+            const tokenSzDecimals = new Map();
             for (const t of meta.tokens ?? []) {
                 tokenNames.set(t.index, t.name);
+                if (t.szDecimals !== undefined)
+                    tokenSzDecimals.set(t.index, t.szDecimals);
             }
             // Find USDC token index for filtering
             const usdcTokenIndex = meta.tokens?.find(t => t.name === "USDC")?.index ?? 0;
+            // HIP-1 meme tokens with low liquidity / unreliable orderbooks — skip for spot trading
+            const SPOT_EXCLUDE = new Set(["TRUMP", "PEPE", "HFUN"]);
             for (const u of meta.universe) {
-                const baseToken = tokenNames.get(u.tokens[0]) ?? "";
+                const baseTokenIndex = u.tokens[0];
+                const baseToken = tokenNames.get(baseTokenIndex) ?? "";
                 if (!baseToken)
                     continue;
                 const key = baseToken.toUpperCase();
+                if (SPOT_EXCLUDE.has(key))
+                    continue;
                 const isUsdcPair = u.tokens[1] === usdcTokenIndex;
                 if (this._spotAssetMap.has(key) && !isUsdcPair)
                     continue;
                 this._spotAssetMap.set(key, u.index);
                 this._spotAssetReverse.set(u.index, key);
                 this._spotDecimals.set(key, {
-                    size: u.szDecimals ?? 2,
+                    size: tokenSzDecimals.get(baseTokenIndex) ?? 2,
                     price: 6,
                 });
+                this._spotCanonical.set(key, u.isCanonical === true);
             }
         }
         catch (e) {
@@ -82,8 +92,11 @@ export class HyperliquidSpotAdapter {
             if (!metaCtx?.[0]?.universe)
                 return [];
             const tokenNames = new Map();
+            const tokenSzDec = new Map();
             for (const t of metaCtx[0].tokens ?? []) {
                 tokenNames.set(t.index, t.name);
+                if (t.szDecimals !== undefined)
+                    tokenSzDec.set(t.index, t.szDecimals);
             }
             const ctxs = metaCtx[1] ?? [];
             const markets = [];
@@ -100,7 +113,7 @@ export class HyperliquidSpotAdapter {
                     quoteToken,
                     markPrice: String(ctx.markPx ?? ctx.midPx ?? "0"),
                     volume24h: String(ctx.dayNtlVlm ?? "0"),
-                    sizeDecimals: u.szDecimals ?? 2,
+                    sizeDecimals: tokenSzDec.get(u.tokens[0]) ?? 2,
                     priceDecimals: 6,
                 });
             }
@@ -112,12 +125,13 @@ export class HyperliquidSpotAdapter {
     }
     async getSpotOrderbook(symbol) {
         await this.init();
-        const { spotIndex } = this._resolveBase(symbol);
-        // HL spot L2 book uses the universe name, which is like "ETH/USDC" internally
-        // But the API takes coin=<name>, where name is from spotMeta universe
+        const { base, spotIndex } = this._resolveBase(symbol);
+        // Canonical tokens (e.g. PURR) use "BASE/USDC", non-canonical (e.g. UBTC) use "@index"
+        const isCanonical = this._spotCanonical.get(base) ?? false;
+        const coin = isCanonical ? `${base}/USDC` : `@${spotIndex}`;
         const book = await this._infoPost({
             type: "l2Book",
-            coin: `@${spotIndex}`,
+            coin,
         });
         const levels = book?.levels ?? [[], []];
         return {
@@ -133,8 +147,9 @@ export class HyperliquidSpotAdapter {
     }
     async getSpotBalances() {
         try {
-            const state = await this._hl.client.info.spot.getSpotClearinghouseState(this._hl.address);
-            const balances = state?.balances ?? [];
+            // Reuse cached spot clearinghouse state (shared with getBalance() — saves 1 API call)
+            const state = await this._hl._getSpotClearinghouseState();
+            const balances = (state?.balances ?? []);
             return balances.map((b) => ({
                 token: String(b.coin ?? ""),
                 total: String(b.total ?? "0"),

package/dist/exchanges/hyperliquid.d.ts

@@ -43,6 +43,8 @@ export declare class HyperliquidAdapter implements ExchangeAdapter {
     private ensureAddress;
     /** Always fetches live clearinghouseState, writes result to shared cache for dashboard */
     private _getClearinghouseState;
+    /** Cached spot clearinghouse state — shared between getBalance() and HyperliquidSpotAdapter */
+    _getSpotClearinghouseState(): Promise<Record<string, unknown>>;
     getBalance(): Promise<ExchangeBalance>;
     getPositions(): Promise<ExchangePosition[]>;
     getOpenOrders(): Promise<ExchangeOrder[]>;

package/dist/exchanges/hyperliquid.js

@@ -258,6 +258,14 @@ export class HyperliquidAdapter {
             return state;
         });
     }
+    /** Cached spot clearinghouse state — shared between getBalance() and HyperliquidSpotAdapter */
+    async _getSpotClearinghouseState() {
+        this.ensureAddress();
+        const { withCache, TTL_ACCOUNT } = await import("../cache.js");
+        return withCache(`acct:hl:spot_chs:${this._address}`, TTL_ACCOUNT, async () => {
+            return await this.sdk.info.spot.getSpotClearinghouseState(this._address);
+        });
+    }
     async getBalance() {
         const state = await this._getClearinghouseState();
         const s = state;
@@ -277,8 +285,8 @@ export class HyperliquidAdapter {
             // 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 spotState = await this._getSpotClearinghouseState();
+                const balances = (spotState?.balances ?? []);
                 const usdc = balances.find((b) => String(b.coin).startsWith("USDC"));
                 const spotTotal = usdc?.total !== undefined ? Number(usdc.total) : NaN;
                 const spotHold = Number(usdc?.hold ?? 0);

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

@@ -15,7 +15,9 @@ export declare class LighterSpotAdapter implements SpotAdapter {
     private _spotBaseMap;
     private _spotDecimals;
     private _spotMinSize;
+    private _spotPrices;
     private _initialized;
+    private _clientOrderCounter;
     constructor(ltAdapter: LighterAdapter);
     init(): Promise<void>;
     private _loadSpotMarkets;
@@ -32,6 +34,8 @@ export declare class LighterSpotAdapter implements SpotAdapter {
         tif?: string;
     }): Promise<unknown>;
     spotCancelOrder(symbol: string, orderId: string): Promise<unknown>;
+    /** Cancel all orders across all markets (spot + perp) */
+    spotCancelAllOrders(_symbol?: string): Promise<unknown>;
     /** Transfer USDC from perp account to spot account (required before spot buys) */
     transferUsdcToSpot(amount: number): Promise<unknown>;
     /** Transfer USDC from spot account back to perp account */
@@ -48,6 +52,8 @@ export declare class LighterSpotAdapter implements SpotAdapter {
     /** Check if a base token has a spot market */
     hasSpotMarket(base: string): boolean;
     private _placeOrder;
+    /** Generate a unique client order index (uint48). Uses timestamp + counter. */
+    private _nextClientOrderIndex;
     private _getNextNonce;
     private _sendTx;
     private _restGet;

package/dist/exchanges/lighter-spot.js

@@ -13,7 +13,9 @@ export class LighterSpotAdapter {
     _spotBaseMap = new Map(); // "ETH" → "ETH/USDC"
     _spotDecimals = new Map();
     _spotMinSize = new Map(); // min order sizes
+    _spotPrices = new Map(); // "ETH/USDC" → markPrice (from init)
     _initialized = false;
+    _clientOrderCounter = 0;
     constructor(ltAdapter) {
         this._lt = ltAdapter;
     }
@@ -40,6 +42,11 @@ export class LighterSpotAdapter {
                     base: parseFloat(ob.min_base_amount || "0"),
                     quote: parseFloat(ob.min_quote_amount || "0"),
                 });
+                // Cache price from orderBooks response (avoids N separate orderbook calls in getSpotMarkets)
+                const price = ob.mark_price ?? (ob.best_ask_price && ob.best_bid_price
+                    ? String((parseFloat(ob.best_ask_price) + parseFloat(ob.best_bid_price)) / 2) : "0");
+                if (price !== "0")
+                    this._spotPrices.set(symbol, price);
                 const base = symbol.split("/")[0];
                 if (base)
                     this._spotBaseMap.set(base, symbol);
@@ -84,22 +91,25 @@ export class LighterSpotAdapter {
     async getSpotMarkets() {
         await this.init();
         const entries = Array.from(this._spotMarketMap.entries());
-        // Fetch all orderbooks in parallel (instead of sequential per-market)
-        const obResults = await Promise.allSettled(entries.map(([symbol]) => this.getSpotOrderbook(symbol).then(ob => {
-            if (ob.bids.length > 0 && ob.asks.length > 0) {
-                return String((Number(ob.bids[0][0]) + Number(ob.asks[0][0])) / 2);
-            }
-            return "0";
-        })));
-        return entries.map(([symbol], i) => {
+        // Use prices cached from init's /orderBooks response (0 extra API calls).
+        // Only fetch individual orderbooks if no cached price available.
+        const missingPrices = entries.filter(([sym]) => !this._spotPrices.has(sym));
+        if (missingPrices.length > 0) {
+            const results = await Promise.allSettled(missingPrices.map(([symbol]) => this.getSpotOrderbook(symbol).then(ob => {
+                if (ob.bids.length > 0 && ob.asks.length > 0) {
+                    this._spotPrices.set(symbol, String((Number(ob.bids[0][0]) + Number(ob.asks[0][0])) / 2));
+                }
+            })));
+            void results; // consume
+        }
+        return entries.map(([symbol]) => {
             const parts = symbol.split("/");
             const base = parts[0] ?? "";
             const quote = parts[1] ?? "USDC";
             const dec = this._spotDecimals.get(symbol) ?? { size: 4, price: 2 };
-            const markPrice = obResults[i].status === "fulfilled" ? obResults[i].value : "0";
             return {
                 symbol, baseToken: base, quoteToken: quote,
-                markPrice, volume24h: "0",
+                markPrice: this._spotPrices.get(symbol) ?? "0", volume24h: "0",
                 sizeDecimals: dec.size, priceDecimals: dec.price,
             };
         });
@@ -128,32 +138,36 @@ export class LighterSpotAdapter {
     async getSpotBalances() {
         try {
             await this.init();
-            const balances = [];
             const address = this._lt.address;
             if (!address)
                 return [];
-            const res = await this._restGet("/account", {
-                by: "l1_address",
-                value: address,
+            // Reuse cached account data (shared with LighterAdapter.fetchAccount() — saves 1 API call)
+            const { withCache, TTL_ACCOUNT } = await import("../cache.js");
+            const acct = await withCache(`acct:lt:account:${address}`, TTL_ACCOUNT, async () => {
+                const res = await this._restGet("/account", {
+                    by: "l1_address",
+                    value: address,
+                });
+                const found = res.accounts?.find(a => a.account_index === this._lt.accountIndex)
+                    ?? res.accounts?.[0];
+                return found ?? null;
             });
-            const acct = res.accounts?.find(a => a.account_index === this._lt.accountIndex)
-                ?? res.accounts?.[0];
             if (!acct)
                 return [];
+            const balances = [];
             // 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 (bal > 0) {
-                        balances.push({
-                            token: asset.symbol === "USDC" ? "USDC_SPOT" : asset.symbol,
-                            total: asset.balance,
-                            available: String(bal - locked),
-                            held: asset.locked_balance,
-                        });
-                    }
+            const assets = (acct.assets ?? []);
+            for (const asset of assets) {
+                const bal = parseFloat(asset.balance || "0");
+                const locked = parseFloat(asset.locked_balance || "0");
+                if (bal > 0) {
+                    balances.push({
+                        token: asset.symbol === "USDC" ? "USDC_SPOT" : asset.symbol,
+                        total: asset.balance,
+                        available: String(bal - locked),
+                        held: asset.locked_balance,
+                    });
                 }
             }
             return balances;
@@ -244,18 +258,42 @@ export class LighterSpotAdapter {
         if (marketId === undefined) {
             throw new Error(`Unknown Lighter spot market: ${symbol}`);
         }
-        // Access signer through the adapter
+        // Lighter order IDs can exceed Number.MAX_SAFE_INTEGER (2^53-1).
+        // The WASM signer only accepts JS number, so large IDs lose precision
+        // and the cancel silently targets the wrong order.
+        // Fall back to cancelAll for the market when the ID is unsafe.
+        const idNum = Number(orderId);
+        if (!Number.isSafeInteger(idNum)) {
+            return this.spotCancelAllOrders(symbol);
+        }
         const signer = this._lt.signer;
         const nonce = await this._getNextNonce();
         const signed = await signer.signCancelOrder({
             marketIndex: marketId,
-            orderIndex: parseInt(orderId),
+            orderIndex: idNum,
             nonce,
             apiKeyIndex: this._lt._apiKeyIndex,
             accountIndex: this._lt.accountIndex,
         });
         return this._sendTx(signed);
     }
+    /** Cancel all orders across all markets (spot + perp) */
+    async spotCancelAllOrders(_symbol) {
+        if (this._lt.isReadOnly)
+            throw new Error("Cancel requires API key");
+        const signer = this._lt.signer;
+        const nonce = await this._getNextNonce();
+        const apiKeyIndex = this._lt._apiKeyIndex;
+        // time must be in milliseconds, in the future
+        const signed = await signer.signCancelAllOrders({
+            timeInForce: 1,
+            time: Date.now() + 3600_000,
+            nonce,
+            apiKeyIndex,
+            accountIndex: this._lt.accountIndex,
+        });
+        return this._sendTx(signed);
+    }
     /** Transfer USDC from perp account to spot account (required before spot buys) */
     async transferUsdcToSpot(amount) {
         return this._selfTransfer(amount, 0, 1); // route: Perp(0) → Spot(1)
@@ -333,9 +371,13 @@ export class LighterSpotAdapter {
         const nonce = await this._getNextNonce();
         const signer = this._lt.signer;
         const apiKeyIndex = this._lt._apiKeyIndex;
+        // Use a unique clientOrderIndex (uint48, max 2^48-1 ≈ 281 trillion).
+        // This value is used for cancel operations instead of the exchange-assigned
+        // order_id which can exceed Number.MAX_SAFE_INTEGER.
+        const clientOrderIndex = this._nextClientOrderIndex();
         const signed = await signer.signCreateOrder({
             marketIndex: opts.marketIndex,
-            clientOrderIndex: 0,
+            clientOrderIndex,
             baseAmount: opts.baseAmount,
             price: opts.price,
             isAsk: opts.isAsk,
@@ -353,6 +395,13 @@ export class LighterSpotAdapter {
         }
         return this._sendTx(signed);
     }
+    /** Generate a unique client order index (uint48). Uses timestamp + counter. */
+    _nextClientOrderIndex() {
+        // Timestamp in seconds gives ~10 digits. Add counter for uniqueness within same second.
+        // uint48 max = 281_474_976_710_655. Date.now()/1000 ≈ 1.7 trillion (fits).
+        const base = Math.floor(Date.now() / 1000) % 281_474_976_710_000;
+        return base + (this._clientOrderCounter++ % 655);
+    }
     async _getNextNonce() {
         const apiKeyIndex = this._lt._apiKeyIndex;
         const res = await this._restGet("/nextNonce", {

package/dist/exchanges/lighter.d.ts

@@ -9,6 +9,7 @@ export declare class LighterAdapter implements ExchangeAdapter {
     private _address;
     private _marketMap;
     private _marketDecimals;
+    private _clientOrderCounter;
     private _evmKey;
     private _apiKey;
     private _accountIndexInit;
@@ -149,6 +150,8 @@ export declare class LighterAdapter implements ExchangeAdapter {
     private signOrder;
     private sendTx;
     private restGet;
+    /** Generate a unique client order index (uint48). */
+    private nextClientOrderIndex;
     private ensureSigner;
     private static _wasmClient;
     private static getWasmClient;

package/dist/exchanges/lighter.js

@@ -7,6 +7,7 @@ export class LighterAdapter {
     _address;
     _marketMap = new Map(); // symbol → marketIndex
     _marketDecimals = new Map(); // symbol → decimals
+    _clientOrderCounter = 0;
     _evmKey;
     _apiKey;
     _accountIndexInit;
@@ -73,26 +74,30 @@ export class LighterAdapter {
             await this._refreshMarketMap();
             return;
         }
-        // Retry account lookup on 429 (rate limit) — critical for _accountIndex
-        for (let attempt = 0; attempt < 3; attempt++) {
-            try {
-                const res = await fetch(`${this._baseUrl}/api/v1/account?by=l1_address&value=${this._address}`);
-                if (res.status === 429 && attempt < 2) {
-                    await new Promise(r => setTimeout(r, 1000 * (attempt + 1)));
-                    continue;
-                }
-                const json = await res.json();
-                if (json.accounts && json.accounts.length > 0) {
-                    this._accountIndex = this._accountIndexInit >= 0
-                        ? this._accountIndexInit
-                        : json.accounts[0].account_index;
+        // If accountIndex is already known (from env/opts), skip API lookup entirely
+        if (this._accountIndexInit >= 0) {
+            this._accountIndex = this._accountIndexInit;
+        }
+        else {
+            // Retry account lookup on 429 (rate limit) — critical for _accountIndex
+            for (let attempt = 0; attempt < 3; attempt++) {
+                try {
+                    const res = await fetch(`${this._baseUrl}/api/v1/account?by=l1_address&value=${this._address}`);
+                    if (res.status === 429 && attempt < 2) {
+                        await new Promise(r => setTimeout(r, 2000 * (attempt + 1)));
+                        continue;
+                    }
+                    const json = await res.json();
+                    if (json.accounts && json.accounts.length > 0) {
+                        this._accountIndex = json.accounts[0].account_index;
+                    }
+                    break;
                 }
-                break;
-            }
-            catch {
-                if (attempt < 2) {
-                    await new Promise(r => setTimeout(r, 1000));
-                    continue;
+                catch {
+                    if (attempt < 2) {
+                        await new Promise(r => setTimeout(r, 2000));
+                        continue;
+                    }
                 }
             }
         }
@@ -434,7 +439,7 @@ export class LighterAdapter {
         const { priceTicks: slippageTicks } = this.toTicks(symbol, 0, slippagePrice);
         const signed = await this.signOrder({
             marketIndex,
-            clientOrderIndex: 0,
+            clientOrderIndex: this.nextClientOrderIndex(),
             baseAmount,
             price: Math.max(slippageTicks, 1),
             isAsk: side === "sell" ? 1 : 0,
@@ -457,7 +462,7 @@ export class LighterAdapter {
         const isIoc = opts?.tif?.toUpperCase() === "IOC";
         const signed = await this.signOrder({
             marketIndex,
-            clientOrderIndex: 0,
+            clientOrderIndex: this.nextClientOrderIndex(),
             baseAmount,
             price: priceTicks,
             isAsk: side === "sell" ? 1 : 0,
@@ -473,10 +478,17 @@ export class LighterAdapter {
     async cancelOrder(symbol, orderId) {
         this.ensureSigner();
         await this.ensureMarketMap();
+        // Lighter order IDs can exceed Number.MAX_SAFE_INTEGER (2^53-1).
+        // The WASM signer only accepts JS number, so large IDs lose precision.
+        // Fall back to cancelAllOrders when the ID is unsafe.
+        const idNum = Number(orderId);
+        if (!Number.isSafeInteger(idNum)) {
+            return this.cancelAllOrders(symbol);
+        }
         const nonce = await this.getNextNonce();
         const marketIndex = this.getMarketIndex(symbol);
         const signed = await this._signer.signCancelOrder({
-            marketIndex, orderIndex: parseInt(orderId), nonce,
+            marketIndex, orderIndex: idNum, nonce,
             apiKeyIndex: this._apiKeyIndex, accountIndex: this._accountIndex,
         });
         return this.sendTx(signed);
@@ -495,7 +507,7 @@ export class LighterAdapter {
         }
         const nonce = await this.getNextNonce();
         const signed = await this._signer.signCancelAllOrders({
-            timeInForce: 0, time: Math.floor(Date.now() / 1000) + 86400, nonce,
+            timeInForce: 1, time: Date.now() + 3600_000, nonce,
             apiKeyIndex: this._apiKeyIndex, accountIndex: this._accountIndex,
         });
         return this.sendTx(signed);
@@ -506,9 +518,13 @@ export class LighterAdapter {
         const nonce = await this.getNextNonce();
         const marketIndex = this.getMarketIndex(symbol);
         const { baseAmount, priceTicks } = this.toTicks(symbol, parseFloat(size), parseFloat(price));
+        const idNum = Number(orderId);
+        if (!Number.isSafeInteger(idNum)) {
+            throw new Error(`Order ID ${orderId} exceeds MAX_SAFE_INTEGER — cancel and re-place instead`);
+        }
         const signed = await this._signer.signModifyOrder({
             marketIndex,
-            index: parseInt(orderId),
+            index: idNum,
             baseAmount,
             price: priceTicks,
             triggerPrice: 0,
@@ -541,7 +557,7 @@ export class LighterAdapter {
         }
         const signed = await this.signOrder({
             marketIndex,
-            clientOrderIndex: 0,
+            clientOrderIndex: this.nextClientOrderIndex(),
             baseAmount,
             price: Math.max(priceTicks, 1),
             isAsk: side === "sell" ? 1 : 0,
@@ -946,6 +962,11 @@ export class LighterAdapter {
             throw new Error(`GET ${path} failed (${res.status}): ${await res.text()}`);
         return res.json();
     }
+    /** Generate a unique client order index (uint48). */
+    nextClientOrderIndex() {
+        const base = Math.floor(Date.now() / 1000) % 281_474_976_710_000;
+        return base + (this._clientOrderCounter++ % 655);
+    }
     ensureSigner() {
         if (this._readOnly || this._accountIndex < 0 || !this._signer) {
             throw new Error("This command requires a Lighter API key. Run `perp -e lighter manage setup-api-key` first, " +

package/dist/exchanges/pacifica.js

@@ -79,13 +79,26 @@ export class PacificaAdapter {
     async getBalance() {
         if (!this._hasRealKey)
             throw new Error("No private key configured — account data unavailable. Run: perp init");
-        const [info, positions] = await Promise.all([
+        const [info, positions, prices] = await Promise.all([
             this.client.getAccount(this.account),
             this._getPositions(),
+            this._getPrices(),
         ]);
         const raw = info;
-        // Use API-provided unrealized PnL from positions
-        const totalPnl = positions.reduce((sum, p) => sum + Number(p.unrealized_pnl ?? 0), 0);
+        const priceMap = new Map(prices.map((p) => [p.symbol, p]));
+        // API often returns unrealized_pnl=0 — compute from price delta when needed
+        let totalPnl = 0;
+        for (const p of positions) {
+            let upnl = Number(p.unrealized_pnl ?? 0);
+            if (upnl === 0 && Number(p.amount) > 0) {
+                const mark = Number(priceMap.get(p.symbol)?.mark ?? p.mark_price ?? 0);
+                const entry = Number(p.entry_price);
+                const dir = p.side === "bid" ? 1 : -1;
+                if (mark > 0 && entry > 0)
+                    upnl = (mark - entry) * Number(p.amount) * dir;
+            }
+            totalPnl += upnl;
+        }
         return {
             equity: info.account_equity,
             available: info.available_to_spend,
@@ -114,6 +127,15 @@ export class PacificaAdapter {
         return positions.map((p) => {
             const mark = priceMap.get(p.symbol)?.mark ?? p.mark_price ?? "0";
             const side = p.side === "bid" ? "long" : "short";
+            const size = Number(p.amount);
+            const entry = Number(p.entry_price);
+            const markNum = Number(mark);
+            // API often returns unrealized_pnl=0 — compute from price delta when needed
+            let upnl = Number(p.unrealized_pnl ?? 0);
+            if (upnl === 0 && size > 0 && entry > 0 && markNum > 0) {
+                const dir = side === "long" ? 1 : -1;
+                upnl = (markNum - entry) * size * dir;
+            }
             return {
                 symbol: p.symbol,
                 side: side,
@@ -121,7 +143,7 @@ export class PacificaAdapter {
                 entryPrice: String(p.entry_price),
                 markPrice: mark,
                 liquidationPrice: String(p.liquidation_price ?? "N/A"),
-                unrealizedPnl: String(p.unrealized_pnl ?? "0"),
+                unrealizedPnl: upnl.toFixed(4),
                 leverage: p.leverage ?? levMap.get(String(p.symbol)) ?? 1,
             };
         });

package/dist/index.js

@@ -322,16 +322,284 @@ const apiSpecCmd = program
     printJson(jsonOk(getCliSpec(program)));
 });
 apiSpecCmd._hidden = true;
-// Deprecated: perp status → use 'perp portfolio' or 'perp account'
-const statusCmd = program.command("status").description("Use 'perp portfolio'")
-    .option("--health", "Check connectivity").action(async (opts) => {
+// Unified dashboard: balances + positions + top arb opportunities
+program.command("status")
+    .description("Unified dashboard: balances, positions, and top arb opportunities")
+    .option("--health", "Check connectivity only")
+    .action(async (opts) => {
     if (opts.health) {
         const { runHealthCheck } = await import("./commands/risk.js");
         return runHealthCheck(isJson);
     }
-    console.log("Use 'perp portfolio' or 'perp account' instead.");
+    const json = isJson();
+    const { formatUsd, formatPnl, makeTable, printJson, jsonOk, withJsonErrors } = await import("./utils.js");
+    const { fetchAllFundingRates, TOP_SYMBOLS } = await import("./funding-rates.js");
+    const { saveFundingSnapshot, getHistoricalRates } = await import("./funding-history.js");
+    await withJsonErrors(json, async () => {
+        const EX_LIST = ["pacifica", "hyperliquid", "lighter"];
+        const exAbbr = (e) => e === "pacifica" ? "PAC" : e === "hyperliquid" ? "HL" : "LT";
+        const snapshotPromises = EX_LIST.map(async (ex) => {
+            try {
+                const adapter = await getAdapterForExchange(ex);
+                const [balance, positions, orders] = await Promise.all([
+                    adapter.getBalance(), adapter.getPositions(), adapter.getOpenOrders(),
+                ]);
+                // Fetch spot balances for HL and LT (Pacifica is perp-only)
+                let spotHoldings = [];
+                let isUnified = false;
+                try {
+                    if (ex === "hyperliquid") {
+                        const { HyperliquidSpotAdapter } = await import("./exchanges/hyperliquid-spot.js");
+                        const hlSpot = new HyperliquidSpotAdapter(adapter);
+                        await hlSpot.init();
+                        const [raw, markets] = await Promise.all([hlSpot.getSpotBalances(), hlSpot.getSpotMarkets()]);
+                        const priceMap = new Map(markets.map(m => [m.baseToken.toUpperCase(), Number(m.markPrice)]));
+                        const strip = (t) => t.replace(/-SPOT$/i, "").toUpperCase();
+                        spotHoldings = raw.filter(b => Number(b.total) > 0).map(b => {
+                            const base = strip(b.token);
+                            return { ...b, valueUsd: base === "USDC" ? Number(b.total) : (priceMap.get(base) ?? 0) * Number(b.total) };
+                        });
+                        isUnified = !adapter.dex;
+                    }
+                    else if (ex === "lighter") {
+                        const { LighterAdapter } = await import("./exchanges/lighter.js");
+                        const { LighterSpotAdapter } = await import("./exchanges/lighter-spot.js");
+                        const ltSpot = new LighterSpotAdapter(adapter);
+                        await ltSpot.init();
+                        const [raw, markets] = await Promise.all([ltSpot.getSpotBalances(), ltSpot.getSpotMarkets()]);
+                        const priceMap = new Map(markets.map(m => [m.baseToken.toUpperCase(), Number(m.markPrice)]));
+                        spotHoldings = raw.filter(b => Number(b.total) > 0).map(b => ({
+                            ...b,
+                            valueUsd: b.token === "USDC" || b.token === "USDC_SPOT" ? Number(b.total) : (priceMap.get(b.token.toUpperCase()) ?? 0) * Number(b.total),
+                        }));
+                    }
+                }
+                catch { /* spot not available */ }
+                return { exchange: ex, connected: true, balance, positions, openOrders: orders.length, spotHoldings, isUnified, error: undefined };
+            }
+            catch (err) {
+                return { exchange: ex, connected: false, balance: null, positions: [], openOrders: 0, spotHoldings: [], isUnified: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        });
+        const arbPromise = fetchAllFundingRates({ symbols: TOP_SYMBOLS, minSpread: 0 }).catch(() => null);
+        const [snapshots, arbSnapshot] = await Promise.all([Promise.all(snapshotPromises), arbPromise]);
+        // Save funding snapshot for sparkline history
+        if (arbSnapshot) {
+            try {
+                const allRates = arbSnapshot.symbols.flatMap(s => s.rates);
+                if (allRates.length > 0)
+                    saveFundingSnapshot(allRates);
+            }
+            catch { /* */ }
+        }
+        // Build totals (include non-USDC spot value for unified accounts)
+        let totalEquity = 0;
+        let totalSpotValue = 0;
+        const allPositions = [];
+        const allSpotHoldings = [];
+        for (const s of snapshots) {
+            if (s.balance)
+                totalEquity += Number(s.balance.equity);
+            for (const p of s.positions)
+                allPositions.push({ ...p, exchange: s.exchange });
+            // For unified accounts (HL), USDC is already in perp equity — only add non-USDC spot
+            const displaySpot = s.isUnified
+                ? s.spotHoldings.filter(b => b.token.replace(/-SPOT$/i, "").toUpperCase() !== "USDC")
+                : s.spotHoldings;
+            const spotVal = displaySpot.reduce((sum, b) => sum + b.valueUsd, 0);
+            totalSpotValue += spotVal;
+            totalEquity += spotVal;
+            for (const b of displaySpot)
+                allSpotHoldings.push({ ...b, exchange: s.exchange });
+        }
+        // Top arb
+        const topArb = arbSnapshot
+            ? arbSnapshot.symbols.filter(s => s.maxSpreadAnnual >= 5).sort((a, b) => b.maxSpreadAnnual - a.maxSpreadAnnual).slice(0, 5)
+            : [];
+        // Risk
+        const marginUsed = snapshots.reduce((s, x) => s + (x.balance ? Number(x.balance.marginUsed) : 0), 0);
+        const marginPct = totalEquity > 0 ? (marginUsed / totalEquity) * 100 : 0;
+        const riskLevel = marginPct < 30 ? "LOW" : marginPct < 60 ? "MEDIUM" : "HIGH";
+        if (json) {
+            const now = new Date();
+            const h24 = new Date(now.getTime() - 24 * 3600_000);
+            return printJson(jsonOk({
+                version: _pkg.version,
+                totalEquity,
+                riskLevel,
+                exchanges: snapshots.map(s => ({
+                    name: s.exchange, connected: s.connected,
+                    equity: s.balance ? Number(s.balance.equity) : 0,
+                    available: s.balance ? Number(s.balance.available) : 0,
+                    spotHoldings: s.spotHoldings.filter(b => Number(b.total) > 0).map(b => ({
+                        token: b.token, total: b.total, available: b.available, valueUsd: b.valueUsd,
+                    })),
+                })),
+                totalSpotValue,
+                positions: allPositions,
+                topArbOpportunities: await (async () => {
+                    const { getHistoricalAverages: getAvgs } = await import("./funding-history.js");
+                    const syms = topArb.map(a => a.symbol);
+                    const avgs = syms.length > 0 ? getAvgs(syms, ["hyperliquid", "pacifica", "lighter"]) : new Map();
+                    return topArb.map(a => {
+                        const bestEx = a.rates.find(r => r.exchange === "hyperliquid")?.exchange ?? a.rates[0]?.exchange ?? "hyperliquid";
+                        const avg = avgs.get(`${a.symbol}:${bestEx}`);
+                        return {
+                            symbol: a.symbol, spreadAnnual: a.maxSpreadAnnual,
+                            direction: `${exAbbr(a.shortExchange)}>${exAbbr(a.longExchange)}`,
+                            avg24h: avg?.avg24h != null ? Math.abs(avg.avg24h) * 8760 * 100 : null,
+                            avg7d: avg?.avg7d != null ? Math.abs(avg.avg7d) * 8760 * 100 : null,
+                            rateHistory: getHistoricalRates(a.symbol, bestEx, h24, now).map(h => ({ ts: h.ts, hourlyRate: h.hourlyRate })),
+                        };
+                    });
+                })(),
+            }));
+        }
+        // ── Terminal UI ──
+        console.log(chalk.cyan.bold(`\n  perp-cli v${_pkg.version}`) + chalk.gray(` — ${snapshots.filter(s => s.connected).length} exchanges connected\n`));
+        // Balance bars + Top Arb side by side
+        const now = new Date();
+        const h24 = new Date(now.getTime() - 24 * 3600_000);
+        // Left column: Balances (perp + spot per exchange)
+        // Compute per-exchange totals: perp equity + non-USDC spot (unified) or all spot
+        const exTotals = snapshots.map(s => {
+            if (!s.connected || !s.balance)
+                return { total: 0, margin: 0, equity: 0 };
+            const equity = Number(s.balance.equity);
+            const margin = Number(s.balance.marginUsed);
+            const displaySpot = s.isUnified
+                ? s.spotHoldings.filter(b => b.token.replace(/-SPOT$/i, "").toUpperCase() !== "USDC")
+                : s.spotHoldings;
+            const spotVal = displaySpot.reduce((sum, b) => sum + b.valueUsd, 0);
+            return { total: equity + spotVal, margin, equity };
+        });
+        const balLines = [];
+        balLines.push(chalk.white.bold(" Balances"));
+        for (let i = 0; i < snapshots.length; i++) {
+            const s = snapshots[i];
+            if (!s.connected) {
+                balLines.push(` ${chalk.gray(exAbbr(s.exchange).padEnd(4))} ${chalk.red("disconnected")}`);
+                continue;
+            }
+            const { total, margin, equity } = exTotals[i];
+            const usagePct = equity > 0 ? (margin / equity) * 100 : 0;
+            const barFull = Math.min(20, Math.round(usagePct / 5));
+            const usageColor = usagePct < 30 ? chalk.green : usagePct < 60 ? chalk.yellow : chalk.red;
+            const bar = usageColor("\u2588".repeat(barFull)) + chalk.gray("\u2591".repeat(20 - barFull));
+            balLines.push(` ${chalk.white.bold(exAbbr(s.exchange).padEnd(4))} $${formatUsd(total).padEnd(9)} ${bar} ${usagePct.toFixed(0)}% used`);
+        }
+        // Spot holdings (non-USDC tokens with value)
+        const displaySpotHoldings = allSpotHoldings.filter(b => {
+            const tk = b.token.replace(/[-_]SPOT$/i, "").toUpperCase();
+            return tk !== "USDC";
+        });
+        if (displaySpotHoldings.length > 0) {
+            balLines.push("");
+            balLines.push(chalk.white.bold(" Spot Holdings"));
+            for (const b of displaySpotHoldings) {
+                const token = b.token.replace(/-SPOT$/i, "");
+                const ex = exAbbr(b.exchange);
+                balLines.push(` ${chalk.gray(ex.padEnd(4))} ${chalk.white.bold(token.padEnd(6))} ${b.total.padEnd(12)} ${chalk.gray(`$${formatUsd(b.valueUsd)}`)}`);
+            }
+        }
+        const riskColor = riskLevel === "LOW" ? chalk.green : riskLevel === "MEDIUM" ? chalk.yellow : chalk.red;
+        balLines.push(` ${"─".repeat(44)}`);
+        balLines.push(` ${chalk.cyan.bold("Total")} ${chalk.cyan.bold(`$${formatUsd(totalEquity)}`.padEnd(9))}    Risk: ${riskColor(riskLevel)}`);
+        // Right column: Top Arb Opportunities (with 24h/7d averages from local history — 0 API calls)
+        const { getHistoricalAverages } = await import("./funding-history.js");
+        const arbSymbols = topArb.map(a => a.symbol);
+        const arbExchanges = ["hyperliquid", "pacifica", "lighter"];
+        const histAvgs = arbSymbols.length > 0 ? getHistoricalAverages(arbSymbols, arbExchanges) : new Map();
+        const arbLines = [];
+        arbLines.push(chalk.white.bold(" Top Arb Opportunities"));
+        if (topArb.length > 0) {
+            //          SYMBOL   SPREAD   24h   TREND     7d     DIR
+            arbLines.push(chalk.gray(" " + "".padEnd(8) + "now".padEnd(9) + "24h".padEnd(7) + "".padEnd(9) + "7d".padEnd(7)));
+            for (const a of topArb) {
+                const spreadColor = a.maxSpreadAnnual >= 100 ? chalk.green.bold : a.maxSpreadAnnual >= 30 ? chalk.green : chalk.yellow;
+                const dir = `${exAbbr(a.shortExchange)}>${exAbbr(a.longExchange)}`;
+                const bestEx = a.rates.find(r => r.exchange === "hyperliquid")?.exchange ?? a.rates[0]?.exchange ?? "hyperliquid";
+                // 24h trend arrow
+                const history = getHistoricalRates(a.symbol, bestEx, h24, now);
+                let trend = "";
+                if (history.length >= 2) {
+                    const oldAnn = Math.abs(history[0].hourlyRate) * 8760 * 100;
+                    const newAnn = Math.abs(history[history.length - 1].hourlyRate) * 8760 * 100;
+                    const delta = newAnn - oldAnn;
+                    const abs = Math.abs(delta);
+                    trend = abs < 1 ? chalk.gray(`\u2500${abs.toFixed(0)}%`)
+                        : delta > 0 ? chalk.red(`\u25B2+${abs.toFixed(0)}%`)
+                            : chalk.green(`\u25BC-${abs.toFixed(0)}%`);
+                }
+                // 24h and 7d averages (annualized from hourly)
+                const avg = histAvgs.get(`${a.symbol}:${bestEx}`);
+                const avg24h = avg?.avg24h != null ? `${(Math.abs(avg.avg24h) * 8760 * 100).toFixed(0)}%` : "-";
+                const avg7d = avg?.avg7d != null ? `${(Math.abs(avg.avg7d) * 8760 * 100).toFixed(0)}%` : "-";
+                arbLines.push(` ${chalk.white.bold(a.symbol.padEnd(8))} ${spreadColor(`${a.maxSpreadAnnual.toFixed(1)}%`.padEnd(9))}${chalk.gray(avg24h.padEnd(7))}${trend.padEnd(9)}${chalk.gray(avg7d.padEnd(7))}${chalk.gray(dir)}`);
+            }
+        }
+        else {
+            arbLines.push(chalk.gray(" No opportunities above 5%"));
+        }
+        // Print layout — side-by-side if terminal is wide enough, else stacked
+        const stripAnsi = (s) => s.replace(/\u001b\[[0-9;]*m/g, "");
+        const termW = process.stdout.columns || 80;
+        const SIDE_BY_SIDE_MIN = 100; // 2 indent + 1 + 46 + 1 + 48 + 1
+        if (termW >= SIDE_BY_SIDE_MIN) {
+            const LEFT_W = 46;
+            const RIGHT_W = 48;
+            const maxLines = Math.max(balLines.length, arbLines.length);
+            console.log(`  ${"┌"}${"─".repeat(LEFT_W)}${"┬"}${"─".repeat(RIGHT_W)}${"┐"}`);
+            for (let i = 0; i < maxLines; i++) {
+                const left = balLines[i] ?? "";
+                const right = arbLines[i] ?? "";
+                const leftPad = LEFT_W - stripAnsi(left).length;
+                const rightPad = RIGHT_W - stripAnsi(right).length;
+                console.log(`  \u2502${left}${" ".repeat(Math.max(0, leftPad))}\u2502${right}${" ".repeat(Math.max(0, rightPad))}\u2502`);
+            }
+            console.log(`  ${"└"}${"─".repeat(LEFT_W)}${"┴"}${"─".repeat(RIGHT_W)}${"┘"}`);
+        }
+        else {
+            // Stacked layout for narrow terminals
+            const boxW = Math.min(termW - 4, 74); // 2 indent + 2 borders
+            const printBox = (lines) => {
+                console.log(`  ${"┌"}${"─".repeat(boxW)}${"┐"}`);
+                for (const line of lines) {
+                    const pad = boxW - stripAnsi(line).length;
+                    console.log(`  \u2502${line}${" ".repeat(Math.max(0, pad))}\u2502`);
+                }
+                console.log(`  ${"└"}${"─".repeat(boxW)}${"┘"}`);
+            };
+            printBox(balLines);
+            console.log();
+            printBox(arbLines);
+        }
+        // Positions
+        if (allPositions.length > 0) {
+            console.log(chalk.white.bold("\n  Positions"));
+            const posRows = allPositions.map(p => {
+                const sideColor = p.side === "long" ? chalk.green : chalk.red;
+                const notional = Math.abs(Number(p.size) * Number(p.markPrice));
+                const levStr = p.leverage > 0 ? `${p.leverage}x` : "-";
+                const warn = p.leverage >= 5 ? chalk.red(" \u26A0") : "";
+                return [
+                    chalk.white.bold(p.symbol.replace("-PERP", "")),
+                    chalk.gray(exAbbr(p.exchange)),
+                    sideColor(p.side.toUpperCase()),
+                    p.size,
+                    `$${formatUsd(p.entryPrice)}\u2192$${formatUsd(p.markPrice)}`,
+                    formatPnl(p.unrealizedPnl),
+                    `$${formatUsd(notional)}`,
+                    levStr + warn,
+                ];
+            });
+            console.log(makeTable(["Symbol", "Ex", "Side", "Size", "Entry\u2192Mark", "uPnL", "Notional", "Lev"], posRows));
+        }
+        else {
+            console.log(chalk.gray("\n  No open positions.\n"));
+        }
+    });
 });
-statusCmd._hidden = true;
 // Switch shared API URLs if --network testnet is used
 program.hook("preAction", () => {
     const network = program.opts().network;

package/dist/utils.d.ts

@@ -3,6 +3,8 @@ export declare function formatUsd(value: string | number): string;
 export declare function formatPnl(value: string | number): string;
 export declare function formatPercent(value: string | number): string;
 export declare function makeTable(head: string[], rows: string[][]): string;
+/** Render a sparkline from numeric values. Returns unicode bar chart string. */
+export declare function sparkline(values: number[], width?: number): string;
 export declare function printJson(data: unknown): void;
 export declare function errorAndExit(msg: string): never;
 /** Standard JSON response envelope */

package/dist/utils.js

@@ -96,6 +96,38 @@ function sanitizeValue(val) {
     }
     return val;
 }
+// ── Sparkline ──
+// Density-based shading — renders consistently across all terminal fonts
+// (height-based ▁▂▃▄▅▆▇█ looks identical in many monospace fonts)
+const SPARK_CHARS = [" ", "░", "▒", "▓", "█"];
+/** Render a sparkline from numeric values. Returns unicode bar chart string. */
+export function sparkline(values, width) {
+    if (values.length === 0)
+        return "";
+    const data = width && values.length > width ? downsample(values, width) : values;
+    const min = Math.min(...data);
+    const max = Math.max(...data);
+    const range = max - min;
+    if (range === 0)
+        return SPARK_CHARS[2].repeat(data.length);
+    return data.map(v => {
+        const idx = Math.round(((v - min) / range) * (SPARK_CHARS.length - 1));
+        return SPARK_CHARS[idx];
+    }).join("");
+}
+function downsample(values, targetLen) {
+    const bucketSize = values.length / targetLen;
+    const result = [];
+    for (let i = 0; i < targetLen; i++) {
+        const start = Math.floor(i * bucketSize);
+        const end = Math.floor((i + 1) * bucketSize);
+        let sum = 0;
+        for (let j = start; j < end; j++)
+            sum += values[j];
+        result.push(sum / (end - start));
+    }
+    return result;
+}
 // ── JSON Output ──
 const _isNdjson = () => process.argv.includes("--ndjson");
 export function printJson(data) {

package/package.json

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