perp-cli 0.7.16 → 0.7.19

package/dist/bot/config.d.ts

@@ -37,6 +37,7 @@ export interface FundingArbStrategyParams {
     type: "funding-arb";
     min_spread: number;
     close_spread: number;
+    spot_perp_min_spread?: number;
     size_usd: number;
     max_positions: number;
     exchanges: string[];

package/dist/bot/config.js

@@ -83,6 +83,7 @@ export function parseStrategy(type, raw) {
                 type: "funding-arb",
                 min_spread: Number(raw.min_spread ?? 20),
                 close_spread: Number(raw.close_spread ?? 5),
+                spot_perp_min_spread: raw.spot_perp_min_spread !== undefined ? Number(raw.spot_perp_min_spread) : undefined,
                 size_usd: Number(raw.size_usd ?? raw.size ?? 50),
                 max_positions: Number(raw.max_positions ?? 3),
                 exchanges: Array.isArray(raw.exchanges)

package/dist/bot/strategies/funding-arb-strategy.d.ts

@@ -28,5 +28,28 @@ export declare class FundingArbStrategy implements Strategy {
     init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
     onTick(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
     onStop(ctx: StrategyContext): Promise<StrategyAction[]>;
+    /** Close a spot-perp position: sell spot, transfer USDC back, close perp short */
+    private closeSpotPerp;
+    /** Open a spot-perp position: transfer USDC to spot, buy spot, short perp */
+    private openSpotPerp;
+    /** Transfer USDC from perp to spot account (exchange-specific) */
+    private transferUsdcToSpot;
+    /** Transfer USDC from spot to perp account (exchange-specific) */
+    private transferUsdcToPerp;
+    /**
+     * Get spot adapter for a given exchange name + perp adapter instance.
+     * Returns null if the exchange doesn't support spot or instantiation fails.
+     */
+    private getSpotAdapter;
+    /**
+     * Resolve the perp symbol for a given base symbol on an exchange.
+     * HL getPositions() returns symbols like "PURR" or "PURR-PERP" — we normalize here.
+     */
+    private getPerpSymbol;
+    /**
+     * Get a price estimate for a symbol from the perp adapter.
+     * Tries the base symbol first, then with -PERP suffix.
+     */
+    private getPriceEstimate;
     private fetchRates;
 }

package/dist/bot/strategies/funding-arb-strategy.js

@@ -1,7 +1,7 @@
 import { registerStrategy } from "../strategy-registry.js";
-import { checkArbLiquidity } from "../../liquidity.js";
-import { computeMatchedSize, reconcileArbFills } from "../../arb-sizing.js";
-import { computeAnnualSpread } from "../../funding.js";
+import { checkArbLiquidity, checkSpotPerpLiquidity } from "../../liquidity.js";
+import { computeMatchedSize, computeSpotPerpMatchedSize, reconcileArbFills } from "../../arb-sizing.js";
+import { computeSignedAnnualSpread, annualizeRate } from "../../funding.js";
 export class FundingArbStrategy {
     name = "funding-arb";
     describe() {
@@ -10,6 +10,7 @@ export class FundingArbStrategy {
             params: [
                 { name: "min_spread", type: "number", required: true, description: "Minimum annualized spread %" },
                 { name: "close_spread", type: "number", required: false, default: 5, description: "Spread to close at" },
+                { name: "spot_perp_min_spread", type: "number", required: false, description: "Min spread for spot-perp (default: min_spread)" },
                 { name: "size_usd", type: "number", required: true, description: "Position size in USD" },
                 { name: "max_positions", type: "number", required: false, default: 3, description: "Max concurrent positions" },
                 { name: "exchanges", type: "string", required: true, description: "Comma-separated exchange names" },
@@ -30,6 +31,9 @@ export class FundingArbStrategy {
         ctx.state.set("fundingLastCheck", Date.now());
         ctx.state.set("fundingHistory", []);
         ctx.log(`  [ARB] Funding arb ready | spread >= ${params.min_spread}% | close < ${params.close_spread}% | size $${params.size_usd}`);
+        if (params.spot_perp_min_spread !== undefined) {
+            ctx.log(`  [ARB] Spot-perp min spread: ${params.spot_perp_min_spread}%`);
+        }
         ctx.log(`  [ARB] Exchanges: ${params.exchanges.join(", ")}`);
         // ── Recover existing positions from exchanges ──
         try {
@@ -76,7 +80,7 @@ export class FundingArbStrategy {
                             const longEx = pA.side === "long" ? exA : exB;
                             const shortEx = pA.side === "short" ? exA : exB;
                             const size = pA.side === "long" ? pA.size : pB.size;
-                            recovered.push({ symbol: pA.symbol, longExchange: longEx, shortExchange: shortEx, entrySpread: 0, size });
+                            recovered.push({ symbol: pA.symbol, longExchange: longEx, shortExchange: shortEx, entrySpread: 0, size, mode: "perp-perp" });
                             used.add(keyA);
                             used.add(keyB);
                             break;
@@ -86,10 +90,68 @@ export class FundingArbStrategy {
                     }
                 }
             }
+            // ── Same-exchange spot-perp hedges (e.g. PURR spot + PURR-PERP short on HL) ──
+            for (const [name, a] of adapters) {
+                try {
+                    let spotBalances = [];
+                    if (name === "hyperliquid") {
+                        const { HyperliquidSpotAdapter } = await import("../../exchanges/hyperliquid-spot.js");
+                        const { HyperliquidAdapter } = await import("../../exchanges/hyperliquid.js");
+                        if (a instanceof HyperliquidAdapter) {
+                            const hlSpot = new HyperliquidSpotAdapter(a);
+                            await hlSpot.init();
+                            spotBalances = await hlSpot.getSpotBalances();
+                        }
+                    }
+                    else if (name === "lighter") {
+                        const { LighterSpotAdapter } = await import("../../exchanges/lighter-spot.js");
+                        const { LighterAdapter } = await import("../../exchanges/lighter.js");
+                        if (a instanceof LighterAdapter) {
+                            const ltSpot = new LighterSpotAdapter(a);
+                            await ltSpot.init();
+                            spotBalances = await ltSpot.getSpotBalances();
+                        }
+                    }
+                    const nonUsdc = spotBalances.filter(b => Number(b.total) > 0 && !b.token.toUpperCase().startsWith("USDC"));
+                    if (nonUsdc.length === 0)
+                        continue;
+                    const perpPositions = positionsByExchange.get(name) ?? [];
+                    for (const perp of perpPositions) {
+                        const perpKey = `${name}:${perp.symbol}`;
+                        if (used.has(perpKey))
+                            continue;
+                        const base = perp.symbol.replace(/-PERP$/, "").toUpperCase();
+                        const spotBal = nonUsdc.find(b => b.token.toUpperCase() === base);
+                        if (spotBal && perp.side === "short") {
+                            recovered.push({ symbol: base, longExchange: `${name}-spot`, shortExchange: name, entrySpread: 0, size: perp.size, mode: "spot-perp" });
+                            used.add(perpKey);
+                            ctx.log(`  [ARB] Detected spot-perp hedge: ${base} ${name}-spot↔${name}`);
+                        }
+                    }
+                }
+                catch { /* adapter doesn't support spot */ }
+            }
             if (recovered.length > 0) {
                 ctx.state.set("arbOpenPositions", recovered);
                 ctx.state.set("arbPositions", recovered.length);
-                ctx.log(`  [ARB] Recovered ${recovered.length} existing position(s): ${recovered.map(p => `${p.symbol} ${p.longExchange}↔${p.shortExchange}`).join(", ")}`);
+                ctx.log(`  [ARB] Recovered ${recovered.length} position(s): ${recovered.map(p => `${p.symbol} ${p.longExchange}↔${p.shortExchange}`).join(", ")}`);
+            }
+            // ── Load historical funding income ──
+            let historicalFunding = 0;
+            for (const [name, a] of adapters) {
+                try {
+                    const payments = await a.getFundingPayments(200);
+                    const sum = payments.reduce((s, p) => s + parseFloat(p.payment), 0);
+                    if (Math.abs(sum) > 0.001) {
+                        historicalFunding += sum;
+                        ctx.log(`  [FUND] ${name}: $${sum.toFixed(4)} historical funding`);
+                    }
+                }
+                catch { /* not all adapters support this */ }
+            }
+            if (Math.abs(historicalFunding) > 0.001) {
+                ctx.state.set("fundingIncome", historicalFunding);
+                ctx.log(`  [FUND] Total historical funding: $${historicalFunding.toFixed(4)}`);
             }
         }
         catch (err) {
@@ -131,8 +193,8 @@ export class FundingArbStrategy {
                     try {
                         const payments = await a.getFundingPayments(50);
                         const startTime = ctx.state.get("fundingLastCheck");
-                        const recent = payments.filter(p => p.timestamp > startTime - 5 * 60 * 1000);
-                        const sum = recent.reduce((s, p) => s + parseFloat(p.amount), 0);
+                        const recent = payments.filter(p => p.time > startTime - 5 * 60 * 1000);
+                        const sum = recent.reduce((s, p) => s + parseFloat(p.payment), 0);
                         totalFunding += sum;
                         if (Math.abs(sum) > 0.001) {
                             ctx.log(`  [FUND] ${name}: $${sum.toFixed(4)} funding received`);
@@ -148,39 +210,72 @@ export class FundingArbStrategy {
         }
         // ── Update strategy state for TUI display ──
         const arbPosForDisplay = openPositions.map(p => {
-            const longRate = ratesByExchange.get(p.longExchange)?.get(p.symbol)?.rate;
-            const shortRate = ratesByExchange.get(p.shortExchange)?.get(p.symbol)?.rate;
-            const spread = (longRate !== undefined && shortRate !== undefined)
-                ? computeAnnualSpread(shortRate, p.shortExchange, longRate, p.longExchange)
-                : 0;
-            return `${p.symbol} ${p.longExchange}↔${p.shortExchange} ${spread.toFixed(1)}%`;
+            let signedSpread;
+            if (p.mode === "spot-perp") {
+                // For spot-perp: long side is spot (rate=0), short side is perp
+                const perpExchange = p.shortExchange;
+                const perpSymbol = this.getPerpSymbol(p.symbol, perpExchange);
+                const shortRate = ratesByExchange.get(perpExchange)?.get(perpSymbol)?.rate
+                    ?? ratesByExchange.get(perpExchange)?.get(p.symbol)?.rate;
+                signedSpread = shortRate !== undefined ? annualizeRate(shortRate, perpExchange) : 0;
+            }
+            else {
+                const longRate = ratesByExchange.get(p.longExchange)?.get(p.symbol)?.rate;
+                const shortRate = ratesByExchange.get(p.shortExchange)?.get(p.symbol)?.rate;
+                signedSpread = (longRate !== undefined && shortRate !== undefined)
+                    ? computeSignedAnnualSpread(shortRate, p.shortExchange, longRate, p.longExchange)
+                    : 0;
+            }
+            const sign = signedSpread >= 0 ? "+" : "";
+            return `${p.symbol} ${p.longExchange}↔${p.shortExchange} ${sign}${signedSpread.toFixed(1)}%`;
         });
         ctx.state.set("arbPositionDetails", arbPosForDisplay);
         ctx.state.set("fundingTotal", `$${ctx.state.get("fundingIncome").toFixed(4)}`);
-        // ── Check existing positions for close_spread ──
+        // ── Check existing positions for close conditions ──
         const toClose = [];
         for (const pos of openPositions) {
-            const longRate = ratesByExchange.get(pos.longExchange)?.get(pos.symbol)?.rate;
-            const shortRate = ratesByExchange.get(pos.shortExchange)?.get(pos.symbol)?.rate;
-            if (longRate === undefined || shortRate === undefined)
-                continue;
-            const currentSpread = computeAnnualSpread(shortRate, pos.shortExchange, longRate, pos.longExchange);
-            if (currentSpread < params.close_spread) {
-                ctx.log(`  [ARB] Closing ${pos.symbol}: spread ${currentSpread.toFixed(1)}% < close_spread ${params.close_spread}% (entry: ${pos.entrySpread.toFixed(1)}%)`);
-                const longAdapter = adapters.get(pos.longExchange);
-                const shortAdapter = adapters.get(pos.shortExchange);
-                if (longAdapter && shortAdapter) {
-                    try {
-                        await Promise.all([
-                            longAdapter.marketOrder(pos.symbol, "sell", pos.size),
-                            shortAdapter.marketOrder(pos.symbol, "buy", pos.size),
-                        ]);
-                        toClose.push(pos);
-                        ctx.log(`  [ARB] Closed ${pos.symbol} position`);
-                    }
-                    catch (err) {
-                        const msg = err instanceof Error ? err.message : String(err);
-                        ctx.log(`  [ARB] Close failed for ${pos.symbol}: ${msg}`);
+            let signedSpread;
+            if (pos.mode === "spot-perp") {
+                const perpExchange = pos.shortExchange;
+                const perpSymbol = this.getPerpSymbol(pos.symbol, perpExchange);
+                const shortRate = ratesByExchange.get(perpExchange)?.get(perpSymbol)?.rate
+                    ?? ratesByExchange.get(perpExchange)?.get(pos.symbol)?.rate;
+                if (shortRate === undefined)
+                    continue;
+                signedSpread = annualizeRate(shortRate, perpExchange);
+            }
+            else {
+                const longRate = ratesByExchange.get(pos.longExchange)?.get(pos.symbol)?.rate;
+                const shortRate = ratesByExchange.get(pos.shortExchange)?.get(pos.symbol)?.rate;
+                if (longRate === undefined || shortRate === undefined)
+                    continue;
+                signedSpread = computeSignedAnnualSpread(shortRate, pos.shortExchange, longRate, pos.longExchange);
+            }
+            // Close if funding flipped (losing money) or spread below close threshold
+            const shouldClose = signedSpread < 0 || signedSpread < params.close_spread;
+            if (shouldClose) {
+                const sign = signedSpread >= 0 ? "+" : "";
+                ctx.log(`  [ARB] Closing ${pos.symbol}: signed spread ${sign}${signedSpread.toFixed(1)}% (close_spread=${params.close_spread}%, entry=${pos.entrySpread.toFixed(1)}%)`);
+                if (pos.mode === "spot-perp") {
+                    await this.closeSpotPerp(pos, adapters, ctx);
+                    toClose.push(pos);
+                }
+                else {
+                    const longAdapter = adapters.get(pos.longExchange);
+                    const shortAdapter = adapters.get(pos.shortExchange);
+                    if (longAdapter && shortAdapter) {
+                        try {
+                            await Promise.all([
+                                longAdapter.marketOrder(pos.symbol, "sell", pos.size),
+                                shortAdapter.marketOrder(pos.symbol, "buy", pos.size),
+                            ]);
+                            toClose.push(pos);
+                            ctx.log(`  [ARB] Closed ${pos.symbol} position`);
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            ctx.log(`  [ARB] Close failed for ${pos.symbol}: ${msg}`);
+                        }
                     }
                 }
             }
@@ -200,6 +295,7 @@ export class FundingArbStrategy {
             for (const sym of map.keys())
                 allSymbols.add(sym);
         }
+        // Perp-perp opportunities
         for (const sym of allSymbols) {
             let minRate = Infinity, maxRate = -Infinity;
             let minExchange = "", maxExchange = "";
@@ -217,7 +313,7 @@ export class FundingArbStrategy {
                 }
             }
             if (minExchange && maxExchange && minExchange !== maxExchange) {
-                const spread = computeAnnualSpread(maxRate, maxExchange, minRate, minExchange);
+                const spread = computeSignedAnnualSpread(maxRate, maxExchange, minRate, minExchange);
                 if (spread >= params.min_spread) {
                     opportunities.push({
                         symbol: sym,
@@ -226,116 +322,160 @@ export class FundingArbStrategy {
                         longRate: minRate,
                         shortRate: maxRate,
                         spread,
+                        mode: "perp-perp",
                     });
                 }
             }
         }
+        // Spot-perp opportunities: for each exchange with positive perp rate, check if spot is available
+        const spotPerpMinSpread = params.spot_perp_min_spread ?? params.min_spread;
+        for (const [name, a] of adapters) {
+            try {
+                const spotAdapter = await this.getSpotAdapter(name, a);
+                if (!spotAdapter)
+                    continue;
+                const spotMarkets = await spotAdapter.getSpotMarkets();
+                const spotSymbols = new Set(spotMarkets.map(m => m.baseToken.toUpperCase()));
+                const perpRates = ratesByExchange.get(name);
+                if (!perpRates)
+                    continue;
+                for (const [sym, { rate }] of perpRates) {
+                    // Only consider positive funding (shorts receive, longs pay)
+                    if (rate <= 0)
+                        continue;
+                    const base = sym.replace(/-PERP$/, "").toUpperCase();
+                    if (!spotSymbols.has(base))
+                        continue;
+                    const annualSpread = annualizeRate(rate, name);
+                    if (annualSpread >= spotPerpMinSpread) {
+                        opportunities.push({
+                            symbol: base,
+                            longExchange: `${name}-spot`,
+                            shortExchange: name,
+                            longRate: 0,
+                            shortRate: rate,
+                            spread: annualSpread,
+                            mode: "spot-perp",
+                        });
+                    }
+                }
+            }
+            catch { /* exchange doesn't support spot */ }
+        }
         opportunities.sort((a, b) => b.spread - a.spread);
         if (opportunities.length > 0) {
             const top = opportunities.slice(0, 3);
             for (const opp of top) {
-                ctx.log(`  [ARB] ${opp.symbol}: ${opp.spread.toFixed(1)}% spread (long ${opp.longExchange} ${(opp.longRate * 100).toFixed(4)}% / short ${opp.shortExchange} ${(opp.shortRate * 100).toFixed(4)}%)`);
+                if (opp.mode === "spot-perp") {
+                    ctx.log(`  [ARB] ${opp.symbol}: ${opp.spread.toFixed(1)}% spread [spot-perp] (short ${opp.shortExchange} ${(opp.shortRate * 100).toFixed(4)}%)`);
+                }
+                else {
+                    ctx.log(`  [ARB] ${opp.symbol}: ${opp.spread.toFixed(1)}% spread (long ${opp.longExchange} ${(opp.longRate * 100).toFixed(4)}% / short ${opp.shortExchange} ${(opp.shortRate * 100).toFixed(4)}%)`);
+                }
             }
             // Auto-execute if under position limit
             if (arbPositions < params.max_positions && opportunities.length > 0) {
                 const best = opportunities[0];
-                const longAdapter = adapters.get(best.longExchange);
-                const shortAdapter = adapters.get(best.shortExchange);
-                if (longAdapter && shortAdapter) {
-                    const price = ratesByExchange.get(best.longExchange)?.get(best.symbol)?.price ?? 0;
-                    if (price > 0) {
-                        // Balance check — reduce size to fit available balance
-                        let targetSizeUsd = params.size_usd;
-                        try {
-                            const [longBal, shortBal] = await Promise.all([
-                                longAdapter.getBalance(),
-                                shortAdapter.getBalance(),
-                            ]);
-                            const longAvail = parseFloat(longBal.available);
-                            const shortAvail = parseFloat(shortBal.available);
-                            const minAvail = Math.min(longAvail, shortAvail);
-                            // Use at most 80% of available balance per leg
-                            const maxAffordable = minAvail * 0.8;
-                            if (maxAffordable < 10) {
-                                ctx.log(`  [ARB] Skip ${best.symbol}: insufficient balance ($${minAvail.toFixed(2)} available, need $10+ per leg)`);
-                                return [];
-                            }
-                            if (targetSizeUsd > maxAffordable) {
-                                ctx.log(`  [ARB] Size reduced $${targetSizeUsd} → $${maxAffordable.toFixed(0)} (limited by balance $${minAvail.toFixed(2)})`);
-                                targetSizeUsd = Math.floor(maxAffordable);
-                            }
-                        }
-                        catch { /* non-critical, proceed with original size */ }
-                        // Liquidity check
-                        const liq = await checkArbLiquidity(longAdapter, shortAdapter, best.symbol, targetSizeUsd, 0.5, (msg) => ctx.log(`  ${msg}`));
-                        if (!liq.viable)
-                            return [];
-                        // Compute matched size
-                        let matched = computeMatchedSize(liq.adjustedSizeUsd, price, best.longExchange, best.shortExchange);
-                        if (!matched) {
-                            ctx.log(`  [ARB] Skip ${best.symbol}: can't compute matched size (min notional or precision issue)`);
-                            return [];
-                        }
-                        try {
-                            ctx.log(`  [ARB] Opening: ${matched.size} ${best.symbol} on both legs ($${matched.notional.toFixed(0)}/leg, slippage ~${liq.longSlippage.toFixed(2)}%/${liq.shortSlippage.toFixed(2)}%)`);
+                if (best.mode === "spot-perp") {
+                    await this.openSpotPerp(best, adapters, ctx);
+                }
+                else {
+                    const longAdapter = adapters.get(best.longExchange);
+                    const shortAdapter = adapters.get(best.shortExchange);
+                    if (longAdapter && shortAdapter) {
+                        const price = ratesByExchange.get(best.longExchange)?.get(best.symbol)?.price ?? 0;
+                        if (price > 0) {
+                            // Balance check
+                            let targetSizeUsd = params.size_usd;
                             try {
-                                await Promise.all([
-                                    longAdapter.marketOrder(best.symbol, "buy", matched.size),
-                                    shortAdapter.marketOrder(best.symbol, "sell", matched.size),
+                                const [longBal, shortBal] = await Promise.all([
+                                    longAdapter.getBalance(),
+                                    shortAdapter.getBalance(),
                                 ]);
+                                const longAvail = parseFloat(longBal.available);
+                                const shortAvail = parseFloat(shortBal.available);
+                                const minAvail = Math.min(longAvail, shortAvail);
+                                const maxAffordable = minAvail * 0.8;
+                                if (maxAffordable < 10) {
+                                    ctx.log(`  [ARB] Skip ${best.symbol}: insufficient balance ($${minAvail.toFixed(2)} available, need $10+ per leg)`);
+                                    return [];
+                                }
+                                if (targetSizeUsd > maxAffordable) {
+                                    ctx.log(`  [ARB] Size reduced $${targetSizeUsd} → $${maxAffordable.toFixed(0)} (limited by balance $${minAvail.toFixed(2)})`);
+                                    targetSizeUsd = Math.floor(maxAffordable);
+                                }
                             }
-                            catch (orderErr) {
-                                // Parse lot size from error and retry with corrected size
-                                const errMsg = orderErr instanceof Error ? orderErr.message : String(orderErr);
-                                const lotMatch = errMsg.match(/not a multiple of lot size (\d+(?:\.\d+)?)/);
-                                if (lotMatch) {
-                                    const lotSize = parseFloat(lotMatch[1]);
-                                    ctx.log(`  [ARB] Lot size ${lotSize} detected, recalculating...`);
-                                    matched = computeMatchedSize(liq.adjustedSizeUsd, price, best.longExchange, best.shortExchange, { lotSize });
-                                    if (!matched) {
-                                        ctx.log(`  [ARB] Skip ${best.symbol}: can't meet lot size ${lotSize}`);
-                                        return [];
-                                    }
-                                    ctx.log(`  [ARB] Retry: ${matched.size} ${best.symbol} ($${matched.notional.toFixed(0)}/leg)`);
+                            catch { /* non-critical, proceed with original size */ }
+                            // Liquidity check
+                            const liq = await checkArbLiquidity(longAdapter, shortAdapter, best.symbol, targetSizeUsd, 0.5, (msg) => ctx.log(`  ${msg}`));
+                            if (!liq.viable)
+                                return [];
+                            // Compute matched size
+                            let matched = computeMatchedSize(liq.adjustedSizeUsd, price, best.longExchange, best.shortExchange);
+                            if (!matched) {
+                                ctx.log(`  [ARB] Skip ${best.symbol}: can't compute matched size (min notional or precision issue)`);
+                                return [];
+                            }
+                            try {
+                                ctx.log(`  [ARB] Opening: ${matched.size} ${best.symbol} on both legs ($${matched.notional.toFixed(0)}/leg, slippage ~${liq.longSlippage.toFixed(2)}%/${liq.shortSlippage.toFixed(2)}%)`);
+                                try {
                                     await Promise.all([
                                         longAdapter.marketOrder(best.symbol, "buy", matched.size),
                                         shortAdapter.marketOrder(best.symbol, "sell", matched.size),
                                     ]);
                                 }
-                                else {
-                                    throw orderErr;
+                                catch (orderErr) {
+                                    // Parse lot size from error and retry with corrected size
+                                    const errMsg = orderErr instanceof Error ? orderErr.message : String(orderErr);
+                                    const lotMatch = errMsg.match(/not a multiple of lot size (\d+(?:\.\d+)?)/);
+                                    if (lotMatch) {
+                                        const lotSize = parseFloat(lotMatch[1]);
+                                        ctx.log(`  [ARB] Lot size ${lotSize} detected, recalculating...`);
+                                        matched = computeMatchedSize(liq.adjustedSizeUsd, price, best.longExchange, best.shortExchange, { lotSize });
+                                        if (!matched) {
+                                            ctx.log(`  [ARB] Skip ${best.symbol}: can't meet lot size ${lotSize}`);
+                                            return [];
+                                        }
+                                        ctx.log(`  [ARB] Retry: ${matched.size} ${best.symbol} ($${matched.notional.toFixed(0)}/leg)`);
+                                        await Promise.all([
+                                            longAdapter.marketOrder(best.symbol, "buy", matched.size),
+                                            shortAdapter.marketOrder(best.symbol, "sell", matched.size),
+                                        ]);
+                                    }
+                                    else {
+                                        throw orderErr;
+                                    }
                                 }
-                            }
-                            // Verify fills match, correct if needed
-                            try {
-                                const recon = await reconcileArbFills(longAdapter, shortAdapter, best.symbol, (msg) => ctx.log(`  ${msg}`));
-                                if (!recon.matched) {
-                                    ctx.log(`  [ARB] WARNING: fills not matched after correction attempt`);
+                                // Verify fills match, correct if needed
+                                try {
+                                    const recon = await reconcileArbFills(longAdapter, shortAdapter, best.symbol, (msg) => ctx.log(`  ${msg}`));
+                                    if (!recon.matched) {
+                                        ctx.log(`  [ARB] WARNING: fills not matched after correction attempt`);
+                                    }
                                 }
+                                catch (reconErr) {
+                                    const reconMsg = reconErr instanceof Error ? reconErr.message : String(reconErr);
+                                    ctx.log(`  [ARB] WARNING: Fill reconciliation failed: ${reconMsg}`);
+                                }
+                                // Track position
+                                const currentPositions = ctx.state.get("arbOpenPositions");
+                                currentPositions.push({
+                                    symbol: best.symbol,
+                                    longExchange: best.longExchange,
+                                    shortExchange: best.shortExchange,
+                                    entrySpread: best.spread,
+                                    size: matched.size,
+                                    mode: "perp-perp",
+                                });
+                                ctx.state.set("arbOpenPositions", currentPositions);
+                                ctx.state.set("arbPositions", currentPositions.length);
+                                ctx.log(`  [ARB] Position opened! (${currentPositions.length}/${params.max_positions})`);
+                                return [{ type: "noop" }];
                             }
-                            catch (reconErr) {
-                                const reconMsg = reconErr instanceof Error ? reconErr.message : String(reconErr);
-                                ctx.log(`  [ARB] WARNING: Fill reconciliation failed: ${reconMsg}`);
+                            catch (err) {
+                                const msg = err instanceof Error ? err.message : String(err);
+                                ctx.log(`  [ARB] Execution failed: ${msg}`);
                             }
-                            // Track position in array
-                            const currentPositions = ctx.state.get("arbOpenPositions");
-                            currentPositions.push({
-                                symbol: best.symbol,
-                                longExchange: best.longExchange,
-                                shortExchange: best.shortExchange,
-                                entrySpread: best.spread,
-                                size: matched.size,
-                            });
-                            ctx.state.set("arbOpenPositions", currentPositions);
-                            ctx.state.set("arbPositions", currentPositions.length);
-                            ctx.log(`  [ARB] Position opened! (${currentPositions.length}/${params.max_positions})`);
-                            // Return noop -- we already executed directly via adapters
-                            // (arb requires multi-adapter coordination, can't be expressed as single-adapter actions)
-                            return [{ type: "noop" }];
-                        }
-                        catch (err) {
-                            const msg = err instanceof Error ? err.message : String(err);
-                            ctx.log(`  [ARB] Execution failed: ${msg}`);
                         }
                     }
                 }
@@ -349,7 +489,6 @@ export class FundingArbStrategy {
     async onStop(ctx) {
         const openPositions = ctx.state.get("arbOpenPositions");
         const extraAdapters = ctx.state.get("extraAdapters");
-        // Close all open arb positions
         if (openPositions && openPositions.length > 0) {
             const adapters = new Map();
             adapters.set(ctx.adapter.name.toLowerCase(), ctx.adapter);
@@ -358,26 +497,31 @@ export class FundingArbStrategy {
                     adapters.set(name, a);
             }
             for (const pos of openPositions) {
-                const longAdapter = adapters.get(pos.longExchange);
-                const shortAdapter = adapters.get(pos.shortExchange);
-                if (longAdapter && shortAdapter) {
-                    try {
-                        ctx.log(`  [ARB] Closing ${pos.symbol} on stop (${pos.size})`);
-                        await Promise.all([
-                            longAdapter.marketOrder(pos.symbol, "sell", pos.size),
-                            shortAdapter.marketOrder(pos.symbol, "buy", pos.size),
-                        ]);
-                    }
-                    catch (err) {
-                        const msg = err instanceof Error ? err.message : String(err);
-                        ctx.log(`  [ARB] Close on stop failed for ${pos.symbol}: ${msg}`);
+                if (pos.mode === "spot-perp") {
+                    await this.closeSpotPerp(pos, adapters, ctx);
+                }
+                else {
+                    const longAdapter = adapters.get(pos.longExchange);
+                    const shortAdapter = adapters.get(pos.shortExchange);
+                    if (longAdapter && shortAdapter) {
+                        try {
+                            ctx.log(`  [ARB] Closing ${pos.symbol} on stop (${pos.size})`);
+                            await Promise.all([
+                                longAdapter.marketOrder(pos.symbol, "sell", pos.size),
+                                shortAdapter.marketOrder(pos.symbol, "buy", pos.size),
+                            ]);
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            ctx.log(`  [ARB] Close on stop failed for ${pos.symbol}: ${msg}`);
+                        }
                     }
                 }
             }
             ctx.state.set("arbOpenPositions", []);
             ctx.state.set("arbPositions", 0);
         }
-        // Cancel on extra adapters directly (M2: was only cancelling on primary adapter)
+        // Cancel on extra adapters directly
         if (extraAdapters) {
             for (const [, a] of extraAdapters) {
                 try {
@@ -388,6 +532,231 @@ export class FundingArbStrategy {
         }
         return [{ type: "cancel_all" }];
     }
+    /** Close a spot-perp position: sell spot, transfer USDC back, close perp short */
+    async closeSpotPerp(pos, adapters, ctx) {
+        const exchangeName = pos.longExchange.replace("-spot", "");
+        const perpAdapter = adapters.get(pos.shortExchange) ?? adapters.get(exchangeName);
+        if (!perpAdapter) {
+            ctx.log(`  [ARB] Close spot-perp failed: no adapter for ${pos.shortExchange}`);
+            return;
+        }
+        try {
+            const spotAdapter = await this.getSpotAdapter(exchangeName, perpAdapter);
+            if (!spotAdapter) {
+                ctx.log(`  [ARB] Close spot-perp failed: spot adapter not available for ${exchangeName}`);
+                return;
+            }
+            ctx.log(`  [ARB] Closing spot-perp ${pos.symbol} on stop (spot sell + perp buy)`);
+            // Step 1: Sell spot
+            try {
+                await spotAdapter.spotMarketOrder(pos.symbol, "sell", pos.size);
+                ctx.log(`  [ARB] Sold spot ${pos.size} ${pos.symbol}`);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.log(`  [ARB] Spot sell failed for ${pos.symbol}: ${msg}`);
+            }
+            // Step 2: Transfer USDC back to perp (use 95% of notional as estimate)
+            try {
+                const perpSymbol = this.getPerpSymbol(pos.symbol, pos.shortExchange);
+                const priceEstimate = await this.getPriceEstimate(perpAdapter, perpSymbol, pos.symbol);
+                const proceeds = priceEstimate * parseFloat(pos.size) * 0.95;
+                if (proceeds > 1) {
+                    await this.transferUsdcToPerp(spotAdapter, exchangeName, Math.floor(proceeds));
+                    ctx.log(`  [ARB] Transferred ~$${Math.floor(proceeds)} USDC back to perp`);
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.log(`  [ARB] USDC transfer back failed: ${msg}`);
+            }
+            // Step 3: Close perp short
+            try {
+                const perpSymbol = this.getPerpSymbol(pos.symbol, pos.shortExchange);
+                await perpAdapter.marketOrder(perpSymbol, "buy", pos.size);
+                ctx.log(`  [ARB] Closed perp short ${pos.size} ${perpSymbol}`);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.log(`  [ARB] Perp close failed for ${pos.symbol}: ${msg}`);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.log(`  [ARB] Close spot-perp failed for ${pos.symbol}: ${msg}`);
+        }
+    }
+    /** Open a spot-perp position: transfer USDC to spot, buy spot, short perp */
+    async openSpotPerp(opp, adapters, ctx) {
+        const params = this.params;
+        const exchangeName = opp.longExchange.replace("-spot", "");
+        const perpAdapter = adapters.get(opp.shortExchange) ?? adapters.get(exchangeName);
+        if (!perpAdapter) {
+            ctx.log(`  [ARB] Open spot-perp failed: no adapter for ${opp.shortExchange}`);
+            return;
+        }
+        try {
+            const spotAdapter = await this.getSpotAdapter(exchangeName, perpAdapter);
+            if (!spotAdapter) {
+                ctx.log(`  [ARB] Open spot-perp failed: spot adapter not available for ${exchangeName}`);
+                return;
+            }
+            // Balance check: need full notional for spot + margin for perp
+            let targetSizeUsd = params.size_usd;
+            try {
+                const perpBal = await perpAdapter.getBalance();
+                const perpAvail = parseFloat(perpBal.available);
+                const maxAffordable = perpAvail * 0.8;
+                if (maxAffordable < 10) {
+                    ctx.log(`  [ARB] Skip spot-perp ${opp.symbol}: insufficient balance ($${perpAvail.toFixed(2)} available)`);
+                    return;
+                }
+                if (targetSizeUsd > maxAffordable) {
+                    ctx.log(`  [ARB] Spot-perp size reduced $${targetSizeUsd} → $${maxAffordable.toFixed(0)} (limited by balance)`);
+                    targetSizeUsd = Math.floor(maxAffordable);
+                }
+            }
+            catch { /* non-critical */ }
+            const perpSymbol = this.getPerpSymbol(opp.symbol, opp.shortExchange);
+            const priceEstimate = await this.getPriceEstimate(perpAdapter, perpSymbol, opp.symbol);
+            if (priceEstimate <= 0) {
+                ctx.log(`  [ARB] Skip spot-perp ${opp.symbol}: can't determine price`);
+                return;
+            }
+            // Liquidity check
+            const liq = await checkSpotPerpLiquidity(spotAdapter, perpAdapter, opp.symbol, perpSymbol, targetSizeUsd, 0.5, (msg) => ctx.log(`  ${msg}`));
+            if (!liq.viable)
+                return;
+            // Compute matched size
+            const spotMarkets = await spotAdapter.getSpotMarkets();
+            const spotMarket = spotMarkets.find(m => m.baseToken.toUpperCase() === opp.symbol.toUpperCase());
+            const spotDecimals = spotMarket?.sizeDecimals;
+            const matched = computeSpotPerpMatchedSize(liq.adjustedSizeUsd, priceEstimate, exchangeName, opp.shortExchange, spotDecimals);
+            if (!matched) {
+                ctx.log(`  [ARB] Skip spot-perp ${opp.symbol}: can't compute matched size`);
+                return;
+            }
+            ctx.log(`  [ARB] Opening spot-perp: ${matched.size} ${opp.symbol} ($${matched.notional.toFixed(0)}, slippage ~${liq.spotSlippage.toFixed(2)}%/${liq.perpSlippage.toFixed(2)}%)`);
+            // Step 1: Transfer USDC to spot
+            const transferAmt = Math.ceil(matched.notional * 1.02); // slight buffer for price movement
+            await this.transferUsdcToSpot(spotAdapter, exchangeName, transferAmt);
+            ctx.log(`  [ARB] Transferred $${transferAmt} USDC to spot`);
+            // Step 2: Buy spot
+            await spotAdapter.spotMarketOrder(opp.symbol, "buy", matched.size);
+            ctx.log(`  [ARB] Bought spot ${matched.size} ${opp.symbol}`);
+            // Step 3: Short perp
+            await perpAdapter.marketOrder(perpSymbol, "sell", matched.size);
+            ctx.log(`  [ARB] Shorted perp ${matched.size} ${perpSymbol}`);
+            // Track position
+            const currentPositions = ctx.state.get("arbOpenPositions");
+            currentPositions.push({
+                symbol: opp.symbol,
+                longExchange: opp.longExchange,
+                shortExchange: opp.shortExchange,
+                entrySpread: opp.spread,
+                size: matched.size,
+                mode: "spot-perp",
+            });
+            ctx.state.set("arbOpenPositions", currentPositions);
+            ctx.state.set("arbPositions", currentPositions.length);
+            ctx.log(`  [ARB] Spot-perp position opened! (${currentPositions.length}/${params.max_positions})`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.log(`  [ARB] Open spot-perp failed for ${opp.symbol}: ${msg}`);
+        }
+    }
+    /** Transfer USDC from perp to spot account (exchange-specific) */
+    async transferUsdcToSpot(spotAdapter, exchangeName, amount) {
+        if (exchangeName === "hyperliquid") {
+            const { HyperliquidSpotAdapter } = await import("../../exchanges/hyperliquid-spot.js");
+            if (spotAdapter instanceof HyperliquidSpotAdapter) {
+                await spotAdapter.transferUsdcToSpot(amount);
+                return;
+            }
+        }
+        else if (exchangeName === "lighter") {
+            const { LighterSpotAdapter } = await import("../../exchanges/lighter-spot.js");
+            if (spotAdapter instanceof LighterSpotAdapter) {
+                await spotAdapter.transferUsdcToSpot(amount);
+                return;
+            }
+        }
+    }
+    /** Transfer USDC from spot to perp account (exchange-specific) */
+    async transferUsdcToPerp(spotAdapter, exchangeName, amount) {
+        if (exchangeName === "hyperliquid") {
+            const { HyperliquidSpotAdapter } = await import("../../exchanges/hyperliquid-spot.js");
+            if (spotAdapter instanceof HyperliquidSpotAdapter) {
+                await spotAdapter.transferUsdcToPerp(amount);
+                return;
+            }
+        }
+        else if (exchangeName === "lighter") {
+            const { LighterSpotAdapter } = await import("../../exchanges/lighter-spot.js");
+            if (spotAdapter instanceof LighterSpotAdapter) {
+                await spotAdapter.transferUsdcToPerp(amount);
+                return;
+            }
+        }
+    }
+    /**
+     * Get spot adapter for a given exchange name + perp adapter instance.
+     * Returns null if the exchange doesn't support spot or instantiation fails.
+     */
+    async getSpotAdapter(name, adapter) {
+        try {
+            if (name === "hyperliquid") {
+                const { HyperliquidSpotAdapter } = await import("../../exchanges/hyperliquid-spot.js");
+                const { HyperliquidAdapter } = await import("../../exchanges/hyperliquid.js");
+                if (adapter instanceof HyperliquidAdapter) {
+                    const spot = new HyperliquidSpotAdapter(adapter);
+                    await spot.init();
+                    return spot;
+                }
+            }
+            else if (name === "lighter") {
+                const { LighterSpotAdapter } = await import("../../exchanges/lighter-spot.js");
+                const { LighterAdapter } = await import("../../exchanges/lighter.js");
+                if (adapter instanceof LighterAdapter) {
+                    const spot = new LighterSpotAdapter(adapter);
+                    await spot.init();
+                    return spot;
+                }
+            }
+        }
+        catch { /* not supported */ }
+        return null;
+    }
+    /**
+     * Resolve the perp symbol for a given base symbol on an exchange.
+     * HL getPositions() returns symbols like "PURR" or "PURR-PERP" — we normalize here.
+     */
+    getPerpSymbol(baseSymbol, exchangeName) {
+        // Strip any existing -PERP suffix first
+        const base = baseSymbol.replace(/-PERP$/, "").toUpperCase();
+        // HL perp symbols are just the base (e.g. "PURR", "ETH", "BTC")
+        // Some HIP-3 tokens might need "-PERP" suffix — use base for now
+        // since getPositions() returns the base form on HL
+        void exchangeName;
+        return base;
+    }
+    /**
+     * Get a price estimate for a symbol from the perp adapter.
+     * Tries the base symbol first, then with -PERP suffix.
+     */
+    async getPriceEstimate(perpAdapter, perpSymbol, fallbackSymbol) {
+        try {
+            const markets = await perpAdapter.getMarkets();
+            const market = markets.find(m => m.symbol.toUpperCase() === perpSymbol.toUpperCase() ||
+                m.symbol.toUpperCase() === fallbackSymbol.toUpperCase() ||
+                m.symbol.toUpperCase() === `${fallbackSymbol.toUpperCase()}-PERP`);
+            return market ? parseFloat(market.markPrice) : 0;
+        }
+        catch {
+            return 0;
+        }
+    }
     async fetchRates(adapter, _exchangeName) {
         try {
             const markets = await adapter.getMarkets();

package/dist/exchanges/lighter.js

@@ -331,8 +331,17 @@ export class LighterAdapter {
         const available = Number(acct.available_balance || 0);
         const collateral = Number(acct.collateral || 0);
         const unrealizedPnl = acct.positions?.reduce((sum, p) => sum + Number(p.unrealized_pnl || 0), 0) ?? 0;
+        // Include spot USDC balance (separate from perp collateral)
+        let spotUsdc = 0;
+        try {
+            const assets = (acct.assets ?? []);
+            const usdcAsset = assets.find(a => a.symbol === "USDC");
+            if (usdcAsset)
+                spotUsdc = parseFloat(usdcAsset.balance || "0");
+        }
+        catch { /* non-critical */ }
         return {
-            equity: String(totalAsset),
+            equity: String(totalAsset + spotUsdc),
             available: String(available),
             marginUsed: String(Math.max(0, collateral - available)),
             unrealizedPnl: String(unrealizedPnl),

package/dist/funding/normalize.d.ts

@@ -28,6 +28,14 @@ export declare function annualizeHourlyRate(hourlyRate: number): number;
  * Normalizes both to hourly before comparing.
  */
 export declare function computeAnnualSpread(rateA: number, exchangeA: string, rateB: number, exchangeB: string): number;
+/**
+ * Compute SIGNED annualized spread for an existing arb position.
+ * Positive = favorable (short receiving more than long paying).
+ * Negative = unfavorable (funding flipped, position losing on funding).
+ *
+ * For spot-perp: pass longRate=0, longExchange=shortExchange (spot has no funding).
+ */
+export declare function computeSignedAnnualSpread(shortRate: number, shortExchange: string, longRate: number, longExchange: string): number;
 /**
  * Estimate hourly funding payment for a position.
  * @param rate - raw funding rate from the exchange

package/dist/funding/normalize.js

@@ -51,6 +51,18 @@ export function computeAnnualSpread(rateA, exchangeA, rateB, exchangeB) {
     const hourlyB = toHourlyRate(rateB, exchangeB);
     return Math.abs(hourlyA - hourlyB) * HOURLY_PERIODS * 100;
 }
+/**
+ * Compute SIGNED annualized spread for an existing arb position.
+ * Positive = favorable (short receiving more than long paying).
+ * Negative = unfavorable (funding flipped, position losing on funding).
+ *
+ * For spot-perp: pass longRate=0, longExchange=shortExchange (spot has no funding).
+ */
+export function computeSignedAnnualSpread(shortRate, shortExchange, longRate, longExchange) {
+    const hourlyShort = toHourlyRate(shortRate, shortExchange);
+    const hourlyLong = toHourlyRate(longRate, longExchange);
+    return (hourlyShort - hourlyLong) * HOURLY_PERIODS * 100;
+}
 /**
  * Estimate hourly funding payment for a position.
  * @param rate - raw funding rate from the exchange

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perp-cli",
-  "version": "0.7.16",
+  "version": "0.7.19",
   "description": "Multi-DEX Perpetual Futures CLI - Pacifica, Hyperliquid, Lighter, Aster",
   "bin": {
     "perp": "dist/index.js",