perp-cli 0.7.30 → 0.7.36

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

@@ -47,6 +47,8 @@ export declare class FundingArbStrategy implements Strategy {
      * HL getPositions() returns symbols like "PURR" or "PURR-PERP" — we normalize here.
      */
     private getPerpSymbol;
+    /** Look up rate from ratesByExchange, trying symbol, symbol-PERP, and symbol without -PERP */
+    private findRate;
     /**
      * Get a price estimate for a symbol from the perp adapter.
      * Tries the base symbol first, then with -PERP suffix.

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

@@ -1,7 +1,7 @@
 import { registerStrategy } from "../strategy-registry.js";
 import { checkArbLiquidity, checkSpotPerpLiquidity } from "../../liquidity.js";
 import { computeMatchedSize, computeSpotPerpMatchedSize, reconcileArbFills } from "../../arb-sizing.js";
-import { computeSignedAnnualSpread, annualizeRate } from "../../funding.js";
+import { getFundingHours } from "../../funding.js";
 import { logExecution, pruneExecutionLog } from "../../execution-log.js";
 export class FundingArbStrategy {
     name = "funding-arb";
@@ -153,7 +153,9 @@ export class FundingArbStrategy {
             for (const [name, a] of adapters) {
                 try {
                     const payments = await a.getFundingPayments(200);
-                    const sum = payments.reduce((s, p) => s + parseFloat(p.payment), 0);
+                    const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000;
+                    const recent = payments.filter(p => p.time > oneDayAgo);
+                    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`);
@@ -193,7 +195,7 @@ export class FundingArbStrategy {
             const rates = await this.fetchRates(a, name);
             const map = new Map();
             for (const r of rates)
-                map.set(r.symbol.toUpperCase(), { rate: r.rate, price: r.price, sizeDecimals: r.sizeDecimals, maxLeverage: r.maxLeverage });
+                map.set(r.symbol.toUpperCase(), { rate: r.rate, price: r.price, sizeDecimals: r.sizeDecimals, maxLeverage: r.maxLeverage, fundingHours: r.fundingHours });
             ratesByExchange.set(name, map);
         }
         // ── Fetch funding income periodically (every 5 minutes) ──
@@ -227,15 +229,19 @@ export class FundingArbStrategy {
                 // For spot-perp: long side is spot (rate=0), short side is perp
                 const perpExchange = p.shortExchange;
                 const perpSymbol = this.getPerpSymbol(p.symbol, perpExchange);
-                const shortRate = ratesByExchange.get(perpExchange)?.get(perpSymbol)?.rate
-                    ?? ratesByExchange.get(perpExchange)?.get(p.symbol)?.rate;
-                signedSpread = shortRate !== undefined ? annualizeRate(shortRate, perpExchange) : 0;
+                const rateInfo = this.findRate(ratesByExchange, perpExchange, perpSymbol)
+                    ?? this.findRate(ratesByExchange, perpExchange, p.symbol);
+                const shortRate = rateInfo?.rate;
+                const fundingH = rateInfo?.fundingHours ?? getFundingHours(perpExchange);
+                signedSpread = shortRate !== undefined ? (shortRate / fundingH) * 8760 * 100 : 0;
             }
             else {
-                const longRate = ratesByExchange.get(p.longExchange)?.get(p.symbol)?.rate;
-                const shortRate = ratesByExchange.get(p.shortExchange)?.get(p.symbol)?.rate;
-                signedSpread = (longRate !== undefined && shortRate !== undefined)
-                    ? computeSignedAnnualSpread(shortRate, p.shortExchange, longRate, p.longExchange)
+                const longInfo = this.findRate(ratesByExchange, p.longExchange, p.symbol);
+                const shortInfo = this.findRate(ratesByExchange, p.shortExchange, p.symbol);
+                const longHourly = longInfo ? longInfo.rate / (longInfo.fundingHours ?? getFundingHours(p.longExchange)) : undefined;
+                const shortHourly = shortInfo ? shortInfo.rate / (shortInfo.fundingHours ?? getFundingHours(p.shortExchange)) : undefined;
+                signedSpread = (longHourly !== undefined && shortHourly !== undefined)
+                    ? (shortHourly - longHourly) * 8760 * 100
                     : 0;
             }
             const sign = signedSpread >= 0 ? "+" : "";
@@ -250,18 +256,21 @@ export class FundingArbStrategy {
             if (pos.mode === "spot-perp") {
                 const perpExchange = pos.shortExchange;
                 const perpSymbol = this.getPerpSymbol(pos.symbol, perpExchange);
-                const shortRate = ratesByExchange.get(perpExchange)?.get(perpSymbol)?.rate
-                    ?? ratesByExchange.get(perpExchange)?.get(pos.symbol)?.rate;
-                if (shortRate === undefined)
+                const rateInfo = this.findRate(ratesByExchange, perpExchange, perpSymbol)
+                    ?? this.findRate(ratesByExchange, perpExchange, pos.symbol);
+                if (rateInfo === undefined)
                     continue;
-                signedSpread = annualizeRate(shortRate, perpExchange);
+                const fundingH = rateInfo.fundingHours ?? getFundingHours(perpExchange);
+                signedSpread = (rateInfo.rate / fundingH) * 8760 * 100;
             }
             else {
-                const longRate = ratesByExchange.get(pos.longExchange)?.get(pos.symbol)?.rate;
-                const shortRate = ratesByExchange.get(pos.shortExchange)?.get(pos.symbol)?.rate;
-                if (longRate === undefined || shortRate === undefined)
+                const longInfo = this.findRate(ratesByExchange, pos.longExchange, pos.symbol);
+                const shortInfo = this.findRate(ratesByExchange, pos.shortExchange, pos.symbol);
+                if (longInfo === undefined || shortInfo === undefined)
                     continue;
-                signedSpread = computeSignedAnnualSpread(shortRate, pos.shortExchange, longRate, pos.longExchange);
+                const longHourly = longInfo.rate / (longInfo.fundingHours ?? getFundingHours(pos.longExchange));
+                const shortHourly = shortInfo.rate / (shortInfo.fundingHours ?? getFundingHours(pos.shortExchange));
+                signedSpread = (shortHourly - longHourly) * 8760 * 100;
             }
             // Close if funding flipped (losing money) or spread below close threshold
             const shouldClose = signedSpread < 0 || signedSpread < params.close_spread;
@@ -293,19 +302,32 @@ 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" } });
                             this._failCooldown.set(`${pos.symbol}:close`, Date.now() + 5 * 60 * 1000);
                         }
+                        if (!closeLongOk)
+                            continue; // don't close short if long failed — keep hedge intact
                         try {
                             const closeShortResult = await shortAdapter.marketOrder(pos.symbol, "buy", pos.size);
                             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) {
                             const msg = err instanceof Error ? err.message : String(err);
-                            ctx.log(`  [ARB] Close short leg failed for ${pos.symbol}: ${msg}`);
+                            ctx.log(`  [ARB] Close short leg failed for ${pos.symbol}: ${msg} — re-opening long to restore hedge`);
                             logExecution({ type: "arb_close", exchange: pos.shortExchange, symbol: pos.symbol, side: "buy", size: pos.size, status: "failed", error: msg, dryRun: false, meta: { mode: pos.mode, leg: "short" } });
+                            // Rollback: re-open long to restore hedge
+                            try {
+                                await longAdapter.marketOrder(pos.symbol, "buy", pos.size);
+                                ctx.log(`  [ARB] Rollback: re-opened long ${pos.size} ${pos.symbol} on ${pos.longExchange}`);
+                                logExecution({ type: "multi_leg_rollback", exchange: pos.longExchange, symbol: pos.symbol, side: "buy", size: pos.size, status: "success", dryRun: false });
+                            }
+                            catch (rbErr) {
+                                const rbMsg = rbErr instanceof Error ? rbErr.message : String(rbErr);
+                                ctx.log(`  [ARB] CRITICAL: Close rollback failed for ${pos.symbol}: ${rbMsg}`);
+                                logExecution({ type: "multi_leg_rollback", exchange: pos.longExchange, symbol: pos.symbol, side: "buy", size: pos.size, status: "failed", error: rbMsg, dryRun: false });
+                            }
+                            this._failCooldown.set(`${pos.symbol}:close`, Date.now() + 5 * 60 * 1000);
+                            continue;
                         }
-                        if (closeLongOk) {
-                            toClose.push(pos);
-                            ctx.log(`  [ARB] Closed ${pos.symbol} position`);
-                        }
+                        toClose.push(pos);
+                        ctx.log(`  [ARB] Closed ${pos.symbol} position`);
                     }
                 }
             }
@@ -327,23 +349,27 @@ export class FundingArbStrategy {
         }
         // Perp-perp opportunities
         for (const sym of allSymbols) {
-            let minRate = Infinity, maxRate = -Infinity;
+            let minHourly = Infinity, maxHourly = -Infinity;
             let minExchange = "", maxExchange = "";
+            let minRate = 0, maxRate = 0;
             for (const exName of exchangeNames) {
-                const rate = ratesByExchange.get(exName)?.get(sym)?.rate;
-                if (rate === undefined)
+                const rateInfo = this.findRate(ratesByExchange, exName, sym);
+                if (!rateInfo)
                     continue;
-                if (rate < minRate) {
-                    minRate = rate;
+                const hourlyRate = rateInfo.rate / (rateInfo.fundingHours ?? getFundingHours(exName));
+                if (hourlyRate < minHourly) {
+                    minHourly = hourlyRate;
                     minExchange = exName;
+                    minRate = rateInfo.rate;
                 }
-                if (rate > maxRate) {
-                    maxRate = rate;
+                if (hourlyRate > maxHourly) {
+                    maxHourly = hourlyRate;
                     maxExchange = exName;
+                    maxRate = rateInfo.rate;
                 }
             }
             if (minExchange && maxExchange && minExchange !== maxExchange) {
-                const spread = computeSignedAnnualSpread(maxRate, maxExchange, minRate, minExchange);
+                const spread = (maxHourly - minHourly) * 8760 * 100;
                 if (spread >= params.min_spread) {
                     opportunities.push({
                         symbol: sym,
@@ -369,14 +395,16 @@ export class FundingArbStrategy {
                 const perpRates = ratesByExchange.get(name);
                 if (!perpRates)
                     continue;
-                for (const [sym, { rate }] of perpRates) {
+                for (const [sym, rateEntry] of perpRates) {
+                    const { rate } = rateEntry;
                     // Only consider positive funding (shorts receive, longs pay)
                     if (rate <= 0)
                         continue;
                     const base = sym.replace(/-PERP$/, "").toUpperCase();
                     if (!spotSymbols.has(base))
                         continue;
-                    const annualSpread = annualizeRate(rate, name);
+                    const hourlyRate = rate / (rateEntry.fundingHours ?? getFundingHours(name));
+                    const annualSpread = hourlyRate * 8760 * 100;
                     if (annualSpread >= spotPerpMinSpread) {
                         opportunities.push({
                             symbol: base,
@@ -432,13 +460,13 @@ export class FundingArbStrategy {
                     const shortAdapter = adapters.get(best.shortExchange);
                     if (!longAdapter || !shortAdapter)
                         continue;
-                    const price = ratesByExchange.get(best.longExchange)?.get(best.symbol)?.price ?? 0;
+                    const price = this.findRate(ratesByExchange, best.longExchange, best.symbol)?.price ?? 0;
                     if (price <= 0)
                         continue;
                     // Determine leverage for this symbol
                     const configLeverage = params.leverage ?? 3;
-                    const longMaxLev = ratesByExchange.get(best.longExchange)?.get(best.symbol)?.maxLeverage ?? 1;
-                    const shortMaxLev = ratesByExchange.get(best.shortExchange)?.get(best.symbol)?.maxLeverage ?? 1;
+                    const longMaxLev = this.findRate(ratesByExchange, best.longExchange, best.symbol)?.maxLeverage ?? 1;
+                    const shortMaxLev = this.findRate(ratesByExchange, best.shortExchange, best.symbol)?.maxLeverage ?? 1;
                     const leverage = Math.min(configLeverage, longMaxLev, shortMaxLev);
                     // Set leverage on both exchanges before ordering
                     try {
@@ -455,12 +483,12 @@ export class FundingArbStrategy {
                             longAdapter.getBalance(),
                             shortAdapter.getBalance(),
                         ]);
-                        // Check margin usage (skip if > 80%)
+                        // 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 > 80 || shortMarginPct > 80) {
+                        if (longMarginPct > 70 || shortMarginPct > 70) {
                             skipMargin++;
                             continue;
                         }
@@ -486,8 +514,8 @@ export class FundingArbStrategy {
                     if (!liq.viable)
                         continue;
                     // Compute matched size (use actual precision from exchange market data)
-                    const longDec = ratesByExchange.get(best.longExchange)?.get(best.symbol)?.sizeDecimals;
-                    const shortDec = ratesByExchange.get(best.shortExchange)?.get(best.symbol)?.sizeDecimals;
+                    const longDec = this.findRate(ratesByExchange, best.longExchange, best.symbol)?.sizeDecimals;
+                    const shortDec = this.findRate(ratesByExchange, best.shortExchange, best.symbol)?.sizeDecimals;
                     let matched = computeMatchedSize(liq.adjustedSizeUsd, price, best.longExchange, best.shortExchange, { longSizeDecimals: longDec, shortSizeDecimals: shortDec });
                     if (!matched) {
                         ctx.log(`  [ARB] Skip ${best.symbol}: can't compute matched size (min notional or precision issue)`);
@@ -541,6 +569,39 @@ export class FundingArbStrategy {
                         const reconMsg = reconErr instanceof Error ? reconErr.message : String(reconErr);
                         ctx.log(`  [ARB] WARNING: Fill reconciliation failed: ${reconMsg}`);
                     }
+                    // Verify both positions actually exist (catches instant liquidation)
+                    try {
+                        const [longPositions, shortPositions] = await Promise.all([
+                            longAdapter.getPositions(),
+                            shortAdapter.getPositions(),
+                        ]);
+                        const longExists = longPositions.some(p => p.symbol.toUpperCase() === best.symbol.toUpperCase() && parseFloat(p.size) > 0);
+                        const shortExists = shortPositions.some(p => p.symbol.toUpperCase() === best.symbol.toUpperCase() && parseFloat(p.size) > 0);
+                        if (!longExists || !shortExists) {
+                            ctx.log(`  [ARB] Position verification failed for ${best.symbol}: long=${longExists}, short=${shortExists}`);
+                            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 });
+                            // Rollback whichever side exists
+                            if (longExists && !shortExists) {
+                                try {
+                                    await longAdapter.marketOrder(best.symbol, "sell", matched.size);
+                                    ctx.log(`  [ARB] Rollback: closed phantom long ${best.symbol}`);
+                                }
+                                catch { /* best effort */ }
+                            }
+                            if (shortExists && !longExists) {
+                                try {
+                                    await shortAdapter.marketOrder(best.symbol, "buy", matched.size);
+                                    ctx.log(`  [ARB] Rollback: closed phantom short ${best.symbol}`);
+                                }
+                                catch { /* best effort */ }
+                            }
+                            this._failCooldown.set(`${best.symbol}:entry`, Date.now() + 10 * 60 * 1000);
+                            continue;
+                        }
+                    }
+                    catch (verifyErr) {
+                        ctx.log(`  [ARB] Position verification error for ${best.symbol}: ${verifyErr instanceof Error ? verifyErr.message : String(verifyErr)}`);
+                    }
                     // Track position
                     const currentPositions = ctx.state.get("arbOpenPositions");
                     currentPositions.push({
@@ -698,8 +759,8 @@ export class FundingArbStrategy {
             // Determine leverage for perp leg
             const configLeverage = params.leverage ?? 3;
             const perpSymbolUpper = this.getPerpSymbol(opp.symbol, opp.shortExchange).toUpperCase();
-            const perpMaxLev = ratesByExchange.get(opp.shortExchange)?.get(perpSymbolUpper)?.maxLeverage
-                ?? ratesByExchange.get(opp.shortExchange)?.get(opp.symbol.toUpperCase())?.maxLeverage
+            const perpMaxLev = this.findRate(ratesByExchange, opp.shortExchange, perpSymbolUpper)?.maxLeverage
+                ?? this.findRate(ratesByExchange, opp.shortExchange, opp.symbol.toUpperCase())?.maxLeverage
                 ?? 1;
             const leverage = Math.min(configLeverage, perpMaxLev);
             // Set leverage on perp before ordering
@@ -714,7 +775,7 @@ export class FundingArbStrategy {
                 // Check margin usage
                 const perpEquity = parseFloat(perpBal.equity);
                 const perpMarginPct = perpEquity > 0 ? parseFloat(perpBal.marginUsed) / perpEquity * 100 : 0;
-                if (perpMarginPct > 80) {
+                if (perpMarginPct > 70) {
                     ctx.log(`  [ARB] Skip spot-perp ${opp.symbol}: perp margin usage too high (${perpMarginPct.toFixed(0)}%)`);
                     return false;
                 }
@@ -888,14 +949,20 @@ export class FundingArbStrategy {
      * HL getPositions() returns symbols like "PURR" or "PURR-PERP" — we normalize here.
      */
     getPerpSymbol(baseSymbol, exchangeName) {
-        // Strip any existing -PERP suffix first
         const base = baseSymbol.replace(/-PERP$/, "").toUpperCase();
-        // HL perp symbols are just the base (e.g. "PURR", "ETH", "BTC")
-        // Some HIP-3 tokens might need "-PERP" suffix — use base for now
-        // since getPositions() returns the base form on HL
         void exchangeName;
         return base;
     }
+    /** Look up rate from ratesByExchange, trying symbol, symbol-PERP, and symbol without -PERP */
+    findRate(ratesByExchange, exchange, symbol) {
+        const map = ratesByExchange.get(exchange);
+        if (!map)
+            return undefined;
+        const upper = symbol.toUpperCase();
+        return map.get(upper)
+            ?? map.get(upper + "-PERP")
+            ?? map.get(upper.replace(/-PERP$/, ""));
+    }
     /**
      * Get a price estimate for a symbol from the perp adapter.
      * Tries the base symbol first, then with -PERP suffix.
@@ -923,6 +990,7 @@ export class FundingArbStrategy {
                 price: parseFloat(m.markPrice),
                 sizeDecimals: m.sizeDecimals,
                 maxLeverage: m.maxLeverage,
+                fundingHours: m.fundingHours,
             }));
         }
         catch {

package/dist/exchanges/aster.js

@@ -77,6 +77,12 @@ export class AsterAdapter {
             const maxLev = Number(s.maxLeverage ?? 50);
             const lotFilter = s.filters
                 ?.find(f => f.filterType === "LOT_SIZE");
+            const nextFunding = Number(premium?.nextFundingTime ?? 0);
+            const hoursFromMidnight = nextFunding > 0 ? (nextFunding % 86400000) / 3600000 : 0;
+            const fundingHours = nextFunding <= 0 ? 1
+                : hoursFromMidnight % 8 === 0 ? 8
+                    : hoursFromMidnight % 4 === 0 ? 4
+                        : 1;
             return {
                 symbol: this._fromApi(sym),
                 markPrice: String(premium?.markPrice ?? ticker?.lastPrice ?? "0"),
@@ -87,6 +93,7 @@ export class AsterAdapter {
                 maxLeverage: maxLev,
                 sizeDecimals: s.quantityPrecision != null ? Number(s.quantityPrecision) : undefined,
                 stepSize: lotFilter?.stepSize != null ? String(lotFilter.stepSize) : undefined,
+                fundingHours,
             };
         });
         this._marketsCache = result;
@@ -277,17 +284,51 @@ export class AsterAdapter {
     }
     // ── Trading ──
     async marketOrder(symbol, side, size) {
+        const apiSymbol = this._toApi(symbol);
         const result = await this._signedPost("/fapi/v1/order", {
-            symbol: this._toApi(symbol),
+            symbol: apiSymbol,
             side: side.toUpperCase(),
             type: "MARKET",
             quantity: size,
         });
-        // Validate fill — Binance-style API returns 200 even for 0-fill orders
         const r = result;
         const executedQty = Number(r.executedQty ?? 0);
+        const orderId = String(r.orderId ?? "");
+        // If immediately filled, return
+        if (executedQty > 0 && r.status === "FILLED")
+            return result;
+        // status=NEW: order accepted but not yet filled — poll for up to 3 seconds
+        if (r.status === "NEW" && orderId) {
+            for (let i = 0; i < 3; i++) {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                try {
+                    const check = await this._signedGet("/fapi/v1/order", {
+                        symbol: apiSymbol,
+                        orderId,
+                    });
+                    const filledQty = Number(check.executedQty ?? 0);
+                    if (filledQty > 0)
+                        return check; // filled
+                    if (check.status === "CANCELED" || check.status === "EXPIRED" || check.status === "REJECTED") {
+                        throw new Error(`Market ${side} ${symbol}: order ${check.status} (orderId: ${orderId})`);
+                    }
+                }
+                catch (e) {
+                    if (e instanceof Error && e.message.startsWith("Market "))
+                        throw e;
+                    // query failed, retry
+                }
+            }
+            // Still not filled after 3s — cancel and throw
+            try {
+                await this._signedDelete("/fapi/v1/order", { symbol: apiSymbol, orderId });
+            }
+            catch { /* best effort cancel */ }
+            throw new Error(`Market ${side} ${symbol}: order not filled after 3s, cancelled (orderId: ${orderId})`);
+        }
+        // executedQty === 0 with non-NEW status
         if (executedQty === 0) {
-            throw new Error(`Market ${side} ${symbol}: order accepted but 0 filled (status: ${r.status}, orderId: ${r.orderId})`);
+            throw new Error(`Market ${side} ${symbol}: order accepted but 0 filled (status: ${r.status}, orderId: ${orderId})`);
         }
         return result;
     }

package/dist/exchanges/interface.d.ts

@@ -12,6 +12,7 @@ export interface ExchangeMarketInfo {
     maxLeverage: number;
     sizeDecimals?: number;
     stepSize?: string;
+    fundingHours?: number;
 }
 export interface ExchangePosition {
     symbol: string;

package/package.json

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