perp-cli 0.7.47 → 0.7.50

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

@@ -201,12 +201,21 @@ export class FundingArbStrategy {
                 const equity = parseFloat(bal.equity);
                 const marginUsed = parseFloat(bal.marginUsed);
                 const marginPct = equity > 0 ? (marginUsed / equity) * 100 : 100;
-                exchangeBalances.set(name, { equity, available: parseFloat(bal.available), marginPct });
-                if (marginPct < 90) {
-                    availableAdapters.set(name, a);
+                const available = parseFloat(bal.available);
+                exchangeBalances.set(name, { equity, available, marginPct });
+                // Skip if: margin > 90%, available < $5, or exchange on liquidation cooldown
+                const exchCooldown = this._failCooldown.get(`${name}:exchange`) ?? 0;
+                if (Date.now() < exchCooldown) {
+                    ctx.log(`  [ARB] ${name} on liquidation cooldown — skipping`);
+                }
+                else if (available < 5) {
+                    ctx.log(`  [ARB] ${name} available $${available.toFixed(2)} too low — skipping`);
+                }
+                else if (marginPct >= 90) {
+                    ctx.log(`  [ARB] ${name} margin ${marginPct.toFixed(0)}% — skipping`);
                 }
                 else {
-                    ctx.log(`  [ARB] ${name} margin ${marginPct.toFixed(0)}% — skipping for this tick`);
+                    availableAdapters.set(name, a);
                 }
             }
             catch (err) {
@@ -334,7 +343,9 @@ export class FundingArbStrategy {
                     const longAdapter = adapters.get(pos.longExchange);
                     const shortAdapter = adapters.get(pos.shortExchange);
                     if (longAdapter && shortAdapter) {
+                        const isPositionGone = (msg) => msg.includes("ReduceOnly") || msg.includes("reduceOnly") || msg.includes("-2022");
                         let closeLongOk = false;
+                        let longPositionGone = false;
                         try {
                             const closeLongResult = await longAdapter.marketOrder(pos.symbol, "sell", pos.size, { reduceOnly: true });
                             closeLongOk = true;
@@ -342,11 +353,20 @@ export class FundingArbStrategy {
                         }
                         catch (err) {
                             const msg = err instanceof Error ? err.message : String(err);
-                            ctx.log(`  [ARB] Close long leg failed for ${pos.symbol}: ${msg} (cooldown 5m)`);
-                            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 (isPositionGone(msg)) {
+                                // Position already liquidated/closed on this exchange
+                                longPositionGone = true;
+                                ctx.log(`  [ARB] Long position gone for ${pos.symbol} on ${pos.longExchange} (liquidated?) — force closing short`);
+                                // Cooldown the exchange for 30 minutes to prevent liquidation-entry cycle
+                                this._failCooldown.set(`${pos.longExchange}:exchange`, Date.now() + 30 * 60 * 1000);
+                            }
+                            else {
+                                ctx.log(`  [ARB] Close long leg failed for ${pos.symbol}: ${msg} (cooldown 5m)`);
+                                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)
+                        if (!closeLongOk && !longPositionGone)
                             continue;
                         try {
                             const closeShortResult = await shortAdapter.marketOrder(pos.symbol, "buy", pos.size, { reduceOnly: true });
@@ -354,25 +374,45 @@ export class FundingArbStrategy {
                         }
                         catch (err) {
                             const msg = err instanceof Error ? err.message : String(err);
-                            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}`);
-                                // Note: re-open is NOT reduceOnly (it's a new position)
-                                logExecution({ type: "multi_leg_rollback", exchange: pos.longExchange, symbol: pos.symbol, side: "buy", size: pos.size, status: "success", dryRun: false });
+                            if (isPositionGone(msg)) {
+                                // Short position also gone — both liquidated, just clean up tracking
+                                ctx.log(`  [ARB] Short position also gone for ${pos.symbol} on ${pos.shortExchange} — removing from tracking`);
+                                this._failCooldown.set(`${pos.shortExchange}:exchange`, Date.now() + 30 * 60 * 1000);
                             }
-                            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 });
+                            else if (closeLongOk) {
+                                // Long was closed but short failed (not liquidated) — rollback long
+                                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" } });
+                                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;
+                            }
+                            else {
+                                // Long was gone, short failed (not liquidated) — orphaned short, force close without reduceOnly
+                                ctx.log(`  [ARB] Force closing orphaned short for ${pos.symbol}: ${msg}`);
+                                try {
+                                    await shortAdapter.marketOrder(pos.symbol, "buy", pos.size);
+                                    ctx.log(`  [ARB] Force closed short ${pos.size} ${pos.symbol} on ${pos.shortExchange}`);
+                                }
+                                catch (forceErr) {
+                                    const forceMsg = forceErr instanceof Error ? forceErr.message : String(forceErr);
+                                    ctx.log(`  [ARB] CRITICAL: Force close short failed for ${pos.symbol}: ${forceMsg}`);
+                                    this._failCooldown.set(`${pos.symbol}:close`, Date.now() + 10 * 60 * 1000);
+                                    continue;
+                                }
                             }
-                            this._failCooldown.set(`${pos.symbol}:close`, Date.now() + 5 * 60 * 1000);
-                            continue;
                         }
                         toClose.push(pos);
-                        ctx.log(`  [ARB] Closed ${pos.symbol} position`);
+                        ctx.log(`  [ARB] Closed ${pos.symbol} position${longPositionGone ? ' (long was liquidated)' : ''}`);
                     }
                 }
             }
@@ -595,20 +635,7 @@ export class FundingArbStrategy {
                             const rbMsg = rbErr instanceof Error ? rbErr.message : String(rbErr);
                             ctx.log(`  [ARB] CRITICAL: Rollback failed for ${best.symbol}: ${rbMsg}`);
                             logExecution({ type: "multi_leg_rollback", exchange: best.longExchange, symbol: best.symbol, side: "sell", size: matched.size, status: "failed", error: rbMsg, dryRun: false });
-                            // Track orphaned long position for manual cleanup
-                            const currentPositions = ctx.state.get("arbOpenPositions");
-                            currentPositions.push({
-                                symbol: best.symbol,
-                                longExchange: best.longExchange,
-                                shortExchange: best.shortExchange, // note: short leg doesn't exist
-                                entrySpread: 0,
-                                size: matched.size,
-                                mode: "perp-perp",
-                                entryTime: 0, // flag as orphaned
-                            });
-                            ctx.state.set("arbOpenPositions", currentPositions);
-                            ctx.state.set("arbPositions", currentPositions.length);
-                            ctx.log(`  [ARB] Tracking orphaned long position for manual cleanup`);
+                            ctx.log(`  [ARB] CRITICAL: Orphaned long position on ${best.longExchange} for ${best.symbol} — operator must close manually`);
                         }
                         this._failCooldown.set(`${best.symbol}:entry`, Date.now() + 5 * 60 * 1000);
                         continue;
@@ -951,6 +978,11 @@ export class FundingArbStrategy {
                 const msg = spotErr instanceof Error ? spotErr.message : String(spotErr);
                 ctx.log(`  [ARB] Open spot-perp failed (spot buy) for ${opp.symbol}: ${msg}`);
                 logExecution({ type: "arb_entry", exchange: opp.longExchange, symbol: opp.symbol, side: "buy", size: matched.size, status: "failed", error: msg, dryRun: false, meta: { mode: "spot-perp", leg: "spot" } });
+                try {
+                    await this.transferUsdcToPerp(spotAdapter, exchangeName, transferAmt);
+                    ctx.log(`  [ARB] Transferred $${transferAmt} USDC back to perp after spot buy failure`);
+                }
+                catch { /* best effort */ }
                 return false;
             }
             // Step 3: Short perp
@@ -1115,9 +1147,12 @@ export class FundingArbStrategy {
             // Bootstrap aster funding hours lazily (1 API call per unknown symbol, cached permanently)
             if (exchangeName === "aster" && "getFundingHours" in adapter) {
                 const aster = adapter;
-                // Only bootstrap symbols not yet cached (up to 5 per tick to limit API calls)
-                const uncached = withRates.filter(m => m.fundingHours === undefined || m.fundingHours === 1);
-                const toBootstrap = uncached.slice(0, 5);
+                // Only bootstrap symbols not yet cached (up to 20 per tick to complete faster)
+                const uncached = withRates.filter(m => {
+                    const cached = adapter?._fundingHoursCache?.get?.(m.symbol);
+                    return cached === undefined; // only truly uncached, not symbols confirmed as 1h
+                });
+                const toBootstrap = uncached.slice(0, 20);
                 for (const m of toBootstrap) {
                     const fh = await aster.getFundingHours(m.symbol);
                     m.fundingHours = fh;

package/package.json

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