perp-cli 0.4.2 → 0.4.8

package/dist/commands/arb-auto.js

@@ -898,7 +898,8 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
     // ── arb scan ── (one-shot spread scan)
     arb
         .command("scan")
-        .description("Scan current funding rate spreads")
+        .description("Scan current funding rate spreads (perp-perp or spot-perp)")
+        .option("--mode <mode>", "Scan mode: perp-perp, spot-perp, all", "perp-perp")
         .option("--min <pct>", "Min annual spread to show", "10")
         .option("--top <n>", "Return only top N results (for JSON output)")
         .option("--hold-days <days>", "Expected hold period for cost calc", "7")
@@ -909,8 +910,50 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
         const holdDays = parseFloat(opts.holdDays);
         const bridgeCostUsd = parseFloat(opts.bridgeCost);
         const sizeUsd = parseFloat(opts.size);
+        // ── spot-perp mode ──
+        if (opts.mode === "spot-perp" || opts.mode === "all") {
+            if (!isJson())
+                console.log(chalk.cyan("\n  Scanning spot+perp funding opportunities...\n"));
+            const { fetchSpotPerpSpreads } = await import("../funding/rates.js");
+            const { spreads: spotSpreads } = await fetchSpotPerpSpreads({ minSpread });
+            if (isJson() && opts.mode === "spot-perp") {
+                let result = spotSpreads.map(s => ({
+                    mode: "spot-perp", symbol: s.symbol, perpExchange: s.perpExchange,
+                    spotExchanges: s.spotExchanges, annualSpreadPct: s.annualSpreadPct,
+                    perpFundingRate: s.perpFundingRate, direction: s.direction,
+                    markPrice: s.bestMarkPrice, estHourlyIncomeUsd: s.estHourlyIncomeUsd,
+                }));
+                if (opts.top)
+                    result = result.slice(0, parseInt(opts.top));
+                return printJson(jsonOk(result));
+            }
+            if (!isJson()) {
+                if (spotSpreads.length === 0) {
+                    console.log(chalk.gray(`  No spot+perp opportunities above ${minSpread}%\n`));
+                }
+                else {
+                    console.log(chalk.gray(`  ${"SYMBOL".padEnd(8)} ${"SPREAD".padEnd(8)} ${"PERP EX".padEnd(9)} ${"SPOT EX".padEnd(12)} ${"FUND".padEnd(12)} DIRECTION`));
+                    for (const s of spotSpreads.slice(0, parseInt(opts.top ?? "30"))) {
+                        const spreadColor = s.annualSpreadPct >= 30 ? chalk.green : chalk.yellow;
+                        const dir = s.direction === "long-spot-short-perp" ? "Spot+Short" : "Sell+Long";
+                        console.log(`  ${chalk.white.bold(s.symbol.padEnd(8))} ` +
+                            `${spreadColor(`${s.annualSpreadPct.toFixed(1)}%`.padEnd(8))} ` +
+                            `${s.perpExchange.slice(0, 8).padEnd(9)} ` +
+                            `${s.spotExchanges.join(",").slice(0, 11).padEnd(12)} ` +
+                            `${(s.perpFundingRate * 100).toFixed(4).padEnd(12)}% ` +
+                            dir);
+                    }
+                    console.log(chalk.gray(`\n  ${spotSpreads.length} spot+perp opportunities (spot funding = 0%)`));
+                }
+            }
+            if (opts.mode === "spot-perp")
+                return;
+            if (!isJson())
+                console.log(""); // separator
+        }
+        // ── perp-perp mode (default) ──
         if (!isJson())
-            console.log(chalk.cyan("\n  Scanning funding rate spreads...\n"));
+            console.log(chalk.cyan("  Scanning perp-perp funding rate spreads...\n"));
         const spreads = await fetchFundingSpreads();
         const filtered = spreads.filter(s => Math.abs(s.spread) >= minSpread);
         if (isJson()) {
@@ -918,14 +961,14 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
                 const grossSpread = Math.abs(s.spread);
                 const rtCost = computeRoundTripCostPct(s.longExch, s.shortExch);
                 const net = computeNetSpread(grossSpread, holdDays, rtCost, bridgeCostUsd, sizeUsd);
-                return { symbol: s.symbol, longExch: s.longExch, shortExch: s.shortExch, markPrice: s.markPrice, grossSpread, netSpread: net, estFeesPct: rtCost };
+                return { mode: "perp-perp", symbol: s.symbol, longExch: s.longExch, shortExch: s.shortExch, markPrice: s.markPrice, grossSpread, netSpread: net, estFeesPct: rtCost };
             }).sort((a, b) => b.netSpread - a.netSpread);
             if (opts.top)
                 enriched = enriched.slice(0, parseInt(opts.top));
             return printJson(jsonOk(enriched));
         }
         if (filtered.length === 0) {
-            console.log(chalk.gray(`  No spreads above ${minSpread}%\n`));
+            console.log(chalk.gray(`  No perp-perp spreads above ${minSpread}%\n`));
             return;
         }
         // Header
@@ -1181,6 +1224,602 @@ export function registerArbAutoCommands(program, getAdapterForExchange, isJson,
             console.log(chalk.red(`    SHORT: ${result.shortError}\n`));
         }
     });
+    // ── arb spot-exec ── (spot+perp arb execution)
+    arb
+        .command("spot-exec")
+        .description("Execute spot+perp arb: buy spot + short perp simultaneously")
+        .argument("<symbol>", "Symbol (e.g. ETH, BTC)")
+        .argument("<spotExch>", "Spot exchange: hl (Hyperliquid) or lt (Lighter)")
+        .argument("<perpExch>", "Perp exchange: hl, lt, pac")
+        .argument("<sizeUsd>", "Position size per leg in USD")
+        .option("--max-slippage <pct>", "Max slippage % per leg", "0.5")
+        .option("--leverage <n>", "Set leverage on perp side before entry")
+        .option("--isolated", "Use isolated margin mode on perp side")
+        .option("--dry-run", "Simulate without executing trades")
+        .action(async (symbol, spotExch, perpExch, sizeUsdStr, opts) => {
+        const sym = symbol.toUpperCase();
+        const sizeUsd = parseFloat(sizeUsdStr);
+        const maxSlippage = parseFloat(opts.maxSlippage);
+        const dryRun = !!opts.dryRun || process.argv.includes("--dry-run");
+        // Resolve exchange aliases
+        const aliasMap = { hl: "hyperliquid", pac: "pacifica", lt: "lighter" };
+        spotExch = aliasMap[spotExch.toLowerCase()] || spotExch.toLowerCase();
+        perpExch = aliasMap[perpExch.toLowerCase()] || perpExch.toLowerCase();
+        // Validate spot exchange
+        if (!["hyperliquid", "lighter"].includes(spotExch)) {
+            const msg = `Spot exchange must be hl or lt (got ${spotExch}). Pacifica is perp-only.`;
+            if (isJson())
+                return printJson(jsonOk({ error: msg }));
+            console.log(chalk.red(`  ${msg}`));
+            return;
+        }
+        // Load spot adapter
+        const { HyperliquidSpotAdapter } = await import("../exchanges/hyperliquid-spot.js");
+        const { LighterSpotAdapter } = await import("../exchanges/lighter-spot.js");
+        let spotAdapter;
+        if (spotExch === "hyperliquid") {
+            const hlAdapter = await getAdapterForExchange("hyperliquid");
+            const hlSpot = new HyperliquidSpotAdapter(hlAdapter);
+            await hlSpot.init();
+            spotAdapter = hlSpot;
+        }
+        else {
+            const ltAdapter = await getAdapterForExchange("lighter");
+            const ltSpot = new LighterSpotAdapter(ltAdapter);
+            await ltSpot.init();
+            spotAdapter = ltSpot;
+        }
+        const perpAdapter = await getAdapterForExchange(perpExch);
+        // 1. Set perp leverage if requested
+        if (opts.leverage) {
+            const lev = parseInt(opts.leverage);
+            const mode = opts.isolated ? "isolated" : "cross";
+            if (!isJson())
+                console.log(chalk.gray(`  Setting perp leverage ${lev}x ${mode} on ${perpExch}...`));
+            try {
+                await perpAdapter.setLeverage(sym, lev, mode);
+            }
+            catch (e) {
+                const msg = `Failed to set leverage: ${e instanceof Error ? e.message : e}`;
+                if (isJson())
+                    return printJson(jsonOk({ error: msg }));
+                console.log(chalk.red(`  ${msg}`));
+                return;
+            }
+        }
+        // 2. Auto-transfer USDC to spot account if needed
+        if (spotExch === "hyperliquid") {
+            const hlSpot = spotAdapter;
+            const transferAmt = Math.ceil(sizeUsd * 1.1);
+            try {
+                const xferResult = await hlSpot.transferUsdcToSpot(transferAmt);
+                if (xferResult?.status === "err" && xferResult.response?.includes("unified")) {
+                    if (!isJson())
+                        console.log(chalk.gray(`  Unified account — no USDC transfer needed`));
+                }
+                else if (xferResult?.status !== "err") {
+                    if (!isJson())
+                        console.log(chalk.gray(`  Transferred $${transferAmt} USDC perp→spot`));
+                    await new Promise(r => setTimeout(r, 500));
+                }
+            }
+            catch {
+                // Non-critical — may be unified account or already have balance
+            }
+        }
+        else if (spotExch === "lighter") {
+            // Lighter requires explicit USDC transfer from perp → spot account
+            const ltSpot = spotAdapter;
+            const transferAmt = Math.ceil(sizeUsd * 1.1);
+            try {
+                const xferResult = await ltSpot.transferUsdcToSpot(transferAmt);
+                if (!isJson())
+                    console.log(chalk.gray(`  Transferred $${transferAmt} USDC perp→spot on Lighter`));
+                await new Promise(r => setTimeout(r, 300));
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                if (!isJson())
+                    console.log(chalk.yellow(`  USDC transfer warning: ${msg}`));
+                // Continue — spot order may still work if spot balance already exists
+            }
+        }
+        // 2b. Verify spot USDC balance is sufficient after transfer
+        try {
+            const spotBalances = await spotAdapter.getSpotBalances();
+            const spotUsdc = spotBalances.find(b => b.token === "USDC_SPOT" || b.token === "USDC");
+            const spotUsdcAvail = Number(spotUsdc?.available ?? 0);
+            // Also check perp balance for the perp leg
+            const perpBalance = await perpAdapter.getBalance();
+            const perpAvail = Number(perpBalance?.available ?? 0);
+            if (spotUsdcAvail < sizeUsd * 0.9) {
+                const msg = `Insufficient spot USDC: have $${spotUsdcAvail.toFixed(2)}, need ~$${sizeUsd}. Transfer may have failed.`;
+                if (isJson())
+                    return printJson(jsonOk({ error: msg, spotUsdcAvail, required: sizeUsd }));
+                console.log(chalk.red(`  ${msg}`));
+                return;
+            }
+            if (perpAvail < sizeUsd * 0.5) {
+                const msg = `Insufficient perp balance: have $${perpAvail.toFixed(2)} available on ${perpExch}, need margin for ~$${sizeUsd}`;
+                if (isJson())
+                    return printJson(jsonOk({ error: msg, perpAvail, required: sizeUsd }));
+                console.log(chalk.red(`  ${msg}`));
+                return;
+            }
+        }
+        catch {
+            // Balance check failed — continue with execution, let order placement catch errors
+        }
+        // 3. Fetch orderbooks simultaneously
+        const spotSymbol = `${sym}/USDC`;
+        if (!isJson())
+            console.log(chalk.gray(`  Checking orderbook depth (spot ${spotExch} + perp ${perpExch})...`));
+        const [spotBook, perpBook] = await Promise.all([
+            spotAdapter.getSpotOrderbook(spotSymbol),
+            perpAdapter.getOrderbook(sym),
+        ]);
+        // 3a. Price cross-validation: verify spot and perp are the same underlying
+        //     Prevents wrong-token trades if index mapping is incorrect
+        const spotMid = spotBook.bids.length > 0 && spotBook.asks.length > 0
+            ? (Number(spotBook.bids[0][0]) + Number(spotBook.asks[0][0])) / 2 : 0;
+        const perpMid = perpBook.bids.length > 0 && perpBook.asks.length > 0
+            ? (Number(perpBook.bids[0][0]) + Number(perpBook.asks[0][0])) / 2 : 0;
+        if (spotMid > 0 && perpMid > 0) {
+            const priceDeviation = Math.abs(spotMid - perpMid) / perpMid * 100;
+            if (priceDeviation > 5) {
+                const msg = `Price mismatch: spot mid $${spotMid.toFixed(4)} vs perp mid $${perpMid.toFixed(4)} (${priceDeviation.toFixed(1)}% deviation). Possible wrong token index — aborting.`;
+                if (isJson())
+                    return printJson(jsonOk({ error: msg, spotMid, perpMid, deviationPct: priceDeviation }));
+                console.log(chalk.red(`\n  ${msg}`));
+                return;
+            }
+        }
+        else if (spotMid === 0) {
+            const msg = `Empty spot orderbook for ${sym} — cannot verify token identity`;
+            if (isJson())
+                return printJson(jsonOk({ error: msg }));
+            console.log(chalk.red(`\n  ${msg}`));
+            return;
+        }
+        // 3b. Validate depth
+        const spotCheck = computeExecutableSize(spotBook.asks, sizeUsd, maxSlippage);
+        const perpCheck = computeExecutableSize(perpBook.bids, sizeUsd, maxSlippage);
+        if (!spotCheck.canFillFull || !perpCheck.canFillFull) {
+            const fillableUsd = Math.min(spotCheck.maxSize * spotCheck.avgFillPrice, perpCheck.maxSize * perpCheck.avgFillPrice);
+            if (isJson())
+                return printJson(jsonOk({
+                    error: "Insufficient orderbook depth",
+                    requestedUsd: sizeUsd, fillableUsd: Math.round(fillableUsd * 100) / 100,
+                    spot: { exchange: spotExch, depthUsd: spotCheck.depthUsd, canFill: spotCheck.canFillFull },
+                    perp: { exchange: perpExch, depthUsd: perpCheck.depthUsd, canFill: perpCheck.canFillFull },
+                }));
+            console.log(chalk.red(`\n  Insufficient depth for $${sizeUsd}:`));
+            console.log(chalk.gray(`    ${spotExch} spot asks: $${spotCheck.depthUsd.toFixed(0)}`));
+            console.log(chalk.gray(`    ${perpExch} perp bids: $${perpCheck.depthUsd.toFixed(0)}`));
+            return;
+        }
+        // 4. Compute matched size
+        const inferDecimals = (levels) => {
+            for (const [, s] of levels) {
+                const dot = s.indexOf(".");
+                if (dot >= 0)
+                    return s.length - dot - 1;
+            }
+            return 0;
+        };
+        const spotDecimals = inferDecimals(spotBook.asks);
+        const perpDecimals = inferDecimals(perpBook.bids);
+        const decimals = Math.min(spotDecimals, perpDecimals);
+        const matchedBase = Math.min(spotCheck.recommendedSize, perpCheck.recommendedSize);
+        const matchedSize = (Math.floor(matchedBase * 10 ** decimals) / 10 ** decimals).toFixed(decimals);
+        const avgPrice = (spotCheck.avgFillPrice + perpCheck.avgFillPrice) / 2;
+        const matchedUsd = matchedBase * avgPrice;
+        if (!isJson()) {
+            console.log(chalk.cyan(`\n  Spot+Perp Arb: ${sym}`));
+            console.log(chalk.gray(`    SPOT  ${spotExch}: buy  ${matchedSize} (~$${(matchedBase * spotCheck.avgFillPrice).toFixed(2)})`));
+            console.log(chalk.gray(`    PERP  ${perpExch}: sell ${matchedSize} (~$${(matchedBase * perpCheck.avgFillPrice).toFixed(2)})`));
+            console.log(chalk.gray(`    Executing both legs simultaneously...\n`));
+        }
+        // 5. Execute both legs (or return dry-run result)
+        if (dryRun) {
+            const result = {
+                status: "filled", mode: "spot-perp", symbol: sym, dryRun: true,
+                size: matchedSize, notionalUsd: Math.round(matchedUsd * 100) / 100,
+                spot: { exchange: spotExch, side: "buy", size: matchedSize },
+                perp: { exchange: perpExch, side: "sell", size: matchedSize },
+            };
+            if (isJson())
+                return printJson(jsonOk(result));
+            console.log(chalk.cyan(`  [DRY-RUN] Would execute: spot buy ${matchedSize} on ${spotExch} + perp sell ${matchedSize} on ${perpExch}`));
+            return;
+        }
+        // Same exchange (e.g. Lighter) shares nonce → must execute sequentially
+        // Different exchanges → execute simultaneously for speed
+        const validatePerpFill = (r) => {
+            const res = r;
+            const statuses = res?.response?.data?.statuses;
+            if (statuses && statuses.length > 0) {
+                const st = statuses[0];
+                if (st.error)
+                    throw new Error(`Perp sell ${sym}: ${st.error}`);
+                const filled = st.filled;
+                if (filled && Number(filled.totalSz ?? 0) === 0) {
+                    throw new Error(`Perp sell ${sym}: 0 fill`);
+                }
+            }
+            return r;
+        };
+        let spotResult;
+        let perpResult;
+        if (spotExch === perpExch) {
+            // Sequential: spot first, then perp (avoids nonce collision on same exchange)
+            spotResult = await spotAdapter.spotMarketOrder(spotSymbol, "buy", matchedSize)
+                .then(r => ({ status: "fulfilled", value: r }))
+                .catch(e => ({ status: "rejected", reason: e }));
+            if (spotResult.status === "fulfilled") {
+                perpResult = await perpAdapter.marketOrder(sym, "sell", matchedSize)
+                    .then(validatePerpFill)
+                    .then(r => ({ status: "fulfilled", value: r }))
+                    .catch(e => ({ status: "rejected", reason: e }));
+            }
+            else {
+                perpResult = { status: "rejected", reason: new Error("Skipped: spot failed") };
+            }
+        }
+        else {
+            // Parallel: different exchanges, no nonce conflict
+            [spotResult, perpResult] = await Promise.allSettled([
+                spotAdapter.spotMarketOrder(spotSymbol, "buy", matchedSize),
+                perpAdapter.marketOrder(sym, "sell", matchedSize).then(validatePerpFill),
+            ]);
+        }
+        const spotOk = spotResult.status === "fulfilled";
+        const perpOk = perpResult.status === "fulfilled";
+        if (spotOk && perpOk) {
+            // ── Post-execution fill verification ──
+            // Wait for exchange state to settle, then verify both legs actually filled
+            let fillVerified = true;
+            let verifyWarnings = [];
+            try {
+                await new Promise(r => setTimeout(r, 800));
+                // Verify spot: check base token balance appeared
+                const spotBals = await spotAdapter.getSpotBalances();
+                const baseToken = sym; // e.g. "ETH"
+                const spotTokenBal = spotBals.find(b => b.token.toUpperCase().startsWith(baseToken));
+                const spotTokenAmt = Number(spotTokenBal?.total ?? 0);
+                const expectedSize = parseFloat(matchedSize);
+                if (spotTokenAmt < expectedSize * 0.5) {
+                    fillVerified = false;
+                    verifyWarnings.push(`Spot buy may not have filled: expected ~${matchedSize} ${baseToken}, found ${spotTokenAmt.toFixed(6)}`);
+                }
+                // Verify perp: check short position exists
+                const perpPositions = await perpAdapter.getPositions();
+                const perpPos = perpPositions.find(p => p.symbol.replace("-PERP", "").toUpperCase() === sym && p.side === "short");
+                if (!perpPos) {
+                    fillVerified = false;
+                    verifyWarnings.push(`Perp short position not found for ${sym} on ${perpExch} — fill may not have executed`);
+                }
+                else if (Number(perpPos.size) < expectedSize * 0.5) {
+                    verifyWarnings.push(`Perp short size ${perpPos.size} < expected ${matchedSize} — partial fill?`);
+                }
+            }
+            catch (verifyErr) {
+                // Verification check itself failed — log but don't block
+                verifyWarnings.push(`Fill verification check failed: ${verifyErr instanceof Error ? verifyErr.message : String(verifyErr)}`);
+            }
+            if (verifyWarnings.length > 0 && !isJson()) {
+                for (const w of verifyWarnings) {
+                    console.log(chalk.yellow(`  ⚠ ${w}`));
+                }
+            }
+            if (!fillVerified) {
+                // Fills couldn't be confirmed — log as unverified but still persist
+                // (rolling back based on uncertain data is worse than persisting)
+                logExecution({
+                    type: "arb_entry", exchange: `spot:${spotExch}+${perpExch}`,
+                    symbol: sym, side: "entry", size: matchedSize,
+                    status: "unverified", dryRun: false,
+                    meta: { mode: "spot-perp", spotExch, perpExch, matchedUsd, warnings: verifyWarnings },
+                });
+            }
+            else {
+                // Log execution — verified
+                logExecution({
+                    type: "arb_entry", exchange: `spot:${spotExch}+${perpExch}`,
+                    symbol: sym, side: "entry", size: matchedSize,
+                    status: "success", dryRun: false,
+                    meta: { mode: "spot-perp", spotExch, perpExch, matchedUsd },
+                });
+            }
+            // Persist position state
+            persistAddPosition({
+                id: `${sym}-spot-${Date.now()}`,
+                symbol: sym,
+                longExchange: spotExch,
+                shortExchange: perpExch,
+                longSize: parseFloat(matchedSize),
+                shortSize: parseFloat(matchedSize),
+                entryTime: new Date().toISOString(),
+                entrySpread: 0, // Will be updated on next scan
+                entryLongPrice: spotCheck.avgFillPrice,
+                entryShortPrice: perpCheck.avgFillPrice,
+                accumulatedFunding: 0,
+                lastCheckTime: new Date().toISOString(),
+                mode: "spot-perp",
+                spotExchange: spotExch,
+                spotSymbol: spotSymbol,
+            });
+            // Return leftover USDC from spot back to perp (non-unified HL accounts)
+            if (spotExch === "hyperliquid") {
+                try {
+                    const hlSpot = spotAdapter;
+                    const bals = await hlSpot.getSpotBalances();
+                    const usdcBal = bals.find(b => b.token.startsWith("USDC"));
+                    const leftover = Number(usdcBal?.available ?? 0);
+                    if (leftover > 1) {
+                        const xfer = await hlSpot.transferUsdcToPerp(Math.floor(leftover));
+                        if (xfer?.status !== "err") {
+                            if (!isJson())
+                                console.log(chalk.gray(`  Returned ~$${Math.floor(leftover)} USDC to perp account`));
+                        }
+                    }
+                }
+                catch { /* non-critical — unified accounts don't need transfer */ }
+            }
+            const result = {
+                status: fillVerified ? "filled" : "filled_unverified",
+                mode: "spot-perp", symbol: sym,
+                size: matchedSize, notionalUsd: Math.round(matchedUsd * 100) / 100,
+                spot: { exchange: spotExch, side: "buy", size: matchedSize },
+                perp: { exchange: perpExch, side: "sell", size: matchedSize },
+                ...(verifyWarnings.length > 0 && { warnings: verifyWarnings }),
+            };
+            if (isJson())
+                return printJson(jsonOk(result));
+            if (fillVerified) {
+                console.log(chalk.green(`  FILLED (verified): ${sym} ${matchedSize} units (~$${matchedUsd.toFixed(2)})`));
+            }
+            else {
+                console.log(chalk.yellow(`  FILLED (unverified): ${sym} ${matchedSize} units (~$${matchedUsd.toFixed(2)})`));
+            }
+            console.log(chalk.green(`    SPOT  ${spotExch} ✓ (bought ${matchedSize})`));
+            console.log(chalk.green(`    PERP  ${perpExch} ✓ (shorted ${matchedSize})\n`));
+        }
+        else if (spotOk !== perpOk) {
+            // One leg failed — rollback
+            const filledSide = spotOk ? "spot" : "perp";
+            const failedSide = spotOk ? "perp" : "spot";
+            const failedErr = spotOk
+                ? perpResult.reason
+                : spotResult.reason;
+            const failedErrMsg = failedErr instanceof Error ? failedErr.message : String(failedErr);
+            if (!isJson()) {
+                console.log(chalk.yellow(`  PARTIAL: ${filledSide} OK, ${failedSide} FAILED — rolling back...`));
+                console.log(chalk.red(`    Reason: ${failedErrMsg}`));
+            }
+            let rollbackOk = false;
+            for (let attempt = 1; attempt <= 2; attempt++) {
+                try {
+                    if (spotOk) {
+                        await spotAdapter.spotMarketOrder(spotSymbol, "sell", matchedSize);
+                    }
+                    else {
+                        await perpAdapter.marketOrder(sym, "buy", matchedSize);
+                    }
+                    rollbackOk = true;
+                    break;
+                }
+                catch { /* retry */ }
+            }
+            logExecution({
+                type: "arb_entry", exchange: `spot:${spotExch}+${perpExch}`,
+                symbol: sym, side: "entry", size: matchedSize,
+                status: "failed", dryRun: false,
+                error: `Partial: ${failedSide} failed (${failedErrMsg}). Rollback: ${rollbackOk ? "ok" : "FAILED"}`,
+            });
+            const result = {
+                status: "partial_fill", mode: "spot-perp", symbol: sym,
+                filledSide, failedSide,
+                failedError: failedErrMsg,
+                rollback: rollbackOk ? "success" : "FAILED — MANUAL CLOSE REQUIRED",
+            };
+            if (isJson())
+                return printJson(jsonOk(result));
+            console.log(rollbackOk
+                ? chalk.yellow(`  Rollback OK — no open exposure.\n`)
+                : chalk.red.bold(`  ROLLBACK FAILED — ${filledSide} leg still open. Close manually!\n`));
+        }
+        else {
+            // Both failed
+            const spotErr = spotResult.reason;
+            const perpErr = perpResult.reason;
+            const result = {
+                status: "both_failed", mode: "spot-perp", symbol: sym,
+                spotError: spotErr instanceof Error ? spotErr.message : String(spotErr),
+                perpError: perpErr instanceof Error ? perpErr.message : String(perpErr),
+            };
+            if (isJson())
+                return printJson(jsonOk(result));
+            console.log(chalk.red(`  Both legs failed:`));
+            console.log(chalk.red(`    SPOT:  ${result.spotError}`));
+            console.log(chalk.red(`    PERP:  ${result.perpError}\n`));
+        }
+    });
+    // ── arb spot-close ── (close spot+perp arb position)
+    arb
+        .command("spot-close")
+        .description("Close a spot+perp arb position: sell spot + buy back perp")
+        .argument("<symbol>", "Symbol (e.g. ETH)")
+        .option("--spot-exch <exchange>", "Spot exchange (hl or lt)")
+        .option("--perp-exch <exchange>", "Perp exchange (hl, lt, pac)")
+        .action(async (symbol, opts) => {
+        const sym = symbol.toUpperCase();
+        // Try to find the position from state
+        const state = loadArbState();
+        const pos = state?.positions.find(p => p.symbol.toUpperCase() === sym && p.mode === "spot-perp");
+        const aliasMap = { hl: "hyperliquid", pac: "pacifica", lt: "lighter" };
+        const spotExch = aliasMap[opts.spotExch?.toLowerCase() ?? ""] || opts.spotExch?.toLowerCase() || pos?.spotExchange || pos?.longExchange;
+        const perpExch = aliasMap[opts.perpExch?.toLowerCase() ?? ""] || opts.perpExch?.toLowerCase() || pos?.shortExchange;
+        if (!spotExch || !perpExch) {
+            const msg = "Cannot determine exchanges. Specify --spot-exch and --perp-exch, or ensure the position is tracked in state.";
+            if (isJson())
+                return printJson(jsonOk({ error: msg }));
+            console.log(chalk.red(`  ${msg}`));
+            return;
+        }
+        // Load adapters
+        const { HyperliquidSpotAdapter } = await import("../exchanges/hyperliquid-spot.js");
+        const { LighterSpotAdapter } = await import("../exchanges/lighter-spot.js");
+        let spotAdapter;
+        if (spotExch === "hyperliquid") {
+            const hlAdapter = await getAdapterForExchange("hyperliquid");
+            const hlSpot = new HyperliquidSpotAdapter(hlAdapter);
+            await hlSpot.init();
+            spotAdapter = hlSpot;
+        }
+        else {
+            const ltAdapter = await getAdapterForExchange("lighter");
+            const ltSpot = new LighterSpotAdapter(ltAdapter);
+            await ltSpot.init();
+            spotAdapter = ltSpot;
+        }
+        const perpAdapter = await getAdapterForExchange(perpExch);
+        const spotSymbol = `${sym}/USDC`;
+        // Find how much to close
+        const perpPositions = await perpAdapter.getPositions();
+        const perpPos = perpPositions.find(p => p.symbol.replace("-PERP", "").toUpperCase() === sym && p.side === "short");
+        if (!perpPos) {
+            const msg = `No short perp position found for ${sym} on ${perpExch}`;
+            if (isJson())
+                return printJson(jsonOk({ error: msg }));
+            console.log(chalk.red(`  ${msg}`));
+            return;
+        }
+        const closeSize = perpPos.size;
+        if (!isJson()) {
+            console.log(chalk.cyan(`\n  Closing Spot+Perp Arb: ${sym}`));
+            console.log(chalk.gray(`    SPOT  ${spotExch}: sell ${closeSize}`));
+            console.log(chalk.gray(`    PERP  ${perpExch}: buy  ${closeSize} (close short)`));
+            console.log(chalk.gray(`    Executing...\n`));
+        }
+        // Same exchange → sequential (nonce collision), different → parallel
+        let spotResult;
+        let perpResult;
+        if (spotExch === perpExch) {
+            // Sequential: sell spot first, then close perp
+            spotResult = await spotAdapter.spotMarketOrder(spotSymbol, "sell", closeSize)
+                .then(r => ({ status: "fulfilled", value: r }))
+                .catch(e => ({ status: "rejected", reason: e }));
+            perpResult = await perpAdapter.marketOrder(sym, "buy", closeSize)
+                .then(r => ({ status: "fulfilled", value: r }))
+                .catch(e => ({ status: "rejected", reason: e }));
+        }
+        else {
+            [spotResult, perpResult] = await Promise.allSettled([
+                spotAdapter.spotMarketOrder(spotSymbol, "sell", closeSize),
+                perpAdapter.marketOrder(sym, "buy", closeSize),
+            ]);
+        }
+        const spotOk = spotResult.status === "fulfilled";
+        const perpOk = perpResult.status === "fulfilled";
+        if (spotOk && perpOk) {
+            // ── Post-close fill verification ──
+            let closeVerified = true;
+            let closeWarnings = [];
+            try {
+                await new Promise(r => setTimeout(r, 800));
+                // Verify spot token was sold (balance should be near zero or gone)
+                const spotBals = await spotAdapter.getSpotBalances();
+                const baseToken = sym;
+                const spotTokenBal = spotBals.find(b => b.token.toUpperCase().startsWith(baseToken));
+                const remainingSpotAmt = Number(spotTokenBal?.total ?? 0);
+                const closedSize = parseFloat(closeSize);
+                if (remainingSpotAmt > closedSize * 0.5) {
+                    closeVerified = false;
+                    closeWarnings.push(`Spot sell may not have filled: still have ${remainingSpotAmt.toFixed(6)} ${baseToken} (expected ~0)`);
+                }
+                // Verify perp short was closed (position should be gone or reduced)
+                const perpPositionsAfter = await perpAdapter.getPositions();
+                const remainingPerpPos = perpPositionsAfter.find(p => p.symbol.replace("-PERP", "").toUpperCase() === sym && p.side === "short");
+                if (remainingPerpPos && Number(remainingPerpPos.size) > closedSize * 0.5) {
+                    closeVerified = false;
+                    closeWarnings.push(`Perp short still open: ${remainingPerpPos.size} ${sym} on ${perpExch} (expected closed)`);
+                }
+            }
+            catch (verifyErr) {
+                closeWarnings.push(`Close verification failed: ${verifyErr instanceof Error ? verifyErr.message : String(verifyErr)}`);
+            }
+            if (closeWarnings.length > 0 && !isJson()) {
+                for (const w of closeWarnings) {
+                    console.log(chalk.yellow(`  ⚠ ${w}`));
+                }
+            }
+            // Remove from state
+            persistRemovePosition(sym);
+            logExecution({
+                type: "arb_close", exchange: `spot:${spotExch}+${perpExch}`,
+                symbol: sym, side: "exit", size: closeSize,
+                status: closeVerified ? "success" : "unverified", dryRun: false,
+                meta: { mode: "spot-perp", ...(closeWarnings.length > 0 && { warnings: closeWarnings }) },
+            });
+            // Return spot USDC proceeds back to perp account
+            if (spotExch === "lighter") {
+                try {
+                    const ltSpot = spotAdapter;
+                    const bals = await ltSpot.getSpotBalances();
+                    const usdcBal = bals.find(b => b.token === "USDC");
+                    const leftover = Number(usdcBal?.available ?? 0);
+                    if (leftover > 0.01) {
+                        await ltSpot.transferUsdcToPerp(leftover);
+                        if (!isJson())
+                            console.log(chalk.gray(`  Returned ~$${leftover.toFixed(2)} USDC spot→perp on Lighter`));
+                    }
+                }
+                catch { /* non-critical */ }
+            }
+            else if (spotExch === "hyperliquid") {
+                try {
+                    const hlSpot = spotAdapter;
+                    const bals = await hlSpot.getSpotBalances();
+                    const usdcBal = bals.find(b => b.token.startsWith("USDC"));
+                    const leftover = Number(usdcBal?.available ?? 0);
+                    if (leftover > 1) {
+                        await hlSpot.transferUsdcToPerp(Math.floor(leftover));
+                    }
+                }
+                catch { /* non-critical */ }
+            }
+            const closeResult = {
+                status: closeVerified ? "closed" : "closed_unverified",
+                mode: "spot-perp", symbol: sym, size: closeSize,
+                ...(closeWarnings.length > 0 && { warnings: closeWarnings }),
+            };
+            if (isJson())
+                return printJson(jsonOk(closeResult));
+            if (closeVerified) {
+                console.log(chalk.green(`  CLOSED (verified): ${sym} ${closeSize} units`));
+            }
+            else {
+                console.log(chalk.yellow(`  CLOSED (unverified): ${sym} ${closeSize} units — check positions manually`));
+            }
+            console.log(chalk.green(`    SPOT  ${spotExch}: sold ✓`));
+            console.log(chalk.green(`    PERP  ${perpExch}: bought (closed short) ✓\n`));
+        }
+        else {
+            const errors = [];
+            if (!spotOk)
+                errors.push(`Spot sell failed: ${spotResult.reason}`);
+            if (!perpOk)
+                errors.push(`Perp buy failed: ${perpResult.reason}`);
+            const result = { status: "partial_close", symbol: sym, spotOk, perpOk, errors };
+            if (isJson())
+                return printJson(jsonOk(result));
+            console.log(chalk.red(`  Close partially failed:`));
+            for (const e of errors)
+                console.log(chalk.red(`    ${e}`));
+            console.log(chalk.yellow(`  Manual intervention may be needed.\n`));
+        }
+    });
     // ── arb pnl ── (check arb position PnL)
     arb
         .command("pnl")