@overcast-xyz/cli 0.1.0

package/dist/commands/rfq.js

@@ -0,0 +1,280 @@
+"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.rfqCreate = rfqCreate;
+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 shared_1 = require("./shared");
+const solana_program_1 = require("@overcast-xyz/solana-program");
+/** `overcast rfq create` — request quotes, pick one, and settle it. */
+async function rfqCreate(opts) {
+    const config = (0, config_1.resolveConfig)(opts);
+    const app = await (0, client_1.createClient)(config);
+    const rfq = app.rfq;
+    p.intro(picocolors_1.default.cyan("Overcast RFQ"));
+    try {
+        // The RFQ creator writes the option (posts the collateral), so it acts on
+        // the MAKER side; quoters respond on the opposite (TAKER) side.
+        await rfq.registerRole("MAKER");
+        const assets = await app.api.listAssets();
+        if (assets.length === 0)
+            throw new Error("backend has no supported assets");
+        const details = await promptRfqDetails(assets, app.settlement.defaultConfig());
+        // Wire up quote collection + error handling before creating.
+        const quotes = [];
+        let notify = null;
+        const wake = () => notify?.();
+        let terminal = null;
+        rfq.onNewQuote = (q) => {
+            quotes.push(q);
+            p.log.success(`Quote ${picocolors_1.default.dim(short(q.quoteId))}: ${(0, core_1.formatAssetAmount)((0, core_1.amountFromWire)(q.details.premiumAmount), q.details.premiumAsset)} from ${short(q.creator)}`);
+            wake();
+        };
+        rfq.onError = (e) => {
+            terminal = `error: ${e.message}`;
+            wake();
+        };
+        const { rfqId } = await rfq.createRfq({
+            creator: app.publicKey,
+            request: { details },
+            side: "MAKER",
+        });
+        p.log.info(`RFQ created: ${picocolors_1.default.bold(rfqId)} — waiting for quotes…`);
+        const chosen = await collectAndChoose(quotes, () => terminal, (fn) => {
+            notify = fn;
+        });
+        if (!chosen) {
+            p.outro(picocolors_1.default.yellow(terminal ?? "No quote selected."));
+            return;
+        }
+        await acceptQuote(rfq, chosen);
+    }
+    finally {
+        rfq.disconnect();
+    }
+}
+/**
+ * Accept a quote and settle it on-chain. The backend now settles inline and
+ * returns the freshly created option in the ack, so there is no separate
+ * `option:created` event to await.
+ */
+async function acceptQuote(rfq, quote) {
+    const spinner = p.spinner();
+    spinner.start("Accepting quote and settling on-chain");
+    try {
+        // The RFQ creator settles as the MAKER, so it authors a collateral offer
+        // over the quoted terms; the client signs it with the protocol signer. The
+        // quote's curated details are accepted as-is (uncurated internally).
+        const { optionId, txHash } = await rfq.acceptQuote({
+            quoteId: quote.quoteId,
+            side: "MAKER",
+            details: quote.details,
+        });
+        spinner.stop(picocolors_1.default.green(`Option created: ${picocolors_1.default.bold(optionId)} (accept tx ${short(txHash)})`));
+        p.outro(picocolors_1.default.green("Done."));
+    }
+    catch (err) {
+        spinner.stop(picocolors_1.default.red(`Accept failed: ${err.message}`));
+    }
+}
+/**
+ * Block until the user picks a quote or the RFQ terminates. New quotes appear
+ * as they arrive; the user can refresh to re-list before choosing.
+ */
+async function collectAndChoose(quotes, terminal, setNotify) {
+    for (;;) {
+        if (terminal())
+            return null;
+        if (quotes.length === 0) {
+            await new Promise((resolve) => setNotify(resolve));
+            continue;
+        }
+        const selection = await p.select({
+            message: "Choose a quote to accept",
+            options: [
+                ...quotes.map((q, i) => ({
+                    value: String(i),
+                    label: `${(0, core_1.formatAssetAmount)((0, core_1.amountFromWire)(q.details.premiumAmount), q.details.premiumAsset)} — ${short(q.creator)}`,
+                })),
+                { value: "refresh", label: picocolors_1.default.dim("↻ wait for more quotes") },
+                { value: "cancel", label: picocolors_1.default.dim("✗ cancel") },
+            ],
+        });
+        const choice = (0, shared_1.ensureNotCancelled)(selection);
+        if (choice === "cancel")
+            return null;
+        if (choice === "refresh")
+            continue;
+        return quotes[Number(choice)];
+    }
+}
+/**
+ * Prompt for an option in the terms a trader actually thinks in — strategy,
+ * underlying, quantity, strike, expiry — and derive the raw collateral /
+ * settlement legs from them.
+ *
+ * A covered call and a cash-secured put are the same swap of `settlementAmount`
+ * of one asset for `collateralAmount` of the other, differing only in which leg
+ * is collateral (see the quote pricer in `quote.ts`):
+ *   - **covered call**   → collateral = underlying (qty), settlement = cash (strike × qty)
+ *   - **cash-secured put** → collateral = cash (strike × qty), settlement = underlying (qty)
+ *
+ * where the strike is the cash price per unit of underlying. Premium is set by
+ * quoting MMs, so it isn't asked for here. Assets are picked from the backend's
+ * allowlist; the raw mint address is what's sent on the wire.
+ */
+async function promptRfqDetails(assets, settlementLayer) {
+    const nowSec = Math.floor(Date.now() / 1000);
+    const byAddress = new Map(assets.map((a) => [a.address, a]));
+    const assetOption = (a) => ({
+        value: a.address,
+        label: `${a.symbol} ${picocolors_1.default.dim(short(a.address))}`,
+    });
+    const group = await p.group({
+        strategy: () => p.select({
+            message: "Strategy",
+            options: [
+                {
+                    value: "call",
+                    label: "Covered call",
+                    hint: "post the underlying, get paid for upside",
+                },
+                {
+                    value: "put",
+                    label: "Cash-secured put",
+                    hint: "post cash, get paid to bid below spot",
+                },
+            ],
+        }),
+        underlyingAsset: () => p.select({
+            message: "Underlying asset",
+            options: assets.map(assetOption),
+        }),
+        quoteAsset: ({ results }) => p.select({
+            message: "Quote (cash) asset",
+            options: assets
+                .filter((a) => a.address !== results.underlyingAsset)
+                .map(assetOption),
+        }),
+        quantity: ({ results }) => {
+            const underlying = byAddress.get(results.underlyingAsset);
+            return p.text({
+                message: `Quantity (${underlying.symbol})`,
+                validate: (0, shared_1.validateDisplayAmount)(underlying),
+            });
+        },
+        strike: ({ results }) => {
+            const underlying = byAddress.get(results.underlyingAsset);
+            const quote = byAddress.get(results.quoteAsset);
+            const quantity = Number(results.quantity);
+            return p.text({
+                message: `Strike price (${quote.symbol} per ${underlying.symbol})`,
+                validate: (value) => {
+                    const positive = (0, shared_1.validatePositiveNumber)(value);
+                    if (positive)
+                        return positive;
+                    // The strike × quantity notional must round to at least one native
+                    // unit of the cash leg, or there's nothing to settle.
+                    try {
+                        const notional = cashNotional(Number(value), quantity, quote);
+                        if (notional < 1n) {
+                            return `Notional rounds to zero ${quote.symbol}`;
+                        }
+                    }
+                    catch {
+                        return "Enter a positive number";
+                    }
+                    return undefined;
+                },
+            });
+        },
+        expiryDays: () => p.text({
+            message: "Expiry (days from now)",
+            initialValue: "1",
+            validate: shared_1.validatePositiveNumber,
+        }),
+    }, { onCancel: () => process.exit(0) });
+    const isCall = group.strategy === "call";
+    const underlying = byAddress.get(group.underlyingAsset);
+    const quote = byAddress.get(group.quoteAsset);
+    const underlyingAmount = (0, core_1.toNativeAmount)(String(group.quantity), underlying);
+    const cashAmount = cashNotional(Number(group.strike), Number(group.quantity), quote);
+    const endTimestamp = nowSec + Math.round(Number(group.expiryDays) * 86_400);
+    // covered call → underlying is collateral; cash-secured put → cash is.
+    const collateralAsset = isCall ? underlying : quote;
+    const collateralAmount = isCall ? underlyingAmount : cashAmount;
+    const settlementAsset = isCall ? quote : underlying;
+    const settlementAmount = isCall ? cashAmount : underlyingAmount;
+    p.note([
+        `${picocolors_1.default.bold(isCall ? "Covered call" : "Cash-secured put")} on ${underlying.symbol}`,
+        `Quantity   ${group.quantity} ${underlying.symbol}`,
+        `Strike     ${group.strike} ${quote.symbol} / ${underlying.symbol}`,
+        `Expiry     ${group.expiryDays}d`,
+        "",
+        `You post   ${(0, core_1.formatAssetAmount)(collateralAmount, collateralAsset)}`,
+        `If settled ${(0, core_1.formatAssetAmount)(settlementAmount, settlementAsset)}`,
+    ].join("\n"), "Order summary");
+    return {
+        startTimestamp: nowSec,
+        endTimestamp,
+        collateralAsset: collateralAsset.address,
+        collateralAmount,
+        settlementAsset: settlementAsset.address,
+        settlementAmount,
+        domain: solana_program_1.SOLANA_DOMAIN, // TODO: the domain should be read by the on-chain contract
+        settlementLayer: settlementLayer,
+        borrowAllowed: false,
+    };
+}
+/**
+ * The cash leg's native amount for a `strike` (cash per underlying unit) and
+ * `quantity` of underlying: `strike × quantity`, rounded to the cash asset's
+ * decimals. Pricing here is display-level, so plain float math is fine — the
+ * result is converted to an exact native `bigint`.
+ */
+function cashNotional(strike, quantity, quote) {
+    const notional = (strike * quantity).toFixed(quote.decimals ?? 0);
+    return (0, core_1.toNativeAmount)(notional, quote);
+}
+/** 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/shared.d.ts

@@ -0,0 +1,81 @@
+import { Asset, AssetRegistry, CuratedOptionDetails, MarketOption, OptionDetails, OvercastReader, OvercastView, WithId } from "@overcast-xyz/core";
+/** Abort cleanly when the user cancels a clack prompt (Ctrl-C). */
+export declare function ensureNotCancelled<T>(value: T | symbol): T;
+/**
+ * Clack `validate` adapter over the layer's address predicate
+ * (`OvercastUtils.isValidAddress`): returns an error string when invalid, or
+ * `undefined` when the address is well-formed.
+ */
+export declare function validateAddress(value: string): string | undefined;
+/** Validate a positive integer amount; returns an error string when invalid. */
+export declare function validateAmount(value: string): string | undefined;
+/** Validate a positive (finite) number; returns an error string when invalid. */
+export declare function validatePositiveNumber(value: string): string | undefined;
+/**
+ * Validate a positive display amount (whole tokens, fractions allowed) that
+ * scales to at least one native unit of `asset`. Returns an error string when
+ * invalid.
+ */
+export declare function validateDisplayAmount(asset: Asset): (value: string) => string | undefined;
+/** Prompt for a mint / address with base58 validation. */
+export declare function promptMint(message: string): Promise<string>;
+/** Prompt for a positive integer (native-unit) amount. */
+export declare function promptAmount(message: string): Promise<bigint>;
+/** Prompt for a content-address / account id with base58 validation. */
+export declare function promptId(message: string): Promise<string>;
+/**
+ * Prompt for a positive integer (native-unit) amount that cannot exceed `max` —
+ * used to cap a burn (exercise / redeem) at the wallet's claim balance.
+ */
+export declare function promptAmountUpTo(message: string, max: bigint): Promise<bigint>;
+/** Prompt for a yes/no confirmation, aborting cleanly on cancel. */
+export declare function confirm(message: string): Promise<boolean>;
+/**
+ * Fetch the backend's asset allowlist (via the app's {@link OvercastView}) and
+ * wrap it in an {@link AssetRegistry} for symbol / decimals resolution. Throws
+ * if the backend has no assets — every picker / formatter downstream needs at
+ * least one.
+ */
+export declare function loadRegistry(view: Pick<OvercastView, "listAssets">): Promise<AssetRegistry>;
+/** Prompt the user to pick an allowlisted asset; returns its mint address. */
+export declare function pickAsset(registry: AssetRegistry, message: string): Promise<Asset>;
+/** Shorten a base58 id for compact display. */
+export declare function short(id: string): string;
+/** Format a unix-seconds timestamp as a compact UTC date-time. */
+export declare function formatTimestamp(seconds: number): string;
+/** The two content-address offer ids that together identify a market option. */
+export interface OptionRef {
+    collateralOffer?: string;
+    settlementOffer?: string;
+}
+/**
+ * Resolve a market option from its `(collateralOffer, settlementOffer)` id pair,
+ * prompting for whichever id wasn't passed as a flag. Throws when no matching
+ * option exists on-chain.
+ */
+export declare function resolveOption(reader: Pick<OvercastReader, "getOption">, ref: OptionRef): Promise<WithId<MarketOption>>;
+/**
+ * Render an option's terms as aligned, human-readable lines — each asset leg
+ * resolved against the registry so symbols and decimals show instead of raw
+ * mints. Shared by the option / offer / exercise / redeem / accept views.
+ */
+export declare function describeOptionDetails(details: OptionDetails, registry: AssetRegistry): string;
+/** Render curated option details as aligned lines, for a detail (show) view. */
+export declare function describeCuratedDetails(details: CuratedOptionDetails): string;
+/**
+ * A compact one-line summary of (possibly partial) curated terms for list rows:
+ * `collateral → settlement · premium · exp <date>`. Legs missing from a partial
+ * (e.g. an RFQ pins everything but the premium) are simply omitted.
+ */
+export declare function summarizeCuratedDetails(details: Partial<CuratedOptionDetails>): string;
+/**
+ * Parse a `--limit` flag to a positive integer page size, throwing on a
+ * malformed value. Returns `undefined` when the flag is absent, letting the
+ * backend apply its default page size.
+ */
+export declare function parseLimit(value?: string): number | undefined;
+/**
+ * Validate an optional address-valued filter flag, throwing a flag-named error
+ * when present but malformed. Returns the trimmed value (or `undefined`).
+ */
+export declare function optionalAddress(flag: string, value?: string): string | undefined;

package/dist/commands/shared.js

@@ -0,0 +1,296 @@
+"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.ensureNotCancelled = ensureNotCancelled;
+exports.validateAddress = validateAddress;
+exports.validateAmount = validateAmount;
+exports.validatePositiveNumber = validatePositiveNumber;
+exports.validateDisplayAmount = validateDisplayAmount;
+exports.promptMint = promptMint;
+exports.promptAmount = promptAmount;
+exports.promptId = promptId;
+exports.promptAmountUpTo = promptAmountUpTo;
+exports.confirm = confirm;
+exports.loadRegistry = loadRegistry;
+exports.pickAsset = pickAsset;
+exports.short = short;
+exports.formatTimestamp = formatTimestamp;
+exports.resolveOption = resolveOption;
+exports.describeOptionDetails = describeOptionDetails;
+exports.describeCuratedDetails = describeCuratedDetails;
+exports.summarizeCuratedDetails = summarizeCuratedDetails;
+exports.parseLimit = parseLimit;
+exports.optionalAddress = optionalAddress;
+const p = __importStar(require("@clack/prompts"));
+const core_1 = require("@overcast-xyz/core");
+const solana_client_1 = require("@overcast-xyz/solana-client");
+const picocolors_1 = __importDefault(require("picocolors"));
+/** Abort cleanly when the user cancels a clack prompt (Ctrl-C). */
+function ensureNotCancelled(value) {
+    if (p.isCancel(value)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    return value;
+}
+/**
+ * Clack `validate` adapter over the layer's address predicate
+ * (`OvercastUtils.isValidAddress`): returns an error string when invalid, or
+ * `undefined` when the address is well-formed.
+ */
+function validateAddress(value) {
+    return solana_client_1.solanaUtils.isValidAddress(value)
+        ? undefined
+        : "Not a valid base58 Solana address";
+}
+/** Validate a positive integer amount; returns an error string when invalid. */
+function validateAmount(value) {
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < 1)
+        return "Enter a positive integer amount";
+    return undefined;
+}
+/** Validate a positive (finite) number; returns an error string when invalid. */
+function validatePositiveNumber(value) {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0)
+        return "Enter a positive number";
+    return undefined;
+}
+/**
+ * Validate a positive display amount (whole tokens, fractions allowed) that
+ * scales to at least one native unit of `asset`. Returns an error string when
+ * invalid.
+ */
+function validateDisplayAmount(asset) {
+    return (value) => {
+        const n = Number(value);
+        if (!Number.isFinite(n) || n <= 0)
+            return "Enter a positive amount";
+        let native;
+        try {
+            native = (0, core_1.toNativeAmount)(value.trim(), asset);
+        }
+        catch {
+            return "Enter a positive amount";
+        }
+        if (native < 1n) {
+            return `Amount is below the smallest unit of ${asset.symbol ?? "this asset"}`;
+        }
+        return undefined;
+    };
+}
+/** Prompt for a mint / address with base58 validation. */
+async function promptMint(message) {
+    const value = await p.text({ message, validate: validateAddress });
+    return ensureNotCancelled(value).trim();
+}
+/** Prompt for a positive integer (native-unit) amount. */
+async function promptAmount(message) {
+    const value = await p.text({ message, validate: validateAmount });
+    return BigInt(ensureNotCancelled(value).trim());
+}
+/** Prompt for a content-address / account id with base58 validation. */
+async function promptId(message) {
+    const value = await p.text({ message, validate: validateAddress });
+    return ensureNotCancelled(value).trim();
+}
+/**
+ * Prompt for a positive integer (native-unit) amount that cannot exceed `max` —
+ * used to cap a burn (exercise / redeem) at the wallet's claim balance.
+ */
+async function promptAmountUpTo(message, max) {
+    const value = await p.text({
+        message: `${message} ${picocolors_1.default.dim(`(max ${max})`)}`,
+        validate: (v) => {
+            const base = validateAmount(v);
+            if (base)
+                return base;
+            if (BigInt(v.trim()) > max)
+                return `Exceeds your balance of ${max}`;
+            return undefined;
+        },
+    });
+    return BigInt(ensureNotCancelled(value).trim());
+}
+/** Prompt for a yes/no confirmation, aborting cleanly on cancel. */
+async function confirm(message) {
+    return ensureNotCancelled(await p.confirm({ message }));
+}
+/**
+ * Fetch the backend's asset allowlist (via the app's {@link OvercastView}) and
+ * wrap it in an {@link AssetRegistry} for symbol / decimals resolution. Throws
+ * if the backend has no assets — every picker / formatter downstream needs at
+ * least one.
+ */
+async function loadRegistry(view) {
+    const assets = await view.listAssets();
+    if (assets.length === 0)
+        throw new Error("backend has no supported assets");
+    return new core_1.AssetRegistry(assets);
+}
+/** Prompt the user to pick an allowlisted asset; returns its mint address. */
+async function pickAsset(registry, message) {
+    const assets = registry.list();
+    const choice = await p.select({
+        message,
+        options: assets.map((a) => ({
+            value: a.address,
+            label: `${a.symbol ?? "?"} ${picocolors_1.default.dim(short(a.address))}`,
+        })),
+    });
+    return registry.require(ensureNotCancelled(choice));
+}
+/** Shorten a base58 id for compact display. */
+function short(id) {
+    return id.length <= 12 ? id : `${id.slice(0, 6)}…${id.slice(-4)}`;
+}
+/** A single asset leg formatted with its symbol, resolved against the registry. */
+function leg(registry, asset, amount) {
+    return (0, core_1.formatAssetAmount)(amount, registry.getOrDefault(asset));
+}
+/** Format a unix-seconds timestamp as a compact UTC date-time. */
+function formatTimestamp(seconds) {
+    return `${new Date(seconds * 1000)
+        .toISOString()
+        .replace("T", " ")
+        .slice(0, 16)} UTC`;
+}
+/**
+ * Resolve a market option from its `(collateralOffer, settlementOffer)` id pair,
+ * prompting for whichever id wasn't passed as a flag. Throws when no matching
+ * option exists on-chain.
+ */
+async function resolveOption(reader, ref) {
+    if (ref.collateralOffer && validateAddress(ref.collateralOffer)) {
+        throw new Error(`invalid --collateral-offer id: ${ref.collateralOffer}`);
+    }
+    if (ref.settlementOffer && validateAddress(ref.settlementOffer)) {
+        throw new Error(`invalid --settlement-offer id: ${ref.settlementOffer}`);
+    }
+    const collateralOffer = ref.collateralOffer ?? (await promptId("Collateral offer id"));
+    const settlementOffer = ref.settlementOffer ?? (await promptId("Settlement offer id"));
+    const option = await reader.getOption(collateralOffer, settlementOffer);
+    if (!option) {
+        throw new Error("no option found for that collateral / settlement offer id pair");
+    }
+    return option;
+}
+/**
+ * Render an option's terms as aligned, human-readable lines — each asset leg
+ * resolved against the registry so symbols and decimals show instead of raw
+ * mints. Shared by the option / offer / exercise / redeem / accept views.
+ */
+function describeOptionDetails(details, registry) {
+    return [
+        `Collateral  ${leg(registry, details.collateralAsset, details.collateralAmount)}`,
+        `Settlement  ${leg(registry, details.settlementAsset, details.settlementAmount)}`,
+        `Premium     ${leg(registry, details.premiumAsset, details.premiumAmount)}`,
+        `Opens       ${formatTimestamp(details.startTimestamp)}`,
+        `Expires     ${formatTimestamp(details.endTimestamp)}`,
+    ].join("\n");
+}
+/* -------------------------------------------------------------------------- */
+/*  Curated (view) rendering                                                    */
+/* -------------------------------------------------------------------------- */
+//
+// The off-chain {@link OvercastView} returns *curated* shapes: each asset field
+// is a resolved {@link Asset} and each native amount a decimal-string. So these
+// need no registry — the metadata travels with the payload — unlike the raw
+// on-chain shapes above.
+/** A curated asset leg (`Asset` embedded, amount as a wire string) → "1.5 SOL". */
+function curatedLeg(asset, amount) {
+    return (0, core_1.formatAssetAmount)((0, core_1.amountFromWire)(amount), asset);
+}
+/** Render curated option details as aligned lines, for a detail (show) view. */
+function describeCuratedDetails(details) {
+    return [
+        `Collateral  ${curatedLeg(details.collateralAsset, details.collateralAmount)}`,
+        `Settlement  ${curatedLeg(details.settlementAsset, details.settlementAmount)}`,
+        `Premium     ${curatedLeg(details.premiumAsset, details.premiumAmount)}`,
+        `Opens       ${formatTimestamp(details.startTimestamp)}`,
+        `Expires     ${formatTimestamp(details.endTimestamp)}`,
+    ].join("\n");
+}
+/**
+ * A compact one-line summary of (possibly partial) curated terms for list rows:
+ * `collateral → settlement · premium · exp <date>`. Legs missing from a partial
+ * (e.g. an RFQ pins everything but the premium) are simply omitted.
+ */
+function summarizeCuratedDetails(details) {
+    const parts = [];
+    if (details.collateralAsset &&
+        details.collateralAmount != null &&
+        details.settlementAsset &&
+        details.settlementAmount != null) {
+        parts.push(`${curatedLeg(details.collateralAsset, details.collateralAmount)} ${picocolors_1.default.dim("→")} ${curatedLeg(details.settlementAsset, details.settlementAmount)}`);
+    }
+    if (details.premiumAsset && details.premiumAmount != null) {
+        parts.push(`premium ${curatedLeg(details.premiumAsset, details.premiumAmount)}`);
+    }
+    if (details.endTimestamp != null) {
+        parts.push(picocolors_1.default.dim(`exp ${formatTimestamp(details.endTimestamp)}`));
+    }
+    return parts.join(picocolors_1.default.dim("  ·  "));
+}
+/**
+ * Parse a `--limit` flag to a positive integer page size, throwing on a
+ * malformed value. Returns `undefined` when the flag is absent, letting the
+ * backend apply its default page size.
+ */
+function parseLimit(value) {
+    if (value == null)
+        return undefined;
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < 1) {
+        throw new Error(`invalid --limit: ${value} (expected a positive integer)`);
+    }
+    return n;
+}
+/**
+ * Validate an optional address-valued filter flag, throwing a flag-named error
+ * when present but malformed. Returns the trimmed value (or `undefined`).
+ */
+function optionalAddress(flag, value) {
+    if (value == null)
+        return undefined;
+    const trimmed = value.trim();
+    if (validateAddress(trimmed))
+        throw new Error(`invalid ${flag}: ${value}`);
+    return trimmed;
+}

package/dist/commands/withdraw.d.ts

@@ -0,0 +1,7 @@
+import { GlobalFlags } from "../config";
+export interface WithdrawOptions extends GlobalFlags {
+    mint?: string;
+    amount?: string;
+}
+/** `overcast withdraw` — pull funds back out of the wallet's escrow vault. */
+export declare function withdraw(opts: WithdrawOptions): Promise<void>;