@overcast-xyz/cli 0.1.0

package/dist/commands/quote.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.runQuoter = runQuoter;
+const p = __importStar(require("@clack/prompts"));
+const core_1 = require("@overcast-xyz/core");
+const picocolors_1 = __importDefault(require("picocolors"));
+const client_1 = require("../client");
+const config_1 = require("../config");
+const quote_webhook_1 = require("./quote-webhook");
+/** Quoter 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 quote` — run an RFQ quoter 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 runQuoter(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_QUOTE_WEBHOOK_URL`) is set.
+    const webhookUrl = opts.webhookUrl ?? process.env.OVERCAST_QUOTE_WEBHOOK_URL;
+    const webhook = webhookUrl
+        ? {
+            url: webhookUrl,
+            timeoutMs: Number(opts.webhookTimeout) || DEFAULT_WEBHOOK_TIMEOUT_MS,
+        }
+        : null;
+    const pricer = webhook
+        ? (0, quote_webhook_1.webhookPricer)(webhook, app.publicKey)
+        : blackScholesPricer({ spread, vol, rate });
+    p.intro(picocolors_1.default.magenta("Overcast RFQ Quoter"));
+    // The quoter 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, quote_webhook_1.postEvent)(webhook, "quoteAccepted", a, app.publicKey);
+    };
+    rfq.onError = (e) => {
+        p.log.error(`RFQ error: ${e.message}`);
+        if (webhook)
+            (0, quote_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, quote_webhook_1.postEvent)(webhook, "newQuote", q, app.publicKey);
+        rfq.onRfqCancelled = (c) => (0, quote_webhook_1.postEvent)(webhook, "rfqCancelled", c, app.publicKey);
+        rfq.onRfqExpired = (e) => (0, quote_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("Quoter 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 quoter'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/redeem.d.ts

@@ -0,0 +1,14 @@
+import { GlobalFlags } from "../config";
+export interface RedeemOptions extends GlobalFlags {
+    collateralOffer?: string;
+    settlementOffer?: string;
+    /** Native-unit amount of collateral-return claims to burn. */
+    amount?: string;
+}
+/**
+ * `overcast redeem` — redeem (burn collateral-return claims of) an option,
+ * pulling the maker's collateral (and any settlement paid on exercise) back
+ * out. Payouts always go to the maker; the wallet must be the maker to hold
+ * claims to redeem.
+ */
+export declare function redeem(opts: RedeemOptions): Promise<void>;

package/dist/commands/redeem.js

@@ -0,0 +1,88 @@
+"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.redeem = redeem;
+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 redeem` — redeem (burn collateral-return claims of) an option,
+ * pulling the maker's collateral (and any settlement paid on exercise) back
+ * out. Payouts always go to the maker; the wallet must be the maker to hold
+ * claims to redeem.
+ */
+async function redeem(opts) {
+    const config = (0, config_1.resolveConfig)(opts);
+    const app = await (0, client_1.createClient)(config);
+    const registry = await (0, shared_1.loadRegistry)(app.api);
+    p.intro(picocolors_1.default.cyan("Overcast redeem"));
+    const option = await (0, shared_1.resolveOption)(app.chain, opts);
+    if (app.publicKey !== option.maker) {
+        p.log.warn(`This wallet is not the option maker (${(0, shared_1.short)(option.maker)}); the redeem will fail.`);
+    }
+    const claims = await app.chain.redeemClaims(option, app.publicKey);
+    p.note([
+        (0, shared_1.describeOptionDetails)(option.details, registry),
+        "",
+        `Your redeem claims  ${picocolors_1.default.bold(claims.toString())}`,
+    ].join("\n"), `Option ${(0, shared_1.short)(option.id)}`);
+    if (claims === 0n && opts.amount == null) {
+        p.outro(picocolors_1.default.yellow("You hold no collateral-return claims for this option."));
+        return;
+    }
+    const amount = opts.amount != null
+        ? BigInt(opts.amount)
+        : await (0, shared_1.promptAmountUpTo)("Amount to redeem", claims);
+    if (!(await (0, shared_1.confirm)(`Redeem ${amount} claim(s)?`))) {
+        p.outro(picocolors_1.default.yellow("Cancelled."));
+        return;
+    }
+    const spinner = p.spinner();
+    spinner.start(`Redeeming ${amount} claim(s)`);
+    try {
+        const { hash } = await app.chain.redeemOption(option, amount);
+        spinner.stop(picocolors_1.default.green(`Redeemed. tx ${picocolors_1.default.bold(hash)}`));
+        p.outro(picocolors_1.default.green("Done."));
+    }
+    catch (err) {
+        spinner.stop(picocolors_1.default.red(`Redeem failed: ${err.message}`));
+        throw err;
+    }
+}

package/dist/commands/rfq-view.d.ts

@@ -0,0 +1,25 @@
+import { GlobalFlags } from "../config";
+export interface RfqListOptions extends GlobalFlags {
+    /** Filter to RFQs created by this address. */
+    creator?: string;
+    /** Filter by side: MAKER or TAKER. */
+    side?: string;
+    /** Filter by lifecycle status (open, quoted, accepted, cancelled, expired). */
+    status?: string;
+    /** Max rows to return. */
+    limit?: string;
+}
+/**
+ * `overcast rfq list` — browse persisted RFQs (open and historical) via the
+ * off-chain {@link OvercastView}. Read-only: no wallet required.
+ */
+export declare function rfqList(opts: RfqListOptions): Promise<void>;
+export interface RfqShowOptions extends GlobalFlags {
+    /** RFQ id to show; prompts when omitted. */
+    id?: string;
+}
+/**
+ * `overcast rfq show` — show a single RFQ's terms and every quote submitted
+ * against it, via the off-chain {@link OvercastView}. Read-only.
+ */
+export declare function rfqShow(opts: RfqShowOptions): Promise<void>;

package/dist/commands/rfq-view.js

@@ -0,0 +1,172 @@
+"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.rfqList = rfqList;
+exports.rfqShow = rfqShow;
+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 shared_1 = require("./shared");
+const SIDES = ["MAKER", "TAKER"];
+const STATUSES = [
+    "open",
+    "quoted",
+    "accepted",
+    "cancelled",
+    "expired",
+];
+/**
+ * `overcast rfq list` — browse persisted RFQs (open and historical) via the
+ * off-chain {@link OvercastView}. Read-only: no wallet required.
+ */
+async function rfqList(opts) {
+    const config = (0, config_1.resolveConfig)(opts, { keypairOptional: true });
+    const app = await (0, client_1.createClient)(config);
+    const filter = {
+        creator: (0, shared_1.optionalAddress)("--creator", opts.creator),
+        side: parseSide(opts.side),
+        status: parseStatus(opts.status),
+    };
+    const limit = (0, shared_1.parseLimit)(opts.limit);
+    p.intro(picocolors_1.default.cyan("Overcast RFQs"));
+    const spinner = p.spinner();
+    spinner.start("Loading RFQs");
+    try {
+        const page = await app.view.listRfqs({
+            filter,
+            page: limit ? { limit } : undefined,
+        });
+        spinner.stop(`${page.items.length} RFQ(s)`);
+        if (page.items.length === 0) {
+            p.outro(picocolors_1.default.yellow("No RFQs match."));
+            return;
+        }
+        for (const rfq of page.items) {
+            p.log.message([
+                `${picocolors_1.default.bold((0, shared_1.short)(rfq.rfqId))}  ${statusTag(rfq.status)} ${picocolors_1.default.dim(rfq.side)}  ${(0, shared_1.summarizeCuratedDetails)(rfq.details)}`,
+                picocolors_1.default.dim(`creator ${(0, shared_1.short)(rfq.creator)} · ${(0, shared_1.formatTimestamp)(Math.floor(rfq.createdAt / 1000))}`),
+            ].join("\n"));
+        }
+        p.outro(picocolors_1.default.green(`${page.total ?? page.items.length} total.`));
+    }
+    catch (err) {
+        spinner.stop(picocolors_1.default.red(`List failed: ${err.message}`));
+        throw err;
+    }
+}
+/**
+ * `overcast rfq show` — show a single RFQ's terms and every quote submitted
+ * against it, via the off-chain {@link OvercastView}. Read-only.
+ */
+async function rfqShow(opts) {
+    const config = (0, config_1.resolveConfig)(opts, { keypairOptional: true });
+    const app = await (0, client_1.createClient)(config);
+    if (opts.id && (0, shared_1.validateAddress)(opts.id)) {
+        throw new Error(`invalid RFQ id: ${opts.id}`);
+    }
+    const id = opts.id ?? (await (0, shared_1.promptId)("RFQ id"));
+    p.intro(picocolors_1.default.cyan("Overcast RFQ"));
+    const spinner = p.spinner();
+    spinner.start("Loading RFQ");
+    try {
+        const rfq = await app.view.getRfq(id);
+        if (!rfq) {
+            spinner.stop(picocolors_1.default.yellow(`No RFQ found for ${(0, shared_1.short)(id)}.`));
+            return;
+        }
+        const quotes = await app.view.listQuotes(id);
+        spinner.stop(`${quotes.items.length} quote(s)`);
+        p.note([
+            `Creator  ${(0, shared_1.short)(rfq.creator)}`,
+            `Side     ${rfq.side}`,
+            `Status   ${statusTag(rfq.status)}`,
+            "",
+            (0, shared_1.summarizeCuratedDetails)(rfq.details),
+        ].join("\n"), `RFQ ${(0, shared_1.short)(rfq.rfqId)}`);
+        if (quotes.items.length === 0) {
+            p.log.info(picocolors_1.default.dim("No quotes yet."));
+        }
+        else {
+            for (const quote of quotes.items) {
+                p.log.message([
+                    `${picocolors_1.default.bold((0, shared_1.short)(quote.quoteId))}  ${(0, core_1.formatAssetAmount)((0, core_1.amountFromWire)(quote.details.premiumAmount), quote.details.premiumAsset)}  ${picocolors_1.default.dim(quote.status)}`,
+                    picocolors_1.default.dim(`from ${(0, shared_1.short)(quote.creator)}`),
+                ].join("\n"));
+            }
+        }
+        p.outro(picocolors_1.default.green("Done."));
+    }
+    catch (err) {
+        spinner.stop(picocolors_1.default.red(`Lookup failed: ${err.message}`));
+        throw err;
+    }
+}
+/** Colour an RFQ status for scannable list output. */
+function statusTag(status) {
+    switch (status) {
+        case "open":
+        case "quoted":
+            return picocolors_1.default.green(status);
+        case "accepted":
+            return picocolors_1.default.cyan(status);
+        default:
+            return picocolors_1.default.dim(status);
+    }
+}
+/** Validate the optional `--side` filter against the {@link ClientRole} union. */
+function parseSide(value) {
+    if (value == null)
+        return undefined;
+    const side = value.toUpperCase();
+    if (!SIDES.includes(side)) {
+        throw new Error(`invalid --side: ${value} (expected ${SIDES.join(" or ")})`);
+    }
+    return side;
+}
+/** Validate the optional `--status` filter against the {@link RfqStatus} union. */
+function parseStatus(value) {
+    if (value == null)
+        return undefined;
+    const status = value.toLowerCase();
+    if (!STATUSES.includes(status)) {
+        throw new Error(`invalid --status: ${value} (expected ${STATUSES.join(", ")})`);
+    }
+    return status;
+}

package/dist/commands/rfq.d.ts

@@ -0,0 +1,4 @@
+import { GlobalFlags } from "../config";
+export type RfqOptions = GlobalFlags;
+/** `overcast rfq create` — request quotes, pick one, and settle it. */
+export declare function rfqCreate(opts: RfqOptions): Promise<void>;