perp-cli 0.15.0 → 0.16.0

package/dist/commands/market.js

@@ -1,15 +1,139 @@
-import { tapeSkippedOf } from "../exchanges/interface.js";
+import { sortByTime, tapeSkippedOf } from "../exchanges/interface.js";
 import { makeTable, formatUsd, formatPercent, printJson, jsonOk, jsonError, withJsonErrors, normalizeSymbolArg } from "../utils.js";
 import chalk from "chalk";
 import { PerpError } from "../errors.js";
 import { midDecimal } from "../exchanges/precision.js";
-import { hasPacificaSdk, isDexCapable, klinesNeedAuth } from "../exchanges/capabilities.js";
-import { getVenue, listVenuesWithRole, tryResolveVenueId, unofficialApiNote } from "../exchanges/venue.js";
+import { isDexCapable, klinesNeedAuth } from "../exchanges/capabilities.js";
+import { getVenue, listVenuesWithRole, tryResolveVenueId, unofficialApiNote, withFundingVerified } from "../exchanges/venue.js";
 import "../exchanges/venues/index.js";
-/** Venues with an adapter (market-data-only venues have none — see `perp arb scan`). */
-const EXCHANGES = listVenuesWithRole("account").map(v => v.id);
+/**
+ * Venues of the multi-venue `market list|prices` (no -e): every venue with the marketData role
+ * and a (public) adapter — market-data-only venues (TxFlow, Variational, GRVT, Extended) included.
+ * They were left out in 0.15.0 because the list was the account-role venues.
+ */
+export const MARKET_DATA_VENUES = listVenuesWithRole("marketData").filter(v => v.create !== null).map(v => v.id);
+/**
+ * `--limit` / `-l` / `--depth`: a positive integer, the same rule on every venue (parseInt took
+ * "abc" as NaN and "-5" as a negative slice). Anything else → INVALID_PARAMS before any request.
+ */
+export function parsePositiveIntArg(raw, flag) {
+    const t = raw.trim();
+    if (!/^\d+$/.test(t) || Number(t) < 1 || !Number.isSafeInteger(Number(t))) {
+        throw new PerpError("INVALID_PARAMS", `${flag} must be a positive integer (got "${raw}")`, { remediation: `Pass e.g. ${flag} 10` });
+    }
+    return Number(t);
+}
+/**
+ * Most order-book levels per side each venue serves (measured live 2026-10-19; the request size
+ * where the venue takes one): one rule for every venue — `--depth` above it is INVALID_PARAMS
+ * naming the max, never clamped or silently short. Absent = the full book (Extended).
+ */
+export const BOOK_DEPTH_MAX = {
+    hyperliquid: 20, pacifica: 10, lighter: 50, "lighter-rh": 50, aster: 50, arcus: 50, ondo: 50,
+    qfex: 20, txflow: 20, risex: 250, grvt: 500,
+};
+export function assertBookDepth(venue, depth) {
+    const id = tryResolveVenueId(venue);
+    const max = id === null ? undefined : BOOK_DEPTH_MAX[id];
+    if (max !== undefined && depth > max) {
+        throw new PerpError("INVALID_PARAMS", `--depth ${depth} exceeds ${venue}'s order book (max ${max} levels per side)`, {
+            exchange: venue, remediation: `Pass --depth 1..${max}`,
+        });
+    }
+}
+/**
+ * `--start` / `--end`: unix ms (digits) or an ISO-8601 date / time (`Date.parse`; "2026-10-18" is
+ * UTC midnight). parseInt("2026-10-18") read 2026 ms. Non-finite → INVALID_PARAMS.
+ */
+export function parseTimeArg(raw, flag) {
+    const t = raw.trim();
+    const ms = /^\d+$/.test(t) ? Number(t) : /^\d{4}-\d{2}-\d{2}/.test(t) ? Date.parse(t) : NaN;
+    // A unix-seconds value (10 digits today) read as ms lands in 1970: refused with a hint.
+    if (/^\d+$/.test(t) && ms < 1e11) {
+        throw new PerpError("INVALID_PARAMS", `${flag} ${raw} looks like unix seconds; pass milliseconds or an ISO date`, {
+            remediation: `Pass e.g. ${flag} ${t}000 or ${flag} 2026-10-18T00:00:00Z`,
+        });
+    }
+    if (!Number.isFinite(ms)) {
+        throw new PerpError("INVALID_PARAMS", `${flag} must be unix milliseconds or an ISO date (got "${raw}")`, {
+            remediation: `Pass e.g. ${flag} 1792368000000 or ${flag} 2026-10-18T00:00:00Z`,
+        });
+    }
+    return ms;
+}
+/**
+ * Bare market symbol of a CLI argument as `market info` matches it against getMarkets() rows:
+ * "btc-perp" → "BTC", Extended "BTC-USD" / "TSLA_24_5-USD" → "BTC" / "TSLA", TxFlow "BTC-USDC" → "BTC"
+ * (book / funding resolve these through the venue; info read the raw argument and missed them).
+ * HIP-3 "xyz:XYZ100" keeps its prefix.
+ */
+export function bareSymbolOf(arg) {
+    return normalizeSymbolArg(arg.trim()).replace(/-PERP$/, "").replace(/-(USD|USDC|USDT)$/, "").replace(/_24_5$/, "");
+}
+/**
+ * History order, one rule for every venue: trades and funding history newest first, candles
+ * oldest first (Aster / QFEX answered funding oldest first, GRVT trades oldest first). A stable
+ * copy — the adapter's array (and its non-enumerable tape metadata) is left as is.
+ */
+export function newestFirst(rows) {
+    return sortByTime(rows, "desc");
+}
+/** Human reason of a listed-but-untradable market, keyed on `status` (null when none is known). */
+const NOT_TRADABLE_REASON = {
+    nonUsdQuote: "non-USD quote — readable, not tradable through perp-cli",
+    offHours: "outside the underlying's trading hours",
+    reduceOnly: "reduce-only",
+    halted: "trading halted",
+};
+export function notTradableReason(m) {
+    if (m.tradable !== false)
+        return null;
+    if (typeof m.status === "string" && m.status !== "")
+        return NOT_TRADABLE_REASON[m.status] ?? m.status;
+    return "not tradable right now";
+}
+/** Symbol cell; a listed market that is not tradable is marked with its reason. */
+function symbolCell(m) {
+    const why = notTradableReason(m);
+    return why === null ? chalk.white.bold(m.symbol) : `${chalk.white.bold(m.symbol)} ${chalk.yellow(`(${why})`)}`;
+}
+/** Multi-venue human output: the footnote of every listed venue read through an unofficial API. */
+function printUnofficialNotes(venues) {
+    for (const ex of venues) {
+        const id = tryResolveVenueId(ex);
+        const note = id === null ? null : unofficialApiNote(getVenue(id));
+        if (note !== null)
+            console.log(chalk.yellow(`  * ${note}`));
+    }
+}
+/**
+ * meta.warnings for market rows whose fundingRate is null for a known reason (Lighter: the
+ * settled-rate snapshot could not be read) — the reason reaches --json, not only stderr.
+ */
+function fundingWarnings(adapters, rows = null) {
+    // Tied to the rows served: no warning next to rows that all carry a rate (a cached listing).
+    if (rows !== null && !rows.some(r => r.fundingRate === null))
+        return undefined;
+    const w = adapters.map(a => a.fundingWarning?.() ?? null).filter((x) => x !== null);
+    return w.length > 0 ? { warnings: w } : undefined;
+}
 /** null = venue does not publish the value → "-" (never rendered as $0). */
 const usdOrDash = (v) => (v === null ? chalk.gray("-") : `$${formatUsd(v)}`);
+/** Non-USD quote currency of a row (QFEX "SAMSUNG-KRW": quoteAsset "KRW"); null = USD or not stated. */
+const nonUsdQuoteOf = (m) => {
+    const q = m.quoteAsset;
+    return typeof q === "string" && q !== "USD" ? q : null;
+};
+/** A price of row `m` in its quote currency: "$1.23" for USD, "213,500 KRW" otherwise; null → "-". */
+const priceOrDash = (v, m) => {
+    const q = nonUsdQuoteOf(m);
+    return v === null ? chalk.gray("-") : q === null ? `$${formatUsd(v)}` : `${formatUsd(v)} ${q}`;
+};
+/** 24h volume: USD, or (no USD figure) the venue's quote-currency notional labelled with its currency. */
+const volumeCell = (m) => {
+    const local = m.volume24hQuote;
+    return m.volume24h === null && typeof local === "string" ? priceOrDash(local, m) : usdOrDash(m.volume24h);
+};
 /**
  * Funding cell. On a venue whose funding interval is per market (VenueDefinition.fundingRateBasis
  * "perMarket": Variational, Aster, GRVT) the raw rate is labelled with its interval ("+0.0079%/8h"), since
@@ -41,7 +165,7 @@ function formatOpenInterest(m, withUsd) {
     const mark = Number(m.markPrice);
     if (!withUsd || !Number.isFinite(oi) || !(mark > 0))
         return base;
-    return `${base} ${chalk.gray(`(≈ $${formatUsd(oi * mark)} at mark)`)}`;
+    return `${base} ${chalk.gray(`(≈ ${priceOrDash(String(oi * mark), m)} at mark)`)}`;
 }
 function printRfqQuotes(q, json) {
     if (json)
@@ -110,11 +234,11 @@ getAccountAdapter) {
         const explicitExchange = program.getOptionValueSource?.("exchange") === "cli";
         const HEADERS = ["Symbol", "Mark", "Index", "Funding", "24h Vol", "OI (base)", "Max Lev"];
         const marketRow = (m, perMarket = false) => [
-            chalk.white.bold(m.symbol),
-            `$${formatUsd(m.markPrice)}`,
-            usdOrDash(m.indexPrice),
+            symbolCell(m),
+            priceOrDash(m.markPrice, m),
+            priceOrDash(m.indexPrice, m),
             fundingCell(m, perMarket),
-            usdOrDash(m.volume24h),
+            volumeCell(m),
             formatOpenInterest(m, false),
             m.maxLeverage === null ? chalk.gray("-") : String(m.maxLeverage) + "x",
         ];
@@ -122,17 +246,17 @@ getAccountAdapter) {
         if (!explicitExchange && getAdapterForExchange) {
             const grouped = {};
             const errors = {};
-            await Promise.all(EXCHANGES.map(async (ex) => {
+            const listed = [];
+            await Promise.all(MARKET_DATA_VENUES.map(async (ex) => {
                 try {
                     const adapter = await getAdapterForExchange(ex);
                     grouped[ex] = await adapter.getMarkets();
+                    listed.push(adapter);
                     // --hip3: fetch HIP-3 dex markets
                     if (opts.hip3 && ex === "hyperliquid" && isDexCapable(adapter)) {
                         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();
+                            const markets = await adapter.forDex(d.name).getMarkets();
                             if (markets.length > 0)
                                 grouped[`hip3:${d.name}`] = markets;
                         }));
@@ -143,7 +267,7 @@ getAccountAdapter) {
                 }
             }));
             if (isJson()) {
-                return printJson(jsonOk({ exchanges: grouped, errors: Object.keys(errors).length > 0 ? errors : undefined }));
+                return printJson(jsonOk({ exchanges: Object.fromEntries(Object.entries(grouped).map(([ex, rows]) => [ex, withFundingVerified(ex, rows)])), errors: Object.keys(errors).length > 0 ? errors : undefined }, fundingWarnings(listed, Object.values(grouped).flat())));
             }
             // Per-exchange tables
             for (const [ex, markets] of Object.entries(grouped)) {
@@ -157,6 +281,7 @@ getAccountAdapter) {
             for (const [ex, msg] of Object.entries(errors)) {
                 console.log(chalk.gray(`  ${ex}: ${msg}`));
             }
+            printUnofficialNotes(Object.keys(grouped));
             return;
         }
         // Single exchange mode
@@ -167,18 +292,16 @@ getAccountAdapter) {
         if (opts.hip3 && isDexCapable(adapter)) {
             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();
+                const m = await adapter.forDex(d.name).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({ main: withFundingVerified(adapter.name, markets), hip3: Object.fromEntries(Object.entries(hip3).map(([d, rows]) => [d, withFundingVerified(adapter.name, rows)])) }));
             }
-            return printJson(jsonOk(markets));
+            return printJson(jsonOk(withFundingVerified(adapter.name, markets), fundingWarnings([adapter], markets)));
         }
         const perMarket = perMarketFunding(adapter.name);
         // Rows that carry an asset class (Extended: crypto / equity / etf / index / commodity / fx / preIpo) show it.
@@ -204,25 +327,27 @@ getAccountAdapter) {
         const explicitExchange = program.getOptionValueSource?.("exchange") === "cli";
         const PRICE_HEADERS = ["Symbol", "Mark", "Index", "Funding"];
         const priceRow = (m, perMarket = false) => [
-            chalk.white.bold(m.symbol),
-            `$${formatUsd(m.markPrice)}`,
-            usdOrDash(m.indexPrice),
+            symbolCell(m),
+            priceOrDash(m.markPrice, m),
+            priceOrDash(m.indexPrice, m),
             fundingCell(m, perMarket),
         ];
         if (!explicitExchange && getAdapterForExchange) {
             const grouped = {};
             const errors = {};
-            await Promise.all(EXCHANGES.map(async (ex) => {
+            const listed = [];
+            await Promise.all(MARKET_DATA_VENUES.map(async (ex) => {
                 try {
                     const adapter = await getAdapterForExchange(ex);
                     grouped[ex] = await adapter.getMarkets();
+                    listed.push(adapter);
                 }
                 catch (err) {
                     errors[ex] = err instanceof Error ? err.message : String(err);
                 }
             }));
             if (isJson()) {
-                return printJson(jsonOk({ exchanges: grouped, errors: Object.keys(errors).length > 0 ? errors : undefined }));
+                return printJson(jsonOk({ exchanges: Object.fromEntries(Object.entries(grouped).map(([ex, rows]) => [ex, withFundingVerified(ex, rows)])), errors: Object.keys(errors).length > 0 ? errors : undefined }, fundingWarnings(listed, Object.values(grouped).flat())));
             }
             for (const [ex, markets] of Object.entries(grouped)) {
                 if (markets.length === 0)
@@ -232,29 +357,15 @@ getAccountAdapter) {
             }
             for (const [ex, msg] of Object.entries(errors))
                 console.log(chalk.gray(`  ${ex}: ${msg}`));
+            printUnofficialNotes(Object.keys(grouped));
             return;
         }
         const adapter = await getAdapter();
-        if (hasPacificaSdk(adapter)) {
-            const sdk = adapter.sdk;
-            const prices = await sdk.getPrices();
-            if (isJson())
-                return printJson(jsonOk(prices));
-            const rows = prices.map((p) => [
-                chalk.white.bold(p.symbol),
-                `$${formatUsd(p.mark)}`,
-                `$${formatUsd(p.mid)}`,
-                `$${formatUsd(p.oracle)}`,
-                formatPercent(p.funding),
-            ]);
-            console.log(makeTable(["Symbol", "Mark", "Mid", "Oracle", "Funding"], rows));
-        }
-        else {
-            const markets = await adapter.getMarkets();
-            if (isJson())
-                return printJson(jsonOk(markets));
-            console.log(makeTable(PRICE_HEADERS, markets.map(m => priceRow(m, perMarketFunding(adapter.name)))));
-        }
+        // One normalized shape on every venue (Pacifica included — it printed the raw /info/prices rows).
+        const markets = await adapter.getMarkets();
+        if (isJson())
+            return printJson(jsonOk(withFundingVerified(adapter.name, markets), fundingWarnings([adapter], markets)));
+        console.log(makeTable(PRICE_HEADERS, markets.map(m => priceRow(m, perMarketFunding(adapter.name)))));
     });
     market
         .command("info <symbol>")
@@ -268,20 +379,25 @@ getAccountAdapter) {
             return void await withJsonErrors(isJson(), async () => {
                 const one = await single.call(adapter, symbol);
                 if (isJson())
-                    return printJson(jsonOk(one));
+                    return printJson(jsonOk(withFundingVerified(adapter.name, [one])[0]));
                 printMarketInfo(adapter.name, one);
             });
         }
         const markets = await adapter.getMarkets();
         const sym = symbol.toUpperCase();
+        const bare = bareSymbolOf(symbol).toUpperCase();
         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"
+            const sBare = s.replace(/-PERP$/, "");
+            return s === sym || sBare === sym || sBare === bare
+                || s.split(":").pop() === sym || s.split(":").pop() === bare; // HIP-3: "km:US500" matches "US500"
         });
         if (!m) {
             // Printed (envelope / Error + Remediation) and exit 1 via withJsonErrors.
             return void await withJsonErrors(isJson(), async () => {
+                const delistedErr = adapter.delistedError?.(symbol) ?? null;
+                if (delistedErr !== null)
+                    throw delistedErr;
                 const delisted = typeof adapter.delistedMessage === "function"
                     ? adapter.delistedMessage(symbol)
                     : null;
@@ -292,7 +408,7 @@ getAccountAdapter) {
             });
         }
         if (isJson())
-            return printJson(jsonOk(m));
+            return printJson(jsonOk(withFundingVerified(adapter.name, [m])[0], fundingWarnings([adapter], [m])));
         printMarketInfo(adapter.name, m);
     });
     market
@@ -300,15 +416,19 @@ getAccountAdapter) {
         .description("Show orderbook for a symbol")
         .option("-d, --depth <n>", "Number of levels", "10")
         .action(async (symbol, opts) => {
+        const depth = parsePositiveIntArg(opts.depth, "--depth");
         const adapter = await getAdapter();
         const sym = normalizeSymbolArg(symbol);
         // RFQ venue (Variational): no order book — the maker's indicative quotes, labelled as such.
         if (adapter.getRfqQuotes !== undefined)
             return printRfqQuotes(await adapter.getRfqQuotes(sym), isJson());
-        const book = await adapter.getOrderbook(sym);
+        // `depth` reaches venues that size the request by it (GRVT, RISEx); every answer is cut to
+        // `depth` levels per side — JSON included (it printed the venue's full book).
+        assertBookDepth(adapter.name, depth);
+        const full = await adapter.getOrderbook(sym, depth);
+        const book = { ...full, bids: full.bids.slice(0, depth), asks: full.asks.slice(0, depth) };
         if (isJson())
             return printJson(jsonOk(book));
-        const depth = parseInt(opts.depth);
         const asks = book.asks.slice(0, depth).reverse();
         const bids = book.bids.slice(0, depth);
         // Compute spread
@@ -329,21 +449,24 @@ getAccountAdapter) {
             return "█".repeat(len);
         };
         console.log(chalk.cyan.bold(`\n  Orderbook: ${sym} (${adapter.name})\n`));
-        console.log(chalk.gray("  Price          Size          Cum$              Depth"));
+        // A book with a non-USD quoteAsset (QFEX SAMSUNG-KRW) shows its currency, never a $.
+        const quote = nonUsdQuoteOf(book);
+        const money = (v) => priceOrDash(String(v), book);
+        console.log(chalk.gray(`  Price          Size          ${quote === null ? "Cum$          " : `Cum (${quote})`.padEnd(14)}    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)}`) +
+            console.log(chalk.red(`  ${formatUsd(p).padStart(12)}  ${String(a).padEnd(12)}  ${money(cumUsd).padEnd(quote === null ? 15 : 18)}`) +
                 chalk.red.dim(bar(askCums[i])));
         });
         // Spread line
         const spreadStr = spreadAbs > 0
-            ? `$${formatUsd(spreadAbs)} (${spreadPct.toFixed(3)}%)`
+            ? `${money(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)}`) +
+            console.log(chalk.green(`  ${formatUsd(p).padStart(12)}  ${String(a).padEnd(12)}  ${money(cumUsd).padEnd(quote === null ? 15 : 18)}`) +
                 chalk.green.dim(bar(bidCums[i])));
         });
         console.log();
@@ -351,11 +474,15 @@ getAccountAdapter) {
     market
         .command("trades <symbol>")
         .description("Recent trades for a symbol")
-        .option("--limit <n>", "Number of recent trades to show", "20")
+        .option("--limit <n>", "Number of recent trades to show (default: the venue's own default, within its cap)")
         .action(async (symbol, opts) => {
+        // No --limit → undefined: each adapter applies its own default within its venue cap, so a
+        // plain `market trades` never trips a cap (HL serves 10).
+        const limit = opts.limit === undefined ? undefined : parsePositiveIntArg(opts.limit, "--limit");
         const adapter = await getAdapter();
-        const trades = await adapter.getRecentTrades(normalizeSymbolArg(symbol), parseInt(opts.limit));
-        const skipped = tapeSkippedOf(trades);
+        const raw = await adapter.getRecentTrades(normalizeSymbolArg(symbol), limit);
+        const trades = newestFirst(raw);
+        const skipped = tapeSkippedOf(trades); // metadata survives the sort (sortByTime)
         if (isJson())
             return printJson(jsonOk(trades, skipped !== null ? { skippedRows: skipped } : undefined));
         if (skipped !== null)
@@ -377,31 +504,35 @@ getAccountAdapter) {
         .description("Funding rate history")
         .option("-l, --limit <n>", "Number of records", "10")
         .action(async (symbol, opts) => {
+        const limit = parsePositiveIntArg(opts.limit, "--limit");
         const adapter = await getAdapter();
         // A venue without a funding-history API (Variational): its current funding terms, labelled as such.
         if (adapter.getFundingTerms !== undefined)
             return printFundingTerms(await adapter.getFundingTerms(normalizeSymbolArg(symbol)), isJson());
-        const history = await adapter.getFundingHistory(normalizeSymbolArg(symbol), parseInt(opts.limit));
+        const history = newestFirst(await adapter.getFundingHistory(normalizeSymbolArg(symbol), limit));
         if (isJson())
             return printJson(jsonOk(history));
         if (history.length === 0) {
             console.log(chalk.gray("\n  No funding history.\n"));
             return;
         }
-        const hasOracle = history.some((h) => h.price != null && h.price !== "0" && h.price !== "");
+        // `price` is the venue's reference price of the print — oracle (Pacifica), mark (GRVT, Aster)
+        // or index (RISEx) — so the column is "Price", not "Oracle"; each rate shows its interval.
+        const hasPrice = history.some((h) => h.price != null && h.price !== "0" && h.price !== "");
         const rows = history.map((h) => {
             const base = [
                 new Date(h.time).toLocaleString(),
-                formatPercent(h.rate),
+                h.rate === null ? chalk.gray(h.marketClosed === true ? "market closed" : "N/A") : formatPercent(h.rate),
+                h.intervalHours === null ? chalk.gray("-") : `${h.intervalHours}h`,
             ];
-            if (hasOracle)
+            if (hasPrice)
                 base.push(h.price != null ? `$${formatUsd(h.price)}` : chalk.gray("n/a"));
             return base;
         });
-        const headers = hasOracle ? ["Time", "Funding Rate", "Oracle"] : ["Time", "Funding Rate"];
+        const headers = hasPrice ? ["Time", "Funding Rate", "Interval", "Price"] : ["Time", "Funding Rate", "Interval"];
         console.log(makeTable(headers, rows));
-        if (!hasOracle)
-            console.log(chalk.gray("  Note: Oracle price not available for this exchange.\n"));
+        if (!hasPrice)
+            console.log(chalk.gray("  Note: no reference price published with this venue's funding prints.\n"));
     });
     market
         .command("mid <symbol>")
@@ -448,16 +579,22 @@ getAccountAdapter) {
     market
         .command("kline <symbol> <interval>")
         .description("Kline/candlestick data (intervals: 1m,5m,15m,1h,4h,1d,...)")
-        .option("--start <ts>", "Start time (unix ms)")
-        .option("--end <ts>", "End time (unix ms)")
+        .option("--start <ts>", "Start time (unix ms or ISO date, e.g. 2026-10-18T00:00:00Z)")
+        .option("--end <ts>", "End time (unix ms or ISO date)")
         .action(async (symbol, interval, opts) => {
         const publicAdapter = await getAdapter();
         // A venue whose candles endpoint is authenticated (Ondo) is read with the registered key.
         const adapter = getAccountAdapter !== undefined && klinesNeedAuth(publicAdapter) ? await getAccountAdapter() : publicAdapter;
         const now = Date.now();
-        const startTime = opts.start ? parseInt(opts.start) : now - 24 * 60 * 60 * 1000;
-        const endTime = opts.end ? parseInt(opts.end) : now;
-        const klines = await adapter.getKlines(normalizeSymbolArg(symbol), interval, startTime, endTime);
+        const startTime = opts.start !== undefined ? parseTimeArg(opts.start, "--start") : now - 24 * 60 * 60 * 1000;
+        const endTime = opts.end !== undefined ? parseTimeArg(opts.end, "--end") : now;
+        if (startTime > endTime) {
+            throw new PerpError("INVALID_PARAMS", `--start (${new Date(startTime).toISOString()}) is after --end (${new Date(endTime).toISOString()})`, {
+                remediation: "Pass --start before --end",
+            });
+        }
+        // Candles oldest first (ascending open time) on every venue.
+        const klines = sortByTime(await adapter.getKlines(normalizeSymbolArg(symbol), interval, startTime, endTime), "asc");
         if (isJson())
             return printJson(jsonOk(klines));
         if (klines.length === 0) {
@@ -467,10 +604,11 @@ getAccountAdapter) {
         // ISO (UTC) candle open times — one format for every venue, independent of the host locale.
         const rows = klines.slice(-20).map((k) => [
             new Date(k.time).toISOString(),
-            `$${formatUsd(k.open)}`,
-            `$${formatUsd(k.high)}`,
-            `$${formatUsd(k.low)}`,
-            `$${formatUsd(k.close)}`,
+            // A row with a non-USD quoteAsset (QFEX SAMSUNG-KRW) prints its currency, never a $.
+            priceOrDash(k.open, k),
+            priceOrDash(k.high, k),
+            priceOrDash(k.low, k),
+            priceOrDash(k.close, k),
             k.volume === null ? chalk.gray("-") : k.volume,
             k.trades === null ? chalk.gray("-") : String(k.trades),
         ]);
@@ -501,7 +639,8 @@ getAccountAdapter) {
             const rows = dexes.map(d => [
                 chalk.white.bold(d.name),
                 chalk.gray(d.deployer ? d.deployer.slice(0, 6) + "..." + d.deployer.slice(-4) : "-"),
-                String(d.assets.length),
+                // Live (non-delisted) assets; a dex whose every asset is delisted is marked as such.
+                d.delisted === true ? chalk.gray("delisted") : String(d.assets.length),
                 d.assets.slice(0, 5).join(", ") + (d.assets.length > 5 ? ` +${d.assets.length - 5}` : ""),
             ]);
             console.log(makeTable(["DEX", "Deployer", "Assets", "Markets"], rows));
@@ -510,13 +649,37 @@ getAccountAdapter) {
         });
     });
 }
+/**
+ * Why a listed market is not tradable, from the row's `status` when the venue states it (QFEX
+ * "nonUsdQuote", Ondo "closed" / "reduceOnly"); the generic off-hours text only when it does not.
+ * null = tradable or no tradability flag.
+ */
+export function notTradableNote(m) {
+    const r = m;
+    if (r.tradable !== false)
+        return null;
+    if (r.status === "nonUsdQuote")
+        return `Read-only in perp-cli: quoted in ${typeof r.quoteAsset === "string" ? r.quoteAsset : "a non-USD currency"} (orders, sizing and risk limits are USD-only).`;
+    if (r.status === "closed")
+        return "Not tradable: the venue has closed this market to new trading.";
+    if (r.status === "reduceOnly")
+        return "Reduce-only on the venue: positions can be closed, not opened.";
+    return "Not tradable right now (off-hours, reduce-only or halted on the venue).";
+}
 function printMarketInfo(venue, m) {
     console.log(chalk.cyan.bold(`\n  ${m.symbol} on ${venue}\n`));
-    console.log(`  Mark Price:     $${formatUsd(m.markPrice)}`);
-    console.log(`  Index Price:    ${usdOrDash(m.indexPrice)}`);
+    const note = notTradableNote(m);
+    if (note !== null)
+        console.log(chalk.yellow(`  ${note}`));
+    console.log(`  Mark Price:     ${priceOrDash(m.markPrice, m)}`);
+    console.log(`  Index Price:    ${priceOrDash(m.indexPrice, m)}`);
     // Per-market funding interval (GRVT 4h / 8h, Variational, Aster): the rate carries its interval.
     console.log(`  Funding Rate:   ${fundingCell(m, perMarketFunding(venue))}`);
-    console.log(`  24h Volume:     ${usdOrDash(m.volume24h)}`);
+    // A venue whose rate is unverified (QFEX) labels it on the row.
+    const fundingNote = m.fundingNote;
+    if (typeof fundingNote === "string")
+        console.log(chalk.yellow(`                  ${fundingNote}`));
+    console.log(`  24h Volume:     ${volumeCell(m)}`);
     console.log(`  Open Interest:  ${formatOpenInterest(m, true)}`);
     console.log(`  Max Leverage:   ${m.maxLeverage === null ? chalk.gray("-") : `${m.maxLeverage}x`}`);
     console.log();

package/dist/commands/options.d.ts

@@ -7,3 +7,8 @@
  */
 import { Command } from "commander";
 export declare function registerOptionsCommands(program: Command, isJson: () => boolean): void;
+/**
+ * Greeks by significant figures (3), not fixed decimals: toFixed(3) printed theta / vega of cheap
+ * options as -0.000. Derive publishes greeks at a 1e-5 resolution, so "0" can mean |x| < 0.00001.
+ */
+export declare function fmtGreek(v: string | null | undefined): string;

package/dist/commands/options.js

@@ -90,8 +90,21 @@ function fmtPx(v) {
 function fmtPct(v) {
     return v === null ? dash : `${(Number(v) * 100).toFixed(1)}%`;
 }
-function fmtGreek(v) {
-    return v === null || v === undefined ? dash : Number(v).toFixed(3);
+/**
+ * Greeks by significant figures (3), not fixed decimals: toFixed(3) printed theta / vega of cheap
+ * options as -0.000. Derive publishes greeks at a 1e-5 resolution, so "0" can mean |x| < 0.00001.
+ */
+export function fmtGreek(v) {
+    if (v === null || v === undefined)
+        return dash;
+    const n = Number(v);
+    if (!Number.isFinite(n))
+        return dash;
+    if (n === 0)
+        return "0";
+    // Fixed notation, 3 significant figures (String() switches to 1.23e-7 below 1e-6).
+    const decimals = Math.max(0, 2 - Math.floor(Math.log10(Math.abs(n))));
+    return n.toFixed(Math.min(decimals, 20)).replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "");
 }
 function sideCells(q) {
     if (q === null)
@@ -130,5 +143,9 @@ function printQuote(q) {
         ["rho", fmtGreek(q.greeks?.rho), "OI", q.openInterest],
         ["24h contracts", q.stats24h.contracts, "24h trades", String(q.stats24h.trades)],
     ];
-    console.log(makeTable(["field", "value", "field", "value"], rows) + "\n");
+    console.log(makeTable(["field", "value", "field", "value"], rows));
+    if (q.venue === "derive")
+        console.log(chalk.gray("  Greeks: 3 significant figures; Derive publishes them at a 1e-5 resolution (0 = |value| < 0.00001).\n"));
+    else
+        console.log();
 }