perp-cli 0.7.43 → 0.7.48

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

@@ -26,10 +26,13 @@ export declare class FundingArbStrategy implements Strategy {
     private get params();
     private _config;
     private _failCooldown;
+    private _spotAdapterCache;
     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 */
+    /** Close a spot-perp position: sell spot, transfer USDC back, close perp short.
+     * Returns true only if ALL steps succeed. If spot sell succeeds but perp close fails,
+     * attempts to re-buy spot as rollback and returns false. */
     private closeSpotPerp;
     /** Open a spot-perp position: transfer USDC to spot, buy spot, short perp */
     private openSpotPerp;

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

@@ -25,6 +25,7 @@ export class FundingArbStrategy {
     }
     _config = {};
     _failCooldown = new Map(); // "symbol:action" → timestamp of next retry
+    _spotAdapterCache = new Map();
     async init(ctx, _snapshot) {
         // Prune old execution logs (keep 30 days)
         try {
@@ -168,6 +169,7 @@ export class FundingArbStrategy {
                 ctx.state.set("fundingIncome", historicalFunding);
                 ctx.log(`  [FUND] Total historical funding: $${historicalFunding.toFixed(4)}`);
             }
+            // Note: aster funding intervals are bootstrapped lazily via getFundingHours()
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -200,15 +202,17 @@ export class FundingArbStrategy {
                 const marginUsed = parseFloat(bal.marginUsed);
                 const marginPct = equity > 0 ? (marginUsed / equity) * 100 : 100;
                 exchangeBalances.set(name, { equity, available: parseFloat(bal.available), marginPct });
-                if (marginPct < 70) {
+                if (marginPct < 90) {
                     availableAdapters.set(name, a);
                 }
                 else {
                     ctx.log(`  [ARB] ${name} margin ${marginPct.toFixed(0)}% — skipping for this tick`);
                 }
             }
-            catch {
-                availableAdapters.set(name, a); // on error, include it
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.log(`  [ARB] getBalance failed for ${name}: ${msg} — skipping`);
+                // Don't include in availableAdapters
             }
         }
         // Determine which exchanges need rate fetching.
@@ -322,14 +326,17 @@ export class FundingArbStrategy {
                 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);
+                    const spotPerpClosed = await this.closeSpotPerp(pos, adapters, ctx);
+                    if (spotPerpClosed)
+                        toClose.push(pos);
                 }
                 else {
                     const longAdapter = adapters.get(pos.longExchange);
                     const shortAdapter = adapters.get(pos.shortExchange);
                     if (longAdapter && shortAdapter) {
+                        const isPositionGone = (msg) => msg.includes("ReduceOnly") || msg.includes("reduceOnly") || msg.includes("-2022");
                         let closeLongOk = false;
+                        let longPositionGone = false;
                         try {
                             const closeLongResult = await longAdapter.marketOrder(pos.symbol, "sell", pos.size, { reduceOnly: true });
                             closeLongOk = true;
@@ -337,11 +344,18 @@ export class FundingArbStrategy {
                         }
                         catch (err) {
                             const msg = err instanceof Error ? err.message : String(err);
-                            ctx.log(`  [ARB] Close long leg failed for ${pos.symbol}: ${msg} (cooldown 5m)`);
-                            logExecution({ type: "arb_close", exchange: pos.longExchange, symbol: pos.symbol, side: "sell", size: pos.size, status: "failed", error: msg, dryRun: false, meta: { mode: pos.mode, leg: "long" } });
-                            this._failCooldown.set(`${pos.symbol}:close`, Date.now() + 5 * 60 * 1000);
+                            if (isPositionGone(msg)) {
+                                // Position already liquidated/closed on this exchange
+                                longPositionGone = true;
+                                ctx.log(`  [ARB] Long position gone for ${pos.symbol} on ${pos.longExchange} (liquidated?) — force closing short`);
+                            }
+                            else {
+                                ctx.log(`  [ARB] Close long leg failed for ${pos.symbol}: ${msg} (cooldown 5m)`);
+                                logExecution({ type: "arb_close", exchange: pos.longExchange, symbol: pos.symbol, side: "sell", size: pos.size, status: "failed", error: msg, dryRun: false, meta: { mode: pos.mode, leg: "long" } });
+                                this._failCooldown.set(`${pos.symbol}:close`, Date.now() + 5 * 60 * 1000);
+                            }
                         }
-                        if (!closeLongOk)
+                        if (!closeLongOk && !longPositionGone)
                             continue;
                         try {
                             const closeShortResult = await shortAdapter.marketOrder(pos.symbol, "buy", pos.size, { reduceOnly: true });
@@ -349,25 +363,44 @@ export class FundingArbStrategy {
                         }
                         catch (err) {
                             const msg = err instanceof Error ? err.message : String(err);
-                            ctx.log(`  [ARB] Close short leg failed for ${pos.symbol}: ${msg} — re-opening long to restore hedge`);
-                            logExecution({ type: "arb_close", exchange: pos.shortExchange, symbol: pos.symbol, side: "buy", size: pos.size, status: "failed", error: msg, dryRun: false, meta: { mode: pos.mode, leg: "short" } });
-                            // Rollback: re-open long to restore hedge
-                            try {
-                                await longAdapter.marketOrder(pos.symbol, "buy", pos.size);
-                                ctx.log(`  [ARB] Rollback: re-opened long ${pos.size} ${pos.symbol} on ${pos.longExchange}`);
-                                // Note: re-open is NOT reduceOnly (it's a new position)
-                                logExecution({ type: "multi_leg_rollback", exchange: pos.longExchange, symbol: pos.symbol, side: "buy", size: pos.size, status: "success", dryRun: false });
+                            if (isPositionGone(msg)) {
+                                // Short position also gone — both liquidated, just clean up tracking
+                                ctx.log(`  [ARB] Short position also gone for ${pos.symbol} on ${pos.shortExchange} — removing from tracking`);
                             }
-                            catch (rbErr) {
-                                const rbMsg = rbErr instanceof Error ? rbErr.message : String(rbErr);
-                                ctx.log(`  [ARB] CRITICAL: Close rollback failed for ${pos.symbol}: ${rbMsg}`);
-                                logExecution({ type: "multi_leg_rollback", exchange: pos.longExchange, symbol: pos.symbol, side: "buy", size: pos.size, status: "failed", error: rbMsg, dryRun: false });
+                            else if (closeLongOk) {
+                                // Long was closed but short failed (not liquidated) — rollback long
+                                ctx.log(`  [ARB] Close short leg failed for ${pos.symbol}: ${msg} — re-opening long to restore hedge`);
+                                logExecution({ type: "arb_close", exchange: pos.shortExchange, symbol: pos.symbol, side: "buy", size: pos.size, status: "failed", error: msg, dryRun: false, meta: { mode: pos.mode, leg: "short" } });
+                                try {
+                                    await longAdapter.marketOrder(pos.symbol, "buy", pos.size);
+                                    ctx.log(`  [ARB] Rollback: re-opened long ${pos.size} ${pos.symbol} on ${pos.longExchange}`);
+                                    logExecution({ type: "multi_leg_rollback", exchange: pos.longExchange, symbol: pos.symbol, side: "buy", size: pos.size, status: "success", dryRun: false });
+                                }
+                                catch (rbErr) {
+                                    const rbMsg = rbErr instanceof Error ? rbErr.message : String(rbErr);
+                                    ctx.log(`  [ARB] CRITICAL: Close rollback failed for ${pos.symbol}: ${rbMsg}`);
+                                    logExecution({ type: "multi_leg_rollback", exchange: pos.longExchange, symbol: pos.symbol, side: "buy", size: pos.size, status: "failed", error: rbMsg, dryRun: false });
+                                }
+                                this._failCooldown.set(`${pos.symbol}:close`, Date.now() + 5 * 60 * 1000);
+                                continue;
+                            }
+                            else {
+                                // Long was gone, short failed (not liquidated) — orphaned short, force close without reduceOnly
+                                ctx.log(`  [ARB] Force closing orphaned short for ${pos.symbol}: ${msg}`);
+                                try {
+                                    await shortAdapter.marketOrder(pos.symbol, "buy", pos.size);
+                                    ctx.log(`  [ARB] Force closed short ${pos.size} ${pos.symbol} on ${pos.shortExchange}`);
+                                }
+                                catch (forceErr) {
+                                    const forceMsg = forceErr instanceof Error ? forceErr.message : String(forceErr);
+                                    ctx.log(`  [ARB] CRITICAL: Force close short failed for ${pos.symbol}: ${forceMsg}`);
+                                    this._failCooldown.set(`${pos.symbol}:close`, Date.now() + 10 * 60 * 1000);
+                                    continue;
+                                }
                             }
-                            this._failCooldown.set(`${pos.symbol}:close`, Date.now() + 5 * 60 * 1000);
-                            continue;
                         }
                         toClose.push(pos);
-                        ctx.log(`  [ARB] Closed ${pos.symbol} position`);
+                        ctx.log(`  [ARB] Closed ${pos.symbol} position${longPositionGone ? ' (long was liquidated)' : ''}`);
                     }
                 }
             }
@@ -510,12 +543,23 @@ export class FundingArbStrategy {
                     const leverage = Math.min(configLeverage, longMaxLev, shortMaxLev);
                     // Set leverage on both exchanges before ordering
                     try {
-                        await Promise.all([
-                            longAdapter.setLeverage(best.symbol, leverage, "cross"),
-                            shortAdapter.setLeverage(best.symbol, leverage, "cross"),
-                        ]);
+                        await longAdapter.setLeverage(best.symbol, leverage, "cross");
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        ctx.log(`  [ARB] setLeverage failed on ${best.longExchange} for ${best.symbol}: ${msg}`);
+                        this._failCooldown.set(`${best.symbol}:entry`, Date.now() + 5 * 60 * 1000);
+                        continue;
+                    }
+                    try {
+                        await shortAdapter.setLeverage(best.symbol, leverage, "cross");
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        ctx.log(`  [ARB] setLeverage failed on ${best.shortExchange} for ${best.symbol}: ${msg}`);
+                        this._failCooldown.set(`${best.symbol}:entry`, Date.now() + 5 * 60 * 1000);
+                        continue;
                     }
-                    catch { /* non-critical, some exchanges set leverage on order */ }
                     // Balance + margin check (use pre-fetched balances from tick start)
                     let targetSizeUsd = params.size_usd;
                     const longBal = exchangeBalances.get(best.longExchange);
@@ -579,6 +623,20 @@ export class FundingArbStrategy {
                             const rbMsg = rbErr instanceof Error ? rbErr.message : String(rbErr);
                             ctx.log(`  [ARB] CRITICAL: Rollback failed for ${best.symbol}: ${rbMsg}`);
                             logExecution({ type: "multi_leg_rollback", exchange: best.longExchange, symbol: best.symbol, side: "sell", size: matched.size, status: "failed", error: rbMsg, dryRun: false });
+                            // Track orphaned long position for manual cleanup
+                            const currentPositions = ctx.state.get("arbOpenPositions");
+                            currentPositions.push({
+                                symbol: best.symbol,
+                                longExchange: best.longExchange,
+                                shortExchange: best.shortExchange, // note: short leg doesn't exist
+                                entrySpread: 0,
+                                size: matched.size,
+                                mode: "perp-perp",
+                                entryTime: 0, // flag as orphaned
+                            });
+                            ctx.state.set("arbOpenPositions", currentPositions);
+                            ctx.state.set("arbPositions", currentPositions.length);
+                            ctx.log(`  [ARB] Tracking orphaned long position for manual cleanup`);
                         }
                         this._failCooldown.set(`${best.symbol}:entry`, Date.now() + 5 * 60 * 1000);
                         continue;
@@ -674,38 +732,70 @@ export class FundingArbStrategy {
                 for (const [name, a] of extraAdapters)
                     adapters.set(name, a);
             }
+            const remainingPositions = [];
             for (const pos of openPositions) {
                 if (pos.mode === "spot-perp") {
-                    await this.closeSpotPerp(pos, adapters, ctx);
+                    const closed = await this.closeSpotPerp(pos, adapters, ctx);
+                    if (!closed) {
+                        ctx.log(`  [ARB] CRITICAL: spot-perp ${pos.symbol} could not be fully closed on stop — requires manual cleanup`);
+                        remainingPositions.push(pos);
+                    }
                 }
                 else {
                     const longAdapter = adapters.get(pos.longExchange);
                     const shortAdapter = adapters.get(pos.shortExchange);
                     if (longAdapter && shortAdapter) {
                         ctx.log(`  [ARB] Closing ${pos.symbol} on stop (${pos.size})`);
+                        let closeLongOk = false;
                         try {
                             const closeLongResult = await longAdapter.marketOrder(pos.symbol, "sell", pos.size, { reduceOnly: true });
                             logExecution({ type: "arb_close", exchange: pos.longExchange, symbol: pos.symbol, side: "sell", size: pos.size, status: "success", dryRun: false, meta: { mode: pos.mode, leg: "long", stop: true, response: closeLongResult } });
+                            closeLongOk = true;
                         }
                         catch (err) {
                             const msg = err instanceof Error ? err.message : String(err);
                             ctx.log(`  [ARB] Close on stop failed (long) for ${pos.symbol}: ${msg}`);
                             logExecution({ type: "arb_close", exchange: pos.longExchange, symbol: pos.symbol, side: "sell", size: pos.size, status: "failed", error: msg, dryRun: false, meta: { mode: pos.mode, leg: "long", stop: true } });
                         }
+                        if (!closeLongOk) {
+                            ctx.log(`  [ARB] CRITICAL: ${pos.symbol} long close failed on stop — skipping short close to preserve hedge`);
+                            remainingPositions.push(pos);
+                            continue;
+                        }
+                        let closeShortOk = false;
                         try {
                             const closeShortResult = await shortAdapter.marketOrder(pos.symbol, "buy", pos.size, { reduceOnly: true });
                             logExecution({ type: "arb_close", exchange: pos.shortExchange, symbol: pos.symbol, side: "buy", size: pos.size, status: "success", dryRun: false, meta: { mode: pos.mode, leg: "short", stop: true, response: closeShortResult } });
+                            closeShortOk = true;
                         }
                         catch (err) {
                             const msg = err instanceof Error ? err.message : String(err);
-                            ctx.log(`  [ARB] Close on stop failed (short) for ${pos.symbol}: ${msg}`);
+                            ctx.log(`  [ARB] Close on stop failed (short) for ${pos.symbol}: ${msg} — re-opening long to restore hedge`);
                             logExecution({ type: "arb_close", exchange: pos.shortExchange, symbol: pos.symbol, side: "buy", size: pos.size, status: "failed", error: msg, dryRun: false, meta: { mode: pos.mode, leg: "short", stop: true } });
+                            // Rollback: re-open long to restore hedge
+                            try {
+                                await longAdapter.marketOrder(pos.symbol, "buy", pos.size);
+                                ctx.log(`  [ARB] Rollback: re-opened long ${pos.size} ${pos.symbol} on ${pos.longExchange}`);
+                                logExecution({ type: "multi_leg_rollback", exchange: pos.longExchange, symbol: pos.symbol, side: "buy", size: pos.size, status: "success", dryRun: false });
+                            }
+                            catch (rbErr) {
+                                const rbMsg = rbErr instanceof Error ? rbErr.message : String(rbErr);
+                                ctx.log(`  [ARB] CRITICAL: Stop rollback failed for ${pos.symbol}: ${rbMsg}`);
+                                logExecution({ type: "multi_leg_rollback", exchange: pos.longExchange, symbol: pos.symbol, side: "buy", size: pos.size, status: "failed", error: rbMsg, dryRun: false });
+                            }
+                        }
+                        if (!closeShortOk) {
+                            remainingPositions.push(pos);
                         }
                     }
+                    else {
+                        ctx.log(`  [ARB] CRITICAL: ${pos.symbol} adapters not found on stop — requires manual cleanup`);
+                        remainingPositions.push(pos);
+                    }
                 }
             }
-            ctx.state.set("arbOpenPositions", []);
-            ctx.state.set("arbPositions", 0);
+            ctx.state.set("arbOpenPositions", remainingPositions);
+            ctx.state.set("arbPositions", remainingPositions.length);
         }
         // Cancel on extra adapters directly
         if (extraAdapters) {
@@ -718,29 +808,34 @@ export class FundingArbStrategy {
         }
         return [{ type: "cancel_all" }];
     }
-    /** Close a spot-perp position: sell spot, transfer USDC back, close perp short */
+    /** Close a spot-perp position: sell spot, transfer USDC back, close perp short.
+     * Returns true only if ALL steps succeed. If spot sell succeeds but perp close fails,
+     * attempts to re-buy spot as rollback and returns false. */
     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;
+            return false;
         }
         try {
             const spotAdapter = await this.getSpotAdapter(exchangeName, perpAdapter);
             if (!spotAdapter) {
                 ctx.log(`  [ARB] Close spot-perp failed: spot adapter not available for ${exchangeName}`);
-                return;
+                return false;
             }
-            ctx.log(`  [ARB] Closing spot-perp ${pos.symbol} on stop (spot sell + perp buy)`);
+            ctx.log(`  [ARB] Closing spot-perp ${pos.symbol} (spot sell + perp buy)`);
             // Step 1: Sell spot
+            let spotSold = false;
             try {
                 await spotAdapter.spotMarketOrder(pos.symbol, "sell", pos.size);
                 ctx.log(`  [ARB] Sold spot ${pos.size} ${pos.symbol}`);
+                spotSold = true;
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
                 ctx.log(`  [ARB] Spot sell failed for ${pos.symbol}: ${msg}`);
+                return false;
             }
             // Step 2: Transfer USDC back to perp (use 95% of notional as estimate)
             try {
@@ -755,21 +850,36 @@ export class FundingArbStrategy {
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
                 ctx.log(`  [ARB] USDC transfer back failed: ${msg}`);
+                // Non-fatal: continue to close perp short
             }
             // Step 3: Close perp short
+            const perpSymbol = this.getPerpSymbol(pos.symbol, pos.shortExchange);
             try {
-                const perpSymbol = this.getPerpSymbol(pos.symbol, pos.shortExchange);
                 await perpAdapter.marketOrder(perpSymbol, "buy", pos.size, { reduceOnly: true });
                 ctx.log(`  [ARB] Closed perp short ${pos.size} ${perpSymbol}`);
+                return true;
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
                 ctx.log(`  [ARB] Perp close failed for ${pos.symbol}: ${msg}`);
+                // Rollback: re-buy spot to restore hedge
+                if (spotSold) {
+                    try {
+                        await spotAdapter.spotMarketOrder(pos.symbol, "buy", pos.size);
+                        ctx.log(`  [ARB] Rollback: re-bought spot ${pos.size} ${pos.symbol} on ${exchangeName}`);
+                    }
+                    catch (rbErr) {
+                        const rbMsg = rbErr instanceof Error ? rbErr.message : String(rbErr);
+                        ctx.log(`  [ARB] CRITICAL: Spot-perp close rollback failed for ${pos.symbol}: ${rbMsg}`);
+                    }
+                }
+                return false;
             }
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             ctx.log(`  [ARB] Close spot-perp failed for ${pos.symbol}: ${msg}`);
+            return false;
         }
     }
     /** Open a spot-perp position: transfer USDC to spot, buy spot, short perp */
@@ -798,7 +908,11 @@ export class FundingArbStrategy {
             try {
                 await perpAdapter.setLeverage(this.getPerpSymbol(opp.symbol, opp.shortExchange), leverage, "cross");
             }
-            catch { /* non-critical */ }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.log(`  [ARB] setLeverage failed on ${opp.shortExchange} for ${opp.symbol}: ${msg}`);
+                return false;
+            }
             // Balance check: spot needs full notional, perp needs sizeUsd / leverage margin
             let targetSizeUsd = params.size_usd;
             try {
@@ -806,7 +920,7 @@ export class FundingArbStrategy {
                 // Check margin usage
                 const perpEquity = parseFloat(perpBal.equity);
                 const perpMarginPct = perpEquity > 0 ? parseFloat(perpBal.marginUsed) / perpEquity * 100 : 0;
-                if (perpMarginPct > 70) {
+                if (perpMarginPct > 90) {
                     ctx.log(`  [ARB] Skip spot-perp ${opp.symbol}: perp margin usage too high (${perpMarginPct.toFixed(0)}%)`);
                     return false;
                 }
@@ -825,7 +939,11 @@ export class FundingArbStrategy {
                     targetSizeUsd = Math.floor(maxNotional);
                 }
             }
-            catch { /* non-critical */ }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.log(`  [ARB] Balance check failed for spot-perp ${opp.symbol}: ${msg}`);
+                return false;
+            }
             const perpSymbol = this.getPerpSymbol(opp.symbol, opp.shortExchange);
             const priceEstimate = await this.getPriceEstimate(perpAdapter, perpSymbol, opp.symbol);
             if (priceEstimate <= 0) {
@@ -953,25 +1071,32 @@ export class FundingArbStrategy {
      * Returns null if the exchange doesn't support spot or instantiation fails.
      */
     async getSpotAdapter(name, adapter) {
+        const cached = this._spotAdapterCache.get(name);
+        if (cached)
+            return cached;
         try {
+            let spot = null;
             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;
+                    const instance = new HyperliquidSpotAdapter(adapter);
+                    await instance.init();
+                    spot = instance;
                 }
             }
             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;
+                    const instance = new LighterSpotAdapter(adapter);
+                    await instance.init();
+                    spot = instance;
                 }
             }
+            if (spot)
+                this._spotAdapterCache.set(name, spot);
+            return spot;
         }
         catch { /* not supported */ }
         return null;
@@ -1011,12 +1136,22 @@ export class FundingArbStrategy {
             return 0;
         }
     }
-    async fetchRates(adapter, _exchangeName) {
+    async fetchRates(adapter, exchangeName) {
         try {
             const markets = await adapter.getMarkets();
-            return markets
-                .filter(m => m.fundingRate != null)
-                .map(m => ({
+            const withRates = markets.filter(m => m.fundingRate != null);
+            // Bootstrap aster funding hours lazily (1 API call per unknown symbol, cached permanently)
+            if (exchangeName === "aster" && "getFundingHours" in adapter) {
+                const aster = adapter;
+                // Only bootstrap symbols not yet cached (up to 5 per tick to limit API calls)
+                const uncached = withRates.filter(m => m.fundingHours === undefined || m.fundingHours === 1);
+                const toBootstrap = uncached.slice(0, 5);
+                for (const m of toBootstrap) {
+                    const fh = await aster.getFundingHours(m.symbol);
+                    m.fundingHours = fh;
+                }
+            }
+            return withRates.map(m => ({
                 symbol: m.symbol,
                 rate: parseFloat(m.fundingRate),
                 price: parseFloat(m.markPrice),

package/dist/exchanges/aster.d.ts

@@ -14,6 +14,7 @@ export declare class AsterAdapter implements ExchangeAdapter {
     private _testnet;
     private _marketsCache;
     private _marketsCacheTime;
+    private _fundingHoursCache;
     private _accountCache;
     private _positionsCache;
     private _ordersCache;
@@ -26,6 +27,8 @@ export declare class AsterAdapter implements ExchangeAdapter {
     /** Aster API symbol → CLI symbol (ETHUSDT → ETH) */
     private _fromApi;
     init(): Promise<void>;
+    /** Get funding interval for a symbol (lazy bootstrap — queries on first access, cached permanently). */
+    getFundingHours(symbol: string): Promise<number>;
     getMarkets(): Promise<ExchangeMarketInfo[]>;
     getOrderbook(symbol: string): Promise<{
         bids: [string, string][];

package/dist/exchanges/aster.js

@@ -14,6 +14,7 @@ export class AsterAdapter {
     _testnet;
     _marketsCache = null;
     _marketsCacheTime = 0;
+    _fundingHoursCache = new Map();
     _accountCache = null;
     _positionsCache = null;
     _ordersCache = null;
@@ -46,6 +47,26 @@ export class AsterAdapter {
         await this._publicGet("/fapi/v1/time");
     }
     // ── Market Data ──
+    /** Get funding interval for a symbol (lazy bootstrap — queries on first access, cached permanently). */
+    async getFundingHours(symbol) {
+        const key = symbol.toUpperCase();
+        const cached = this._fundingHoursCache.get(key);
+        if (cached !== undefined)
+            return cached;
+        try {
+            const apiSym = this._toApi(key);
+            const data = await this._publicGet("/fapi/v1/fundingRate", { symbol: apiSym, limit: "2" });
+            if (Array.isArray(data) && data.length >= 2) {
+                const hours = Math.abs(data[1].fundingTime - data[0].fundingTime) / 3600000;
+                const rounded = hours <= 1.5 ? 1 : hours <= 5 ? 4 : 8;
+                this._fundingHoursCache.set(key, rounded);
+                return rounded;
+            }
+        }
+        catch { /* non-critical */ }
+        this._fundingHoursCache.set(key, 1); // default
+        return 1;
+    }
     async getMarkets() {
         // Return cached result if fresh
         if (this._marketsCache && Date.now() - this._marketsCacheTime < AsterAdapter.CACHE_TTL) {
@@ -77,12 +98,9 @@ export class AsterAdapter {
             const maxLev = Number(s.maxLeverage ?? 50);
             const lotFilter = s.filters
                 ?.find(f => f.filterType === "LOT_SIZE");
-            const nextFunding = Number(premium?.nextFundingTime ?? 0);
-            const hoursFromMidnight = nextFunding > 0 ? (nextFunding % 86400000) / 3600000 : 0;
-            const fundingHours = nextFunding <= 0 ? 1
-                : hoursFromMidnight % 8 === 0 ? 8
-                    : hoursFromMidnight % 4 === 0 ? 4
-                        : 1;
+            // Use cached funding interval if available (populated by loadFundingIntervals()),
+            // otherwise default to 1h.
+            const fundingHours = this._fundingHoursCache.get(this._fromApi(sym)) ?? 1;
             return {
                 symbol: this._fromApi(sym),
                 markPrice: String(premium?.markPrice ?? ticker?.lastPrice ?? "0"),

package/package.json

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