perp-cli 0.14.1 → 0.14.2

package/dist/arb/sizing.js

@@ -10,10 +10,11 @@ export function computeMatchedSize(sizeUsd, price, longExchange, shortExchange,
     const rawSize = sizeUsd / price;
     // Use explicitly provided decimals if available, else conservative defaults
     const szDecimals = Math.min(opts?.longSizeDecimals ?? getSizeDecimals(longExchange), opts?.shortSizeDecimals ?? getSizeDecimals(shortExchange));
-    // If lotSize is provided, round to nearest multiple of lotSize (floor)
+    // If lotSize is provided, round to nearest multiple of lotSize (floor). The 1e-9 guard keeps a
+    // float quotient like 0.3 / 0.1 = 2.9999999999999996 from dropping a whole lot (as fillSizeString does).
     let roundedSize;
     if (opts?.lotSize && opts.lotSize > 0) {
-        roundedSize = Math.floor(rawSize / opts.lotSize) * opts.lotSize;
+        roundedSize = Math.floor(rawSize / opts.lotSize + 1e-9) * opts.lotSize;
     }
     else {
         // Round DOWN to the least precise exchange's decimals
@@ -31,7 +32,7 @@ export function computeMatchedSize(sizeUsd, price, longExchange, shortExchange,
         // Try rounding UP instead
         let roundedUp;
         if (opts?.lotSize && opts.lotSize > 0) {
-            roundedUp = Math.ceil(rawSize / opts.lotSize) * opts.lotSize;
+            roundedUp = Math.ceil(rawSize / opts.lotSize - 1e-9) * opts.lotSize;
         }
         else {
             const factor = Math.pow(10, szDecimals);
@@ -43,17 +44,38 @@ export function computeMatchedSize(sizeUsd, price, longExchange, shortExchange,
         // (b), so a ceil that still fell short of minNotional was returned and then
         // rejected by the venue — SSOT Rule #2: fail honestly with null instead.
         if (notionalUp >= minNotional && notionalUp <= sizeUsd * 1.2) {
-            return { size: formatSize(roundedUp, szDecimals, opts?.lotSize), notional: notionalUp };
+            return sized(roundedUp, price, szDecimals, opts?.lotSize);
         }
         return null; // Can't meet minimum within tolerance
     }
-    return { size: formatSize(roundedSize, szDecimals, opts?.lotSize), notional };
+    return sized(roundedSize, price, szDecimals, opts?.lotSize);
+}
+/**
+ * The size string sent to both venues and the notional OF THAT STRING (never of the unformatted
+ * float). With a lot, the lot's own decimals are used — formatting a 0.0001-lot size with the
+ * venue default (e.g. 2) used to round 0.0157 UP to "0.02" or a 0.004 size to "0.00". A size that
+ * formats to zero is not viable (null), never a zero-size order.
+ */
+function sized(size, price, szDecimals, lotSize) {
+    const str = formatSize(size, szDecimals, lotSize);
+    const n = Number(str);
+    if (!(n > 0))
+        return null;
+    return { size: str, notional: n * price };
 }
 function formatSize(size, szDecimals, lotSize) {
-    if (lotSize && lotSize >= 1)
-        return String(Math.round(size));
+    if (lotSize && lotSize > 0)
+        return size.toFixed(decimalsOfLot(lotSize)); // whole lots (≥1) → 0 decimals; 2.5 → 1
     return size.toFixed(szDecimals);
 }
+/** Decimal places of a lot size (0.0001 → 4, 0.5 → 1, 1e-7 → 7). */
+function decimalsOfLot(lot) {
+    const s = lot.toString();
+    const exp = /e-(\d+)$/.exec(s);
+    if (exp)
+        return Number(exp[1]) + (s.split("e")[0].split(".")[1]?.length ?? 0);
+    return s.includes(".") ? s.split(".")[1].length : 0;
+}
 /** Size decimal precision by exchange (conservative fallbacks — prefer explicit decimals via opts) */
 function getSizeDecimals(exchange) {
     switch (exchange.toLowerCase()) {

package/dist/bot/conditions.d.ts

@@ -17,7 +17,11 @@ export interface MarketSnapshot {
  * @returns RSI value between 0 and 100, or NaN if insufficient data.
  */
 export declare function calculateRSI(closes: number[], period?: number): number;
-export declare function getMarketSnapshot(adapter: ExchangeAdapter, symbol: string): Promise<MarketSnapshot>;
+/**
+ * `log` receives a line for each failed klines / orderbook read; the affected fields are NaN
+ * (every condition comparison on them is false), never a fabricated 0.
+ */
+export declare function getMarketSnapshot(adapter: ExchangeAdapter, symbol: string, log?: (msg: string) => void): Promise<MarketSnapshot>;
 export declare function evaluateCondition(condition: Condition, snapshot: MarketSnapshot, context: {
     equity: number | null;
     startTime: number;

package/dist/bot/conditions.js

@@ -38,7 +38,11 @@ export function calculateRSI(closes, period = 14) {
     const rs = avgGain / avgLoss;
     return 100 - 100 / (1 + rs);
 }
-export async function getMarketSnapshot(adapter, symbol) {
+/**
+ * `log` receives a line for each failed klines / orderbook read; the affected fields are NaN
+ * (every condition comparison on them is false), never a fabricated 0.
+ */
+export async function getMarketSnapshot(adapter, symbol, log) {
     const markets = await adapter.getMarkets();
     const m = markets.find(mk => symbolMatch(mk.symbol, symbol));
     if (!m) {
@@ -50,9 +54,10 @@ export async function getMarketSnapshot(adapter, symbol) {
     const fundingRate = m.fundingRate === null ? NaN : parseFloat(m.fundingRate);
     // Unknown volume → NaN, never 0: a 0 would read as "no liquidity" to volume conditions.
     const volume24h = m.volume24h === null ? NaN : parseFloat(m.volume24h);
-    // Try to get kline data for 24h high/low + RSI
-    let high24h = price;
-    let low24h = price;
+    // 24h high/low + RSI from klines. Unknown (failed read / no candles) → NaN: a high=low=price
+    // fallback would read as 0% volatility and satisfy "volatility_below" on a number nobody measured.
+    let high24h = NaN;
+    let low24h = NaN;
     let rsi = NaN;
     try {
         const now = Date.now();
@@ -72,11 +77,11 @@ export async function getMarketSnapshot(adapter, symbol) {
             rsi = calculateRSI(closes, 14);
         }
     }
-    catch {
-        // non-critical
+    catch (e) {
+        log?.(`  WARNING: ${adapter.name} ${symbol} klines read failed — volatility / RSI unknown this tick: ${e instanceof Error ? e.message : String(e)}`);
     }
-    // Calculate bid-ask spread from orderbook
-    let spreadPct = 0;
+    // Bid-ask spread from the orderbook. Unknown (failed read / empty side) → NaN, never 0.
+    let spreadPct = NaN;
     try {
         const ob = await adapter.getOrderbook(symbol);
         if (ob.bids.length > 0 && ob.asks.length > 0) {
@@ -88,10 +93,10 @@ export async function getMarketSnapshot(adapter, symbol) {
             }
         }
     }
-    catch {
-        // non-critical
+    catch (e) {
+        log?.(`  WARNING: ${adapter.name} ${symbol} orderbook read failed — spread unknown this tick: ${e instanceof Error ? e.message : String(e)}`);
     }
-    const volatility24h = price > 0 ? ((high24h - low24h) / price) * 100 : 0;
+    const volatility24h = price > 0 ? ((high24h - low24h) / price) * 100 : NaN;
     return { price, high24h, low24h, volume24h, fundingRate, volatility24h, rsi, spreadPct };
 }
 export function evaluateCondition(condition, snapshot, context) {

package/dist/bot/engine.d.ts

@@ -87,3 +87,15 @@ export declare function executeActions(adapter: ExchangeAdapter, symbol: string,
     filled: number;
 }>;
 export { filledOf };
+/** TUI positions of one venue; a failed read → `error` set (shown "unavailable"), never an empty list. */
+export declare function fetchPositions(adapter: ExchangeAdapter, symbol: string, exchangeName?: string): Promise<{
+    positions: import("./tui/index.js").Position[];
+    error: string | null;
+}>;
+/** A venue whose balance read failed is listed with `error` set and null amounts, never left out. */
+export declare function fetchExchangeBalances(primaryAdapter: ExchangeAdapter, extraAdapters?: Map<string, ExchangeAdapter>): Promise<import("./tui/index.js").ExchangeBalance[]>;
+/** TUI open orders; a failed read → `error` set (shown "unavailable"), never an empty list. */
+export declare function fetchOpenOrders(adapter: ExchangeAdapter, symbol: string): Promise<{
+    orders: import("./tui/index.js").OpenOrder[];
+    error: string | null;
+}>;

package/dist/bot/engine.js

@@ -336,7 +336,7 @@ isDryRun) {
             const loopStart = Date.now();
             try {
                 // Get market data (enriched for strategy use)
-                const { snapshot, unknown: dataUnknown } = await getEnrichedSnapshot(adapter, config.symbol);
+                const { snapshot, unknown: dataUnknown } = await getEnrichedSnapshot(adapter, config.symbol, (m) => effectiveLog(m));
                 if (snapshot.price > 0)
                     lastPrice = snapshot.price;
                 // A strategy that reads the orderbook / klines never runs on fake (empty) data.
@@ -505,8 +505,9 @@ isDryRun) {
                     }
                 }
                 // ── 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),
+                // Display data: a failed venue read is carried as an error (rendered "unavailable"), never as empty.
+                const [{ positions, errors: positionErrors }, { orders: openOrders, error: openOrdersError }, exchangeBalances] = await Promise.all([
+                    extraAdapters ? fetchAllPositions(adapter, config.symbol, extraAdapters) : fetchPositions(adapter, config.symbol, adapter.name).then(r => ({ positions: r.positions, errors: r.error === null ? [] : [{ exchange: adapter.name, error: r.error }] })),
                     fetchOpenOrders(adapter, config.symbol),
                     fetchExchangeBalances(adapter, extraAdapters),
                 ]);
@@ -551,7 +552,7 @@ isDryRun) {
                     }
                 }
                 if (mode === "tui" || mode === "json") {
-                    const tuiState = buildTuiState(state, config, snapshot, positions, openOrders, strategyCtx, exchangeBalances);
+                    const tuiState = buildTuiState(state, config, snapshot, positions, openOrders, strategyCtx, exchangeBalances, { positionErrors, openOrdersError });
                     if (mode === "tui") {
                         tuiEmitter.emitState(tuiState);
                     }
@@ -882,7 +883,7 @@ export { filledOf };
  * read): the empty arrays in `snapshot` then are NOT data — the engine skips the tick of a
  * strategy that reads them (MARKET_DATA_STRATEGIES).
  */
-async function getEnrichedSnapshot(adapter, symbol) {
+async function getEnrichedSnapshot(adapter, symbol, log) {
     // Multi-symbol strategies use "ALL" — skip market-specific data
     if (symbol.toUpperCase() === "ALL") {
         return {
@@ -894,7 +895,7 @@ async function getEnrichedSnapshot(adapter, symbol) {
             unknown: null,
         };
     }
-    const base = await getMarketSnapshot(adapter, symbol);
+    const base = await getMarketSnapshot(adapter, symbol, log);
     const failed = [];
     const why = (what) => (e) => { failed.push(`${what} read failed: ${e instanceof Error ? e.message : String(e)}`); return null; };
     const [orderbook, klines] = await Promise.all([
@@ -909,11 +910,11 @@ async function getEnrichedSnapshot(adapter, symbol) {
 // ── Utils ──
 function logStatus(log, state, snapshot, phase) {
     const runtime = formatDuration(Math.floor((Date.now() - state.startTime) / 1000));
-    const vol = snapshot.volatility24h.toFixed(1);
+    const vol = Number.isFinite(snapshot.volatility24h) ? `${snapshot.volatility24h.toFixed(1)}%` : "unknown";
     const fr = (snapshot.fundingRate * 100).toFixed(4);
     const eq = usdOrUnknown(state.equity);
     const dd = state.equity !== null && state.peakEquity !== null ? `$${(state.peakEquity - state.equity).toFixed(2)}` : "unknown";
-    log(chalk.gray(`  [${phase}] $${snapshot.price.toFixed(2)} | vol: ${vol}% | fr: ${fr}% | ` +
+    log(chalk.gray(`  [${phase}] $${snapshot.price.toFixed(2)} | vol: ${vol} | fr: ${fr}% | ` +
         `eq: ${eq} | dd: ${dd} | fills: ${state.fills} | ${runtime}`));
 }
 /** "$12.34", or "unknown" for a null (unknown) amount. */
@@ -937,27 +938,29 @@ function sleep(ms) {
     return new Promise(r => setTimeout(r, ms));
 }
 // ── TUI helpers ──
-async function fetchPositions(adapter, symbol, exchangeName) {
+/** TUI positions of one venue; a failed read → `error` set (shown "unavailable"), never an empty list. */
+export async function fetchPositions(adapter, symbol, exchangeName) {
     try {
         const positions = await adapter.getPositions();
         const isAll = symbol.toUpperCase() === "ALL";
-        return positions
-            .filter(p => (isAll || p.symbol.toUpperCase() === symbol.toUpperCase() || p.symbol.toUpperCase() === symbol.toUpperCase() + "-PERP") && parseFloat(p.size) !== 0)
-            .map(p => ({
-            symbol: p.symbol,
-            side: p.side,
-            size: p.size,
-            entryPrice: p.entryPrice,
-            markPrice: p.markPrice,
-            unrealizedPnl: p.unrealizedPnl,
-            exchange: exchangeName ?? adapter.name,
-        }));
+        return { positions: positions
+                .filter(p => (isAll || p.symbol.toUpperCase() === symbol.toUpperCase() || p.symbol.toUpperCase() === symbol.toUpperCase() + "-PERP") && parseFloat(p.size) !== 0)
+                .map(p => ({
+                symbol: p.symbol,
+                side: p.side,
+                size: p.size,
+                entryPrice: p.entryPrice,
+                markPrice: p.markPrice,
+                unrealizedPnl: p.unrealizedPnl,
+                exchange: exchangeName ?? adapter.name,
+            })), error: null };
     }
-    catch {
-        return [];
+    catch (e) {
+        return { positions: [], error: `positions read failed: ${e instanceof Error ? e.message : String(e)}` };
     }
 }
-async function fetchExchangeBalances(primaryAdapter, extraAdapters) {
+/** A venue whose balance read failed is listed with `error` set and null amounts, never left out. */
+export async function fetchExchangeBalances(primaryAdapter, extraAdapters) {
     const adapters = [[primaryAdapter.name, primaryAdapter]];
     if (extraAdapters) {
         for (const [name, a] of extraAdapters) {
@@ -971,7 +974,9 @@ async function fetchExchangeBalances(primaryAdapter, extraAdapters) {
             const bal = await a.getBalance();
             results.push({ exchange: name, equity: bal.equity, available: bal.available });
         }
-        catch { /* skip */ }
+        catch (e) {
+            results.push({ exchange: name, equity: null, available: null, error: e instanceof Error ? e.message : String(e) });
+        }
     }));
     return results;
 }
@@ -986,15 +991,14 @@ async function fetchSpotPositions(adapter) {
     try {
         const spot = await getBotSpotAdapter(adapter.name, adapter);
         if (spot === null)
-            return [];
+            return { positions: [], error: null };
         net = spotNetworkOf(spot);
         raw = await spot.getSpotBalances();
         markets = await spotMarketsForValuation(getVenue(adapter.name), spot, raw, net);
     }
     catch (e) {
-        // Display-only path: surface the failure instead of hiding it, keep the TUI alive.
-        process.stderr.write(`[warn] ${adapter.name} spot positions unavailable: ${e instanceof Error ? e.message : String(e)}\n`);
-        return [];
+        // Display-only path: surfaced as "unavailable" in the TUI / JSON state, the TUI stays alive.
+        return { positions: [], error: `spot positions read failed: ${e instanceof Error ? e.message : String(e)}` };
     }
     const def = getVenue(adapter.name);
     const priceMap = new Map(markets.map(m => [m.baseToken.toUpperCase(), m.markPrice]));
@@ -1025,7 +1029,7 @@ async function fetchSpotPositions(adapter) {
             exchange: adapter.name,
         });
     }
-    return out;
+    return { positions: out, error: null };
 }
 async function fetchAllPositions(primaryAdapter, symbol, extraAdapters) {
     const adapters = [[primaryAdapter.name, primaryAdapter]];
@@ -1036,33 +1040,38 @@ async function fetchAllPositions(primaryAdapter, symbol, extraAdapters) {
         }
     }
     const all = [];
+    const errors = [];
     await Promise.all(adapters.map(async ([name, a]) => {
         const [perpPos, spotPos] = await Promise.all([
             fetchPositions(a, symbol, name),
             fetchSpotPositions(a),
         ]);
-        all.push([...perpPos, ...spotPos]);
+        all.push([...perpPos.positions, ...spotPos.positions]);
+        for (const err of [perpPos.error, spotPos.error])
+            if (err !== null)
+                errors.push({ exchange: name, error: err });
     }));
-    return all.flat();
+    return { positions: all.flat(), errors };
 }
-async function fetchOpenOrders(adapter, symbol) {
+/** TUI open orders; a failed read → `error` set (shown "unavailable"), never an empty list. */
+export async function fetchOpenOrders(adapter, symbol) {
     try {
         const orders = await adapter.getOpenOrders();
-        return orders
-            .filter(o => o.symbol.toUpperCase() === symbol.toUpperCase() || o.symbol.toUpperCase() === symbol.toUpperCase() + "-PERP")
-            .map(o => ({
-            orderId: o.orderId,
-            side: o.side,
-            price: o.price,
-            size: o.size,
-            type: o.type,
-        }));
+        return { orders: orders
+                .filter(o => o.symbol.toUpperCase() === symbol.toUpperCase() || o.symbol.toUpperCase() === symbol.toUpperCase() + "-PERP")
+                .map(o => ({
+                orderId: o.orderId,
+                side: o.side,
+                price: o.price,
+                size: o.size,
+                type: o.type,
+            })), error: null };
     }
-    catch {
-        return [];
+    catch (e) {
+        return { orders: [], error: `open orders read failed: ${e instanceof Error ? e.message : String(e)}` };
     }
 }
-function buildTuiState(state, config, snapshot, positions, openOrders, strategyCtx, exchangeBalances) {
+function buildTuiState(state, config, snapshot, positions, openOrders, strategyCtx, exchangeBalances, readErrors) {
     // Extract serializable strategy state from the Map
     const strategyState = {};
     for (const [k, v] of strategyCtx.state) {
@@ -1099,5 +1108,7 @@ function buildTuiState(state, config, snapshot, positions, openOrders, strategyC
         strategyState,
         tick: strategyCtx.tick,
         exchangeBalances,
+        positionErrors: readErrors?.positionErrors ?? [],
+        openOrdersError: readErrors?.openOrdersError ?? null,
     };
 }

package/dist/bot/strategies/claude-agent.js

@@ -76,8 +76,8 @@ function buildMarketMessage(snapshot, symbol) {
         `Symbol: ${symbol}`,
         `Price: ${snapshot.price.toFixed(4)}`,
         `Funding Rate: ${(snapshot.fundingRate * 100).toFixed(4)}%`,
-        `24h Volatility: ${snapshot.volatility24h.toFixed(2)}%`,
-        `24h Volume: ${snapshot.volume24h.toFixed(2)}`,
+        `24h Volatility: ${Number.isFinite(snapshot.volatility24h) ? `${snapshot.volatility24h.toFixed(2)}%` : "unknown"}`,
+        `24h Volume: ${Number.isFinite(snapshot.volume24h) ? snapshot.volume24h.toFixed(2) : "unknown"}`,
         `Open Interest: ${snapshot.openInterest}`,
     ];
     const bestBid = snapshot.orderbook.bids[0];

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

@@ -7,7 +7,7 @@ import { logExecution, pruneExecutionLog } from "../../execution-log.js";
 import { annualizeHourlyRate } from "../../funding/normalize.js";
 import { getBotSpotAdapter, nonQuoteSpotBalances, readSpotQuoteAvailableFresh, spotNetworkOf, spotTokenBase, sweepSpotQuoteToPerp } from "../../exchanges/spot-factory.js";
 import { getVenue } from "../../exchanges/venue.js";
-import { isPositionGone, transferUsdcToSpot, transferUsdcToPerp, getPerpSymbol, findRate, getPriceEstimate, fetchRates, botSpotPerpMatches, assertFundingArbLegs, cancelBotSymbols } from "./funding-arb-utils.js";
+import { isPositionGone, transferUsdcToSpot, transferUsdcToPerp, getPerpSymbol, findRate, getPriceEstimate, fetchRates, botSpotPerpMatches, assertFundingArbLegs, cancelBotSymbols, collectFundingSince } from "./funding-arb-utils.js";
 import { fillSizeString, sizeDecimalsOf, spotLotStepOf, spotMarketFill } from "../../exchanges/spot-result.js";
 import { floorToStep, lotStepOf } from "../../exchanges/precision.js";
 import { isQuarantined, quarantineKey, quarantineSymbol } from "../quarantine.js";
@@ -70,6 +70,9 @@ export class FundingArbStrategy {
         ctx.state.set("arbOpenPositions", []);
         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.state.set("fundingHistory", []);
         ctx.log(`  [ARB] Funding arb ready | spread >= ${params.min_spread}% | close < ${params.close_spread}% | size $${params.size_usd}`);
@@ -99,14 +102,17 @@ export class FundingArbStrategy {
                 try {
                     const payments = await a.getFundingPayments(200);
                     const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000;
-                    const recent = payments.filter(p => p.time > oneDayAgo);
+                    const startedAt = ctx.state.get("fundingStartTime");
+                    const recent = payments.filter(p => p.time > oneDayAgo && p.time <= startedAt);
                     const sum = recent.reduce((s, p) => s + parseFloat(p.payment), 0);
                     if (Math.abs(sum) > 0.001) {
                         historicalFunding += sum;
                         ctx.log(`  [FUND] ${name}: $${sum.toFixed(4)} historical funding`);
                     }
                 }
-                catch { /* not all adapters support this */ }
+                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);
@@ -385,25 +391,15 @@ export class FundingArbStrategy {
         const lastCheck = ctx.state.get("fundingLastCheck");
         if (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.time > startTime - 5 * 60 * 1000);
-                        const sum = recent.reduce((s, p) => s + parseFloat(p.payment), 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);
+                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)}`);
+            }
         }
         // ── Update strategy state for TUI display ──
         const arbPosForDisplay = openPositions.map(p => {

package/dist/bot/strategies/funding-arb-utils.d.ts

@@ -91,3 +91,22 @@ export declare function fetchRates(adapter: ExchangeAdapter, exchangeName: strin
  * cancelled when the bot traded no symbol.
  */
 export declare function cancelBotSymbols(adapters: Map<string, ExchangeAdapter>, symbols: ReadonlySet<string>, tag: string, log: (msg: string) => void): Promise<void>;
+/**
+ * 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 declare function collectFundingSince(adapters: ReadonlyMap<string, {
+    getFundingPayments(limit?: number): Promise<Array<{
+        time: number;
+        payment: string;
+    }>>;
+}>, since: Record<string, number>, defaultStart: number, log: (msg: string) => void): Promise<{
+    total: number;
+    failed: string[];
+}>;

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

@@ -249,3 +249,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 };
+}