perp-cli 0.7.17 → 0.7.20

package/dist/bot/conditions.js

@@ -44,7 +44,7 @@ export async function getMarketSnapshot(adapter, symbol) {
         throw new Error(`Market "${symbol}" not found on ${adapter.name}`);
     }
     const price = parseFloat(m.markPrice);
-    const fundingRate = parseFloat(m.fundingRate);
+    const fundingRate = parseFloat(m.fundingRate ?? "0");
     const volume24h = parseFloat(m.volume24h);
     // Try to get kline data for 24h high/low + RSI
     let high24h = price;

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;
@@ -89,20 +93,37 @@ export class FundingArbStrategy {
             // ── Same-exchange spot-perp hedges (e.g. PURR spot + PURR-PERP short on HL) ──
             for (const [name, a] of adapters) {
                 try {
-                    const spotState = await a._getSpotClearinghouseState?.();
-                    if (!spotState?.balances)
+                    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 spotBalances = spotState.balances
-                        .filter(b => Number(b.total) > 0 && b.coin.toUpperCase() !== "USDC");
                     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 = spotBalances.find(b => b.coin.toUpperCase() === base);
+                        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 });
+                            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}`);
                         }
@@ -189,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}`);
+                        }
                     }
                 }
             }
@@ -241,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 = "";
@@ -258,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,
@@ -267,117 +322,163 @@ 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)}%)`);
-            }
-            // 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) {
+                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: try each opportunity until one succeeds
+            if (arbPositions < params.max_positions) {
+                for (const best of opportunities) {
+                    if (best.mode === "spot-perp") {
+                        const opened = await this.openSpotPerp(best, adapters, ctx);
+                        if (opened)
+                            return [{ type: "noop" }];
+                        continue;
+                    }
+                    const longAdapter = adapters.get(best.longExchange);
+                    const shortAdapter = adapters.get(best.shortExchange);
+                    if (!longAdapter || !shortAdapter)
+                        continue;
                     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);
-                            }
+                    if (price <= 0)
+                        continue;
+                    // Balance check
+                    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);
+                        const maxAffordable = minAvail * 0.8;
+                        if (maxAffordable < 10) {
+                            ctx.log(`  [ARB] Skip ${best.symbol}: insufficient balance ($${minAvail.toFixed(2)} available)`);
+                            continue;
                         }
-                        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 [];
+                        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)
+                        continue;
+                    // 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)`);
+                        continue;
+                    }
+                    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 {
-                            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),
+                            ]);
+                        }
+                        catch (orderErr) {
+                            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}`);
+                                    continue;
+                                }
+                                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),
                                 ]);
                             }
-                            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`);
-                                }
+                            else {
+                                throw orderErr;
                             }
-                            catch (reconErr) {
-                                const reconMsg = reconErr instanceof Error ? reconErr.message : String(reconErr);
-                                ctx.log(`  [ARB] WARNING: Fill reconciliation failed: ${reconMsg}`);
+                        }
+                        // Verify fills match
+                        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`);
                             }
-                            // 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}`);
+                        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 (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        ctx.log(`  [ARB] Execution failed for ${best.symbol}: ${msg}`);
+                        continue;
                     }
                 }
             }
@@ -390,7 +491,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);
@@ -399,26 +499,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 {
@@ -429,10 +534,239 @@ 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 false;
+        }
+        try {
+            const spotAdapter = await this.getSpotAdapter(exchangeName, perpAdapter);
+            if (!spotAdapter) {
+                ctx.log(`  [ARB] Open spot-perp failed: spot adapter not available for ${exchangeName}`);
+                return false;
+            }
+            // 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 false;
+                }
+                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 false;
+            }
+            // Liquidity check
+            const liq = await checkSpotPerpLiquidity(spotAdapter, perpAdapter, opp.symbol, perpSymbol, targetSizeUsd, 0.5, (msg) => ctx.log(`  ${msg}`));
+            if (!liq.viable)
+                return false;
+            // 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 false;
+            }
+            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})`);
+            return true;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.log(`  [ARB] Open spot-perp failed for ${opp.symbol}: ${msg}`);
+            return false;
+        }
+    }
+    /** 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();
-            return markets.map(m => ({
+            return markets
+                .filter(m => m.fundingRate != null) // skip symbols with unavailable rates
+                .map(m => ({
                 symbol: m.symbol,
                 rate: parseFloat(m.fundingRate),
                 price: parseFloat(m.markPrice),

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

@@ -48,7 +48,7 @@ export class FundingArbV2Strategy {
                 const map = new Map();
                 for (const m of markets) {
                     map.set(m.symbol.toUpperCase(), {
-                        rate: parseFloat(m.fundingRate),
+                        rate: m.fundingRate != null ? parseFloat(m.fundingRate) : NaN,
                         price: parseFloat(m.markPrice),
                     });
                 }

package/dist/bot/strategies/funding-auto.js

@@ -125,7 +125,7 @@ class FundingAutoStrategy {
                     const sym = normalizeSymbol(raw);
                     const price = parseFloat(m.markPrice);
                     map.set(sym, {
-                        rate: parseFloat(m.fundingRate),
+                        rate: m.fundingRate != null ? parseFloat(m.fundingRate) : NaN,
                         price,
                         exchange: name,
                     });

package/dist/commands/market.js

@@ -15,7 +15,7 @@ export function registerMarketCommands(program, getAdapter, isJson, getAdapterFo
             chalk.white.bold(m.symbol),
             `$${formatUsd(m.markPrice)}`,
             `$${formatUsd(m.indexPrice)}`,
-            formatPercent(m.fundingRate),
+            m.fundingRate != null ? formatPercent(m.fundingRate) : chalk.gray("N/A"),
             `$${formatUsd(m.volume24h)}`,
             `$${formatUsd(m.openInterest)}`,
             String(m.maxLeverage) + "x",
@@ -98,7 +98,7 @@ export function registerMarketCommands(program, getAdapter, isJson, getAdapterFo
             chalk.white.bold(m.symbol),
             `$${formatUsd(m.markPrice)}`,
             `$${formatUsd(m.indexPrice)}`,
-            formatPercent(m.fundingRate),
+            m.fundingRate != null ? formatPercent(m.fundingRate) : chalk.gray("N/A"),
         ];
         if (!explicitExchange && getAdapterForExchange) {
             const grouped = {};
@@ -170,7 +170,7 @@ export function registerMarketCommands(program, getAdapter, isJson, getAdapterFo
         console.log(chalk.cyan.bold(`\n  ${m.symbol} on ${adapter.name}\n`));
         console.log(`  Mark Price:     $${formatUsd(m.markPrice)}`);
         console.log(`  Index Price:    $${formatUsd(m.indexPrice)}`);
-        console.log(`  Funding Rate:   ${formatPercent(m.fundingRate)}`);
+        console.log(`  Funding Rate:   ${m.fundingRate != null ? formatPercent(m.fundingRate) : chalk.gray("N/A")}`);
         console.log(`  24h Volume:     $${formatUsd(m.volume24h)}`);
         console.log(`  Open Interest:  $${formatUsd(m.openInterest)}`);
         console.log(`  Max Leverage:   ${m.maxLeverage}x`);

package/dist/exchanges/aster.js

@@ -79,7 +79,7 @@ export class AsterAdapter {
                 symbol: this._fromApi(sym),
                 markPrice: String(premium?.markPrice ?? ticker?.lastPrice ?? "0"),
                 indexPrice: String(premium?.indexPrice ?? "0"),
-                fundingRate: String(premium?.lastFundingRate ?? "0"),
+                fundingRate: premium?.lastFundingRate != null ? String(premium.lastFundingRate) : null,
                 volume24h: String(ticker?.quoteVolume ?? ticker?.volume ?? "0"),
                 openInterest: "0",
                 maxLeverage: maxLev,

package/dist/exchanges/hyperliquid.js

@@ -218,7 +218,7 @@ export class HyperliquidAdapter {
                 symbol: sym,
                 markPrice: String(ctx.markPx ?? mids[sym] ?? "0"),
                 indexPrice: String(ctx.oraclePx ?? "0"),
-                fundingRate: String(ctx.funding ?? "0"),
+                fundingRate: ctx.funding != null ? String(ctx.funding) : null,
                 volume24h: String(ctx.dayNtlVlm ?? "0"),
                 openInterest: String(ctx.openInterest ?? "0"),
                 maxLeverage: Number(asset.maxLeverage ?? 50),

package/dist/exchanges/interface.d.ts

@@ -6,7 +6,7 @@ export interface ExchangeMarketInfo {
     symbol: string;
     markPrice: string;
     indexPrice: string;
-    fundingRate: string;
+    fundingRate: string | null;
     volume24h: string;
     openInterest: string;
     maxLeverage: number;

package/dist/exchanges/lighter.js

@@ -266,18 +266,22 @@ export class LighterAdapter {
             return this._marketsCache;
         const markets = [];
         try {
-            const res = await this.restGet("/orderBookDetails", {});
-            for (const d of res.order_book_details ?? []) {
+            // Fetch order book details and funding rates in parallel
+            const [obRes, fundingRates] = await Promise.all([
+                this.restGet("/orderBookDetails", {}),
+                this.getFundingRates().catch(() => new Map()),
+            ]);
+            for (const d of obRes.order_book_details ?? []) {
                 if (d.market_type !== "perp")
                     continue;
-                // max_leverage from min_initial_margin_fraction (e.g. 400 = 4% margin = 25x)
                 const imf = d.min_initial_margin_fraction ?? d.default_initial_margin_fraction ?? 500;
                 const maxLev = imf > 0 ? Math.floor(10000 / imf) : 50;
+                const fr = fundingRates.get(d.symbol);
                 markets.push({
                     symbol: d.symbol,
-                    markPrice: String(d.last_trade_price ?? 0),
+                    markPrice: fr?.markPrice ?? String(d.last_trade_price ?? 0),
                     indexPrice: String(d.last_trade_price ?? 0),
-                    fundingRate: "0", // funding rates require auth
+                    fundingRate: fr?.rate ?? null,
                     volume24h: String(d.daily_quote_token_volume ?? 0),
                     openInterest: String(d.open_interest ?? 0),
                     maxLeverage: maxLev,
@@ -331,8 +335,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.17",
+  "version": "0.7.20",
   "description": "Multi-DEX Perpetual Futures CLI - Pacifica, Hyperliquid, Lighter, Aster",
   "bin": {
     "perp": "dist/index.js",