perp-cli 0.6.3 → 0.7.1

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

@@ -0,0 +1,59 @@
+import { registerStrategy } from "../strategy-registry.js";
+export class DCAStrategy {
+    name = "dca";
+    describe() {
+        return {
+            description: "Dollar-cost averaging with timed intervals",
+            params: [
+                { name: "amount", type: "number", required: true, description: "Base size per order" },
+                { name: "interval_sec", type: "number", required: true, description: "Seconds between orders" },
+                { name: "total_orders", type: "number", required: false, default: 0, description: "Max orders (0 = unlimited)" },
+                { name: "price_limit", type: "number", required: false, description: "Max price to buy at" },
+            ],
+        };
+    }
+    get params() {
+        return this._config;
+    }
+    _config = {};
+    async init(ctx, _snapshot) {
+        this._config = ctx.config;
+        const params = this.params;
+        ctx.state.set("dcaOrdersPlaced", 0);
+        ctx.state.set("dcaLastOrder", 0);
+        ctx.log(`  [DCA] Ready: ${params.amount} ${ctx.symbol} every ${params.interval_sec}s`);
+    }
+    async onTick(ctx, snapshot) {
+        const params = this.params;
+        const dcaOrdersPlaced = ctx.state.get("dcaOrdersPlaced");
+        const dcaLastOrder = ctx.state.get("dcaLastOrder");
+        // Check if it's time for next order
+        const timeSinceLast = (Date.now() - dcaLastOrder) / 1000;
+        if (dcaLastOrder > 0 && timeSinceLast < params.interval_sec)
+            return [];
+        // Check order limit
+        if (params.total_orders > 0 && dcaOrdersPlaced >= params.total_orders)
+            return [];
+        // Check price limit
+        if (params.price_limit) {
+            if (snapshot.price > params.price_limit)
+                return [];
+        }
+        // Place market buy order
+        ctx.state.set("dcaOrdersPlaced", dcaOrdersPlaced + 1);
+        ctx.state.set("dcaLastOrder", Date.now());
+        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)}`);
+        return [{
+                type: "place_order",
+                side: "buy",
+                price: "0",
+                size: String(params.amount),
+                orderType: "market",
+            }];
+    }
+    async onStop(_ctx) {
+        return [{ type: "cancel_all" }];
+    }
+}
+registerStrategy("dca", (_config) => new DCAStrategy());

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

@@ -0,0 +1,29 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+export declare class EngineMmStrategy implements Strategy {
+    readonly name = "engine-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[]>;
+    /** Composite fair value: equal-weight VWAP + EMA(20) + mid-price + orderbook mid */
+    private computeFairValue;
+    /** Dynamic spread: base_spread * (1 + volatility_factor * ATR/price) */
+    private computeDynamicSpread;
+}

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

@@ -0,0 +1,141 @@
+import { registerStrategy } from "../strategy-registry.js";
+import { calculateEMA, calculateVWAP, calculateATR } from "../indicators.js";
+export class EngineMmStrategy {
+    name = "engine-mm";
+    describe() {
+        return {
+            description: "Production quoting engine with composite fair value and dynamic spread",
+            params: [
+                { name: "baseSpread", type: "number", required: true, description: "Base spread in basis points" },
+                { name: "levels", type: "number", required: false, default: 3, description: "Number of levels each side (3-5)" },
+                { name: "maxInventory", type: "number", required: true, description: "Maximum inventory position" },
+                { name: "skewFactor", type: "number", required: false, default: 0.5, description: "Inventory skew factor (0-1)" },
+                { name: "refreshSec", type: "number", required: false, default: 5, description: "Minimum seconds between requotes" },
+            ],
+        };
+    }
+    get params() {
+        return this._config;
+    }
+    _config = {};
+    async init(ctx, _snapshot) {
+        this._config = ctx.config;
+        ctx.state.set("inventory", 0);
+        ctx.state.set("lastRefresh", 0);
+        const p = this.params;
+        ctx.log(`  [ENGINE-MM] baseSpread=${p.baseSpread}bps, levels=${p.levels}, maxInv=${p.maxInventory}, skew=${p.skewFactor}`);
+    }
+    async onTick(ctx, snapshot) {
+        const params = this.params;
+        const now = Date.now();
+        const lastRefresh = ctx.state.get("lastRefresh") ?? 0;
+        // Rate-limit requotes
+        if (now - lastRefresh < (params.refreshSec ?? 5) * 1000) {
+            return [{ type: "noop" }];
+        }
+        ctx.state.set("lastRefresh", now);
+        const actions = [];
+        actions.push({ type: "cancel_all" });
+        // Compute fair value: composite of VWAP + EMA(20) + mid-price + oracle (equal weight)
+        const fairValue = this.computeFairValue(snapshot);
+        // Compute dynamic spread: base_spread * (1 + volatility_factor * ATR/price)
+        const dynamicSpread = this.computeDynamicSpread(snapshot);
+        // Inventory skew: shift quotes away from heavy side
+        const inventory = ctx.state.get("inventory") ?? 0;
+        const inventoryRatio = params.maxInventory > 0 ? inventory / params.maxInventory : 0;
+        const skew = inventoryRatio * (params.skewFactor ?? 0.5) * dynamicSpread;
+        const levels = params.levels || 3;
+        for (let i = 1; i <= levels; i++) {
+            const levelSpread = dynamicSpread * (1 + (i - 1) * 0.5); // increasing spread per level
+            const bidPrice = fairValue - levelSpread / 2 - skew;
+            const askPrice = fairValue + levelSpread / 2 - skew;
+            // Reduce size on heavy inventory side
+            const baseSize = params.maxInventory / (levels * 2);
+            const inventoryPenalty = Math.min(Math.abs(inventoryRatio), 0.8);
+            const bidSize = inventory > 0 ? baseSize * (1 - inventoryPenalty) : baseSize;
+            const askSize = inventory < 0 ? baseSize * (1 - inventoryPenalty) : baseSize;
+            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 from price movement
+        const prevMid = ctx.state.get("prevMid") ?? snapshot.price;
+        if (snapshot.price > prevMid) {
+            ctx.state.set("inventory", Math.min(inventory + (params.maxInventory / (levels * 4)), params.maxInventory));
+        }
+        else if (snapshot.price < prevMid) {
+            ctx.state.set("inventory", Math.max(inventory - (params.maxInventory / (levels * 4)), -params.maxInventory));
+        }
+        ctx.state.set("prevMid", snapshot.price);
+        return actions;
+    }
+    async onStop(_ctx) {
+        return [{ type: "cancel_all" }];
+    }
+    /** Composite fair value: equal-weight VWAP + EMA(20) + mid-price + orderbook mid */
+    computeFairValue(snapshot) {
+        const components = [];
+        // Mid-price (always available)
+        components.push(snapshot.price);
+        // VWAP from klines
+        if (snapshot.klines.length > 0) {
+            const candles = snapshot.klines.map(k => ({
+                close: parseFloat(k.close),
+                volume: parseFloat(k.volume),
+            }));
+            const vwap = calculateVWAP(candles);
+            if (vwap > 0)
+                components.push(vwap);
+        }
+        // EMA(20) from klines
+        if (snapshot.klines.length >= 20) {
+            const closes = snapshot.klines.map(k => parseFloat(k.close));
+            const ema = calculateEMA(closes, 20);
+            if (ema.length > 0)
+                components.push(ema[ema.length - 1]);
+        }
+        // Orderbook mid
+        if (snapshot.orderbook.bids.length > 0 && snapshot.orderbook.asks.length > 0) {
+            const bestBid = parseFloat(snapshot.orderbook.bids[0][0]);
+            const bestAsk = parseFloat(snapshot.orderbook.asks[0][0]);
+            if (bestBid > 0 && bestAsk > 0) {
+                components.push((bestBid + bestAsk) / 2);
+            }
+        }
+        return components.reduce((s, v) => s + v, 0) / components.length;
+    }
+    /** Dynamic spread: base_spread * (1 + volatility_factor * ATR/price) */
+    computeDynamicSpread(snapshot) {
+        const baseSpreadFrac = this.params.baseSpread / 10000;
+        let volatilityFactor = 1;
+        if (snapshot.klines.length >= 15) {
+            const candles = snapshot.klines.map(k => ({
+                high: parseFloat(k.high),
+                low: parseFloat(k.low),
+                close: parseFloat(k.close),
+            }));
+            const atr = calculateATR(candles, 14);
+            if (atr.length > 0) {
+                const latestATR = atr[atr.length - 1];
+                volatilityFactor = 1 + (latestATR / snapshot.price);
+            }
+        }
+        return snapshot.price * baseSpreadFrac * volatilityFactor;
+    }
+}
+registerStrategy("engine-mm", (_config) => new EngineMmStrategy());

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

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

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

@@ -0,0 +1,168 @@
+import { registerStrategy } from "../strategy-registry.js";
+import { checkArbLiquidity } from "../../liquidity.js";
+import { computeMatchedSize, reconcileArbFills } from "../../arb-sizing.js";
+export class FundingArbStrategy {
+    name = "funding-arb";
+    describe() {
+        return {
+            description: "Cross-exchange funding rate arbitrage",
+            params: [
+                { name: "min_spread", type: "number", required: true, description: "Minimum annualized spread %" },
+                { name: "close_spread", type: "number", required: false, default: 5, description: "Spread to close at" },
+                { name: "size_usd", type: "number", required: true, description: "Position size in USD" },
+                { name: "max_positions", type: "number", required: false, default: 3, description: "Max concurrent positions" },
+                { name: "exchanges", type: "string", required: true, description: "Comma-separated exchange names" },
+            ],
+        };
+    }
+    get params() {
+        return this._config;
+    }
+    _config = {};
+    async init(ctx, _snapshot) {
+        this._config = ctx.config;
+        const params = this.params;
+        ctx.state.set("arbRunning", true);
+        ctx.state.set("arbPositions", 0);
+        ctx.log(`  [ARB] Funding arb ready | spread >= ${params.min_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");
+        // Get extra adapters from context state (set by engine)
+        const extraAdapters = ctx.state.get("extraAdapters");
+        // Build adapter map from primary + extras
+        const adapters = new Map();
+        adapters.set(ctx.adapter.name.toLowerCase(), ctx.adapter);
+        if (extraAdapters) {
+            for (const [name, a] of extraAdapters)
+                adapters.set(name, a);
+        }
+        if (adapters.size < 2) {
+            ctx.log(`  [ARB] Need 2+ exchanges, have ${adapters.size}. Skipping.`);
+            return [];
+        }
+        // Fetch rates from all exchanges
+        const ratesByExchange = new Map();
+        for (const [name, a] of adapters) {
+            const rates = await this.fetchRates(a, name);
+            const map = new Map();
+            for (const r of rates)
+                map.set(r.symbol.toUpperCase(), { rate: r.rate, price: r.price });
+            ratesByExchange.set(name, map);
+        }
+        // Find opportunities
+        const exchangeNames = [...ratesByExchange.keys()];
+        const opportunities = [];
+        const allSymbols = new Set();
+        for (const [, map] of ratesByExchange) {
+            for (const sym of map.keys())
+                allSymbols.add(sym);
+        }
+        for (const sym of allSymbols) {
+            let minRate = Infinity, maxRate = -Infinity;
+            let minExchange = "", maxExchange = "";
+            for (const exName of exchangeNames) {
+                const rate = ratesByExchange.get(exName)?.get(sym)?.rate;
+                if (rate === undefined)
+                    continue;
+                if (rate < minRate) {
+                    minRate = rate;
+                    minExchange = exName;
+                }
+                if (rate > maxRate) {
+                    maxRate = rate;
+                    maxExchange = exName;
+                }
+            }
+            if (minExchange && maxExchange && minExchange !== maxExchange) {
+                const { computeAnnualSpread: cas } = await import("../../funding.js");
+                const spread = cas(maxRate, maxExchange, minRate, minExchange);
+                if (spread >= params.min_spread) {
+                    opportunities.push({
+                        symbol: sym,
+                        longExchange: minExchange,
+                        shortExchange: maxExchange,
+                        longRate: minRate,
+                        shortRate: maxRate,
+                        spread,
+                    });
+                }
+            }
+        }
+        opportunities.sort((a, b) => b.spread - a.spread);
+        if (opportunities.length > 0) {
+            const top = opportunities.slice(0, 3);
+            for (const opp of top) {
+                ctx.log(`  [ARB] ${opp.symbol}: ${opp.spread.toFixed(1)}% spread (long ${opp.longExchange} ${(opp.longRate * 100).toFixed(4)}% / short ${opp.shortExchange} ${(opp.shortRate * 100).toFixed(4)}%)`);
+            }
+            // Auto-execute if under position limit
+            if (arbPositions < params.max_positions && opportunities.length > 0) {
+                const best = opportunities[0];
+                const longAdapter = adapters.get(best.longExchange);
+                const shortAdapter = adapters.get(best.shortExchange);
+                if (longAdapter && shortAdapter) {
+                    const price = ratesByExchange.get(best.longExchange)?.get(best.symbol)?.price ?? 0;
+                    if (price > 0) {
+                        // Liquidity check
+                        const liq = await checkArbLiquidity(longAdapter, shortAdapter, best.symbol, params.size_usd, 0.5, (msg) => ctx.log(`  ${msg}`));
+                        if (!liq.viable)
+                            return [];
+                        // Compute matched size
+                        const 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),
+                            ]);
+                            // Verify fills match, correct if needed
+                            try {
+                                const recon = await reconcileArbFills(longAdapter, shortAdapter, best.symbol, (msg) => ctx.log(`  ${msg}`));
+                                if (!recon.matched) {
+                                    ctx.log(`  [ARB] WARNING: fills not matched after correction attempt`);
+                                }
+                            }
+                            catch { /* non-critical */ }
+                            ctx.state.set("arbPositions", arbPositions + 1);
+                            ctx.log(`  [ARB] Position opened! (${arbPositions + 1}/${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" }];
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            ctx.log(`  [ARB] Execution failed: ${msg}`);
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            ctx.log(`  [ARB] No opportunities >= ${params.min_spread}% spread`);
+        }
+        return [];
+    }
+    async onStop(_ctx) {
+        return [{ type: "cancel_all" }];
+    }
+    async fetchRates(adapter, _exchangeName) {
+        try {
+            const markets = await adapter.getMarkets();
+            return markets.map(m => ({
+                symbol: m.symbol,
+                rate: parseFloat(m.fundingRate),
+                price: parseFloat(m.markPrice),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+}
+registerStrategy("funding-arb", (_config) => new FundingArbStrategy());

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

@@ -0,0 +1,32 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+export declare class FundingArbV2Strategy implements Strategy {
+    readonly name = "funding-arb-v2";
+    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 minSpread();
+    private get closeSpread();
+    private get maxPositions();
+    private get sizeUsd();
+    private get scanIntervalSec();
+    init(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, _snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(ctx: StrategyContext): Promise<StrategyAction[]>;
+    private getAdapters;
+    /** Convert 8h funding rate difference to annualized spread % */
+    private annualizeSpread;
+}