@overcast-xyz/cli 0.1.0

package/dist/commands/assets.js

@@ -0,0 +1,80 @@
+"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.assetsList = assetsList;
+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 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.
+ */
+async function assetsList(opts) {
+    const config = (0, config_1.resolveConfig)(opts, { keypairOptional: true });
+    const app = await (0, client_1.createClient)(config);
+    p.intro(picocolors_1.default.cyan("Overcast assets"));
+    const spinner = p.spinner();
+    spinner.start("Loading asset allowlist");
+    try {
+        const assets = await app.api.listAssets();
+        spinner.stop(`${assets.length} asset(s)`);
+        if (assets.length === 0) {
+            p.outro(picocolors_1.default.yellow("Backend has no supported assets."));
+            return;
+        }
+        p.note(assets
+            .map((a) => {
+            const symbol = picocolors_1.default.bold((a.symbol ?? "?").padEnd(6));
+            const name = a.name ? ` ${a.name}` : "";
+            const price = a.lastKnownPriceUsd != null
+                ? picocolors_1.default.dim(` ~$${a.lastKnownPriceUsd}`)
+                : "";
+            return `${symbol} ${(0, shared_1.short)(a.address)}${name}${picocolors_1.default.dim(` · ${a.decimals ?? 0}dp`)}${price}`;
+        })
+            .join("\n"), "Allowlist");
+        p.outro(picocolors_1.default.green("Done."));
+    }
+    catch (err) {
+        spinner.stop(picocolors_1.default.red(`Load failed: ${err.message}`));
+        throw err;
+    }
+}

package/dist/commands/balance.d.ts

@@ -0,0 +1,9 @@
+import { GlobalFlags } from "../config";
+export interface BalanceOptions extends GlobalFlags {
+    /** Asset mint to check; prompts from the allowlist when omitted. */
+    mint?: string;
+    /** Vault owner to inspect; defaults to the wallet. */
+    user?: string;
+}
+/** `overcast balance` — show a user's protocol escrow vault balance for an asset. */
+export declare function balance(opts: BalanceOptions): Promise<void>;

package/dist/commands/balance.js

@@ -0,0 +1,74 @@
+"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.balance = balance;
+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");
+/** `overcast balance` — show a user's protocol escrow vault balance for an asset. */
+async function balance(opts) {
+    const config = (0, config_1.resolveConfig)(opts, { keypairOptional: true });
+    if (opts.user && (0, shared_1.validateAddress)(opts.user)) {
+        throw new Error(`invalid --user address: ${opts.user}`);
+    }
+    // Whose vault to read: an explicit --user, else the wallet's own — but only
+    // when a keypair was supplied. Resolve this up front so a misuse fails fast,
+    // before any network round-trip.
+    if (!opts.user && !config.privateKey) {
+        throw new Error("pass --user <address>, or a --keypair to read your own vault");
+    }
+    const app = await (0, client_1.createClient)(config);
+    const registry = await (0, shared_1.loadRegistry)(app.api);
+    const user = opts.user ?? app.publicKey;
+    const asset = opts.mint
+        ? registry.getOrDefault(opts.mint)
+        : await (0, shared_1.pickAsset)(registry, "Asset to check");
+    const spinner = p.spinner();
+    spinner.start(`Reading vault balance for ${asset.symbol ?? asset.address}`);
+    try {
+        const amount = await app.chain.balance(user, asset);
+        spinner.stop(`${picocolors_1.default.bold((0, core_1.formatAssetAmount)(amount, asset))} ${picocolors_1.default.dim(`(vault of ${user})`)}`);
+    }
+    catch (err) {
+        spinner.stop(picocolors_1.default.red(`Balance lookup failed: ${err.message}`));
+        throw err;
+    }
+}

package/dist/commands/deposit.d.ts

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

package/dist/commands/deposit.js

@@ -0,0 +1,67 @@
+"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.deposit = deposit;
+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 deposit` — credit the wallet's protocol escrow vault. */
+async function deposit(opts) {
+    const config = (0, config_1.resolveConfig)(opts);
+    const app = await (0, client_1.createClient)(config);
+    const mint = opts.mint ?? (await (0, shared_1.promptMint)("Mint to deposit"));
+    const amount = opts.amount
+        ? BigInt(opts.amount)
+        : await (0, shared_1.promptAmount)("Amount to deposit (native units)");
+    const spinner = p.spinner();
+    spinner.start(`Depositing ${amount} of ${mint}`);
+    try {
+        const { hash } = await app.chain.deposit({
+            depositor: app.publicKey,
+            mint,
+            amount,
+        });
+        spinner.stop(picocolors_1.default.green(`Deposited. tx ${picocolors_1.default.bold(hash)}`));
+    }
+    catch (err) {
+        spinner.stop(picocolors_1.default.red(`Deposit failed: ${err.message}`));
+        throw err;
+    }
+}

package/dist/commands/exercise.d.ts

@@ -0,0 +1,14 @@
+import { GlobalFlags } from "../config";
+export interface ExerciseOptions extends GlobalFlags {
+    collateralOffer?: string;
+    settlementOffer?: string;
+    /** Native-unit amount of exercise claims to burn. */
+    amount?: string;
+}
+/**
+ * `overcast exercise` — exercise (burn exercise-claims of) an option the wallet
+ * holds, swapping settlement for the underlying collateral. The wallet must be
+ * the option's taker; we surface the wallet's claim balance and the terms
+ * before submitting.
+ */
+export declare function exercise(opts: ExerciseOptions): Promise<void>;

package/dist/commands/exercise.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.exercise = exercise;
+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 exercise` — exercise (burn exercise-claims of) an option the wallet
+ * holds, swapping settlement for the underlying collateral. The wallet must be
+ * the option's taker; we surface the wallet's claim balance and the terms
+ * before submitting.
+ */
+async function exercise(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 exercise"));
+    const option = await (0, shared_1.resolveOption)(app.chain, opts);
+    if (app.publicKey !== option.taker) {
+        p.log.warn(`This wallet is not the option taker (${(0, shared_1.short)(option.taker)}); the exercise will fail.`);
+    }
+    const claims = await app.chain.exerciseClaims(option, app.publicKey);
+    p.note([
+        (0, shared_1.describeOptionDetails)(option.details, registry),
+        "",
+        `Your exercise 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 exercise claims for this option."));
+        return;
+    }
+    const amount = opts.amount != null
+        ? BigInt(opts.amount)
+        : await (0, shared_1.promptAmountUpTo)("Amount to exercise", claims);
+    if (!(await (0, shared_1.confirm)(`Exercise ${amount} claim(s)?`))) {
+        p.outro(picocolors_1.default.yellow("Cancelled."));
+        return;
+    }
+    const spinner = p.spinner();
+    spinner.start(`Exercising ${amount} claim(s)`);
+    try {
+        const { hash } = await app.chain.exerciseOption(option, amount);
+        spinner.stop(picocolors_1.default.green(`Exercised. tx ${picocolors_1.default.bold(hash)}`));
+        p.outro(picocolors_1.default.green("Done."));
+    }
+    catch (err) {
+        spinner.stop(picocolors_1.default.red(`Exercise failed: ${err.message}`));
+        throw err;
+    }
+}

package/dist/commands/key.d.ts

@@ -0,0 +1,15 @@
+import { GlobalFlags } from "../config";
+export interface KeyOptions extends GlobalFlags {
+    key?: string;
+}
+/**
+ * `overcast key add` — authorize a key to sign operations on your wallet's
+ * behalf. Registers a signing-key record owned by your wallet so an operator can
+ * later submit your delegable calls with an operation signed by `key`.
+ */
+export declare function keyAdd(opts: KeyOptions): Promise<void>;
+/**
+ * `overcast key remove` — revoke a previously authorized signing key, closing
+ * its record (rent refunded). Operations signed with `key` are rejected after.
+ */
+export declare function keyRemove(opts: KeyOptions): Promise<void>;

package/dist/commands/key.js

@@ -0,0 +1,98 @@
+"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.keyAdd = keyAdd;
+exports.keyRemove = keyRemove;
+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");
+/**
+ * Resolve the signing key from the `--key` flag (or a positional arg surfaced as
+ * `opts.key`), prompting with base58 validation when absent. Throws on a
+ * malformed flag value so a typo fails fast instead of hitting the chain.
+ */
+async function resolveKey(opts, message) {
+    if (opts.key) {
+        const trimmed = opts.key.trim();
+        if ((0, shared_1.validateAddress)(trimmed))
+            throw new Error(`invalid key: ${opts.key}`);
+        return trimmed;
+    }
+    return (0, shared_1.promptId)(message);
+}
+/**
+ * `overcast key add` — authorize a key to sign operations on your wallet's
+ * behalf. Registers a signing-key record owned by your wallet so an operator can
+ * later submit your delegable calls with an operation signed by `key`.
+ */
+async function keyAdd(opts) {
+    const config = (0, config_1.resolveConfig)(opts);
+    const app = await (0, client_1.createClient)(config);
+    const key = await resolveKey(opts, "Public key to authorize");
+    const spinner = p.spinner();
+    spinner.start(`Authorizing ${key}`);
+    try {
+        const { hash } = await app.chain.addAuthorizedKey(key);
+        spinner.stop(picocolors_1.default.green(`Authorized. tx ${picocolors_1.default.bold(hash)}`));
+    }
+    catch (err) {
+        spinner.stop(picocolors_1.default.red(`Authorize failed: ${err.message}`));
+        throw err;
+    }
+}
+/**
+ * `overcast key remove` — revoke a previously authorized signing key, closing
+ * its record (rent refunded). Operations signed with `key` are rejected after.
+ */
+async function keyRemove(opts) {
+    const config = (0, config_1.resolveConfig)(opts);
+    const app = await (0, client_1.createClient)(config);
+    const key = await resolveKey(opts, "Public key to revoke");
+    const spinner = p.spinner();
+    spinner.start(`Revoking ${key}`);
+    try {
+        const { hash } = await app.chain.removeAuthorizedKey(key);
+        spinner.stop(picocolors_1.default.green(`Revoked. tx ${picocolors_1.default.bold(hash)}`));
+    }
+    catch (err) {
+        spinner.stop(picocolors_1.default.red(`Revoke failed: ${err.message}`));
+        throw err;
+    }
+}

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

@@ -0,0 +1,36 @@
+import type { QuoteAcceptedPayload, QuoteNewPayload } from "@overcast/core";
+import type { QuotePricer } from "./mm";
+/** Connection settings for the market maker'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/mm-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/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 MM.
+ */
+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 `./mm` is erased at runtime, so logging through the same
+// `@clack/prompts` channel the MM command uses introduces no import cycle and
+// keeps webhook warnings visually consistent with the rest of the MM 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)}`;
+}