@overcast-xyz/cli 0.1.0

package/dist/commands/mm.d.ts

@@ -0,0 +1,37 @@
+import { NewRfqPayload } from "@overcast/core";
+import { GlobalFlags } from "../config";
+/** A market maker's priced premium for an RFQ: asset address + native amount. */
+export interface Premium {
+    premiumAsset: string;
+    premiumAmount: bigint;
+}
+/**
+ * Prices an incoming RFQ. Returns the premium to quote, or `null` to skip the
+ * RFQ. May be async so pricers can consult external data (e.g. a spot oracle).
+ */
+export type QuotePricer = (rfq: NewRfqPayload) => Promise<Premium | null>;
+export interface MmOptions extends GlobalFlags {
+    /** MM edge added on top of the Black-Scholes fair value (fraction). */
+    spread?: string;
+    /** Annualized implied volatility, e.g. `0.8` for 80%. */
+    vol?: string;
+    /** Annualized risk-free rate, e.g. `0.05` for 5%. */
+    rate?: string;
+    /** Endpoint each RFQ event is POSTed to; its reply drives the quote. */
+    webhookUrl?: string;
+    /** Per-event webhook timeout, in milliseconds. */
+    webhookTimeout?: string;
+}
+/**
+ * `overcast mm` — run a market maker that auto-quotes every incoming RFQ using
+ * a Black-Scholes price.
+ *
+ * A cash-secured put and a covered call are the same instrument — an option to
+ * swap `settlementAmount` of one asset for `collateralAmount` of the other —
+ * differing only in which leg is collateral. We identify the stablecoin (cash)
+ * leg and the volatile (underlying) leg, then price:
+ *   - settlement is cash  → collateral is the underlying → **covered call**
+ *   - collateral is cash  → settlement is the underlying → **cash-secured put**
+ * See {@link blackScholesPricer}.
+ */
+export declare function runMarketMaker(opts: MmOptions): Promise<void>;

package/dist/commands/mm.js

@@ -0,0 +1,345 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMarketMaker = runMarketMaker;
+const p = __importStar(require("@clack/prompts"));
+const core_1 = require("@overcast/core");
+const picocolors_1 = __importDefault(require("picocolors"));
+const client_1 = require("../client");
+const config_1 = require("../config");
+const mm_webhook_1 = require("./mm-webhook");
+/** MM edge as a fraction of fair value (2%). */
+const DEFAULT_SPREAD = 0.02;
+/** Annualized implied volatility used for every quote (80%). */
+const DEFAULT_VOL = 0.8;
+/** Annualized risk-free rate (crypto convention: assume 0). */
+const DEFAULT_RATE = 0;
+/** Per-event webhook timeout when `--webhook-timeout` is omitted. */
+const DEFAULT_WEBHOOK_TIMEOUT_MS = 5000;
+const SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+/**
+ * Symbols treated as the cash / numeraire leg. A quote needs exactly one cash
+ * leg and one volatile-underlying leg; the cash side is assumed to be ~$1.
+ */
+const STABLE_SYMBOLS = new Set([
+    "USDC",
+    "USDT",
+    "USDH",
+    "PYUSD",
+    "DAI",
+    "USDP",
+    "TUSD",
+    "USD",
+]);
+/**
+ * `overcast mm` — run a market maker that auto-quotes every incoming RFQ using
+ * a Black-Scholes price.
+ *
+ * A cash-secured put and a covered call are the same instrument — an option to
+ * swap `settlementAmount` of one asset for `collateralAmount` of the other —
+ * differing only in which leg is collateral. We identify the stablecoin (cash)
+ * leg and the volatile (underlying) leg, then price:
+ *   - settlement is cash  → collateral is the underlying → **covered call**
+ *   - collateral is cash  → settlement is the underlying → **cash-secured put**
+ * See {@link blackScholesPricer}.
+ */
+async function runMarketMaker(opts) {
+    const config = (0, config_1.resolveConfig)(opts);
+    const app = await (0, client_1.createClient)(config);
+    const spread = opts.spread ? Number(opts.spread) : DEFAULT_SPREAD;
+    const vol = opts.vol ? Number(opts.vol) : DEFAULT_VOL;
+    const rate = opts.rate ? Number(opts.rate) : DEFAULT_RATE;
+    const rfq = app.rfq;
+    // Webhook mode: delegate pricing (and forward every lifecycle event) to a
+    // developer-supplied local endpoint. Falls back to the built-in Black-Scholes
+    // pricer when no `--webhook-url` (or `OVERCAST_MM_WEBHOOK_URL`) is set.
+    const webhookUrl = opts.webhookUrl ?? process.env.OVERCAST_MM_WEBHOOK_URL;
+    const webhook = webhookUrl
+        ? {
+            url: webhookUrl,
+            timeoutMs: Number(opts.webhookTimeout) || DEFAULT_WEBHOOK_TIMEOUT_MS,
+        }
+        : null;
+    const pricer = webhook
+        ? (0, mm_webhook_1.webhookPricer)(webhook, app.publicKey)
+        : blackScholesPricer({ spread, vol, rate });
+    p.intro(picocolors_1.default.magenta("Overcast Market Maker"));
+    // The market maker takes the option (pays the premium), so it acts on the
+    // TAKER side — the opposite of the RFQ creator's MAKER side.
+    await rfq.registerRole("TAKER");
+    p.log.info(`Maker ${picocolors_1.default.bold(app.publicKey)}`);
+    p.log.info(picocolors_1.default.dim(webhook
+        ? `Webhook — ${webhook.url} (timeout ${webhook.timeoutMs}ms)`
+        : `Black-Scholes — vol ${vol * 100}%, rate ${rate * 100}%, edge ${spread * 100}%`));
+    p.log.info(picocolors_1.default.dim("Listening for RFQs. Press Ctrl-C to stop."));
+    rfq.onQuoteAccepted = (a) => {
+        p.log.success(`Quote ${short(a.quoteId)} accepted — option ${picocolors_1.default.bold(a.optionId)} (RFQ ${short(a.rfqId)})`);
+        if (webhook)
+            (0, mm_webhook_1.postEvent)(webhook, "quoteAccepted", a, app.publicKey);
+    };
+    rfq.onError = (e) => {
+        p.log.error(`RFQ error: ${e.message}`);
+        if (webhook)
+            (0, mm_webhook_1.postEvent)(webhook, "error", e, app.publicKey);
+    };
+    // In webhook mode, forward the remaining lifecycle events too so the endpoint
+    // has full visibility (these are fire-and-forget — their replies are ignored).
+    if (webhook) {
+        rfq.onNewQuote = (q) => (0, mm_webhook_1.postEvent)(webhook, "newQuote", q, app.publicKey);
+        rfq.onRfqCancelled = (c) => (0, mm_webhook_1.postEvent)(webhook, "rfqCancelled", c, app.publicKey);
+        rfq.onRfqExpired = (e) => (0, mm_webhook_1.postEvent)(webhook, "rfqExpired", e, app.publicKey);
+    }
+    // Auto-quote every incoming RFQ (Black-Scholes, or the webhook's reply).
+    rfq.onNewRfq = (incoming) => {
+        void quoteRfq(rfq, app.publicKey, incoming, pricer);
+    };
+    // Run until interrupted.
+    await new Promise((resolve) => {
+        process.on("SIGINT", () => {
+            p.log.warn("Shutting down…");
+            rfq.disconnect();
+            resolve();
+        });
+    });
+    p.outro(picocolors_1.default.magenta("Market maker stopped."));
+}
+/**
+ * Price an incoming RFQ and submit a quote over the full option terms — the
+ * RFQ's legs completed with the maker's premium — on the TAKER side. The client
+ * authors the settlement offer and signs it with the protocol signer, so no
+ * signature is passed here.
+ */
+async function quoteRfq(rfq, creator, incoming, pricer) {
+    try {
+        const premium = await pricer(incoming);
+        if (!premium)
+            return; // the pricer already logged why it skipped
+        const details = (0, core_1.completeOptionDetails)(incoming.details, premium);
+        if (!details) {
+            skip(incoming.rfqId, "RFQ is missing option terms");
+            return;
+        }
+        const { quoteId } = await rfq.submitQuote({
+            rfqId: incoming.rfqId,
+            details,
+            creator,
+            side: "TAKER",
+        });
+        p.log.success(`Quoted ${premium.premiumAmount} ${short(premium.premiumAsset)} on RFQ ${short(incoming.rfqId)} (quote ${short(quoteId)})`);
+    }
+    catch (err) {
+        p.log.error(`Failed to quote RFQ ${short(incoming.rfqId)}: ${err.message}`);
+    }
+}
+/**
+ * Black-Scholes pricer. Maps an RFQ onto European-option terms and quotes the
+ * fair premium plus a `spread` edge, denominated in the cash (stablecoin) leg.
+ *
+ * The contract lets the holder swap the underlying for cash at the implied
+ * strike `K = cashAmount / underlyingAmount` (USD per underlying unit), with
+ * `underlyingAmount` as the contract size.
+ *
+ * Spot comes from a live CoinGecko lookup, falling back to the asset's
+ * backend-supplied {@link Asset.lastKnownPriceUsd} (the only source for RWAs,
+ * which have no `coinGeckoId`). Volatility uses the asset's own
+ * {@link Asset.volatility} when present, else the configured default. Returns
+ * `null` (skips the RFQ) when the legs can't be priced — no single cash leg, no
+ * usable spot price, or the option has already expired.
+ */
+function blackScholesPricer(params) {
+    const { spread, vol, rate } = params;
+    return async (rfq) => {
+        const Sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+        await Sleep(Math.random() * 1000);
+        // `d` is the curated (wire) shape — assets resolved, amounts as decimal
+        // strings — but only *partially* filled: the RFQ may omit some terms. We can
+        // only price a fully-specified pair of legs, so bail otherwise.
+        const d = rfq.details;
+        if (d.endTimestamp == null ||
+            !d.collateralAsset ||
+            d.collateralAmount == null ||
+            !d.settlementAsset ||
+            d.settlementAmount == null) {
+            skip(rfq.rfqId, "RFQ does not specify both option legs");
+            return null;
+        }
+        // Capture the now-narrowed terms before any further `await` widens them back.
+        const endTimestamp = d.endTimestamp;
+        const collateral = {
+            asset: d.collateralAsset,
+            amount: (0, core_1.toDisplayAmount)((0, core_1.amountFromWire)(d.collateralAmount), d.collateralAsset),
+        };
+        const settlement = {
+            asset: d.settlementAsset,
+            amount: (0, core_1.toDisplayAmount)((0, core_1.amountFromWire)(d.settlementAmount), d.settlementAsset),
+        };
+        // Need exactly one cash leg and one volatile leg to define an option.
+        const collateralIsCash = isStable(collateral.asset);
+        const settlementIsCash = isStable(settlement.asset);
+        if (collateralIsCash === settlementIsCash) {
+            skip(rfq.rfqId, `need exactly one stablecoin leg (got ${symbol(collateral.asset)}/${symbol(settlement.asset)})`);
+            return null;
+        }
+        // settlement = cash → covered call; collateral = cash → cash-secured put.
+        const isCall = settlementIsCash;
+        const cash = isCall ? settlement : collateral;
+        const underlying = isCall ? collateral : settlement;
+        // Prefer a live CoinGecko spot, falling back to the backend-supplied last
+        // known price. For RWAs (no `coinGeckoId`) the last known price is the only
+        // source — they're never auto-refreshed against a live feed.
+        const liveSpot = underlying.asset.coinGeckoId
+            ? await fetchSpotUsd(underlying.asset.coinGeckoId)
+            : null;
+        const spot = liveSpot ?? underlying.asset.lastKnownPriceUsd ?? null;
+        if (spot == null) {
+            skip(rfq.rfqId, `no spot or last known price for ${symbol(underlying.asset)}`);
+            return null;
+        }
+        // Use the asset's own volatility when the backend provides one; otherwise
+        // fall back to the configured default.
+        const sigma = underlying.asset.volatility ?? vol;
+        const nowSec = Math.floor(Date.now() / 1000);
+        const years = (endTimestamp - nowSec) / SECONDS_PER_YEAR;
+        if (years <= 0) {
+            skip(rfq.rfqId, "option has already expired");
+            return null;
+        }
+        const strike = Number(cash.amount) / Number(underlying.amount); // USD per underlying unit
+        const perUnit = blackScholes(isCall, spot, strike, years, rate, sigma);
+        const fairCash = perUnit * Number(underlying.amount); // total premium in cash units
+        const quotedCash = fairCash * (1 + spread) * (Math.random() * 0.05 + 0.95); // add the MM's edge
+        // Pricing is done in floats (display units); the quoted premium becomes an
+        // exact native `bigint`. The backend requires a positive premium, so clamp
+        // to at least one native unit.
+        const decimals = cash.asset.decimals ?? 0;
+        const native = (0, core_1.parseUnits)(quotedCash.toFixed(decimals), decimals);
+        const premiumAmount = native < 1n ? 1n : native;
+        return { premiumAsset: cash.asset.address, premiumAmount };
+    };
+}
+/**
+ * Black-Scholes price of one European option, in the same currency as `S`/`K`.
+ *
+ * @param isCall true for a call, false for a put
+ * @param S spot price of the underlying
+ * @param K strike price
+ * @param T time to expiry, in years
+ * @param r annualized risk-free rate
+ * @param sigma annualized volatility
+ */
+function blackScholes(isCall, S, K, T, r, sigma) {
+    // Degenerate inputs: the option is worth its (undiscounted) intrinsic value.
+    if (sigma <= 0 || T <= 0) {
+        return Math.max(0, isCall ? S - K : K - S);
+    }
+    const sqrtT = Math.sqrt(T);
+    const d1 = (Math.log(S / K) + (r + (sigma * sigma) / 2) * T) / (sigma * sqrtT);
+    const d2 = d1 - sigma * sqrtT;
+    const disc = Math.exp(-r * T);
+    return isCall
+        ? S * normCdf(d1) - K * disc * normCdf(d2)
+        : K * disc * normCdf(-d2) - S * normCdf(-d1);
+}
+/**
+ * Standard normal CDF via the Zelen & Severo rational approximation
+ * (Abramowitz & Stegun 26.2.17), accurate to ~7.5e-8.
+ */
+function normCdf(x) {
+    if (x < 0)
+        return 1 - normCdf(-x);
+    const t = 1 / (1 + 0.2316419 * x);
+    const poly = t *
+        (0.31938153 +
+            t *
+                (-0.356563782 +
+                    t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
+    const pdf = 0.3989422804014327 * Math.exp((-x * x) / 2);
+    return 1 - pdf * poly;
+}
+// --- spot prices -------------------------------------------------------------
+/** Cached CoinGecko USD prices, refreshed on a short TTL to avoid rate limits. */
+const SPOT_TTL_MS = 60_000;
+const spotCache = new Map();
+/**
+ * Fetch the USD spot price for a CoinGecko id, served from a short-lived cache.
+ * Returns `null` if the lookup fails (network error or unknown id) so the
+ * pricer can skip the RFQ rather than quote on stale or missing data.
+ */
+async function fetchSpotUsd(coinGeckoId) {
+    const cached = spotCache.get(coinGeckoId);
+    if (cached && Date.now() - cached.at < SPOT_TTL_MS)
+        return cached.price;
+    try {
+        const url = `https://api.coingecko.com/api/v3/simple/price?ids=${encodeURIComponent(coinGeckoId)}&vs_currencies=usd`;
+        const res = await fetch(url);
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        const price = body[coinGeckoId]?.usd;
+        if (typeof price !== "number" || !(price > 0))
+            return null;
+        spotCache.set(coinGeckoId, { price, at: Date.now() });
+        return price;
+    }
+    catch {
+        return null;
+    }
+}
+// --- helpers -----------------------------------------------------------------
+/**
+ * Whether an asset is treated as the cash / numeraire leg. The backend's own
+ * {@link Asset.cashLike} classification wins when present; otherwise fall back to
+ * the stablecoin-symbol heuristic for assets that predate the flag.
+ */
+function isStable(asset) {
+    if (asset.cashLike != null)
+        return asset.cashLike;
+    return asset.symbol ? STABLE_SYMBOLS.has(asset.symbol.toUpperCase()) : false;
+}
+/** A display label for an asset (symbol, falling back to a short address). */
+function symbol(asset) {
+    return asset.symbol ?? short(asset.address);
+}
+/** Log why an RFQ was skipped without quoting. */
+function skip(rfqId, reason) {
+    p.log.warn(`Skipping RFQ ${short(rfqId)}: ${reason}`);
+}
+/** Shorten a base58 id for log lines. */
+function short(id) {
+    return id.length <= 12 ? id : `${id.slice(0, 6)}…${id.slice(-4)}`;
+}

package/dist/commands/offer.d.ts

@@ -0,0 +1,29 @@
+import { GlobalFlags } from "../config";
+export interface OfferShowOptions extends GlobalFlags {
+    /** Offer id to look up; prompts when omitted. */
+    id?: string;
+}
+/**
+ * `overcast offer show` — look up an open offer by its content-address id.
+ *
+ * Collateral (maker) and settlement (taker) offers now share a single
+ * content-addressed namespace; the offer's own `side` says which it is.
+ */
+export declare function offerShow(opts: OfferShowOptions): Promise<void>;
+export interface OfferListOptions extends GlobalFlags {
+    /** Which side to list: `collateral` (maker), `settlement` (taker), or `both` (default). */
+    kind?: string;
+    /** Filter to the offer's counterparty (its creator). */
+    party?: string;
+    /** Filter to offers touching this asset. */
+    asset?: string;
+    /** Max rows. */
+    limit?: string;
+}
+/**
+ * `overcast offer list` — browse open offers via the off-chain
+ * {@link OvercastView}. Read-only. Offers now live in a single namespace;
+ * `--kind` narrows the listing to one side (by the offer's `side`), and with
+ * none given both sides are shown.
+ */
+export declare function offerList(opts: OfferListOptions): Promise<void>;

package/dist/commands/offer.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.offerShow = offerShow;
+exports.offerList = offerList;
+const p = __importStar(require("@clack/prompts"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const client_1 = require("../client");
+const config_1 = require("../config");
+const shared_1 = require("./shared");
+/**
+ * `overcast offer show` — look up an open offer by its content-address id.
+ *
+ * Collateral (maker) and settlement (taker) offers now share a single
+ * content-addressed namespace; the offer's own `side` says which it is.
+ */
+async function offerShow(opts) {
+    const config = (0, config_1.resolveConfig)(opts, { keypairOptional: true });
+    const app = await (0, client_1.createClient)(config);
+    const registry = await (0, shared_1.loadRegistry)(app.api);
+    if (opts.id && (0, shared_1.validateAddress)(opts.id)) {
+        throw new Error(`invalid offer id: ${opts.id}`);
+    }
+    const id = opts.id ?? (await (0, shared_1.promptId)("Offer id"));
+    p.intro(picocolors_1.default.cyan("Overcast offer"));
+    const spinner = p.spinner();
+    spinner.start("Looking up offer");
+    try {
+        const offer = await app.chain.getOffer(id);
+        if (!offer) {
+            spinner.stop(picocolors_1.default.yellow(`No open offer found for ${(0, shared_1.short)(id)}.`));
+            return;
+        }
+        spinner.stop(`${sideLabel(offer.side)} offer ${(0, shared_1.short)(id)}`);
+        p.note([
+            `Creator  ${(0, shared_1.short)(offer.creator)}`,
+            "",
+            (0, shared_1.describeOptionDetails)(offer.details, registry),
+        ].join("\n"), `${sideLabel(offer.side)} offer`);
+        p.outro(picocolors_1.default.green("Done."));
+    }
+    catch (err) {
+        spinner.stop(picocolors_1.default.red(`Lookup failed: ${err.message}`));
+        throw err;
+    }
+}
+/**
+ * `overcast offer list` — browse open offers via the off-chain
+ * {@link OvercastView}. Read-only. Offers now live in a single namespace;
+ * `--kind` narrows the listing to one side (by the offer's `side`), and with
+ * none given both sides are shown.
+ */
+async function offerList(opts) {
+    const kind = parseKind(opts.kind);
+    const config = (0, config_1.resolveConfig)(opts, { keypairOptional: true });
+    const app = await (0, client_1.createClient)(config);
+    const query = {
+        filter: {
+            party: (0, shared_1.optionalAddress)("--party", opts.party),
+            asset: (0, shared_1.optionalAddress)("--asset", opts.asset),
+        },
+        page: opts.limit ? { limit: (0, shared_1.parseLimit)(opts.limit) } : undefined,
+    };
+    p.intro(picocolors_1.default.cyan("Overcast offers"));
+    const spinner = p.spinner();
+    spinner.start("Loading offers");
+    try {
+        const { items } = await app.api.listOffers(query);
+        // A single namespace has no per-side query filter, so narrow by the offer's
+        // own `side` here when `--kind` asks for one.
+        const offers = kind === "both" ? items : items.filter((o) => o.side === kindSide(kind));
+        spinner.stop("Offers loaded.");
+        if (!renderOffers(offers)) {
+            p.outro(picocolors_1.default.yellow("No offers match."));
+            return;
+        }
+        p.outro(picocolors_1.default.green("Done."));
+    }
+    catch (err) {
+        spinner.stop(picocolors_1.default.red(`List failed: ${err.message}`));
+        throw err;
+    }
+}
+/** Print the offers, one per line with side + creator; returns whether any were shown. */
+function renderOffers(offers) {
+    if (offers.length === 0) {
+        p.log.info(`${picocolors_1.default.bold("Offers")} ${picocolors_1.default.dim("— none")}`);
+        return false;
+    }
+    p.log.info(picocolors_1.default.bold(`Offers (${offers.length})`));
+    for (const offer of offers) {
+        p.log.message([
+            `${picocolors_1.default.bold((0, shared_1.short)(offer.id))}  ${(0, shared_1.summarizeCuratedDetails)(offer.details)}`,
+            picocolors_1.default.dim(`${sideLabel(offer.side).toLowerCase()} ${(0, shared_1.short)(offer.creator)}`),
+        ].join("\n"));
+    }
+    return true;
+}
+/** Human-readable name for an offer's side. */
+function sideLabel(side) {
+    return side === "MAKER" ? "Collateral" : "Settlement";
+}
+/** The {@link OptionSide} a non-`both` `--kind` selects. */
+function kindSide(kind) {
+    return kind === "collateral" ? "MAKER" : "TAKER";
+}
+/** Validate the `--kind` flag, defaulting to listing both sides. */
+function parseKind(value) {
+    const kind = (value ?? "both").toLowerCase();
+    if (kind !== "collateral" && kind !== "settlement" && kind !== "both") {
+        throw new Error(`invalid --kind: ${value} (expected collateral, settlement, or both)`);
+    }
+    return kind;
+}

package/dist/commands/option.d.ts

@@ -0,0 +1,28 @@
+import { GlobalFlags } from "../config";
+export interface OptionShowOptions extends GlobalFlags {
+    collateralOffer?: string;
+    settlementOffer?: string;
+}
+/**
+ * `overcast option show` — resolve a market option from its
+ * `(collateralOffer, settlementOffer)` id pair and print its terms alongside
+ * the live claim state: the outstanding exercise / redeem claim supplies and,
+ * when a wallet is supplied, that wallet's own holdings of each.
+ */
+export declare function optionShow(opts: OptionShowOptions): Promise<void>;
+export interface OptionListOptions extends GlobalFlags {
+    /** Filter to options where this address is the maker. */
+    maker?: string;
+    /** Filter to options where this address is the taker. */
+    taker?: string;
+    /** Filter to options touching this asset (premium, collateral, or settlement). */
+    asset?: string;
+    /** Max rows to return. */
+    limit?: string;
+}
+/**
+ * `overcast option list` — browse the backend's curated market options via the
+ * off-chain {@link OvercastView}. Read-only: no wallet required. Filters map
+ * straight onto the view's {@link OptionFilter}; results are newest-first.
+ */
+export declare function optionList(opts: OptionListOptions): Promise<void>;