perp-cli 0.7.37 → 0.7.42

package/dist/bot/config.d.ts

@@ -42,6 +42,7 @@ export interface FundingArbStrategyParams {
     max_positions: number;
     exchanges: string[];
     leverage?: number;
+    min_hold_hours?: number;
 }
 export interface GenericStrategyParams {
     type: string;

package/dist/bot/config.js

@@ -30,7 +30,7 @@ function parseBotConfig(raw) {
     const name = String(raw.name ?? `bot-${Date.now()}`);
     const exchange = String(raw.exchange ?? "hyperliquid");
     const symbol = String(raw.symbol ?? "ETH");
-    const monitorInterval = Number(raw.monitor_interval_sec ?? raw.interval ?? 10);
+    const monitorInterval = Number(raw.monitor_interval_sec ?? raw.interval ?? 30);
     // Strategy
     const stratRaw = (raw.strategy ?? raw.params ?? {});
     const stratType = String(stratRaw.type ?? raw.strategy_type ?? "grid");
@@ -131,7 +131,7 @@ export function quickGridConfig(opts) {
             ...(opts.maxRuntime ? [{ type: "time_after", value: opts.maxRuntime }] : []),
         ],
         risk: { ...DEFAULT_RISK, max_drawdown: opts.maxDrawdown },
-        monitor_interval_sec: 10,
+        monitor_interval_sec: 30,
     };
 }
 export function quickDCAConfig(opts) {

package/dist/bot/presets.js

@@ -58,7 +58,7 @@ const gridStandard = {
             { type: "volatility_above", value: 12 },
         ],
         risk: { ...DEFAULT_RISK, max_drawdown: 100, max_daily_loss: 50 },
-        monitor_interval_sec: 10,
+        monitor_interval_sec: 30,
     }),
 };
 const gridAggressive = {
@@ -111,7 +111,7 @@ const gridLongBias = {
         entry_conditions: [{ type: "always", value: 0 }],
         exit_conditions: [],
         risk: { ...DEFAULT_RISK, max_drawdown: 150, max_daily_loss: 75 },
-        monitor_interval_sec: 10,
+        monitor_interval_sec: 30,
     }),
 };
 // ── DCA Presets ──

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

@@ -16,6 +16,7 @@ export class FundingArbStrategy {
                 { name: "max_positions", type: "number", required: false, default: 3, description: "Max concurrent positions" },
                 { name: "exchanges", type: "string", required: true, description: "Comma-separated exchange names" },
                 { name: "leverage", type: "number", required: false, default: 3, description: "Max leverage to use" },
+                { name: "min_hold_hours", type: "number", required: false, default: 2, description: "Min hold time before close (hours)" },
             ],
         };
     }
@@ -88,7 +89,7 @@ export class FundingArbStrategy {
                             const longEx = pA.side === "long" ? exA : exB;
                             const shortEx = pA.side === "short" ? exA : exB;
                             const size = pA.side === "long" ? pA.size : pB.size;
-                            recovered.push({ symbol: pA.symbol, longExchange: longEx, shortExchange: shortEx, entrySpread: 0, size, mode: "perp-perp" });
+                            recovered.push({ symbol: pA.symbol, longExchange: longEx, shortExchange: shortEx, entrySpread: 0, size, mode: "perp-perp", entryTime: 0 });
                             used.add(keyA);
                             used.add(keyB);
                             break;
@@ -135,7 +136,7 @@ export class FundingArbStrategy {
                         const spotBal = nonUsdc.find(b => b.token.toUpperCase().replace(/-SPOT$/, "") === base);
                         ctx.log(`  [ARB] ${name} perp ${perp.symbol}(${perp.side}) → base=${base}, spotMatch=${spotBal ? spotBal.token : "none"}`);
                         if (spotBal && perp.side === "short") {
-                            recovered.push({ symbol: base, longExchange: `${name}-spot`, shortExchange: name, entrySpread: 0, size: perp.size, mode: "spot-perp" });
+                            recovered.push({ symbol: base, longExchange: `${name}-spot`, shortExchange: name, entrySpread: 0, size: perp.size, mode: "spot-perp", entryTime: 0 });
                             used.add(perpKey);
                             ctx.log(`  [ARB] Detected spot-perp hedge: ${base} ${name}-spot↔${name}`);
                         }
@@ -189,9 +190,44 @@ export class FundingArbStrategy {
             ctx.log(`  [ARB] Need 2+ exchanges, have ${adapters.size}. Skipping.`);
             return [];
         }
-        // Fetch rates from all exchanges
-        const ratesByExchange = new Map();
+        // ── Pre-filter exchanges by margin availability ──
+        const exchangeBalances = new Map();
+        const availableAdapters = new Map();
         for (const [name, a] of adapters) {
+            try {
+                const bal = await a.getBalance();
+                const equity = parseFloat(bal.equity);
+                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) {
+                    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
+            }
+        }
+        // Determine which exchanges need rate fetching.
+        // When at max_positions we only need rates for exchanges that hold open positions
+        // (to evaluate close conditions). Exchanges with no positions can be skipped.
+        const atMaxPositions = openPositions.length >= (params.max_positions ?? 3);
+        const positionExchanges = new Set();
+        if (atMaxPositions) {
+            for (const p of openPositions) {
+                positionExchanges.add(p.longExchange.replace(/-spot$/i, ""));
+                positionExchanges.add(p.shortExchange);
+            }
+        }
+        const exchangesToScan = atMaxPositions
+            ? [...adapters].filter(([name]) => positionExchanges.has(name))
+            : [...adapters];
+        // Fetch rates — all exchanges if room for new positions, only position exchanges if full
+        const ratesByExchange = new Map();
+        for (const [name, a] of exchangesToScan) {
             const rates = await this.fetchRates(a, name);
             const map = new Map();
             for (const r of rates)
@@ -273,7 +309,10 @@ export class FundingArbStrategy {
                 signedSpread = (shortHourly - longHourly) * 8760 * 100;
             }
             // Close if funding flipped (losing money) or spread below close threshold
-            const shouldClose = signedSpread < 0 || signedSpread < params.close_spread;
+            const minHoldMs = (params.min_hold_hours ?? 2) * 60 * 60 * 1000;
+            const holdTime = pos.entryTime > 0 ? Date.now() - pos.entryTime : Infinity;
+            const isFundingFlipped = signedSpread < 0;
+            const shouldClose = isFundingFlipped || (holdTime >= minHoldMs && signedSpread < params.close_spread);
             if (shouldClose) {
                 // Cooldown: skip if close recently failed for this symbol
                 const closeKey = `${pos.symbol}:close`;
@@ -341,6 +380,7 @@ export class FundingArbStrategy {
         // ── Find new opportunities ──
         const arbPositions = ctx.state.get("arbOpenPositions").length;
         const exchangeNames = [...ratesByExchange.keys()];
+        const scanExchangeNames = exchangeNames.filter(n => availableAdapters.has(n));
         const opportunities = [];
         const allSymbols = new Set();
         for (const [, map] of ratesByExchange) {
@@ -352,7 +392,7 @@ export class FundingArbStrategy {
             let minHourly = Infinity, maxHourly = -Infinity;
             let minExchange = "", maxExchange = "";
             let minRate = 0, maxRate = 0;
-            for (const exName of exchangeNames) {
+            for (const exName of scanExchangeNames) {
                 const rateInfo = this.findRate(ratesByExchange, exName, sym);
                 if (!rateInfo)
                     continue;
@@ -438,7 +478,6 @@ export class FundingArbStrategy {
             if (arbPositions < params.max_positions) {
                 // Skip symbols already in open positions
                 const openSymbols = new Set(ctx.state.get("arbOpenPositions").map(p => p.symbol.toUpperCase()));
-                let skipMargin = 0;
                 let skipCooldown = 0;
                 for (const best of opportunities) {
                     if (openSymbols.has(best.symbol.toUpperCase()))
@@ -476,39 +515,24 @@ export class FundingArbStrategy {
                         ]);
                     }
                     catch { /* non-critical, some exchanges set leverage on order */ }
-                    // Balance + margin check
+                    // Balance + margin check (use pre-fetched balances from tick start)
                     let targetSizeUsd = params.size_usd;
-                    try {
-                        const [longBal, shortBal] = await Promise.all([
-                            longAdapter.getBalance(),
-                            shortAdapter.getBalance(),
-                        ]);
-                        // Check margin usage (skip if > 70%)
-                        const longEquity = parseFloat(longBal.equity);
-                        const shortEquity = parseFloat(shortBal.equity);
-                        const longMarginPct = longEquity > 0 ? parseFloat(longBal.marginUsed) / longEquity * 100 : 0;
-                        const shortMarginPct = shortEquity > 0 ? parseFloat(shortBal.marginUsed) / shortEquity * 100 : 0;
-                        if (longMarginPct > 70 || shortMarginPct > 70) {
-                            skipMargin++;
+                    const longBal = exchangeBalances.get(best.longExchange);
+                    const shortBal = exchangeBalances.get(best.shortExchange);
+                    if (!longBal || !shortBal)
+                        continue;
+                    const minAvail = Math.min(longBal.available, shortBal.available);
+                    const requiredMarginPerLeg = targetSizeUsd / leverage;
+                    if (minAvail < requiredMarginPerLeg) {
+                        // Try reducing size to what's affordable
+                        const maxAffordableNotional = minAvail * leverage * 0.8;
+                        if (maxAffordableNotional < 10) {
+                            ctx.log(`  [ARB] Skip ${best.symbol}: insufficient margin ($${minAvail.toFixed(2)} < $${requiredMarginPerLeg.toFixed(2)} at ${leverage}x)`);
                             continue;
                         }
-                        // Required margin per leg = sizeUsd / leverage
-                        const longAvail = parseFloat(longBal.available);
-                        const shortAvail = parseFloat(shortBal.available);
-                        const minAvail = Math.min(longAvail, shortAvail);
-                        const requiredMarginPerLeg = targetSizeUsd / leverage;
-                        if (minAvail < requiredMarginPerLeg) {
-                            // Try reducing size to what's affordable
-                            const maxAffordableNotional = minAvail * leverage * 0.8;
-                            if (maxAffordableNotional < 10) {
-                                ctx.log(`  [ARB] Skip ${best.symbol}: insufficient margin ($${minAvail.toFixed(2)} < $${requiredMarginPerLeg.toFixed(2)} needed at ${leverage}x)`);
-                                continue;
-                            }
-                            ctx.log(`  [ARB] Size reduced $${targetSizeUsd} → $${maxAffordableNotional.toFixed(0)} (limited by margin $${minAvail.toFixed(2)} at ${leverage}x)`);
-                            targetSizeUsd = Math.floor(maxAffordableNotional);
-                        }
+                        ctx.log(`  [ARB] Size reduced $${targetSizeUsd} → $${maxAffordableNotional.toFixed(0)} (limited by margin $${minAvail.toFixed(2)} at ${leverage}x)`);
+                        targetSizeUsd = Math.floor(maxAffordableNotional);
                     }
-                    catch { /* non-critical, proceed with original size */ }
                     // Liquidity check
                     const liq = await checkArbLiquidity(longAdapter, shortAdapter, best.symbol, targetSizeUsd, 0.5, (msg) => ctx.log(`  ${msg}`));
                     if (!liq.viable)
@@ -570,15 +594,19 @@ export class FundingArbStrategy {
                         ctx.log(`  [ARB] WARNING: Fill reconciliation failed: ${reconMsg}`);
                     }
                     // Verify both positions actually exist (catches instant liquidation)
-                    // Wait for cache to expire before checking (exchanges cache positions for ~5s)
-                    await new Promise(resolve => setTimeout(resolve, 6000));
+                    // Invalidate cache so getPositions returns fresh data
+                    const { invalidateCache } = await import("../../cache.js");
+                    invalidateCache("acct");
+                    await new Promise(resolve => setTimeout(resolve, 2000)); // brief wait for exchange settlement
                     try {
                         const [longPositions, shortPositions] = await Promise.all([
                             longAdapter.getPositions(),
                             shortAdapter.getPositions(),
                         ]);
-                        const longExists = longPositions.some(p => p.symbol.toUpperCase() === best.symbol.toUpperCase() && parseFloat(p.size) > 0);
-                        const shortExists = shortPositions.some(p => p.symbol.toUpperCase() === best.symbol.toUpperCase() && parseFloat(p.size) > 0);
+                        const symUpper = best.symbol.toUpperCase();
+                        const matchSymbol = (s) => { const u = s.toUpperCase(); return u === symUpper || u === symUpper + "-PERP" || u.replace(/-PERP$/, "") === symUpper; };
+                        const longExists = longPositions.some(p => matchSymbol(p.symbol) && parseFloat(p.size) > 0);
+                        const shortExists = shortPositions.some(p => matchSymbol(p.symbol) && parseFloat(p.size) > 0);
                         if (!longExists && !shortExists) {
                             // Both missing likely means cache issue — log warning but don't rollback
                             ctx.log(`  [ARB] Position verification: both sides not visible for ${best.symbol} (may be cache delay)`);
@@ -617,6 +645,7 @@ export class FundingArbStrategy {
                         entrySpread: best.spread,
                         size: matched.size,
                         mode: "perp-perp",
+                        entryTime: Date.now(),
                     });
                     ctx.state.set("arbOpenPositions", currentPositions);
                     ctx.state.set("arbPositions", currentPositions.length);
@@ -624,13 +653,8 @@ export class FundingArbStrategy {
                     return [{ type: "noop" }];
                 }
                 // Log skip summary only when there were skips (avoids noise when nothing happened)
-                if (skipMargin > 0 || skipCooldown > 0) {
-                    const parts = [];
-                    if (skipMargin > 0)
-                        parts.push(`${skipMargin} margin`);
-                    if (skipCooldown > 0)
-                        parts.push(`${skipCooldown} cooldown`);
-                    ctx.log(`  [ARB] Skipped ${skipMargin + skipCooldown} opportunities (${parts.join(", ")})`);
+                if (skipCooldown > 0) {
+                    ctx.log(`  [ARB] Skipped ${skipCooldown} opportunities (${skipCooldown} cooldown)`);
                 }
             }
         }
@@ -875,6 +899,7 @@ export class FundingArbStrategy {
                 entrySpread: opp.spread,
                 size: matched.size,
                 mode: "spot-perp",
+                entryTime: Date.now(),
             });
             ctx.state.set("arbOpenPositions", currentPositions);
             ctx.state.set("arbPositions", currentPositions.length);

package/dist/cache.d.ts

@@ -4,7 +4,7 @@
  * Dashboard and CLI share cached data via /tmp/perp-cli-cache/.
  * Writes are atomic (write to .tmp then rename) to prevent partial reads.
  */
-export declare const TTL_ACCOUNT = 5000;
+export declare const TTL_ACCOUNT = 15000;
 export declare const TTL_MARKET = 30000;
 export declare function getCached<T>(key: string): T | null;
 export declare function setCached<T>(key: string, data: T, ttlMs: number): void;

package/dist/cache.js

@@ -9,7 +9,7 @@ import { join } from "path";
 import { tmpdir } from "os";
 const CACHE_DIR = join(tmpdir(), "perp-cli-cache");
 // TTL presets
-export const TTL_ACCOUNT = 5_000; // 5s — balance, positions, orders
+export const TTL_ACCOUNT = 15_000; // 15s — balance, positions, orders (ticks are 30s; 15s ensures same-tick dedup)
 export const TTL_MARKET = 30_000; // 30s — funding rates, prices, markets
 let dirReady = false;
 function ensureDir() {

package/package.json

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