perp-cli 0.3.3

package/dist/strategies/dca.js

@@ -0,0 +1,114 @@
+import { updateJobState } from "../jobs.js";
+export async function runDCA(adapter, params, jobId, log = console.log) {
+    const { symbol, side, amountPerOrder, intervalSec, totalOrders } = params;
+    const maxRuntime = (params.maxRuntime ?? 0) * 1000;
+    const state = {
+        ordersPlaced: 0,
+        totalFilled: 0,
+        totalCost: 0,
+        avgPrice: 0,
+        errors: 0,
+        startedAt: Date.now(),
+        running: true,
+    };
+    const target = totalOrders > 0 ? `${totalOrders} orders` : "unlimited (Ctrl+C to stop)";
+    log(`[DCA] ${side.toUpperCase()} ${amountPerOrder} ${symbol} every ${intervalSec}s | ${target}`);
+    if (params.priceLimit) {
+        log(`[DCA] Price limit: $${params.priceLimit} (${side === "buy" ? "won't buy above" : "won't sell below"})`);
+    }
+    // Graceful shutdown
+    const shutdown = () => { state.running = false; };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    try {
+        while (state.running) {
+            // Check if we've reached order limit
+            if (totalOrders > 0 && state.ordersPlaced >= totalOrders) {
+                log(`[DCA] Reached target of ${totalOrders} orders. Done.`);
+                break;
+            }
+            // Check max runtime
+            if (maxRuntime > 0 && Date.now() - state.startedAt > maxRuntime) {
+                log(`[DCA] Max runtime reached. Stopping.`);
+                break;
+            }
+            // Check price limit
+            if (params.priceLimit) {
+                try {
+                    const markets = await adapter.getMarkets();
+                    const market = markets.find(m => m.symbol.toUpperCase() === symbol.toUpperCase());
+                    if (market) {
+                        const price = parseFloat(market.markPrice);
+                        if (side === "buy" && price > params.priceLimit) {
+                            log(`[DCA] Price $${price.toFixed(2)} > limit $${params.priceLimit}. Skipping.`);
+                            await sleep(intervalSec * 1000);
+                            continue;
+                        }
+                        if (side === "sell" && price < params.priceLimit) {
+                            log(`[DCA] Price $${price.toFixed(2)} < limit $${params.priceLimit}. Skipping.`);
+                            await sleep(intervalSec * 1000);
+                            continue;
+                        }
+                    }
+                }
+                catch {
+                    // non-critical, proceed with order
+                }
+            }
+            // Place market order
+            try {
+                const result = await adapter.marketOrder(symbol, side, String(amountPerOrder));
+                state.ordersPlaced++;
+                state.totalFilled += amountPerOrder;
+                const fillPrice = Number(result?.price ?? result?.avg_price ?? result?.fill_price ?? 0);
+                if (fillPrice > 0) {
+                    state.totalCost += amountPerOrder * fillPrice;
+                    state.avgPrice = state.totalCost / state.totalFilled;
+                }
+                const progress = totalOrders > 0 ? ` (${state.ordersPlaced}/${totalOrders})` : "";
+                log(`[DCA] Order #${state.ordersPlaced}${progress}: ${side} ${amountPerOrder} ${symbol}${state.avgPrice > 0 ? ` @ $${state.avgPrice.toFixed(2)} avg` : ""}`);
+                // Update job state
+                if (jobId) {
+                    updateJobState(jobId, {
+                        result: {
+                            ordersPlaced: state.ordersPlaced,
+                            totalFilled: state.totalFilled,
+                            avgPrice: state.avgPrice,
+                            errors: state.errors,
+                            runtime: Math.floor((Date.now() - state.startedAt) / 1000),
+                        },
+                    });
+                }
+            }
+            catch (err) {
+                state.errors++;
+                const msg = err instanceof Error ? err.message : String(err);
+                log(`[DCA] Order error: ${msg}`);
+                if (state.errors > 10 && state.errors > state.ordersPlaced) {
+                    log(`[DCA] Too many errors. Stopping.`);
+                    break;
+                }
+            }
+            // Wait for next interval
+            if (state.running && (totalOrders === 0 || state.ordersPlaced < totalOrders)) {
+                await sleep(intervalSec * 1000);
+            }
+        }
+    }
+    finally {
+        process.removeListener("SIGINT", shutdown);
+        process.removeListener("SIGTERM", shutdown);
+    }
+    const runtime = Math.floor((Date.now() - state.startedAt) / 1000);
+    log(`[DCA] Done. ${state.ordersPlaced} orders, ${state.totalFilled} filled, avg $${state.avgPrice.toFixed(2)}, ${state.errors} errors, ${runtime}s`);
+    if (jobId) {
+        updateJobState(jobId, {
+            status: "done",
+            result: { ordersPlaced: state.ordersPlaced, totalFilled: state.totalFilled, avgPrice: state.avgPrice, runtime },
+        });
+    }
+    return { ordersPlaced: state.ordersPlaced, totalFilled: state.totalFilled, avgPrice: state.avgPrice, runtime };
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

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

@@ -0,0 +1,15 @@
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export interface FundingArbParams {
+    minSpread: number;
+    closeSpread: number;
+    size: string;
+    sizeUsd?: number;
+    symbols?: string[];
+    intervalSec: number;
+    autoExecute: boolean;
+    maxPositions?: number;
+    autoRebalance?: boolean;
+    rebalanceThreshold?: number;
+    maxDrawdown?: number;
+}
+export declare function runFundingArb(adapters: Map<string, ExchangeAdapter>, params: FundingArbParams, jobId?: string, log?: (msg: string) => void): Promise<void>;

package/dist/strategies/funding-arb.js

@@ -0,0 +1,281 @@
+import { symbolMatch } from "../utils.js";
+import { updateJobState } from "../jobs.js";
+import { fetchAllBalances, computeRebalancePlan, hasEnoughBalance } from "../rebalance.js";
+import { checkArbLiquidity } from "../liquidity.js";
+import { computeAnnualSpread } from "../funding.js";
+import { fetchPacificaPrices, fetchHyperliquidMeta, fetchLighterOrderBookDetails, fetchLighterFundingRates, } from "../shared-api.js";
+import { computeMatchedSize, reconcileArbFills } from "../arb-sizing.js";
+async function fetchAllRates() {
+    const [pacRates, hlRates, ltRates] = await Promise.allSettled([
+        fetchPacificaPrices().then(assets => assets.map(p => ({
+            exchange: "pacifica", symbol: p.symbol, fundingRate: p.funding, markPrice: p.mark,
+        }))),
+        fetchHyperliquidMeta().then(assets => assets.map(a => ({
+            exchange: "hyperliquid", symbol: a.symbol, fundingRate: a.funding, markPrice: a.markPx,
+        }))),
+        (async () => {
+            const [details, funding] = await Promise.all([
+                fetchLighterOrderBookDetails(),
+                fetchLighterFundingRates(),
+            ]);
+            const priceMap = new Map(details.map(d => [d.marketId, d.lastTradePrice]));
+            const symMap = new Map(details.map(d => [d.marketId, d.symbol]));
+            return funding.map(fr => ({
+                exchange: "lighter",
+                symbol: fr.symbol || symMap.get(fr.marketId) || "",
+                fundingRate: fr.rate,
+                markPrice: fr.markPrice || priceMap.get(fr.marketId) || 0,
+            }));
+        })(),
+    ]);
+    return [
+        ...(pacRates.status === "fulfilled" ? pacRates.value : []),
+        ...(hlRates.status === "fulfilled" ? hlRates.value : []),
+        ...(ltRates.status === "fulfilled" ? ltRates.value : []),
+    ];
+}
+// annualize: use computeAnnualSpread from funding.ts for cross-exchange comparison
+export async function runFundingArb(adapters, params, jobId, log = console.log) {
+    const maxPos = params.maxPositions ?? 3;
+    const closeSpread = params.closeSpread ?? 5;
+    const positions = [];
+    let cycleCount = 0;
+    let lastRebalanceCheck = 0;
+    log(`[ARB] Funding rate arbitrage started`);
+    log(`[ARB] Entry spread: >= ${params.minSpread}% | Close spread: <= ${closeSpread}%`);
+    log(`[ARB] Size: ${params.size} | Interval: ${params.intervalSec}s`);
+    log(`[ARB] Auto-execute: ${params.autoExecute} | Max positions: ${maxPos}`);
+    log(`[ARB] Exchanges: ${[...adapters.keys()].join(", ")}`);
+    if (params.autoRebalance)
+        log(`[ARB] Auto-rebalance: ON (threshold: $${params.rebalanceThreshold ?? 100})`);
+    if (params.maxDrawdown)
+        log(`[ARB] Max drawdown: $${params.maxDrawdown}`);
+    if (params.symbols?.length)
+        log(`[ARB] Symbols: ${params.symbols.join(", ")}`);
+    while (true) {
+        cycleCount++;
+        try {
+            const rates = await fetchAllRates();
+            // Group by symbol
+            const rateMap = new Map();
+            for (const r of rates) {
+                if (params.symbols?.length && !params.symbols.includes(r.symbol))
+                    continue;
+                if (!rateMap.has(r.symbol))
+                    rateMap.set(r.symbol, []);
+                rateMap.get(r.symbol).push(r);
+            }
+            // ── Phase 1: Check positions for close conditions ──
+            for (let i = positions.length - 1; i >= 0; i--) {
+                const pos = positions[i];
+                const symbolRates = rateMap.get(pos.symbol);
+                if (!symbolRates)
+                    continue;
+                const longRate = symbolRates.find((r) => r.exchange === pos.longExchange);
+                const shortRate = symbolRates.find((r) => r.exchange === pos.shortExchange);
+                if (!longRate || !shortRate)
+                    continue;
+                const currentSpread = computeAnnualSpread(shortRate.fundingRate, shortRate.exchange, longRate.fundingRate, longRate.exchange);
+                if (currentSpread <= closeSpread) {
+                    log(`[ARB] CLOSE signal: ${pos.symbol} spread ${currentSpread.toFixed(1)}% <= ${closeSpread}%`);
+                    if (params.autoExecute) {
+                        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),
+                                ]);
+                                log(`[ARB] CLOSED ${pos.symbol} — both legs unwound`);
+                                // Estimate P&L from funding collected
+                                const hoursOpen = (Date.now() - pos.openedAt) / (1000 * 60 * 60);
+                                // entrySpread is annualized %; convert to per-hour rate
+                                const hourlySpreadRate = pos.entrySpread / 100 / (24 * 365);
+                                const estimatedFunding = hourlySpreadRate * hoursOpen * Number(pos.size) * pos.entryPrices.long;
+                                log(`[ARB] Est. funding P&L: ~$${estimatedFunding.toFixed(2)} (${hoursOpen.toFixed(1)}h open)`);
+                            }
+                            catch (err) {
+                                const msg = err instanceof Error ? err.message : String(err);
+                                log(`[ARB] Close error: ${msg}`);
+                                continue; // don't remove position if close failed
+                            }
+                        }
+                    }
+                    positions.splice(i, 1);
+                }
+            }
+            // ── Phase 2: Max drawdown check ──
+            if (params.maxDrawdown && params.autoExecute && positions.length > 0) {
+                try {
+                    const snapshots = await fetchAllBalances(adapters);
+                    const totalPnl = snapshots.reduce((s, e) => s + e.unrealizedPnl, 0);
+                    if (totalPnl < -params.maxDrawdown) {
+                        log(`[ARB] MAX DRAWDOWN hit: uPnL $${totalPnl.toFixed(2)} < -$${params.maxDrawdown}`);
+                        log(`[ARB] Closing all ${positions.length} positions...`);
+                        await closeAllPositions(positions, adapters, log);
+                        positions.length = 0;
+                    }
+                }
+                catch { /* non-critical */ }
+            }
+            // ── Phase 3: Balance check + rebalance trigger ──
+            let balanceSnapshots = null;
+            const shouldCheckBalance = params.autoRebalance && (Date.now() - lastRebalanceCheck > 300_000); // every 5 min
+            if (shouldCheckBalance || (params.autoExecute && positions.length < maxPos)) {
+                try {
+                    balanceSnapshots = await fetchAllBalances(adapters);
+                    lastRebalanceCheck = Date.now();
+                    if (params.autoRebalance) {
+                        const threshold = params.rebalanceThreshold ?? 100;
+                        const lowExchanges = balanceSnapshots.filter((s) => s.available < threshold);
+                        if (lowExchanges.length > 0) {
+                            const plan = computeRebalancePlan(balanceSnapshots, { minMove: 50, reserve: 20 });
+                            if (plan.moves.length > 0) {
+                                log(`[ARB] Rebalance needed: ${plan.summary}`);
+                                for (const move of plan.moves) {
+                                    log(`[ARB]   $${move.amount} ${move.from} → ${move.to}`);
+                                }
+                                log(`[ARB] Run 'perp rebalance execute' to rebalance.`);
+                            }
+                        }
+                    }
+                }
+                catch { /* non-critical */ }
+            }
+            // ── Phase 4: Find new entry opportunities ──
+            if (positions.length < maxPos) {
+                for (const [symbol, symbolRates] of rateMap) {
+                    if (symbolRates.length < 2)
+                        continue;
+                    if (positions.find((p) => symbolMatch(p.symbol, symbol)))
+                        continue;
+                    if (positions.length >= maxPos)
+                        break;
+                    // Only consider exchanges we have adapters for
+                    const available = symbolRates.filter((r) => adapters.has(r.exchange));
+                    if (available.length < 2)
+                        continue;
+                    available.sort((a, b) => a.fundingRate - b.fundingRate);
+                    const lowest = available[0];
+                    const highest = available[available.length - 1];
+                    if (lowest.exchange === highest.exchange)
+                        continue;
+                    const annualSpread = computeAnnualSpread(highest.fundingRate, highest.exchange, lowest.fundingRate, lowest.exchange);
+                    if (annualSpread >= params.minSpread) {
+                        const longEx = lowest.exchange;
+                        const shortEx = highest.exchange;
+                        log(`[ARB] ENTRY signal: ${symbol} spread ${annualSpread.toFixed(1)}% — long ${longEx} (${(lowest.fundingRate * 100).toFixed(4)}%) / short ${shortEx} (${(highest.fundingRate * 100).toFixed(4)}%)`);
+                        if (params.autoExecute) {
+                            const longAdapter = adapters.get(longEx);
+                            const shortAdapter = adapters.get(shortEx);
+                            if (!longAdapter || !shortAdapter) {
+                                log(`[ARB] Skip: adapter not available for ${longEx} or ${shortEx}`);
+                                continue;
+                            }
+                            // Check orderbook liquidity & adjust size
+                            const requestedUsd = params.sizeUsd ?? Number(params.size) * highest.markPrice;
+                            const liq = await checkArbLiquidity(longAdapter, shortAdapter, symbol, requestedUsd, 0.5, log);
+                            if (!liq.viable)
+                                continue;
+                            // Compute matched size (same for both legs)
+                            const matched = computeMatchedSize(liq.adjustedSizeUsd, highest.markPrice, longEx, shortEx);
+                            if (!matched) {
+                                log(`[ARB] Skip ${symbol}: can't compute matched size (min notional or precision issue)`);
+                                continue;
+                            }
+                            // Check balances before trading
+                            if (balanceSnapshots) {
+                                if (!hasEnoughBalance(balanceSnapshots, longEx, matched.notional) ||
+                                    !hasEnoughBalance(balanceSnapshots, shortEx, matched.notional)) {
+                                    log(`[ARB] Skip ${symbol}: insufficient balance on ${longEx} or ${shortEx} (need ~$${matched.notional.toFixed(0)} per leg)`);
+                                    continue;
+                                }
+                            }
+                            try {
+                                log(`[ARB] Opening: ${matched.size} ${symbol} on both legs ($${matched.notional.toFixed(0)}/leg, slippage ~${liq.longSlippage.toFixed(2)}%/${liq.shortSlippage.toFixed(2)}%)...`);
+                                await Promise.all([
+                                    longAdapter.marketOrder(symbol, "buy", matched.size),
+                                    shortAdapter.marketOrder(symbol, "sell", matched.size),
+                                ]);
+                                // Verify fills match, correct if needed
+                                try {
+                                    const recon = await reconcileArbFills(longAdapter, shortAdapter, symbol, log);
+                                    if (!recon.matched) {
+                                        log(`[ARB] WARNING: fills not matched after correction attempt`);
+                                    }
+                                }
+                                catch { /* non-critical */ }
+                                positions.push({
+                                    symbol,
+                                    longExchange: longEx,
+                                    shortExchange: shortEx,
+                                    size: matched.size,
+                                    entrySpread: annualSpread,
+                                    openedAt: Date.now(),
+                                    entryPrices: { long: lowest.markPrice, short: highest.markPrice },
+                                });
+                                log(`[ARB] OPENED ${symbol} delta-neutral (${positions.length}/${maxPos})`);
+                            }
+                            catch (err) {
+                                const msg = err instanceof Error ? err.message : String(err);
+                                log(`[ARB] Entry error: ${msg}`);
+                            }
+                        }
+                    }
+                }
+            }
+            // ── Update job state ──
+            if (jobId) {
+                updateJobState(jobId, {
+                    result: {
+                        cycle: cycleCount,
+                        activePositions: positions.length,
+                        positions: positions.map((p) => ({
+                            symbol: p.symbol,
+                            long: p.longExchange,
+                            short: p.shortExchange,
+                            size: p.size,
+                            entrySpread: p.entrySpread,
+                            hoursOpen: ((Date.now() - p.openedAt) / 3_600_000).toFixed(1),
+                        })),
+                        lastCheck: new Date().toISOString(),
+                    },
+                });
+            }
+            // Periodic status log
+            if (cycleCount % 10 === 0) {
+                const posInfo = positions.length > 0
+                    ? positions.map((p) => `${p.symbol}(${p.entrySpread.toFixed(0)}%)`).join(", ")
+                    : "none";
+                log(`[ARB] Cycle ${cycleCount} | ${positions.length} positions: ${posInfo} | ${rateMap.size} symbols`);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(`[ARB] Cycle error: ${msg}`);
+        }
+        await sleep(params.intervalSec * 1000);
+    }
+}
+async function closeAllPositions(positions, adapters, log) {
+    for (const pos of positions) {
+        const longAdapter = adapters.get(pos.longExchange);
+        const shortAdapter = adapters.get(pos.shortExchange);
+        if (!longAdapter || !shortAdapter)
+            continue;
+        try {
+            await Promise.all([
+                longAdapter.marketOrder(pos.symbol, "sell", pos.size),
+                shortAdapter.marketOrder(pos.symbol, "buy", pos.size),
+            ]);
+            log(`[ARB] Emergency closed ${pos.symbol}`);
+        }
+        catch (err) {
+            log(`[ARB] Failed to close ${pos.symbol}: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/dist/strategies/grid.d.ts

@@ -0,0 +1,34 @@
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export interface GridParams {
+    symbol: string;
+    side: "long" | "short" | "neutral";
+    upperPrice: number;
+    lowerPrice: number;
+    grids: number;
+    totalSize: number;
+    leverage?: number;
+    intervalSec?: number;
+    maxRuntime?: number;
+    trailingStop?: number;
+}
+export interface GridState {
+    gridLines: GridLine[];
+    activeOrders: Map<string, string>;
+    fills: number;
+    totalPnl: number;
+    peakEquity: number;
+    startedAt: number;
+    running: boolean;
+}
+interface GridLine {
+    price: number;
+    side: "buy" | "sell";
+    size: number;
+    filled: boolean;
+}
+export declare function runGrid(adapter: ExchangeAdapter, params: GridParams, jobId?: string, log?: (msg: string) => void): Promise<{
+    fills: number;
+    totalPnl: number;
+    runtime: number;
+}>;
+export {};

package/dist/strategies/grid.js

@@ -0,0 +1,185 @@
+import { updateJobState } from "../jobs.js";
+export async function runGrid(adapter, params, jobId, log = console.log) {
+    const { symbol, upperPrice, lowerPrice, grids, totalSize } = params;
+    const intervalMs = (params.intervalSec ?? 10) * 1000;
+    const maxRuntime = (params.maxRuntime ?? 0) * 1000;
+    const sizePerGrid = totalSize / grids;
+    if (upperPrice <= lowerPrice)
+        throw new Error("upperPrice must be > lowerPrice");
+    if (grids < 2)
+        throw new Error("Need at least 2 grid lines");
+    // Set leverage if specified
+    if (params.leverage) {
+        try {
+            await adapter.setLeverage(symbol, params.leverage);
+            log(`[GRID] Leverage set to ${params.leverage}x`);
+        }
+        catch {
+            log(`[GRID] Could not set leverage (may not be supported)`);
+        }
+    }
+    // Build grid lines
+    const step = (upperPrice - lowerPrice) / (grids - 1);
+    const gridLines = [];
+    for (let i = 0; i < grids; i++) {
+        gridLines.push({
+            price: lowerPrice + step * i,
+            side: "buy", // will be set based on current price
+            size: sizePerGrid,
+            filled: false,
+        });
+    }
+    log(`[GRID] ${symbol} ${params.side} | ${grids} grids | $${lowerPrice} - $${upperPrice} | step $${step.toFixed(2)}`);
+    log(`[GRID] Size per grid: ${sizePerGrid.toFixed(6)} | Total: ${totalSize}`);
+    const state = {
+        gridLines,
+        activeOrders: new Map(),
+        fills: 0,
+        totalPnl: 0,
+        peakEquity: 0,
+        startedAt: Date.now(),
+        running: true,
+    };
+    // Graceful shutdown
+    const shutdown = () => { state.running = false; };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    try {
+        // Get current price to determine buy/sell sides
+        const markets = await adapter.getMarkets();
+        const market = markets.find(m => m.symbol.toUpperCase() === symbol.toUpperCase());
+        const currentPrice = market ? parseFloat(market.markPrice) : (upperPrice + lowerPrice) / 2;
+        // Assign sides: buy below current, sell above current
+        for (const line of gridLines) {
+            if (params.side === "long") {
+                line.side = "buy";
+            }
+            else if (params.side === "short") {
+                line.side = "sell";
+            }
+            else {
+                line.side = line.price < currentPrice ? "buy" : "sell";
+            }
+        }
+        log(`[GRID] Current price: $${currentPrice.toFixed(2)} | Placing ${grids} limit orders...`);
+        // Place initial grid orders
+        await placeGridOrders(adapter, symbol, gridLines, state, log);
+        // Main loop: monitor fills and replace orders
+        while (state.running) {
+            await sleep(intervalMs);
+            if (maxRuntime > 0 && Date.now() - state.startedAt > maxRuntime) {
+                log(`[GRID] Max runtime reached. Stopping.`);
+                break;
+            }
+            try {
+                // Check open orders
+                const openOrders = await adapter.getOpenOrders();
+                const openIds = new Set(openOrders.filter(o => o.symbol.toUpperCase() === symbol.toUpperCase()).map(o => o.orderId));
+                // Find filled grid orders
+                let newFills = 0;
+                for (let i = 0; i < gridLines.length; i++) {
+                    const orderId = state.activeOrders.get(String(i));
+                    if (orderId && !openIds.has(orderId)) {
+                        // Order filled — flip and replace
+                        const line = gridLines[i];
+                        state.fills++;
+                        newFills++;
+                        line.filled = true;
+                        // Flip side: buy → sell, sell → buy (take profit at next grid)
+                        const newSide = line.side === "buy" ? "sell" : "buy";
+                        const newPrice = line.side === "buy"
+                            ? line.price + step // sell one grid above
+                            : line.price - step; // buy one grid below
+                        if (newPrice >= lowerPrice && newPrice <= upperPrice) {
+                            try {
+                                const result = await adapter.limitOrder(symbol, newSide, String(newPrice.toFixed(2)), String(line.size));
+                                const newOrderId = String(result?.orderId ?? result?.oid ?? result?.id ?? "");
+                                state.activeOrders.set(String(i), newOrderId);
+                                line.side = newSide;
+                                line.price = newPrice;
+                                line.filled = false;
+                            }
+                            catch (err) {
+                                const msg = err instanceof Error ? err.message : String(err);
+                                log(`[GRID] Replace order error: ${msg}`);
+                            }
+                        }
+                        else {
+                            state.activeOrders.delete(String(i));
+                        }
+                    }
+                }
+                if (newFills > 0) {
+                    // Estimate PnL from grid spacing
+                    state.totalPnl += newFills * step * sizePerGrid;
+                    log(`[GRID] ${newFills} fill(s) | Total fills: ${state.fills} | Est. PnL: $${state.totalPnl.toFixed(2)}`);
+                }
+                // Update job state
+                if (jobId) {
+                    updateJobState(jobId, {
+                        result: {
+                            fills: state.fills,
+                            totalPnl: state.totalPnl,
+                            activeOrders: state.activeOrders.size,
+                            runtime: Math.floor((Date.now() - state.startedAt) / 1000),
+                        },
+                    });
+                }
+                // Trailing stop check
+                if (params.trailingStop) {
+                    const bal = await adapter.getBalance();
+                    const equity = parseFloat(bal.equity);
+                    if (equity > state.peakEquity)
+                        state.peakEquity = equity;
+                    const drawdown = ((state.peakEquity - equity) / state.peakEquity) * 100;
+                    if (drawdown > params.trailingStop) {
+                        log(`[GRID] Trailing stop triggered (${drawdown.toFixed(1)}% drawdown). Stopping.`);
+                        break;
+                    }
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log(`[GRID] Monitor error: ${msg}`);
+            }
+        }
+    }
+    finally {
+        process.removeListener("SIGINT", shutdown);
+        process.removeListener("SIGTERM", shutdown);
+        // Cancel remaining grid orders
+        log(`[GRID] Cancelling remaining orders...`);
+        try {
+            await adapter.cancelAllOrders(symbol);
+        }
+        catch {
+            // best-effort
+        }
+    }
+    const runtime = Math.floor((Date.now() - state.startedAt) / 1000);
+    log(`[GRID] Done. ${state.fills} fills, est. PnL $${state.totalPnl.toFixed(2)}, runtime ${runtime}s`);
+    if (jobId) {
+        updateJobState(jobId, { status: "done", result: { fills: state.fills, totalPnl: state.totalPnl, runtime } });
+    }
+    return { fills: state.fills, totalPnl: state.totalPnl, runtime };
+}
+async function placeGridOrders(adapter, symbol, gridLines, state, log) {
+    let placed = 0;
+    for (let i = 0; i < gridLines.length; i++) {
+        const line = gridLines[i];
+        try {
+            const result = await adapter.limitOrder(symbol, line.side, String(line.price.toFixed(2)), String(line.size));
+            const orderId = String(result?.orderId ?? result?.oid ?? result?.id ?? "");
+            state.activeOrders.set(String(i), orderId);
+            placed++;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(`[GRID] Order at $${line.price.toFixed(2)} failed: ${msg}`);
+        }
+    }
+    log(`[GRID] Placed ${placed}/${gridLines.length} orders`);
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/dist/strategies/trailing-stop.d.ts

@@ -0,0 +1,17 @@
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export interface TrailingStopParams {
+    symbol: string;
+    trailPct: number;
+    intervalSec?: number;
+    activationPrice?: number;
+}
+export interface TrailingStopResult {
+    triggered: boolean;
+    reason: "triggered" | "cancelled" | "no_position";
+    peakPrice?: number;
+    triggerPrice?: number;
+    changePct?: number;
+    positionSide?: string;
+    runtime: number;
+}
+export declare function runTrailingStop(adapter: ExchangeAdapter, params: TrailingStopParams, jobId?: string, log?: (msg: string) => void): Promise<TrailingStopResult>;