perp-cli 0.3.3

package/dist/bot/conditions.d.ts

@@ -0,0 +1,32 @@
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+import type { Condition } from "./config.js";
+export interface MarketSnapshot {
+    price: number;
+    high24h: number;
+    low24h: number;
+    volume24h: number;
+    fundingRate: number;
+    volatility24h: number;
+    rsi: number;
+    spreadPct: number;
+}
+/**
+ * Calculate RSI from an array of closing prices using Wilder's smoothing method.
+ * @param closes Array of closing prices, oldest first.
+ * @param period RSI period (default 14).
+ * @returns RSI value between 0 and 100, or NaN if insufficient data.
+ */
+export declare function calculateRSI(closes: number[], period?: number): number;
+export declare function getMarketSnapshot(adapter: ExchangeAdapter, symbol: string): Promise<MarketSnapshot>;
+export declare function evaluateCondition(condition: Condition, snapshot: MarketSnapshot, context: {
+    equity: number;
+    startTime: number;
+    peakEquity: number;
+    dailyPnl: number;
+}): boolean;
+export declare function evaluateAllConditions(conditions: Condition[], snapshot: MarketSnapshot, context: {
+    equity: number;
+    startTime: number;
+    peakEquity: number;
+    dailyPnl: number;
+}, mode?: "all" | "any"): boolean;

package/dist/bot/conditions.js

@@ -0,0 +1,141 @@
+// ── RSI Calculation (Wilder smoothing) ──
+/**
+ * Calculate RSI from an array of closing prices using Wilder's smoothing method.
+ * @param closes Array of closing prices, oldest first.
+ * @param period RSI period (default 14).
+ * @returns RSI value between 0 and 100, or NaN if insufficient data.
+ */
+export function calculateRSI(closes, period = 14) {
+    if (closes.length < period + 1)
+        return NaN;
+    // Calculate price changes (deltas)
+    const deltas = [];
+    for (let i = 1; i < closes.length; i++) {
+        deltas.push(closes[i] - closes[i - 1]);
+    }
+    // Separate gains and losses
+    const gains = deltas.map(d => (d > 0 ? d : 0));
+    const losses = deltas.map(d => (d < 0 ? -d : 0));
+    // First average: simple mean of first `period` values
+    let avgGain = 0;
+    let avgLoss = 0;
+    for (let i = 0; i < period; i++) {
+        avgGain += gains[i];
+        avgLoss += losses[i];
+    }
+    avgGain /= period;
+    avgLoss /= period;
+    // Subsequent averages: Wilder smoothing
+    for (let i = period; i < deltas.length; i++) {
+        avgGain = (avgGain * (period - 1) + gains[i]) / period;
+        avgLoss = (avgLoss * (period - 1) + losses[i]) / period;
+    }
+    // Handle edge case: no losses at all
+    if (avgLoss === 0) {
+        return avgGain === 0 ? 50 : 100;
+    }
+    const rs = avgGain / avgLoss;
+    return 100 - 100 / (1 + rs);
+}
+export async function getMarketSnapshot(adapter, symbol) {
+    const markets = await adapter.getMarkets();
+    const m = markets.find(mk => mk.symbol.toUpperCase() === symbol.toUpperCase());
+    if (!m) {
+        return { price: 0, high24h: 0, low24h: 0, volume24h: 0, fundingRate: 0, volatility24h: 0, rsi: NaN, spreadPct: 0 };
+    }
+    const price = parseFloat(m.markPrice);
+    const fundingRate = parseFloat(m.fundingRate);
+    const volume24h = parseFloat(m.volume24h);
+    // Try to get kline data for 24h high/low + RSI
+    let high24h = price;
+    let low24h = price;
+    let rsi = NaN;
+    try {
+        const now = Date.now();
+        // Fetch enough candles for RSI (need period+1 candles minimum; fetch 48h for safety)
+        const klines = await adapter.getKlines(symbol, "1h", now - 48 * 3600 * 1000, now);
+        if (klines.length > 0) {
+            // Sort by time ascending
+            klines.sort((a, b) => a.time - b.time);
+            // 24h high/low: use only the last 24 candles
+            const last24h = klines.filter(k => k.time >= now - 24 * 3600 * 1000);
+            if (last24h.length > 0) {
+                high24h = Math.max(...last24h.map(k => parseFloat(k.high)));
+                low24h = Math.min(...last24h.map(k => parseFloat(k.low)));
+            }
+            // RSI from all available close prices
+            const closes = klines.map(k => parseFloat(k.close));
+            rsi = calculateRSI(closes, 14);
+        }
+    }
+    catch {
+        // non-critical
+    }
+    // Calculate bid-ask spread from orderbook
+    let spreadPct = 0;
+    try {
+        const ob = await adapter.getOrderbook(symbol);
+        if (ob.bids.length > 0 && ob.asks.length > 0) {
+            const bestBid = parseFloat(ob.bids[0][0]);
+            const bestAsk = parseFloat(ob.asks[0][0]);
+            const midPrice = (bestBid + bestAsk) / 2;
+            if (midPrice > 0) {
+                spreadPct = ((bestAsk - bestBid) / midPrice) * 100;
+            }
+        }
+    }
+    catch {
+        // non-critical
+    }
+    const volatility24h = price > 0 ? ((high24h - low24h) / price) * 100 : 0;
+    return { price, high24h, low24h, volume24h, fundingRate, volatility24h, rsi, spreadPct };
+}
+export function evaluateCondition(condition, snapshot, context) {
+    const val = typeof condition.value === "number" ? condition.value : parseFloat(String(condition.value));
+    switch (condition.type) {
+        case "always":
+            return true;
+        case "price_above":
+            return snapshot.price > val;
+        case "price_below":
+            return snapshot.price < val;
+        case "volatility_above":
+            return snapshot.volatility24h > val;
+        case "volatility_below":
+            return snapshot.volatility24h < val;
+        case "funding_rate_above":
+            return snapshot.fundingRate > val;
+        case "funding_rate_below":
+            return snapshot.fundingRate < val;
+        case "rsi_above":
+            // RSI was pre-computed in the snapshot from 1h kline data.
+            // If RSI is NaN (insufficient data), the condition is not met.
+            return !isNaN(snapshot.rsi) && snapshot.rsi > val;
+        case "rsi_below":
+            return !isNaN(snapshot.rsi) && snapshot.rsi < val;
+        case "balance_above":
+            return context.equity > val;
+        case "balance_below":
+            return context.equity < val;
+        case "spread_above":
+            // Bid-ask spread percentage, pre-computed from orderbook in snapshot.
+            return snapshot.spreadPct > val;
+        case "time_after": {
+            const elapsed = (Date.now() - context.startTime) / 1000;
+            return elapsed > val;
+        }
+        // Custom exit conditions (not standard ConditionType but used in exit logic)
+        case "max_drawdown":
+            return (context.peakEquity - context.equity) > val;
+        default:
+            return false;
+    }
+}
+export function evaluateAllConditions(conditions, snapshot, context, mode = "all") {
+    if (conditions.length === 0)
+        return true;
+    if (mode === "all") {
+        return conditions.every(c => evaluateCondition(c, snapshot, context));
+    }
+    return conditions.some(c => evaluateCondition(c, snapshot, context));
+}

package/dist/bot/config.d.ts

@@ -0,0 +1,76 @@
+export type ConditionType = "price_above" | "price_below" | "volatility_above" | "volatility_below" | "funding_rate_above" | "funding_rate_below" | "spread_above" | "rsi_above" | "rsi_below" | "balance_above" | "balance_below" | "time_after" | "always";
+export interface Condition {
+    type: ConditionType;
+    value: number | string;
+    symbol?: string;
+    exchange?: string;
+}
+export interface RiskConfig {
+    max_position_usd: number;
+    max_daily_loss: number;
+    max_drawdown: number;
+    pause_after_loss_sec: number;
+    max_open_bots: number;
+}
+export interface GridStrategyParams {
+    type: "grid";
+    grids: number;
+    size: number;
+    side: "long" | "short" | "neutral";
+    range_mode: "auto" | "fixed";
+    range_pct?: number;
+    upper?: number;
+    lower?: number;
+    rebalance: boolean;
+    rebalance_cooldown: number;
+    leverage?: number;
+}
+export interface DCAStrategyParams {
+    type: "dca";
+    amount: number;
+    interval_sec: number;
+    total_orders: number;
+    price_limit?: number;
+}
+export interface FundingArbStrategyParams {
+    type: "funding-arb";
+    min_spread: number;
+    close_spread: number;
+    size_usd: number;
+    max_positions: number;
+    exchanges: string[];
+}
+export type StrategyParams = GridStrategyParams | DCAStrategyParams | FundingArbStrategyParams;
+export interface BotConfig {
+    name: string;
+    exchange: string;
+    symbol: string;
+    strategy: StrategyParams;
+    entry_conditions: Condition[];
+    exit_conditions: Condition[];
+    risk: RiskConfig;
+    monitor_interval_sec: number;
+}
+export declare function loadBotConfig(pathOrInline: string): BotConfig;
+export declare function quickGridConfig(opts: {
+    exchange: string;
+    symbol: string;
+    rangePct: number;
+    grids: number;
+    size: number;
+    side: string;
+    maxDrawdown: number;
+    maxRuntime?: number;
+    leverage?: number;
+}): BotConfig;
+export declare function quickDCAConfig(opts: {
+    exchange: string;
+    symbol: string;
+    side: string;
+    amount: number;
+    intervalSec: number;
+    orders: number;
+    triggerDrop?: number;
+    priceLimit?: number;
+    maxDrawdown: number;
+}): BotConfig;

package/dist/bot/config.js

@@ -0,0 +1,160 @@
+import { readFileSync, existsSync } from "node:fs";
+import { parse as parseYaml } from "yaml";
+// ── Defaults ──
+const DEFAULT_RISK = {
+    max_position_usd: 1000,
+    max_daily_loss: 100,
+    max_drawdown: 200,
+    pause_after_loss_sec: 300,
+    max_open_bots: 5,
+};
+// ── Loader ──
+export function loadBotConfig(pathOrInline) {
+    let raw;
+    if (existsSync(pathOrInline)) {
+        const content = readFileSync(pathOrInline, "utf-8");
+        if (pathOrInline.endsWith(".json")) {
+            raw = JSON.parse(content);
+        }
+        else {
+            raw = parseYaml(content);
+        }
+    }
+    else {
+        // Try parsing as inline JSON
+        raw = JSON.parse(pathOrInline);
+    }
+    return parseBotConfig(raw);
+}
+function parseBotConfig(raw) {
+    const name = String(raw.name ?? `bot-${Date.now()}`);
+    const exchange = String(raw.exchange ?? "hyperliquid");
+    const symbol = String(raw.symbol ?? "ETH");
+    const monitorInterval = Number(raw.monitor_interval_sec ?? raw.interval ?? 10);
+    // Strategy
+    const stratRaw = (raw.strategy ?? raw.params ?? {});
+    const stratType = String(stratRaw.type ?? raw.strategy_type ?? "grid");
+    const strategy = parseStrategy(stratType, stratRaw);
+    // Conditions
+    const entryConds = parseConditions(raw.entry_conditions);
+    const exitConds = parseConditions(raw.exit_conditions);
+    // If no entry conditions, default to "always"
+    if (entryConds.length === 0) {
+        entryConds.push({ type: "always", value: 0 });
+    }
+    // Risk
+    const riskRaw = (raw.risk ?? {});
+    const risk = {
+        max_position_usd: Number(riskRaw.max_position_usd ?? DEFAULT_RISK.max_position_usd),
+        max_daily_loss: Number(riskRaw.max_daily_loss ?? DEFAULT_RISK.max_daily_loss),
+        max_drawdown: Number(riskRaw.max_drawdown ?? DEFAULT_RISK.max_drawdown),
+        pause_after_loss_sec: Number(riskRaw.pause_after_loss_sec ?? riskRaw.pause_after_loss ?? DEFAULT_RISK.pause_after_loss_sec),
+        max_open_bots: Number(riskRaw.max_open_bots ?? DEFAULT_RISK.max_open_bots),
+    };
+    return { name, exchange, symbol, strategy, entry_conditions: entryConds, exit_conditions: exitConds, risk, monitor_interval_sec: monitorInterval };
+}
+function parseStrategy(type, raw) {
+    switch (type) {
+        case "grid":
+            return {
+                type: "grid",
+                grids: Number(raw.grids ?? 10),
+                size: Number(raw.size ?? 0.1),
+                side: (String(raw.side ?? "neutral")),
+                range_mode: String(raw.range_mode ?? "auto"),
+                range_pct: raw.range_pct !== undefined ? Number(raw.range_pct) : 3,
+                upper: raw.upper !== undefined ? Number(raw.upper) : undefined,
+                lower: raw.lower !== undefined ? Number(raw.lower) : undefined,
+                rebalance: raw.rebalance !== false,
+                rebalance_cooldown: Number(raw.rebalance_cooldown ?? 60),
+                leverage: raw.leverage !== undefined ? Number(raw.leverage) : undefined,
+            };
+        case "dca":
+            return {
+                type: "dca",
+                amount: Number(raw.amount ?? 0.01),
+                interval_sec: Number(raw.interval_sec ?? raw.interval ?? 60),
+                total_orders: Number(raw.total_orders ?? raw.orders ?? 0),
+                price_limit: raw.price_limit !== undefined ? Number(raw.price_limit) : undefined,
+            };
+        case "funding-arb":
+            return {
+                type: "funding-arb",
+                min_spread: Number(raw.min_spread ?? 20),
+                close_spread: Number(raw.close_spread ?? 5),
+                size_usd: Number(raw.size_usd ?? raw.size ?? 50),
+                max_positions: Number(raw.max_positions ?? 3),
+                exchanges: Array.isArray(raw.exchanges)
+                    ? raw.exchanges.map(String)
+                    : String(raw.exchanges ?? "pacifica,hyperliquid").split(",").map(s => s.trim()),
+            };
+        default:
+            throw new Error(`Unknown strategy type: ${type}`);
+    }
+}
+function parseConditions(raw) {
+    if (!raw || !Array.isArray(raw))
+        return [];
+    return raw.map((c) => {
+        const cond = c;
+        return {
+            type: String(cond.type ?? "always"),
+            value: cond.value !== undefined ? (typeof cond.value === "number" ? cond.value : String(cond.value)) : 0,
+            symbol: cond.symbol ? String(cond.symbol) : undefined,
+            exchange: cond.exchange ? String(cond.exchange) : undefined,
+        };
+    });
+}
+// ── Quick config builders ──
+export function quickGridConfig(opts) {
+    return {
+        name: `grid-${opts.symbol.toLowerCase()}-${Date.now().toString(36)}`,
+        exchange: opts.exchange,
+        symbol: opts.symbol,
+        strategy: {
+            type: "grid",
+            grids: opts.grids,
+            size: opts.size,
+            side: opts.side,
+            range_mode: "auto",
+            range_pct: opts.rangePct,
+            rebalance: true,
+            rebalance_cooldown: 60,
+            leverage: opts.leverage,
+        },
+        entry_conditions: [{ type: "always", value: 0 }],
+        exit_conditions: [
+            { type: "max_drawdown", value: opts.maxDrawdown },
+            ...(opts.maxRuntime ? [{ type: "time_after", value: opts.maxRuntime }] : []),
+        ],
+        risk: { ...DEFAULT_RISK, max_drawdown: opts.maxDrawdown },
+        monitor_interval_sec: 10,
+    };
+}
+export function quickDCAConfig(opts) {
+    const entryConds = [];
+    if (opts.triggerDrop) {
+        entryConds.push({ type: "price_below", value: opts.triggerDrop });
+    }
+    else {
+        entryConds.push({ type: "always", value: 0 });
+    }
+    return {
+        name: `dca-${opts.symbol.toLowerCase()}-${Date.now().toString(36)}`,
+        exchange: opts.exchange,
+        symbol: opts.symbol,
+        strategy: {
+            type: "dca",
+            amount: opts.amount,
+            interval_sec: opts.intervalSec,
+            total_orders: opts.orders,
+            price_limit: opts.priceLimit,
+        },
+        entry_conditions: entryConds,
+        exit_conditions: [
+            { type: "max_drawdown", value: opts.maxDrawdown },
+        ],
+        risk: { ...DEFAULT_RISK, max_drawdown: opts.maxDrawdown },
+        monitor_interval_sec: opts.intervalSec,
+    };
+}

package/dist/bot/engine.d.ts

@@ -0,0 +1,8 @@
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+import type { BotConfig } from "./config.js";
+export type BotLog = (msg: string) => void;
+export declare function runBot(adapter: ExchangeAdapter, config: BotConfig, jobId?: string, log?: BotLog, extraAdapters?: Map<string, ExchangeAdapter>): Promise<{
+    fills: number;
+    totalPnl: number;
+    runtime: number;
+}>;