@overcast-xyz/cli 0.1.0

package/dist/commands/option.js

@@ -0,0 +1,138 @@
+"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.optionShow = optionShow;
+exports.optionList = optionList;
+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 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.
+ */
+async function optionShow(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);
+    // The "yours" rows / role need a wallet; without one we still show supplies.
+    const wallet = config.privateKey ? app.publicKey : null;
+    p.intro(picocolors_1.default.cyan("Overcast option"));
+    const option = await (0, shared_1.resolveOption)(app.chain, opts);
+    const spinner = p.spinner();
+    spinner.start("Reading claim state");
+    let exerciseSupply;
+    let redeemSupply;
+    let myExercise = null;
+    let myRedeem = null;
+    try {
+        [exerciseSupply, redeemSupply, myExercise, myRedeem] = await Promise.all([
+            app.chain.exerciseClaimsSupply(option),
+            app.chain.redeemClaimsSupply(option),
+            wallet ? app.chain.exerciseClaims(option, wallet) : Promise.resolve(null),
+            wallet ? app.chain.redeemClaims(option, wallet) : Promise.resolve(null),
+        ]);
+        spinner.stop("Claim state read.");
+    }
+    catch (err) {
+        spinner.stop(picocolors_1.default.red(`Read failed: ${err.message}`));
+        throw err;
+    }
+    p.note((0, shared_1.describeOptionDetails)(option.details, registry), `Option ${(0, shared_1.short)(option.id)}`);
+    // Flag the wallet's role (when known) so the "yours" rows are unambiguous.
+    const role = wallet === option.taker
+        ? picocolors_1.default.dim(" (you are the taker)")
+        : wallet === option.maker
+            ? picocolors_1.default.dim(" (you are the maker)")
+            : "";
+    // Only append "· yours N" when a wallet was supplied to read it.
+    const yours = (mine) => mine === null ? "" : ` · yours ${picocolors_1.default.bold(mine.toString())}`;
+    p.note([
+        `Maker        ${(0, shared_1.short)(option.maker)}`,
+        `Taker        ${(0, shared_1.short)(option.taker)}${role}`,
+        "",
+        `Exercise claims  outstanding ${picocolors_1.default.bold(exerciseSupply.toString())}${yours(myExercise)}`,
+        `Redeem claims    outstanding ${picocolors_1.default.bold(redeemSupply.toString())}${yours(myRedeem)}`,
+    ].join("\n"), "Claims");
+    p.outro(picocolors_1.default.green("Done."));
+}
+/**
+ * `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.
+ */
+async function optionList(opts) {
+    const config = (0, config_1.resolveConfig)(opts, { keypairOptional: true });
+    const app = await (0, client_1.createClient)(config);
+    const filter = {
+        maker: (0, shared_1.optionalAddress)("--maker", opts.maker),
+        taker: (0, shared_1.optionalAddress)("--taker", opts.taker),
+        asset: (0, shared_1.optionalAddress)("--asset", opts.asset),
+    };
+    const limit = (0, shared_1.parseLimit)(opts.limit);
+    p.intro(picocolors_1.default.cyan("Overcast options"));
+    const spinner = p.spinner();
+    spinner.start("Loading options");
+    try {
+        const page = await app.api.listOptions({
+            filter,
+            page: limit ? { limit } : undefined,
+        });
+        spinner.stop(`${page.items.length} option(s)`);
+        if (page.items.length === 0) {
+            p.outro(picocolors_1.default.yellow("No options match."));
+            return;
+        }
+        for (const option of page.items) {
+            // Options are identified by their (collateral, settlement) offer pair —
+            // there is no single option id — so both are shown for `option show`.
+            p.log.message([
+                (0, shared_1.summarizeCuratedDetails)(option.details),
+                picocolors_1.default.dim(`offers ${(0, shared_1.short)(option.collateralOffer)} / ${(0, shared_1.short)(option.settlementOffer)} · maker ${(0, shared_1.short)(option.maker)} · taker ${(0, shared_1.short)(option.taker)}`),
+            ].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;
+    }
+}

package/dist/commands/quote-webhook.d.ts

@@ -0,0 +1,36 @@
+import type { QuoteAcceptedPayload, QuoteNewPayload } from "@overcast-xyz/core";
+import type { QuotePricer } from "./quote";
+/** Connection settings for the quoter's webhook endpoint. */
+export interface WebhookConfig {
+    /** The developer's local endpoint; every event is POSTed here. */
+    url: string;
+    /** Per-request timeout. RFQs are time-boxed, so a slow endpoint is skipped. */
+    timeoutMs: number;
+}
+/**
+ * The lifecycle events we forward to the webhook. `newRfq` is the only
+ * *actionable* one today (its reply drives a quote); the rest are fire-and-forget
+ * notifications, giving the endpoint full lifecycle visibility.
+ */
+export type WebhookEventType = "newRfq" | "newQuote" | "quoteAccepted" | "rfqCancelled" | "rfqExpired" | "error";
+/**
+ * A {@link QuotePricer} that delegates pricing to the configured webhook: it
+ * POSTs the `newRfq` envelope and maps the reply to a {@link Premium}, or `null`
+ * to skip (on an explicit skip, a non-2xx, a timeout, or a malformed reply — the
+ * same "skip rather than quote on bad data" philosophy the built-in pricer uses).
+ *
+ * The CLI stays authoritative on the option terms — the endpoint only supplies
+ * the premium, which `completeOptionDetails` folds into the RFQ's legs — so a
+ * misbehaving endpoint can't tamper with the rest of the option.
+ */
+export declare function webhookPricer(cfg: WebhookConfig, maker: string): QuotePricer;
+/**
+ * Fire-and-forget notify the webhook of a non-actionable lifecycle event. Errors
+ * are swallowed (logged) so a flaky endpoint never breaks the socket handlers.
+ */
+export declare function postEvent(cfg: WebhookConfig, type: Exclude<WebhookEventType, "newRfq">, data: QuoteNewPayload | QuoteAcceptedPayload | {
+    rfqId: string;
+} | {
+    code: string;
+    message: string;
+}, maker: string): void;

package/dist/commands/quote-webhook.js

@@ -0,0 +1,152 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webhookPricer = webhookPricer;
+exports.postEvent = postEvent;
+const p = __importStar(require("@clack/prompts"));
+const core_1 = require("@overcast-xyz/core");
+/**
+ * A {@link QuotePricer} that delegates pricing to the configured webhook: it
+ * POSTs the `newRfq` envelope and maps the reply to a {@link Premium}, or `null`
+ * to skip (on an explicit skip, a non-2xx, a timeout, or a malformed reply — the
+ * same "skip rather than quote on bad data" philosophy the built-in pricer uses).
+ *
+ * The CLI stays authoritative on the option terms — the endpoint only supplies
+ * the premium, which `completeOptionDetails` folds into the RFQ's legs — so a
+ * misbehaving endpoint can't tamper with the rest of the option.
+ */
+function webhookPricer(cfg, maker) {
+    return async (rfq) => {
+        const res = await post(cfg, "newRfq", rfq, maker);
+        if (!res)
+            return null; // network error / timeout / non-2xx — already logged
+        if (res.status === 204)
+            return null; // no content → skip
+        let decision;
+        try {
+            decision = (await res.json());
+        }
+        catch {
+            warn(`webhook returned a non-JSON reply for RFQ ${short(rfq.rfqId)}`);
+            return null;
+        }
+        if (decision.action !== "quote") {
+            if (decision.action === "skip" && decision.reason) {
+                warn(`webhook skipped RFQ ${short(rfq.rfqId)}: ${decision.reason}`);
+            }
+            return null;
+        }
+        const { premiumAsset, premiumAmount } = decision.premium ?? {};
+        if (!premiumAsset || premiumAmount == null) {
+            warn(`webhook quote for RFQ ${short(rfq.rfqId)} is missing premium fields`);
+            return null;
+        }
+        try {
+            return { premiumAsset, premiumAmount: (0, core_1.amountFromWire)(premiumAmount) };
+        }
+        catch {
+            warn(`webhook quote for RFQ ${short(rfq.rfqId)} has a malformed premiumAmount "${premiumAmount}"`);
+            return null;
+        }
+    };
+}
+/**
+ * Fire-and-forget notify the webhook of a non-actionable lifecycle event. Errors
+ * are swallowed (logged) so a flaky endpoint never breaks the socket handlers.
+ */
+function postEvent(cfg, type, data, maker) {
+    void post(cfg, type, data, maker);
+}
+/* -------------------------------------------------------------------------- */
+/*  transport                                                                   */
+/* -------------------------------------------------------------------------- */
+/**
+ * POST an event envelope to the webhook, returning the {@link Response} on a 2xx
+ * or `null` on any failure (network error, timeout, or non-2xx status), logging
+ * the reason. Uses `AbortController` so a slow endpoint can't stall the quoter.
+ */
+async function post(cfg, type, data, maker) {
+    const envelope = {
+        type,
+        timestamp: Date.now(),
+        maker,
+        data,
+    };
+    const body = JSON.stringify(envelope);
+    const headers = {
+        "Content-Type": "application/json",
+        "X-Overcast-Event": type,
+        "X-Overcast-Timestamp": String(envelope.timestamp),
+    };
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), cfg.timeoutMs);
+    try {
+        const res = await fetch(cfg.url, {
+            method: "POST",
+            headers,
+            body,
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            warn(`webhook returned HTTP ${res.status} for ${type}`);
+            return null;
+        }
+        return res;
+    }
+    catch (err) {
+        const reason = err?.name === "AbortError"
+            ? `timed out after ${cfg.timeoutMs}ms`
+            : err.message;
+        warn(`webhook POST (${type}) failed: ${reason}`);
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/* -------------------------------------------------------------------------- */
+/*  logging                                                                     */
+/* -------------------------------------------------------------------------- */
+//
+// The `import type` from `./quote` is erased at runtime, so logging through the
+// same `@clack/prompts` channel the quote command uses introduces no import cycle
+// and keeps webhook warnings visually consistent with the rest of the quote output.
+function warn(message) {
+    p.log.warn(message);
+}
+/** 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/quote.d.ts

@@ -0,0 +1,37 @@
+import { NewRfqPayload } from "@overcast-xyz/core";
+import { GlobalFlags } from "../config";
+/** An RFQ quoter'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 QuoteOptions extends GlobalFlags {
+    /** Quoter 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 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}.
+ */
+export declare function runQuoter(opts: QuoteOptions): Promise<void>;