perp-cli 0.6.3 → 0.7.1

package/dist/bot/index.d.ts

@@ -0,0 +1,16 @@
+export { loadBotConfig, 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";
+export { PRESETS, getPreset, getPresetsByStrategy } from "./presets.js";
+export type { Preset } from "./presets.js";
+export { evaluateCondition, evaluateAllConditions, getMarketSnapshot, calculateRSI } from "./conditions.js";
+export type { MarketSnapshot } from "./conditions.js";
+export * from "./indicators.js";
+export * from "./strategy-types.js";
+export { registerStrategy, getStrategy, listStrategies } from "./strategy-registry.js";
+export type { StrategyFactory } from "./strategy-registry.js";
+export { appendJournal, readJournal, clearJournal } from "./trade-journal.js";
+export type { JournalEntry } from "./trade-journal.js";
+export { analyzePerformance, suggestAdjustments } from "./reflect.js";
+export type { ReflectReport } from "./reflect.js";

package/dist/bot/index.js

@@ -0,0 +1,10 @@
+// bot/ barrel — public API
+export { loadBotConfig, 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";
+export * from "./indicators.js";
+export * from "./strategy-types.js";
+export { registerStrategy, getStrategy, listStrategies } from "./strategy-registry.js";
+export { appendJournal, readJournal, clearJournal } from "./trade-journal.js";
+export { analyzePerformance, suggestAdjustments } from "./reflect.js";

package/dist/bot/indicators.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Technical indicator library for trading strategies.
+ * Pure functions — no side effects, no API calls.
+ */
+/** Calculate Exponential Moving Average */
+export declare function calculateEMA(prices: number[], period: number): number[];
+/** Calculate Simple Moving Average */
+export declare function calculateSMA(prices: number[], period: number): number[];
+/** Calculate Volume Weighted Average Price */
+export declare function calculateVWAP(candles: {
+    close: number;
+    volume: number;
+}[]): number;
+/** Calculate Average True Range */
+export declare function calculateATR(candles: {
+    high: number;
+    low: number;
+    close: number;
+}[], period: number): number[];
+/** Calculate Bollinger Bands */
+export declare function calculateBollingerBands(prices: number[], period: number, stdDevMultiplier?: number): {
+    upper: number[];
+    middle: number[];
+    lower: number[];
+};
+/** Calculate RSI (extracted from conditions.ts) */
+export declare function calculateRSI(closes: number[], period?: number): number;
+/** Detect market regime: low-vol-trending, low-vol-ranging, high-vol-trending, high-vol-ranging */
+export declare function detectRegime(prices: number[], period?: number): "low-vol-trending" | "low-vol-ranging" | "high-vol-trending" | "high-vol-ranging";

package/dist/bot/indicators.js

@@ -0,0 +1,144 @@
+/**
+ * Technical indicator library for trading strategies.
+ * Pure functions — no side effects, no API calls.
+ */
+/** Calculate Exponential Moving Average */
+export function calculateEMA(prices, period) {
+    if (prices.length < period)
+        return [];
+    const k = 2 / (period + 1);
+    const ema = [];
+    // SMA for first value
+    let sum = 0;
+    for (let i = 0; i < period; i++)
+        sum += prices[i];
+    ema.push(sum / period);
+    // EMA for rest
+    for (let i = period; i < prices.length; i++) {
+        ema.push(prices[i] * k + ema[ema.length - 1] * (1 - k));
+    }
+    return ema;
+}
+/** Calculate Simple Moving Average */
+export function calculateSMA(prices, period) {
+    if (prices.length < period)
+        return [];
+    const sma = [];
+    for (let i = period - 1; i < prices.length; i++) {
+        let sum = 0;
+        for (let j = i - period + 1; j <= i; j++)
+            sum += prices[j];
+        sma.push(sum / period);
+    }
+    return sma;
+}
+/** Calculate Volume Weighted Average Price */
+export function calculateVWAP(candles) {
+    let cumVolPrice = 0;
+    let cumVol = 0;
+    for (const c of candles) {
+        cumVolPrice += c.close * c.volume;
+        cumVol += c.volume;
+    }
+    return cumVol > 0 ? cumVolPrice / cumVol : 0;
+}
+/** Calculate Average True Range */
+export function calculateATR(candles, period) {
+    if (candles.length < 2)
+        return [];
+    const tr = [];
+    for (let i = 1; i < candles.length; i++) {
+        const h = candles[i].high;
+        const l = candles[i].low;
+        const pc = candles[i - 1].close;
+        tr.push(Math.max(h - l, Math.abs(h - pc), Math.abs(l - pc)));
+    }
+    // Wilder smoothing for ATR
+    if (tr.length < period)
+        return [];
+    const atr = [];
+    let sum = 0;
+    for (let i = 0; i < period; i++)
+        sum += tr[i];
+    atr.push(sum / period);
+    for (let i = period; i < tr.length; i++) {
+        atr.push((atr[atr.length - 1] * (period - 1) + tr[i]) / period);
+    }
+    return atr;
+}
+/** Calculate Bollinger Bands */
+export function calculateBollingerBands(prices, period, stdDevMultiplier = 2) {
+    const middle = calculateSMA(prices, period);
+    const upper = [];
+    const lower = [];
+    for (let i = 0; i < middle.length; i++) {
+        const sliceStart = i;
+        const slice = prices.slice(sliceStart, sliceStart + period);
+        const mean = middle[i];
+        const variance = slice.reduce((s, v) => s + (v - mean) ** 2, 0) / period;
+        const stdDev = Math.sqrt(variance);
+        upper.push(mean + stdDevMultiplier * stdDev);
+        lower.push(mean - stdDevMultiplier * stdDev);
+    }
+    return { upper, middle, lower };
+}
+/** Calculate RSI (extracted from conditions.ts) */
+export function calculateRSI(closes, period = 14) {
+    if (closes.length < period + 1)
+        return 50; // neutral default
+    let gainSum = 0;
+    let lossSum = 0;
+    for (let i = 1; i <= period; i++) {
+        const diff = closes[i] - closes[i - 1];
+        if (diff > 0)
+            gainSum += diff;
+        else
+            lossSum -= diff;
+    }
+    let avgGain = gainSum / period;
+    let avgLoss = lossSum / period;
+    // Wilder smoothing
+    for (let i = period + 1; i < closes.length; i++) {
+        const diff = closes[i] - closes[i - 1];
+        avgGain = (avgGain * (period - 1) + (diff > 0 ? diff : 0)) / period;
+        avgLoss = (avgLoss * (period - 1) + (diff < 0 ? -diff : 0)) / period;
+    }
+    if (avgLoss === 0)
+        return 100;
+    const rs = avgGain / avgLoss;
+    return 100 - 100 / (1 + rs);
+}
+/** Detect market regime: low-vol-trending, low-vol-ranging, high-vol-trending, high-vol-ranging */
+export function detectRegime(prices, period = 20) {
+    if (prices.length < period)
+        return "low-vol-ranging";
+    const recent = prices.slice(-period);
+    // Volatility: std dev of returns
+    const returns = [];
+    for (let i = 1; i < recent.length; i++) {
+        returns.push((recent[i] - recent[i - 1]) / recent[i - 1]);
+    }
+    const meanReturn = returns.reduce((s, r) => s + r, 0) / returns.length;
+    const variance = returns.reduce((s, r) => s + (r - meanReturn) ** 2, 0) / returns.length;
+    const vol = Math.sqrt(variance);
+    // Trend: slope of linear regression
+    const n = recent.length;
+    let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
+    for (let i = 0; i < n; i++) {
+        sumX += i;
+        sumY += recent[i];
+        sumXY += i * recent[i];
+        sumX2 += i * i;
+    }
+    const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
+    const normalizedSlope = Math.abs(slope / (sumY / n));
+    const isHighVol = vol > 0.02; // >2% daily vol
+    const isTrending = normalizedSlope > 0.001;
+    if (isHighVol && isTrending)
+        return "high-vol-trending";
+    if (isHighVol && !isTrending)
+        return "high-vol-ranging";
+    if (!isHighVol && isTrending)
+        return "low-vol-trending";
+    return "low-vol-ranging";
+}

package/dist/bot/reflect.d.ts

@@ -0,0 +1,34 @@
+/**
+ * REFLECT: Performance analysis + auto-parameter adjustment
+ * Metrics: win rate, avg win/loss, fee drag ratio, direction split, holding periods
+ * Auto-adjust: within guardrail bounds (e.g., spread ±20%, size ±30%)
+ */
+import type { JournalEntry } from "./trade-journal.js";
+export interface ReflectReport {
+    period: {
+        from: number;
+        to: number;
+        days: number;
+    };
+    totalTrades: number;
+    winRate: number;
+    avgWin: number;
+    avgLoss: number;
+    profitFactor: number;
+    feeDragRatio: number;
+    directionSplit: {
+        long: number;
+        short: number;
+    };
+    avgHoldingPeriodMs: number;
+    bestStrategy: string;
+    worstStrategy: string;
+    suggestions: string[];
+}
+export declare function analyzePerformance(entries: JournalEntry[], periodDays?: number): ReflectReport;
+export declare function suggestAdjustments(report: ReflectReport): {
+    param: string;
+    current: number;
+    suggested: number;
+    reason: string;
+}[];

package/dist/bot/reflect.js

@@ -0,0 +1,155 @@
+/**
+ * REFLECT: Performance analysis + auto-parameter adjustment
+ * Metrics: win rate, avg win/loss, fee drag ratio, direction split, holding periods
+ * Auto-adjust: within guardrail bounds (e.g., spread ±20%, size ±30%)
+ */
+export function analyzePerformance(entries, periodDays = 30) {
+    const now = Date.now();
+    const from = now - periodDays * 24 * 60 * 60 * 1000;
+    const to = now;
+    const inPeriod = entries.filter((e) => e.timestamp >= from && e.timestamp <= to);
+    if (inPeriod.length === 0) {
+        return {
+            period: { from, to, days: periodDays },
+            totalTrades: 0,
+            winRate: 0,
+            avgWin: 0,
+            avgLoss: 0,
+            profitFactor: 0,
+            feeDragRatio: 0,
+            directionSplit: { long: 0, short: 0 },
+            avgHoldingPeriodMs: 0,
+            bestStrategy: "",
+            worstStrategy: "",
+            suggestions: ["No trades in the selected period."],
+        };
+    }
+    // PnL-based metrics (only entries with pnl defined)
+    const withPnl = inPeriod.filter((e) => e.pnl !== undefined);
+    const wins = withPnl.filter((e) => (e.pnl ?? 0) > 0);
+    const losses = withPnl.filter((e) => (e.pnl ?? 0) <= 0);
+    const winRate = withPnl.length > 0 ? wins.length / withPnl.length : 0;
+    const avgWin = wins.length > 0 ? wins.reduce((s, e) => s + (e.pnl ?? 0), 0) / wins.length : 0;
+    const avgLoss = losses.length > 0 ? losses.reduce((s, e) => s + (e.pnl ?? 0), 0) / losses.length : 0;
+    const totalGross = wins.reduce((s, e) => s + (e.pnl ?? 0), 0);
+    const totalLoss = Math.abs(losses.reduce((s, e) => s + (e.pnl ?? 0), 0));
+    const profitFactor = totalLoss > 0 ? totalGross / totalLoss : totalGross > 0 ? Infinity : 0;
+    // Fee drag: total fees / gross profit
+    const totalFees = inPeriod.reduce((s, e) => s + (e.fees ?? 0), 0);
+    const feeDragRatio = totalGross > 0 ? totalFees / totalGross : 0;
+    // Direction split
+    const longs = inPeriod.filter((e) => e.side === "buy").length;
+    const shorts = inPeriod.filter((e) => e.side === "sell").length;
+    const total = inPeriod.length;
+    const directionSplit = {
+        long: total > 0 ? longs / total : 0,
+        short: total > 0 ? shorts / total : 0,
+    };
+    // Holding period
+    const withHolding = inPeriod.filter((e) => e.holdingPeriodMs !== undefined);
+    const avgHoldingPeriodMs = withHolding.length > 0
+        ? withHolding.reduce((s, e) => s + (e.holdingPeriodMs ?? 0), 0) / withHolding.length
+        : 0;
+    // Per-strategy PnL
+    const strategyPnl = new Map();
+    for (const e of withPnl) {
+        strategyPnl.set(e.strategy, (strategyPnl.get(e.strategy) ?? 0) + (e.pnl ?? 0));
+    }
+    let bestStrategy = "";
+    let worstStrategy = "";
+    if (strategyPnl.size > 0) {
+        let bestPnl = -Infinity;
+        let worstPnl = Infinity;
+        for (const [strat, pnl] of strategyPnl) {
+            if (pnl > bestPnl) {
+                bestPnl = pnl;
+                bestStrategy = strat;
+            }
+            if (pnl < worstPnl) {
+                worstPnl = pnl;
+                worstStrategy = strat;
+            }
+        }
+    }
+    const suggestions = buildSuggestions({ winRate, avgWin, avgLoss, profitFactor, feeDragRatio, directionSplit, avgHoldingPeriodMs, totalTrades: inPeriod.length });
+    return {
+        period: { from, to, days: periodDays },
+        totalTrades: inPeriod.length,
+        winRate,
+        avgWin,
+        avgLoss,
+        profitFactor,
+        feeDragRatio,
+        directionSplit,
+        avgHoldingPeriodMs,
+        bestStrategy,
+        worstStrategy,
+        suggestions,
+    };
+}
+function buildSuggestions(metrics) {
+    const suggestions = [];
+    if (metrics.winRate < 0.4) {
+        suggestions.push("Win rate below 40% — consider tightening entry conditions or widening spread.");
+    }
+    if (metrics.profitFactor < 1.0 && metrics.totalTrades >= 10) {
+        suggestions.push("Profit factor below 1.0 — strategy is net losing; review sizing or stop-loss levels.");
+    }
+    if (metrics.feeDragRatio > 0.3) {
+        suggestions.push("Fee drag exceeds 30% of gross profit — reduce order frequency or increase minimum profit threshold.");
+    }
+    if (metrics.avgWin > 0 && metrics.avgLoss < 0 && Math.abs(metrics.avgLoss) > metrics.avgWin * 2) {
+        suggestions.push("Average loss is more than 2× average win — improve risk/reward ratio or tighten stop-loss.");
+    }
+    if (metrics.directionSplit.long > 0.8) {
+        suggestions.push("Strategy is heavily long-biased (>80%) — consider hedging short exposure.");
+    }
+    if (metrics.directionSplit.short > 0.8) {
+        suggestions.push("Strategy is heavily short-biased (>80%) — verify market regime alignment.");
+    }
+    if (metrics.avgHoldingPeriodMs > 24 * 60 * 60 * 1000) {
+        suggestions.push("Average holding period exceeds 24h — review if overnight risk is compensated.");
+    }
+    if (suggestions.length === 0) {
+        suggestions.push("Performance looks healthy. Keep monitoring.");
+    }
+    return suggestions;
+}
+export function suggestAdjustments(report) {
+    const adjustments = [];
+    // Spread adjustment: tighten if win rate is high, widen if low
+    if (report.winRate < 0.4 && report.totalTrades >= 10) {
+        adjustments.push({
+            param: "spread_bps",
+            current: 10,
+            suggested: Math.round(10 * 1.2), // +20% guardrail
+            reason: "Low win rate — widening spread to improve fill quality.",
+        });
+    }
+    else if (report.winRate > 0.65 && report.profitFactor > 1.5) {
+        adjustments.push({
+            param: "spread_bps",
+            current: 10,
+            suggested: Math.round(10 * 0.8), // -20% guardrail
+            reason: "Strong win rate — tightening spread to capture more flow.",
+        });
+    }
+    // Size adjustment: reduce if fee drag is high or profit factor < 1
+    if (report.feeDragRatio > 0.3 || report.profitFactor < 1.0) {
+        adjustments.push({
+            param: "size_usd",
+            current: 100,
+            suggested: Math.round(100 * 0.7), // -30% guardrail
+            reason: "High fee drag or negative profit factor — reducing size to limit losses.",
+        });
+    }
+    else if (report.profitFactor > 2.0 && report.winRate > 0.55) {
+        adjustments.push({
+            param: "size_usd",
+            current: 100,
+            suggested: Math.round(100 * 1.3), // +30% guardrail
+            reason: "Strong performance — scaling up size within guardrail bounds.",
+        });
+    }
+    return adjustments;
+}

package/dist/bot/strategies/aggressive-taker.d.ts

@@ -0,0 +1,36 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+/**
+ * Aggressive taker strategy.
+ * Crosses spread with directional bias from EMA crossover signals.
+ * - Short EMA cross above long EMA = buy (bullish).
+ * - Short EMA cross below long EMA = sell (bearish).
+ * Size modulation: larger in strong trend, smaller in weak.
+ */
+export declare class AggressiveTakerStrategy implements Strategy {
+    readonly name = "aggressive-taker";
+    private _config;
+    describe(): {
+        description: string;
+        params: ({
+            name: string;
+            type: "number";
+            required: boolean;
+            default: number;
+            description: string;
+        } | {
+            name: string;
+            type: "number";
+            required: boolean;
+            description: string;
+            default?: undefined;
+        })[];
+    };
+    private get shortEmaPeriod();
+    private get longEmaPeriod();
+    private get baseSize();
+    private get maxSize();
+    private get minSignalStrength();
+    init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(ctx: StrategyContext): Promise<StrategyAction[]>;
+}

package/dist/bot/strategies/aggressive-taker.js

@@ -0,0 +1,125 @@
+import { registerStrategy } from "../strategy-registry.js";
+import { calculateEMA } from "../indicators.js";
+/**
+ * Aggressive taker strategy.
+ * Crosses spread with directional bias from EMA crossover signals.
+ * - Short EMA cross above long EMA = buy (bullish).
+ * - Short EMA cross below long EMA = sell (bearish).
+ * Size modulation: larger in strong trend, smaller in weak.
+ */
+export class AggressiveTakerStrategy {
+    name = "aggressive-taker";
+    _config = {};
+    describe() {
+        return {
+            description: "Aggressive market taker with EMA crossover signals and size modulation",
+            params: [
+                { name: "shortEmaPeriod", type: "number", required: false, default: 9, description: "Short EMA period" },
+                { name: "longEmaPeriod", type: "number", required: false, default: 21, description: "Long EMA period" },
+                { name: "baseSize", type: "number", required: true, description: "Base position size" },
+                { name: "maxSize", type: "number", required: false, default: 0, description: "Max position size (0 = 3x base)" },
+                { name: "minSignalStrength", type: "number", required: false, default: 0.001, description: "Min EMA divergence ratio to act" },
+            ],
+        };
+    }
+    get shortEmaPeriod() { return Number(this._config.shortEmaPeriod ?? 9); }
+    get longEmaPeriod() { return Number(this._config.longEmaPeriod ?? 21); }
+    get baseSize() { return Number(this._config.baseSize ?? 0.1); }
+    get maxSize() { return Number(this._config.maxSize ?? 0) || this.baseSize * 3; }
+    get minSignalStrength() { return Number(this._config.minSignalStrength ?? 0.001); }
+    async init(ctx, _snapshot) {
+        this._config = ctx.config;
+        ctx.state.set("position", null); // null | { side, entry, size }
+        ctx.state.set("prevSignal", 0); // -1 sell, 0 neutral, 1 buy
+        ctx.log(`  [TAKER] Ready | shortEMA=${this.shortEmaPeriod} longEMA=${this.longEmaPeriod} base=${this.baseSize} max=${this.maxSize}`);
+    }
+    async onTick(ctx, snapshot) {
+        const actions = [];
+        const klines = snapshot.klines;
+        if (klines.length < this.longEmaPeriod + 1) {
+            ctx.log(`  [TAKER] Insufficient klines (${klines.length}/${this.longEmaPeriod + 1})`);
+            return [];
+        }
+        const closes = klines.map(k => parseFloat(k.close));
+        const price = snapshot.price;
+        // Compute EMAs
+        const shortEma = calculateEMA(closes, this.shortEmaPeriod);
+        const longEma = calculateEMA(closes, this.longEmaPeriod);
+        if (shortEma.length === 0 || longEma.length === 0)
+            return [];
+        const currentShort = shortEma[shortEma.length - 1];
+        const currentLong = longEma[longEma.length - 1];
+        // Signal strength = normalized divergence
+        const divergence = (currentShort - currentLong) / currentLong;
+        const signalStrength = Math.abs(divergence);
+        // Determine signal: +1 bullish, -1 bearish, 0 neutral
+        let signal = 0;
+        if (divergence > this.minSignalStrength)
+            signal = 1;
+        else if (divergence < -this.minSignalStrength)
+            signal = -1;
+        const prevSignal = ctx.state.get("prevSignal");
+        const position = ctx.state.get("position");
+        // Size modulation: scale between baseSize and maxSize based on signal strength
+        const sizeRange = this.maxSize - this.baseSize;
+        // Cap strength at 5x minSignalStrength for scaling
+        const strengthCapped = Math.min(signalStrength / (this.minSignalStrength * 5), 1);
+        const orderSize = this.baseSize + sizeRange * strengthCapped;
+        // Signal changed — trade
+        if (signal !== 0 && signal !== prevSignal) {
+            // Close existing position if flipping
+            if (position) {
+                ctx.log(`  [TAKER] Close ${position.side} @ $${price.toFixed(2)}`);
+                actions.push({
+                    type: "place_order",
+                    side: position.side === "buy" ? "sell" : "buy",
+                    price: price.toFixed(2),
+                    size: String(position.size),
+                    orderType: "market",
+                    reduceOnly: true,
+                });
+            }
+            // Open new position
+            const side = signal > 0 ? "buy" : "sell";
+            const roundedSize = parseFloat(orderSize.toFixed(6));
+            ctx.state.set("position", { side, entry: price, size: roundedSize });
+            ctx.log(`  [TAKER] ${side.toUpperCase()} @ $${price.toFixed(2)} size=${roundedSize} strength=${signalStrength.toFixed(4)}`);
+            actions.push({
+                type: "place_order",
+                side,
+                price: price.toFixed(2),
+                size: String(roundedSize),
+                orderType: "market",
+            });
+        }
+        // Neutral signal — close if we have a position
+        if (signal === 0 && position) {
+            ctx.log(`  [TAKER] Signal neutral, closing ${position.side} @ $${price.toFixed(2)}`);
+            actions.push({
+                type: "place_order",
+                side: position.side === "buy" ? "sell" : "buy",
+                price: price.toFixed(2),
+                size: String(position.size),
+                orderType: "market",
+                reduceOnly: true,
+            });
+            ctx.state.set("position", null);
+        }
+        ctx.state.set("prevSignal", signal);
+        return actions;
+    }
+    async onStop(ctx) {
+        const position = ctx.state.get("position");
+        if (!position)
+            return [];
+        return [{
+                type: "place_order",
+                side: position.side === "buy" ? "sell" : "buy",
+                price: "0",
+                size: String(position.size),
+                orderType: "market",
+                reduceOnly: true,
+            }];
+    }
+}
+registerStrategy("aggressive-taker", (_config) => new AggressiveTakerStrategy());

package/dist/bot/strategies/apex-strategy.d.ts

@@ -0,0 +1,36 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+export declare class ApexStrategy implements Strategy {
+    readonly name = "apex";
+    private cfg;
+    private guardConfig;
+    private slots;
+    private pulseHistory;
+    private dailyLoss;
+    describe(): {
+        description: string;
+        params: ({
+            name: string;
+            type: "number";
+            required: boolean;
+            default: number;
+            description: string;
+        } | {
+            name: string;
+            type: "string";
+            required: boolean;
+            default: string;
+            description: string;
+        } | {
+            name: string;
+            type: "number";
+            required: boolean;
+            description: string;
+            default?: undefined;
+        })[];
+    };
+    init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(ctx: StrategyContext): Promise<StrategyAction[]>;
+    private calculateRoe;
+    private determineSide;
+}