perp-cli 0.14.2 → 0.15.0

package/dist/commands/manage.js

@@ -99,9 +99,17 @@ export function registerWalletManageCommands(parent, getAdapter, isJson, getPaci
         .description("Create a new vault (lake)")
         .option("--manager <address>", "Manager address (omit to create a fresh vault with no manager)")
         .option("--nickname <name>", "Display name for the vault")
-        .option("--initial-deposit <amount>", "Seed deposit in USDC from the creator")
+        .option("--initial-deposit <amount>", "Seed deposit in USDC from the creator (master-signed only: refused with an agent key)")
         .action(async (opts) => {
         const a = await pac();
+        // A seed deposit moves funds into a vault like `vault deposit`: master-signed only (an agent
+        // key must not be able to fund a vault it names the manager of).
+        if (opts.initialDeposit !== undefined && a.activeSignerTier !== "master" && a.activeSignerTier !== "pk") {
+            throw new PerpError("NO_SIGNER_AVAILABLE", "A vault seed deposit (--initial-deposit) must be signed by the master wallet, not the agent key", {
+                exchange: "pacifica",
+                remediation: "Re-run with --no-agent (master wallet), or create the vault without --initial-deposit and deposit with: perp -e pacifica vault deposit <vault> <amount>",
+            });
+        }
         const result = await a.sdk.createLake({
             manager: opts.manager === undefined ? null : opts.manager,
             nickname: opts.nickname === undefined ? null : opts.nickname,
@@ -112,26 +120,20 @@ export function registerWalletManageCommands(parent, getAdapter, isJson, getPaci
         console.log(chalk.green(`\n  Vault created.\n`));
         console.log(JSON.stringify(result, null, 2));
     });
-    lake
-        .command("deposit <lake> <amount>")
-        .description("Deposit USDC into a vault (<lake> = vault address)")
-        .action(async (lakeAddress, amount) => {
-        const a = await pac();
-        const result = await a.sdk.depositToLake({ lake: lakeAddress, amount: parsePositiveDecimal(amount, "deposit amount") }, a.publicKey, a.signer);
-        if (isJson())
-            return printJson(jsonOk(result));
-        console.log(chalk.green(`\n  Deposited $${amount} to vault ${lakeAddress}.\n`));
-    });
-    lake
-        .command("withdraw <lake> <shares>")
-        .description("Redeem vault shares (<lake> = vault address, <shares> = number of shares, not USDC)")
-        .action(async (lakeAddress, shares) => {
-        const a = await pac();
-        const result = await a.sdk.withdrawFromLake({ lake: lakeAddress, shares: parsePositiveDecimal(shares, "shares") }, a.publicKey, a.signer);
-        if (isJson())
-            return printJson(jsonOk(result));
-        console.log(chalk.green(`\n  Redeemed ${shares} shares from vault ${lakeAddress}.\n`));
-    });
+    // deposit / withdraw moved to the validated path (`perp -e pacifica vault deposit|withdraw`):
+    // nickname / address resolution, documented limits, --dry-run, unknown-outcome handling, and a
+    // master-only vault deposit. These stubs refuse before any key is loaded or anything is signed.
+    for (const [sub, args, target] of [["deposit", "<lake> <amount>", "vault deposit <vault> <amount>"], ["withdraw", "<lake> <shares>", "vault withdraw <vault> <shares>|--all"]]) {
+        lake
+            .command(`${sub} ${args}`)
+            .description(`Moved: use perp -e pacifica ${target} (validated, supports --dry-run)`)
+            .action(() => {
+            throw new PerpError("INVALID_PARAMS", `wallet manage lake ${sub} was replaced by: perp -e pacifica ${target}`, {
+                exchange: "pacifica",
+                remediation: `Run: perp -e pacifica --dry-run ${target} — then without --dry-run (nothing was signed or sent)`,
+            });
+        });
+    }
     // Pacifica builder-OWNER tools. A user's builder approval / revoke / status is
     // `perp wallet builder approve|revoke|status <venue>` (settings builder.<venue>).
     const builder = manage.command("builder").description("Pacifica builder-owner tools (overview, trades, leaderboard, update-fee). Approve / revoke / status: perp wallet builder");

package/dist/commands/market.js

@@ -1,33 +1,122 @@
-import { makeTable, formatUsd, formatPercent, printJson, jsonOk, jsonError, withJsonErrors } from "../utils.js";
+import { 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 { listVenuesWithRole } from "../exchanges/venue.js";
+import { getVenue, listVenuesWithRole, tryResolveVenueId, unofficialApiNote } 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);
 /** null = venue does not publish the value → "-" (never rendered as $0). */
 const usdOrDash = (v) => (v === null ? chalk.gray("-") : `$${formatUsd(v)}`);
+/**
+ * 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
+ * the rows of one table cover different periods.
+ */
+function fundingCell(m, perMarket) {
+    if (m.fundingRate == null)
+        return chalk.gray("N/A");
+    const hours = perMarket ? m.fundingHours ?? null : null;
+    return hours === null ? formatPercent(m.fundingRate) : `${formatPercent(m.fundingRate)}${chalk.gray(`/${hours}h`)}`;
+}
+/** True when `venueName` is a registered venue whose funding interval is per market. */
+function perMarketFunding(venueName) {
+    const id = tryResolveVenueId(venueName);
+    return id !== null && getVenue(id).fundingRateBasis === "perMarket";
+}
+/** Base asset of a market symbol: "BTC-PERP" → "BTC", "xyz:XYZ100" → "XYZ100". */
+const baseAssetOf = (symbol) => symbol.split(":").pop().replace(/-PERP$/i, "");
+/**
+ * Open interest is published in BASE-asset units by every venue (ExchangeMarketInfo.openInterest),
+ * so it is shown as "<n> <BASE>" — never with a "$". `withUsd` adds the notional at the mark
+ * price, labelled as such; null (not published) → "-".
+ */
+function formatOpenInterest(m, withUsd) {
+    if (m.openInterest === null)
+        return chalk.gray("-");
+    const oi = Number(m.openInterest);
+    const base = `${Number.isFinite(oi) ? oi.toLocaleString("en-US", { maximumFractionDigits: 4 }) : m.openInterest} ${baseAssetOf(m.symbol)}`;
+    const mark = Number(m.markPrice);
+    if (!withUsd || !Number.isFinite(oi) || !(mark > 0))
+        return base;
+    return `${base} ${chalk.gray(`(≈ $${formatUsd(oi * mark)} at mark)`)}`;
+}
+function printRfqQuotes(q, json) {
+    if (json)
+        return printJson(jsonOk(q));
+    console.log(chalk.cyan.bold(`\n  RFQ quotes: ${q.ticker} (${q.venue}) — not an order book\n`));
+    console.log(`  Mark: $${formatUsd(q.markPrice)}   Base spread: ${q.baseSpreadBps === null ? chalk.gray("-") : `${Number(q.baseSpreadBps).toFixed(2)} bps`}   Quoted at: ${q.updatedAt ?? chalk.gray("-")}`);
+    if (q.quotes.length === 0) {
+        console.log(chalk.gray("\n  No quotes published right now (the market may be closed).\n"));
+    }
+    else {
+        console.log(makeTable(["Size", "Bid", "Ask", "Spread"], q.quotes.map(t => {
+            const bid = Number(t.bid);
+            const ask = Number(t.ask);
+            const mid = (bid + ask) / 2;
+            return [
+                t.notionalUsd === null ? "min order" : `$${formatUsd(t.notionalUsd)}`,
+                chalk.green(`$${formatUsd(t.bid)}`),
+                chalk.red(`$${formatUsd(t.ask)}`),
+                mid > 0 ? `${((ask - bid) / mid * 10_000).toFixed(2)} bps` : chalk.gray("-"),
+            ];
+        })));
+    }
+    console.log(chalk.gray(`  ${q.note}\n`));
+}
+function printFundingTerms(t, json) {
+    if (json)
+        return printJson(jsonOk(t));
+    console.log(chalk.cyan.bold(`\n  Funding: ${t.ticker} (${t.venue}) — current terms, no history published\n`));
+    if (t.swap !== null) {
+        const row = (label, r) => r === null
+            ? [label, chalk.gray("-"), chalk.gray("-"), chalk.gray("-"), chalk.gray("-")]
+            : [label, formatPercent(r.intervalLong), formatPercent(r.intervalShort), formatPercent(r.annualizedLong), formatPercent(r.annualizedShort)];
+        console.log(makeTable(["Payment", "Long / day", "Short / day", "Long APR", "Short APR"], [row("last applied", t.swap.last), row("next", t.swap.next)]));
+    }
+    else {
+        console.log(`  Rate kind:      ${t.rateKind ?? chalk.gray("-")}`);
+        console.log(`  Interval:       ${t.intervalHours === null ? chalk.gray("-") : `${t.intervalHours}h`}`);
+        console.log(`  Per interval:   ${t.intervalRate === null ? chalk.gray("N/A") : formatPercent(t.intervalRate)}`);
+        console.log(`  Hourly:         ${t.hourlyRate === null ? chalk.gray("N/A") : formatPercent(t.hourlyRate)}`);
+        console.log(`  APR:            ${t.annualizedPct === null ? chalk.gray("N/A") : `${t.annualizedPct.toFixed(2)}%`}`);
+    }
+    console.log(`  Next funding:   ${t.nextFundingTime === null ? chalk.gray("-") : new Date(t.nextFundingTime).toLocaleString()}`);
+    console.log(chalk.gray(`  ${t.note}\n`));
+}
 export function registerMarketCommands(program, getAdapter, isJson, getAdapterForExchange, 
 /** Credentialed adapter of the selected venue — for market data the venue serves only to an authenticated account. */
 getAccountAdapter) {
     const market = program.command("market").description("Market data commands");
+    // Human output for a venue read through an UNOFFICIAL API carries a footnote (JSON rows carry venueApi).
+    market.hook("postAction", () => {
+        if (isJson())
+            return;
+        const raw = program.opts().exchange;
+        const id = raw === undefined ? null : tryResolveVenueId(raw);
+        if (id === null)
+            return;
+        const note = unofficialApiNote(getVenue(id));
+        if (note !== null)
+            console.log(chalk.yellow(`  * ${note}\n`));
+    });
     market
         .command("list")
         .description("List all available markets")
         .option("--hip3", "Include HIP-3 dex markets (Hyperliquid)")
         .action(async (opts) => {
         const explicitExchange = program.getOptionValueSource?.("exchange") === "cli";
-        const HEADERS = ["Symbol", "Mark", "Index", "Funding", "24h Vol", "OI", "Max Lev"];
-        const marketRow = (m) => [
+        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),
-            m.fundingRate != null ? formatPercent(m.fundingRate) : chalk.gray("N/A"),
+            fundingCell(m, perMarket),
             usdOrDash(m.volume24h),
-            usdOrDash(m.openInterest),
-            String(m.maxLeverage) + "x",
+            formatOpenInterest(m, false),
+            m.maxLeverage === null ? chalk.gray("-") : String(m.maxLeverage) + "x",
         ];
         // Multi-exchange mode
         if (!explicitExchange && getAdapterForExchange) {
@@ -63,7 +152,7 @@ getAccountAdapter) {
                 const isHip3 = ex.startsWith("hip3:");
                 const label = isHip3 ? chalk.magenta.bold(`  HIP-3: ${ex.slice(5)}`) : chalk.cyan.bold(`  ${ex.toUpperCase()}`);
                 console.log(`\n${label} ${chalk.gray(`(${markets.length} markets)`)}`);
-                console.log(makeTable(HEADERS, markets.map(marketRow)));
+                console.log(makeTable(HEADERS, markets.map(m => marketRow(m))));
             }
             for (const [ex, msg] of Object.entries(errors)) {
                 console.log(chalk.gray(`  ${ex}: ${msg}`));
@@ -91,10 +180,21 @@ getAccountAdapter) {
             }
             return printJson(jsonOk(markets));
         }
-        console.log(makeTable(HEADERS, markets.map(marketRow)));
+        const perMarket = perMarketFunding(adapter.name);
+        // Rows that carry an asset class (Extended: crypto / equity / etf / index / commodity / fx / preIpo) show it.
+        const classOf = (m) => {
+            const c = m.assetClass;
+            return typeof c === "string" ? c : null;
+        };
+        if (markets.length > 0 && markets.every(m => classOf(m) !== null)) {
+            console.log(makeTable([...HEADERS, "Class"], markets.map(m => [...marketRow(m, perMarket), classOf(m)])));
+        }
+        else {
+            console.log(makeTable(HEADERS, markets.map(m => marketRow(m, perMarket))));
+        }
         for (const [dex, m] of Object.entries(hip3)) {
             console.log(chalk.magenta.bold(`\n  HIP-3: ${dex}`) + chalk.gray(` (${m.length} markets)`));
-            console.log(makeTable(HEADERS, m.map(marketRow)));
+            console.log(makeTable(HEADERS, m.map(x => marketRow(x))));
         }
     });
     market
@@ -103,11 +203,11 @@ getAccountAdapter) {
         .action(async () => {
         const explicitExchange = program.getOptionValueSource?.("exchange") === "cli";
         const PRICE_HEADERS = ["Symbol", "Mark", "Index", "Funding"];
-        const priceRow = (m) => [
+        const priceRow = (m, perMarket = false) => [
             chalk.white.bold(m.symbol),
             `$${formatUsd(m.markPrice)}`,
             usdOrDash(m.indexPrice),
-            m.fundingRate != null ? formatPercent(m.fundingRate) : chalk.gray("N/A"),
+            fundingCell(m, perMarket),
         ];
         if (!explicitExchange && getAdapterForExchange) {
             const grouped = {};
@@ -128,7 +228,7 @@ getAccountAdapter) {
                 if (markets.length === 0)
                     continue;
                 console.log(chalk.cyan.bold(`\n  ${ex.toUpperCase()}`) + chalk.gray(` (${markets.length} markets)`));
-                console.log(makeTable(PRICE_HEADERS, markets.map(priceRow)));
+                console.log(makeTable(PRICE_HEADERS, markets.map(m => priceRow(m))));
             }
             for (const [ex, msg] of Object.entries(errors))
                 console.log(chalk.gray(`  ${ex}: ${msg}`));
@@ -153,7 +253,7 @@ getAccountAdapter) {
             const markets = await adapter.getMarkets();
             if (isJson())
                 return printJson(jsonOk(markets));
-            console.log(makeTable(PRICE_HEADERS, markets.map(priceRow)));
+            console.log(makeTable(PRICE_HEADERS, markets.map(m => priceRow(m, perMarketFunding(adapter.name)))));
         }
     });
     market
@@ -161,6 +261,17 @@ getAccountAdapter) {
         .description("Detailed info for a single market")
         .action(async (symbol) => {
         const adapter = await getAdapter();
+        // A venue that serves one market directly (GRVT: one ticker + one margin-rules read instead
+        // of the whole fan-out) answers here; SYMBOL_NOT_FOUND comes from its own directory.
+        const single = adapter.getMarketInfo;
+        if (typeof single === "function") {
+            return void await withJsonErrors(isJson(), async () => {
+                const one = await single.call(adapter, symbol);
+                if (isJson())
+                    return printJson(jsonOk(one));
+                printMarketInfo(adapter.name, one);
+            });
+        }
         const markets = await adapter.getMarkets();
         const sym = symbol.toUpperCase();
         const m = markets.find((mk) => {
@@ -169,21 +280,20 @@ getAccountAdapter) {
                 || s.split(":").pop() === sym; // HIP-3: "km:US500" matches "US500"
         });
         if (!m) {
-            if (isJson())
-                return printJson(jsonError("SYMBOL_NOT_FOUND", `Market ${sym} not found`));
-            console.log(chalk.red(`\n  Market "${sym}" not found.\n`));
-            return process.exit(1);
+            // Printed (envelope / Error + Remediation) and exit 1 via withJsonErrors.
+            return void await withJsonErrors(isJson(), async () => {
+                const delisted = typeof adapter.delistedMessage === "function"
+                    ? adapter.delistedMessage(symbol)
+                    : null;
+                throw new PerpError("SYMBOL_NOT_FOUND", delisted ?? `Market ${normalizeSymbolArg(symbol)} not found on ${adapter.name}`, {
+                    exchange: adapter.name,
+                    remediation: `List markets: perp -e ${adapter.name} market list`,
+                });
+            });
         }
         if (isJson())
             return printJson(jsonOk(m));
-        console.log(chalk.cyan.bold(`\n  ${m.symbol} on ${adapter.name}\n`));
-        console.log(`  Mark Price:     $${formatUsd(m.markPrice)}`);
-        console.log(`  Index Price:    ${usdOrDash(m.indexPrice)}`);
-        console.log(`  Funding Rate:   ${m.fundingRate != null ? formatPercent(m.fundingRate) : chalk.gray("N/A")}`);
-        console.log(`  24h Volume:     ${usdOrDash(m.volume24h)}`);
-        console.log(`  Open Interest:  ${usdOrDash(m.openInterest)}`);
-        console.log(`  Max Leverage:   ${m.maxLeverage}x`);
-        console.log();
+        printMarketInfo(adapter.name, m);
     });
     market
         .command("book <symbol>")
@@ -191,7 +301,11 @@ getAccountAdapter) {
         .option("-d, --depth <n>", "Number of levels", "10")
         .action(async (symbol, opts) => {
         const adapter = await getAdapter();
-        const book = await adapter.getOrderbook(symbol.toUpperCase());
+        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);
         if (isJson())
             return printJson(jsonOk(book));
         const depth = parseInt(opts.depth);
@@ -214,7 +328,7 @@ getAccountAdapter) {
             const len = maxCum > 0 ? Math.round((cum / maxCum) * BAR_WIDTH) : 0;
             return "█".repeat(len);
         };
-        console.log(chalk.cyan.bold(`\n  Orderbook: ${symbol.toUpperCase()} (${adapter.name})\n`));
+        console.log(chalk.cyan.bold(`\n  Orderbook: ${sym} (${adapter.name})\n`));
         console.log(chalk.gray("  Price          Size          Cum$              Depth"));
         console.log(chalk.gray("  " + "─".repeat(60)));
         asks.forEach(([p, a], i) => {
@@ -240,9 +354,12 @@ getAccountAdapter) {
         .option("--limit <n>", "Number of recent trades to show", "20")
         .action(async (symbol, opts) => {
         const adapter = await getAdapter();
-        const trades = await adapter.getRecentTrades(symbol.toUpperCase(), parseInt(opts.limit));
+        const trades = await adapter.getRecentTrades(normalizeSymbolArg(symbol), parseInt(opts.limit));
+        const skipped = tapeSkippedOf(trades);
         if (isJson())
-            return printJson(jsonOk(trades));
+            return printJson(jsonOk(trades, skipped !== null ? { skippedRows: skipped } : undefined));
+        if (skipped !== null)
+            console.log(chalk.yellow(`  ${skipped.count} tape row(s) skipped: ${skipped.reason}`));
         if (trades.length === 0) {
             console.log(chalk.gray("\n  No recent trades.\n"));
             return;
@@ -261,7 +378,10 @@ getAccountAdapter) {
         .option("-l, --limit <n>", "Number of records", "10")
         .action(async (symbol, opts) => {
         const adapter = await getAdapter();
-        const history = await adapter.getFundingHistory(symbol.toUpperCase(), parseInt(opts.limit));
+        // 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));
         if (isJson())
             return printJson(jsonOk(history));
         if (history.length === 0) {
@@ -287,7 +407,7 @@ getAccountAdapter) {
         .command("mid <symbol>")
         .description("Get mid price for a single symbol (fast)")
         .action(async (symbol) => {
-        const sym = symbol.toUpperCase();
+        const sym = normalizeSymbolArg(symbol);
         // withJsonErrors: every failure (incl. an empty book) is an error envelope AND exit code 1.
         await withJsonErrors(isJson(), async () => {
             const adapter = await getAdapter();
@@ -337,21 +457,22 @@ getAccountAdapter) {
         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(symbol.toUpperCase(), interval, startTime, endTime);
+        const klines = await adapter.getKlines(normalizeSymbolArg(symbol), interval, startTime, endTime);
         if (isJson())
             return printJson(jsonOk(klines));
         if (klines.length === 0) {
             console.log(chalk.gray("\n  No kline data.\n"));
             return;
         }
+        // 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).toLocaleString(),
+            new Date(k.time).toISOString(),
             `$${formatUsd(k.open)}`,
             `$${formatUsd(k.high)}`,
             `$${formatUsd(k.low)}`,
             `$${formatUsd(k.close)}`,
-            k.volume,
-            String(k.trades),
+            k.volume === null ? chalk.gray("-") : k.volume,
+            k.trades === null ? chalk.gray("-") : String(k.trades),
         ]);
         console.log(makeTable(["Time", "Open", "High", "Low", "Close", "Volume", "Trades"], rows));
     });
@@ -389,3 +510,14 @@ getAccountAdapter) {
         });
     });
 }
+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)}`);
+    // 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)}`);
+    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

@@ -0,0 +1,9 @@
+/**
+ * `perp options` — read-only options market data (`-e derive`).
+ *
+ * Public, keyless reads through the options venue registry (src/exchanges/options-venues.ts);
+ * no orders, no account. JSON shapes: src/exchanges/options-interface.ts (`schema: 1`).
+ * The venue is the root `-e`; a perp venue there (or no `-e`) is CAPABILITY_UNSUPPORTED.
+ */
+import { Command } from "commander";
+export declare function registerOptionsCommands(program: Command, isJson: () => boolean): void;

package/dist/commands/options.js

@@ -0,0 +1,134 @@
+/**
+ * `perp options` — read-only options market data (`-e derive`).
+ *
+ * Public, keyless reads through the options venue registry (src/exchanges/options-venues.ts);
+ * no orders, no account. JSON shapes: src/exchanges/options-interface.ts (`schema: 1`).
+ * The venue is the root `-e`; a perp venue there (or no `-e`) is CAPABILITY_UNSUPPORTED.
+ */
+import chalk from "chalk";
+import { networkOf } from "../cli-flags.js";
+import { PerpError } from "../errors.js";
+import { getOptionsVenue, listOptionsVenueIds } from "../exchanges/options-venues.js";
+import { makeTable, printJson, jsonOk } from "../utils.js";
+export function registerOptionsCommands(program, isJson) {
+    const options = program
+        .command("options")
+        .description(`Options market data, read-only (-e ${listOptionsVenueIds().join(" | -e ")}): expiries, chain, greeks, IV`);
+    async function venue() {
+        if (program.getOptionValueSource("exchange") !== "cli") {
+            throw new PerpError("CAPABILITY_UNSUPPORTED", "perp options needs an options venue in -e", {
+                remediation: `Use -e ${listOptionsVenueIds()[0]} (e.g. perp -e ${listOptionsVenueIds()[0]} options expiries ETH)`,
+            });
+        }
+        return getOptionsVenue(String(program.opts().exchange), networkOf(program));
+    }
+    // ── options underlyings ──────────────────────────────────────────────────
+    options
+        .command("underlyings")
+        .description("List underlyings that have options on the venue")
+        .action(async () => {
+        const data = await (await venue()).listUnderlyings();
+        if (isJson())
+            return printJson(jsonOk(data));
+        const rows = data.underlyings.map(u => [chalk.white.bold(u.underlying), u.spotPrice === null ? chalk.gray("—") : fmtPx(u.spotPrice)]);
+        console.log(`\n  ${chalk.white.bold(`${data.venue} options underlyings`)}\n` + makeTable(["underlying", "spot"], rows) + "\n");
+    });
+    // ── options expiries <underlying> ────────────────────────────────────────
+    options
+        .command("expiries <underlying>")
+        .description("List active option expiries of an underlying (e.g. ETH)")
+        .action(async (underlying) => {
+        const data = await (await venue()).listExpiries(underlying);
+        if (isJson())
+            return printJson(jsonOk(data));
+        const rows = data.expiries.map(e => [
+            chalk.white.bold(e.expiry),
+            new Date(e.expiryMs).toISOString().slice(11, 16) + " UTC",
+            String(e.strikes),
+            String(e.instruments),
+        ]);
+        console.log(`\n  ${chalk.white.bold(`${data.underlying} options (${data.venue})`)}\n` + makeTable(["expiry", "time", "strikes", "instruments"], rows) + "\n");
+    });
+    // ── options chain <underlying> ───────────────────────────────────────────
+    options
+        .command("chain <underlying>")
+        .description("Option chain for one expiry: calls / puts per strike with bid / ask, mark, IV, greeks, OI")
+        .option("--expiry <date>", "Expiry (YYYY-MM-DD, UTC); default: the nearest active expiry")
+        .option("--strikes <n>", "Only the N strikes closest to the ATM reference (forward, else index)")
+        .action(async (underlying, opts) => {
+        const strikes = opts.strikes === undefined ? null : parseStrikes(opts.strikes);
+        const chain = await (await venue()).getChain({ underlying, expiry: opts.expiry ?? null, strikesAroundAtm: strikes });
+        if (isJson())
+            return printJson(jsonOk(chain));
+        printChain(chain);
+    });
+    // ── options quote <instrument> ───────────────────────────────────────────
+    options
+        .command("quote <instrument>")
+        .description("One option: bid / ask (price + size), mark, IV, greeks, forward, index, OI, 24h volume (e.g. ETH-20261225-3500-P)")
+        .action(async (instrument) => {
+        const q = await (await venue()).getQuote(instrument);
+        if (isJson())
+            return printJson(jsonOk(q));
+        printQuote(q);
+    });
+}
+function parseStrikes(raw) {
+    const n = Number(raw);
+    if (!/^\d+$/.test(raw.trim()) || !Number.isInteger(n) || n < 1) {
+        throw new PerpError("INVALID_PARAMS", `--strikes must be a positive integer (got "${raw}")`, {
+            remediation: "Pass a positive integer, e.g. --strikes 10",
+        });
+    }
+    return n;
+}
+// ── human output ──
+const dash = chalk.gray("—");
+function fmtPx(v) {
+    return v === null ? dash : String(Number(Number(v).toPrecision(8)));
+}
+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);
+}
+function sideCells(q) {
+    if (q === null)
+        return [dash, dash, dash, dash, dash];
+    return [
+        q.bid === null ? dash : fmtPx(q.bid.price),
+        q.ask === null ? dash : fmtPx(q.ask.price),
+        fmtPx(q.mark),
+        fmtPct(q.iv.mark),
+        fmtGreek(q.greeks?.delta),
+    ];
+}
+function printChain(c) {
+    const ref = c.atm === null ? "ATM unknown" : `ATM ${c.atm.strike} (${c.atm.reference} ${fmtPx(c.atm.price)})`;
+    console.log(chalk.white.bold(`\n  ${c.underlying} options — ${c.expiry} (${c.venue})`));
+    console.log(chalk.gray(`  index ${fmtPx(c.index)} · forward ${fmtPx(c.forward)} · ${ref} · ${c.rows.length}/${c.strikesListed} strikes\n`));
+    const rows = c.rows.map(r => {
+        const strike = c.atm !== null && r.strike === c.atm.strike ? chalk.yellow.bold(r.strike) : chalk.white.bold(r.strike);
+        return [...sideCells(r.call), strike, ...sideCells(r.put).reverse()];
+    });
+    console.log(makeTable(["C bid", "C ask", "C mark", "C IV", "C Δ", "strike", "P Δ", "P IV", "P mark", "P ask", "P bid"], rows));
+    if (c.missingTickers.length > 0)
+        console.log(chalk.yellow(`  no ticker: ${c.missingTickers.join(", ")}`));
+    console.log("");
+}
+function printQuote(q) {
+    const side = (s) => (s === null ? dash : `${fmtPx(s.price)} × ${s.size}`);
+    console.log(chalk.white.bold(`\n  ${q.instrument}`) + chalk.gray(`  (${q.venue} · ${q.kind} · strike ${q.strike} · expiry ${new Date(q.expiryMs).toISOString().replace("T", " ").slice(0, 16)} UTC)`));
+    const rows = [
+        ["bid", side(q.bid), "IV", fmtPct(q.iv.bid)],
+        ["ask", side(q.ask), "IV", fmtPct(q.iv.ask)],
+        ["mark", fmtPx(q.mark), "IV", fmtPct(q.iv.mark)],
+        ["index", fmtPx(q.index), "forward", fmtPx(q.forward)],
+        ["delta", fmtGreek(q.greeks?.delta), "gamma", q.greeks === null ? dash : q.greeks.gamma],
+        ["theta", fmtGreek(q.greeks?.theta), "vega", fmtGreek(q.greeks?.vega)],
+        ["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");
+}

package/dist/commands/pacifica-earn.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+type Getter = (exchange: string) => Promise<ExchangeAdapter>;
+export declare function registerPacificaEarnCommands(program: Command, getAdapterForExchange: Getter, isJson: () => boolean): void;
+export {};