perp-cli 0.14.1 → 0.14.3

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

@@ -110,6 +110,23 @@ export function findRate(ratesByExchange, exchange, symbol) {
     const upper = symbol.toUpperCase();
     return map.get(upper) ?? map.get(upper + "-PERP") ?? map.get(upper.replace(/-PERP$/, ""));
 }
+/**
+ * Leverage for an entry: the configured value, capped by every leg's published max.
+ * A leg whose max is unpublished (undefined) is not a cap — the venue enforces its own
+ * limit on setLeverage / the order — and `logUnknown` names it, so it is never read as 1x.
+ */
+export function cappedLeverage(configured, legs, logUnknown) {
+    let leverage = configured;
+    for (const leg of legs) {
+        if (leg.maxLeverage === undefined) {
+            logUnknown(`  [LEV] ${leg.exchange} does not publish a max leverage — using ${configured}x; the venue enforces its cap`);
+        }
+        else {
+            leverage = Math.min(leverage, leg.maxLeverage);
+        }
+    }
+    return leverage;
+}
 /** Match a symbol against a target, accounting for -PERP suffix variations. */
 export function matchSymbol(s, target) {
     const u = s.toUpperCase();
@@ -165,32 +182,33 @@ async function marketFundingHours(adapter, exchangeName, symbol) {
     }
     return getFundingHours(exchangeName);
 }
-/** Score a symbol's funding rate using history. Returns null if insufficient data. */
+/**
+ * Score a symbol's funding rate using history. null = not enough data (fewer than 2 history
+ * points, or the per-symbol funding basis is unknown). A failed read THROWS — callers must not
+ * mistake a 429 / timeout for "history too thin".
+ */
 export async function scoreFunding(adapter, symbol, exchangeName, periods, cache) {
     const key = `${exchangeName}:${symbol}`;
     const cached = cache?.get(key);
     if (cached && Date.now() - cached.ts < 10 * 60 * 1000)
         return cached.score;
-    // Outside the try: an unknown venue is a configuration error, not "no score".
     const venueHours = hasPerSymbolFundingHours(adapter) ? null : getFundingHours(exchangeName);
-    try {
-        const fH = venueHours !== null ? venueHours : await marketFundingHours(adapter, exchangeName, symbol);
-        if (fH === null)
-            return null; // per-symbol basis unknown — the hourly rate would be a guess
-        const history = await adapter.getFundingHistory(symbol, periods);
-        if (history.length < 2)
-            return null;
-        const rates = history.map(h => parseFloat(h.rate));
-        const avgRate = rates.reduce((s, r) => s + r, 0) / rates.length;
-        const consistency = rates.filter(r => r > 0).length / rates.length;
-        const annualized = annualizeHourlyRate(avgRate / fH);
-        const score = { symbol, exchange: exchangeName, avgRate, consistency, annualized, payments: rates.length };
-        cache?.set(key, { score, ts: Date.now() });
-        return score;
-    }
-    catch {
+    const fH = venueHours !== null ? venueHours : await marketFundingHours(adapter, exchangeName, symbol);
+    if (fH === null)
+        return null; // per-symbol basis unknown — the hourly rate would be a guess
+    const history = await adapter.getFundingHistory(symbol, periods);
+    if (history.length < 2)
         return null;
+    const rates = history.map(h => parseFloat(h.rate));
+    if (rates.some(r => !Number.isFinite(r))) {
+        throw new PerpError("EXCHANGE_ERROR", `${exchangeName} ${symbol}: funding history has a non-numeric rate`, { exchange: exchangeName });
     }
+    const avgRate = rates.reduce((s, r) => s + r, 0) / rates.length;
+    const consistency = rates.filter(r => r > 0).length / rates.length;
+    const annualized = annualizeHourlyRate(avgRate / fH);
+    const score = { symbol, exchange: exchangeName, avgRate, consistency, annualized, payments: rates.length };
+    cache?.set(key, { score, ts: Date.now() });
+    return score;
 }
 /**
  * Fetch funding rates from an exchange adapter. Failures propagate — callers
@@ -207,6 +225,7 @@ export async function fetchRates(adapter, exchangeName) {
             continue;
         m.fundingHours = await marketFundingHours(adapter, exchangeName, m.symbol);
     }
+    // maxLeverage undefined = not published by the venue (callers cap by published maxes only — see cappedLeverage).
     const result = [];
     for (const m of withRates) {
         // Skip aster symbols with unknown funding period — the hourly rate would be a guess.
@@ -221,7 +240,7 @@ export async function fetchRates(adapter, exchangeName) {
             rate: parseFloat(m.fundingRate),
             price: parseFloat(m.markPrice),
             sizeDecimals: m.sizeDecimals,
-            maxLeverage: m.maxLeverage,
+            maxLeverage: m.maxLeverage ?? undefined,
             fundingHours: m.fundingHours,
         });
     }
@@ -249,3 +268,47 @@ export async function cancelBotSymbols(adapters, symbols, tag, log) {
     }
     log(`  ${tag} Cancel requested for ${[...symbols].join(", ")} on ${[...adapters.keys()].join(", ")}`);
 }
+/** Venues whose funding history is CAPABILITY_UNSUPPORTED, already reported once (collectFundingSince). */
+const _fundingUnsupportedLogged = new Set();
+/**
+ * Books settled funding not yet booked (shared by the funding-arb and spot-perp bots).
+ * `since[venue]` is a per-venue HIGH-WATER MARK of the newest payment time already booked
+ * (initially `defaultStart`, the bot's start — recovery booked the 24 h before it): only payments
+ * strictly newer are summed, so consecutive reads never count a payment twice. A venue whose read
+ * fails keeps its mark and is re-read next time; the others are booked — one failure never drops
+ * or blocks the rest, and a failed read is never counted as 0. When a catching-up read returns a
+ * full page whose oldest row is still newer than the mark, older payments may be beyond the page
+ * and a warning is logged. `since` is mutated in place.
+ */
+export async function collectFundingSince(adapters, since, defaultStart, log) {
+    const PAGE = 50;
+    let total = 0;
+    const failed = [];
+    for (const [name, a] of adapters) {
+        try {
+            const payments = await a.getFundingPayments(PAGE);
+            const mark = since[name] ?? defaultStart;
+            const fresh = payments.filter(fp => fp.time > mark);
+            const sum = fresh.reduce((s, fp) => s + parseFloat(fp.payment), 0);
+            total += sum;
+            since[name] = fresh.reduce((m, fp) => Math.max(m, fp.time), mark);
+            if (payments.length >= PAGE && fresh.length === payments.length) {
+                log(`  [FUND] ${name}: ${PAGE} unbooked payments in one read — older ones since the last booked payment may be missing from fundingIncome`);
+            }
+            if (Math.abs(sum) > 0.001)
+                log(`  [FUND] ${name}: $${sum.toFixed(4)} funding`);
+        }
+        catch (e) {
+            failed.push(name);
+            // A venue that does not offer funding history at all (QFEX: CAPABILITY_UNSUPPORTED) is said
+            // once per process; a read failure is logged every time.
+            const unsupported = e instanceof PerpError && e.structured.code === "CAPABILITY_UNSUPPORTED";
+            if (!unsupported || !_fundingUnsupportedLogged.has(name)) {
+                log(`  [FUND] ${name}: ${unsupported ? "funding history not supported — its funding is not counted" : "funding history unavailable (re-read next check)"}: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            if (unsupported)
+                _fundingUnsupportedLogged.add(name);
+        }
+    }
+    return { total, failed };
+}

package/dist/bot/strategies/funding-auto.js

@@ -54,16 +54,22 @@ class FundingAutoStrategy {
     get defaultFeeRate() { return Number(this._config.defaultFeeRate ?? 0.0005); }
     get defaultSlippage() { return Number(this._config.defaultSlippage ?? 0.001); }
     get scanIntervalTicks() { return Number(this._config.scanIntervalTicks ?? 1); }
-    /** Position size: min of sizeUsd (if set) and maxCapitalPct% of total equity */
-    _cachedEquity = 0;
+    /** Total equity across all venues, read this tick; null = some venue's balance is unknown. */
+    _cachedEquity = null;
+    /**
+     * Position size: min of sizeUsd (if set) and maxCapitalPct% of total equity. null = cannot be
+     * sized (equity unknown, or no capital and no sizeUsd) — no entry, never a substituted size.
+     */
     getSizeUsd() {
+        if (this._cachedEquity === null)
+            return null;
         const fixedSize = Number(this._config.sizeUsd ?? 0);
         const capitalLimit = this._cachedEquity * (this.maxCapitalPct / 100);
         if (fixedSize > 0 && capitalLimit > 0)
             return Math.min(fixedSize, capitalLimit);
         if (capitalLimit > 0)
             return capitalLimit;
-        return fixedSize > 0 ? fixedSize : 100; // fallback
+        return null;
     }
     describe() {
         return {
@@ -96,22 +102,27 @@ class FundingAutoStrategy {
         ctx.log(`[funding-auto] Starting (perp-perp only; spot-perp mode is not supported by this strategy)`);
     }
     async onTick(ctx, _snapshot) {
-        // Cache total equity across ALL exchanges for capital-based sizing
-        try {
-            const adapters = this.getAdapters(ctx);
-            let totalEquity = 0;
-            for (const [, adapter] of adapters) {
-                try {
-                    const bal = await adapter.getBalance();
-                    totalEquity += Number(bal.equity) || 0;
-                }
-                catch { /* skip */ }
-            }
-            this._cachedEquity = totalEquity > 0 ? totalEquity : this._cachedEquity;
-        }
-        catch { /* keep previous cached value */ }
         // Get all adapters
         const adapters = this.getAdapters(ctx);
+        // Total equity across ALL exchanges for capital-based sizing, read fresh every tick.
+        // Any unknown balance → equity unknown (null): no new entry is sized this tick (never a
+        // stale value, a venue counted as $0, or a substituted size).
+        let totalEquity = 0;
+        for (const [name, adapter] of adapters) {
+            try {
+                const bal = await adapter.getBalance();
+                const eq = Number(bal.equity);
+                if (!Number.isFinite(eq))
+                    throw new Error(`equity "${bal.equity}" is not a number`);
+                if (totalEquity !== null)
+                    totalEquity += eq;
+            }
+            catch (e) {
+                totalEquity = null;
+                ctx.log(`[funding-auto] ${name} balance unreadable (${e instanceof Error ? e.message : String(e)}) — equity unknown, no new entries this tick`);
+            }
+        }
+        this._cachedEquity = totalEquity;
         if (adapters.size < 2) {
             ctx.log(`[funding-auto] Need 2+ exchanges, have ${adapters.size}. Skipping.`);
             return [];
@@ -123,6 +134,8 @@ class FundingAutoStrategy {
         // Fetch funding rates from all exchanges (price data cached for position sizing)
         const ratesByExchange = new Map();
         const priceCache = new Map(); // "exchange:symbol" -> price
+        // Venues whose markets could not be read this tick: no open / close decision touches them.
+        const ratesUnavailable = new Set();
         for (const [name, adapter] of adapters) {
             try {
                 const markets = await adapter.getMarkets();
@@ -144,17 +157,19 @@ class FundingAutoStrategy {
                 }
                 ratesByExchange.set(name, map);
             }
-            catch {
-                // Skip unavailable exchange
+            catch (e) {
+                ratesUnavailable.add(name);
+                ctx.log(`[funding-auto] ${name} markets unreadable (${e instanceof Error ? e.message : String(e)}) — no open / close decision on ${name} this tick`);
             }
         }
         // Store priceCache for use by openPosition/closePosition
         ctx.state.set("priceCache", priceCache);
         // Calculate notional for discovered positions (using current price)
+        // (unknown price → notional left unset, never valued at $0)
         for (const pos of positions) {
             const price = priceCache.get(`${pos.longExchange}:${pos.symbol}`)
-                || priceCache.get(`${pos.shortExchange}:${pos.symbol}`) || 0;
-            if (price > 0) {
+                ?? priceCache.get(`${pos.shortExchange}:${pos.symbol}`);
+            if (price !== undefined) {
                 pos.notional = Math.max(pos.longSize, pos.shortSize) * price;
             }
         }
@@ -171,12 +186,15 @@ class FundingAutoStrategy {
                 const longRates = ratesByExchange.get(pos.longExchange);
                 const shortRates = ratesByExchange.get(pos.shortExchange);
                 if (!longRates || !shortRates) {
+                    const down = [pos.longExchange, pos.shortExchange].filter(n => ratesUnavailable.has(n) || !ratesByExchange.has(n));
+                    ctx.log(`[funding-auto] ${pos.symbol}: rates unavailable on ${down.join(", ")} — skipping the exit decision this tick`);
                     surviving.push(pos);
                     continue;
                 }
                 const longInfo = longRates.get(pos.symbol);
                 const shortInfo = shortRates.get(pos.symbol);
                 if (!longInfo || !shortInfo) {
+                    ctx.log(`[funding-auto] ${pos.symbol}: market missing on ${!longInfo ? pos.longExchange : pos.shortExchange} — skipping the exit decision this tick`);
                     surviving.push(pos);
                     continue;
                 }
@@ -184,6 +202,11 @@ class FundingAutoStrategy {
                 // (each normalized by its own funding basis), annualized %. Positive = still
                 // earning; ≤ 0 = the pair has reversed and now pays.
                 const currentSpread = annualizeHourlyRate(hourlyOf(shortInfo, pos.shortExchange) - hourlyOf(longInfo, pos.longExchange));
+                if (!Number.isFinite(currentSpread)) {
+                    ctx.log(`[funding-auto] ${pos.symbol}: funding rate unknown (${pos.longExchange}↔${pos.shortExchange}) — skipping the exit decision this tick`);
+                    surviving.push(pos);
+                    continue;
+                }
                 // Calculate real P&L from exchange history. An unreadable history is never "0":
                 // no close decision for this pair this tick.
                 const [longPnl, shortPnl] = await Promise.all([
@@ -219,8 +242,14 @@ class FundingAutoStrategy {
             return surviving.length > 0 ? [{ type: "noop" }] : [];
         if (surviving.length >= this.maxPositions)
             return [{ type: "noop" }];
+        // Unknown sizing (equity unknown, or no capital and no sizeUsd): no new entries this tick.
+        const sizeUsd = this.getSizeUsd();
+        if (sizeUsd === null) {
+            ctx.log(`[funding-auto] No new entries: position size unknown (equity ${this._cachedEquity === null ? "unknown" : `$${this._cachedEquity.toFixed(2)}`}, sizeUsd ${Number(this._config.sizeUsd ?? 0)})`);
+            return surviving.length > 0 ? [{ type: "noop" }] : [];
+        }
         ctx.state.set("lastScan", Date.now());
-        ctx.log(`[funding-auto] Scanning ${ratesByExchange.size} exchanges, equity: $${this._cachedEquity.toFixed(2)}, size: $${this.getSizeUsd().toFixed(2)}/pos, active: ${surviving.length}`);
+        ctx.log(`[funding-auto] Scanning ${ratesByExchange.size} exchanges, equity: $${this._cachedEquity.toFixed(2)}, size: $${sizeUsd.toFixed(2)}/pos, active: ${surviving.length}`);
         const activeSymbols = new Set(surviving.map(p => `${p.symbol}:${p.mode}`));
         // Also block symbols we already tried to enter (prevents re-entry on failed/tiny orders)
         const attempted = ctx.state.get("attemptedSymbols") ?? new Set();
@@ -263,7 +292,7 @@ class FundingAutoStrategy {
             if (annualSpread < this.perpPerpMinSpread)
                 continue;
             // Calculate cost and break-even
-            const notional = this.getSizeUsd();
+            const notional = sizeUsd;
             const hourlyIncome = Math.abs(maxRate - minRate) * notional;
             const { totalCost } = calculateCosts(notional, this.defaultFeeRate, this.defaultFeeRate, this.defaultSlippage, this.defaultSlippage);
             const breakEvenHours = calculateBreakEven(totalCost, hourlyIncome);
@@ -314,7 +343,7 @@ class FundingAutoStrategy {
             // Track attempted symbols to prevent re-entry on same tick cycle
             attempted.add(`${opp.symbol}:${opp.mode}`);
             ctx.state.set("attemptedSymbols", attempted);
-            const success = await this.openPosition(ctx, opp, adapters);
+            const success = await this.openPosition(ctx, opp, adapters, sizeUsd);
             if (success) {
                 currentCount++;
                 perpPerpOpened++;
@@ -362,16 +391,10 @@ class FundingAutoStrategy {
         }
         return adapters;
     }
-    /** Resolve cached price for a symbol on a given exchange */
+    /** Cached (this tick's) price for a symbol on a given exchange; undefined = unknown. */
     getCachedPrice(ctx, exchange, symbol) {
         const cache = ctx.state.get("priceCache");
-        return cache?.get(`${exchange}:${symbol}`) ?? 0;
-    }
-    /** Format size with exchange-appropriate precision based on asset price */
-    formatSize(rawSize, _symbol) {
-        // Use price to determine precision
-        const price = rawSize > 0 ? this.getSizeUsd() / rawSize : 0;
-        return formatSizeForPrice(rawSize, price);
+        return cache?.get(`${exchange}:${symbol}`);
     }
     /** Discover existing arb pairs from live exchange positions; `unreadable` = venues whose positions failed to load. */
     async discoverArbPairs(adapters, log) {
@@ -458,7 +481,7 @@ class FundingAutoStrategy {
      * (reduce-only, verified). A definite short failure rolls the long back reduce-only.
      * An unknown outcome or a failed rollback / trim quarantines the symbol.
      */
-    async openPosition(ctx, opp, adapters) {
+    async openPosition(ctx, opp, adapters, notionalUsd) {
         // Engine: equity unknown → no new entries (closes still run).
         if (ctx.state.get("equityUnknown") === true) {
             ctx.log(`[funding-auto] Skip ${opp.symbol}: equity unknown — no new entries`);
@@ -469,11 +492,12 @@ class FundingAutoStrategy {
         if (!longAdapter || !shortAdapter)
             return false;
         const price = this.getCachedPrice(ctx, opp.longExchange, opp.symbol)
-            || this.getCachedPrice(ctx, opp.shortExchange, opp.symbol);
-        if (price <= 0)
+            ?? this.getCachedPrice(ctx, opp.shortExchange, opp.symbol);
+        if (price === undefined) {
+            ctx.log(`[funding-auto] Skip ${opp.symbol}: price unknown on ${opp.longExchange} / ${opp.shortExchange}`);
             return false;
-        const notionalUsd = this.getSizeUsd();
-        const size = this.formatSize(notionalUsd / price, opp.symbol);
+        }
+        const size = formatSizeForPrice(notionalUsd / price, price);
         // Minimum notional check — skip if below exchange minimums
         if (notionalUsd < MIN_NOTIONAL_USD) {
             ctx.log(`[funding-auto] Skip ${opp.symbol}: notional $${notionalUsd.toFixed(0)} < min $${MIN_NOTIONAL_USD}`);

package/dist/bot/strategies/grid-strategy.d.ts

@@ -1,4 +1,6 @@
 import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+/** Consecutive failed open-order reads after which every tick logs a loud warning. */
+export declare const GRID_READ_FAILURE_WARN = 5;
 export declare class GridStrategy implements Strategy {
     readonly name = "grid";
     describe(): {

package/dist/bot/strategies/grid-strategy.js

@@ -1,4 +1,6 @@
 import { registerStrategy } from "../strategy-registry.js";
+/** Consecutive failed open-order reads after which every tick logs a loud warning. */
+export const GRID_READ_FAILURE_WARN = 5;
 export class GridStrategy {
     name = "grid";
     describe() {
@@ -95,12 +97,13 @@ export class GridStrategy {
             }
             // For each filled level, place the opposite (counter) order
             const newLevels = [...matchedLevels];
+            const counterOrders = [];
             for (const filled of unmatchedLevels) {
                 const wasBuy = filled.side === "buy";
                 const newSide = wasBuy ? "sell" : "buy";
                 const newPrice = wasBuy ? filled.price + step : filled.price - step;
                 if (newPrice >= gridLower && newPrice <= gridUpper) {
-                    actions.push({
+                    counterOrders.push({
                         type: "place_order",
                         side: newSide,
                         price: newPrice.toFixed(2),
@@ -111,8 +114,24 @@ export class GridStrategy {
                 }
             }
             ctx.state.set("gridLevels", newLevels);
+            actions.push(...counterOrders);
+            const prevFailures = ctx.state.get("gridReadFailures") ?? 0;
+            if (prevFailures > 0)
+                ctx.log(`  [GRID] Open orders readable again after ${prevFailures} failed read(s)`);
+            ctx.state.set("gridReadFailures", 0);
+        }
+        catch (e) {
+            // No fill detection / counter orders on an unread book (never on stale data); retried next tick.
+            const failures = (ctx.state.get("gridReadFailures") ?? 0) + 1;
+            ctx.state.set("gridReadFailures", failures);
+            const reason = e instanceof Error ? e.message : String(e);
+            if (failures >= GRID_READ_FAILURE_WARN) {
+                ctx.log(`  [GRID] WARNING: open orders unreadable for ${failures} consecutive ticks (${reason}) — the grid is NOT placing counter orders; check: perp -e ${ctx.adapter.name} account orders`);
+            }
+            else {
+                ctx.log(`  [GRID] Open orders read failed (${failures}/${GRID_READ_FAILURE_WARN}): ${reason} — fill detection skipped this tick`);
+            }
         }
-        catch { /* retry next loop */ }
         // Auto-rebalance if price exits range
         if (params.rebalance) {
             const lastRebalance = ctx.state.get("lastRebalance") ?? 0;

package/dist/bot/strategies/spot-perp-arb-strategy.js

@@ -12,7 +12,7 @@ import { registerStrategy } from "../strategy-registry.js";
 import { getFundingHours } from "../../funding.js";
 import { annualizeHourlyRate } from "../../funding/normalize.js";
 import { pruneExecutionLog } from "../../execution-log.js";
-import { buildAdapterMap, getPerpSymbol, findRate, matchSymbol, fetchRates, scoreFunding, botSpotPerpMatches, assertFundingArbLegs, cancelBotSymbols } from "./funding-arb-utils.js";
+import { buildAdapterMap, getPerpSymbol, findRate, cappedLeverage, matchSymbol, fetchRates, scoreFunding, botSpotPerpMatches, assertFundingArbLegs, cancelBotSymbols, collectFundingSince } from "./funding-arb-utils.js";
 import { SpotPerpExecutor } from "./spot-perp-executor.js";
 import { findSpotQuoteBalance, getBotSpotAdapter, nonQuoteSpotBalances, spotNetworkOf, spotSharesPerpMargin, spotTokenBase } from "../../exchanges/spot-factory.js";
 import { getVenue } from "../../exchanges/venue.js";
@@ -84,6 +84,9 @@ export class SpotPerpArbStrategy {
         ctx.state.set("spaPositions", []);
         ctx.state.set("arbPositions", 0);
         ctx.state.set("fundingIncome", 0);
+        // Payments up to this instant are covered by the startup recovery (last 24 h); the periodic
+        // check books only payments newer than it (collectFundingSince high-water mark).
+        ctx.state.set("fundingStartTime", Date.now());
         ctx.state.set("fundingLastCheck", Date.now());
         ctx.log(`  [SPA] Ready | rate >= ${p.min_rate}% | close < ${p.close_rate}% | size $${p.size_usd}`);
         ctx.log(`  [SPA] Consistency >= ${(p.min_consistency * 100).toFixed(0)}% | history ${p.history_periods} periods | rotation ${p.rotation_threshold}%`);
@@ -103,13 +106,16 @@ export class SpotPerpArbStrategy {
                 try {
                     const payments = await a.getFundingPayments(200);
                     const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000;
-                    const sum = payments.filter(fp => fp.time > oneDayAgo).reduce((s, fp) => s + parseFloat(fp.payment), 0);
+                    const startedAt = ctx.state.get("fundingStartTime");
+                    const sum = payments.filter(fp => fp.time > oneDayAgo && fp.time <= startedAt).reduce((s, fp) => s + parseFloat(fp.payment), 0);
                     if (Math.abs(sum) > 0.001) {
                         historicalFunding += sum;
                         ctx.log(`  [FUND] ${name}: $${sum.toFixed(4)} historical`);
                     }
                 }
-                catch { /* not supported */ }
+                catch (e) {
+                    ctx.log(`  [FUND] ${name}: funding history unavailable — historical funding excludes it: ${e instanceof Error ? e.message : String(e)}`);
+                }
             }
             if (Math.abs(historicalFunding) > 0.001)
                 ctx.state.set("fundingIncome", historicalFunding);
@@ -181,22 +187,15 @@ export class SpotPerpArbStrategy {
         const lastCheck = ctx.state.get("fundingLastCheck");
         if (Date.now() - lastCheck > 5 * 60 * 1000) {
             try {
-                let total = 0;
-                for (const [name, a] of adapters) {
-                    try {
-                        const payments = await a.getFundingPayments(50);
-                        const start = ctx.state.get("fundingLastCheck");
-                        const sum = payments.filter(fp => fp.time > start - 5 * 60 * 1000).reduce((s, fp) => s + parseFloat(fp.payment), 0);
-                        total += sum;
-                        if (Math.abs(sum) > 0.001)
-                            ctx.log(`  [FUND] ${name}: $${sum.toFixed(4)}`);
-                    }
-                    catch { /* skip */ }
-                }
+                const since = ctx.state.get("fundingLastCheckByVenue") ?? {};
+                const { total } = await collectFundingSince(adapters, since, ctx.state.get("fundingStartTime"), ctx.log);
+                ctx.state.set("fundingLastCheckByVenue", since);
                 ctx.state.set("fundingIncome", ctx.state.get("fundingIncome") + total);
                 ctx.state.set("fundingLastCheck", Date.now());
             }
-            catch { /* non-critical */ }
+            catch (e) {
+                ctx.log(`  [FUND] funding check failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
         }
         for (const pos of positions) {
             if (Date.now() - pos.lastFundingCheck < 10 * 60 * 1000)
@@ -213,7 +212,10 @@ export class SpotPerpArbStrategy {
                     pos.fundingHistory = recent.map(fp => ({ time: fp.time, amount: parseFloat(fp.payment) }));
                 pos.lastFundingCheck = Date.now();
             }
-            catch { /* non-critical */ }
+            catch (e) {
+                // lastFundingCheck is not advanced: retried next tick.
+                ctx.log(`  [FUND] ${pos.symbol} ${pos.perpExchange}: funding history unavailable: ${e instanceof Error ? e.message : String(e)}`);
+            }
         }
         const display = positions.map(pos => {
             const ann = this.calcAnnualized(pos, ratesByExchange);
@@ -311,7 +313,7 @@ export class SpotPerpArbStrategy {
             const allowed = allowedByBase.get(pos.symbol.toUpperCase());
             if (allowed === undefined)
                 continue;
-            const candidates = await this.findPerpCandidates(pos.symbol, adapters, ratesByExchange, allowed);
+            const candidates = await this.findPerpCandidates(pos.symbol, adapters, ratesByExchange, allowed, ctx.log);
             const best = candidates[0];
             if (!best || best.exchange === pos.perpExchange)
                 continue;
@@ -329,12 +331,12 @@ export class SpotPerpArbStrategy {
                 continue;
             const perpSym = getPerpSymbol(pos.symbol, pos.perpExchange);
             const newMaxLev = findRate(ratesByExchange, best.exchange, getPerpSymbol(pos.symbol, best.exchange))?.maxLeverage
-                ?? findRate(ratesByExchange, best.exchange, pos.symbol)?.maxLeverage ?? 1;
+                ?? findRate(ratesByExchange, best.exchange, pos.symbol)?.maxLeverage;
             const ok = await this.executor.rotateShort({
                 symbol: pos.symbol, perpSymbol: perpSym,
                 currentExchange: pos.perpExchange, newExchange: best.exchange,
                 currentAdapter: oldAdapter, newAdapter,
-                size: pos.size, leverage: Math.min(p.leverage, newMaxLev), log: ctx.log,
+                size: pos.size, leverage: cappedLeverage(p.leverage, [{ exchange: best.exchange, maxLeverage: newMaxLev }], ctx.log), log: ctx.log,
             });
             if (ok.ok) {
                 // The spot leg is unchanged: the state entry follows the short to its new venue.
@@ -385,7 +387,7 @@ export class SpotPerpArbStrategy {
                         continue;
                     if (this.quarantined(base, ctx))
                         continue;
-                    const candidates = await this.findPerpCandidates(base, adapters, ratesByExchange, allowed);
+                    const candidates = await this.findPerpCandidates(base, adapters, ratesByExchange, allowed, ctx.log);
                     for (const cand of candidates) {
                         if (cand.score.annualized < p.min_rate || cand.score.consistency < p.min_consistency)
                             continue;
@@ -499,7 +501,7 @@ export class SpotPerpArbStrategy {
         return byBase;
     }
     /** Find all perp exchanges for a symbol, sorted by annualized rate (highest first). */
-    async findPerpCandidates(symbol, adapters, ratesByExchange, allowedPerpVenues) {
+    async findPerpCandidates(symbol, adapters, ratesByExchange, allowedPerpVenues, log) {
         const candidates = [];
         for (const [exName, adapter] of adapters) {
             if (!allowedPerpVenues.has(exName))
@@ -508,8 +510,20 @@ export class SpotPerpArbStrategy {
             const ri = findRate(ratesByExchange, exName, perpSym) ?? findRate(ratesByExchange, exName, symbol);
             if (!ri || ri.rate <= 0)
                 continue;
-            const score = await this.scoreFundingLocal(adapter, perpSym, exName)
-                ?? await this.scoreFundingLocal(adapter, symbol, exName);
+            // A failed history read is not "too little history": say so, then try the next symbol form;
+            // a venue with no readable form is left out this cycle.
+            let score = null;
+            for (const sym of perpSym === symbol ? [perpSym] : [perpSym, symbol]) {
+                try {
+                    score = await this.scoreFundingLocal(adapter, sym, exName);
+                }
+                catch (e) {
+                    log(`  [SPA] ${sym} on ${exName}: funding history unreadable — not a candidate this cycle: ${e instanceof Error ? e.message : String(e)}`);
+                    continue;
+                }
+                if (score)
+                    break;
+            }
             if (!score)
                 continue;
             candidates.push({ exchange: exName, rate: ri.rate, score });
@@ -567,8 +581,7 @@ export class SpotPerpArbStrategy {
             const perpSymbol = getPerpSymbol(symbol, perpExchange);
             const rateInfo = findRate(ratesByExchange, perpExchange, perpSymbol)
                 ?? findRate(ratesByExchange, perpExchange, symbol);
-            const perpMaxLev = rateInfo?.maxLeverage ?? 1;
-            const leverage = Math.min(p.leverage, perpMaxLev);
+            const leverage = cappedLeverage(p.leverage, [{ exchange: perpExchange, maxLeverage: rateInfo?.maxLeverage }], ctx.log);
             // Pre-entry: verify fundingHours (aster lazy bootstrap may not have run yet)
             if (perpExchange === "aster" && rateInfo && "getFundingHours" in perpAdapter) {
                 const actualFh = await perpAdapter.getFundingHours(symbol);
@@ -589,11 +602,17 @@ export class SpotPerpArbStrategy {
             const maxTotalPositionUsd = riskConfig?.max_position_usd ?? Infinity;
             const positions = ctx.state.get("spaPositions");
             let currentTotalUsd = 0;
-            for (const pos of positions) {
+            // No cap (Infinity): exposure does not gate the entry.
+            for (const pos of Number.isFinite(maxTotalPositionUsd) ? positions : []) {
                 const ri = findRate(ratesByExchange, pos.perpExchange, getPerpSymbol(pos.symbol, pos.perpExchange))
                     ?? findRate(ratesByExchange, pos.perpExchange, pos.symbol);
-                const price = ri?.price ?? 0;
-                currentTotalUsd += price * parseFloat(pos.size);
+                // Unknown price of a held position → exposure unknown: no new entry this cycle (a $0
+                // valuation would understate exposure and let the max_position_usd cap be bypassed).
+                if (ri === undefined || !(ri.price > 0)) {
+                    ctx.log(`  [SPA] Skip ${symbol}: ${pos.symbol} ${pos.perpExchange} price unknown this cycle — total exposure unknown, no new entries`);
+                    return false;
+                }
+                currentTotalUsd += ri.price * parseFloat(pos.size);
             }
             const remainingBudget = maxTotalPositionUsd - currentTotalUsd;
             if (remainingBudget < 10) {

package/dist/bot/tui/BotDashboard.d.ts

@@ -1,7 +1,14 @@
 export interface ExchangeBalance {
     exchange: string;
-    equity: string;
-    available: string;
+    /** null = the balance read failed (`error` says why) — shown "unavailable", never $0. */
+    equity: string | null;
+    available: string | null;
+    error?: string;
+}
+/** A venue whose display read (positions / spot balances) failed this tick. */
+export interface VenueReadError {
+    exchange: string;
+    error: string;
 }
 export interface BotTuiState {
     phase: string;
@@ -29,6 +36,10 @@ export interface BotTuiState {
     strategyState: Record<string, unknown>;
     tick: number;
     exchangeBalances?: ExchangeBalance[];
+    /** Venues whose positions could not be read: their positions are unknown, not empty. */
+    positionErrors?: VenueReadError[];
+    /** Open orders read failure (null = read): the orders are unknown, not empty. */
+    openOrdersError?: string | null;
 }
 export interface Position {
     symbol: string;