@overcast-xyz/cli 0.1.0

package/README.md

@@ -0,0 +1,272 @@
+# `@overcast-xyz/cli`
+
+A command-line interface for the **Overcast** Solana options protocol. It covers
+the full lifecycle: funding your protocol vault, browsing and inspecting market
+options, running the request-for-quote (RFQ) engine as a taker, exercising and
+redeeming options, and running an automated RFQ quoter.
+
+---
+
+## ⚠️ Status: pre-release, heavy development
+
+Please read this before you build anything on top of the CLI or SDK.
+
+- **Not published yet.** Neither the CLI nor the underlying SDK is available on
+  npm. **A public release will follow** — for now you build and run it from this
+  repository (see [Installation](#installation)).
+- **Under heavy development — expect breaking changes.** The entire CLI and its
+  API surface are actively changing. Command names, flags, output shapes, and
+  the exported SDK functions **can and will change without notice or a
+  deprecation window**. Pin to a specific commit if you need stability.
+- **How the signer is provided will change.** Today a keypair is supplied
+  inline via `--keypair` / `OVERCAST_KEYPAIR` (see [Wallet & signing](#wallet--signing)).
+  The signing model is being reworked, so the way you provide a signer — and how
+  signing happens for RFQ quotes and accepts — **is expected to change**.
+- **Signatures are stubbed today.** RFQ quote submission and quote acceptance
+  currently send a placeholder signature (`"0x0"`) because backend signature
+  verification is a no-op while the on-chain byte layout is being settled. For
+  the **RFQ-quoter webhook**, your endpoint returns only a premium — **no
+  signature is required**, and any signature field may be left empty or set to a
+  placeholder like `"0x0"` for now. **This part is still under construction** and
+  real signing will be wired in later.
+
+---
+
+## Installation
+
+Because nothing is published yet, run it from source within the monorepo.
+
+```bash
+# from the repo root, install workspace dependencies
+pnpm install
+
+# then, in this package:
+cd packages/overcast-cli
+
+# option A — compile with tsc to dist/ (also builds the SDK types)
+pnpm build
+node dist/bin.js --help
+
+# option B — produce a single self-contained executable in dist-bundle/
+pnpm bundle
+./dist-bundle/overcast.js --help
+```
+
+The examples below use `overcast` as shorthand for whichever of the two you run
+(`node dist/bin.js …` or `./dist-bundle/overcast.js …`).
+
+---
+
+## Getting started: run an RFQ quoter
+
+The quoter takes options and **pays the premium in the cash (stablecoin)
+leg**, so before it can quote anything you need funded, deposited cash inside the
+protocol. Work through these steps in order.
+
+**1. Point at your network and wallet.** Set the connection + wallet once so you
+don't repeat the flags on every command (or pass them per-command instead):
+
+```bash
+export SOLANA_RPC_URL=http://127.0.0.1:8899        # your RPC (defaults to localhost)
+export OVERCAST_BACKEND_URL=http://127.0.0.1:3000  # the Overcast backend (defaults to localhost)
+export OVERCAST_KEYPAIR=~/.config/solana/id.json   # a path, base58 secret key, or JSON byte array
+```
+
+**2. Check which assets the protocol supports.** Only allowlisted mints can be
+used; note the mint address of the cash asset you want to quote in:
+
+```bash
+overcast assets
+```
+
+**3. Hold the mints in your wallet.** Your wallet must already own the SPL token
+you intend to quote with — i.e. the **cash mint** you'll pay premiums in
+(and any underlying you plan to post). The CLI does not mint or airdrop tokens;
+acquire them the usual way for your network (faucet/mint authority on a test
+validator, a swap/transfer on mainnet).
+
+**4. Deposit that cash into the protocol.** Premiums are paid from your on-chain
+**escrow vault**, not straight from your wallet, so move funds in first. Amounts
+are in **native (smallest) units** — e.g. `10000000` = 10 USDC at 6 decimals:
+
+```bash
+overcast deposit --mint <cash-mint> --amount <native-units>
+
+# confirm it landed
+overcast balance --mint <cash-mint>
+```
+
+**5. Run the quoter.** With cash deposited, start quoting. The built-in
+Black-Scholes pricer needs no extra setup:
+
+```bash
+overcast quote
+```
+
+It connects to the backend, registers on the TAKER side, and auto-quotes every
+incoming RFQ until you stop it with `Ctrl-C`. To price with your own strategy
+instead, use the [webhook mode](#rfq-quoting).
+
+> **In short:** allowlisted mint in your wallet → `deposit` cash into the vault →
+> `quote`. Skipping the deposit is the most common reason a quoter connects
+> but can't quote.
+
+---
+
+## Configuration
+
+Every command resolves its connection and wallet settings from **flags first,
+then environment variables, then localhost defaults**.
+
+| Setting              | Flag                                 | Environment variable   | Default                           |
+| -------------------- | ------------------------------------ | ---------------------- | --------------------------------- |
+| Wallet keypair       | `-k, --keypair <path\|base58\|json>` | `OVERCAST_KEYPAIR`     | _(required for signing commands)_ |
+| Solana RPC URL       | `--rpc <url>`                        | `SOLANA_RPC_URL`       | `http://127.0.0.1:8899`           |
+| Overcast backend URL | `--backend <url>`                    | `OVERCAST_BACKEND_URL` | `http://127.0.0.1:3000`           |
+| RFQ transport        | `--transport <polling\|websocket>`   | —                      | `websocket`                       |
+
+These four are **global flags**: they can be passed either on the root command
+or on any subcommand, and they show up in every command's `--help` under a
+dedicated "Global Options" section.
+
+### Wallet & signing
+
+The keypair may be given three ways (all via `--keypair` or `OVERCAST_KEYPAIR`):
+
+- a **path** to a Solana CLI `id.json` file,
+- a raw **JSON byte array** string, or
+- a **base58**-encoded secret key string.
+
+A file path is read by the CLI itself, so only inlined key material is handed to
+the client. Read-only commands (e.g. `balance`, `option show`, `assets`) work
+without a keypair; anything that signs a transaction requires one.
+
+> **Reminder:** this inline mechanism is temporary — see the status note above.
+> How the signer is provided is expected to change.
+
+---
+
+## Commands
+
+Run `overcast --help`, or `overcast <command> --help`, for the authoritative,
+always-current list.
+
+### Vault management
+
+```bash
+# Deposit into your protocol escrow vault (amounts are in native/smallest units)
+overcast deposit --mint <mint> --amount <n>
+
+# Withdraw from your vault
+overcast withdraw --mint <mint> --amount <n>
+
+# Show a vault balance for an asset (defaults to your own wallet)
+overcast balance --mint <mint> [--user <address>]
+```
+
+Omitted `--mint` / `--amount` values are prompted for interactively.
+
+### Discovering options & offers
+
+```bash
+# List the backend's supported asset allowlist
+overcast assets
+
+# Browse curated market options
+overcast option list [--maker <addr>] [--taker <addr>] [--asset <addr>] [--limit <n>]
+
+# Show one option's terms and live claim state
+overcast option show --collateral-offer <id> --settlement-offer <id>
+
+# Browse open collateral / settlement offers
+overcast offer list [--kind collateral|settlement|both] [--party <addr>] [--asset <addr>] [--limit <n>]
+
+# Look up a single open offer by id
+overcast offer show --id <id>
+```
+
+A market option is identified by the **pair** of ids
+`(collateral-offer, settlement-offer)`.
+
+### Trading an option
+
+```bash
+# Match a collateral + settlement offer to mint an option
+overcast accept --collateral-offer <id> --settlement-offer <id>
+
+# Exercise an option you hold (swap settlement for collateral)
+overcast exercise --collateral-offer <id> --settlement-offer <id> [--amount <n>]
+
+# Redeem an option's collateral back to the maker
+overcast redeem --collateral-offer <id> --settlement-offer <id> [--amount <n>]
+```
+
+### RFQ (request-for-quote)
+
+```bash
+# Create an RFQ, collect quotes live, and accept one — fully interactive
+overcast rfq create
+```
+
+`rfq create` walks you through the option in trader terms (strategy, underlying,
+quantity, strike, expiry), broadcasts the RFQ on the **MAKER** side, streams in
+quotes as quoters respond, and settles the one you pick on-chain.
+
+> The quote-accept step currently sends a stubbed signature (`"0x0"`); real
+> signing lands once the byte layout is settled.
+
+### RFQ quoting
+
+Run an automated quoter that auto-quotes every incoming RFQ. It acts on the
+**TAKER** side (it takes the option and pays the premium). Two pricing modes:
+
+**1. Built-in Black-Scholes pricer (default)**
+
+```bash
+overcast quote \
+  --spread 0.02 \   # edge over fair value, as a fraction (default 0.02 = 2%)
+  --vol 0.8 \       # annualized implied volatility (default 0.8 = 80%)
+  --rate 0.0        # annualized risk-free rate (default 0)
+```
+
+It identifies the cash (stablecoin) leg and the volatile underlying leg, pulls a
+spot price (CoinGecko, falling back to the backend's last-known price), and
+quotes the fair premium plus your edge.
+
+**2. Webhook pricer — bring your own strategy**
+
+```bash
+overcast quote \
+  --webhook-url http://127.0.0.1:9000/quote \
+  --webhook-timeout 5000    # per-event timeout in ms (default 5000)
+```
+
+The URL can also come from `OVERCAST_QUOTE_WEBHOOK_URL`. In this mode the CLI
+handles all the RFQ plumbing and forwards every lifecycle event to your local
+endpoint; your reply to the `newRfq` event drives the quote. See
+[`webhook-contract/`](./webhook-contract/) for the full wire contract, a JSON
+schema, TypeScript types, and a minimal Express handler.
+
+> **Webhook signing is not wired yet.** Your endpoint only supplies a
+> **premium** — the CLI stays authoritative on the rest of the option terms, and
+> **no signature is required from your endpoint**. Where a signature field
+> appears, it can currently be left empty or set to a placeholder like `"0x0"`.
+> This is still under construction.
+
+---
+
+## Programmatic use (SDK)
+
+The command implementations are also exported from the package entry point so
+they can be reused or tested outside the CLI:
+
+```ts
+import {
+  deposit,
+  rfqCreate,
+  runQuoter,
+  resolveConfig,
+} from "@overcast-xyz/cli";
+```
+
+The same pre-release caveats apply — these exports are unstable and will change.

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const picocolors_1 = __importDefault(require("picocolors"));
+const accept_1 = require("./commands/accept");
+const assets_1 = require("./commands/assets");
+const balance_1 = require("./commands/balance");
+const deposit_1 = require("./commands/deposit");
+const exercise_1 = require("./commands/exercise");
+const key_1 = require("./commands/key");
+const quote_1 = require("./commands/quote");
+const offer_1 = require("./commands/offer");
+const option_1 = require("./commands/option");
+const redeem_1 = require("./commands/redeem");
+const rfq_1 = require("./commands/rfq");
+const withdraw_1 = require("./commands/withdraw");
+/**
+ * Merge a subcommand's own options with the root program's global options
+ * (`--keypair`, `--rpc`, `--backend`, `--transport`) so either level can supply them.
+ */
+function withGlobals(cmd, opts) {
+    return { ...cmd.optsWithGlobals(), ...opts };
+}
+/** The root program's connection / wallet flags, shared by every command. */
+const GLOBAL_FLAGS = new Set([
+    "--keypair",
+    "--rpc",
+    "--backend",
+    "--transport",
+]);
+/**
+ * Surface the root program's global options in every (sub)command's `--help`
+ * and tint them so they read as inherited, not command-specific.
+ *
+ * `showGlobalOptions` adds the dedicated "Global Options:" section to subcommand
+ * help (commander hides inherited options there by default). We highlight via
+ * the option *description* rather than its term: commander@12 measures column
+ * widths with raw `String.length`, so colouring a term's flags would let its
+ * ANSI codes throw the alignment off — the trailing description column is safe.
+ */
+function highlightGlobalOptions(root) {
+    const isGlobal = (option) => GLOBAL_FLAGS.has(option.long ?? "");
+    const apply = (cmd) => {
+        cmd.configureHelp({
+            showGlobalOptions: true,
+            optionDescription(option) {
+                const description = commander_1.Help.prototype.optionDescription.call(this, option);
+                return isGlobal(option) ? picocolors_1.default.cyan(description) : description;
+            },
+        });
+        cmd.commands.forEach(apply);
+    };
+    apply(root);
+}
+const program = new commander_1.Command();
+program
+    .name("overcast")
+    .description("CLI for the Overcast Solana protocol (deposits, RFQ, RFQ quoting)")
+    .version("0.1.0")
+    .option("-k, --keypair <path|base58|json>", "wallet keypair (or OVERCAST_KEYPAIR)")
+    .option("--rpc <url>", "Solana RPC url (or SOLANA_RPC_URL)")
+    .option("--backend <url>", "Overcast backend url (or OVERCAST_BACKEND_URL)")
+    .addOption(new commander_1.Option("--transport <transport>", "RFQ client transport: polling or websocket (default websocket)").choices(["polling", "websocket"]));
+program
+    .command("deposit")
+    .description("Deposit funds into your protocol escrow vault")
+    .option("-m, --mint <id>", "asset mint to deposit")
+    .option("-a, --amount <n>", "amount in native units")
+    .action(async function (opts) {
+    await (0, deposit_1.deposit)(withGlobals(this, opts));
+});
+program
+    .command("withdraw")
+    .description("Withdraw funds from your protocol escrow vault")
+    .option("-m, --mint <id>", "asset mint to withdraw")
+    .option("-a, --amount <n>", "amount in native units")
+    .action(async function (opts) {
+    await (0, withdraw_1.withdraw)(withGlobals(this, opts));
+});
+program
+    .command("balance")
+    .description("Show a protocol escrow vault balance for an asset")
+    .option("-m, --mint <id>", "asset mint to check")
+    .option("-u, --user <id>", "vault owner to inspect (defaults to your wallet)")
+    .action(async function (opts) {
+    await (0, balance_1.balance)(withGlobals(this, opts));
+});
+const key = program
+    .command("key")
+    .description("Manage signing keys authorized to act for your wallet");
+key
+    .command("add")
+    .description("Authorize a key to sign operations on your wallet's behalf")
+    .argument("[pubkey]", "public key to authorize")
+    .action(async function (pubkey, opts) {
+    await (0, key_1.keyAdd)(withGlobals(this, { ...opts, key: pubkey }));
+});
+key
+    .command("remove")
+    .description("Revoke a previously authorized signing key")
+    .argument("[pubkey]", "public key to revoke")
+    .action(async function (pubkey, opts) {
+    await (0, key_1.keyRemove)(withGlobals(this, { ...opts, key: pubkey }));
+});
+const option = program.command("option").description("Inspect market options");
+option
+    .command("show")
+    .description("Show an option's terms and live claim state")
+    .option("-c, --collateral-offer <id>", "collateral offer id")
+    .option("-s, --settlement-offer <id>", "settlement offer id")
+    .action(async function (opts) {
+    await (0, option_1.optionShow)(withGlobals(this, opts));
+});
+option
+    .command("list")
+    .description("Browse curated market options from the backend")
+    .option("-m, --maker <id>", "filter by maker address")
+    .option("-t, --taker <id>", "filter by taker address")
+    .option("-a, --asset <id>", "filter by any asset leg")
+    .option("-n, --limit <n>", "max rows to return")
+    .action(async function (opts) {
+    await (0, option_1.optionList)(withGlobals(this, opts));
+});
+const offer = program.command("offer").description("Inspect open offers");
+offer
+    .command("show")
+    .description("Look up an open collateral or settlement offer by id")
+    .option("-i, --id <id>", "offer id")
+    .action(async function (opts) {
+    await (0, offer_1.offerShow)(withGlobals(this, opts));
+});
+offer
+    .command("list")
+    .description("Browse open collateral / settlement offers from the backend")
+    .option("-k, --kind <kind>", "collateral, settlement, or both (default)")
+    .option("-p, --party <id>", "filter by counterparty (maker/taker)")
+    .option("-a, --asset <id>", "filter by any asset leg")
+    .option("-n, --limit <n>", "max rows")
+    .action(async function (opts) {
+    await (0, offer_1.offerList)(withGlobals(this, opts));
+});
+program
+    .command("accept")
+    .description("Match a collateral and settlement offer to mint an option")
+    .option("-c, --collateral-offer <id>", "collateral offer id")
+    .option("-s, --settlement-offer <id>", "settlement offer id")
+    .action(async function (opts) {
+    await (0, accept_1.accept)(withGlobals(this, opts));
+});
+program
+    .command("exercise")
+    .description("Exercise an option you hold (swap settlement for collateral)")
+    .option("-c, --collateral-offer <id>", "collateral offer id")
+    .option("-s, --settlement-offer <id>", "settlement offer id")
+    .option("-a, --amount <n>", "exercise-claims to burn (native units)")
+    .action(async function (opts) {
+    await (0, exercise_1.exercise)(withGlobals(this, opts));
+});
+program
+    .command("redeem")
+    .description("Redeem an option's collateral back to the maker")
+    .option("-c, --collateral-offer <id>", "collateral offer id")
+    .option("-s, --settlement-offer <id>", "settlement offer id")
+    .option("-a, --amount <n>", "collateral-return claims to burn (native units)")
+    .action(async function (opts) {
+    await (0, redeem_1.redeem)(withGlobals(this, opts));
+});
+const rfq = program.command("rfq").description("Request-for-quote operations");
+rfq
+    .command("create")
+    .description("Create an RFQ, collect quotes, and accept one")
+    .action(async function (opts) {
+    await (0, rfq_1.rfqCreate)(withGlobals(this, opts));
+});
+program
+    .command("assets")
+    .description("List the backend's supported asset allowlist")
+    .action(async function (opts) {
+    await (0, assets_1.assetsList)(withGlobals(this, opts));
+});
+program
+    .command("quote")
+    .description("Run an RFQ quoter that auto-quotes incoming RFQs (Black-Scholes, or a webhook)")
+    .option("-s, --spread <pct>", "quoter edge over fair value, as a fraction (default 0.02)")
+    .option("--vol <sigma>", "annualized implied volatility, e.g. 0.8 (default 0.8)")
+    .option("--rate <r>", "annualized risk-free rate, e.g. 0.05 (default 0)")
+    .option("--webhook-url <url>", "POST each RFQ event to this local URL; its reply drives the quote (or OVERCAST_QUOTE_WEBHOOK_URL)")
+    .option("--webhook-timeout <ms>", "per-event webhook timeout in ms (default 5000)")
+    .action(async function (opts) {
+    await (0, quote_1.runQuoter)(withGlobals(this, opts));
+});
+highlightGlobalOptions(program);
+program.parseAsync(process.argv).catch((err) => {
+    console.error(picocolors_1.default.red(err.message));
+    process.exit(1);
+});

package/dist/client.d.ts

@@ -0,0 +1,12 @@
+import { OvercastApp } from "@overcast-xyz/core";
+import { SolanaLayer } from "@overcast-xyz/solana-client";
+import { CliConfig } from "./config";
+/**
+ * Build the CLI's {@link OvercastClient} from {@link CliConfig}.
+ *
+ * The config is mapped onto a {@link SolanaConfig} and handed to the
+ * {@link SolanaFactory}; everything the app exposes — signer, transaction
+ * writer, on-chain reader and RFQ channel — is then derived from that single
+ * config by {@link OvercastApp.create}.
+ */
+export declare function createClient(config: CliConfig): Promise<OvercastApp<SolanaLayer>>;

package/dist/client.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = createClient;
+const core_1 = require("@overcast-xyz/core");
+const solana_client_1 = require("@overcast-xyz/solana-client");
+const config_1 = require("./config");
+/**
+ * Build the CLI's {@link OvercastClient} from {@link CliConfig}.
+ *
+ * The config is mapped onto a {@link SolanaConfig} and handed to the
+ * {@link SolanaFactory}; everything the app exposes — signer, transaction
+ * writer, on-chain reader and RFQ channel — is then derived from that single
+ * config by {@link OvercastApp.create}.
+ */
+function createClient(config) {
+    const factory = new solana_client_1.SolanaFactory((0, config_1.toSolanaConfig)(config));
+    return core_1.OvercastApp.create({ factory });
+}

package/dist/commands/accept.d.ts

@@ -0,0 +1,11 @@
+import { GlobalFlags } from "../config";
+export interface AcceptOptions extends GlobalFlags {
+    collateralOffer?: string;
+    settlementOffer?: string;
+}
+/**
+ * `overcast accept` — match an existing collateral offer with a settlement
+ * offer to mint the option on-chain. Both offers are looked up by their
+ * content-address ids and shown for review before submitting.
+ */
+export declare function accept(opts: AcceptOptions): Promise<void>;

package/dist/commands/accept.js

@@ -0,0 +1,112 @@
+"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.accept = accept;
+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 accept` — match an existing collateral offer with a settlement
+ * offer to mint the option on-chain. Both offers are looked up by their
+ * content-address ids and shown for review before submitting.
+ */
+async function accept(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);
+    for (const [flag, value] of [
+        ["--collateral-offer", opts.collateralOffer],
+        ["--settlement-offer", opts.settlementOffer],
+    ]) {
+        if (value && (0, shared_1.validateAddress)(value)) {
+            throw new Error(`invalid ${flag} id: ${value}`);
+        }
+    }
+    p.intro(picocolors_1.default.cyan("Overcast accept"));
+    const collateralId = opts.collateralOffer ?? (await (0, shared_1.promptId)("Collateral offer id"));
+    const settlementId = opts.settlementOffer ?? (await (0, shared_1.promptId)("Settlement offer id"));
+    const spinner = p.spinner();
+    spinner.start("Looking up offers");
+    // Offers now share one namespace, so an id could resolve to either side; the
+    // match is only valid with a maker-side collateral offer and a taker-side
+    // settlement offer, so require each to be the expected side.
+    const [collateralOffer, settlementOffer] = await Promise.all([
+        app.chain.getOffer(collateralId),
+        app.chain.getOffer(settlementId),
+    ]);
+    if (!collateralOffer || collateralOffer.side !== "MAKER") {
+        spinner.stop(picocolors_1.default.red(`No maker (collateral) offer found for ${(0, shared_1.short)(collateralId)}.`));
+        return;
+    }
+    if (!settlementOffer || settlementOffer.side !== "TAKER") {
+        spinner.stop(picocolors_1.default.red(`No taker (settlement) offer found for ${(0, shared_1.short)(settlementId)}.`));
+        return;
+    }
+    spinner.stop("Offers found.");
+    // Both offers describe the same option terms; show the collateral leg's view
+    // plus the two counterparties so the match is reviewable.
+    p.note([
+        `Maker  ${(0, shared_1.short)(collateralOffer.creator)}`,
+        `Taker  ${(0, shared_1.short)(settlementOffer.creator)}`,
+        "",
+        (0, shared_1.describeOptionDetails)(collateralOffer.details, registry),
+    ].join("\n"), "Match");
+    if (!(await (0, shared_1.confirm)("Accept this match and mint the option?"))) {
+        p.outro(picocolors_1.default.yellow("Cancelled."));
+        return;
+    }
+    const submit = p.spinner();
+    submit.start("Accepting offer and minting option on-chain");
+    try {
+        const { hash } = await app.chain.acceptOffer(settlementOffer, collateralOffer);
+        submit.stop(picocolors_1.default.green(`Option minted. tx ${picocolors_1.default.bold(hash)}`));
+        // Surface the id pair so the new option can be inspected / exercised.
+        p.note([
+            `overcast option show \\`,
+            `  --collateral-offer ${collateralId} \\`,
+            `  --settlement-offer ${settlementId}`,
+        ].join("\n"), "Inspect the option");
+        p.outro(picocolors_1.default.green("Done."));
+    }
+    catch (err) {
+        submit.stop(picocolors_1.default.red(`Accept failed: ${err.message}`));
+        throw err;
+    }
+}

package/dist/commands/assets.d.ts

@@ -0,0 +1,9 @@
+import { GlobalFlags } from "../config";
+export type AssetsOptions = GlobalFlags;
+/**
+ * `overcast assets` — list the backend's asset allowlist via the off-chain
+ * {@link OvercastView}. This is the set of assets the protocol will accept on an
+ * RFQ / quote / offer, and the metadata every amount elsewhere is formatted
+ * against. Read-only: no wallet required.
+ */
+export declare function assetsList(opts: AssetsOptions): Promise<void>;