@raintree-technology/perps 0.1.2 → 0.1.4

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

@@ -0,0 +1,820 @@
+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 { inferExitCode } from "../../lib/exit-codes.js";
+import { normalizeMarket, normalizeSide } from "./shared.js";
+import { readFileSync } from "node:fs";
+function parseNumber(value, label) {
+    const parsed = Number.parseFloat(value);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`${label} must be a finite number`);
+    }
+    return parsed;
+}
+function parsePositiveNumber(value, label) {
+    const parsed = parseNumber(value, label);
+    if (parsed <= 0) {
+        throw new Error(`${label} must be a positive number`);
+    }
+    return parsed;
+}
+function parsePositiveInteger(value, label) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${label} must be a positive integer`);
+    }
+    return parsed;
+}
+function parseNonNegativeInteger(value, label) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new Error(`${label} must be a non-negative integer`);
+    }
+    return parsed;
+}
+function parseNonZeroNumber(value, label) {
+    const parsed = parseNumber(value, label);
+    if (parsed === 0) {
+        throw new Error(`${label} must be non-zero`);
+    }
+    return parsed;
+}
+function parseMarginType(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "cross" || normalized === "isolated") {
+        return normalized;
+    }
+    throw new Error('Margin type must be "cross" or "isolated"');
+}
+function parseOrderType(value) {
+    if (typeof value !== "string") {
+        throw new Error("Order type must be a string");
+    }
+    const normalized = value.trim().toLowerCase();
+    const allowed = ["market", "limit", "stop", "stop_limit", "take_profit"];
+    if (!allowed.includes(normalized)) {
+        throw new Error(`Unsupported order type '${value}'`);
+    }
+    return normalized;
+}
+function parseBoolean(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true")
+            return true;
+        if (normalized === "false")
+            return false;
+    }
+    throw new Error(`${label} must be a boolean`);
+}
+function parseJsonArrayInput(options, label) {
+    const payload = options.ordersFile !== undefined
+        ? readFileSync(options.ordersFile, "utf8")
+        : options.orders;
+    if (payload === undefined) {
+        throw new Error(`${label} payload is required via --orders or --orders-file`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch (err) {
+        throw new Error(`${label} payload must be valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!Array.isArray(parsed)) {
+        throw new Error(`${label} payload must be a JSON array`);
+    }
+    return parsed;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function parseBatchOrderParams(input) {
+    if (!isRecord(input)) {
+        throw new Error("Each batch order item must be an object");
+    }
+    const sideRaw = input.side;
+    const marketRaw = input.market;
+    const typeRaw = input.type;
+    const sizeRaw = input.size;
+    if (typeof sideRaw !== "string")
+        throw new Error("Batch order item requires string field 'side'");
+    if (typeof marketRaw !== "string")
+        throw new Error("Batch order item requires string field 'market'");
+    if (typeof sizeRaw !== "string" && typeof sizeRaw !== "number") {
+        throw new Error("Batch order item requires string/number field 'size'");
+    }
+    const params = {
+        side: normalizeSide(sideRaw),
+        market: normalizeMarket(marketRaw),
+        type: typeRaw === undefined ? "limit" : parseOrderType(typeRaw),
+        size: parsePositiveNumber(String(sizeRaw), "Batch order size").toString(),
+    };
+    if (input.price !== undefined) {
+        params.price = parsePositiveNumber(String(input.price), "Batch order price").toString();
+    }
+    if (input.triggerPrice !== undefined) {
+        params.triggerPrice = parsePositiveNumber(String(input.triggerPrice), "Batch order triggerPrice").toString();
+    }
+    if (input.reduceOnly !== undefined) {
+        params.reduceOnly = parseBoolean(input.reduceOnly, "Batch order reduceOnly");
+    }
+    if (input.postOnly !== undefined) {
+        params.postOnly = parseBoolean(input.postOnly, "Batch order postOnly");
+    }
+    if (input.clientOrderId !== undefined) {
+        if (typeof input.clientOrderId !== "string" || input.clientOrderId.trim().length === 0) {
+            throw new Error("Batch order clientOrderId must be a non-empty string when provided");
+        }
+        params.clientOrderId = input.clientOrderId;
+    }
+    return params;
+}
+function parseBatchCancelParams(input) {
+    if (!isRecord(input)) {
+        throw new Error("Each batch cancel item must be an object");
+    }
+    if (typeof input.orderId !== "string" || input.orderId.trim().length === 0) {
+        throw new Error("Batch cancel item requires non-empty string field 'orderId'");
+    }
+    const params = {
+        orderId: input.orderId.trim(),
+    };
+    if (input.market !== undefined) {
+        if (typeof input.market !== "string" || input.market.trim().length === 0) {
+            throw new Error("Batch cancel item market must be a non-empty string when provided");
+        }
+        params.market = normalizeMarket(input.market);
+    }
+    return params;
+}
+function assertFeatureMethod(adapter, feature, method, capabilityLabel) {
+    if (!adapter.info.features[feature]) {
+        throw new Error(`${adapter.info.name} does not support ${capabilityLabel}`);
+    }
+    if (typeof adapter[method] !== "function") {
+        throw new Error(`${adapter.info.name} reports ${capabilityLabel} support but is missing adapter method '${method}'`);
+    }
+}
+function handleCommandError(outputOpts, err) {
+    const code = inferExitCode(err);
+    const message = err instanceof Error ? err.message : String(err);
+    if (outputOpts.json) {
+        output({
+            status: "error",
+            error: {
+                message,
+                exitCode: code,
+            },
+        }, outputOpts);
+    }
+    else {
+        outputError(message);
+    }
+    process.exit(code);
+}
+async function runWithConnectedAdapter(command, adapter, requirement, action) {
+    const ctx = getContext(command);
+    const outputOpts = getOutputOptions(command);
+    const exchangeId = getSelectedExchange(command);
+    let connected = false;
+    try {
+        const credentials = getExchangeCredentials(ctx.config, exchangeId, requirement);
+        await adapter.connect({
+            testnet: ctx.config.testnet,
+            rpcUrl: credentials.fullnodeUrl,
+            wsUrl: credentials.wsUrl,
+            credentials,
+        });
+        connected = true;
+        await action(adapter, outputOpts);
+    }
+    catch (err) {
+        handleCommandError(outputOpts, err);
+    }
+    finally {
+        if (connected) {
+            await adapter.disconnect().catch(() => undefined);
+        }
+    }
+}
+function formatFloat(value) {
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) ? parsed.toFixed(6) : value;
+}
+export function registerAdvancedOrderSimpleCommands(order) {
+    order
+        .command("get <orderId>")
+        .description("Show an order by ID")
+        .option("--symbol <symbol>", "Optional market symbol hint")
+        .action(async function (orderId) {
+        const adapter = getExchangeAdapter();
+        const opts = this.opts();
+        await runWithConnectedAdapter(this, adapter, { requireReadAccess: true }, async (connectedAdapter, out) => {
+            const orderRow = await connectedAdapter.getOrder(orderId);
+            if (out.json) {
+                output({ orderId, order: orderRow }, out);
+                return;
+            }
+            if (!orderRow) {
+                outputError(`Order ${orderId} not found${opts.symbol ? ` for ${normalizeMarket(opts.symbol)}` : ""}`);
+                return;
+            }
+            outputSuccess(`Order ${orderId}`);
+            console.log(`  Market:  ${orderRow.market}`);
+            console.log(`  Side:    ${orderRow.side}`);
+            console.log(`  Type:    ${orderRow.type}`);
+            console.log(`  Size:    ${formatFloat(orderRow.size)}`);
+            if (orderRow.price) {
+                console.log(`  Price:   ${formatFloat(orderRow.price)}`);
+            }
+            if (orderRow.triggerPrice) {
+                console.log(`  Trigger: ${formatFloat(orderRow.triggerPrice)}`);
+            }
+            console.log(`  Status:  ${orderRow.status}`);
+            console.log("");
+        });
+    });
+    order
+        .command("open [symbol]")
+        .description("Show open orders (optionally for one market)")
+        .action(async function (symbol) {
+        const adapter = getExchangeAdapter();
+        const market = symbol ? normalizeMarket(symbol) : undefined;
+        await runWithConnectedAdapter(this, adapter, { requireReadAccess: true }, async (connectedAdapter, out) => {
+            const orders = await connectedAdapter.getOrders(market);
+            if (out.json) {
+                output({ orders }, out);
+                return;
+            }
+            outputSuccess(`Fetched ${orders.length} open orders`);
+            for (const row of orders) {
+                console.log(`  ${row.id}  ${row.market.padEnd(10)} ${row.side.padEnd(5)} ${row.type.padEnd(11)} ${row.status.padEnd(9)} size=${formatFloat(row.size)}${row.price ? ` price=${formatFloat(row.price)}` : ""}`);
+            }
+            console.log("");
+        });
+    });
+    order
+        .command("trades [symbol]")
+        .description("Show account trade fills")
+        .option("--limit <n>", "Maximum rows (default: 100)")
+        .action(async function (symbol) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            const opts = this.opts();
+            const limit = opts.limit !== undefined ? parsePositiveInteger(opts.limit, "Limit") : 100;
+            const market = symbol ? normalizeMarket(symbol) : undefined;
+            await runWithConnectedAdapter(this, adapter, { requireReadAccess: true }, async (connectedAdapter, out) => {
+                const trades = await connectedAdapter.getTrades(market, limit);
+                if (out.json) {
+                    output({ trades }, out);
+                    return;
+                }
+                outputSuccess(`Fetched ${trades.length} fills`);
+                for (const row of trades) {
+                    console.log(`  ${row.market.padEnd(10)} ${row.side.padEnd(5)} price=${row.price} size=${row.size} fee=${row.fee} timestamp=${new Date(row.timestamp).toISOString()}`);
+                }
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    order
+        .command("position <symbol>")
+        .description("Show the current position for one market")
+        .action(async function (symbol) {
+        const adapter = getExchangeAdapter();
+        const market = normalizeMarket(symbol);
+        await runWithConnectedAdapter(this, adapter, { requireReadAccess: true }, async (connectedAdapter, out) => {
+            const position = await connectedAdapter.getPosition(market);
+            if (out.json) {
+                output({ market, position }, out);
+                return;
+            }
+            if (!position) {
+                outputError(`No open position for ${market}`);
+                return;
+            }
+            outputSuccess(`Position ${market}`);
+            console.log(`  Side:       ${position.side}`);
+            console.log(`  Size:       ${formatFloat(position.size)}`);
+            console.log(`  Entry:      ${formatFloat(position.entryPrice)}`);
+            console.log(`  Mark:       ${formatFloat(position.markPrice)}`);
+            console.log(`  Leverage:   ${position.leverage}x`);
+            console.log(`  uPnL:       ${position.unrealizedPnl}`);
+            console.log(`  MarginType: ${position.marginType}`);
+            console.log("");
+        });
+    });
+    order
+        .command("batch-place")
+        .description("Place multiple orders from a JSON payload")
+        .option("--orders <json>", "JSON array of order params")
+        .option("--orders-file <path>", "Path to a JSON file containing an array of order params")
+        .action(async function () {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            assertFeatureMethod(adapter, "batchOrders", "batchPlaceOrders", "batch order placement");
+            const opts = this.opts();
+            const parsed = parseJsonArrayInput(opts, "batch-place");
+            const paramsList = parsed.map((item) => parseBatchOrderParams(item));
+            await runWithConnectedAdapter(this, adapter, { requireTrading: true }, async (connectedAdapter, out) => {
+                const orders = await connectedAdapter.batchPlaceOrders(paramsList);
+                if (out.json) {
+                    output({ orders }, out);
+                    return;
+                }
+                outputSuccess(`Placed ${orders.length} orders`);
+                for (const row of orders) {
+                    console.log(`  ${row.id}  ${row.market.padEnd(10)} ${row.side.padEnd(5)} ${row.type.padEnd(11)} ${row.status.padEnd(9)} size=${formatFloat(row.size)}${row.price ? ` price=${formatFloat(row.price)}` : ""}`);
+                }
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    order
+        .command("batch-cancel")
+        .description("Cancel multiple orders from a JSON payload")
+        .option("--orders <json>", "JSON array of cancel params")
+        .option("--orders-file <path>", "Path to a JSON file containing an array of cancel params")
+        .action(async function () {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            assertFeatureMethod(adapter, "batchOrders", "batchCancelOrders", "batch order cancellation");
+            const opts = this.opts();
+            const parsed = parseJsonArrayInput(opts, "batch-cancel");
+            const paramsList = parsed.map((item) => parseBatchCancelParams(item));
+            await runWithConnectedAdapter(this, adapter, { requireTrading: true }, async (connectedAdapter, out) => {
+                const results = await connectedAdapter.batchCancelOrders(paramsList);
+                const cancelled = results.filter(Boolean).length;
+                if (out.json) {
+                    output({ results }, out);
+                    return;
+                }
+                outputSuccess(`Cancelled ${cancelled}/${results.length} orders`);
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    order
+        .command("cancel-all-after <timeoutMs>")
+        .description("Schedule an automatic cancel-all timeout in milliseconds (0 disables)")
+        .action(async function (timeoutMs) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            assertFeatureMethod(adapter, "cancelAllAfter", "cancelAllAfter", "cancel-all-after scheduling");
+            const timeout = parseNonNegativeInteger(timeoutMs, "timeoutMs");
+            await runWithConnectedAdapter(this, adapter, { requireTrading: true }, async (connectedAdapter, out) => {
+                await connectedAdapter.cancelAllAfter(timeout);
+                if (out.json) {
+                    output({ timeoutMs: timeout }, out);
+                    return;
+                }
+                outputSuccess("Cancel-all-after updated");
+                console.log(`  timeoutMs: ${timeout}`);
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    const mmp = order.command("mmp").description("Manage Market Maker Protection");
+    mmp
+        .command("set <symbol>")
+        .description("Set MMP config for a market")
+        .requiredOption("--window-ms <ms>", "MMP rolling window in milliseconds")
+        .requiredOption("--frozen-ms <ms>", "Freeze duration in milliseconds")
+        .requiredOption("--quantity-limit <size>", "Max quantity in window")
+        .requiredOption("--delta-limit <delta>", "Max delta in window")
+        .action(async function (symbol) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            assertFeatureMethod(adapter, "mmp", "setMMP", "MMP configuration");
+            const opts = this.opts();
+            const config = {
+                market: normalizeMarket(symbol),
+                windowMs: parsePositiveInteger(opts.windowMs, "windowMs"),
+                frozenMs: parsePositiveInteger(opts.frozenMs, "frozenMs"),
+                quantityLimit: parsePositiveNumber(opts.quantityLimit, "quantityLimit").toString(),
+                deltaLimit: parsePositiveNumber(opts.deltaLimit, "deltaLimit").toString(),
+            };
+            await runWithConnectedAdapter(this, adapter, { requireReadAccess: true }, async (connectedAdapter, out) => {
+                await connectedAdapter.setMMP(config);
+                if (out.json) {
+                    output({ config }, out);
+                    return;
+                }
+                outputSuccess(`MMP updated for ${config.market}`);
+                console.log(`  windowMs:      ${config.windowMs}`);
+                console.log(`  frozenMs:      ${config.frozenMs}`);
+                console.log(`  quantityLimit: ${config.quantityLimit}`);
+                console.log(`  deltaLimit:    ${config.deltaLimit}`);
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    mmp
+        .command("get <symbol>")
+        .description("Get MMP status for a market")
+        .action(async function (symbol) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            assertFeatureMethod(adapter, "mmp", "getMMP", "MMP status queries");
+            const market = normalizeMarket(symbol);
+            await runWithConnectedAdapter(this, adapter, { requireReadAccess: true }, async (connectedAdapter, out) => {
+                const status = await connectedAdapter.getMMP(market);
+                if (out.json) {
+                    output({ status }, out);
+                    return;
+                }
+                outputSuccess(`MMP ${market}`);
+                console.log(`  Frozen: ${status.frozen}`);
+                if (status.frozenUntil) {
+                    console.log(`  FrozenUntil: ${new Date(status.frozenUntil).toISOString()}`);
+                }
+                if (status.config) {
+                    console.log(`  Window:       ${status.config.windowMs}`);
+                    console.log(`  FrozenMs:     ${status.config.frozenMs}`);
+                    console.log(`  Quantity:     ${status.config.quantityLimit}`);
+                    console.log(`  Delta:        ${status.config.deltaLimit}`);
+                }
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    mmp
+        .command("reset <symbol>")
+        .description("Reset MMP freeze state for a market")
+        .action(async function (symbol) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            assertFeatureMethod(adapter, "mmp", "resetMMP", "MMP reset");
+            const market = normalizeMarket(symbol);
+            await runWithConnectedAdapter(this, adapter, { requireReadAccess: true }, async (connectedAdapter, out) => {
+                await connectedAdapter.resetMMP(market);
+                if (out.json) {
+                    output({ market, reset: true }, out);
+                    return;
+                }
+                outputSuccess(`MMP reset for ${market}`);
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    order
+        .command("modify <orderId> <symbol>")
+        .description("Modify an existing order")
+        .option("--price <price>", "New limit price")
+        .option("--size <size>", "New order size")
+        .option("--trigger-price <price>", "New trigger price for stop/take-profit orders")
+        .action(async function (orderId, symbol) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            assertFeatureMethod(adapter, "modifyOrders", "modifyOrder", "order modification");
+            const opts = this.opts();
+            const update = {
+                orderId,
+                market: normalizeMarket(symbol),
+            };
+            let updatedFields = 0;
+            if (opts.price !== undefined) {
+                update.price = parsePositiveNumber(opts.price, "Price").toString();
+                updatedFields++;
+            }
+            if (opts.size !== undefined) {
+                update.size = parsePositiveNumber(opts.size, "Size").toString();
+                updatedFields++;
+            }
+            if (opts.triggerPrice !== undefined) {
+                update.triggerPrice = parsePositiveNumber(opts.triggerPrice, "Trigger price").toString();
+                updatedFields++;
+            }
+            if (updatedFields === 0) {
+                throw new Error("At least one of --price, --size, or --trigger-price is required");
+            }
+            await runWithConnectedAdapter(this, adapter, { requireTrading: true }, async (connectedAdapter, out) => {
+                const updated = await connectedAdapter.modifyOrder(update);
+                if (out.json) {
+                    output({
+                        order: updated,
+                    }, out);
+                    return;
+                }
+                outputSuccess(`Order ${orderId} modified`);
+                console.log(`  ID:      ${updated.id}`);
+                console.log(`  Market:  ${updated.market}`);
+                console.log(`  Side:    ${updated.side}`);
+                console.log(`  Type:    ${updated.type}`);
+                console.log(`  Size:    ${formatFloat(updated.size)}`);
+                if (updated.price) {
+                    console.log(`  Price:   ${formatFloat(updated.price)}`);
+                }
+                if (updated.triggerPrice) {
+                    console.log(`  Trigger: ${formatFloat(updated.triggerPrice)}`);
+                }
+                console.log(`  Status:  ${updated.status}`);
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    order
+        .command("leverage <symbol> <value>")
+        .description("Set leverage for a market")
+        .action(async function (symbol, value) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            const leverage = parsePositiveNumber(value, "Leverage");
+            const market = normalizeMarket(symbol);
+            await runWithConnectedAdapter(this, adapter, { requireTrading: true }, async (_connectedAdapter, out) => {
+                await _connectedAdapter.setLeverage(market, leverage);
+                if (out.json) {
+                    output({ market, leverage }, out);
+                    return;
+                }
+                outputSuccess(`Leverage set for ${market}`);
+                console.log(`  Leverage: ${leverage}x`);
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    order
+        .command("margin-type <symbol> <type>")
+        .description("Set margin type (cross or isolated) for a market")
+        .action(async function (symbol, type) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            const marginType = parseMarginType(type);
+            const market = normalizeMarket(symbol);
+            await runWithConnectedAdapter(this, adapter, { requireTrading: true }, async (_connectedAdapter, out) => {
+                await _connectedAdapter.setMarginType(market, marginType);
+                if (out.json) {
+                    output({ market, marginType }, out);
+                    return;
+                }
+                outputSuccess(`Margin type set for ${market}`);
+                console.log(`  Type: ${marginType}`);
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    const twap = order
+        .command("twap")
+        .description("Manage TWAP orders");
+    twap
+        .command("place <side> <symbol> <size>")
+        .description("Place a TWAP order")
+        .requiredOption("--duration-ms <ms>", "TWAP duration in milliseconds")
+        .option("--interval-ms <ms>", "TWAP execution interval in milliseconds")
+        .action(async function (side, symbol, size) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            assertFeatureMethod(adapter, "twapOrders", "placeTWAP", "TWAP orders");
+            const opts = this.opts();
+            const params = {
+                side: normalizeSide(side),
+                market: normalizeMarket(symbol),
+                size: parsePositiveNumber(size, "Size").toString(),
+                durationMs: parsePositiveInteger(opts.durationMs, "Duration"),
+            };
+            if (opts.intervalMs !== undefined) {
+                params.intervalMs = parsePositiveInteger(opts.intervalMs, "Interval");
+            }
+            await runWithConnectedAdapter(this, adapter, { requireTrading: true }, async (connectedAdapter, out) => {
+                const status = await connectedAdapter.placeTWAP(params);
+                if (out.json) {
+                    output({ twap: status }, out);
+                    return;
+                }
+                outputSuccess(`TWAP order placed (${status.id})`);
+                console.log(`  Market:     ${status.market}`);
+                console.log(`  Side:       ${status.side}`);
+                console.log(`  Status:     ${status.status}`);
+                console.log(`  Total Size: ${formatFloat(status.totalSize)}`);
+                console.log(`  Remaining:  ${formatFloat(status.remainingSize)}`);
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    twap
+        .command("cancel <twapId>")
+        .description("Cancel a TWAP order")
+        .action(async function (twapId) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            assertFeatureMethod(adapter, "twapOrders", "cancelTWAP", "TWAP orders");
+            await runWithConnectedAdapter(this, adapter, { requireTrading: true }, async (connectedAdapter, out) => {
+                const cancelled = await connectedAdapter.cancelTWAP(twapId);
+                if (out.json) {
+                    output({ twapId, cancelled }, out);
+                    return;
+                }
+                if (cancelled) {
+                    outputSuccess(`TWAP ${twapId} cancelled`);
+                }
+                else {
+                    outputError(`Unable to cancel TWAP ${twapId}`);
+                }
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    twap
+        .command("status <twapId>")
+        .description("Show TWAP status")
+        .action(async function (twapId) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            assertFeatureMethod(adapter, "twapOrders", "getTWAPStatus", "TWAP status queries");
+            await runWithConnectedAdapter(this, adapter, { requireReadAccess: true }, async (connectedAdapter, out) => {
+                const status = await connectedAdapter.getTWAPStatus(twapId);
+                if (out.json) {
+                    output({ twapId, status }, out);
+                    return;
+                }
+                if (!status) {
+                    outputError(`No TWAP status found for ${twapId}`);
+                    return;
+                }
+                outputSuccess(`TWAP ${twapId}`);
+                console.log(`  Market:     ${status.market}`);
+                console.log(`  Side:       ${status.side}`);
+                console.log(`  Status:     ${status.status}`);
+                console.log(`  Total Size: ${formatFloat(status.totalSize)}`);
+                console.log(`  Executed:   ${formatFloat(status.executedSize)}`);
+                console.log(`  Remaining:  ${formatFloat(status.remainingSize)}`);
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    order
+        .command("isolated-margin <symbol> [amount]")
+        .description("Adjust isolated margin for a market (positive adds, negative removes)")
+        .option("--amount <amount>", "Margin amount (non-zero). Supports negative values.")
+        .action(async function (symbol, amount) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            assertFeatureMethod(adapter, "isolatedMargin", "updateIsolatedMargin", "isolated margin updates");
+            const opts = this.opts();
+            const rawAmount = amount ?? opts.amount;
+            if (rawAmount === undefined) {
+                throw new Error("Amount is required as <amount> or --amount");
+            }
+            const parsedAmount = parseNonZeroNumber(rawAmount, "Amount");
+            const market = normalizeMarket(symbol);
+            await runWithConnectedAdapter(this, adapter, { requireTrading: true }, async (connectedAdapter, out) => {
+                await connectedAdapter.updateIsolatedMargin(market, parsedAmount.toString());
+                if (out.json) {
+                    output({ market, amount: parsedAmount.toString() }, out);
+                    return;
+                }
+                outputSuccess(`Updated isolated margin for ${market}`);
+                console.log(`  Amount: ${parsedAmount}`);
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    order
+        .command("history [symbol]")
+        .description("Show order history")
+        .option("--limit <n>", "Maximum rows (default: 100)")
+        .action(async function (symbol) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            assertFeatureMethod(adapter, "orderHistory", "getOrderHistory", "order history");
+            const opts = this.opts();
+            const limit = opts.limit !== undefined ? parsePositiveInteger(opts.limit, "Limit") : 100;
+            const market = symbol ? normalizeMarket(symbol) : undefined;
+            await runWithConnectedAdapter(this, adapter, { requireReadAccess: true }, async (connectedAdapter, out) => {
+                const orders = await connectedAdapter.getOrderHistory(market, limit);
+                if (out.json) {
+                    output({ orders }, out);
+                    return;
+                }
+                outputSuccess(`Fetched ${orders.length} historical orders`);
+                for (const row of orders) {
+                    console.log(`  ${row.id}  ${row.market.padEnd(10)} ${row.side.padEnd(5)} ${row.type.padEnd(11)} ${row.status.padEnd(9)} size=${formatFloat(row.size)}${row.price ? ` price=${formatFloat(row.price)}` : ""}`);
+                }
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    order
+        .command("funding-history [symbol]")
+        .description("Show funding payment history")
+        .option("--limit <n>", "Maximum rows (default: 100)")
+        .action(async function (symbol) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            assertFeatureMethod(adapter, "fundingHistory", "getFundingHistory", "funding history");
+            const opts = this.opts();
+            const limit = opts.limit !== undefined ? parsePositiveInteger(opts.limit, "Limit") : 100;
+            const market = symbol ? normalizeMarket(symbol) : undefined;
+            await runWithConnectedAdapter(this, adapter, { requireReadAccess: true }, async (connectedAdapter, out) => {
+                const payments = await connectedAdapter.getFundingHistory(market, limit);
+                if (out.json) {
+                    output({ payments }, out);
+                    return;
+                }
+                outputSuccess(`Fetched ${payments.length} funding records`);
+                for (const row of payments) {
+                    console.log(`  ${row.market.padEnd(10)} amount=${row.amount} rate=${row.rate} timestamp=${new Date(row.timestamp).toISOString()}`);
+                }
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+    order
+        .command("public-trades <symbol>")
+        .description("Show recent public trades")
+        .option("--limit <n>", "Maximum rows (default: 100)")
+        .action(async function (symbol) {
+        const adapter = getExchangeAdapter();
+        const outputOpts = getOutputOptions(this);
+        try {
+            assertFeatureMethod(adapter, "publicTrades", "getPublicTrades", "public trade history");
+            const opts = this.opts();
+            const limit = opts.limit !== undefined ? parsePositiveInteger(opts.limit, "Limit") : 100;
+            const market = normalizeMarket(symbol);
+            await runWithConnectedAdapter(this, adapter, {}, async (connectedAdapter, out) => {
+                const trades = await connectedAdapter.getPublicTrades(market, limit);
+                if (out.json) {
+                    output({ trades }, out);
+                    return;
+                }
+                outputSuccess(`Fetched ${trades.length} public trades`);
+                for (const row of trades) {
+                    console.log(`  ${row.market.padEnd(10)} ${row.side.padEnd(5)} price=${row.price} size=${row.size} timestamp=${new Date(row.timestamp).toISOString()}`);
+                }
+                console.log("");
+            });
+        }
+        catch (err) {
+            handleCommandError(outputOpts, err);
+        }
+    });
+}