perp-cli 0.6.4 → 0.7.2

package/dist/bot/strategies/mean-reversion.js

@@ -0,0 +1,118 @@
+import { registerStrategy } from "../strategy-registry.js";
+import { calculateSMA, calculateBollingerBands } from "../indicators.js";
+/**
+ * Mean reversion strategy.
+ * Entry: price deviates > threshold from SMA, confirmed by Bollinger Band touch.
+ *   - Buy when price touches lower band (oversold).
+ *   - Sell when price touches upper band (overbought).
+ * Exit: price returns to SMA (the mean).
+ */
+export class MeanReversionStrategy {
+    name = "mean-reversion";
+    _config = {};
+    describe() {
+        return {
+            description: "Mean reversion using Bollinger Bands — buy at lower band, sell at upper band, exit at mean",
+            params: [
+                { name: "smaPeriod", type: "number", required: false, default: 20, description: "SMA lookback period" },
+                { name: "bollingerStdDev", type: "number", required: false, default: 2, description: "Bollinger Bands std dev multiplier" },
+                { name: "entryThreshold", type: "number", required: false, default: 0, description: "Extra threshold beyond band (0 = band touch)" },
+                { name: "size", type: "number", required: true, description: "Position size" },
+            ],
+        };
+    }
+    get smaPeriod() { return Number(this._config.smaPeriod ?? 20); }
+    get bollingerStdDev() { return Number(this._config.bollingerStdDev ?? 2); }
+    get entryThreshold() { return Number(this._config.entryThreshold ?? 0); }
+    get size() { return Number(this._config.size ?? 0.1); }
+    async init(ctx, _snapshot) {
+        this._config = ctx.config;
+        ctx.state.set("position", null); // null | { side, entry }
+        ctx.log(`  [MEAN-REV] Ready | sma=${this.smaPeriod} stdDev=${this.bollingerStdDev} threshold=${this.entryThreshold}`);
+    }
+    async onTick(ctx, snapshot) {
+        const actions = [];
+        const klines = snapshot.klines;
+        if (klines.length < this.smaPeriod) {
+            ctx.log(`  [MEAN-REV] Insufficient klines (${klines.length}/${this.smaPeriod})`);
+            return [];
+        }
+        const closes = klines.map(k => parseFloat(k.close));
+        const price = snapshot.price;
+        // Compute indicators
+        const smaValues = calculateSMA(closes, this.smaPeriod);
+        const currentSMA = smaValues.length > 0 ? smaValues[smaValues.length - 1] : price;
+        const bands = calculateBollingerBands(closes, this.smaPeriod, this.bollingerStdDev);
+        const upperBand = bands.upper.length > 0 ? bands.upper[bands.upper.length - 1] : price;
+        const lowerBand = bands.lower.length > 0 ? bands.lower[bands.lower.length - 1] : price;
+        const position = ctx.state.get("position");
+        // If no position, check for entry signals
+        if (!position) {
+            // Buy signal: price at or below lower band (- threshold)
+            if (price <= lowerBand - this.entryThreshold) {
+                ctx.state.set("position", { side: "buy", entry: price });
+                ctx.log(`  [MEAN-REV] Long entry @ $${price.toFixed(2)} (lower band $${lowerBand.toFixed(2)}, mean $${currentSMA.toFixed(2)})`);
+                actions.push({
+                    type: "place_order",
+                    side: "buy",
+                    price: price.toFixed(2),
+                    size: String(this.size),
+                    orderType: "market",
+                });
+            }
+            // Sell signal: price at or above upper band (+ threshold)
+            else if (price >= upperBand + this.entryThreshold) {
+                ctx.state.set("position", { side: "sell", entry: price });
+                ctx.log(`  [MEAN-REV] Short entry @ $${price.toFixed(2)} (upper band $${upperBand.toFixed(2)}, mean $${currentSMA.toFixed(2)})`);
+                actions.push({
+                    type: "place_order",
+                    side: "sell",
+                    price: price.toFixed(2),
+                    size: String(this.size),
+                    orderType: "market",
+                });
+            }
+            return actions;
+        }
+        // Manage existing position — exit when price returns to mean
+        if (position.side === "buy" && price >= currentSMA) {
+            ctx.log(`  [MEAN-REV] Close long @ $${price.toFixed(2)} (mean $${currentSMA.toFixed(2)})`);
+            ctx.state.set("position", null);
+            actions.push({
+                type: "place_order",
+                side: "sell",
+                price: price.toFixed(2),
+                size: String(this.size),
+                orderType: "market",
+                reduceOnly: true,
+            });
+        }
+        else if (position.side === "sell" && price <= currentSMA) {
+            ctx.log(`  [MEAN-REV] Close short @ $${price.toFixed(2)} (mean $${currentSMA.toFixed(2)})`);
+            ctx.state.set("position", null);
+            actions.push({
+                type: "place_order",
+                side: "buy",
+                price: price.toFixed(2),
+                size: String(this.size),
+                orderType: "market",
+                reduceOnly: true,
+            });
+        }
+        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(this.size),
+                orderType: "market",
+                reduceOnly: true,
+            }];
+    }
+}
+registerStrategy("mean-reversion", (_config) => new MeanReversionStrategy());

package/dist/bot/strategies/momentum-breakout.d.ts

@@ -0,0 +1,36 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+/**
+ * Momentum breakout strategy.
+ * Entry: price breaks above N-period high (buy) or below N-period low (sell)
+ *        with volume confirmation (volume > avgVolume * multiplier).
+ * Stop: ATR-based trailing stop.
+ * Take profit: risk/reward ratio based.
+ */
+export declare class MomentumBreakoutStrategy implements Strategy {
+    readonly name = "momentum-breakout";
+    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 lookbackPeriod();
+    private get volumeMultiplier();
+    private get atrMultiplier();
+    private get riskReward();
+    private get size();
+    init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(ctx: StrategyContext): Promise<StrategyAction[]>;
+}

package/dist/bot/strategies/momentum-breakout.js

@@ -0,0 +1,159 @@
+import { registerStrategy } from "../strategy-registry.js";
+import { calculateATR, calculateSMA } from "../indicators.js";
+/**
+ * Momentum breakout strategy.
+ * Entry: price breaks above N-period high (buy) or below N-period low (sell)
+ *        with volume confirmation (volume > avgVolume * multiplier).
+ * Stop: ATR-based trailing stop.
+ * Take profit: risk/reward ratio based.
+ */
+export class MomentumBreakoutStrategy {
+    name = "momentum-breakout";
+    _config = {};
+    describe() {
+        return {
+            description: "Momentum breakout with volume confirmation and ATR trailing stop",
+            params: [
+                { name: "lookbackPeriod", type: "number", required: false, default: 20, description: "Periods for high/low channel" },
+                { name: "volumeMultiplier", type: "number", required: false, default: 1.5, description: "Volume must exceed avg * this" },
+                { name: "atrMultiplier", type: "number", required: false, default: 2, description: "ATR multiplier for stop distance" },
+                { name: "riskReward", type: "number", required: false, default: 2, description: "Take profit = stop distance * this" },
+                { name: "size", type: "number", required: true, description: "Position size" },
+            ],
+        };
+    }
+    get lookbackPeriod() { return Number(this._config.lookbackPeriod ?? 20); }
+    get volumeMultiplier() { return Number(this._config.volumeMultiplier ?? 1.5); }
+    get atrMultiplier() { return Number(this._config.atrMultiplier ?? 2); }
+    get riskReward() { return Number(this._config.riskReward ?? 2); }
+    get size() { return Number(this._config.size ?? 0.1); }
+    async init(ctx, _snapshot) {
+        this._config = ctx.config;
+        ctx.state.set("position", null); // null | { side, entry, stop, tp }
+        ctx.log(`  [BREAKOUT] Ready | lookback=${this.lookbackPeriod} volMult=${this.volumeMultiplier} atrMult=${this.atrMultiplier} rr=${this.riskReward}`);
+    }
+    async onTick(ctx, snapshot) {
+        const actions = [];
+        const klines = snapshot.klines;
+        if (klines.length < this.lookbackPeriod + 1) {
+            ctx.log(`  [BREAKOUT] Insufficient klines (${klines.length}/${this.lookbackPeriod + 1})`);
+            return [];
+        }
+        const closes = klines.map(k => parseFloat(k.close));
+        const highs = klines.map(k => parseFloat(k.high));
+        const lows = klines.map(k => parseFloat(k.low));
+        const volumes = klines.map(k => parseFloat(k.volume));
+        const price = snapshot.price;
+        // Compute indicators
+        const candles = klines.map(k => ({
+            high: parseFloat(k.high),
+            low: parseFloat(k.low),
+            close: parseFloat(k.close),
+        }));
+        const atrValues = calculateATR(candles, this.lookbackPeriod);
+        const currentATR = atrValues.length > 0 ? atrValues[atrValues.length - 1] : 0;
+        // N-period high/low (excluding current bar)
+        const lookbackHighs = highs.slice(-this.lookbackPeriod - 1, -1);
+        const lookbackLows = lows.slice(-this.lookbackPeriod - 1, -1);
+        const channelHigh = Math.max(...lookbackHighs);
+        const channelLow = Math.min(...lookbackLows);
+        // Volume confirmation
+        const avgVolSma = calculateSMA(volumes, this.lookbackPeriod);
+        const avgVolume = avgVolSma.length > 0 ? avgVolSma[avgVolSma.length - 1] : 0;
+        const currentVolume = volumes[volumes.length - 1];
+        const volumeConfirmed = avgVolume > 0 && currentVolume > avgVolume * this.volumeMultiplier;
+        const position = ctx.state.get("position");
+        // If no position, look for breakout entry
+        if (!position) {
+            if (price > channelHigh && volumeConfirmed && currentATR > 0) {
+                const stopDistance = currentATR * this.atrMultiplier;
+                const stop = price - stopDistance;
+                const tp = price + stopDistance * this.riskReward;
+                ctx.state.set("position", { side: "buy", entry: price, stop, tp });
+                ctx.log(`  [BREAKOUT] Long breakout @ $${price.toFixed(2)} | stop $${stop.toFixed(2)} | tp $${tp.toFixed(2)}`);
+                actions.push({
+                    type: "place_order",
+                    side: "buy",
+                    price: price.toFixed(2),
+                    size: String(this.size),
+                    orderType: "market",
+                });
+            }
+            else if (price < channelLow && volumeConfirmed && currentATR > 0) {
+                const stopDistance = currentATR * this.atrMultiplier;
+                const stop = price + stopDistance;
+                const tp = price - stopDistance * this.riskReward;
+                ctx.state.set("position", { side: "sell", entry: price, stop, tp });
+                ctx.log(`  [BREAKOUT] Short breakout @ $${price.toFixed(2)} | stop $${stop.toFixed(2)} | tp $${tp.toFixed(2)}`);
+                actions.push({
+                    type: "place_order",
+                    side: "sell",
+                    price: price.toFixed(2),
+                    size: String(this.size),
+                    orderType: "market",
+                });
+            }
+            return actions;
+        }
+        // Manage existing position — trailing stop + take profit
+        if (position.side === "buy") {
+            // Trail stop up
+            const newStop = price - currentATR * this.atrMultiplier;
+            if (newStop > position.stop) {
+                position.stop = newStop;
+                ctx.state.set("position", position);
+            }
+            // Check exit
+            if (price <= position.stop || price >= position.tp) {
+                const reason = price <= position.stop ? "stop" : "take-profit";
+                ctx.log(`  [BREAKOUT] Close long (${reason}) @ $${price.toFixed(2)}`);
+                ctx.state.set("position", null);
+                actions.push({
+                    type: "place_order",
+                    side: "sell",
+                    price: price.toFixed(2),
+                    size: String(this.size),
+                    orderType: "market",
+                    reduceOnly: true,
+                });
+            }
+        }
+        else {
+            // Trail stop down for short
+            const newStop = price + currentATR * this.atrMultiplier;
+            if (newStop < position.stop) {
+                position.stop = newStop;
+                ctx.state.set("position", position);
+            }
+            if (price >= position.stop || price <= position.tp) {
+                const reason = price >= position.stop ? "stop" : "take-profit";
+                ctx.log(`  [BREAKOUT] Close short (${reason}) @ $${price.toFixed(2)}`);
+                ctx.state.set("position", null);
+                actions.push({
+                    type: "place_order",
+                    side: "buy",
+                    price: price.toFixed(2),
+                    size: String(this.size),
+                    orderType: "market",
+                    reduceOnly: true,
+                });
+            }
+        }
+        return actions;
+    }
+    async onStop(ctx) {
+        const position = ctx.state.get("position");
+        if (!position)
+            return [];
+        // Close position on stop
+        return [{
+                type: "place_order",
+                side: position.side === "buy" ? "sell" : "buy",
+                price: "0",
+                size: String(this.size),
+                orderType: "market",
+                reduceOnly: true,
+            }];
+    }
+}
+registerStrategy("momentum-breakout", (_config) => new MomentumBreakoutStrategy());

package/dist/bot/strategies/regime-mm.d.ts

@@ -0,0 +1,25 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+export declare class RegimeMmStrategy implements Strategy {
+    readonly name = "regime-mm";
+    describe(): {
+        description: string;
+        params: ({
+            name: string;
+            type: "number";
+            required: boolean;
+            description: string;
+            default?: undefined;
+        } | {
+            name: string;
+            type: "number";
+            required: boolean;
+            default: number;
+            description: string;
+        })[];
+    };
+    private get params();
+    private _config;
+    init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(_ctx: StrategyContext): Promise<StrategyAction[]>;
+}

package/dist/bot/strategies/regime-mm.js

@@ -0,0 +1,111 @@
+import { registerStrategy } from "../strategy-registry.js";
+import { detectRegime } from "../indicators.js";
+/** Per-regime parameter multipliers */
+const REGIME_PARAMS = {
+    "low-vol-trending": { spreadMult: 0.8, sizeMult: 1.0, bias: "trend" },
+    "low-vol-ranging": { spreadMult: 0.8, sizeMult: 1.0, bias: "symmetric" },
+    "high-vol-trending": { spreadMult: 2.0, sizeMult: 0.5, bias: "trend" },
+    "high-vol-ranging": { spreadMult: 2.0, sizeMult: 0.7, bias: "aggressive-revert" },
+};
+export class RegimeMmStrategy {
+    name = "regime-mm";
+    describe() {
+        return {
+            description: "Volatility-adaptive market making using regime detection",
+            params: [
+                { name: "baseSpread", type: "number", required: true, description: "Base spread in basis points" },
+                { name: "size", type: "number", required: true, description: "Base order size" },
+                { name: "regimeWindow", type: "number", required: false, default: 20, description: "Lookback period for regime detection" },
+            ],
+        };
+    }
+    get params() {
+        return this._config;
+    }
+    _config = {};
+    async init(ctx, _snapshot) {
+        this._config = ctx.config;
+        ctx.state.set("inventory", 0);
+        ctx.state.set("currentRegime", "low-vol-ranging");
+        const p = this.params;
+        ctx.log(`  [REGIME-MM] baseSpread=${p.baseSpread}bps, size=${p.size}, window=${p.regimeWindow || 20}`);
+    }
+    async onTick(ctx, snapshot) {
+        const params = this.params;
+        const actions = [];
+        actions.push({ type: "cancel_all" });
+        // Detect current regime from kline close prices
+        const window = params.regimeWindow || 20;
+        let regime = "low-vol-ranging";
+        if (snapshot.klines.length >= window) {
+            const closes = snapshot.klines.map(k => parseFloat(k.close));
+            regime = detectRegime(closes, window);
+        }
+        const prevRegime = ctx.state.get("currentRegime");
+        if (regime !== prevRegime) {
+            ctx.log(`  [REGIME-MM] Regime shift: ${prevRegime} -> ${regime}`);
+            ctx.state.set("currentRegime", regime);
+        }
+        const rp = REGIME_PARAMS[regime];
+        const mid = snapshot.price;
+        const spreadFrac = (params.baseSpread / 10000) * rp.spreadMult;
+        const size = params.size * rp.sizeMult;
+        const inventory = ctx.state.get("inventory") ?? 0;
+        // Trend bias: compute slope direction from recent prices
+        let trendBias = 0;
+        if (rp.bias === "trend" && snapshot.klines.length >= 5) {
+            const recent = snapshot.klines.slice(-5).map(k => parseFloat(k.close));
+            const slope = (recent[recent.length - 1] - recent[0]) / recent[0];
+            trendBias = slope * mid * 0.5; // shift quotes in trend direction
+        }
+        // Aggressive inventory reversion for high-vol-ranging
+        let inventoryShift = 0;
+        if (rp.bias === "aggressive-revert" && inventory !== 0) {
+            inventoryShift = -inventory * spreadFrac * mid * 2;
+        }
+        else if (inventory !== 0) {
+            // Standard inventory management
+            inventoryShift = -inventory * spreadFrac * mid * 0.5;
+        }
+        const bidPrice = mid * (1 - spreadFrac / 2) + trendBias + inventoryShift;
+        const askPrice = mid * (1 + spreadFrac / 2) + trendBias + inventoryShift;
+        // Adjust sizes: reduce on heavy side
+        const maxInv = params.size * 10;
+        const invRatio = maxInv > 0 ? Math.abs(inventory) / maxInv : 0;
+        const sizePenalty = Math.min(invRatio, 0.8);
+        const bidSize = inventory > 0 ? size * (1 - sizePenalty) : size;
+        const askSize = inventory < 0 ? size * (1 - sizePenalty) : size;
+        if (bidSize > 0 && bidPrice > 0) {
+            actions.push({
+                type: "place_order",
+                side: "buy",
+                price: bidPrice.toFixed(6),
+                size: String(bidSize),
+                orderType: "limit",
+            });
+        }
+        if (askSize > 0 && askPrice > 0) {
+            actions.push({
+                type: "place_order",
+                side: "sell",
+                price: askPrice.toFixed(6),
+                size: String(askSize),
+                orderType: "limit",
+            });
+        }
+        // Update inventory estimate
+        const prevMid = ctx.state.get("prevMid") ?? mid;
+        if (mid > prevMid) {
+            ctx.state.set("inventory", inventory + size * 0.3);
+        }
+        else if (mid < prevMid) {
+            ctx.state.set("inventory", inventory - size * 0.3);
+        }
+        ctx.state.set("prevMid", mid);
+        return actions;
+    }
+    async onStop(_ctx) {
+        return [{ type: "cancel_all" }];
+    }
+}
+registerStrategy("regime-mm", (_config) => new RegimeMmStrategy());

package/dist/bot/strategies/rfq-agent.d.ts

@@ -0,0 +1,25 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+export declare class RfqAgentStrategy implements Strategy {
+    readonly name = "rfq-agent";
+    private _config;
+    private get params();
+    describe(): {
+        description: string;
+        params: ({
+            name: string;
+            type: "number";
+            required: boolean;
+            description: string;
+            default?: undefined;
+        } | {
+            name: string;
+            type: "number";
+            required: boolean;
+            default: number;
+            description: string;
+        })[];
+    };
+    init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(_ctx: StrategyContext): Promise<StrategyAction[]>;
+}

package/dist/bot/strategies/rfq-agent.js

@@ -0,0 +1,71 @@
+import { registerStrategy } from "../strategy-registry.js";
+export class RfqAgentStrategy {
+    name = "rfq-agent";
+    _config = {};
+    get params() {
+        return {
+            totalSize: Number(this._config.totalSize ?? 1),
+            sliceSize: Number(this._config.sliceSize ?? 0.1),
+            spreadBps: Number(this._config.spreadBps ?? 10),
+            delayMs: Number(this._config.delayMs ?? 1000),
+        };
+    }
+    describe() {
+        return {
+            description: "Iceberg-style large order execution: splits into slices at wider spreads to reduce market impact",
+            params: [
+                { name: "totalSize", type: "number", required: true, description: "Total order size to execute" },
+                { name: "sliceSize", type: "number", required: true, description: "Size of each individual slice" },
+                { name: "spreadBps", type: "number", required: false, default: 10, description: "Spread offset per slice in basis points" },
+                { name: "delayMs", type: "number", required: false, default: 1000, description: "Minimum ms between slices" },
+            ],
+        };
+    }
+    async init(ctx, _snapshot) {
+        this._config = ctx.config;
+        const { totalSize, sliceSize, spreadBps, delayMs } = this.params;
+        ctx.state.set("remainingSize", totalSize);
+        ctx.state.set("lastSliceTime", 0);
+        const slices = Math.ceil(totalSize / sliceSize);
+        ctx.log(`  [RFQ-AGENT] totalSize=${totalSize} sliceSize=${sliceSize} ` +
+            `spread=${spreadBps}bps delayMs=${delayMs} (~${slices} slices)`);
+    }
+    async onTick(ctx, snapshot) {
+        const { sliceSize, spreadBps, delayMs } = this.params;
+        const remainingSize = ctx.state.get("remainingSize");
+        const lastSliceTime = ctx.state.get("lastSliceTime");
+        if (remainingSize <= 0) {
+            ctx.log("  [RFQ-AGENT] All slices placed — execution complete");
+            return [{ type: "noop" }];
+        }
+        const now = Date.now();
+        if (now - lastSliceTime < delayMs) {
+            return [{ type: "noop" }];
+        }
+        const thisSlice = Math.min(sliceSize, remainingSize);
+        const spreadFraction = spreadBps / 10000;
+        // Determine side from config, default buy; offer at wider spread to reduce impact
+        const side = ctx.config.side ?? "buy";
+        const price = side === "buy"
+            ? snapshot.price * (1 - spreadFraction) // bid below mid
+            : snapshot.price * (1 + spreadFraction); // ask above mid
+        const newRemaining = remainingSize - thisSlice;
+        ctx.state.set("remainingSize", newRemaining);
+        ctx.state.set("lastSliceTime", now);
+        ctx.log(`  [RFQ-AGENT] Placing slice ${thisSlice.toFixed(6)} @ ${price.toFixed(6)} ` +
+            `(remaining: ${newRemaining.toFixed(6)})`);
+        return [
+            {
+                type: "place_order",
+                side,
+                price: price.toFixed(6),
+                size: thisSlice.toFixed(6),
+                orderType: "limit",
+            },
+        ];
+    }
+    async onStop(_ctx) {
+        return [{ type: "cancel_all" }];
+    }
+}
+registerStrategy("rfq-agent", (_config) => new RfqAgentStrategy());

package/dist/bot/strategies/simple-mm.d.ts

@@ -0,0 +1,25 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+export declare class SimpleMmStrategy implements Strategy {
+    readonly name = "simple-mm";
+    describe(): {
+        description: string;
+        params: ({
+            name: string;
+            type: "number";
+            required: boolean;
+            description: string;
+            default?: undefined;
+        } | {
+            name: string;
+            type: "number";
+            required: boolean;
+            default: number;
+            description: string;
+        })[];
+    };
+    private get params();
+    private _config;
+    init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(_ctx: StrategyContext): Promise<StrategyAction[]>;
+}

package/dist/bot/strategies/simple-mm.js

@@ -0,0 +1,76 @@
+import { registerStrategy } from "../strategy-registry.js";
+export class SimpleMmStrategy {
+    name = "simple-mm";
+    describe() {
+        return {
+            description: "Symmetric bid/ask market making at fixed spread",
+            params: [
+                { name: "spread", type: "number", required: true, description: "Spread in basis points" },
+                { name: "size", type: "number", required: true, description: "Order size per level" },
+                { name: "levels", type: "number", required: false, default: 1, description: "Number of levels each side" },
+            ],
+        };
+    }
+    get params() {
+        return this._config;
+    }
+    _config = {};
+    async init(ctx, _snapshot) {
+        this._config = ctx.config;
+        ctx.state.set("inventory", 0);
+        ctx.log(`  [SIMPLE-MM] spread=${this.params.spread}bps, size=${this.params.size}, levels=${this.params.levels}`);
+    }
+    async onTick(ctx, snapshot) {
+        const { spread, size, levels } = this.params;
+        const actions = [];
+        const inventory = ctx.state.get("inventory") ?? 0;
+        // Cancel all existing orders, then re-quote
+        actions.push({ type: "cancel_all" });
+        const mid = snapshot.price;
+        const spreadFraction = spread / 10000; // bps to fraction
+        for (let i = 1; i <= (levels || 1); i++) {
+            const offset = (spreadFraction / 2) * i;
+            const bidPrice = mid * (1 - offset);
+            const askPrice = mid * (1 + offset);
+            // Simple inventory skew: reduce size on heavy side
+            const inventorySkew = Math.min(Math.abs(inventory) / (size * levels * 2), 0.8);
+            const bidSize = inventory > 0 ? size * (1 - inventorySkew) : size;
+            const askSize = inventory < 0 ? size * (1 - inventorySkew) : size;
+            if (bidSize > 0) {
+                actions.push({
+                    type: "place_order",
+                    side: "buy",
+                    price: bidPrice.toFixed(6),
+                    size: String(bidSize),
+                    orderType: "limit",
+                });
+            }
+            if (askSize > 0) {
+                actions.push({
+                    type: "place_order",
+                    side: "sell",
+                    price: askPrice.toFixed(6),
+                    size: String(askSize),
+                    orderType: "limit",
+                });
+            }
+        }
+        // Track approximate inventory from fills (simplified: assume fills at each tick)
+        // Real inventory tracking would use adapter.getPositions()
+        const prevMid = ctx.state.get("prevMid") ?? mid;
+        if (mid > prevMid) {
+            // Price moved up: likely bid was filled
+            ctx.state.set("inventory", inventory + size);
+        }
+        else if (mid < prevMid) {
+            // Price moved down: likely ask was filled
+            ctx.state.set("inventory", inventory - size);
+        }
+        ctx.state.set("prevMid", mid);
+        return actions;
+    }
+    async onStop(_ctx) {
+        return [{ type: "cancel_all" }];
+    }
+}
+registerStrategy("simple-mm", (_config) => new SimpleMmStrategy());

package/dist/bot/strategy-registry.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Strategy registry for bot engine.
+ * Strategies register here — engine uses registry to resolve by name.
+ */
+import type { Strategy } from "./strategy-types.js";
+export type StrategyFactory = (config: Record<string, unknown>) => Strategy;
+export declare function registerStrategy(name: string, factory: StrategyFactory): void;
+export declare function getStrategy(name: string): StrategyFactory | undefined;
+export declare function listStrategies(): string[];