perp-cli 0.4.8 → 0.4.10

package/dist/commands/trade.js

@@ -12,7 +12,7 @@ function pac(adapter) {
         throw new Error("This command requires --exchange pacifica");
     return adapter;
 }
-export function registerTradeCommands(program, getAdapter, isJson, isDryRun = () => false) {
+export function registerTradeCommands(program, getAdapter, isJson, isDryRun = () => false, getAdapterForExchange) {
     /** Guard: if --dry-run is active, log the intended action and return without executing. */
     function dryRunGuard(action, details) {
         if (!isDryRun())
@@ -29,11 +29,11 @@ export function registerTradeCommands(program, getAdapter, isJson, isDryRun = ()
             console.log();
         }
         logExecution({
-            type: action.includes("limit") ? "limit_order" : action.includes("stop") ? "stop_order" : action.includes("cancel") ? "cancel" : "market_order",
+            type: action.includes("split") ? "split_order" : action.includes("limit") ? "limit_order" : action.includes("stop") ? "stop_order" : action.includes("cancel") ? "cancel" : "market_order",
             exchange: details.exchange ?? "unknown",
             symbol: (details.symbol ?? "").toUpperCase(),
             side: details.side ?? "",
-            size: String(details.size ?? "0"),
+            size: String(details.size ?? details.totalUsd ?? "0"),
             price: details.price,
             status: "simulated",
             dryRun: true,
@@ -48,12 +48,37 @@ export function registerTradeCommands(program, getAdapter, isJson, isDryRun = ()
         .option("-s, --slippage <pct>", "Slippage percent", "1")
         .option("--reduce-only", "Reduce only order")
         .option("--smart", "Smart execution: IOC limit at best bid/ask + 1 tick (reduces slippage)")
+        .option("--split", "Use orderbook-aware split execution for large orders")
+        .option("--max-slippage <pct>", "Max slippage per split slice (%)", "0.3")
         .option("--client-id <id>", "Client order ID for idempotent tracking")
         .option("--auto-id", "Auto-generate a client order ID")
         .action(async (symbol, side, size, opts) => {
         const s = side.toLowerCase();
         if (s !== "buy" && s !== "sell")
             errorAndExit("Side must be buy or sell");
+        const sym = symbol.toUpperCase();
+        // ── Split execution branch ──
+        if (opts.split) {
+            const adapter = await getAdapter();
+            if (dryRunGuard("split-order", { exchange: adapter.name, symbol: sym, side: s, size }))
+                return;
+            const { runSplitOrder } = await import("../strategies/split-order.js");
+            const markets = await adapter.getMarkets();
+            const market = markets.find(m => symbolMatch(m.symbol, sym));
+            const markPrice = market ? parseFloat(market.markPrice) : 0;
+            const notionalUsd = markPrice > 0 ? parseFloat(size) * markPrice : parseFloat(size);
+            const result = await runSplitOrder(adapter, {
+                symbol: sym,
+                side: s,
+                totalSizeUsd: notionalUsd,
+                maxSlippagePct: parseFloat(opts.maxSlippage ?? "0.3"),
+            }, isJson() ? () => { } : (msg) => console.log(chalk.gray(`  ${msg}`)));
+            if (isJson())
+                return printJson(jsonOk(result));
+            const statusColor = result.status === "complete" ? chalk.green : result.status === "partial" ? chalk.yellow : chalk.red;
+            console.log(`\n  ${statusColor(result.status.toUpperCase())} | ${result.slices.length} slices | $${formatUsd(result.filledUsd)} filled | slippage: ${result.totalSlippagePct.toFixed(3)}%\n`);
+            return;
+        }
         const clientId = opts.autoId ? generateClientId() : opts.clientId;
         if (clientId && isOrderDuplicate(clientId)) {
             if (isJson())
@@ -62,7 +87,7 @@ export function registerTradeCommands(program, getAdapter, isJson, isDryRun = ()
             return;
         }
         const adapter = await getAdapter();
-        if (dryRunGuard("market_order", { exchange: adapter.name, symbol: symbol.toUpperCase(), side: s, size, smart: !!opts.smart }))
+        if (dryRunGuard("market_order", { exchange: adapter.name, symbol: sym, side: s, size, smart: !!opts.smart }))
             return;
         if (clientId) {
             logClientId({
@@ -186,6 +211,47 @@ export function registerTradeCommands(program, getAdapter, isJson, isDryRun = ()
         console.log(chalk.green(`\n  Market SELL ${size} ${symbol.toUpperCase()} placed on ${adapter.name}.${opts.smart ? " (smart)" : ""}\n`));
         printJson(jsonOk(result));
     });
+    // ── Split Order (orderbook-aware) ──
+    trade
+        .command("split <symbol> <side> <usd>")
+        .description("Orderbook-aware split execution — breaks large orders into slices based on depth")
+        .option("--max-slippage <pct>", "Max slippage per slice (%)", "0.3")
+        .option("--max-slices <n>", "Max number of slices", "10")
+        .option("--delay <ms>", "Delay between slices in ms", "1000")
+        .option("--min-slice <usd>", "Minimum slice size in USD", "100")
+        .action(async (symbol, side, usd, opts) => {
+        const sym = symbol.toUpperCase();
+        const orderSide = side.toLowerCase();
+        const totalUsd = parseFloat(usd);
+        if (!["buy", "sell"].includes(orderSide))
+            errorAndExit("Side must be 'buy' or 'sell'");
+        if (isNaN(totalUsd) || totalUsd <= 0)
+            errorAndExit("USD amount must be > 0");
+        const exchange = program.opts().exchange ?? "unknown";
+        if (dryRunGuard("split-order", { exchange, symbol: sym, side: orderSide, totalUsd, ...opts }))
+            return;
+        const adapter = await getAdapter();
+        const { runSplitOrder } = await import("../strategies/split-order.js");
+        const result = await runSplitOrder(adapter, {
+            symbol: sym,
+            side: orderSide,
+            totalSizeUsd: totalUsd,
+            maxSlippagePct: parseFloat(opts.maxSlippage),
+            maxSlices: parseInt(opts.maxSlices),
+            delayMs: parseInt(opts.delay),
+            minSliceUsd: parseFloat(opts.minSlice),
+        }, isJson() ? () => { } : (msg) => console.log(chalk.gray(`  ${msg}`)));
+        if (isJson())
+            return printJson(jsonOk(result));
+        const statusColor = result.status === "complete" ? chalk.green
+            : result.status === "partial" ? chalk.yellow
+                : chalk.red;
+        console.log(`\n  ${statusColor(result.status.toUpperCase())} | ${result.slices.length} slices`);
+        console.log(`  Filled: $${formatUsd(result.filledUsd)} / $${formatUsd(result.requestedUsd)}`);
+        console.log(`  Avg Price: $${formatUsd(result.avgPrice)}`);
+        console.log(`  Slippage: ${result.totalSlippagePct.toFixed(3)}%`);
+        console.log(`  Runtime: ${result.runtime.toFixed(1)}s\n`);
+    });
     trade
         .command("limit <symbol> <side> <price> <size>")
         .description("Place a limit order")
@@ -622,120 +688,7 @@ export function registerTradeCommands(program, getAdapter, isJson, isDryRun = ()
             throw err;
         }
     });
-    // ── Grid Bot (shortcut with --background) ──
-    trade
-        .command("grid <symbol>")
-        .description("Run grid trading bot (foreground or --background)")
-        .requiredOption("--upper <price>", "Upper price bound")
-        .requiredOption("--lower <price>", "Lower price bound")
-        .option("--grids <n>", "Number of grid lines", "10")
-        .option("--size <size>", "Total position size (base)", "0.1")
-        .option("--side <side>", "Grid bias: long, short, neutral", "neutral")
-        .option("--leverage <n>", "Leverage to set")
-        .option("--interval <sec>", "Check interval in seconds", "10")
-        .option("--max-runtime <sec>", "Max runtime in seconds (0 = forever)", "0")
-        .option("--trailing-stop <pct>", "Stop if equity drops by this % from peak")
-        .option("--background", "Run in background (tmux)")
-        .action(async (symbol, opts) => {
-        const exchange = (await getAdapter()).name;
-        const cliArgs = [
-            `-e`, exchange, symbol.toUpperCase(),
-            `--upper`, opts.upper, `--lower`, opts.lower,
-            `--grids`, opts.grids, `--size`, opts.size,
-            `--side`, opts.side, `--interval`, opts.interval,
-            `--max-runtime`, opts.maxRuntime,
-            ...(opts.leverage ? [`--leverage`, opts.leverage] : []),
-            ...(opts.trailingStop ? [`--trailing-stop`, opts.trailingStop] : []),
-        ];
-        if (opts.background) {
-            const { startJob } = await import("../jobs.js");
-            const job = startJob({
-                strategy: "grid",
-                exchange,
-                params: { symbol: symbol.toUpperCase(), ...opts },
-                cliArgs,
-            });
-            if (isJson())
-                return printJson(jsonOk(job));
-            console.log(chalk.green(`\n  Grid bot started in background.`));
-            console.log(`  ID: ${chalk.white.bold(job.id)}`);
-            console.log(`  Range: $${opts.lower} - $${opts.upper} | ${opts.grids} grids`);
-            console.log(`  Logs: ${chalk.gray(`perp jobs logs ${job.id}`)}`);
-            console.log(`  Stop: ${chalk.gray(`perp jobs stop ${job.id}`)}\n`);
-            return;
-        }
-        // Foreground: delegate to `run grid`
-        const { runGrid } = await import("../strategies/grid.js");
-        const adapter = await getAdapter();
-        const log = (msg) => {
-            const ts = new Date().toLocaleTimeString();
-            console.log(`${chalk.gray(ts)} ${msg}`);
-        };
-        await runGrid(adapter, {
-            symbol: symbol.toUpperCase(),
-            side: opts.side,
-            upperPrice: parseFloat(opts.upper),
-            lowerPrice: parseFloat(opts.lower),
-            grids: parseInt(opts.grids),
-            totalSize: parseFloat(opts.size),
-            leverage: opts.leverage ? parseInt(opts.leverage) : undefined,
-            intervalSec: parseInt(opts.interval),
-            maxRuntime: parseInt(opts.maxRuntime),
-            trailingStop: opts.trailingStop ? parseFloat(opts.trailingStop) : undefined,
-        }, undefined, log);
-    });
-    // ── DCA (shortcut with --background) ──
-    trade
-        .command("dca <symbol> <side> <amount> <interval>")
-        .description("Run DCA strategy (foreground or --background)")
-        .option("--orders <n>", "Total number of orders (0 = unlimited)", "0")
-        .option("--price-limit <price>", "Stop buying above / selling below this price")
-        .option("--max-runtime <sec>", "Max runtime in seconds (0 = forever)", "0")
-        .option("--background", "Run in background (tmux)")
-        .action(async (symbol, side, amount, interval, opts) => {
-        const s = side.toLowerCase();
-        if (s !== "buy" && s !== "sell")
-            errorAndExit("Side must be buy or sell");
-        const exchange = (await getAdapter()).name;
-        const cliArgs = [
-            `-e`, exchange, symbol.toUpperCase(), s, amount, interval,
-            `--orders`, opts.orders, `--max-runtime`, opts.maxRuntime,
-            ...(opts.priceLimit ? [`--price-limit`, opts.priceLimit] : []),
-        ];
-        if (opts.background) {
-            const { startJob } = await import("../jobs.js");
-            const job = startJob({
-                strategy: "dca",
-                exchange,
-                params: { symbol: symbol.toUpperCase(), side: s, amount, interval, ...opts },
-                cliArgs,
-            });
-            if (isJson())
-                return printJson(jsonOk(job));
-            console.log(chalk.green(`\n  DCA started in background.`));
-            console.log(`  ID: ${chalk.white.bold(job.id)}`);
-            console.log(`  ${s.toUpperCase()} ${amount} ${symbol.toUpperCase()} every ${interval}s`);
-            console.log(`  Logs: ${chalk.gray(`perp jobs logs ${job.id}`)}`);
-            console.log(`  Stop: ${chalk.gray(`perp jobs stop ${job.id}`)}\n`);
-            return;
-        }
-        // Foreground
-        const { runDCA } = await import("../strategies/dca.js");
-        const adapter = await getAdapter();
-        const log = (msg) => {
-            const ts = new Date().toLocaleTimeString();
-            console.log(`${chalk.gray(ts)} ${msg}`);
-        };
-        await runDCA(adapter, {
-            symbol: symbol.toUpperCase(),
-            side: s,
-            amountPerOrder: parseFloat(amount),
-            intervalSec: parseInt(interval),
-            totalOrders: parseInt(opts.orders),
-            priceLimit: opts.priceLimit ? parseFloat(opts.priceLimit) : undefined,
-            maxRuntime: parseInt(opts.maxRuntime),
-        }, undefined, log);
-    });
+    // grid/dca moved to 'perp bot grid' / 'perp bot dca'
     // ── Position Management Shortcuts ──
     trade
         .command("close-all")
@@ -1124,147 +1077,7 @@ export function registerTradeCommands(program, getAdapter, isJson, isDryRun = ()
         }
         console.log();
     });
-    // ── Trailing Stop ──
-    trade
-        .command("trailing-stop <symbol>")
-        .description("Client-side trailing stop that monitors price and closes position when price drops by X% from peak")
-        .requiredOption("--trail <pct>", "Trail percentage (e.g., 3 = close when price drops 3% from high)")
-        .option("--interval <sec>", "Check interval in seconds", "5")
-        .option("--activation <price>", "Only start trailing after price reaches this level")
-        .option("--background", "Run in background (tmux)")
-        .action(async (symbol, opts) => {
-        const sym = symbol.toUpperCase();
-        const trailPct = parseFloat(opts.trail);
-        const intervalSec = parseInt(opts.interval);
-        const activationPrice = opts.activation ? parseFloat(opts.activation) : undefined;
-        if (isNaN(trailPct) || trailPct <= 0)
-            errorAndExit("Trail percentage must be > 0");
-        const exchange = (await getAdapter()).name;
-        // --background → run via tmux
-        if (opts.background) {
-            const { startJob } = await import("../jobs.js");
-            const cliArgs = [
-                `-e`, exchange, sym,
-                `--trail`, opts.trail,
-                `--interval`, opts.interval,
-                ...(opts.activation ? [`--activation`, opts.activation] : []),
-            ];
-            const job = startJob({
-                strategy: "trailing-stop",
-                exchange,
-                params: { symbol: sym, trail: trailPct, interval: intervalSec, activation: activationPrice },
-                cliArgs,
-            });
-            if (isJson())
-                return printJson(jsonOk(job));
-            console.log(chalk.green(`\n  Trailing stop started in background.`));
-            console.log(`  ID: ${chalk.white.bold(job.id)}`);
-            console.log(`  Trail: ${trailPct}%${activationPrice ? ` | Activation: $${activationPrice}` : ""}`);
-            console.log(`  Logs: ${chalk.gray(`perp jobs logs ${job.id}`)}`);
-            console.log(`  Stop: ${chalk.gray(`perp jobs stop ${job.id}`)}\n`);
-            return;
-        }
-        // Foreground: run trailing stop loop
-        const adapter = await getAdapter();
-        // Auto-detect position side
-        const positions = await adapter.getPositions();
-        const pos = positions.find(p => symbolMatch(p.symbol, sym));
-        if (!pos)
-            errorAndExit(`No open position for ${sym}. Open a position first.`);
-        const positionSide = pos.side; // "long" or "short"
-        const closeSide = positionSide === "long" ? "sell" : "buy";
-        const posSize = pos.size;
-        console.log(chalk.cyan(`\n  Trailing Stop for ${sym} (${positionSide} ${posSize})`));
-        console.log(chalk.cyan(`  Trail: ${trailPct}% | Interval: ${intervalSec}s${activationPrice ? ` | Activation: $${activationPrice}` : ""}`));
-        console.log(chalk.gray(`  Press Ctrl+C to cancel.\n`));
-        let peakPrice = 0;
-        let activated = !activationPrice; // if no activation price, start immediately
-        let running = true;
-        const cleanup = () => { running = false; };
-        process.on("SIGINT", cleanup);
-        process.on("SIGTERM", cleanup);
-        try {
-            while (running) {
-                const markets = await adapter.getMarkets();
-                const market = markets.find(m => symbolMatch(m.symbol, sym));
-                if (!market) {
-                    console.log(chalk.yellow(`  Market data for ${sym} not found, retrying...`));
-                    await new Promise(r => setTimeout(r, intervalSec * 1000));
-                    continue;
-                }
-                const currentPrice = parseFloat(market.markPrice);
-                // Check activation
-                if (!activated && activationPrice) {
-                    if (positionSide === "long" && currentPrice >= activationPrice) {
-                        activated = true;
-                        console.log(chalk.green(`  Activated at $${currentPrice.toFixed(2)} (>= $${activationPrice})`));
-                    }
-                    else if (positionSide === "short" && currentPrice <= activationPrice) {
-                        activated = true;
-                        console.log(chalk.green(`  Activated at $${currentPrice.toFixed(2)} (<= $${activationPrice})`));
-                    }
-                    else {
-                        const ts = new Date().toLocaleTimeString();
-                        console.log(chalk.gray(`  ${ts} | $${currentPrice.toFixed(2)} | Waiting for activation ($${activationPrice})...`));
-                        await new Promise(r => setTimeout(r, intervalSec * 1000));
-                        continue;
-                    }
-                }
-                // Update peak
-                if (positionSide === "long") {
-                    if (currentPrice > peakPrice)
-                        peakPrice = currentPrice;
-                    const dropPct = ((peakPrice - currentPrice) / peakPrice) * 100;
-                    const ts = new Date().toLocaleTimeString();
-                    console.log(chalk.gray(`  ${ts} | Price: $${currentPrice.toFixed(2)} | Peak: $${peakPrice.toFixed(2)} | Drop: ${dropPct.toFixed(2)}%`));
-                    if (dropPct >= trailPct) {
-                        console.log(chalk.red(`\n  TRAILING STOP TRIGGERED! Price dropped ${dropPct.toFixed(2)}% from peak $${peakPrice.toFixed(2)}`));
-                        console.log(chalk.red(`  Closing ${positionSide} ${posSize} ${sym}...\n`));
-                        const result = await adapter.marketOrder(sym, closeSide, posSize);
-                        logExecution({
-                            type: "market_order", exchange: adapter.name, symbol: sym,
-                            side: closeSide, size: posSize, status: "success", dryRun: false,
-                            meta: { action: "trailing-stop", trailPct, peakPrice, triggerPrice: currentPrice },
-                        });
-                        if (isJson())
-                            return printJson(jsonOk({ triggered: true, peakPrice, triggerPrice: currentPrice, dropPct, result }));
-                        console.log(chalk.green(`  Position closed. Peak: $${peakPrice.toFixed(2)}, Exit: $${currentPrice.toFixed(2)}\n`));
-                        return;
-                    }
-                }
-                else {
-                    // Short position: track lowest price, trigger when price rises
-                    if (peakPrice === 0 || currentPrice < peakPrice)
-                        peakPrice = currentPrice;
-                    const risePct = ((currentPrice - peakPrice) / peakPrice) * 100;
-                    const ts = new Date().toLocaleTimeString();
-                    console.log(chalk.gray(`  ${ts} | Price: $${currentPrice.toFixed(2)} | Trough: $${peakPrice.toFixed(2)} | Rise: ${risePct.toFixed(2)}%`));
-                    if (risePct >= trailPct) {
-                        console.log(chalk.red(`\n  TRAILING STOP TRIGGERED! Price rose ${risePct.toFixed(2)}% from trough $${peakPrice.toFixed(2)}`));
-                        console.log(chalk.red(`  Closing ${positionSide} ${posSize} ${sym}...\n`));
-                        const result = await adapter.marketOrder(sym, closeSide, posSize);
-                        logExecution({
-                            type: "market_order", exchange: adapter.name, symbol: sym,
-                            side: closeSide, size: posSize, status: "success", dryRun: false,
-                            meta: { action: "trailing-stop", trailPct, troughPrice: peakPrice, triggerPrice: currentPrice },
-                        });
-                        if (isJson())
-                            return printJson(jsonOk({ triggered: true, troughPrice: peakPrice, triggerPrice: currentPrice, risePct, result }));
-                        console.log(chalk.green(`  Position closed. Trough: $${peakPrice.toFixed(2)}, Exit: $${currentPrice.toFixed(2)}\n`));
-                        return;
-                    }
-                }
-                await new Promise(r => setTimeout(r, intervalSec * 1000));
-            }
-        }
-        finally {
-            process.removeListener("SIGINT", cleanup);
-            process.removeListener("SIGTERM", cleanup);
-        }
-        if (isJson())
-            return printJson(jsonOk({ triggered: false, reason: "cancelled" }));
-        console.log(chalk.yellow(`\n  Trailing stop cancelled.\n`));
-    });
+    // grid/dca/trailing-stop moved to 'perp bot'
     // ── PnL Tracker ──
     trade
         .command("pnl-track")
@@ -1345,4 +1158,173 @@ export function registerTradeCommands(program, getAdapter, isJson, isDryRun = ()
         }
         console.log(chalk.yellow(`\n  PnL tracker stopped.\n`));
     });
+    // ── Multi-leg orders ──────────────────────────────────────────────────
+    if (getAdapterForExchange) {
+        const tradeCmd = program.commands.find(c => c.name() === "trade");
+        if (tradeCmd) {
+            registerMultiAction(tradeCmd, getAdapterForExchange, isJson);
+        }
+        // Keep deprecated top-level 'multi' alias (hidden from help)
+        registerMultiAction(program, getAdapterForExchange, isJson, true);
+    }
+}
+function parseMultiLeg(spec) {
+    const parts = spec.split(":");
+    if (parts.length !== 4) {
+        throw new Error(`Invalid leg format "${spec}" — expected exchange:symbol:side:size`);
+    }
+    const [exchange, symbol, side, size] = parts;
+    // Normalize exchange aliases
+    const exMap = {
+        hl: "hyperliquid", pac: "pacifica", lit: "lighter",
+        hyperliquid: "hyperliquid", pacifica: "pacifica", lighter: "lighter",
+    };
+    const normalizedExchange = exMap[exchange.toLowerCase()];
+    if (!normalizedExchange) {
+        throw new Error(`Unknown exchange "${exchange}" in leg spec`);
+    }
+    if (side !== "buy" && side !== "sell") {
+        throw new Error(`Invalid side "${side}" — must be "buy" or "sell"`);
+    }
+    if (isNaN(Number(size)) || Number(size) <= 0) {
+        throw new Error(`Invalid size "${size}" — must be a positive number`);
+    }
+    return { exchange: normalizedExchange, symbol: symbol.toUpperCase(), side, size };
+}
+function registerMultiAction(parent, getAdapterForExchange, isJson, deprecated = false) {
+    const cmd = parent
+        .command("multi <legs...>")
+        .description(deprecated ? "Use 'perp trade multi'" : "Execute multi-leg orders (exchange:symbol:side:size)");
+    if (deprecated)
+        cmd._hidden = true;
+    cmd
+        .option("--smart", "Use smart order (IOC limit + fallback) for each leg")
+        .option("--rollback", "Auto-rollback filled legs if any leg fails", true)
+        .option("--no-rollback", "Disable auto-rollback")
+        .option("--timeout <ms>", "Per-leg timeout in milliseconds", "30000")
+        .action(async (legSpecs, opts) => {
+        await withJsonErrors(isJson(), async () => {
+            // Parse legs
+            const legs = legSpecs.map(parseMultiLeg);
+            if (legs.length < 2) {
+                const err = "Multi-leg requires at least 2 legs";
+                if (isJson()) {
+                    printJson(jsonError("INVALID_ARGS", err));
+                    return;
+                }
+                throw new Error(err);
+            }
+            if (!isJson()) {
+                console.log(chalk.cyan.bold("Multi-Leg Order\n"));
+                for (const l of legs) {
+                    const color = l.side === "buy" ? chalk.green : chalk.red;
+                    console.log(`  ${l.exchange.padEnd(14)} ${color(l.side.toUpperCase())} ${l.symbol} x ${l.size}`);
+                }
+                console.log();
+            }
+            // Get adapters (deduplicated)
+            const adapters = new Map();
+            for (const l of legs) {
+                if (!adapters.has(l.exchange)) {
+                    adapters.set(l.exchange, await getAdapterForExchange(l.exchange));
+                }
+            }
+            // Execute all legs simultaneously
+            const timeoutMs = parseInt(opts.timeout);
+            const results = await Promise.allSettled(legs.map(async (leg) => {
+                const adapter = adapters.get(leg.exchange);
+                const orderPromise = opts.smart
+                    ? smartOrder(adapter, leg.symbol, leg.side, leg.size).then(r => r.result)
+                    : adapter.marketOrder(leg.symbol, leg.side, leg.size);
+                // Apply timeout
+                const result = await Promise.race([
+                    orderPromise,
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("Leg timeout")), timeoutMs)),
+                ]);
+                // Log execution
+                logExecution({
+                    type: "multi_leg",
+                    exchange: leg.exchange,
+                    symbol: leg.symbol,
+                    side: leg.side,
+                    size: leg.size,
+                    status: "success",
+                    dryRun: false,
+                    meta: { result, smart: opts.smart },
+                });
+                return { leg, status: "filled", result };
+            }));
+            // Process results
+            const legResults = results.map((r, i) => {
+                if (r.status === "fulfilled")
+                    return r.value;
+                return {
+                    leg: legs[i],
+                    status: "failed",
+                    error: r.reason instanceof Error ? r.reason.message : String(r.reason),
+                };
+            });
+            const filled = legResults.filter(r => r.status === "filled");
+            const failed = legResults.filter(r => r.status === "failed");
+            // Rollback if partial fill and rollback enabled
+            if (failed.length > 0 && filled.length > 0 && opts.rollback) {
+                if (!isJson()) {
+                    console.log(chalk.yellow(`\n  ${failed.length} leg(s) failed — rolling back ${filled.length} filled leg(s)...\n`));
+                }
+                for (const fr of filled) {
+                    const adapter = adapters.get(fr.leg.exchange);
+                    const reverseSide = fr.leg.side === "buy" ? "sell" : "buy";
+                    try {
+                        await adapter.marketOrder(fr.leg.symbol, reverseSide, fr.leg.size);
+                        fr.status = "rolled_back";
+                        logExecution({
+                            type: "multi_leg_rollback",
+                            exchange: fr.leg.exchange,
+                            symbol: fr.leg.symbol,
+                            side: reverseSide,
+                            size: fr.leg.size,
+                            status: "success",
+                            dryRun: false,
+                        });
+                        if (!isJson()) {
+                            console.log(chalk.gray(`  Rolled back: ${fr.leg.exchange} ${reverseSide} ${fr.leg.symbol} x ${fr.leg.size}`));
+                        }
+                    }
+                    catch (err) {
+                        if (!isJson()) {
+                            console.log(chalk.red(`  Rollback failed: ${fr.leg.exchange} ${fr.leg.symbol} — ${err instanceof Error ? err.message : err}`));
+                        }
+                    }
+                }
+            }
+            if (isJson()) {
+                printJson(jsonOk({
+                    legs: legResults.map(r => ({
+                        exchange: r.leg.exchange,
+                        symbol: r.leg.symbol,
+                        side: r.leg.side,
+                        size: r.leg.size,
+                        status: r.status,
+                        error: r.error,
+                    })),
+                    summary: {
+                        total: legs.length,
+                        filled: legResults.filter(r => r.status === "filled").length,
+                        failed: failed.length,
+                        rolledBack: legResults.filter(r => r.status === "rolled_back").length,
+                    },
+                }));
+            }
+            else {
+                console.log(chalk.cyan.bold("\nResults:\n"));
+                for (const r of legResults) {
+                    const icon = r.status === "filled" ? chalk.green("OK") :
+                        r.status === "rolled_back" ? chalk.yellow("ROLLBACK") :
+                            chalk.red("FAIL");
+                    console.log(`  ${icon} ${r.leg.exchange.padEnd(14)} ${r.leg.side} ${r.leg.symbol} x ${r.leg.size}${r.error ? ` — ${r.error}` : ""}`);
+                }
+                console.log(`\n  Total: ${legs.length}  Filled: ${filled.length}  Failed: ${failed.length}  Rolled back: ${legResults.filter(r => r.status === "rolled_back").length}`);
+            }
+        });
+    });
 }

package/dist/commands/wallet.d.ts

@@ -11,4 +11,8 @@ export declare function getWalletSetupStatus(): {
 };
 /** Exported so config.ts can resolve the active wallet key */
 export declare function getActiveWalletKey(exchange: string): string | null;
+/** Get wallet key by name. Returns null if wallet doesn't exist. */
+export declare function getWalletKeyByName(name: string): string | null;
+/** Get all wallet names. */
+export declare function getWalletNames(): string[];
 export declare function registerWalletCommands(program: Command, isJson: () => boolean): void;

package/dist/commands/wallet.js

@@ -42,6 +42,16 @@ export function getActiveWalletKey(exchange) {
         return null;
     return store.wallets[name]?.privateKey ?? null;
 }
+/** Get wallet key by name. Returns null if wallet doesn't exist. */
+export function getWalletKeyByName(name) {
+    const store = loadStore();
+    return store.wallets[name]?.privateKey ?? null;
+}
+/** Get all wallet names. */
+export function getWalletNames() {
+    const store = loadStore();
+    return Object.keys(store.wallets);
+}
 async function getSolanaBalances(address, isTestnet) {
     const { Connection, PublicKey } = await import("@solana/web3.js");
     const rpcUrl = isTestnet

package/dist/config.d.ts

@@ -4,7 +4,7 @@ export type Exchange = "pacifica" | "hyperliquid" | "lighter";
  * Try to load a private key without throwing if none is found.
  * Returns null if no key is configured.
  */
-export declare function tryLoadPrivateKey(exchange: Exchange, pkOverride?: string): Promise<string | null>;
-export declare function loadPrivateKey(exchange: Exchange, pkOverride?: string): Promise<string>;
+export declare function tryLoadPrivateKey(exchange: Exchange, pkOverride?: string, walletName?: string): Promise<string | null>;
+export declare function loadPrivateKey(exchange: Exchange, pkOverride?: string, walletName?: string): Promise<string>;
 export declare function parseSolanaKeypair(input: string): Keypair;
 export declare function isEvmPrivateKey(input: string): boolean;

package/dist/config.js

@@ -7,15 +7,23 @@ import { existsSync, readFileSync } from "fs";
  * Try to load a private key without throwing if none is found.
  * Returns null if no key is configured.
  */
-export async function tryLoadPrivateKey(exchange, pkOverride) {
+export async function tryLoadPrivateKey(exchange, pkOverride, walletName) {
     try {
-        return await loadPrivateKey(exchange, pkOverride);
+        return await loadPrivateKey(exchange, pkOverride, walletName);
     }
     catch {
         return null;
     }
 }
-export async function loadPrivateKey(exchange, pkOverride) {
+export async function loadPrivateKey(exchange, pkOverride, walletName) {
+    // 0. Wallet name override (--wallet flag)
+    if (walletName) {
+        const { getWalletKeyByName } = await import("./commands/wallet.js");
+        const key = getWalletKeyByName(walletName);
+        if (!key)
+            throw new Error(`Wallet "${walletName}" not found. Run: perp wallet list`);
+        return key;
+    }
     // 1. CLI flag
     if (pkOverride)
         return pkOverride;

package/dist/exchanges/hyperliquid-spot.d.ts

@@ -15,6 +15,7 @@ export declare class HyperliquidSpotAdapter implements SpotAdapter {
     private _spotAssetReverse;
     private _spotDecimals;
     private _initialized;
+    private _cachedMetaCtx;
     constructor(hlAdapter: HyperliquidAdapter);
     /** Load spot metadata from the Hyperliquid spot API */
     init(): Promise<void>;