perp-cli 0.7.24 → 0.7.32

package/dist/arb/sizing.js

@@ -55,10 +55,11 @@ function getSizeDecimals(exchange) {
         case "hyperliquid": return 2; // HL perps range 0-5; 2 is safe middle ground
         case "lighter": return 2;
         case "pacifica": return 4;
+        case "aster": return 0; // aster symbols mostly use integers; explicit sizeDecimals overrides this
         // Spot exchanges
         case "spot:hyperliquid": return 2;
         case "spot:lighter": return 2;
-        default: return 2;
+        default: return 0; // conservative: integers when unknown
     }
 }
 /** Minimum notional (USD) per exchange */

package/dist/bot/config.d.ts

@@ -41,6 +41,7 @@ export interface FundingArbStrategyParams {
     size_usd: number;
     max_positions: number;
     exchanges: string[];
+    leverage?: number;
 }
 export interface GenericStrategyParams {
     type: string;

package/dist/bot/config.js

@@ -89,6 +89,7 @@ export function parseStrategy(type, raw) {
                 exchanges: Array.isArray(raw.exchanges)
                     ? raw.exchanges.map(String)
                     : String(raw.exchanges ?? "pacifica,hyperliquid").split(",").map(s => s.trim()),
+                leverage: raw.leverage !== undefined ? Number(raw.leverage) : undefined,
             };
         default:
             return { type, ...raw };

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

@@ -25,6 +25,7 @@ export declare class FundingArbStrategy implements Strategy {
     };
     private get params();
     private _config;
+    private _failCooldown;
     init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
     onTick(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
     onStop(ctx: StrategyContext): Promise<StrategyAction[]>;

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

@@ -15,6 +15,7 @@ export class FundingArbStrategy {
                 { name: "size_usd", type: "number", required: true, description: "Position size in USD" },
                 { name: "max_positions", type: "number", required: false, default: 3, description: "Max concurrent positions" },
                 { name: "exchanges", type: "string", required: true, description: "Comma-separated exchange names" },
+                { name: "leverage", type: "number", required: false, default: 3, description: "Max leverage to use" },
             ],
         };
     }
@@ -22,6 +23,7 @@ export class FundingArbStrategy {
         return this._config;
     }
     _config = {};
+    _failCooldown = new Map(); // "symbol:action" → timestamp of next retry
     async init(ctx, _snapshot) {
         // Prune old execution logs (keep 30 days)
         try {
@@ -130,7 +132,7 @@ export class FundingArbStrategy {
                             continue;
                         }
                         const base = perp.symbol.replace(/-PERP$/, "").toUpperCase();
-                        const spotBal = nonUsdc.find(b => b.token.toUpperCase() === base);
+                        const spotBal = nonUsdc.find(b => b.token.toUpperCase().replace(/-SPOT$/, "") === base);
                         ctx.log(`  [ARB] ${name} perp ${perp.symbol}(${perp.side}) → base=${base}, spotMatch=${spotBal ? spotBal.token : "none"}`);
                         if (spotBal && perp.side === "short") {
                             recovered.push({ symbol: base, longExchange: `${name}-spot`, shortExchange: name, entrySpread: 0, size: perp.size, mode: "spot-perp" });
@@ -191,7 +193,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 });
+                map.set(r.symbol.toUpperCase(), { rate: r.rate, price: r.price, sizeDecimals: r.sizeDecimals, maxLeverage: r.maxLeverage });
             ratesByExchange.set(name, map);
         }
         // ── Fetch funding income periodically (every 5 minutes) ──
@@ -264,6 +266,11 @@ export class FundingArbStrategy {
             // Close if funding flipped (losing money) or spread below close threshold
             const shouldClose = signedSpread < 0 || signedSpread < params.close_spread;
             if (shouldClose) {
+                // Cooldown: skip if close recently failed for this symbol
+                const closeKey = `${pos.symbol}:close`;
+                const cooldownUntil = this._failCooldown.get(closeKey) ?? 0;
+                if (Date.now() < cooldownUntil)
+                    continue;
                 const sign = signedSpread >= 0 ? "+" : "";
                 ctx.log(`  [ARB] Closing ${pos.symbol}: signed spread ${sign}${signedSpread.toFixed(1)}% (close_spread=${params.close_spread}%, entry=${pos.entrySpread.toFixed(1)}%)`);
                 if (pos.mode === "spot-perp") {
@@ -274,19 +281,44 @@ export class FundingArbStrategy {
                     const longAdapter = adapters.get(pos.longExchange);
                     const shortAdapter = adapters.get(pos.shortExchange);
                     if (longAdapter && shortAdapter) {
+                        let closeLongOk = false;
                         try {
-                            await Promise.all([
-                                longAdapter.marketOrder(pos.symbol, "sell", pos.size),
-                                shortAdapter.marketOrder(pos.symbol, "buy", pos.size),
-                            ]);
-                            toClose.push(pos);
-                            ctx.log(`  [ARB] Closed ${pos.symbol} position`);
-                            logExecution({ type: "arb_close", exchange: `${pos.longExchange}↔${pos.shortExchange}`, symbol: pos.symbol, side: "close", size: pos.size, status: "success", dryRun: false, meta: { mode: pos.mode, signedSpread: signedSpread } });
+                            const closeLongResult = await longAdapter.marketOrder(pos.symbol, "sell", pos.size);
+                            closeLongOk = true;
+                            logExecution({ type: "arb_close", exchange: pos.longExchange, symbol: pos.symbol, side: "sell", size: pos.size, status: "success", dryRun: false, meta: { mode: pos.mode, leg: "long", signedSpread: signedSpread, response: closeLongResult } });
                         }
                         catch (err) {
                             const msg = err instanceof Error ? err.message : String(err);
-                            ctx.log(`  [ARB] Close failed for ${pos.symbol}: ${msg}`);
+                            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)
+                            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} — 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;
+                        }
+                        toClose.push(pos);
+                        ctx.log(`  [ARB] Closed ${pos.symbol} position`);
                     }
                 }
             }
@@ -391,11 +423,20 @@ export class FundingArbStrategy {
             if (arbPositions < params.max_positions) {
                 // Skip symbols already in open positions
                 const openSymbols = new Set(ctx.state.get("arbOpenPositions").map(p => p.symbol.toUpperCase()));
+                let skipMargin = 0;
+                let skipCooldown = 0;
                 for (const best of opportunities) {
                     if (openSymbols.has(best.symbol.toUpperCase()))
                         continue;
+                    // Cooldown: skip if entry recently failed for this symbol
+                    const entryKey = `${best.symbol}:entry`;
+                    const entryCooldown = this._failCooldown.get(entryKey) ?? 0;
+                    if (Date.now() < entryCooldown) {
+                        skipCooldown++;
+                        continue;
+                    }
                     if (best.mode === "spot-perp") {
-                        const opened = await this.openSpotPerp(best, adapters, ctx);
+                        const opened = await this.openSpotPerp(best, adapters, ctx, ratesByExchange);
                         if (opened)
                             return [{ type: "noop" }];
                         continue;
@@ -407,24 +448,49 @@ export class FundingArbStrategy {
                     const price = ratesByExchange.get(best.longExchange)?.get(best.symbol)?.price ?? 0;
                     if (price <= 0)
                         continue;
-                    // Balance check
+                    // 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 leverage = Math.min(configLeverage, longMaxLev, shortMaxLev);
+                    // Set leverage on both exchanges before ordering
+                    try {
+                        await Promise.all([
+                            longAdapter.setLeverage(best.symbol, leverage, "cross"),
+                            shortAdapter.setLeverage(best.symbol, leverage, "cross"),
+                        ]);
+                    }
+                    catch { /* non-critical, some exchanges set leverage on order */ }
+                    // Balance + margin check
                     let targetSizeUsd = params.size_usd;
                     try {
                         const [longBal, shortBal] = await Promise.all([
                             longAdapter.getBalance(),
                             shortAdapter.getBalance(),
                         ]);
+                        // Check margin usage (skip if > 80%)
+                        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) {
+                            skipMargin++;
+                            continue;
+                        }
+                        // Required margin per leg = sizeUsd / leverage
                         const longAvail = parseFloat(longBal.available);
                         const shortAvail = parseFloat(shortBal.available);
                         const minAvail = Math.min(longAvail, shortAvail);
-                        const maxAffordable = minAvail * 0.8;
-                        if (maxAffordable < 10) {
-                            ctx.log(`  [ARB] Skip ${best.symbol}: insufficient balance ($${minAvail.toFixed(2)} available)`);
-                            continue;
-                        }
-                        if (targetSizeUsd > maxAffordable) {
-                            ctx.log(`  [ARB] Size reduced $${targetSizeUsd} → $${maxAffordable.toFixed(0)} (limited by balance $${minAvail.toFixed(2)})`);
-                            targetSizeUsd = Math.floor(maxAffordable);
+                        const requiredMarginPerLeg = targetSizeUsd / leverage;
+                        if (minAvail < requiredMarginPerLeg) {
+                            // Try reducing size to what's affordable
+                            const maxAffordableNotional = minAvail * leverage * 0.8;
+                            if (maxAffordableNotional < 10) {
+                                ctx.log(`  [ARB] Skip ${best.symbol}: insufficient margin ($${minAvail.toFixed(2)} < $${requiredMarginPerLeg.toFixed(2)} needed at ${leverage}x)`);
+                                continue;
+                            }
+                            ctx.log(`  [ARB] Size reduced $${targetSizeUsd} → $${maxAffordableNotional.toFixed(0)} (limited by margin $${minAvail.toFixed(2)} at ${leverage}x)`);
+                            targetSizeUsd = Math.floor(maxAffordableNotional);
                         }
                     }
                     catch { /* non-critical, proceed with original size */ }
@@ -440,68 +506,77 @@ export class FundingArbStrategy {
                         ctx.log(`  [ARB] Skip ${best.symbol}: can't compute matched size (min notional or precision issue)`);
                         continue;
                     }
+                    ctx.log(`  [ARB] Opening: ${matched.size} ${best.symbol} on both legs ($${matched.notional.toFixed(0)}/leg, slippage ~${liq.longSlippage.toFixed(2)}%/${liq.shortSlippage.toFixed(2)}%)`);
+                    // Step 1: Execute long leg first
+                    let longResult;
                     try {
-                        ctx.log(`  [ARB] Opening: ${matched.size} ${best.symbol} on both legs ($${matched.notional.toFixed(0)}/leg, slippage ~${liq.longSlippage.toFixed(2)}%/${liq.shortSlippage.toFixed(2)}%)`);
+                        longResult = await longAdapter.marketOrder(best.symbol, "buy", matched.size);
+                        logExecution({ type: "arb_entry", exchange: best.longExchange, symbol: best.symbol, side: "buy", size: matched.size, notional: matched.notional / 2, status: "success", dryRun: false, meta: { mode: "perp-perp", leg: "long", response: longResult } });
+                    }
+                    catch (longErr) {
+                        const msg = longErr instanceof Error ? longErr.message : String(longErr);
+                        ctx.log(`  [ARB] Long leg failed for ${best.symbol}: ${msg} (cooldown 5m)`);
+                        logExecution({ type: "arb_entry", exchange: best.longExchange, symbol: best.symbol, side: "buy", size: matched.size, status: "failed", error: msg, dryRun: false, meta: { mode: "perp-perp", leg: "long" } });
+                        this._failCooldown.set(`${best.symbol}:entry`, Date.now() + 5 * 60 * 1000);
+                        continue;
+                    }
+                    // Step 2: Execute short leg
+                    try {
+                        const shortResult = await shortAdapter.marketOrder(best.symbol, "sell", matched.size);
+                        logExecution({ type: "arb_entry", exchange: best.shortExchange, symbol: best.symbol, side: "sell", size: matched.size, notional: matched.notional / 2, status: "success", dryRun: false, meta: { mode: "perp-perp", leg: "short", response: shortResult } });
+                    }
+                    catch (shortErr) {
+                        const msg = shortErr instanceof Error ? shortErr.message : String(shortErr);
+                        ctx.log(`  [ARB] Short leg failed for ${best.symbol}: ${msg} — ROLLING BACK long leg (cooldown 5m)`);
+                        logExecution({ type: "arb_entry", exchange: best.shortExchange, symbol: best.symbol, side: "sell", size: matched.size, status: "failed", error: msg, dryRun: false, meta: { mode: "perp-perp", leg: "short" } });
+                        // Rollback: close the long position
                         try {
-                            await Promise.all([
-                                longAdapter.marketOrder(best.symbol, "buy", matched.size),
-                                shortAdapter.marketOrder(best.symbol, "sell", matched.size),
-                            ]);
+                            await longAdapter.marketOrder(best.symbol, "sell", matched.size);
+                            ctx.log(`  [ARB] Rollback success: closed long ${matched.size} ${best.symbol} on ${best.longExchange}`);
+                            logExecution({ type: "multi_leg_rollback", exchange: best.longExchange, symbol: best.symbol, side: "sell", size: matched.size, status: "success", dryRun: false });
                         }
-                        catch (orderErr) {
-                            const errMsg = orderErr instanceof Error ? orderErr.message : String(orderErr);
-                            const lotMatch = errMsg.match(/not a multiple of lot size (\d+(?:\.\d+)?)/);
-                            if (lotMatch) {
-                                const lotSize = parseFloat(lotMatch[1]);
-                                ctx.log(`  [ARB] Lot size ${lotSize} detected, recalculating...`);
-                                matched = computeMatchedSize(liq.adjustedSizeUsd, price, best.longExchange, best.shortExchange, { lotSize, longSizeDecimals: longDec, shortSizeDecimals: shortDec });
-                                if (!matched) {
-                                    ctx.log(`  [ARB] Skip ${best.symbol}: can't meet lot size ${lotSize}`);
-                                    continue;
-                                }
-                                ctx.log(`  [ARB] Retry: ${matched.size} ${best.symbol} ($${matched.notional.toFixed(0)}/leg)`);
-                                await Promise.all([
-                                    longAdapter.marketOrder(best.symbol, "buy", matched.size),
-                                    shortAdapter.marketOrder(best.symbol, "sell", matched.size),
-                                ]);
-                            }
-                            else {
-                                throw orderErr;
-                            }
-                        }
-                        // Verify fills match
-                        try {
-                            const recon = await reconcileArbFills(longAdapter, shortAdapter, best.symbol, (msg) => ctx.log(`  ${msg}`));
-                            if (!recon.matched) {
-                                ctx.log(`  [ARB] WARNING: fills not matched after correction attempt`);
-                            }
+                        catch (rbErr) {
+                            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 });
                         }
-                        catch (reconErr) {
-                            const reconMsg = reconErr instanceof Error ? reconErr.message : String(reconErr);
-                            ctx.log(`  [ARB] WARNING: Fill reconciliation failed: ${reconMsg}`);
+                        this._failCooldown.set(`${best.symbol}:entry`, Date.now() + 5 * 60 * 1000);
+                        continue;
+                    }
+                    // Verify fills match
+                    try {
+                        const recon = await reconcileArbFills(longAdapter, shortAdapter, best.symbol, (msg) => ctx.log(`  ${msg}`));
+                        if (!recon.matched) {
+                            ctx.log(`  [ARB] WARNING: fills not matched after correction attempt`);
                         }
-                        // Track position
-                        const currentPositions = ctx.state.get("arbOpenPositions");
-                        currentPositions.push({
-                            symbol: best.symbol,
-                            longExchange: best.longExchange,
-                            shortExchange: best.shortExchange,
-                            entrySpread: best.spread,
-                            size: matched.size,
-                            mode: "perp-perp",
-                        });
-                        ctx.state.set("arbOpenPositions", currentPositions);
-                        ctx.state.set("arbPositions", currentPositions.length);
-                        ctx.log(`  [ARB] Position opened! (${currentPositions.length}/${params.max_positions})`);
-                        logExecution({ type: "arb_entry", exchange: `${best.longExchange}↔${best.shortExchange}`, symbol: best.symbol, side: "long/short", size: matched.size, notional: matched.notional, status: "success", dryRun: false, meta: { mode: "perp-perp", spread: best.spread } });
-                        return [{ type: "noop" }];
                     }
-                    catch (err) {
-                        const msg = err instanceof Error ? err.message : String(err);
-                        ctx.log(`  [ARB] Execution failed for ${best.symbol}: ${msg}`);
-                        logExecution({ type: "arb_entry", exchange: `${best.longExchange}↔${best.shortExchange}`, symbol: best.symbol, side: "long/short", size: matched?.size ?? "0", status: "failed", error: msg, dryRun: false, meta: { mode: "perp-perp" } });
-                        continue;
+                    catch (reconErr) {
+                        const reconMsg = reconErr instanceof Error ? reconErr.message : String(reconErr);
+                        ctx.log(`  [ARB] WARNING: Fill reconciliation failed: ${reconMsg}`);
                     }
+                    // Track position
+                    const currentPositions = ctx.state.get("arbOpenPositions");
+                    currentPositions.push({
+                        symbol: best.symbol,
+                        longExchange: best.longExchange,
+                        shortExchange: best.shortExchange,
+                        entrySpread: best.spread,
+                        size: matched.size,
+                        mode: "perp-perp",
+                    });
+                    ctx.state.set("arbOpenPositions", currentPositions);
+                    ctx.state.set("arbPositions", currentPositions.length);
+                    ctx.log(`  [ARB] Position opened! (${currentPositions.length}/${params.max_positions})`);
+                    return [{ type: "noop" }];
+                }
+                // Log skip summary only when there were skips (avoids noise when nothing happened)
+                if (skipMargin > 0 || skipCooldown > 0) {
+                    const parts = [];
+                    if (skipMargin > 0)
+                        parts.push(`${skipMargin} margin`);
+                    if (skipCooldown > 0)
+                        parts.push(`${skipCooldown} cooldown`);
+                    ctx.log(`  [ARB] Skipped ${skipMargin + skipCooldown} opportunities (${parts.join(", ")})`);
                 }
             }
         }
@@ -528,16 +603,24 @@ export class FundingArbStrategy {
                     const longAdapter = adapters.get(pos.longExchange);
                     const shortAdapter = adapters.get(pos.shortExchange);
                     if (longAdapter && shortAdapter) {
+                        ctx.log(`  [ARB] Closing ${pos.symbol} on stop (${pos.size})`);
                         try {
-                            ctx.log(`  [ARB] Closing ${pos.symbol} on stop (${pos.size})`);
-                            await Promise.all([
-                                longAdapter.marketOrder(pos.symbol, "sell", pos.size),
-                                shortAdapter.marketOrder(pos.symbol, "buy", pos.size),
-                            ]);
+                            const closeLongResult = await longAdapter.marketOrder(pos.symbol, "sell", pos.size);
+                            logExecution({ type: "arb_close", exchange: pos.longExchange, symbol: pos.symbol, side: "sell", size: pos.size, status: "success", dryRun: false, meta: { mode: pos.mode, leg: "long", stop: true, response: closeLongResult } });
                         }
                         catch (err) {
                             const msg = err instanceof Error ? err.message : String(err);
-                            ctx.log(`  [ARB] Close on stop failed for ${pos.symbol}: ${msg}`);
+                            ctx.log(`  [ARB] Close on stop failed (long) for ${pos.symbol}: ${msg}`);
+                            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", stop: true } });
+                        }
+                        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", stop: true, response: closeShortResult } });
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            ctx.log(`  [ARB] Close on stop failed (short) for ${pos.symbol}: ${msg}`);
+                            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", stop: true } });
                         }
                     }
                 }
@@ -611,7 +694,7 @@ export class FundingArbStrategy {
         }
     }
     /** Open a spot-perp position: transfer USDC to spot, buy spot, short perp */
-    async openSpotPerp(opp, adapters, ctx) {
+    async openSpotPerp(opp, adapters, ctx, ratesByExchange) {
         const params = this.params;
         const exchangeName = opp.longExchange.replace("-spot", "");
         const perpAdapter = adapters.get(opp.shortExchange) ?? adapters.get(exchangeName);
@@ -625,19 +708,42 @@ export class FundingArbStrategy {
                 ctx.log(`  [ARB] Open spot-perp failed: spot adapter not available for ${exchangeName}`);
                 return false;
             }
-            // Balance check: need full notional for spot + margin for perp
+            // 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
+                ?? 1;
+            const leverage = Math.min(configLeverage, perpMaxLev);
+            // Set leverage on perp before ordering
+            try {
+                await perpAdapter.setLeverage(this.getPerpSymbol(opp.symbol, opp.shortExchange), leverage, "cross");
+            }
+            catch { /* non-critical */ }
+            // Balance check: spot needs full notional, perp needs sizeUsd / leverage margin
             let targetSizeUsd = params.size_usd;
             try {
                 const perpBal = await perpAdapter.getBalance();
-                const perpAvail = parseFloat(perpBal.available);
-                const maxAffordable = perpAvail * 0.8;
-                if (maxAffordable < 10) {
-                    ctx.log(`  [ARB] Skip spot-perp ${opp.symbol}: insufficient balance ($${perpAvail.toFixed(2)} available)`);
+                // Check margin usage
+                const perpEquity = parseFloat(perpBal.equity);
+                const perpMarginPct = perpEquity > 0 ? parseFloat(perpBal.marginUsed) / perpEquity * 100 : 0;
+                if (perpMarginPct > 80) {
+                    ctx.log(`  [ARB] Skip spot-perp ${opp.symbol}: perp margin usage too high (${perpMarginPct.toFixed(0)}%)`);
                     return false;
                 }
-                if (targetSizeUsd > maxAffordable) {
-                    ctx.log(`  [ARB] Spot-perp size reduced $${targetSizeUsd} → $${maxAffordable.toFixed(0)} (limited by balance)`);
-                    targetSizeUsd = Math.floor(maxAffordable);
+                const perpAvail = parseFloat(perpBal.available);
+                // Total needed from perp account: spot notional (to transfer) + perp margin
+                const perpMarginRequired = targetSizeUsd / leverage;
+                const totalNeeded = targetSizeUsd + perpMarginRequired;
+                if (perpAvail < totalNeeded) {
+                    // Solve for max affordable: perpAvail >= notional + notional/lev = notional*(1 + 1/lev)
+                    const maxNotional = perpAvail * 0.8 / (1 + 1 / leverage);
+                    if (maxNotional < 10) {
+                        ctx.log(`  [ARB] Skip spot-perp ${opp.symbol}: insufficient balance ($${perpAvail.toFixed(2)} available, need $${totalNeeded.toFixed(2)})`);
+                        return false;
+                    }
+                    ctx.log(`  [ARB] Spot-perp size reduced $${targetSizeUsd} → $${maxNotional.toFixed(0)} (limited by balance at ${leverage}x)`);
+                    targetSizeUsd = Math.floor(maxNotional);
                 }
             }
             catch { /* non-critical */ }
@@ -666,11 +772,46 @@ export class FundingArbStrategy {
             await this.transferUsdcToSpot(spotAdapter, exchangeName, transferAmt);
             ctx.log(`  [ARB] Transferred $${transferAmt} USDC to spot`);
             // Step 2: Buy spot
-            await spotAdapter.spotMarketOrder(opp.symbol, "buy", matched.size);
-            ctx.log(`  [ARB] Bought spot ${matched.size} ${opp.symbol}`);
+            let spotResult;
+            try {
+                spotResult = await spotAdapter.spotMarketOrder(opp.symbol, "buy", matched.size);
+                ctx.log(`  [ARB] Bought spot ${matched.size} ${opp.symbol}`);
+                logExecution({ type: "arb_entry", exchange: opp.longExchange, symbol: opp.symbol, side: "buy", size: matched.size, notional: matched.notional, status: "success", dryRun: false, meta: { mode: "spot-perp", leg: "spot", response: spotResult } });
+            }
+            catch (spotErr) {
+                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" } });
+                return false;
+            }
             // Step 3: Short perp
-            await perpAdapter.marketOrder(perpSymbol, "sell", matched.size);
-            ctx.log(`  [ARB] Shorted perp ${matched.size} ${perpSymbol}`);
+            try {
+                const perpResult = await perpAdapter.marketOrder(perpSymbol, "sell", matched.size);
+                ctx.log(`  [ARB] Shorted perp ${matched.size} ${perpSymbol}`);
+                logExecution({ type: "arb_entry", exchange: opp.shortExchange, symbol: opp.symbol, side: "sell", size: matched.size, notional: matched.notional, status: "success", dryRun: false, meta: { mode: "spot-perp", leg: "perp", response: perpResult } });
+            }
+            catch (perpErr) {
+                const msg = perpErr instanceof Error ? perpErr.message : String(perpErr);
+                ctx.log(`  [ARB] Open spot-perp failed (perp short) for ${opp.symbol}: ${msg} — ROLLING BACK spot buy`);
+                logExecution({ type: "arb_entry", exchange: opp.shortExchange, symbol: opp.symbol, side: "sell", size: matched.size, status: "failed", error: msg, dryRun: false, meta: { mode: "spot-perp", leg: "perp" } });
+                // Rollback: sell spot back and transfer USDC back to perp
+                try {
+                    await spotAdapter.spotMarketOrder(opp.symbol, "sell", matched.size);
+                    ctx.log(`  [ARB] Rollback success: sold spot ${matched.size} ${opp.symbol}`);
+                    logExecution({ type: "multi_leg_rollback", exchange: opp.longExchange, symbol: opp.symbol, side: "sell", size: matched.size, status: "success", dryRun: false });
+                    // Transfer USDC back to perp account
+                    try {
+                        await this.transferUsdcToPerp(spotAdapter, opp.longExchange.replace("-spot", ""), Math.ceil(matched.notional * 1.02));
+                    }
+                    catch { /* best effort */ }
+                }
+                catch (rbErr) {
+                    const rbMsg = rbErr instanceof Error ? rbErr.message : String(rbErr);
+                    ctx.log(`  [ARB] CRITICAL: Spot rollback failed for ${opp.symbol}: ${rbMsg}`);
+                    logExecution({ type: "multi_leg_rollback", exchange: opp.longExchange, symbol: opp.symbol, side: "sell", size: matched.size, status: "failed", error: rbMsg, dryRun: false });
+                }
+                return false;
+            }
             // Track position
             const currentPositions = ctx.state.get("arbOpenPositions");
             currentPositions.push({
@@ -684,7 +825,6 @@ export class FundingArbStrategy {
             ctx.state.set("arbOpenPositions", currentPositions);
             ctx.state.set("arbPositions", currentPositions.length);
             ctx.log(`  [ARB] Spot-perp position opened! (${currentPositions.length}/${params.max_positions})`);
-            logExecution({ type: "arb_entry", exchange: `${opp.longExchange}↔${opp.shortExchange}`, symbol: opp.symbol, side: "spot-long/perp-short", size: matched.size, notional: matched.notional, status: "success", dryRun: false, meta: { mode: "spot-perp", spread: opp.spread } });
             return true;
         }
         catch (err) {
@@ -795,6 +935,7 @@ export class FundingArbStrategy {
                 rate: parseFloat(m.fundingRate),
                 price: parseFloat(m.markPrice),
                 sizeDecimals: m.sizeDecimals,
+                maxLeverage: m.maxLeverage,
             }));
         }
         catch {

package/dist/commands/bot.js

@@ -435,6 +435,11 @@ export function registerBotCommands(program, getAdapter, getAdapterFor, isJson)
         .option("--config <path>", "YAML/JSON config file")
         .option("--headless", "Run without TUI dashboard")
         .option("--param <key=value>", "Strategy parameter (repeatable)", (val, acc) => [...acc, val], [])
+        .option("--max-positions <n>", "Max simultaneous positions")
+        .option("--size <usd>", "Position size per leg ($)")
+        .option("--min-spread <pct>", "Min annual spread to enter (%)")
+        .option("--close-spread <pct>", "Close when spread drops below (%)")
+        .option("--exchanges <list>", "Comma-separated exchanges")
         .action(async (strategyName, symbol, opts) => {
         if (!strategyName) {
             await import("../bot/engine.js");
@@ -493,6 +498,17 @@ export function registerBotCommands(program, getAdapter, getAdapterFor, isJson)
                 else
                     params[key] = raw;
             }
+            // Merge shorthand CLI options into params
+            if (opts.maxPositions)
+                params.max_positions = parseInt(opts.maxPositions);
+            if (opts.size)
+                params.size_usd = parseFloat(opts.size);
+            if (opts.minSpread)
+                params.min_spread = parseFloat(opts.minSpread);
+            if (opts.closeSpread)
+                params.close_spread = parseFloat(opts.closeSpread);
+            if (opts.exchanges)
+                params.exchanges = opts.exchanges;
             const adapter = await getAdapter();
             const strategy = parseStrategy(strategyName, params);
             config = {

package/dist/exchanges/aster.js

@@ -277,12 +277,53 @@ export class AsterAdapter {
     }
     // ── Trading ──
     async marketOrder(symbol, side, size) {
-        return this._signedPost("/fapi/v1/order", {
-            symbol: this._toApi(symbol),
+        const apiSymbol = this._toApi(symbol);
+        const result = await this._signedPost("/fapi/v1/order", {
+            symbol: apiSymbol,
             side: side.toUpperCase(),
             type: "MARKET",
             quantity: size,
         });
+        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: ${orderId})`);
+        }
+        return result;
     }
     async limitOrder(symbol, side, price, size, opts) {
         const params = {

package/dist/exchanges/hyperliquid.js

@@ -214,6 +214,7 @@ export class HyperliquidAdapter {
         const result = universe.map((asset, i) => {
             const ctx = (ctxs[i] ?? {});
             const sym = String(asset.name);
+            const szDec = this._szDecimalsMap.get(sym) ?? (asset.szDecimals !== undefined ? Number(asset.szDecimals) : undefined);
             return {
                 symbol: sym,
                 markPrice: String(ctx.markPx ?? mids[sym] ?? "0"),
@@ -222,6 +223,7 @@ export class HyperliquidAdapter {
                 volume24h: String(ctx.dayNtlVlm ?? "0"),
                 openInterest: String(ctx.openInterest ?? "0"),
                 maxLeverage: Number(asset.maxLeverage ?? 50),
+                sizeDecimals: szDec,
             };
         });
         this._marketsCache = result;

package/dist/exchanges/lighter.js

@@ -266,6 +266,8 @@ export class LighterAdapter {
             return this._marketsCache;
         const markets = [];
         try {
+            // Ensure _marketDecimals is populated (has supported_size_decimals per symbol)
+            await this.ensureMarketMap();
             // Fetch order book details and funding rates in parallel
             const [obRes, fundingRates] = await Promise.all([
                 this.restGet("/orderBookDetails", {}),
@@ -277,6 +279,7 @@ export class LighterAdapter {
                 const imf = d.min_initial_margin_fraction ?? d.default_initial_margin_fraction ?? 500;
                 const maxLev = imf > 0 ? Math.floor(10000 / imf) : 50;
                 const fr = fundingRates.get(d.symbol);
+                const dec = this._marketDecimals.get(d.symbol.toUpperCase());
                 markets.push({
                     symbol: d.symbol,
                     markPrice: fr?.markPrice ?? String(d.last_trade_price ?? 0),
@@ -285,6 +288,7 @@ export class LighterAdapter {
                     volume24h: String(d.daily_quote_token_volume ?? 0),
                     openInterest: String(d.open_interest ?? 0),
                     maxLeverage: maxLev,
+                    sizeDecimals: dec?.size,
                 });
             }
         }

package/dist/exchanges/pacifica.js

@@ -64,6 +64,9 @@ export class PacificaAdapter {
         const priceMap = new Map(prices.map((p) => [p.symbol, p]));
         const result = markets.map((m) => {
             const p = priceMap.get(m.symbol);
+            // Derive sizeDecimals from lot_size (e.g. "0.001" → 3, "1" → 0)
+            const lotSize = parseFloat(m.lot_size ?? "0");
+            const sizeDecimals = lotSize > 0 ? Math.max(0, -Math.floor(Math.log10(lotSize))) : undefined;
             return {
                 symbol: m.symbol,
                 markPrice: p?.mark ?? "-",
@@ -72,6 +75,8 @@ export class PacificaAdapter {
                 volume24h: p?.volume_24h ?? "-",
                 openInterest: p?.open_interest ?? "-",
                 maxLeverage: m.max_leverage,
+                sizeDecimals,
+                stepSize: lotSize > 0 ? m.lot_size : undefined,
             };
         });
         this._marketsCache = result;

package/package.json

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