@raintree-technology/perps 0.1.0

package/dist/commands/operator/index.js

@@ -0,0 +1,146 @@
+import { getOutputOptions } from "../../cli/program.js";
+import { output, outputError, outputSuccess } from "../../cli/output.js";
+import { withJsonContract } from "../../lib/contracts.js";
+import { readOperatorState, setKillSwitch } from "../../lib/operator-state.js";
+import { getTelemetrySnapshot, resetTelemetry, summarizeFailureRates } from "../../lib/telemetry.js";
+export function registerOperatorCommands(program) {
+    const operator = program
+        .command("operator")
+        .alias("bot")
+        .description("Operator controls, heartbeat, and kill-switch");
+    operator
+        .command("status")
+        .description("Show latest heartbeat and kill-switch status")
+        .action(function () {
+        const outputOpts = getOutputOptions(this);
+        const state = readOperatorState();
+        const heartbeat = state.heartbeat;
+        const halted = state.killSwitch.enabled || (heartbeat?.halted ?? false);
+        const haltReason = state.killSwitch.enabled
+            ? state.killSwitch.reason ?? "Manual kill switch enabled"
+            : heartbeat?.haltReason;
+        const status = {
+            halted,
+            haltReason,
+            killSwitch: state.killSwitch,
+            heartbeat: heartbeat ?? null,
+        };
+        if (outputOpts.json) {
+            output(status, outputOpts);
+            return;
+        }
+        console.log("\nOperator Status:\n");
+        console.log(`  Halted:      ${halted ? "YES" : "NO"}`);
+        if (haltReason) {
+            console.log(`  Halt reason: ${haltReason}`);
+        }
+        console.log(`  Kill switch: ${state.killSwitch.enabled ? "ON" : "OFF"}`);
+        if (state.killSwitch.updatedAt > 0) {
+            console.log(`  Updated:     ${new Date(state.killSwitch.updatedAt).toISOString()}`);
+        }
+        console.log("");
+        if (!heartbeat) {
+            console.log("  No heartbeat recorded yet.");
+            console.log("  Run an order/arb execution command to emit a heartbeat snapshot.\n");
+            return;
+        }
+        console.log("  Latest Heartbeat:");
+        console.log(`    Exchange:  ${heartbeat.exchange}`);
+        if (heartbeat.market)
+            console.log(`    Market:    ${heartbeat.market}`);
+        console.log(`    Equity:    $${heartbeat.equity.toFixed(2)}`);
+        console.log(`    Exposure:  $${heartbeat.exposureUsd.toFixed(2)}`);
+        console.log(`    Drawdown:  ${heartbeat.drawdownPct.toFixed(2)}%`);
+        console.log(`    Peak:      $${heartbeat.peakEquity.toFixed(2)}`);
+        console.log(`    Halted:    ${heartbeat.halted ? "YES" : "NO"}`);
+        if (heartbeat.haltReason) {
+            console.log(`    Reason:    ${heartbeat.haltReason}`);
+        }
+        console.log(`    Updated:   ${new Date(heartbeat.updatedAt).toISOString()} (${formatAge(Date.now() - heartbeat.updatedAt)} ago)`);
+        console.log("");
+    });
+    operator
+        .command("halt [reason]")
+        .description("Enable manual kill switch")
+        .action(function (reason) {
+        const outputOpts = getOutputOptions(this);
+        const state = setKillSwitch(true, reason);
+        if (outputOpts.json) {
+            output({ success: true, killSwitch: state.killSwitch }, outputOpts);
+            return;
+        }
+        outputSuccess("Kill switch enabled");
+        if (state.killSwitch.reason) {
+            console.log(`  Reason: ${state.killSwitch.reason}`);
+        }
+        console.log("");
+    });
+    operator
+        .command("resume")
+        .description("Disable manual kill switch")
+        .action(function () {
+        const outputOpts = getOutputOptions(this);
+        const state = setKillSwitch(false);
+        if (outputOpts.json) {
+            output({ success: true, killSwitch: state.killSwitch }, outputOpts);
+            return;
+        }
+        outputSuccess("Kill switch disabled");
+        if (state.heartbeat?.halted) {
+            outputError("Circuit breaker is still halted by drawdown. Use safer sizing or reset state if intentional.");
+        }
+        console.log("");
+    });
+    operator
+        .command("telemetry")
+        .description("Show auth/funding reliability telemetry")
+        .option("--reset", "Reset telemetry counters after printing")
+        .action(function () {
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        const snapshot = getTelemetrySnapshot();
+        const rates = summarizeFailureRates(snapshot);
+        if (outputOpts.json) {
+            output(withJsonContract("operator.telemetry.snapshot", {
+                snapshot,
+                rates,
+            }), outputOpts);
+        }
+        else {
+            console.log("\nTelemetry:\n");
+            console.log(`  Updated: ${new Date(snapshot.updatedAt).toISOString()}`);
+            console.log(`  Counters: ${Object.keys(snapshot.counters).length}`);
+            if (rates.length === 0) {
+                console.log("  No telemetry events recorded yet.\n");
+            }
+            else {
+                console.log("");
+                for (const row of rates) {
+                    console.log(`  ${row.metric}: total=${row.total} failRate=${(row.failureRate * 100).toFixed(1)}% successRate=${(row.successRate * 100).toFixed(1)}%`);
+                }
+                console.log("");
+            }
+        }
+        if (opts.reset) {
+            resetTelemetry();
+            if (!outputOpts.json) {
+                outputSuccess("Telemetry counters reset");
+            }
+        }
+    });
+}
+function formatAge(ms) {
+    if (ms < 1_000)
+        return `${ms}ms`;
+    const seconds = Math.floor(ms / 1_000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ${seconds % 60}s`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ${minutes % 60}m`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ${hours % 24}h`;
+}

package/dist/commands/order/cancel-simple.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simple cancel order command using the adapter interface
+ */
+import { Command } from "commander";
+export declare function registerCancelOrderSimpleCommand(order: Command): void;

package/dist/commands/order/cancel-simple.js

@@ -0,0 +1,104 @@
+/**
+ * Simple cancel order command using the adapter interface
+ */
+import { getContext, getOutputOptions, getSelectedExchange } from "../../cli/program.js";
+import { output, outputError, outputSuccess } from "../../cli/output.js";
+import { getExchangeAdapter } from "../../lib/exchange.js";
+import { getExchangeCredentials } from "../../lib/config.js";
+export function registerCancelOrderSimpleCommand(order) {
+    order
+        .command("cancel <orderId> <symbol>")
+        .description("Cancel an order by ID")
+        .action(async function (orderId, symbol) {
+        const ctx = getContext(this);
+        const outputOpts = getOutputOptions(this);
+        const exchangeId = getSelectedExchange(this);
+        let connected = false;
+        try {
+            const adapter = getExchangeAdapter();
+            const credentials = getExchangeCredentials(ctx.config, exchangeId, {
+                requireTrading: true,
+            });
+            await adapter.connect({
+                testnet: ctx.config.testnet,
+                rpcUrl: credentials.fullnodeUrl,
+                wsUrl: credentials.wsUrl,
+                credentials,
+            });
+            connected = true;
+            // Normalize market
+            let market = symbol.toUpperCase();
+            if (!market.includes("-")) {
+                market = `${market}-PERP`;
+            }
+            const success = await adapter.cancelOrder({
+                orderId,
+                market,
+            });
+            if (outputOpts.json) {
+                output({ success, orderId, market }, outputOpts);
+            }
+            else {
+                if (success) {
+                    outputSuccess(`Order ${orderId} cancelled`);
+                }
+                else {
+                    outputError(`Failed to cancel order ${orderId}`);
+                }
+            }
+        }
+        catch (err) {
+            outputError(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+        finally {
+            if (connected)
+                await getExchangeAdapter().disconnect().catch(() => undefined);
+        }
+    });
+    // Cancel all orders
+    order
+        .command("cancel-all [symbol]")
+        .description("Cancel all open orders (optionally for a specific market)")
+        .action(async function (symbol) {
+        const ctx = getContext(this);
+        const outputOpts = getOutputOptions(this);
+        const exchangeId = getSelectedExchange(this);
+        let connected = false;
+        try {
+            const adapter = getExchangeAdapter();
+            const credentials = getExchangeCredentials(ctx.config, exchangeId, {
+                requireTrading: true,
+            });
+            await adapter.connect({
+                testnet: ctx.config.testnet,
+                rpcUrl: credentials.fullnodeUrl,
+                wsUrl: credentials.wsUrl,
+                credentials,
+            });
+            connected = true;
+            let market;
+            if (symbol) {
+                market = symbol.toUpperCase();
+                if (!market.includes("-")) {
+                    market = `${market}-PERP`;
+                }
+            }
+            const count = await adapter.cancelAllOrders(market);
+            if (outputOpts.json) {
+                output({ cancelled: count, market: market ?? "all" }, outputOpts);
+            }
+            else {
+                outputSuccess(`Cancelled ${count} orders${market ? ` for ${market}` : ""}`);
+            }
+        }
+        catch (err) {
+            outputError(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+        finally {
+            if (connected)
+                await getExchangeAdapter().disconnect().catch(() => undefined);
+        }
+    });
+}

package/dist/commands/order/index.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerOrderCommands(program: Command): void;

package/dist/commands/order/index.js

@@ -0,0 +1,13 @@
+import { registerLimitOrderSimpleCommand } from "./limit-simple.js";
+import { registerMarketOrderSimpleCommand } from "./market-simple.js";
+import { registerCancelOrderSimpleCommand } from "./cancel-simple.js";
+import { registerTriggerOrderSimpleCommands } from "./trigger-simple.js";
+export function registerOrderCommands(program) {
+    const order = program
+        .command("order")
+        .description("Order management and trading (requires authentication)");
+    registerLimitOrderSimpleCommand(order);
+    registerMarketOrderSimpleCommand(order);
+    registerTriggerOrderSimpleCommands(order);
+    registerCancelOrderSimpleCommand(order);
+}

package/dist/commands/order/limit-simple.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simple limit order command using the adapter interface
+ */
+import { Command } from "commander";
+export declare function registerLimitOrderSimpleCommand(order: Command): void;

package/dist/commands/order/limit-simple.js

@@ -0,0 +1,195 @@
+/**
+ * Simple limit order command using the adapter interface
+ */
+import { getContext, getOutputOptions, getSelectedExchange } from "../../cli/program.js";
+import { output, outputError, outputSuccess } from "../../cli/output.js";
+import { getExchangeAdapter } from "../../lib/exchange.js";
+import { getExchangeCredentials } from "../../lib/config.js";
+import { RiskPolicyMiddleware } from "../../lib/risk/policy-middleware.js";
+import { executeOrderWithSafety } from "../../lib/execution/safety.js";
+import { runWithExecutionJournal } from "../../lib/execution/journal.js";
+import { normalizeMarket, normalizeSide } from "./shared.js";
+import { withJsonContract } from "../../lib/contracts.js";
+import { inferExitCode } from "../../lib/exit-codes.js";
+export function registerLimitOrderSimpleCommand(order) {
+    order
+        .command("limit <side> <symbol> <size> <price>")
+        .description("Place a limit order (side: buy/long or sell/short)")
+        .option("--reduce-only", "Reduce-only order")
+        .option("--post-only", "Post-only order (maker only)")
+        .option("--confidence <0-1>", "Signal confidence for risk policy (default: 1.0)")
+        .option("--tp <pct>", "Attach take-profit (% from entry)")
+        .option("--sl <pct>", "Attach stop-loss (% from entry)")
+        .option("--no-close-then-flip", "Disable auto close-then-flip behavior")
+        .option("--idempotency-key <key>", "Idempotency key for safe retries")
+        .action(async function (side, symbol, size, price) {
+        const ctx = getContext(this);
+        const outputOpts = getOutputOptions(this);
+        const exchangeId = getSelectedExchange(this);
+        const opts = this.opts();
+        try {
+            // Normalize inputs
+            const market = normalizeMarket(symbol);
+            const requestedSize = parseFloat(size);
+            if (!Number.isFinite(requestedSize) || requestedSize <= 0) {
+                throw new Error("Size must be a positive number");
+            }
+            const limitPrice = parseFloat(price);
+            if (!Number.isFinite(limitPrice) || limitPrice <= 0) {
+                throw new Error("Price must be a positive number");
+            }
+            const normalizedSide = normalizeSide(side);
+            const closeThenFlip = opts.closeThenFlip ?? true;
+            const confidence = opts.confidence ? parseFloat(opts.confidence) : 1;
+            if (!Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+                throw new Error("Confidence must be a number between 0 and 1");
+            }
+            const shouldAttachTpSl = opts.tp !== undefined || opts.sl !== undefined;
+            const tp = opts.tp !== undefined ? parseFloat(opts.tp) : ctx.config.executionSafety.takeProfitPct;
+            const sl = opts.sl !== undefined ? parseFloat(opts.sl) : ctx.config.executionSafety.stopLossPct;
+            if (shouldAttachTpSl) {
+                if (!Number.isFinite(tp) || tp <= 0)
+                    throw new Error("TP must be a positive number");
+                if (!Number.isFinite(sl) || sl <= 0)
+                    throw new Error("SL must be a positive number");
+            }
+            const adapter = getExchangeAdapter();
+            const credentials = getExchangeCredentials(ctx.config, exchangeId, {
+                requireTrading: true,
+            });
+            await adapter.connect({
+                testnet: ctx.config.testnet,
+                rpcUrl: credentials.fullnodeUrl,
+                wsUrl: credentials.wsUrl,
+                credentials,
+            });
+            try {
+                const riskPolicy = new RiskPolicyMiddleware(ctx.config, exchangeId);
+                const riskDecision = await riskPolicy.evaluateOrder(adapter, {
+                    market,
+                    side: normalizedSide,
+                    requestedSizeBase: requestedSize,
+                    referencePriceUsd: limitPrice,
+                    confidence,
+                    reason: "cli:order:limit",
+                });
+                if (!riskDecision.allowed || riskDecision.adjustedSizeBase <= 0) {
+                    throw new Error(riskDecision.reason ?? "Order blocked by risk policy");
+                }
+                const finalSize = riskDecision.adjustedSizeBase;
+                const journaled = await runWithExecutionJournal({
+                    idempotencyKey: opts.idempotencyKey,
+                    metadata: {
+                        command: "order.limit",
+                        exchange: exchangeId,
+                        testnet: ctx.config.testnet,
+                        market,
+                        side: normalizedSide,
+                        orderType: "limit",
+                    },
+                    request: {
+                        market,
+                        side: normalizedSide,
+                        requestedSize: requestedSize.toFixed(8),
+                        limitPrice: limitPrice.toFixed(8),
+                        reduceOnly: opts.reduceOnly ?? false,
+                        postOnly: opts.postOnly ?? false,
+                        confidence,
+                        closeThenFlip,
+                        tp: shouldAttachTpSl ? tp : null,
+                        sl: shouldAttachTpSl ? sl : null,
+                    },
+                    execute: async () => {
+                        const execution = await executeOrderWithSafety(adapter, {
+                            market,
+                            side: normalizedSide,
+                            type: "limit",
+                            size: finalSize.toFixed(8),
+                            price: limitPrice.toString(),
+                            reduceOnly: opts.reduceOnly,
+                            postOnly: opts.postOnly,
+                        }, {
+                            closeThenFlip,
+                            spreadAwarePricing: false,
+                            attachTpSl: shouldAttachTpSl,
+                            tpSlConfig: shouldAttachTpSl
+                                ? { takeProfitPct: tp, stopLossPct: sl }
+                                : undefined,
+                        });
+                        return {
+                            order: execution.order,
+                            risk: {
+                                requestedSize,
+                                adjustedSize: finalSize,
+                                adjustedNotionalUsd: riskDecision.adjustedSizeUsd,
+                                referencePrice: limitPrice,
+                            },
+                            safety: {
+                                closedOppositePosition: execution.closedOppositePosition,
+                                tpSlOrderIds: execution.tpSlOrderIds,
+                            },
+                        };
+                    },
+                });
+                const response = {
+                    ...journaled.result.order,
+                    risk: journaled.result.risk,
+                    safety: journaled.result.safety,
+                    idempotency: {
+                        key: journaled.idempotencyKey,
+                        replayed: journaled.replayed,
+                        autoGenerated: journaled.autoGeneratedKey,
+                        journalId: journaled.journalId,
+                    },
+                };
+                if (outputOpts.json) {
+                    output(withJsonContract("order.execution.result", {
+                        executionStatus: journaled.replayed ? "replayed" : "executed",
+                        ...response,
+                    }), outputOpts);
+                }
+                else {
+                    outputSuccess(journaled.replayed ? "Order replayed from idempotency journal!" : "Order placed!");
+                    console.log(`  Order ID:  ${response.id}`);
+                    console.log(`  Market:    ${response.market}`);
+                    console.log(`  Side:      ${response.side.toUpperCase()}`);
+                    console.log(`  Size:      ${response.size}`);
+                    console.log(`  Price:     $${response.price}`);
+                    console.log(`  Status:    ${response.status}`);
+                    if (Math.abs(response.risk.adjustedSize - response.risk.requestedSize) > 1e-12) {
+                        console.log(`  Risk Size: adjusted from ${response.risk.requestedSize} to ${response.risk.adjustedSize.toFixed(8)}`);
+                    }
+                    if (response.safety.closedOppositePosition) {
+                        console.log("  Safety:    closed opposite position before opening new side");
+                    }
+                    if (response.safety.tpSlOrderIds.length > 0) {
+                        console.log(`  TP/SL:     attached (${response.safety.tpSlOrderIds.join(", ")})`);
+                    }
+                    console.log(`  Idempotency: ${response.idempotency.key}` +
+                        (response.idempotency.replayed ? " (replayed)" : ""));
+                    console.log("");
+                }
+            }
+            finally {
+                await adapter.disconnect();
+            }
+        }
+        catch (err) {
+            const code = inferExitCode(err);
+            const message = err instanceof Error ? err.message : String(err);
+            if (outputOpts.json) {
+                output(withJsonContract("order.execution.result", {
+                    status: "error",
+                    error: {
+                        message,
+                        exitCode: code,
+                    },
+                }), outputOpts);
+            }
+            else {
+                outputError(message);
+            }
+            process.exit(code);
+        }
+    });
+}

package/dist/commands/order/market-simple.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simple market order command using the adapter interface
+ */
+import { Command } from "commander";
+export declare function registerMarketOrderSimpleCommand(order: Command): void;

package/dist/commands/order/market-simple.js

@@ -0,0 +1,190 @@
+/**
+ * Simple market order command using the adapter interface
+ */
+import { getContext, getOutputOptions, getSelectedExchange } from "../../cli/program.js";
+import { output, outputError, outputSuccess } from "../../cli/output.js";
+import { getExchangeAdapter } from "../../lib/exchange.js";
+import { getExchangeCredentials } from "../../lib/config.js";
+import { RiskPolicyMiddleware } from "../../lib/risk/policy-middleware.js";
+import { executeOrderWithSafety } from "../../lib/execution/safety.js";
+import { runWithExecutionJournal } from "../../lib/execution/journal.js";
+import { normalizeMarket, normalizeSide } from "./shared.js";
+import { withJsonContract } from "../../lib/contracts.js";
+import { inferExitCode } from "../../lib/exit-codes.js";
+export function registerMarketOrderSimpleCommand(order) {
+    order
+        .command("market <side> <symbol> <size>")
+        .description("Place a market order (side: buy/long or sell/short)")
+        .option("--reduce-only", "Reduce-only order")
+        .option("--confidence <0-1>", "Signal confidence for risk policy (default: 1.0)")
+        .option("--tp <pct>", "Attach take-profit (% from entry)")
+        .option("--sl <pct>", "Attach stop-loss (% from entry)")
+        .option("--no-close-then-flip", "Disable auto close-then-flip behavior")
+        .option("--no-spread-aware", "Disable spread-aware execution pricing")
+        .option("--idempotency-key <key>", "Idempotency key for safe retries")
+        .action(async function (side, symbol, size) {
+        const ctx = getContext(this);
+        const outputOpts = getOutputOptions(this);
+        const exchangeId = getSelectedExchange(this);
+        const opts = this.opts();
+        try {
+            // Normalize inputs
+            const market = normalizeMarket(symbol);
+            const requestedSize = parseFloat(size);
+            if (!Number.isFinite(requestedSize) || requestedSize <= 0) {
+                throw new Error("Size must be a positive number");
+            }
+            const normalizedSide = normalizeSide(side);
+            const closeThenFlip = opts.closeThenFlip ?? true;
+            const spreadAware = opts.spreadAware ?? true;
+            const confidence = opts.confidence ? parseFloat(opts.confidence) : 1;
+            if (!Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+                throw new Error("Confidence must be a number between 0 and 1");
+            }
+            const shouldAttachTpSl = opts.tp !== undefined || opts.sl !== undefined;
+            const tp = opts.tp !== undefined ? parseFloat(opts.tp) : ctx.config.executionSafety.takeProfitPct;
+            const sl = opts.sl !== undefined ? parseFloat(opts.sl) : ctx.config.executionSafety.stopLossPct;
+            if (shouldAttachTpSl) {
+                if (!Number.isFinite(tp) || tp <= 0)
+                    throw new Error("TP must be a positive number");
+                if (!Number.isFinite(sl) || sl <= 0)
+                    throw new Error("SL must be a positive number");
+            }
+            const adapter = getExchangeAdapter();
+            const credentials = getExchangeCredentials(ctx.config, exchangeId, {
+                requireTrading: true,
+            });
+            await adapter.connect({
+                testnet: ctx.config.testnet,
+                rpcUrl: credentials.fullnodeUrl,
+                wsUrl: credentials.wsUrl,
+                credentials,
+            });
+            try {
+                const riskPolicy = new RiskPolicyMiddleware(ctx.config, exchangeId);
+                const riskDecision = await riskPolicy.evaluateOrder(adapter, {
+                    market,
+                    side: normalizedSide,
+                    requestedSizeBase: requestedSize,
+                    confidence,
+                    reason: "cli:order:market",
+                });
+                if (!riskDecision.allowed || riskDecision.adjustedSizeBase <= 0) {
+                    throw new Error(riskDecision.reason ?? "Order blocked by risk policy");
+                }
+                const finalSize = riskDecision.adjustedSizeBase;
+                const journaled = await runWithExecutionJournal({
+                    idempotencyKey: opts.idempotencyKey,
+                    metadata: {
+                        command: "order.market",
+                        exchange: exchangeId,
+                        testnet: ctx.config.testnet,
+                        market,
+                        side: normalizedSide,
+                        orderType: "market",
+                    },
+                    request: {
+                        market,
+                        side: normalizedSide,
+                        requestedSize: requestedSize.toFixed(8),
+                        reduceOnly: opts.reduceOnly ?? false,
+                        confidence,
+                        closeThenFlip,
+                        spreadAware,
+                        spreadOffset: ctx.config.executionSafety.spreadOffset,
+                        tp: shouldAttachTpSl ? tp : null,
+                        sl: shouldAttachTpSl ? sl : null,
+                    },
+                    execute: async () => {
+                        const execution = await executeOrderWithSafety(adapter, {
+                            market,
+                            side: normalizedSide,
+                            type: "market",
+                            size: finalSize.toFixed(8),
+                            reduceOnly: opts.reduceOnly,
+                        }, {
+                            closeThenFlip,
+                            spreadAwarePricing: spreadAware,
+                            spreadOffset: ctx.config.executionSafety.spreadOffset,
+                            attachTpSl: shouldAttachTpSl,
+                            tpSlConfig: shouldAttachTpSl
+                                ? { takeProfitPct: tp, stopLossPct: sl }
+                                : undefined,
+                        });
+                        return {
+                            order: execution.order,
+                            risk: {
+                                requestedSize,
+                                adjustedSize: finalSize,
+                                adjustedNotionalUsd: riskDecision.adjustedSizeUsd,
+                                referencePrice: riskDecision.referencePriceUsd,
+                            },
+                            safety: {
+                                closedOppositePosition: execution.closedOppositePosition,
+                                tpSlOrderIds: execution.tpSlOrderIds,
+                                pricing: execution.pricing,
+                            },
+                        };
+                    },
+                });
+                const response = {
+                    ...journaled.result.order,
+                    risk: journaled.result.risk,
+                    safety: journaled.result.safety,
+                    idempotency: {
+                        key: journaled.idempotencyKey,
+                        replayed: journaled.replayed,
+                        autoGenerated: journaled.autoGeneratedKey,
+                        journalId: journaled.journalId,
+                    },
+                };
+                if (outputOpts.json) {
+                    output(withJsonContract("order.execution.result", {
+                        executionStatus: journaled.replayed ? "replayed" : "executed",
+                        ...response,
+                    }), outputOpts);
+                }
+                else {
+                    outputSuccess(journaled.replayed ? "Order replayed from idempotency journal!" : "Market order placed!");
+                    console.log(`  Order ID:  ${response.id}`);
+                    console.log(`  Market:    ${response.market}`);
+                    console.log(`  Side:      ${response.side.toUpperCase()}`);
+                    console.log(`  Size:      ${response.size}`);
+                    console.log(`  Status:    ${response.status}`);
+                    if (Math.abs(response.risk.adjustedSize - response.risk.requestedSize) > 1e-12) {
+                        console.log(`  Risk Size: adjusted from ${response.risk.requestedSize} to ${response.risk.adjustedSize.toFixed(8)}`);
+                    }
+                    if (response.safety.closedOppositePosition) {
+                        console.log("  Safety:    closed opposite position before opening new side");
+                    }
+                    if (response.safety.tpSlOrderIds.length > 0) {
+                        console.log(`  TP/SL:     attached (${response.safety.tpSlOrderIds.join(", ")})`);
+                    }
+                    console.log(`  Idempotency: ${response.idempotency.key}` +
+                        (response.idempotency.replayed ? " (replayed)" : ""));
+                    console.log("");
+                }
+            }
+            finally {
+                await adapter.disconnect();
+            }
+        }
+        catch (err) {
+            const code = inferExitCode(err);
+            const message = err instanceof Error ? err.message : String(err);
+            if (outputOpts.json) {
+                output(withJsonContract("order.execution.result", {
+                    status: "error",
+                    error: {
+                        message,
+                        exitCode: code,
+                    },
+                }), outputOpts);
+            }
+            else {
+                outputError(message);
+            }
+            process.exit(code);
+        }
+    });
+}