perp-cli 0.7.39 → 0.7.43

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

@@ -190,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)
@@ -296,7 +331,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 } });
                         }
@@ -307,9 +342,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) {
@@ -320,6 +355,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) {
@@ -345,6 +381,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) {
@@ -356,7 +393,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;
@@ -442,7 +479,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()))
@@ -480,39 +516,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)
@@ -550,7 +571,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 });
                         }
@@ -574,8 +595,10 @@ 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(),
@@ -595,14 +618,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 */ }
@@ -631,13 +654,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)`);
                 }
             }
         }
@@ -666,7 +684,7 @@ export class FundingArbStrategy {
                     if (longAdapter && shortAdapter) {
                         ctx.log(`  [ARB] Closing ${pos.symbol} on stop (${pos.size})`);
                         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 } });
                         }
                         catch (err) {
@@ -675,7 +693,7 @@ export class FundingArbStrategy {
                             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 } });
                         }
                         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 } });
                         }
                         catch (err) {
@@ -741,7 +759,7 @@ export class FundingArbStrategy {
             // Step 3: Close perp short
             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}`);
             }
             catch (err) {

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/dist/exchanges/aster.d.ts

@@ -44,7 +44,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

@@ -283,14 +283,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.39",
+  "version": "0.7.43",
   "description": "Multi-DEX Perpetual Futures CLI - Pacifica, Hyperliquid, Lighter, Aster",
   "bin": {
     "perp": "dist/index.js",