perp-cli 0.7.1 → 0.7.3

package/dist/arb/sizing.d.ts

@@ -8,6 +8,7 @@ import type { ExchangeAdapter } from "../exchanges/index.js";
 export declare function computeMatchedSize(sizeUsd: number, price: number, longExchange: string, shortExchange: string, opts?: {
     longSizeDecimals?: number;
     shortSizeDecimals?: number;
+    lotSize?: number;
 }): {
     size: string;
     notional: number;

package/dist/arb/sizing.js

@@ -10,9 +10,16 @@ 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));
-    // Round DOWN to the least precise exchange's decimals
-    const factor = Math.pow(10, szDecimals);
-    const roundedSize = Math.floor(rawSize * factor) / factor;
+    // If lotSize is provided, round to nearest multiple of lotSize (floor)
+    let roundedSize;
+    if (opts?.lotSize && opts.lotSize > 0) {
+        roundedSize = Math.floor(rawSize / opts.lotSize) * opts.lotSize;
+    }
+    else {
+        // Round DOWN to the least precise exchange's decimals
+        const factor = Math.pow(10, szDecimals);
+        roundedSize = Math.floor(rawSize * factor) / factor;
+    }
     if (roundedSize <= 0)
         return null;
     // Verify notional meets minimum for both exchanges
@@ -20,15 +27,27 @@ export function computeMatchedSize(sizeUsd, price, longExchange, shortExchange,
     const minNotional = Math.max(getMinNotional(longExchange), getMinNotional(shortExchange));
     if (notional < minNotional) {
         // Try rounding UP instead
-        const roundedUp = Math.ceil(rawSize * factor) / factor;
+        let roundedUp;
+        if (opts?.lotSize && opts.lotSize > 0) {
+            roundedUp = Math.ceil(rawSize / opts.lotSize) * opts.lotSize;
+        }
+        else {
+            const factor = Math.pow(10, szDecimals);
+            roundedUp = Math.ceil(rawSize * factor) / factor;
+        }
         const notionalUp = roundedUp * price;
         // Only round up if the increase is small (< 20% over requested)
         if (notionalUp <= sizeUsd * 1.2) {
-            return { size: roundedUp.toFixed(szDecimals), notional: notionalUp };
+            return { size: formatSize(roundedUp, szDecimals, opts?.lotSize), notional: notionalUp };
         }
         return null; // Can't meet minimum
     }
-    return { size: roundedSize.toFixed(szDecimals), notional };
+    return { size: formatSize(roundedSize, szDecimals, opts?.lotSize), notional };
+}
+function formatSize(size, szDecimals, lotSize) {
+    if (lotSize && lotSize >= 1)
+        return String(Math.round(size));
+    return size.toFixed(szDecimals);
 }
 /** Size decimal precision by exchange (conservative fallbacks — prefer explicit decimals via opts) */
 function getSizeDecimals(exchange) {

package/dist/arb/utils.js

@@ -7,6 +7,7 @@ export const SETTLEMENT_SCHEDULES = {
     hyperliquid: Array.from({ length: 24 }, (_, i) => i), // every hour
     pacifica: Array.from({ length: 24 }, (_, i) => i), // every hour
     lighter: Array.from({ length: 24 }, (_, i) => i), // every hour
+    aster: [0, 8, 16], // every 8 hours (Binance convention)
 };
 /**
  * Get the most recent settlement time for an exchange.

package/dist/bot/conditions.js

@@ -41,7 +41,7 @@ export async function getMarketSnapshot(adapter, symbol) {
     const markets = await adapter.getMarkets();
     const m = markets.find(mk => mk.symbol.toUpperCase() === symbol.toUpperCase());
     if (!m) {
-        return { price: 0, high24h: 0, low24h: 0, volume24h: 0, fundingRate: 0, volatility24h: 0, rsi: NaN, spreadPct: 0 };
+        throw new Error(`Market "${symbol}" not found on ${adapter.name}`);
     }
     const price = parseFloat(m.markPrice);
     const fundingRate = parseFloat(m.fundingRate);
@@ -124,7 +124,6 @@ export function evaluateCondition(condition, snapshot, context) {
             const elapsed = (Date.now() - context.startTime) / 1000;
             return elapsed > val;
         }
-        // Custom exit conditions (not standard ConditionType but used in exit logic)
         case "max_drawdown":
             return (context.peakEquity - context.equity) > val;
         default:

package/dist/bot/config.d.ts

@@ -1,4 +1,4 @@
-export type ConditionType = "price_above" | "price_below" | "volatility_above" | "volatility_below" | "funding_rate_above" | "funding_rate_below" | "spread_above" | "rsi_above" | "rsi_below" | "balance_above" | "balance_below" | "time_after" | "always";
+export type ConditionType = "price_above" | "price_below" | "volatility_above" | "volatility_below" | "funding_rate_above" | "funding_rate_below" | "spread_above" | "rsi_above" | "rsi_below" | "balance_above" | "balance_below" | "time_after" | "max_drawdown" | "always";
 export interface Condition {
     type: ConditionType;
     value: number | string;
@@ -31,6 +31,7 @@ export interface DCAStrategyParams {
     interval_sec: number;
     total_orders: number;
     price_limit?: number;
+    side?: "buy" | "sell";
 }
 export interface FundingArbStrategyParams {
     type: "funding-arb";
@@ -56,6 +57,7 @@ export interface BotConfig {
     monitor_interval_sec: number;
 }
 export declare function loadBotConfig(pathOrInline: string): BotConfig;
+export declare function parseStrategy(type: string, raw: Record<string, unknown>): StrategyParams;
 export declare function quickGridConfig(opts: {
     exchange: string;
     symbol: string;

package/dist/bot/config.js

@@ -53,7 +53,7 @@ function parseBotConfig(raw) {
     };
     return { name, exchange, symbol, strategy, entry_conditions: entryConds, exit_conditions: exitConds, risk, monitor_interval_sec: monitorInterval };
 }
-function parseStrategy(type, raw) {
+export function parseStrategy(type, raw) {
     switch (type) {
         case "grid":
             return {
@@ -65,7 +65,7 @@ function parseStrategy(type, raw) {
                 range_pct: raw.range_pct !== undefined ? Number(raw.range_pct) : 3,
                 upper: raw.upper !== undefined ? Number(raw.upper) : undefined,
                 lower: raw.lower !== undefined ? Number(raw.lower) : undefined,
-                rebalance: raw.rebalance !== false,
+                rebalance: raw.rebalance !== false && raw.rebalance !== "false",
                 rebalance_cooldown: Number(raw.rebalance_cooldown ?? 60),
                 leverage: raw.leverage !== undefined ? Number(raw.leverage) : undefined,
             };
@@ -76,6 +76,7 @@ function parseStrategy(type, raw) {
                 interval_sec: Number(raw.interval_sec ?? raw.interval ?? 60),
                 total_orders: Number(raw.total_orders ?? raw.orders ?? 0),
                 price_limit: raw.price_limit !== undefined ? Number(raw.price_limit) : undefined,
+                side: raw.side !== undefined ? String(raw.side) : undefined,
             };
         case "funding-arb":
             return {
@@ -149,6 +150,7 @@ export function quickDCAConfig(opts) {
             interval_sec: opts.intervalSec,
             total_orders: opts.orders,
             price_limit: opts.priceLimit,
+            side: opts.side ?? "buy",
         },
         entry_conditions: entryConds,
         exit_conditions: [

package/dist/bot/engine.js

@@ -56,9 +56,11 @@ mode = "headless") {
         dailyStartDate: new Date().toISOString().slice(0, 10),
         fills: 0,
         totalPnl: 0,
+        initialEquity: 0,
         rebalanceCount: 0,
         lastRebalance: 0,
         strategyActive: false,
+        riskBreached: false,
     };
     // Resolve strategy from registry
     const strategyFactory = getStrategy(config.strategy.type);
@@ -84,7 +86,7 @@ mode = "headless") {
     let tuiUnmount;
     let paused = false;
     // Wrap log for TUI/JSON modes
-    const effectiveLog = mode === "json"
+    let effectiveLog = mode === "json"
         ? () => { } // JSON mode suppresses console log; NDJSON emitted per tick
         : mode === "tui"
             ? (msg) => tuiEmitter.emitLog(msg)
@@ -105,7 +107,7 @@ mode = "headless") {
         }
         catch {
             // Fallback to headless if TUI fails (e.g., non-TTY)
-            // mode stays as-is but we just use the original log
+            effectiveLog = log;
         }
     }
     const shutdown = () => { running = false; state.phase = "stopped"; };
@@ -130,6 +132,7 @@ mode = "headless") {
         state.equity = parseFloat(bal.equity);
         state.peakEquity = state.equity;
         state.dailyStartEquity = state.equity;
+        state.initialEquity = state.equity;
         effectiveLog(`  Starting equity: $${state.equity.toFixed(2)}`);
     }
     catch {
@@ -162,6 +165,7 @@ mode = "headless") {
                         state.dailyStartDate = today;
                     }
                     state.dailyPnl = state.equity - state.dailyStartEquity;
+                    state.totalPnl = state.equity - state.initialEquity;
                 }
                 catch { /* non-critical */ }
                 const context = {
@@ -217,6 +221,7 @@ mode = "headless") {
                                 ? `drawdown $${drawdown.toFixed(2)} > limit $${config.risk.max_drawdown}`
                                 : "exit condition met";
                         effectiveLog(`  Exiting: ${reason}`);
+                        state.riskBreached = riskBreached;
                         state.phase = "exiting";
                     }
                     else {
@@ -237,19 +242,29 @@ mode = "headless") {
                         effectiveLog(`  Pausing ${config.risk.pause_after_loss_sec}s after loss`);
                         state.phase = "paused";
                         await sleep(config.risk.pause_after_loss_sec * 1000);
+                        // Data will be refreshed on the next loop iteration (re-fetches snapshot + equity)
                         state.phase = "monitoring";
                         effectiveLog(`  Resuming monitoring...`);
                     }
-                    else {
-                        // If exit due to risk breach, stop completely
+                    else if (state.riskBreached) {
+                        // Risk breach (drawdown or daily loss exceeded) — stop completely
                         effectiveLog(`  Bot stopped.`);
                         break;
                     }
+                    else {
+                        // Normal exit condition (not risk breach) — return to monitoring
+                        state.phase = "monitoring";
+                        state.riskBreached = false;
+                        effectiveLog(`  Exit condition met, returning to monitoring...`);
+                    }
                 }
                 // ── Emit state update for TUI / JSON ──
-                const positions = await fetchPositions(adapter, config.symbol);
-                const openOrders = await fetchOpenOrders(adapter, config.symbol);
-                const tuiState = buildTuiState(state, config, snapshot, positions, openOrders, strategyCtx);
+                const [positions, openOrders, exchangeBalances] = await Promise.all([
+                    extraAdapters ? fetchAllPositions(adapter, config.symbol, extraAdapters) : fetchPositions(adapter, config.symbol, adapter.name),
+                    fetchOpenOrders(adapter, config.symbol),
+                    extraAdapters ? fetchExchangeBalances(adapter, extraAdapters) : Promise.resolve(undefined),
+                ]);
+                const tuiState = buildTuiState(state, config, snapshot, positions, openOrders, strategyCtx, exchangeBalances);
                 if (mode === "tui") {
                     tuiEmitter.emitState(tuiState);
                 }
@@ -351,18 +366,16 @@ async function executeActions(adapter, symbol, actions, log, dryRun = false) {
 // ── Enriched snapshot ──
 async function getEnrichedSnapshot(adapter, symbol) {
     const base = await getMarketSnapshot(adapter, symbol);
-    const [orderbook, klines, markets] = await Promise.all([
+    const [orderbook, klines] = await Promise.all([
         adapter.getOrderbook(symbol).catch(() => ({ bids: [], asks: [] })),
         adapter.getKlines(symbol, "1h", Date.now() - 24 * 60 * 60 * 1000, Date.now()).catch(() => []),
-        adapter.getMarkets().catch(() => []),
     ]);
-    const market = markets.find(m => m.symbol.toUpperCase().includes(symbol.toUpperCase()));
-    return { ...base, klines, orderbook, openInterest: market?.openInterest ?? "0" };
+    return { ...base, klines, orderbook, openInterest: "0" };
 }
 // ── Utils ──
-/** Count fill-producing actions (market orders and limit orders) */
+/** Count fill-producing actions (all order placements) */
 function countFills(actions) {
-    return actions.filter(a => a.type === "place_order" && a.orderType === "market").length;
+    return actions.filter(a => a.type === "place_order").length;
 }
 function logStatus(log, state, snapshot, phase) {
     const runtime = formatDuration(Math.floor((Date.now() - state.startTime) / 1000));
@@ -390,11 +403,12 @@ function sleep(ms) {
     return new Promise(r => setTimeout(r, ms));
 }
 // ── TUI helpers ──
-async function fetchPositions(adapter, symbol) {
+async function fetchPositions(adapter, symbol, exchangeName) {
     try {
         const positions = await adapter.getPositions();
+        const isAll = symbol.toUpperCase() === "ALL";
         return positions
-            .filter(p => p.symbol.toUpperCase().includes(symbol.toUpperCase()) && parseFloat(p.size) !== 0)
+            .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,
@@ -402,17 +416,47 @@ async function fetchPositions(adapter, symbol) {
             entryPrice: p.entryPrice,
             markPrice: p.markPrice,
             unrealizedPnl: p.unrealizedPnl,
+            exchange: exchangeName ?? adapter.name,
         }));
     }
     catch {
         return [];
     }
 }
+async function fetchExchangeBalances(primaryAdapter, extraAdapters) {
+    const adapters = [[primaryAdapter.name, primaryAdapter]];
+    if (extraAdapters) {
+        for (const [name, a] of extraAdapters)
+            adapters.push([name, a]);
+    }
+    const results = [];
+    await Promise.all(adapters.map(async ([name, a]) => {
+        try {
+            const bal = await a.getBalance();
+            results.push({ exchange: name, equity: bal.equity, available: bal.available });
+        }
+        catch { /* skip */ }
+    }));
+    return results;
+}
+async function fetchAllPositions(primaryAdapter, symbol, extraAdapters) {
+    const adapters = [[primaryAdapter.name, primaryAdapter]];
+    if (extraAdapters) {
+        for (const [name, a] of extraAdapters)
+            adapters.push([name, a]);
+    }
+    const all = [];
+    await Promise.all(adapters.map(async ([name, a]) => {
+        const pos = await fetchPositions(a, symbol, name);
+        all.push(pos);
+    }));
+    return all.flat();
+}
 async function fetchOpenOrders(adapter, symbol) {
     try {
         const orders = await adapter.getOpenOrders();
         return orders
-            .filter(o => o.symbol.toUpperCase().includes(symbol.toUpperCase()))
+            .filter(o => o.symbol.toUpperCase() === symbol.toUpperCase() || o.symbol.toUpperCase() === symbol.toUpperCase() + "-PERP")
             .map(o => ({
             orderId: o.orderId,
             side: o.side,
@@ -425,7 +469,7 @@ async function fetchOpenOrders(adapter, symbol) {
         return [];
     }
 }
-function buildTuiState(state, config, snapshot, positions, openOrders, strategyCtx) {
+function buildTuiState(state, config, snapshot, positions, openOrders, strategyCtx, exchangeBalances) {
     // Extract serializable strategy state from the Map
     const strategyState = {};
     for (const [k, v] of strategyCtx.state) {
@@ -453,12 +497,13 @@ function buildTuiState(state, config, snapshot, positions, openOrders, strategyC
         exchange: config.exchange,
         price: snapshot.price,
         volume24h: snapshot.volume24h ?? 0,
-        openInterest: "0",
+        openInterest: snapshot.openInterest ?? "0",
         fundingRate: snapshot.fundingRate,
         volatility24h: snapshot.volatility24h,
         positions,
         openOrders,
         strategyState,
         tick: strategyCtx.tick,
+        exchangeBalances,
     };
 }

package/dist/bot/index.d.ts

@@ -1,4 +1,4 @@
-export { loadBotConfig, quickGridConfig, quickDCAConfig, } from "./config.js";
+export { loadBotConfig, parseStrategy, quickGridConfig, quickDCAConfig, } from "./config.js";
 export type { ConditionType, Condition, RiskConfig, GridStrategyParams, DCAStrategyParams, FundingArbStrategyParams, GenericStrategyParams, StrategyParams, BotConfig, } from "./config.js";
 export { runBot } from "./engine.js";
 export type { BotLog, BotOutputMode } from "./engine.js";

package/dist/bot/index.js

@@ -1,5 +1,5 @@
 // bot/ barrel — public API
-export { loadBotConfig, quickGridConfig, quickDCAConfig, } from "./config.js";
+export { loadBotConfig, parseStrategy, quickGridConfig, quickDCAConfig, } from "./config.js";
 export { runBot } from "./engine.js";
 export { PRESETS, getPreset, getPresetsByStrategy } from "./presets.js";
 export { evaluateCondition, evaluateAllConditions, getMarketSnapshot, calculateRSI } from "./conditions.js";

package/dist/bot/presets.js

@@ -194,6 +194,7 @@ const dcaSeller = {
             amount: 0.01,
             interval_sec: 3600,
             total_orders: 24,
+            side: "sell",
         },
         entry_conditions: [{ type: "always", value: 0 }],
         exit_conditions: [],

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

@@ -34,19 +34,23 @@ export class DCAStrategy {
         // Check order limit
         if (params.total_orders > 0 && dcaOrdersPlaced >= params.total_orders)
             return [];
-        // Check price limit
+        // Check price limit (buy: skip if price too high, sell: skip if price too low)
         if (params.price_limit) {
-            if (snapshot.price > params.price_limit)
+            const side = params.side ?? "buy";
+            if (side === "buy" && snapshot.price > params.price_limit)
+                return [];
+            if (side === "sell" && snapshot.price < params.price_limit)
                 return [];
         }
         // Place market buy order
         ctx.state.set("dcaOrdersPlaced", dcaOrdersPlaced + 1);
         ctx.state.set("dcaLastOrder", Date.now());
+        const side = params.side ?? "buy";
         const progress = params.total_orders > 0 ? ` (${dcaOrdersPlaced + 1}/${params.total_orders})` : "";
-        ctx.log(`  [DCA] Order #${dcaOrdersPlaced + 1}${progress}: buy ${params.amount} ${ctx.symbol} @ $${snapshot.price.toFixed(2)}`);
+        ctx.log(`  [DCA] Order #${dcaOrdersPlaced + 1}${progress}: ${side} ${params.amount} ${ctx.symbol} @ $${snapshot.price.toFixed(2)}`);
         return [{
                 type: "place_order",
-                side: "buy",
+                side,
                 price: "0",
                 size: String(params.amount),
                 orderType: "market",

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

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

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

@@ -1,6 +1,7 @@
 import { registerStrategy } from "../strategy-registry.js";
 import { checkArbLiquidity } from "../../liquidity.js";
 import { computeMatchedSize, reconcileArbFills } from "../../arb-sizing.js";
+import { computeAnnualSpread } from "../../funding.js";
 export class FundingArbStrategy {
     name = "funding-arb";
     describe() {
@@ -23,13 +24,14 @@ export class FundingArbStrategy {
         this._config = ctx.config;
         const params = this.params;
         ctx.state.set("arbRunning", true);
+        ctx.state.set("arbOpenPositions", []);
         ctx.state.set("arbPositions", 0);
-        ctx.log(`  [ARB] Funding arb ready | spread >= ${params.min_spread}% | size $${params.size_usd}`);
+        ctx.log(`  [ARB] Funding arb ready | spread >= ${params.min_spread}% | close < ${params.close_spread}% | size $${params.size_usd}`);
         ctx.log(`  [ARB] Exchanges: ${params.exchanges.join(", ")}`);
     }
     async onTick(ctx, _snapshot) {
         const params = this.params;
-        const arbPositions = ctx.state.get("arbPositions");
+        const openPositions = ctx.state.get("arbOpenPositions");
         // Get extra adapters from context state (set by engine)
         const extraAdapters = ctx.state.get("extraAdapters");
         // Build adapter map from primary + extras
@@ -52,7 +54,42 @@ export class FundingArbStrategy {
                 map.set(r.symbol.toUpperCase(), { rate: r.rate, price: r.price });
             ratesByExchange.set(name, map);
         }
-        // Find opportunities
+        // ── Check existing positions for close_spread ──
+        const toClose = [];
+        for (const pos of openPositions) {
+            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)
+                continue;
+            const currentSpread = computeAnnualSpread(shortRate, pos.shortExchange, longRate, pos.longExchange);
+            if (currentSpread < params.close_spread) {
+                ctx.log(`  [ARB] Closing ${pos.symbol}: spread ${currentSpread.toFixed(1)}% < close_spread ${params.close_spread}% (entry: ${pos.entrySpread.toFixed(1)}%)`);
+                const longAdapter = adapters.get(pos.longExchange);
+                const shortAdapter = adapters.get(pos.shortExchange);
+                if (longAdapter && shortAdapter) {
+                    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`);
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        ctx.log(`  [ARB] Close failed for ${pos.symbol}: ${msg}`);
+                    }
+                }
+            }
+        }
+        // Remove closed positions
+        if (toClose.length > 0) {
+            const remaining = openPositions.filter(p => !toClose.includes(p));
+            ctx.state.set("arbOpenPositions", remaining);
+            ctx.state.set("arbPositions", remaining.length);
+        }
+        // ── Find new opportunities ──
+        const arbPositions = ctx.state.get("arbOpenPositions").length;
         const exchangeNames = [...ratesByExchange.keys()];
         const opportunities = [];
         const allSymbols = new Set();
@@ -77,8 +114,7 @@ export class FundingArbStrategy {
                 }
             }
             if (minExchange && maxExchange && minExchange !== maxExchange) {
-                const { computeAnnualSpread: cas } = await import("../../funding.js");
-                const spread = cas(maxRate, maxExchange, minRate, minExchange);
+                const spread = computeAnnualSpread(maxRate, maxExchange, minRate, minExchange);
                 if (spread >= params.min_spread) {
                     opportunities.push({
                         symbol: sym,
@@ -110,17 +146,41 @@ export class FundingArbStrategy {
                         if (!liq.viable)
                             return [];
                         // Compute matched size
-                        const matched = computeMatchedSize(liq.adjustedSizeUsd, price, best.longExchange, best.shortExchange);
+                        let matched = computeMatchedSize(liq.adjustedSizeUsd, price, best.longExchange, best.shortExchange);
                         if (!matched) {
                             ctx.log(`  [ARB] Skip ${best.symbol}: can't compute matched size (min notional or precision issue)`);
                             return [];
                         }
                         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)}%)`);
-                            await Promise.all([
-                                longAdapter.marketOrder(best.symbol, "buy", matched.size),
-                                shortAdapter.marketOrder(best.symbol, "sell", matched.size),
-                            ]);
+                            try {
+                                await Promise.all([
+                                    longAdapter.marketOrder(best.symbol, "buy", matched.size),
+                                    shortAdapter.marketOrder(best.symbol, "sell", matched.size),
+                                ]);
+                            }
+                            catch (orderErr) {
+                                // Parse lot size from error and retry with corrected size
+                                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 });
+                                    if (!matched) {
+                                        ctx.log(`  [ARB] Skip ${best.symbol}: can't meet lot size ${lotSize}`);
+                                        return [];
+                                    }
+                                    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, correct if needed
                             try {
                                 const recon = await reconcileArbFills(longAdapter, shortAdapter, best.symbol, (msg) => ctx.log(`  ${msg}`));
@@ -128,9 +188,22 @@ export class FundingArbStrategy {
                                     ctx.log(`  [ARB] WARNING: fills not matched after correction attempt`);
                                 }
                             }
-                            catch { /* non-critical */ }
-                            ctx.state.set("arbPositions", arbPositions + 1);
-                            ctx.log(`  [ARB] Position opened! (${arbPositions + 1}/${params.max_positions})`);
+                            catch (reconErr) {
+                                const reconMsg = reconErr instanceof Error ? reconErr.message : String(reconErr);
+                                ctx.log(`  [ARB] WARNING: Fill reconciliation failed: ${reconMsg}`);
+                            }
+                            // Track position in array
+                            const currentPositions = ctx.state.get("arbOpenPositions");
+                            currentPositions.push({
+                                symbol: best.symbol,
+                                longExchange: best.longExchange,
+                                shortExchange: best.shortExchange,
+                                entrySpread: best.spread,
+                                size: matched.size,
+                            });
+                            ctx.state.set("arbOpenPositions", currentPositions);
+                            ctx.state.set("arbPositions", currentPositions.length);
+                            ctx.log(`  [ARB] Position opened! (${currentPositions.length}/${params.max_positions})`);
                             // Return noop -- we already executed directly via adapters
                             // (arb requires multi-adapter coordination, can't be expressed as single-adapter actions)
                             return [{ type: "noop" }];
@@ -148,7 +221,46 @@ export class FundingArbStrategy {
         }
         return [];
     }
-    async onStop(_ctx) {
+    async onStop(ctx) {
+        const openPositions = ctx.state.get("arbOpenPositions");
+        const extraAdapters = ctx.state.get("extraAdapters");
+        // Close all open arb positions
+        if (openPositions && openPositions.length > 0) {
+            const adapters = new Map();
+            adapters.set(ctx.adapter.name.toLowerCase(), ctx.adapter);
+            if (extraAdapters) {
+                for (const [name, a] of extraAdapters)
+                    adapters.set(name, a);
+            }
+            for (const pos of openPositions) {
+                const longAdapter = adapters.get(pos.longExchange);
+                const shortAdapter = adapters.get(pos.shortExchange);
+                if (longAdapter && shortAdapter) {
+                    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),
+                        ]);
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        ctx.log(`  [ARB] Close on stop failed for ${pos.symbol}: ${msg}`);
+                    }
+                }
+            }
+            ctx.state.set("arbOpenPositions", []);
+            ctx.state.set("arbPositions", 0);
+        }
+        // Cancel on extra adapters directly (M2: was only cancelling on primary adapter)
+        if (extraAdapters) {
+            for (const [, a] of extraAdapters) {
+                try {
+                    await a.cancelAllOrders();
+                }
+                catch { /* best effort */ }
+            }
+        }
         return [{ type: "cancel_all" }];
     }
     async fetchRates(adapter, _exchangeName) {