perp-cli 0.3.3

package/dist/commands/bridge.js

@@ -0,0 +1,396 @@
+import chalk from "chalk";
+import { formatUsd, makeTable, printJson, jsonOk } from "../utils.js";
+import { logExecution } from "../execution-log.js";
+import { executeBestBridge, getAllQuotes, checkDebridgeStatus, checkBridgeGasBalance, CHAIN_IDS, USDC_ADDRESSES, EXCHANGE_TO_CHAIN, } from "../bridge-engine.js";
+export function registerBridgeCommands(program, isJson) {
+    const bridge = program.command("bridge").description("Cross-chain USDC bridge (deBridge DLN)");
+    // ── bridge chains ──
+    bridge
+        .command("chains")
+        .description("List supported chains and USDC addresses")
+        .action(async () => {
+        if (isJson()) {
+            return printJson(jsonOk({ chains: CHAIN_IDS, usdc: USDC_ADDRESSES, exchanges: EXCHANGE_TO_CHAIN }));
+        }
+        console.log(chalk.cyan.bold("\n  Supported Bridge Chains\n"));
+        const rows = Object.entries(CHAIN_IDS).map(([chain, id]) => [
+            chalk.white.bold(chain),
+            String(id),
+            USDC_ADDRESSES[chain] ? chalk.green("USDC") : chalk.gray("-"),
+            USDC_ADDRESSES[chain] ? chalk.gray(USDC_ADDRESSES[chain].slice(0, 10) + "...") : "",
+        ]);
+        console.log(makeTable(["Chain", "Chain ID", "Token", "Address"], rows));
+        console.log(chalk.cyan.bold("  Exchange → Chain Mapping\n"));
+        for (const [ex, chain] of Object.entries(EXCHANGE_TO_CHAIN)) {
+            console.log(`  ${chalk.white.bold(ex.padEnd(14))} → ${chain}`);
+        }
+        console.log(chalk.gray("\n  Bridge powered by deBridge DLN (~2s settlement)\n"));
+    });
+    // ── bridge quote ──
+    bridge
+        .command("quote")
+        .description("Get bridge quotes from all providers")
+        .requiredOption("--from <chain>", "Source chain (solana, arbitrum, base)")
+        .requiredOption("--to <chain>", "Destination chain")
+        .requiredOption("--amount <amount>", "USDC amount")
+        .option("--sender <address>", "Source address")
+        .option("--recipient <address>", "Destination address")
+        .action(async (opts) => {
+        const srcChain = opts.from.toLowerCase();
+        const dstChain = opts.to.toLowerCase();
+        const amount = parseFloat(opts.amount);
+        if (!isJson())
+            console.log(chalk.cyan(`\n  Fetching quotes: $${amount} USDC ${srcChain} → ${dstChain}...\n`));
+        const quotes = await getAllQuotes(srcChain, dstChain, amount, opts.sender ?? "0x0000000000000000000000000000000000000000", opts.recipient ?? "0x0000000000000000000000000000000000000000");
+        if (isJson())
+            return printJson(jsonOk({ quotes }));
+        if (quotes.length === 0) {
+            console.log(chalk.red("  No providers available for this route.\n"));
+            return;
+        }
+        const PROVIDER_NAMES = {
+            cctp: "Circle CCTP",
+            relay: "Relay",
+            debridge: "deBridge DLN",
+        };
+        const rows = quotes.map((q, i) => {
+            const tag = i === 0 ? chalk.green(" ★ BEST") : "";
+            const name = PROVIDER_NAMES[q.provider] ?? q.provider;
+            const feeStr = q.fee <= 0 ? chalk.green("FREE") : `$${formatUsd(q.fee)}`;
+            const pct = ((q.fee / q.amountIn) * 100).toFixed(2);
+            const gasTag = q.gasIncluded
+                ? chalk.green("included")
+                : chalk.yellow("dst gas needed");
+            return [
+                (i === 0 ? chalk.green.bold(name) : chalk.white(name)) + tag,
+                `$${formatUsd(q.amountOut)}`,
+                `${feeStr} (${pct}%)`,
+                `~${q.estimatedTime}s`,
+                gasTag,
+            ];
+        });
+        console.log(chalk.cyan.bold(`  Bridge Quotes: $${formatUsd(amount)} USDC ${srcChain} → ${dstChain}\n`));
+        console.log(makeTable(["Provider", "Receive", "Fee", "ETA", "Dst Gas"], rows));
+        // Show gas notes per provider
+        for (const q of quotes) {
+            if (q.gasNote) {
+                const name = PROVIDER_NAMES[q.provider] ?? q.provider;
+                console.log(chalk.gray(`  ${name}: ${q.gasNote}`));
+            }
+        }
+        console.log();
+        console.log(chalk.gray(`  Execute with: perp bridge send --from ${srcChain} --to ${dstChain} --amount ${opts.amount}`));
+        console.log(chalk.gray(`  Pick provider: --provider cctp|relay|debridge\n`));
+    });
+    // ── bridge send ──
+    bridge
+        .command("send")
+        .description("Execute a USDC bridge transaction")
+        .requiredOption("--from <chain>", "Source chain")
+        .requiredOption("--to <chain>", "Destination chain")
+        .requiredOption("--amount <amount>", "USDC amount")
+        .option("--sender <address>", "Source address (auto-detected from key)")
+        .option("--recipient <address>", "Destination address")
+        .option("--provider <name>", "Force provider: cctp, relay, debridge (default: cheapest)")
+        .option("--fast", "Use fast finality (~1-2 min, $1-1.3 fee, auto-relay). Default: standard (~13-20 min, $0.01, manual relay)")
+        .option("--dry-run", "Show quotes without executing")
+        .action(async (opts) => {
+        const srcChain = opts.from.toLowerCase();
+        const dstChain = opts.to.toLowerCase();
+        const amount = parseFloat(opts.amount);
+        if (isNaN(amount) || amount <= 0)
+            throw new Error("Invalid amount");
+        const chosenProvider = opts.provider?.toLowerCase();
+        if (chosenProvider && !["cctp", "relay", "debridge"].includes(chosenProvider)) {
+            throw new Error(`Invalid provider: ${opts.provider}. Use cctp, relay, or debridge.`);
+        }
+        // Load the appropriate private key
+        const { loadPrivateKey, parseSolanaKeypair } = await import("../config.js");
+        let senderAddress;
+        let recipientAddress;
+        let signerKey;
+        if (srcChain === "solana") {
+            const pk = await loadPrivateKey("pacifica");
+            const keypair = parseSolanaKeypair(pk);
+            senderAddress = opts.sender ?? keypair.publicKey.toBase58();
+            signerKey = pk;
+        }
+        else {
+            const exchange = "hyperliquid";
+            const pk = await loadPrivateKey(exchange);
+            const { ethers } = await import("ethers");
+            const wallet = new ethers.Wallet(pk);
+            senderAddress = opts.sender ?? wallet.address;
+            signerKey = pk;
+        }
+        // Determine recipient address and destination signer key
+        let dstSignerKey;
+        if (opts.recipient) {
+            recipientAddress = opts.recipient;
+        }
+        else if (dstChain === "solana") {
+            const pk = await loadPrivateKey("pacifica");
+            const keypair = parseSolanaKeypair(pk);
+            recipientAddress = keypair.publicKey.toBase58();
+            dstSignerKey = pk;
+        }
+        else {
+            const exchange = "hyperliquid";
+            const pk = await loadPrivateKey(exchange);
+            const { ethers } = await import("ethers");
+            recipientAddress = new ethers.Wallet(pk).address;
+            dstSignerKey = pk;
+        }
+        // Fetch all quotes
+        if (!isJson())
+            console.log(chalk.cyan(`\n  Bridge: $${amount} USDC ${srcChain} → ${dstChain}\n`));
+        const quotes = await getAllQuotes(srcChain, dstChain, amount, senderAddress, recipientAddress);
+        if (quotes.length === 0)
+            throw new Error(`No bridge available for ${srcChain} → ${dstChain}`);
+        // Pick the quote to use
+        let selectedQuote;
+        if (chosenProvider) {
+            const match = quotes.find(q => q.provider === chosenProvider);
+            if (!match)
+                throw new Error(`Provider "${chosenProvider}" not available for this route`);
+            selectedQuote = match;
+        }
+        else {
+            selectedQuote = quotes[0]; // best (sorted by amountOut)
+        }
+        const PROVIDER_NAMES = {
+            cctp: "Circle CCTP",
+            relay: "Relay",
+            debridge: "deBridge DLN",
+        };
+        if (!isJson()) {
+            // Show comparison table
+            const rows = quotes.map((q) => {
+                const name = PROVIDER_NAMES[q.provider] ?? q.provider;
+                const selected = q.provider === selectedQuote.provider;
+                const feeStr = q.fee <= 0 ? chalk.green("FREE") : `$${formatUsd(q.fee)}`;
+                const pct = ((q.fee / q.amountIn) * 100).toFixed(2);
+                const tag = selected ? chalk.green(" ← selected") : "";
+                const gasTag = q.gasIncluded
+                    ? chalk.green("included")
+                    : chalk.yellow("dst gas needed");
+                return [
+                    (selected ? chalk.green.bold(name) : chalk.white(name)) + tag,
+                    `$${formatUsd(q.amountOut)}`,
+                    `${feeStr} (${pct}%)`,
+                    `~${q.estimatedTime}s`,
+                    gasTag,
+                ];
+            });
+            console.log(makeTable(["Provider", "Receive", "Fee", "ETA", "Dst Gas"], rows));
+            if (!selectedQuote.gasIncluded) {
+                console.log(chalk.yellow(`  ⚠ ${selectedQuote.gasNote}`));
+            }
+            console.log(`  From:     ${senderAddress}`);
+            console.log(`  To:       ${recipientAddress}\n`);
+        }
+        if (opts.dryRun) {
+            if (isJson())
+                return printJson(jsonOk({ quotes, selected: selectedQuote.provider }));
+            console.log(chalk.yellow("  [DRY RUN] Transaction not executed.\n"));
+            return;
+        }
+        // Gas balance preflight check
+        const needsDstGas = !selectedQuote.gasIncluded;
+        const gasCheck = await checkBridgeGasBalance(srcChain, senderAddress, dstChain, recipientAddress, needsDstGas);
+        if (!gasCheck.ok) {
+            const msg = gasCheck.errors.map(e => `  ✗ ${e}`).join("\n");
+            if (isJson())
+                return printJson({ ok: false, error: "Insufficient gas", details: gasCheck.errors });
+            console.log(chalk.red("\n  Insufficient gas for bridge:\n"));
+            console.log(chalk.red(msg));
+            if (needsDstGas) {
+                console.log(chalk.yellow("\n  Tip: use --fast to skip destination gas (Circle auto-relays)\n"));
+            }
+            process.exitCode = 1;
+            return;
+        }
+        const providerName = PROVIDER_NAMES[selectedQuote.provider] ?? selectedQuote.provider;
+        if (!isJson())
+            console.log(chalk.yellow(`  Executing via ${providerName}...\n`));
+        let result;
+        try {
+            result = await executeBestBridge(srcChain, dstChain, amount, signerKey, senderAddress, recipientAddress, dstSignerKey, chosenProvider, !!opts.fast);
+            logExecution({ type: "bridge", exchange: "bridge", symbol: "USDC", side: `${srcChain}->${dstChain}`, size: String(amount), status: "success", dryRun: false, meta: { provider: result.provider, txHash: result.txHash, fast: !!opts.fast } });
+        }
+        catch (err) {
+            logExecution({ type: "bridge", exchange: "bridge", symbol: "USDC", side: `${srcChain}->${dstChain}`, size: String(amount), status: "failed", dryRun: false, error: err instanceof Error ? err.message : String(err) });
+            throw err;
+        }
+        if (isJson())
+            return printJson(jsonOk(result));
+        console.log(chalk.green("  Bridge transaction submitted!"));
+        console.log(`  TX Hash:  ${result.txHash}`);
+        console.log(`  Provider: ${result.provider}`);
+        if (result.receiveTxHash) {
+            console.log(`  Receive:  ${result.receiveTxHash} (${dstChain})`);
+        }
+        console.log(chalk.gray(`\n  Funds arrive in ~${selectedQuote.estimatedTime}s on ${dstChain}.\n`));
+    });
+    // ── bridge between exchanges (shortcut) ──
+    bridge
+        .command("exchange")
+        .description("Bridge USDC between exchanges (shortcut)")
+        .requiredOption("--from <exchange>", "Source exchange (pacifica, hyperliquid, lighter)")
+        .requiredOption("--to <exchange>", "Destination exchange")
+        .requiredOption("--amount <amount>", "USDC amount")
+        .option("--provider <name>", "Force provider: cctp, relay, debridge (default: cheapest)")
+        .option("--fast", "Use fast finality (~1-2 min, $1-1.3 fee, auto-relay)")
+        .option("--dry-run", "Show quotes without executing")
+        .action(async (opts) => {
+        const srcExchange = opts.from.toLowerCase();
+        const dstExchange = opts.to.toLowerCase();
+        const srcChain = EXCHANGE_TO_CHAIN[srcExchange];
+        const dstChain = EXCHANGE_TO_CHAIN[dstExchange];
+        if (!srcChain)
+            throw new Error(`Unknown exchange: ${srcExchange}`);
+        if (!dstChain)
+            throw new Error(`Unknown exchange: ${dstExchange}`);
+        if (srcChain === dstChain)
+            throw new Error("Same chain — no bridge needed");
+        const chosenProvider = opts.provider?.toLowerCase();
+        if (chosenProvider && !["cctp", "relay", "debridge"].includes(chosenProvider)) {
+            throw new Error(`Invalid provider: ${opts.provider}. Use cctp, relay, or debridge.`);
+        }
+        const amount = parseFloat(opts.amount);
+        if (!isJson())
+            console.log(chalk.cyan(`\n  Bridge: $${amount} USDC ${srcExchange} (${srcChain}) → ${dstExchange} (${dstChain})\n`));
+        // Load keys
+        const { loadPrivateKey, parseSolanaKeypair } = await import("../config.js");
+        let senderAddress;
+        let recipientAddress;
+        let signerKey;
+        // Source
+        if (srcChain === "solana") {
+            const pk = await loadPrivateKey("pacifica");
+            senderAddress = parseSolanaKeypair(pk).publicKey.toBase58();
+            signerKey = pk;
+        }
+        else {
+            const pk = await loadPrivateKey(srcExchange);
+            const { ethers } = await import("ethers");
+            senderAddress = new ethers.Wallet(pk).address;
+            signerKey = pk;
+        }
+        // Destination
+        let dstSignerKey;
+        if (dstChain === "solana") {
+            const pk = await loadPrivateKey("pacifica");
+            recipientAddress = parseSolanaKeypair(pk).publicKey.toBase58();
+            dstSignerKey = pk;
+        }
+        else {
+            const pk = await loadPrivateKey(dstExchange);
+            const { ethers } = await import("ethers");
+            recipientAddress = new ethers.Wallet(pk).address;
+            dstSignerKey = pk;
+        }
+        const quotes = await getAllQuotes(srcChain, dstChain, amount, senderAddress, recipientAddress);
+        if (quotes.length === 0)
+            throw new Error(`No bridge available for ${srcChain} → ${dstChain}`);
+        let selectedQuote;
+        if (chosenProvider) {
+            const match = quotes.find(q => q.provider === chosenProvider);
+            if (!match)
+                throw new Error(`Provider "${chosenProvider}" not available for this route`);
+            selectedQuote = match;
+        }
+        else {
+            selectedQuote = quotes[0];
+        }
+        const PROVIDER_NAMES = {
+            cctp: "Circle CCTP",
+            relay: "Relay",
+            debridge: "deBridge DLN",
+        };
+        if (!isJson()) {
+            const rows = quotes.map((q) => {
+                const name = PROVIDER_NAMES[q.provider] ?? q.provider;
+                const selected = q.provider === selectedQuote.provider;
+                const feeStr = q.fee <= 0 ? chalk.green("FREE") : `$${formatUsd(q.fee)}`;
+                const pct = ((q.fee / q.amountIn) * 100).toFixed(2);
+                const tag = selected ? chalk.green(" ← selected") : "";
+                const gasTag = q.gasIncluded
+                    ? chalk.green("included")
+                    : chalk.yellow("dst gas needed");
+                return [
+                    (selected ? chalk.green.bold(name) : chalk.white(name)) + tag,
+                    `$${formatUsd(q.amountOut)}`,
+                    `${feeStr} (${pct}%)`,
+                    `~${q.estimatedTime}s`,
+                    gasTag,
+                ];
+            });
+            console.log(makeTable(["Provider", "Receive", "Fee", "ETA", "Dst Gas"], rows));
+            if (!selectedQuote.gasIncluded) {
+                console.log(chalk.yellow(`  ⚠ ${selectedQuote.gasNote}`));
+            }
+        }
+        if (opts.dryRun) {
+            if (isJson())
+                return printJson(jsonOk({ quotes, selected: selectedQuote.provider }));
+            console.log(chalk.yellow("  [DRY RUN] Not executed.\n"));
+            return;
+        }
+        // Gas balance preflight check
+        const needsDstGas = !selectedQuote.gasIncluded;
+        const gasCheck = await checkBridgeGasBalance(srcChain, senderAddress, dstChain, recipientAddress, needsDstGas);
+        if (!gasCheck.ok) {
+            const msg = gasCheck.errors.map(e => `  ✗ ${e}`).join("\n");
+            if (isJson())
+                return printJson({ ok: false, error: "Insufficient gas", details: gasCheck.errors });
+            console.log(chalk.red("\n  Insufficient gas for bridge:\n"));
+            console.log(chalk.red(msg));
+            if (needsDstGas) {
+                console.log(chalk.yellow("\n  Tip: use --fast to skip destination gas (Circle auto-relays)\n"));
+            }
+            process.exitCode = 1;
+            return;
+        }
+        const providerName = PROVIDER_NAMES[selectedQuote.provider] ?? selectedQuote.provider;
+        if (!isJson())
+            console.log(chalk.yellow(`  Executing via ${providerName}...\n`));
+        let result;
+        try {
+            result = await executeBestBridge(srcChain, dstChain, amount, signerKey, senderAddress, recipientAddress, dstSignerKey, chosenProvider, !!opts.fast);
+            logExecution({ type: "bridge", exchange: "bridge", symbol: "USDC", side: `${srcExchange}->${dstExchange}`, size: String(amount), status: "success", dryRun: false, meta: { provider: result.provider, txHash: result.txHash, fast: !!opts.fast } });
+        }
+        catch (err) {
+            logExecution({ type: "bridge", exchange: "bridge", symbol: "USDC", side: `${srcExchange}->${dstExchange}`, size: String(amount), status: "failed", dryRun: false, error: err instanceof Error ? err.message : String(err) });
+            throw err;
+        }
+        if (isJson())
+            return printJson(jsonOk(result));
+        console.log(chalk.green("  Bridge submitted!"));
+        console.log(`  TX:       ${result.txHash}`);
+        console.log(`  Provider: ${result.provider}`);
+        if (result.receiveTxHash) {
+            console.log(`  Receive:  ${result.receiveTxHash} (${dstChain})`);
+            console.log(chalk.green(`  USDC arrived on ${dstExchange}!`));
+        }
+        console.log(chalk.gray(`\n  After arrival, deposit into ${dstExchange}:`));
+        console.log(chalk.gray(`  perp deposit ${dstExchange} ${opts.amount}\n`));
+    });
+    // ── bridge status ──
+    bridge
+        .command("status <orderId>")
+        .description("Check bridge order status")
+        .action(async (orderId) => {
+        const status = await checkDebridgeStatus(orderId);
+        if (isJson())
+            return printJson(jsonOk(status));
+        const state = String(status.status ?? status.orderStatus ?? "unknown");
+        const stateColor = state.includes("Fulfilled") || state.includes("completed")
+            ? chalk.green
+            : state.includes("pending") ? chalk.yellow : chalk.white;
+        console.log(chalk.cyan.bold("\n  Bridge Order Status\n"));
+        console.log(`  Order ID: ${orderId}`);
+        console.log(`  Status:   ${stateColor(state)}`);
+        console.log();
+    });
+}

package/dist/commands/dashboard.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export declare function registerDashboardCommands(program: Command, getAdapterForExchange: (exchange: string) => Promise<ExchangeAdapter>, isJson: () => boolean, getHLAdapterForDex?: (dex: string) => Promise<ExchangeAdapter>): void;

package/dist/commands/dashboard.js

@@ -0,0 +1,176 @@
+import chalk from "chalk";
+import { startDashboard } from "../dashboard/server.js";
+const KNOWN_HIP3_DEXES = ["xyz", "flx", "hyna", "km", "cash", "vntl"];
+const HL_INFO_URL = "https://api.hyperliquid.xyz/info";
+/** Lightweight check: query HL info API directly for dex positions (no SDK/WebSocket needed) */
+async function checkDexPositions(address, dex) {
+    try {
+        const res = await fetch(HL_INFO_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ type: "clearinghouseState", user: address, dex }),
+        });
+        const state = await res.json();
+        const positions = (state?.assetPositions ?? []);
+        return positions.filter(p => {
+            const pos = (p.position ?? p);
+            return Number(pos.szi ?? 0) !== 0;
+        }).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Scan known HIP-3 dexes for active positions, then create adapters only for active ones */
+async function autoDetectHip3Dexes(address, getHLAdapterForDex, verbose) {
+    // Phase 1: lightweight parallel scan via raw API (no WebSocket connections)
+    const checks = await Promise.all(KNOWN_HIP3_DEXES.map(async (dex) => ({
+        dex,
+        count: await checkDexPositions(address, dex),
+    })));
+    const activeDexes = checks.filter(c => c.count > 0);
+    // Phase 2: create full adapters only for dexes with positions
+    const results = [];
+    for (const { dex, count } of activeDexes) {
+        try {
+            const adapter = await getHLAdapterForDex(dex);
+            results.push({ name: `hl:${dex}`, adapter });
+            if (verbose)
+                console.log(chalk.green(`  ✓ hl:${dex} (HIP-3, ${count} position${count > 1 ? "s" : ""})`));
+        }
+        catch {
+            // skip
+        }
+    }
+    return results;
+}
+export function registerDashboardCommands(program, getAdapterForExchange, isJson, getHLAdapterForDex) {
+    program
+        .command("dashboard")
+        .description("Launch live web dashboard for real-time portfolio monitoring")
+        .option("-p, --port <port>", "Port to serve dashboard on (auto-finds free port)", "3456")
+        .option("--interval <ms>", "Poll interval in milliseconds", "5000")
+        .option("--exchanges <list>", "Comma-separated exchanges to monitor", "pacifica,hyperliquid,lighter")
+        .option("--dex <list>", "Comma-separated HIP-3 dexes to monitor (e.g. xyz,flx,hyna)")
+        .option("--no-auto-dex", "Disable auto-detection of HIP-3 dexes with active positions")
+        .action(async (opts) => {
+        const exchangeNames = opts.exchanges.split(",").map((s) => s.trim()).filter(Boolean);
+        const dexNames = opts.dex ? opts.dex.split(",").map((s) => s.trim()).filter(Boolean) : [];
+        const autoDex = opts.autoDex !== false;
+        const port = parseInt(opts.port, 10);
+        const interval = parseInt(opts.interval, 10);
+        if (isJson()) {
+            const { printJson, jsonOk } = await import("../utils.js");
+            const exchanges = [];
+            for (const name of exchangeNames) {
+                try {
+                    const adapter = await getAdapterForExchange(name);
+                    exchanges.push({ name, adapter });
+                }
+                catch { /* skip */ }
+            }
+            if (getHLAdapterForDex) {
+                for (const dex of dexNames) {
+                    try {
+                        const adapter = await getHLAdapterForDex(dex);
+                        exchanges.push({ name: `hl:${dex}`, adapter });
+                    }
+                    catch { /* skip */ }
+                }
+                if (autoDex && !dexNames.length && exchangeNames.includes("hyperliquid")) {
+                    const hlEx = exchanges.find(e => e.name === "hyperliquid");
+                    const hlAddr = hlEx ? hlEx.adapter.address ?? "" : "";
+                    if (hlAddr) {
+                        const detected = await autoDetectHip3Dexes(hlAddr, getHLAdapterForDex, false);
+                        exchanges.push(...detected);
+                    }
+                }
+            }
+            if (!exchanges.length) {
+                const { jsonError } = await import("../utils.js");
+                console.log(JSON.stringify(jsonError("NO_EXCHANGES", "No exchange adapters could be initialized. Check your keys.")));
+                process.exit(1);
+            }
+            const dashboard = await startDashboard(exchanges, { port, pollInterval: interval });
+            printJson(jsonOk({ url: `http://localhost:${dashboard.port}`, port: dashboard.port, exchanges: exchanges.map((e) => e.name) }));
+            await new Promise(() => { });
+            return;
+        }
+        console.log(chalk.cyan.bold("\n  perp-cli Live Dashboard\n"));
+        console.log(chalk.gray(`  Initializing exchanges: ${exchangeNames.join(", ")}${dexNames.length ? ` + HIP-3: ${dexNames.join(", ")}` : ""}...\n`));
+        const exchanges = [];
+        for (const name of exchangeNames) {
+            try {
+                const adapter = await getAdapterForExchange(name);
+                exchanges.push({ name, adapter });
+                console.log(chalk.green(`  ✓ ${name}`));
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.log(chalk.yellow(`  ✗ ${name}: ${msg.slice(0, 80)}`));
+            }
+        }
+        // Initialize HIP-3 dex adapters (explicit --dex)
+        if (getHLAdapterForDex) {
+            for (const dex of dexNames) {
+                try {
+                    const adapter = await getHLAdapterForDex(dex);
+                    exchanges.push({ name: `hl:${dex}`, adapter });
+                    console.log(chalk.green(`  ✓ hl:${dex} (HIP-3)`));
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.log(chalk.yellow(`  ✗ hl:${dex}: ${msg.slice(0, 80)}`));
+                }
+            }
+            // Auto-detect HIP-3 dexes with active positions (when --dex not specified)
+            if (autoDex && !dexNames.length && exchangeNames.includes("hyperliquid")) {
+                const hlEx = exchanges.find(e => e.name === "hyperliquid");
+                const hlAddr = hlEx ? hlEx.adapter.address ?? "" : "";
+                if (hlAddr) {
+                    console.log(chalk.gray("  Scanning HIP-3 dexes for active positions..."));
+                    const detected = await autoDetectHip3Dexes(hlAddr, getHLAdapterForDex, true);
+                    exchanges.push(...detected);
+                    if (!detected.length)
+                        console.log(chalk.gray("  No active HIP-3 dex positions found"));
+                }
+            }
+        }
+        if (!exchanges.length) {
+            console.error(chalk.red("\n  No exchanges available. Check your private keys in .env\n"));
+            process.exit(1);
+        }
+        console.log(chalk.gray(`\n  Starting server on port ${port}...`));
+        const dashboard = await startDashboard(exchanges, { port, pollInterval: interval });
+        console.log(chalk.cyan.bold(`\n  Dashboard running at: `) + chalk.white.bold(`http://localhost:${dashboard.port}`));
+        console.log(chalk.gray(`  Monitoring: ${exchanges.map((e) => e.name).join(", ")}`));
+        console.log(chalk.gray(`  Poll interval: ${interval}ms`));
+        console.log(chalk.gray(`  Press Ctrl+C to stop\n`));
+        // Open browser automatically (best-effort)
+        try {
+            const { exec } = await import("child_process");
+            const url = `http://localhost:${dashboard.port}`;
+            if (process.platform === "darwin")
+                exec(`open ${url}`);
+            else if (process.platform === "linux")
+                exec(`xdg-open ${url}`);
+        }
+        catch {
+            // ignore — user can open manually
+        }
+        // Keep process running
+        const ac = new AbortController();
+        process.on("SIGINT", () => {
+            console.log(chalk.gray("\n  Shutting down dashboard..."));
+            dashboard.close();
+            ac.abort();
+            process.exit(0);
+        });
+        process.on("SIGTERM", () => {
+            dashboard.close();
+            ac.abort();
+            process.exit(0);
+        });
+        await new Promise(() => { });
+    });
+}

package/dist/commands/deposit.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+import type { Network } from "../pacifica/index.js";
+export declare function registerDepositCommands(program: Command, getAdapter: () => Promise<ExchangeAdapter>, isJson: () => boolean, getNetwork: () => Network): void;