perp-cli 0.7.50 → 0.9.1

package/dist/bot/strategies/spot-perp-executor.js

@@ -0,0 +1,271 @@
+/**
+ * Spot-Perp Executor — handles ALL exchange interactions for spot-perp arbitrage.
+ *
+ * Stateless except for spot adapter cache. Never makes trading decisions.
+ * Strategy calls executor methods; executor handles error recovery / rollback.
+ */
+import { logExecution } from "../../execution-log.js";
+import { invalidateCache } from "../../cache.js";
+import { checkSpotPerpLiquidity } from "../../liquidity.js";
+import { computeSpotPerpMatchedSize } from "../../arb-sizing.js";
+import { getSpotAdapter as getSpotAdapterUtil, transferUsdcToSpot, transferUsdcToPerp, getPerpSymbol, matchSymbol, getPriceEstimate, } from "./funding-arb-utils.js";
+// ── Executor ──
+export class SpotPerpExecutor {
+    _spotAdapterCache = new Map();
+    /** Get or create cached spot adapter. */
+    async getSpotAdapter(name, adapter) {
+        const cached = this._spotAdapterCache.get(name);
+        if (cached)
+            return cached;
+        const spot = await getSpotAdapterUtil(name, adapter);
+        if (spot)
+            this._spotAdapterCache.set(name, spot);
+        return spot;
+    }
+    /** Transfer USDC: perp -> spot account. */
+    async transferToSpot(spotAdapter, exchange, amount) {
+        await transferUsdcToSpot(spotAdapter, exchange, amount);
+    }
+    /** Transfer USDC: spot -> perp account. */
+    async transferToPerp(spotAdapter, exchange, amount) {
+        await transferUsdcToPerp(spotAdapter, exchange, amount);
+    }
+    /** Returns true if a reduceOnly rejection indicates the position is already gone. */
+    isPositionGone(msg) {
+        return msg.includes("ReduceOnly") || msg.includes("reduceOnly") || msg.includes("-2022");
+    }
+    /**
+     * Full spot-perp entry flow:
+     * 1. Check liquidity
+     * 2. Compute matched size
+     * 3. Set leverage on perp
+     * 4. Transfer USDC to spot (only the shortfall, track actual transferred)
+     * 5. Buy spot
+     * 6. Short perp
+     * 7. Verify positions
+     * On failure: rollback all completed steps.
+     */
+    async openPosition(params) {
+        const { symbol, perpSymbol, spotExchange, perpExchange, spotAdapter, perpAdapter, sizeUsd, leverage, log } = params;
+        try {
+            // Set leverage
+            try {
+                await perpAdapter.setLeverage(perpSymbol, leverage, "cross");
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log(`  [SPA] setLeverage failed: ${msg}`);
+                return { success: false, error: `setLeverage: ${msg}` };
+            }
+            // Price estimate
+            const price = await getPriceEstimate(perpAdapter, perpSymbol, symbol);
+            if (price <= 0)
+                return { success: false, error: "price <= 0" };
+            // Liquidity check
+            const liq = await checkSpotPerpLiquidity(spotAdapter, perpAdapter, symbol, perpSymbol, sizeUsd, 0.5, (msg) => log(`  ${msg}`));
+            if (!liq.viable)
+                return { success: false, error: "liquidity not viable" };
+            // Compute matched size
+            const spotMarkets = await spotAdapter.getSpotMarkets();
+            const spotDec = spotMarkets.find(m => m.baseToken.toUpperCase() === symbol.toUpperCase())?.sizeDecimals;
+            const matched = computeSpotPerpMatchedSize(liq.adjustedSizeUsd, price, spotExchange, perpExchange, spotDec);
+            if (!matched) {
+                log(`  [SPA] Skip ${symbol}: matched size fail`);
+                return { success: false, error: "matched size fail" };
+            }
+            log(`  [SPA] Opening: ${matched.size} ${symbol} ($${matched.notional.toFixed(0)}) ${spotExchange}-spot<>${perpExchange}`);
+            // Transfer USDC to spot account — only transfer the shortfall, track actual amount
+            const tAmt = Math.ceil(matched.notional * 1.02);
+            let spotUsdcAvailable = 0;
+            try {
+                const spotBals = await spotAdapter.getSpotBalances();
+                const usdcBal = spotBals.find(b => b.token.toUpperCase().startsWith("USDC"));
+                spotUsdcAvailable = usdcBal ? parseFloat(usdcBal.available) : 0;
+            }
+            catch { /* ignore */ }
+            let actualTransferred = 0;
+            if (spotUsdcAvailable >= tAmt) {
+                log(`  [SPA] Spot already has $${spotUsdcAvailable.toFixed(2)} USDC, skipping transfer`);
+            }
+            else {
+                actualTransferred = Math.ceil(tAmt - spotUsdcAvailable);
+                try {
+                    await transferUsdcToSpot(spotAdapter, spotExchange, actualTransferred);
+                    log(`  [SPA] Transferred $${actualTransferred} USDC to ${spotExchange} spot`);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    log(`  [SPA] USDC transfer to spot failed: ${msg}`);
+                    return { success: false, error: `transfer: ${msg}` };
+                }
+            }
+            // Step 1: Buy spot
+            try {
+                await spotAdapter.spotMarketOrder(symbol, "buy", matched.size);
+                logExecution({ type: "arb_entry", exchange: `${spotExchange}-spot`, symbol, side: "buy", size: matched.size, notional: matched.notional, status: "success", dryRun: false, meta: { mode: "spot-perp", leg: "spot" } });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log(`  [SPA] Spot buy failed: ${msg}`);
+                if (actualTransferred > 0) {
+                    try {
+                        await transferUsdcToPerp(spotAdapter, spotExchange, actualTransferred);
+                        log(`  [SPA] Recovered $${actualTransferred} USDC back to perp`);
+                    }
+                    catch { /* best effort */ }
+                }
+                return { success: false, error: `spot buy: ${msg}` };
+            }
+            // Step 2: Short perp
+            try {
+                await perpAdapter.marketOrder(perpSymbol, "sell", matched.size);
+                logExecution({ type: "arb_entry", exchange: perpExchange, symbol, side: "sell", size: matched.size, notional: matched.notional, status: "success", dryRun: false, meta: { mode: "spot-perp", leg: "perp" } });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log(`  [SPA] Perp short failed: ${msg} -- ROLLING BACK spot`);
+                try {
+                    await spotAdapter.spotMarketOrder(symbol, "sell", matched.size);
+                    logExecution({ type: "multi_leg_rollback", exchange: `${spotExchange}-spot`, symbol, side: "sell", size: matched.size, status: "success", dryRun: false });
+                    if (actualTransferred > 0) {
+                        try {
+                            await transferUsdcToPerp(spotAdapter, spotExchange, actualTransferred);
+                        }
+                        catch { /* best effort */ }
+                    }
+                }
+                catch (rbErr) {
+                    log(`  [SPA] CRITICAL: Spot rollback failed: ${rbErr instanceof Error ? rbErr.message : String(rbErr)}`);
+                }
+                return { success: false, error: `perp short: ${msg}` };
+            }
+            // Position verification
+            invalidateCache("acct");
+            try {
+                const perpPositions = await perpAdapter.getPositions();
+                const hasPerp = perpPositions.some(x => matchSymbol(x.symbol, perpSymbol) && parseFloat(x.size) > 0);
+                if (!hasPerp) {
+                    log(`  [SPA] WARNING: Perp position not visible (cache delay?)`);
+                }
+            }
+            catch (err) {
+                log(`  [SPA] Verify error: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return { success: true, size: matched.size, notional: matched.notional };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(`  [SPA] Open failed: ${msg}`);
+            return { success: false, error: msg };
+        }
+    }
+    /**
+     * Full spot-perp close flow:
+     * 1. Close perp short FIRST (reduceOnly) — hedge stays intact if this fails
+     * 2. Sell spot
+     * 3. Transfer USDC back to perp (always, not just same-exchange)
+     */
+    async closePosition(params) {
+        const { symbol, spotExchange, perpExchange, spotAdapter, perpAdapter, size, log } = params;
+        const perpSym = getPerpSymbol(symbol, perpExchange);
+        try {
+            // Step 1: Close perp short FIRST (reduceOnly) — if this fails, hedge is still intact
+            try {
+                await perpAdapter.marketOrder(perpSym, "buy", size, { reduceOnly: true });
+                logExecution({ type: "arb_close", exchange: perpExchange, symbol, side: "buy", size, status: "success", dryRun: false, meta: { mode: "spot-perp" } });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                // ReduceOnly rejected = position already gone, proceed to sell spot
+                if (this.isPositionGone(msg)) {
+                    log(`  [SPA] Perp already closed (ReduceOnly rejected)`);
+                }
+                else {
+                    log(`  [SPA] Perp close failed, hedge intact: ${msg}`);
+                    return false;
+                }
+            }
+            // Step 2: Sell spot
+            try {
+                await spotAdapter.spotMarketOrder(symbol, "sell", size);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log(`  [SPA] Spot sell failed: ${msg} -- re-opening perp hedge`);
+                try {
+                    await perpAdapter.marketOrder(perpSym, "sell", size);
+                }
+                catch (rbErr) {
+                    log(`  [SPA] CRITICAL: Perp re-hedge failed: ${rbErr instanceof Error ? rbErr.message : String(rbErr)}`);
+                }
+                return false;
+            }
+            // Step 3: Transfer USDC back to perp (always — lighter/HL both need this)
+            try {
+                const spotBals = await spotAdapter.getSpotBalances();
+                const usdcBal = spotBals.find(b => b.token.toUpperCase().startsWith("USDC"));
+                const usdcAmount = usdcBal ? parseFloat(usdcBal.total) : 0;
+                if (usdcAmount > 1) {
+                    await transferUsdcToPerp(spotAdapter, spotExchange, Math.floor(usdcAmount));
+                    log(`  [SPA] Transferred $${Math.floor(usdcAmount)} USDC back to perp`);
+                }
+            }
+            catch { /* non-fatal */ }
+            return true;
+        }
+        catch (err) {
+            log(`  [SPA] Close failed: ${err instanceof Error ? err.message : String(err)}`);
+            return false;
+        }
+    }
+    /**
+     * Rotate perp short to better exchange:
+     * 1. Set leverage on new exchange
+     * 2. Close current perp short (reduceOnly)
+     * 3. Open new perp short on new exchange
+     * 4. Rollback if new short fails
+     * Spot stays unchanged.
+     */
+    async rotateShort(params) {
+        const { symbol, currentExchange, newExchange, currentAdapter, newAdapter, size, leverage, log } = params;
+        const oldSym = getPerpSymbol(symbol, currentExchange);
+        const newSym = getPerpSymbol(symbol, newExchange);
+        // Set leverage on new exchange
+        try {
+            await newAdapter.setLeverage(newSym, leverage, "cross");
+        }
+        catch (err) {
+            log(`  [SPA] Rotation setLeverage failed: ${err instanceof Error ? err.message : String(err)}`);
+            return false;
+        }
+        // Close old short
+        try {
+            await currentAdapter.marketOrder(oldSym, "buy", size, { reduceOnly: true });
+            logExecution({ type: "arb_close", exchange: currentExchange, symbol, side: "buy", size, status: "success", dryRun: false, meta: { rotation: true } });
+        }
+        catch (err) {
+            log(`  [SPA] Rotation close failed: ${err instanceof Error ? err.message : String(err)}`);
+            return false;
+        }
+        // Open new short
+        try {
+            await newAdapter.marketOrder(newSym, "sell", size);
+            logExecution({ type: "arb_entry", exchange: newExchange, symbol, side: "sell", size, status: "success", dryRun: false, meta: { rotation: true } });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(`  [SPA] Rotation new short failed: ${msg} -- rolling back`);
+            try {
+                await currentAdapter.marketOrder(oldSym, "sell", size);
+                log(`  [SPA] Rotation rollback OK`);
+                logExecution({ type: "multi_leg_rollback", exchange: currentExchange, symbol, side: "sell", size, status: "success", dryRun: false });
+            }
+            catch (rbErr) {
+                log(`  [SPA] CRITICAL: Rotation rollback failed: ${rbErr instanceof Error ? rbErr.message : String(rbErr)}`);
+                logExecution({ type: "multi_leg_rollback", exchange: currentExchange, symbol, side: "sell", size, status: "failed", error: rbErr instanceof Error ? rbErr.message : String(rbErr), dryRun: false });
+            }
+            return false;
+        }
+        return true;
+    }
+}

package/dist/commands/bot.js

@@ -209,6 +209,85 @@ export function registerBotCommands(program, getAdapter, getAdapterFor, isJson)
         const log = makeLog();
         await runBot(primaryAdapter, config, opts.jobId, log, adapters, mode);
     });
+    // ── bot delta-neutral ──
+    bot
+        .command("delta-neutral")
+        .description("Spot-long + perp-short delta-neutral funding rate farming")
+        .option("--exchanges <list>", "Comma-separated perp exchange names", "lighter,aster")
+        .option("--min-rate <pct>", "Min annualized rate to enter (%)", "10")
+        .option("--close-rate <pct>", "Close when avg rate drops below (%)", "2")
+        .option("--size <usd>", "Position size per leg ($)", "50")
+        .option("--max-positions <n>", "Max simultaneous positions", "5")
+        .option("--leverage <n>", "Perp side leverage", "3")
+        .option("--interval <sec>", "Check interval in seconds", "60")
+        .option("--max-drawdown <usd>", "Stop if drawdown exceeds ($)", "200")
+        .option("--background", "Run in background (tmux)")
+        .option("--headless", "Run without TUI dashboard")
+        .option("--job-id <id>", "Job ID")
+        .action(async (opts) => {
+        const exchangeNames = opts.exchanges.split(",").map(e => e.trim());
+        const adapters = new Map();
+        for (const name of exchangeNames) {
+            try {
+                adapters.set(name, await getAdapterFor(name));
+            }
+            catch {
+                // skip unavailable
+            }
+        }
+        if (adapters.size < 1) {
+            console.error(chalk.red("\n  Need at least 1 exchange for delta-neutral.\n"));
+            return;
+        }
+        const primaryAdapter = adapters.values().next().value;
+        const config = {
+            name: `delta-neutral-${Date.now().toString(36)}`,
+            exchange: primaryAdapter.name,
+            symbol: "ETH",
+            strategy: {
+                type: "spot-perp-arb",
+                exchanges: exchangeNames,
+                min_rate: parseFloat(opts.minRate),
+                close_rate: parseFloat(opts.closeRate),
+                size_usd: parseFloat(opts.size),
+                max_positions: parseInt(opts.maxPositions),
+                leverage: parseInt(opts.leverage),
+            },
+            entry_conditions: [{ type: "always", value: 0 }],
+            exit_conditions: [],
+            risk: {
+                max_position_usd: parseFloat(opts.size) * parseInt(opts.maxPositions) * 2,
+                max_daily_loss: parseFloat(opts.maxDrawdown) / 2,
+                max_drawdown: parseFloat(opts.maxDrawdown),
+                pause_after_loss_sec: 300,
+                max_open_bots: 1,
+            },
+            monitor_interval_sec: parseInt(opts.interval),
+        };
+        if (opts.background) {
+            const { startJob } = await import("../jobs.js");
+            const cliArgs = [
+                `delta-neutral`,
+                `--min-rate`, opts.minRate, `--close-rate`, opts.closeRate,
+                `--size`, opts.size, `--max-positions`, opts.maxPositions,
+                `--leverage`, opts.leverage, `--exchanges`, opts.exchanges,
+                `--interval`, opts.interval, `--max-drawdown`, opts.maxDrawdown,
+            ];
+            const job = startJob({
+                strategy: `bot:delta-neutral`,
+                exchange: "multi",
+                params: { ...opts },
+                cliArgs,
+            });
+            if (isJson())
+                return printJson(jsonOk(job));
+            printBotJobStarted(config.name, job.id);
+            return;
+        }
+        const mode = resolveOutputMode(isJson, opts.headless);
+        const log = makeLog();
+        await runBot(primaryAdapter, config, opts.jobId, log, adapters, mode);
+    });
     // ── bot preset list ──
     bot
         .command("preset-list")
@@ -550,7 +629,7 @@ export function registerBotCommands(program, getAdapter, getAdapterFor, isJson)
         const log = makeLog();
         // Multi-exchange strategies need all adapters
         let extraAdapters;
-        const multiExchangeStrategies = ["funding-auto", "funding-arb", "funding-arb-v2", "basis-arb", "hedge-agent"];
+        const multiExchangeStrategies = ["funding-auto", "funding-arb", "funding-arb-v2", "spot-perp-arb", "basis-arb", "hedge-agent"];
         if (multiExchangeStrategies.includes(strategyName) && getAdapterFor) {
             extraAdapters = new Map();
             for (const ex of ["pacifica", "hyperliquid", "lighter", "aster"]) {

package/dist/commands/trade.js

@@ -1185,6 +1185,137 @@ export function registerTradeCommands(program, getAdapter, isJson, isDryRun = ()
         }
         console.log(chalk.yellow(`\n  PnL tracker stopped.\n`));
     });
+    // === Spot Trading ===
+    trade
+        .command("spot-buy <symbol> <size>")
+        .description("Buy spot token (HL or Lighter spot market)")
+        .action(async (symbol, size) => {
+        await withJsonErrors(isJson(), async () => {
+            const adapter = await getAdapter();
+            const exchangeName = adapter.name.toLowerCase();
+            let spotAdapter;
+            if (exchangeName === "hyperliquid") {
+                const { HyperliquidSpotAdapter } = await import("../exchanges/hyperliquid-spot.js");
+                const { HyperliquidAdapter } = await import("../exchanges/hyperliquid.js");
+                if (adapter instanceof HyperliquidAdapter) {
+                    spotAdapter = new HyperliquidSpotAdapter(adapter);
+                }
+            }
+            else if (exchangeName === "lighter") {
+                const { LighterSpotAdapter } = await import("../exchanges/lighter-spot.js");
+                const { LighterAdapter } = await import("../exchanges/lighter.js");
+                if (adapter instanceof LighterAdapter) {
+                    spotAdapter = new LighterSpotAdapter(adapter);
+                }
+            }
+            if (!spotAdapter) {
+                if (isJson())
+                    return printJson(jsonError("UNSUPPORTED", `${exchangeName} does not support spot trading`));
+                errorAndExit(`${exchangeName} does not support spot trading`);
+                return;
+            }
+            await spotAdapter.init();
+            if (dryRunGuard("spot buy", { exchange: exchangeName, symbol: symbol.toUpperCase(), side: "buy", size }))
+                return;
+            const result = await spotAdapter.spotMarketOrder(symbol.toUpperCase(), "buy", size);
+            logExecution({ type: "market_order", exchange: exchangeName + "-spot", symbol: symbol.toUpperCase(), side: "buy", size, status: "success", dryRun: false, meta: { spot: true, result } });
+            if (isJson()) {
+                printJson(jsonOk({ order: result, symbol: symbol.toUpperCase(), side: "buy", size }));
+            }
+            else {
+                console.log(chalk.green(`\n  ✓ Spot bought ${size} ${symbol.toUpperCase()} on ${exchangeName}\n`));
+            }
+        });
+    });
+    trade
+        .command("spot-sell <symbol> <size>")
+        .description("Sell spot token (HL or Lighter spot market)")
+        .action(async (symbol, size) => {
+        await withJsonErrors(isJson(), async () => {
+            const adapter = await getAdapter();
+            const exchangeName = adapter.name.toLowerCase();
+            let spotAdapter;
+            if (exchangeName === "hyperliquid") {
+                const { HyperliquidSpotAdapter } = await import("../exchanges/hyperliquid-spot.js");
+                const { HyperliquidAdapter } = await import("../exchanges/hyperliquid.js");
+                if (adapter instanceof HyperliquidAdapter) {
+                    spotAdapter = new HyperliquidSpotAdapter(adapter);
+                }
+            }
+            else if (exchangeName === "lighter") {
+                const { LighterSpotAdapter } = await import("../exchanges/lighter-spot.js");
+                const { LighterAdapter } = await import("../exchanges/lighter.js");
+                if (adapter instanceof LighterAdapter) {
+                    spotAdapter = new LighterSpotAdapter(adapter);
+                }
+            }
+            if (!spotAdapter) {
+                if (isJson())
+                    return printJson(jsonError("UNSUPPORTED", `${exchangeName} does not support spot trading`));
+                errorAndExit(`${exchangeName} does not support spot trading`);
+                return;
+            }
+            await spotAdapter.init();
+            if (dryRunGuard("spot sell", { exchange: exchangeName, symbol: symbol.toUpperCase(), side: "sell", size }))
+                return;
+            const result = await spotAdapter.spotMarketOrder(symbol.toUpperCase(), "sell", size);
+            logExecution({ type: "market_order", exchange: exchangeName + "-spot", symbol: symbol.toUpperCase(), side: "sell", size, status: "success", dryRun: false, meta: { spot: true, result } });
+            if (isJson()) {
+                printJson(jsonOk({ order: result, symbol: symbol.toUpperCase(), side: "sell", size }));
+            }
+            else {
+                console.log(chalk.green(`\n  ✓ Spot sold ${size} ${symbol.toUpperCase()} on ${exchangeName}\n`));
+            }
+        });
+    });
+    trade
+        .command("spot-balance")
+        .description("Show spot token balances (HL or Lighter)")
+        .action(async () => {
+        await withJsonErrors(isJson(), async () => {
+            const adapter = await getAdapter();
+            const exchangeName = adapter.name.toLowerCase();
+            let spotAdapter;
+            if (exchangeName === "hyperliquid") {
+                const { HyperliquidSpotAdapter } = await import("../exchanges/hyperliquid-spot.js");
+                const { HyperliquidAdapter } = await import("../exchanges/hyperliquid.js");
+                if (adapter instanceof HyperliquidAdapter) {
+                    spotAdapter = new HyperliquidSpotAdapter(adapter);
+                }
+            }
+            else if (exchangeName === "lighter") {
+                const { LighterSpotAdapter } = await import("../exchanges/lighter-spot.js");
+                const { LighterAdapter } = await import("../exchanges/lighter.js");
+                if (adapter instanceof LighterAdapter) {
+                    spotAdapter = new LighterSpotAdapter(adapter);
+                }
+            }
+            if (!spotAdapter) {
+                if (isJson())
+                    return printJson(jsonError("UNSUPPORTED", `${exchangeName} does not support spot trading`));
+                errorAndExit(`${exchangeName} does not support spot trading`);
+                return;
+            }
+            await spotAdapter.init();
+            const balances = await spotAdapter.getSpotBalances();
+            const nonZero = balances.filter(b => Number(b.total) > 0);
+            if (isJson()) {
+                printJson(jsonOk({ exchange: exchangeName, balances: nonZero }));
+            }
+            else {
+                console.log(chalk.cyan(`\n  Spot Balances (${exchangeName}):\n`));
+                if (nonZero.length === 0) {
+                    console.log(chalk.gray("  No spot tokens\n"));
+                }
+                else {
+                    for (const b of nonZero) {
+                        console.log(`  ${b.token.padEnd(10)} ${b.total.padEnd(15)} available: ${b.available}`);
+                    }
+                    console.log();
+                }
+            }
+        });
+    });
     // ── Multi-leg orders ──────────────────────────────────────────────────
     if (getAdapterForExchange) {
         const tradeCmd = program.commands.find(c => c.name() === "trade");

package/dist/exchanges/aster.d.ts

@@ -28,7 +28,7 @@ export declare class AsterAdapter implements ExchangeAdapter {
     private _fromApi;
     init(): Promise<void>;
     /** Get funding interval for a symbol (lazy bootstrap — queries on first access, cached permanently). */
-    getFundingHours(symbol: string): Promise<number>;
+    getFundingHours(symbol: string): Promise<number | undefined>;
     getMarkets(): Promise<ExchangeMarketInfo[]>;
     getOrderbook(symbol: string): Promise<{
         bids: [string, string][];

package/dist/exchanges/aster.js

@@ -64,8 +64,8 @@ export class AsterAdapter {
             }
         }
         catch { /* non-critical */ }
-        this._fundingHoursCache.set(key, 1); // default
-        return 1;
+        // Don't cache a default — let strategy skip this symbol until real data is available
+        return undefined;
     }
     async getMarkets() {
         // Return cached result if fresh
@@ -98,9 +98,9 @@ export class AsterAdapter {
             const maxLev = Number(s.maxLeverage ?? 50);
             const lotFilter = s.filters
                 ?.find(f => f.filterType === "LOT_SIZE");
-            // Use cached funding interval if available (populated by loadFundingIntervals()),
-            // otherwise default to 1h.
-            const fundingHours = this._fundingHoursCache.get(this._fromApi(sym)) ?? 1;
+            // Use cached funding interval if available (populated by getFundingHours()).
+            // If not yet bootstrapped, fundingHours = undefined → strategy must skip this symbol.
+            const fundingHours = this._fundingHoursCache.get(this._fromApi(sym));
             return {
                 symbol: this._fromApi(sym),
                 markPrice: String(premium?.markPrice ?? ticker?.lastPrice ?? "0"),

package/dist/exchanges/hyperliquid.d.ts

@@ -55,6 +55,13 @@ export declare class HyperliquidAdapter implements ExchangeAdapter {
     getPositions(): Promise<ExchangePosition[]>;
     getOpenOrders(): Promise<ExchangeOrder[]>;
     private _invalidateAccountCache;
+    /**
+     * Validate that an HL order actually filled.
+     * HL API returns status "ok" even for 0-fill IoC orders.
+     * Response shape: { status: "ok", response: { type: "order", data: { statuses: [...] } } }
+     * Each status is one of: { filled: { totalSz, avgPx, oid } }, { resting: { oid } }, { error: "msg" }
+     */
+    private _validateOrderFill;
     marketOrder(symbol: string, side: "buy" | "sell", size: string, opts?: {
         reduceOnly?: boolean;
     }): Promise<unknown>;

package/dist/exchanges/hyperliquid.js

@@ -393,10 +393,32 @@ export class HyperliquidAdapter {
         }
         catch { /* ignore */ }
     }
+    /**
+     * Validate that an HL order actually filled.
+     * HL API returns status "ok" even for 0-fill IoC orders.
+     * Response shape: { status: "ok", response: { type: "order", data: { statuses: [...] } } }
+     * Each status is one of: { filled: { totalSz, avgPx, oid } }, { resting: { oid } }, { error: "msg" }
+     */
+    _validateOrderFill(result, symbol, side, requestedSize) {
+        const r = result;
+        const statuses = r?.response?.data?.statuses;
+        if (!statuses || statuses.length === 0) {
+            throw new Error(`Market ${side} ${symbol}: no order status in response`);
+        }
+        const st = statuses[0];
+        if (st.error) {
+            throw new Error(`Market ${side} ${symbol}: ${st.error}`);
+        }
+        const filled = st.filled;
+        if (!filled || Number(filled.totalSz ?? 0) === 0) {
+            throw new Error(`Market ${side} ${symbol}: order not filled (0 of ${requestedSize}). Check price/liquidity.`);
+        }
+    }
     async marketOrder(symbol, side, size, opts) {
         this.ensureSigner();
         if (this._dex) {
             const r = await this._dexMarketOrder(symbol, side, size);
+            this._validateOrderFill(r, symbol, side, size);
             await this._invalidateAccountCache();
             return r;
         }
@@ -405,6 +427,7 @@ export class HyperliquidAdapter {
         console.log = () => { };
         try {
             const result = await this.sdk.custom.marketOpen(symbol.toUpperCase(), side === "buy", parseFloat(size));
+            this._validateOrderFill(result, symbol, side, size);
             await this._invalidateAccountCache();
             return result;
         }

package/dist/exchanges/lighter-spot.js

@@ -231,6 +231,26 @@ export class LighterSpotAdapter {
             orderType: 1, // MARKET
             timeInForce: 0, // IOC
         });
+        // Verify fill via tx endpoint
+        const txResult = result;
+        if (txResult.tx_hash) {
+            for (let attempt = 0; attempt < 5; attempt++) {
+                await new Promise(r => setTimeout(r, 500));
+                try {
+                    const tx = await this._restGet("/tx", { by: "hash", value: txResult.tx_hash });
+                    const status = Number(tx.status ?? 0);
+                    if (status === 3)
+                        return result; // executed
+                    if (status > 3)
+                        throw new Error(`Spot ${side} ${symbol}: tx rejected (status=${status})`);
+                }
+                catch (e) {
+                    if (e instanceof Error && e.message.startsWith("Spot "))
+                        throw e;
+                }
+            }
+            throw new Error(`Spot ${side} ${symbol}: tx not confirmed after 2.5s (hash=${txResult.tx_hash})`);
+        }
         return result;
     }
     async spotLimitOrder(symbol, side, price, size, opts) {