perp-cli 0.7.42 → 0.7.47

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,8 +326,9 @@ 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);
@@ -331,7 +336,7 @@ export class FundingArbStrategy {
                     if (longAdapter && shortAdapter) {
                         let closeLongOk = false;
                         try {
-                            const closeLongResult = await longAdapter.marketOrder(pos.symbol, "sell", pos.size);
+                            const closeLongResult = await longAdapter.marketOrder(pos.symbol, "sell", pos.size, { reduceOnly: true });
                             closeLongOk = 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", signedSpread: signedSpread, response: closeLongResult } });
                         }
@@ -342,9 +347,9 @@ export class FundingArbStrategy {
                             this._failCooldown.set(`${pos.symbol}:close`, Date.now() + 5 * 60 * 1000);
                         }
                         if (!closeLongOk)
-                            continue; // don't close short if long failed — keep hedge intact
+                            continue;
                         try {
-                            const closeShortResult = await shortAdapter.marketOrder(pos.symbol, "buy", pos.size);
+                            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", signedSpread: signedSpread, response: closeShortResult } });
                         }
                         catch (err) {
@@ -355,6 +360,7 @@ export class FundingArbStrategy {
                             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 });
                             }
                             catch (rbErr) {
@@ -509,12 +515,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);
@@ -570,7 +587,7 @@ export class FundingArbStrategy {
                         logExecution({ type: "arb_entry", exchange: best.shortExchange, symbol: best.symbol, side: "sell", size: matched.size, status: "failed", error: msg, dryRun: false, meta: { mode: "perp-perp", leg: "short" } });
                         // Rollback: close the long position
                         try {
-                            await longAdapter.marketOrder(best.symbol, "sell", matched.size);
+                            await longAdapter.marketOrder(best.symbol, "sell", matched.size, { reduceOnly: true });
                             ctx.log(`  [ARB] Rollback success: closed long ${matched.size} ${best.symbol} on ${best.longExchange}`);
                             logExecution({ type: "multi_leg_rollback", exchange: best.longExchange, symbol: best.symbol, side: "sell", size: matched.size, status: "success", dryRun: false });
                         }
@@ -578,6 +595,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;
@@ -617,14 +648,14 @@ export class FundingArbStrategy {
                             logExecution({ type: "arb_entry", exchange: `${best.longExchange}↔${best.shortExchange}`, symbol: best.symbol, side: "verify", size: matched.size, status: "failed", error: `Position missing after fill: long=${longExists} short=${shortExists}`, dryRun: false });
                             if (longExists && !shortExists) {
                                 try {
-                                    await longAdapter.marketOrder(best.symbol, "sell", matched.size);
+                                    await longAdapter.marketOrder(best.symbol, "sell", matched.size, { reduceOnly: true });
                                     ctx.log(`  [ARB] Rollback: closed phantom long ${best.symbol}`);
                                 }
                                 catch { /* best effort */ }
                             }
                             if (shortExists && !longExists) {
                                 try {
-                                    await shortAdapter.marketOrder(best.symbol, "buy", matched.size);
+                                    await shortAdapter.marketOrder(best.symbol, "buy", matched.size, { reduceOnly: true });
                                     ctx.log(`  [ARB] Rollback: closed phantom short ${best.symbol}`);
                                 }
                                 catch { /* best effort */ }
@@ -673,38 +704,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);
+                            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);
+                            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) {
@@ -717,29 +780,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 {
@@ -754,21 +822,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);
+                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 */
@@ -797,7 +880,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 {
@@ -805,7 +892,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;
                 }
@@ -824,7 +911,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) {
@@ -952,25 +1043,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;
@@ -1010,12 +1108,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][];
@@ -44,7 +47,9 @@ export declare class AsterAdapter implements ExchangeAdapter {
     getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;
     getTradeHistory(limit?: number): Promise<ExchangeTrade[]>;
     getFundingPayments(limit?: number): Promise<ExchangeFundingPayment[]>;
-    marketOrder(symbol: string, side: "buy" | "sell", size: string): Promise<unknown>;
+    marketOrder(symbol: string, side: "buy" | "sell", size: string, opts?: {
+        reduceOnly?: boolean;
+    }): Promise<unknown>;
     limitOrder(symbol: string, side: "buy" | "sell", price: string, size: string, opts?: {
         reduceOnly?: boolean;
         tif?: 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"),
@@ -283,14 +301,17 @@ export class AsterAdapter {
         }));
     }
     // ── Trading ──
-    async marketOrder(symbol, side, size) {
+    async marketOrder(symbol, side, size, opts) {
         const apiSymbol = this._toApi(symbol);
-        const result = await this._signedPost("/fapi/v1/order", {
+        const params = {
             symbol: apiSymbol,
             side: side.toUpperCase(),
             type: "MARKET",
             quantity: size,
-        });
+        };
+        if (opts?.reduceOnly)
+            params.reduceOnly = "true";
+        const result = await this._signedPost("/fapi/v1/order", params);
         const r = result;
         const executedQty = Number(r.executedQty ?? 0);
         const orderId = String(r.orderId ?? "");

package/dist/exchanges/hyperliquid.d.ts

@@ -55,7 +55,9 @@ export declare class HyperliquidAdapter implements ExchangeAdapter {
     getPositions(): Promise<ExchangePosition[]>;
     getOpenOrders(): Promise<ExchangeOrder[]>;
     private _invalidateAccountCache;
-    marketOrder(symbol: string, side: "buy" | "sell", size: string): Promise<unknown>;
+    marketOrder(symbol: string, side: "buy" | "sell", size: string, opts?: {
+        reduceOnly?: boolean;
+    }): Promise<unknown>;
     /**
      * Place a market order on a HIP-3 deployed dex.
      * Bypasses SDK's symbolConversion (which only knows native perps)

package/dist/exchanges/hyperliquid.js

@@ -393,7 +393,7 @@ export class HyperliquidAdapter {
         }
         catch { /* ignore */ }
     }
-    async marketOrder(symbol, side, size) {
+    async marketOrder(symbol, side, size, opts) {
         this.ensureSigner();
         if (this._dex) {
             const r = await this._dexMarketOrder(symbol, side, size);

package/dist/exchanges/interface.d.ts

@@ -85,7 +85,9 @@ export interface ExchangeAdapter {
     getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;
     getTradeHistory(limit?: number): Promise<ExchangeTrade[]>;
     getFundingPayments(limit?: number): Promise<ExchangeFundingPayment[]>;
-    marketOrder(symbol: string, side: "buy" | "sell", size: string): Promise<unknown>;
+    marketOrder(symbol: string, side: "buy" | "sell", size: string, opts?: {
+        reduceOnly?: boolean;
+    }): Promise<unknown>;
     limitOrder(symbol: string, side: "buy" | "sell", price: string, size: string, opts?: {
         reduceOnly?: boolean;
         tif?: string;

package/dist/exchanges/lighter.d.ts

@@ -62,7 +62,9 @@ export declare class LighterAdapter implements ExchangeAdapter {
     private getAuthToken;
     private restGetAuth;
     getOpenOrders(): Promise<ExchangeOrder[]>;
-    marketOrder(symbol: string, side: "buy" | "sell", size: string): Promise<unknown>;
+    marketOrder(symbol: string, side: "buy" | "sell", size: string, opts?: {
+        reduceOnly?: boolean;
+    }): Promise<unknown>;
     limitOrder(symbol: string, side: "buy" | "sell", price: string, size: string, opts?: {
         reduceOnly?: boolean;
         tif?: string;

package/dist/exchanges/lighter.js

@@ -454,8 +454,9 @@ export class LighterAdapter {
             return [];
         }
     }
-    async marketOrder(symbol, side, size) {
+    async marketOrder(symbol, side, size, opts) {
         this.ensureSigner();
+        void opts; // lighter doesn't support reduceOnly on market orders
         await this.ensureMarketMap();
         const nonce = await this.getNextNonce();
         const marketIndex = this.getMarketIndex(symbol);

package/dist/exchanges/pacifica.d.ts

@@ -33,7 +33,9 @@ export declare class PacificaAdapter implements ExchangeAdapter {
     getBalance(): Promise<ExchangeBalance>;
     getPositions(): Promise<ExchangePosition[]>;
     getOpenOrders(): Promise<ExchangeOrder[]>;
-    marketOrder(symbol: string, side: "buy" | "sell", size: string): Promise<unknown>;
+    marketOrder(symbol: string, side: "buy" | "sell", size: string, opts?: {
+        reduceOnly?: boolean;
+    }): Promise<unknown>;
     limitOrder(symbol: string, side: "buy" | "sell", price: string, size: string, opts?: {
         reduceOnly?: boolean;
         tif?: string;

package/dist/exchanges/pacifica.js

@@ -180,9 +180,9 @@ export class PacificaAdapter {
             };
         });
     }
-    async marketOrder(symbol, side, size) {
+    async marketOrder(symbol, side, size, opts) {
         this.ensureSigner();
-        return this.client.createMarketOrder({ symbol, amount: size, side: side === "buy" ? "bid" : "ask", reduce_only: false, slippage_percent: "1" }, this.account, this.signMessage);
+        return this.client.createMarketOrder({ symbol, amount: size, side: side === "buy" ? "bid" : "ask", reduce_only: opts?.reduceOnly ?? false, slippage_percent: "1" }, this.account, this.signMessage);
     }
     async limitOrder(symbol, side, price, size, opts) {
         this.ensureSigner();

package/package.json

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