perp-cli 0.7.11 → 0.7.13

package/dist/bot/engine.js

@@ -152,22 +152,6 @@ mode = "headless") {
             try {
                 // Get market data (enriched for strategy use)
                 const snapshot = await getEnrichedSnapshot(adapter, config.symbol);
-                // Update equity
-                try {
-                    const bal = await adapter.getBalance();
-                    state.equity = parseFloat(bal.equity);
-                    if (state.equity > state.peakEquity)
-                        state.peakEquity = state.equity;
-                    // Reset daily baseline at day boundary
-                    const today = new Date().toISOString().slice(0, 10);
-                    if (today !== state.dailyStartDate) {
-                        state.dailyStartEquity = state.equity;
-                        state.dailyStartDate = today;
-                    }
-                    state.dailyPnl = state.equity - state.dailyStartEquity;
-                    state.totalPnl = state.equity - state.initialEquity;
-                }
-                catch { /* non-critical */ }
                 const context = {
                     equity: state.equity,
                     startTime: state.startTime,
@@ -258,18 +242,41 @@ mode = "headless") {
                         effectiveLog(`  Exit condition met, returning to monitoring...`);
                     }
                 }
-                // ── Emit state update for TUI / JSON ──
+                // ── Fetch balances + emit state update for TUI / JSON ──
                 const [positions, openOrders, exchangeBalances] = await Promise.all([
                     extraAdapters ? fetchAllPositions(adapter, config.symbol, extraAdapters) : fetchPositions(adapter, config.symbol, adapter.name),
                     fetchOpenOrders(adapter, config.symbol),
-                    extraAdapters ? fetchExchangeBalances(adapter, extraAdapters) : Promise.resolve(undefined),
+                    fetchExchangeBalances(adapter, extraAdapters),
                 ]);
-                const tuiState = buildTuiState(state, config, snapshot, positions, openOrders, strategyCtx, exchangeBalances);
-                if (mode === "tui") {
-                    tuiEmitter.emitState(tuiState);
+                // Update equity using the already-fetched balance (avoids a redundant getBalance() call)
+                try {
+                    const primaryBal = exchangeBalances.find(b => b.exchange === adapter.name);
+                    if (primaryBal) {
+                        state.equity = parseFloat(primaryBal.equity);
+                        if (state.equity > state.peakEquity)
+                            state.peakEquity = state.equity;
+                        // Reset daily baseline at day boundary
+                        const today = new Date().toISOString().slice(0, 10);
+                        if (today !== state.dailyStartDate) {
+                            state.dailyStartEquity = state.equity;
+                            state.dailyStartDate = today;
+                        }
+                        state.dailyPnl = state.equity - state.dailyStartEquity;
+                        state.totalPnl = state.equity - state.initialEquity;
+                    }
                 }
-                else if (mode === "json") {
-                    console.log(JSON.stringify(tuiState));
+                catch { /* non-critical */ }
+                if (mode === "tui" || mode === "json") {
+                    const tuiState = buildTuiState(state, config, snapshot, positions, openOrders, strategyCtx, exchangeBalances);
+                    if (mode === "tui") {
+                        tuiEmitter.emitState(tuiState);
+                    }
+                    else {
+                        console.log(JSON.stringify(tuiState));
+                    }
+                }
+                else {
+                    effectiveLog(`  tick: phase=${state.phase} equity=$${state.equity.toFixed(2)}`);
                 }
                 // Update job state
                 if (jobId) {

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

@@ -26,6 +26,9 @@ export class FundingArbStrategy {
         ctx.state.set("arbRunning", true);
         ctx.state.set("arbOpenPositions", []);
         ctx.state.set("arbPositions", 0);
+        ctx.state.set("fundingIncome", 0);
+        ctx.state.set("fundingLastCheck", Date.now());
+        ctx.state.set("fundingHistory", []);
         ctx.log(`  [ARB] Funding arb ready | spread >= ${params.min_spread}% | close < ${params.close_spread}% | size $${params.size_usd}`);
         ctx.log(`  [ARB] Exchanges: ${params.exchanges.join(", ")}`);
     }
@@ -54,6 +57,41 @@ export class FundingArbStrategy {
                 map.set(r.symbol.toUpperCase(), { rate: r.rate, price: r.price });
             ratesByExchange.set(name, map);
         }
+        // ── Fetch funding income periodically (every 5 minutes) ──
+        const lastCheck = ctx.state.get("fundingLastCheck");
+        if (openPositions.length > 0 && Date.now() - lastCheck > 5 * 60 * 1000) {
+            try {
+                let totalFunding = 0;
+                for (const [name, a] of adapters) {
+                    try {
+                        const payments = await a.getFundingPayments(50);
+                        const startTime = ctx.state.get("fundingLastCheck");
+                        const recent = payments.filter(p => p.timestamp > startTime - 5 * 60 * 1000);
+                        const sum = recent.reduce((s, p) => s + parseFloat(p.amount), 0);
+                        totalFunding += sum;
+                        if (Math.abs(sum) > 0.001) {
+                            ctx.log(`  [FUND] ${name}: $${sum.toFixed(4)} funding received`);
+                        }
+                    }
+                    catch { /* not all adapters support this */ }
+                }
+                const prev = ctx.state.get("fundingIncome");
+                ctx.state.set("fundingIncome", prev + totalFunding);
+                ctx.state.set("fundingLastCheck", Date.now());
+            }
+            catch { /* non-critical */ }
+        }
+        // ── Update strategy state for TUI display ──
+        const arbPosForDisplay = openPositions.map(p => {
+            const longRate = ratesByExchange.get(p.longExchange)?.get(p.symbol)?.rate;
+            const shortRate = ratesByExchange.get(p.shortExchange)?.get(p.symbol)?.rate;
+            const spread = (longRate !== undefined && shortRate !== undefined)
+                ? computeAnnualSpread(shortRate, p.shortExchange, longRate, p.longExchange)
+                : 0;
+            return `${p.symbol} ${p.longExchange}↔${p.shortExchange} ${spread.toFixed(1)}%`;
+        });
+        ctx.state.set("arbPositionDetails", arbPosForDisplay);
+        ctx.state.set("fundingTotal", `$${ctx.state.get("fundingIncome").toFixed(4)}`);
         // ── Check existing positions for close_spread ──
         const toClose = [];
         for (const pos of openPositions) {

package/dist/exchanges/aster.d.ts

@@ -12,6 +12,9 @@ export declare class AsterAdapter implements ExchangeAdapter {
     private _apiSecret;
     private _baseUrl;
     private _testnet;
+    private _marketsCache;
+    private _marketsCacheTime;
+    private static readonly CACHE_TTL;
     constructor(apiKey?: string, apiSecret?: string, testnet?: boolean);
     get isReadOnly(): boolean;
     /** CLI symbol → Aster API symbol (ETH → ETHUSDT) */
@@ -55,6 +58,8 @@ export declare class AsterAdapter implements ExchangeAdapter {
         routeType?: number;
     }): Promise<unknown>;
     private _sign;
+    /** Handle 429 rate limit with retry */
+    private _handleResponse;
     private _publicGet;
     private _signedGet;
     private _signedPost;

package/dist/exchanges/aster.js

@@ -12,6 +12,9 @@ export class AsterAdapter {
     _apiSecret;
     _baseUrl;
     _testnet;
+    _marketsCache = null;
+    _marketsCacheTime = 0;
+    static CACHE_TTL = 30_000; // 30 seconds
     constructor(apiKey, apiSecret, testnet = false) {
         this._apiKey = apiKey || process.env.ASTER_API_KEY || "";
         this._apiSecret = apiSecret || process.env.ASTER_API_SECRET || "";
@@ -40,6 +43,10 @@ export class AsterAdapter {
     }
     // ── Market Data ──
     async getMarkets() {
+        // Return cached result if fresh
+        if (this._marketsCache && Date.now() - this._marketsCacheTime < AsterAdapter.CACHE_TTL) {
+            return this._marketsCache;
+        }
         const [info, tickers] = await Promise.all([
             this._publicGet("/fapi/v1/exchangeInfo"),
             this._publicGet("/fapi/v1/ticker/24hr"),
@@ -57,28 +64,12 @@ export class AsterAdapter {
         catch { /* non-critical */ }
         const tradingSymbols = (info?.symbols ?? [])
             .filter((s) => String(s.contractType) === "PERPETUAL" && String(s.status) === "TRADING");
-        // Fetch open interest per symbol in parallel (batched to avoid overwhelming the API).
-        // The /fapi/v1/ticker/24hr response does NOT include openInterest — need a separate endpoint.
-        const oiMap = new Map();
-        const OI_BATCH = 20;
-        for (let i = 0; i < tradingSymbols.length; i += OI_BATCH) {
-            const batch = tradingSymbols.slice(i, i + OI_BATCH);
-            const results = await Promise.allSettled(batch.map(async (s) => {
-                const sym = String(s.symbol);
-                const res = await this._publicGet("/fapi/v1/openInterest", { symbol: sym });
-                return { sym, oi: String(res?.openInterest ?? "0") };
-            }));
-            for (const r of results) {
-                if (r.status === "fulfilled")
-                    oiMap.set(r.value.sym, r.value.oi);
-            }
-        }
-        return tradingSymbols
+        // OI is fetched lazily per symbol (see getMarketInfo) to avoid 300+ API calls
+        const result = tradingSymbols
             .map((s) => {
             const sym = String(s.symbol);
             const ticker = tickerMap.get(sym);
             const premium = premiumMap.get(sym);
-            // Extract max leverage from leverage brackets if available
             const maxLev = Number(s.maxLeverage ?? 50);
             return {
                 symbol: this._fromApi(sym),
@@ -86,10 +77,13 @@ export class AsterAdapter {
                 indexPrice: String(premium?.indexPrice ?? "0"),
                 fundingRate: String(premium?.lastFundingRate ?? "0"),
                 volume24h: String(ticker?.quoteVolume ?? ticker?.volume ?? "0"),
-                openInterest: oiMap.get(sym) ?? "0",
+                openInterest: "0",
                 maxLeverage: maxLev,
             };
         });
+        this._marketsCache = result;
+        this._marketsCacheTime = Date.now();
+        return result;
     }
     async getOrderbook(symbol) {
         const res = await this._publicGet("/fapi/v1/depth", { symbol: this._toApi(symbol), limit: "50" });
@@ -359,62 +353,82 @@ export class AsterAdapter {
             .digest("hex");
         return `${queryString}&signature=${signature}`;
     }
+    /** Handle 429 rate limit with retry */
+    async _handleResponse(res, method, path, attempt = 0) {
+        if (res.status === 429) {
+            if (attempt >= 2)
+                throw new Error(`${method} ${path} rate limited after ${attempt + 1} attempts`);
+            const retryAfter = parseInt(res.headers.get("Retry-After") || "5", 10);
+            const waitMs = Math.min(retryAfter * 1000, 30000);
+            await new Promise(r => setTimeout(r, waitMs));
+            return null; // signal retry
+        }
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`${method} ${path} failed (${res.status}): ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
     async _publicGet(path, params = {}) {
         const qs = Object.entries(params)
             .map(([k, v]) => `${k}=${encodeURIComponent(v)}`)
             .join("&");
         const url = `${this._baseUrl}${path}${qs ? `?${qs}` : ""}`;
-        const res = await fetch(url);
-        if (!res.ok) {
-            const text = await res.text();
-            throw new Error(`GET ${path} failed (${res.status}): ${text.slice(0, 200)}`);
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const res = await fetch(url);
+            const result = await this._handleResponse(res, "GET", path, attempt);
+            if (result !== null)
+                return result;
         }
-        return res.json();
+        throw new Error(`GET ${path} failed: max retries exceeded`);
     }
     async _signedGet(path, params = {}) {
         if (this.isReadOnly)
             throw new Error("No API key configured for Aster. Set ASTER_API_KEY and ASTER_API_SECRET in ~/.perp/.env");
-        const signed = this._sign({ ...params });
-        const url = `${this._baseUrl}${path}?${signed}`;
-        const res = await fetch(url, {
-            headers: { "X-MBX-APIKEY": this._apiKey },
-        });
-        if (!res.ok) {
-            const text = await res.text();
-            throw new Error(`GET ${path} failed (${res.status}): ${text.slice(0, 200)}`);
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const signed = this._sign({ ...params });
+            const url = `${this._baseUrl}${path}?${signed}`;
+            const res = await fetch(url, {
+                headers: { "X-MBX-APIKEY": this._apiKey },
+            });
+            const result = await this._handleResponse(res, "GET", path, attempt);
+            if (result !== null)
+                return result;
         }
-        return res.json();
+        throw new Error(`GET ${path} failed: max retries exceeded`);
     }
     async _signedPost(path, params = {}) {
         if (this.isReadOnly)
             throw new Error("No API key configured for Aster. Set ASTER_API_KEY and ASTER_API_SECRET in ~/.perp/.env");
-        const signed = this._sign({ ...params });
-        const res = await fetch(`${this._baseUrl}${path}`, {
-            method: "POST",
-            headers: {
-                "X-MBX-APIKEY": this._apiKey,
-                "Content-Type": "application/x-www-form-urlencoded",
-            },
-            body: signed,
-        });
-        if (!res.ok) {
-            const text = await res.text();
-            throw new Error(`POST ${path} failed (${res.status}): ${text.slice(0, 200)}`);
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const signed = this._sign({ ...params });
+            const res = await fetch(`${this._baseUrl}${path}`, {
+                method: "POST",
+                headers: {
+                    "X-MBX-APIKEY": this._apiKey,
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: signed,
+            });
+            const result = await this._handleResponse(res, "POST", path, attempt);
+            if (result !== null)
+                return result;
         }
-        return res.json();
+        throw new Error(`POST ${path} failed: max retries exceeded`);
     }
     async _signedDelete(path, params = {}) {
         if (this.isReadOnly)
             throw new Error("No API key configured for Aster. Set ASTER_API_KEY and ASTER_API_SECRET in ~/.perp/.env");
-        const signed = this._sign({ ...params });
-        const res = await fetch(`${this._baseUrl}${path}?${signed}`, {
-            method: "DELETE",
-            headers: { "X-MBX-APIKEY": this._apiKey },
-        });
-        if (!res.ok) {
-            const text = await res.text();
-            throw new Error(`DELETE ${path} failed (${res.status}): ${text.slice(0, 200)}`);
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const signed = this._sign({ ...params });
+            const res = await fetch(`${this._baseUrl}${path}?${signed}`, {
+                method: "DELETE",
+                headers: { "X-MBX-APIKEY": this._apiKey },
+            });
+            const result = await this._handleResponse(res, "DELETE", path, attempt);
+            if (result !== null)
+                return result;
         }
-        return res.json();
+        throw new Error(`DELETE ${path} failed: max retries exceeded`);
     }
 }

package/dist/exchanges/hyperliquid.d.ts

@@ -16,6 +16,9 @@ export declare class HyperliquidAdapter implements ExchangeAdapter {
     /** HIP-3 deployed perp dex name. Empty string = native (validator) perps. */
     private _dex;
     private static _lastNonce;
+    private _marketsCache;
+    private _marketsCacheTime;
+    private static readonly CACHE_TTL;
     constructor(privateKey?: string, testnet?: boolean);
     /** Set the HIP-3 deployed perp dex to query/trade on. */
     setDex(dex: string): void;
@@ -44,7 +47,7 @@ export declare class HyperliquidAdapter implements ExchangeAdapter {
         asks: [string, string][];
     }>;
     private ensureAddress;
-    /** Always fetches live clearinghouseState, writes result to shared cache for dashboard */
+    /** Read-through cached clearinghouseState — returns cached data if fresh */
     private _getClearinghouseState;
     /** Cached spot clearinghouse state — shared between getBalance() and HyperliquidSpotAdapter */
     _getSpotClearinghouseState(): Promise<Record<string, unknown>>;

package/dist/exchanges/hyperliquid.js

@@ -15,7 +15,9 @@ export class HyperliquidAdapter {
     /** HIP-3 deployed perp dex name. Empty string = native (validator) perps. */
     _dex = "";
     static _lastNonce = 0;
-    // In-memory cache removed — using file-based cache (src/cache.ts) for cross-process dedup
+    _marketsCache = null;
+    _marketsCacheTime = 0;
+    static CACHE_TTL = 30_000;
     constructor(privateKey, testnet = false) {
         // Disable WebSocket in SDK — we use REST for all info calls and raw
         // fetch for /exchange. This avoids the false "Please install ws" warning
@@ -181,6 +183,8 @@ export class HyperliquidAdapter {
         throw new Error(`Unknown asset: ${symbol}`);
     }
     async getMarkets() {
+        if (this._marketsCache && Date.now() - this._marketsCacheTime < HyperliquidAdapter.CACHE_TTL)
+            return this._marketsCache;
         let universe;
         let ctxs;
         let mids = {};
@@ -207,7 +211,7 @@ export class HyperliquidAdapter {
                 this._assetMapReverse.set(i, sym);
             });
         }
-        return universe.map((asset, i) => {
+        const result = universe.map((asset, i) => {
             const ctx = (ctxs[i] ?? {});
             const sym = String(asset.name);
             return {
@@ -220,6 +224,9 @@ export class HyperliquidAdapter {
                 maxLeverage: Number(asset.maxLeverage ?? 50),
             };
         });
+        this._marketsCache = result;
+        this._marketsCacheTime = Date.now();
+        return result;
     }
     async getOrderbook(symbol) {
         let levels;
@@ -256,12 +263,12 @@ export class HyperliquidAdapter {
             throw new Error("No private key configured — account data unavailable. Run: perp setup");
         }
     }
-    /** Always fetches live clearinghouseState, writes result to shared cache for dashboard */
+    /** Read-through cached clearinghouseState — returns cached data if fresh */
     async _getClearinghouseState() {
         this.ensureAddress();
-        const { fetchAndCache, TTL_ACCOUNT } = await import("../cache.js");
+        const { withCache, TTL_ACCOUNT } = await import("../cache.js");
         const key = this._dex ? `acct:hl:chs:${this._address}:${this._dex}` : `acct:hl:chs:${this._address}`;
-        return fetchAndCache(key, TTL_ACCOUNT, async () => {
+        return withCache(key, TTL_ACCOUNT, async () => {
             const state = this._dex
                 ? await this._infoPost({ type: "clearinghouseState", user: this._address, dex: this._dex })
                 : await this.sdk.info.perpetuals.getClearinghouseState(this._address);

package/dist/exchanges/lighter.d.ts

@@ -20,6 +20,9 @@ export declare class LighterAdapter implements ExchangeAdapter {
     private _testnet;
     private _readOnly;
     private _evmSigner?;
+    private _marketsCache;
+    private _marketsCacheTime;
+    private static readonly CACHE_TTL;
     /**
      * @param evmKey    EVM private key (0x-prefixed, 32 bytes) — for deposits & key registration
      * @param testnet   Use testnet (chain ID 300) instead of mainnet (chain ID 304)

package/dist/exchanges/lighter.js

@@ -18,7 +18,9 @@ export class LighterAdapter {
     _testnet;
     _readOnly;
     _evmSigner;
-    // In-memory cache removed — using file-based cache (src/cache.ts) for cross-process dedup
+    _marketsCache = null;
+    _marketsCacheTime = 0;
+    static CACHE_TTL = 30_000;
     /**
      * @param evmKey    EVM private key (0x-prefixed, 32 bytes) — for deposits & key registration
      * @param testnet   Use testnet (chain ID 300) instead of mainnet (chain ID 304)
@@ -260,6 +262,8 @@ export class LighterAdapter {
         return { baseAmount, priceTicks };
     }
     async getMarkets() {
+        if (this._marketsCache && Date.now() - this._marketsCacheTime < LighterAdapter.CACHE_TTL)
+            return this._marketsCache;
         const markets = [];
         try {
             const res = await this.restGet("/orderBookDetails", {});
@@ -281,13 +285,15 @@ export class LighterAdapter {
             }
         }
         catch { /* non-critical */ }
+        this._marketsCache = markets;
+        this._marketsCacheTime = Date.now();
         return markets;
     }
     async fetchAccount() {
         if (!this._address)
             return null;
-        const { fetchAndCache, TTL_ACCOUNT } = await import("../cache.js");
-        return fetchAndCache(`acct:lt:account:${this._address}`, TTL_ACCOUNT, async () => {
+        const { withCache, TTL_ACCOUNT } = await import("../cache.js");
+        return withCache(`acct:lt:account:${this._address}`, TTL_ACCOUNT, async () => {
             const res = await this.restGet("/account", {
                 by: "l1_address",
                 value: this._address,

package/dist/exchanges/pacifica.d.ts

@@ -11,6 +11,9 @@ export declare class PacificaAdapter implements ExchangeAdapter {
     private _hasRealKey;
     private account;
     private signMessage;
+    private _marketsCache;
+    private _marketsCacheTime;
+    private static readonly CACHE_TTL;
     constructor(keypair: Keypair, network?: Network, builderCode?: string, hasRealKey?: boolean);
     private ensureSigner;
     /** Inject an external Solana signer. */

package/dist/exchanges/pacifica.js

@@ -9,7 +9,9 @@ export class PacificaAdapter {
     _hasRealKey;
     account;
     signMessage;
-    // In-memory caches removed — using file-based cache (src/cache.ts) for cross-process dedup
+    _marketsCache = null;
+    _marketsCacheTime = 0;
+    static CACHE_TTL = 30_000;
     constructor(keypair, network = "mainnet", builderCode, hasRealKey = true) {
         this._solanaSigner = new LocalSolanaSigner(keypair);
         this._hasRealKey = hasRealKey;
@@ -36,12 +38,12 @@ export class PacificaAdapter {
         throw new Error("keypair not available with external signer");
     }
     async _getPrices() {
-        const { fetchAndCache, TTL_ACCOUNT } = await import("../cache.js");
-        return fetchAndCache(`acct:pac:prices:${this.account.slice(0, 8)}`, TTL_ACCOUNT, () => this.client.getPrices());
+        const { withCache, TTL_ACCOUNT } = await import("../cache.js");
+        return withCache(`acct:pac:prices:${this.account.slice(0, 8)}`, TTL_ACCOUNT, () => this.client.getPrices());
     }
     async _getPositions() {
-        const { fetchAndCache, TTL_ACCOUNT } = await import("../cache.js");
-        return fetchAndCache(`acct:pac:positions:${this.account.slice(0, 8)}`, TTL_ACCOUNT, () => this.client.getPositions(this.account));
+        const { withCache, TTL_ACCOUNT } = await import("../cache.js");
+        return withCache(`acct:pac:positions:${this.account.slice(0, 8)}`, TTL_ACCOUNT, () => this.client.getPositions(this.account));
     }
     get publicKey() {
         return this.account;
@@ -53,12 +55,14 @@ export class PacificaAdapter {
         return this.signMessage;
     }
     async getMarkets() {
+        if (this._marketsCache && Date.now() - this._marketsCacheTime < PacificaAdapter.CACHE_TTL)
+            return this._marketsCache;
         const [markets, prices] = await Promise.all([
             this.client.getInfo(),
             this._getPrices(),
         ]);
         const priceMap = new Map(prices.map((p) => [p.symbol, p]));
-        return markets.map((m) => {
+        const result = markets.map((m) => {
             const p = priceMap.get(m.symbol);
             return {
                 symbol: m.symbol,
@@ -70,6 +74,9 @@ export class PacificaAdapter {
                 maxLeverage: m.max_leverage,
             };
         });
+        this._marketsCache = result;
+        this._marketsCacheTime = Date.now();
+        return result;
     }
     async getOrderbook(symbol) {
         const book = await this.client.getBook(symbol);

package/package.json

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