perp-cli 0.3.3

package/dist/__tests__/arb-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/arb-utils.test.js

@@ -0,0 +1,264 @@
+import { describe, it, expect, vi } from "vitest";
+import { getLastSettlement, getMinutesSinceSettlement, aggressiveSettleBoost, estimateFundingUntilSettlement, computeBasisRisk, formatNotifyMessage, sendNotification, } from "../arb-utils.js";
+// ── Settlement Timing Tests ──
+describe("getMinutesSinceSettlement", () => {
+    it("returns correct minutes after HL settlement (hourly)", () => {
+        // 14:30 UTC — last HL settlement was at 14:00, so 30 minutes ago
+        const now = new Date("2024-06-15T14:30:00Z");
+        const mins = getMinutesSinceSettlement("hyperliquid", now);
+        expect(mins).toBeCloseTo(30, 0);
+    });
+    it("returns correct minutes after PAC settlement (every 1h, same as HL)", () => {
+        // 10:15 UTC — last PAC settlement was at 10:00, so 15 minutes ago
+        const now = new Date("2024-06-15T10:15:00Z");
+        const mins = getMinutesSinceSettlement("pacifica", now);
+        expect(mins).toBeCloseTo(15, 0);
+    });
+    it("returns small value right after settlement", () => {
+        // 16:02 UTC — 2 minutes after PAC settlement at 16:00
+        const now = new Date("2024-06-15T16:02:00Z");
+        const mins = getMinutesSinceSettlement("pacifica", now);
+        expect(mins).toBeCloseTo(2, 0);
+    });
+    it("returns correct value right before next settlement", () => {
+        // 07:55 UTC — 55 minutes since last PAC settlement at 07:00
+        const now = new Date("2024-06-15T07:55:00Z");
+        const mins = getMinutesSinceSettlement("pacifica", now);
+        expect(mins).toBeCloseTo(55, 0);
+    });
+    it("handles midnight correctly for PAC", () => {
+        // 00:05 UTC — 5 minutes after 00:00 PAC settlement
+        const now = new Date("2024-06-15T00:05:00Z");
+        const mins = getMinutesSinceSettlement("pacifica", now);
+        expect(mins).toBeCloseTo(5, 0);
+    });
+    it("handles Lighter same as Pacifica (both hourly)", () => {
+        const now = new Date("2024-06-15T10:00:00Z");
+        const pacMins = getMinutesSinceSettlement("pacifica", now);
+        const ltMins = getMinutesSinceSettlement("lighter", now);
+        expect(ltMins).toBe(pacMins);
+    });
+});
+describe("getLastSettlement", () => {
+    it("returns the exact settlement time for HL", () => {
+        const now = new Date("2024-06-15T14:30:00Z");
+        const last = getLastSettlement("hyperliquid", now);
+        expect(last.getUTCHours()).toBe(14);
+        expect(last.getUTCMinutes()).toBe(0);
+    });
+    it("returns same hour for PAC (hourly settlement, same as HL)", () => {
+        // At 00:05 the last PAC settlement is 00:00 same day
+        const now = new Date("2024-06-15T00:05:00Z");
+        const last = getLastSettlement("pacifica", now);
+        expect(last.getUTCHours()).toBe(0);
+        expect(last.getUTCDate()).toBe(15); // same day since 00:00 is a settlement
+    });
+});
+describe("aggressiveSettleBoost", () => {
+    it("returns > 1.0 immediately after both exchanges settle", () => {
+        // Right after both HL and PAC settle (e.g., 16:01)
+        const now = new Date("2024-06-15T16:01:00Z");
+        const boost = aggressiveSettleBoost("hyperliquid", "pacifica", 10, now);
+        expect(boost).toBeGreaterThan(1.0);
+        expect(boost).toBeLessThanOrEqual(1.5);
+    });
+    it("returns 1.5 at exactly settlement time", () => {
+        // At exactly 16:00:01 — both just settled
+        const now = new Date("2024-06-15T16:00:01Z");
+        const boost = aggressiveSettleBoost("hyperliquid", "pacifica", 10, now);
+        // HL settled 0.01min ago, PAC settled 0.01min ago
+        // min = ~0.01, factor = 1 + 0.5 * (1 - 0.01/10) = ~1.499
+        expect(boost).toBeGreaterThan(1.4);
+        expect(boost).toBeLessThanOrEqual(1.5);
+    });
+    it("returns 1.0 when far from settlement", () => {
+        // 14:30 — both HL and PAC settled at 14:00, 30 minutes ago
+        const now = new Date("2024-06-15T14:30:00Z");
+        const boost = aggressiveSettleBoost("hyperliquid", "pacifica", 10, now);
+        // HL settled 30min ago > 10 window, PAC settled 30min ago > 10 window
+        // min(30, 30) = 30 > 10, so boost = 1.0
+        expect(boost).toBe(1.0);
+    });
+    it("returns 1.0 for both exchanges when settled > window ago", () => {
+        // HL settled 15 minutes ago, PAC settled 15 minutes ago
+        // With window of 10, both are > 10 so boost = 1.0
+        const now = new Date("2024-06-15T08:15:00Z");
+        const boost = aggressiveSettleBoost("hyperliquid", "pacifica", 10, now);
+        // HL settled at 08:00 (15 min ago), PAC settled at 08:00 (15 min ago)
+        // min(15, 15) = 15 > 10 => 1.0
+        expect(boost).toBe(1.0);
+    });
+    it("decays linearly within window", () => {
+        // HL settled 5 minutes ago, PAC settled 5 minutes ago (at 08:05)
+        const now = new Date("2024-06-15T08:05:00Z");
+        const boost = aggressiveSettleBoost("hyperliquid", "pacifica", 10, now);
+        // min(5, 5) = 5, factor = 1 + 0.5 * (1 - 5/10) = 1.25
+        expect(boost).toBeCloseTo(1.25, 1);
+    });
+});
+// ── Funding Estimation Tests ──
+describe("estimateFundingUntilSettlement", () => {
+    it("calculates correct cumulative HL funding", () => {
+        // 0.01% hourly rate, $1000 position, 4 hours until settlement
+        const result = estimateFundingUntilSettlement(0.0001, 0.00005, 1000, 4);
+        // hlCumulative = 0.0001 * 1000 * 4 = 0.4
+        expect(result.hlCumulative).toBeCloseTo(0.4, 4);
+    });
+    it("calculates correct PAC payment (also hourly)", () => {
+        // PAC hourly rate = 0.00005, $1000 position, 4 hours
+        const result = estimateFundingUntilSettlement(0.0001, 0.00005, 1000, 4);
+        // pacPayment = 0.00005 * 1000 * 4 = 0.2
+        expect(result.pacPayment).toBeCloseTo(0.2, 4);
+    });
+    it("calculates net funding correctly", () => {
+        const result = estimateFundingUntilSettlement(0.0001, 0.00005, 1000, 4);
+        // net = 0.4 - 0.2 = 0.2
+        expect(result.netFunding).toBeCloseTo(0.2, 4);
+    });
+    it("handles zero rates", () => {
+        const result = estimateFundingUntilSettlement(0, 0, 1000, 8);
+        expect(result.hlCumulative).toBe(0);
+        expect(result.pacPayment).toBe(0);
+        expect(result.netFunding).toBe(0);
+    });
+    it("scales linearly with position size", () => {
+        const small = estimateFundingUntilSettlement(0.0001, 0.00005, 100, 4);
+        const big = estimateFundingUntilSettlement(0.0001, 0.00005, 1000, 4);
+        expect(big.hlCumulative).toBeCloseTo(small.hlCumulative * 10, 4);
+        expect(big.pacPayment).toBeCloseTo(small.pacPayment * 10, 4);
+    });
+    it("both sides scale with time (both hourly)", () => {
+        const short = estimateFundingUntilSettlement(0.0001, 0.00005, 1000, 2);
+        const long = estimateFundingUntilSettlement(0.0001, 0.00005, 1000, 8);
+        expect(long.hlCumulative).toBeCloseTo(short.hlCumulative * 4, 4);
+        expect(long.pacPayment).toBeCloseTo(short.pacPayment * 4, 4);
+    });
+});
+// ── Basis Risk Tests ──
+describe("computeBasisRisk", () => {
+    it("detects divergence correctly", () => {
+        const result = computeBasisRisk(100, 104, 3);
+        // |100 - 104| / 102 * 100 = ~3.92%
+        expect(result.divergencePct).toBeCloseTo(3.92, 1);
+        expect(result.warning).toBe(true);
+    });
+    it("no warning when divergence is low", () => {
+        const result = computeBasisRisk(100, 101, 3);
+        // |100 - 101| / 100.5 * 100 = ~0.995%
+        expect(result.divergencePct).toBeCloseTo(1.0, 0);
+        expect(result.warning).toBe(false);
+    });
+    it("handles equal prices", () => {
+        const result = computeBasisRisk(50, 50, 3);
+        expect(result.divergencePct).toBe(0);
+        expect(result.warning).toBe(false);
+    });
+    it("handles zero prices", () => {
+        const result = computeBasisRisk(0, 100, 3);
+        expect(result.divergencePct).toBe(0);
+        expect(result.warning).toBe(false);
+    });
+    it("uses custom threshold", () => {
+        const result = computeBasisRisk(100, 101, 0.5);
+        // ~1% divergence > 0.5% threshold
+        expect(result.warning).toBe(true);
+    });
+    it("symmetric for long/short swap", () => {
+        const a = computeBasisRisk(100, 105, 3);
+        const b = computeBasisRisk(105, 100, 3);
+        expect(a.divergencePct).toBeCloseTo(b.divergencePct, 4);
+        expect(a.warning).toBe(b.warning);
+    });
+});
+// ── Notification Tests ──
+describe("formatNotifyMessage", () => {
+    it("formats entry message", () => {
+        const msg = formatNotifyMessage("entry", {
+            symbol: "WIF", longExchange: "lighter", shortExchange: "pacifica",
+            size: 500, netSpread: 28.5,
+        });
+        expect(msg).toContain("WIF");
+        expect(msg).toContain("Long lighter");
+        expect(msg).toContain("Short pacifica");
+        expect(msg).toContain("$500");
+        expect(msg).toContain("28.5%");
+    });
+    it("formats exit message", () => {
+        const msg = formatNotifyMessage("exit", {
+            symbol: "ETH", pnl: 10.5, duration: "7d 3h",
+        });
+        expect(msg).toContain("ETH");
+        expect(msg).toContain("+$10.50");
+        expect(msg).toContain("7d 3h");
+    });
+    it("formats exit message with negative PnL", () => {
+        const msg = formatNotifyMessage("exit", {
+            symbol: "SOL", pnl: -5.25, duration: "2d",
+        });
+        expect(msg).toContain("SOL");
+        expect(msg).toContain("-$5.25");
+    });
+    it("formats reversal message", () => {
+        const msg = formatNotifyMessage("reversal", { symbol: "WIF" });
+        expect(msg).toContain("REVERSAL");
+        expect(msg).toContain("WIF");
+    });
+    it("formats margin message", () => {
+        const msg = formatNotifyMessage("margin", {
+            exchange: "Lighter", marginPct: 25.3, threshold: 30,
+        });
+        expect(msg).toContain("LOW MARGIN");
+        expect(msg).toContain("Lighter");
+        expect(msg).toContain("25.3%");
+        expect(msg).toContain("30.0%");
+    });
+    it("formats basis risk message", () => {
+        const msg = formatNotifyMessage("basis", {
+            symbol: "WIF", divergencePct: 4.2, longExchange: "LT", shortExchange: "PAC",
+        });
+        expect(msg).toContain("BASIS RISK");
+        expect(msg).toContain("WIF");
+        expect(msg).toContain("4.2%");
+        expect(msg).toContain("LT/PAC");
+    });
+});
+describe("sendNotification", () => {
+    it("sends Discord webhook with content field", async () => {
+        const mockFetch = vi.fn().mockResolvedValue({ ok: true });
+        await sendNotification("https://discord.com/api/webhooks/123/abc", "entry", { symbol: "BTC", longExchange: "HL", shortExchange: "PAC", size: 100, netSpread: 30 }, mockFetch);
+        expect(mockFetch).toHaveBeenCalledOnce();
+        const [url, opts] = mockFetch.mock.calls[0];
+        expect(url).toContain("discord.com/api/webhooks");
+        const body = JSON.parse(opts.body);
+        expect(body).toHaveProperty("content");
+        expect(body.content).toContain("BTC");
+    });
+    it("sends Telegram webhook with chat_id and text", async () => {
+        const mockFetch = vi.fn().mockResolvedValue({ ok: true });
+        await sendNotification("https://api.telegram.org/bot123:TOKEN/sendMessage?chat_id=456", "exit", { symbol: "ETH", pnl: 5, duration: "3h" }, mockFetch);
+        expect(mockFetch).toHaveBeenCalledOnce();
+        const [url, opts] = mockFetch.mock.calls[0];
+        expect(url).toContain("api.telegram.org");
+        const body = JSON.parse(opts.body);
+        expect(body).toHaveProperty("chat_id", "456");
+        expect(body).toHaveProperty("text");
+        expect(body.text).toContain("ETH");
+    });
+    it("sends generic webhook with JSON body", async () => {
+        const mockFetch = vi.fn().mockResolvedValue({ ok: true });
+        await sendNotification("https://my-api.example.com/webhook", "basis", { symbol: "SOL", divergencePct: 5 }, mockFetch);
+        expect(mockFetch).toHaveBeenCalledOnce();
+        const [url, opts] = mockFetch.mock.calls[0];
+        expect(url).toContain("my-api.example.com");
+        const body = JSON.parse(opts.body);
+        expect(body).toHaveProperty("event", "basis");
+        expect(body).toHaveProperty("message");
+        expect(body).toHaveProperty("data");
+    });
+    it("does not throw on fetch failure", async () => {
+        const mockFetch = vi.fn().mockRejectedValue(new Error("network error"));
+        // Should not throw
+        await sendNotification("https://discord.com/api/webhooks/123/abc", "entry", { symbol: "BTC" }, mockFetch);
+        expect(mockFetch).toHaveBeenCalledOnce();
+    });
+});

package/dist/__tests__/bot-conditions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/bot-conditions.test.js

@@ -0,0 +1,341 @@
+import { describe, it, expect } from "vitest";
+import { calculateRSI, evaluateCondition, evaluateAllConditions, } from "../bot/conditions.js";
+// ── Helper: build a snapshot with defaults ──
+function makeSnapshot(overrides = {}) {
+    return {
+        price: 100,
+        high24h: 105,
+        low24h: 95,
+        volume24h: 1_000_000,
+        fundingRate: 0.0001,
+        volatility24h: 10,
+        rsi: 50,
+        spreadPct: 0.05,
+        ...overrides,
+    };
+}
+const defaultContext = {
+    equity: 10_000,
+    startTime: Date.now() - 60_000,
+    peakEquity: 10_500,
+    dailyPnl: -200,
+};
+// ═══════════════════════════════════════════════════
+// RSI Calculation Tests
+// ═══════════════════════════════════════════════════
+describe("calculateRSI", () => {
+    it("returns NaN when insufficient data (fewer than period+1 prices)", () => {
+        // Need at least 15 prices for period=14 (to get 14 deltas)
+        const closes = [100, 101, 102, 103, 104]; // only 5 prices
+        expect(calculateRSI(closes, 14)).toBeNaN();
+    });
+    it("returns NaN for empty array", () => {
+        expect(calculateRSI([])).toBeNaN();
+    });
+    it("returns NaN for single price", () => {
+        expect(calculateRSI([100])).toBeNaN();
+    });
+    it("returns 100 when all changes are positive (14 consecutive ups)", () => {
+        // 15 prices: 100, 101, ..., 114 — all gains, no losses
+        const closes = Array.from({ length: 15 }, (_, i) => 100 + i);
+        const rsi = calculateRSI(closes, 14);
+        expect(rsi).toBe(100);
+    });
+    it("returns ~0 when all changes are negative (14 consecutive downs)", () => {
+        // 15 prices: 114, 113, ..., 100 — all losses, no gains
+        const closes = Array.from({ length: 15 }, (_, i) => 114 - i);
+        const rsi = calculateRSI(closes, 14);
+        expect(rsi).toBeCloseTo(0, 5);
+    });
+    it("returns 50 when all prices are the same (no movement)", () => {
+        const closes = Array.from({ length: 20 }, () => 100);
+        const rsi = calculateRSI(closes, 14);
+        // avgGain=0, avgLoss=0 => RSI=50 by convention
+        expect(rsi).toBe(50);
+    });
+    it("returns ~50 when gains and losses are perfectly balanced", () => {
+        // Alternating +1, -1 with enough data for Wilder smoothing to converge
+        const closes = [100];
+        for (let i = 1; i <= 100; i++) {
+            closes.push(closes[i - 1] + (i % 2 === 1 ? 1 : -1));
+        }
+        // With Wilder smoothing, alternating equal gains/losses converges toward 50
+        const rsi = calculateRSI(closes, 14);
+        expect(rsi).toBeGreaterThan(45);
+        expect(rsi).toBeLessThan(55);
+    });
+    it("computes correct RSI for a known sequence (textbook example)", () => {
+        // Classic textbook: 14-period RSI example
+        // Prices chosen so that first 14 deltas have known gains/losses
+        const closes = [
+            44.34, 44.09, 44.15, 43.61, 44.33,
+            44.83, 45.10, 45.42, 45.84, 46.08,
+            45.89, 46.03, 45.61, 46.28, 46.28,
+            46.00, 46.03, 46.41, 46.22, 46.21,
+        ];
+        // This is a well-known RSI example; 14 deltas from 20 prices
+        // First 14 deltas: -0.25, 0.06, -0.54, 0.72, 0.50, 0.27, 0.32, 0.42, 0.24, -0.19, 0.14, -0.42, 0.67, 0.00
+        // Gains: 0, 0.06, 0, 0.72, 0.50, 0.27, 0.32, 0.42, 0.24, 0, 0.14, 0, 0.67, 0 = 3.34, avg = 0.2386
+        // Losses: 0.25, 0, 0.54, 0, 0, 0, 0, 0, 0, 0.19, 0, 0.42, 0, 0 = 1.40, avg = 0.1000
+        // After Wilder smoothing for remaining 5 deltas...
+        // We just verify it's in a reasonable range (60-80 for this bullish data)
+        const rsi = calculateRSI(closes, 14);
+        expect(rsi).toBeGreaterThan(55);
+        expect(rsi).toBeLessThan(80);
+    });
+    it("works with period=7 (shorter period)", () => {
+        // 8 prices needed minimum for period=7
+        const closes = [100, 102, 101, 103, 105, 104, 106, 108];
+        const rsi = calculateRSI(closes, 7);
+        // Mostly up, should be above 50
+        expect(rsi).toBeGreaterThan(50);
+        expect(rsi).toBeLessThanOrEqual(100);
+    });
+    it("handles exactly period+1 prices (minimum required)", () => {
+        // Exactly 15 prices for period=14
+        const closes = Array.from({ length: 15 }, (_, i) => 100 + i * 0.5);
+        const rsi = calculateRSI(closes, 14);
+        // All ups => RSI = 100
+        expect(rsi).toBe(100);
+    });
+    it("handles large datasets correctly", () => {
+        // 200 prices with upward trend + noise
+        const closes = [1000];
+        for (let i = 1; i < 200; i++) {
+            // Trend up ~0.5 with noise +-2
+            closes.push(closes[i - 1] + 0.5 + (Math.sin(i) * 2));
+        }
+        const rsi = calculateRSI(closes, 14);
+        expect(rsi).toBeGreaterThan(0);
+        expect(rsi).toBeLessThan(100);
+        expect(Number.isFinite(rsi)).toBe(true);
+    });
+    it("RSI increases when more gains are added to the series", () => {
+        // Base: mixed data
+        const base = [100, 99, 101, 98, 102, 97, 103, 96, 104, 95, 105, 94, 106, 93, 107];
+        const rsiBase = calculateRSI(base, 14);
+        // Extend with strong gains
+        const bullish = [...base, 110, 115, 120, 125, 130];
+        const rsiBullish = calculateRSI(bullish, 14);
+        expect(rsiBullish).toBeGreaterThan(rsiBase);
+    });
+    it("RSI decreases when more losses are added to the series", () => {
+        const base = [100, 99, 101, 98, 102, 97, 103, 96, 104, 95, 105, 94, 106, 93, 107];
+        const rsiBase = calculateRSI(base, 14);
+        // Extend with strong losses
+        const bearish = [...base, 102, 97, 92, 87, 82];
+        const rsiBearish = calculateRSI(bearish, 14);
+        expect(rsiBearish).toBeLessThan(rsiBase);
+    });
+    it("returns value in [0, 100] range for random data", () => {
+        // Generate random-walk prices
+        const closes = [100];
+        for (let i = 1; i < 50; i++) {
+            closes.push(closes[i - 1] + (Math.random() - 0.5) * 4);
+        }
+        const rsi = calculateRSI(closes, 14);
+        expect(rsi).toBeGreaterThanOrEqual(0);
+        expect(rsi).toBeLessThanOrEqual(100);
+    });
+    it("default period is 14", () => {
+        const closes = Array.from({ length: 20 }, (_, i) => 100 + i);
+        const rsiDefault = calculateRSI(closes);
+        const rsi14 = calculateRSI(closes, 14);
+        expect(rsiDefault).toBe(rsi14);
+    });
+});
+// ═══════════════════════════════════════════════════
+// RSI with real-world-like price data
+// ═══════════════════════════════════════════════════
+describe("calculateRSI with realistic price data", () => {
+    it("produces overbought signal (>70) in strong uptrend", () => {
+        // Simulate strong uptrend: ETH going from 2000 to 2400 over 30 candles
+        const closes = [];
+        for (let i = 0; i < 30; i++) {
+            // Strong consistent uptrend with small pullbacks
+            closes.push(2000 + i * 14 - (i % 3 === 0 ? 5 : 0));
+        }
+        const rsi = calculateRSI(closes, 14);
+        expect(rsi).toBeGreaterThan(70);
+    });
+    it("produces oversold signal (<30) in strong downtrend", () => {
+        // Simulate strong downtrend: ETH going from 2400 to 2000 over 30 candles
+        const closes = [];
+        for (let i = 0; i < 30; i++) {
+            closes.push(2400 - i * 14 + (i % 3 === 0 ? 5 : 0));
+        }
+        const rsi = calculateRSI(closes, 14);
+        expect(rsi).toBeLessThan(30);
+    });
+    it("hovers around 50 in choppy/sideways market", () => {
+        // Simulate choppy market: oscillating around 2000
+        const closes = [];
+        for (let i = 0; i < 40; i++) {
+            closes.push(2000 + Math.sin(i * 0.8) * 20);
+        }
+        const rsi = calculateRSI(closes, 14);
+        expect(rsi).toBeGreaterThan(30);
+        expect(rsi).toBeLessThan(70);
+    });
+    it("responds to trend reversal", () => {
+        // Downtrend then reversal
+        const closes = [];
+        // 20 candles of downtrend
+        for (let i = 0; i < 20; i++) {
+            closes.push(2400 - i * 10);
+        }
+        const rsiBeforeReversal = calculateRSI(closes, 14);
+        // 10 candles of uptrend (reversal)
+        for (let i = 0; i < 10; i++) {
+            closes.push(2200 + i * 15);
+        }
+        const rsiAfterReversal = calculateRSI(closes, 14);
+        expect(rsiAfterReversal).toBeGreaterThan(rsiBeforeReversal);
+    });
+});
+// ═══════════════════════════════════════════════════
+// evaluateCondition tests for RSI
+// ═══════════════════════════════════════════════════
+describe("evaluateCondition — rsi_above", () => {
+    it("returns true when RSI exceeds the threshold", () => {
+        const snapshot = makeSnapshot({ rsi: 75 });
+        const cond = { type: "rsi_above", value: 70 };
+        expect(evaluateCondition(cond, snapshot, defaultContext)).toBe(true);
+    });
+    it("returns false when RSI is below the threshold", () => {
+        const snapshot = makeSnapshot({ rsi: 65 });
+        const cond = { type: "rsi_above", value: 70 };
+        expect(evaluateCondition(cond, snapshot, defaultContext)).toBe(false);
+    });
+    it("returns false when RSI equals the threshold (not strictly above)", () => {
+        const snapshot = makeSnapshot({ rsi: 70 });
+        const cond = { type: "rsi_above", value: 70 };
+        expect(evaluateCondition(cond, snapshot, defaultContext)).toBe(false);
+    });
+    it("returns false when RSI is NaN (insufficient data)", () => {
+        const snapshot = makeSnapshot({ rsi: NaN });
+        const cond = { type: "rsi_above", value: 30 };
+        expect(evaluateCondition(cond, snapshot, defaultContext)).toBe(false);
+    });
+    it("accepts string value and parses it", () => {
+        const snapshot = makeSnapshot({ rsi: 80 });
+        const cond = { type: "rsi_above", value: "70" };
+        expect(evaluateCondition(cond, snapshot, defaultContext)).toBe(true);
+    });
+});
+describe("evaluateCondition — rsi_below", () => {
+    it("returns true when RSI is below the threshold", () => {
+        const snapshot = makeSnapshot({ rsi: 25 });
+        const cond = { type: "rsi_below", value: 30 };
+        expect(evaluateCondition(cond, snapshot, defaultContext)).toBe(true);
+    });
+    it("returns false when RSI is above the threshold", () => {
+        const snapshot = makeSnapshot({ rsi: 45 });
+        const cond = { type: "rsi_below", value: 30 };
+        expect(evaluateCondition(cond, snapshot, defaultContext)).toBe(false);
+    });
+    it("returns false when RSI equals the threshold", () => {
+        const snapshot = makeSnapshot({ rsi: 30 });
+        const cond = { type: "rsi_below", value: 30 };
+        expect(evaluateCondition(cond, snapshot, defaultContext)).toBe(false);
+    });
+    it("returns false when RSI is NaN", () => {
+        const snapshot = makeSnapshot({ rsi: NaN });
+        const cond = { type: "rsi_below", value: 70 };
+        expect(evaluateCondition(cond, snapshot, defaultContext)).toBe(false);
+    });
+});
+// ═══════════════════════════════════════════════════
+// evaluateCondition tests for spread_above
+// ═══════════════════════════════════════════════════
+describe("evaluateCondition — spread_above", () => {
+    it("returns true when spread exceeds threshold", () => {
+        const snapshot = makeSnapshot({ spreadPct: 0.15 });
+        const cond = { type: "spread_above", value: 0.1 };
+        expect(evaluateCondition(cond, snapshot, defaultContext)).toBe(true);
+    });
+    it("returns false when spread is below threshold", () => {
+        const snapshot = makeSnapshot({ spreadPct: 0.03 });
+        const cond = { type: "spread_above", value: 0.1 };
+        expect(evaluateCondition(cond, snapshot, defaultContext)).toBe(false);
+    });
+    it("returns false when spread equals threshold", () => {
+        const snapshot = makeSnapshot({ spreadPct: 0.1 });
+        const cond = { type: "spread_above", value: 0.1 };
+        expect(evaluateCondition(cond, snapshot, defaultContext)).toBe(false);
+    });
+    it("returns false when spread is zero (tight book)", () => {
+        const snapshot = makeSnapshot({ spreadPct: 0 });
+        const cond = { type: "spread_above", value: 0.01 };
+        expect(evaluateCondition(cond, snapshot, defaultContext)).toBe(false);
+    });
+});
+// ═══════════════════════════════════════════════════
+// evaluateAllConditions with RSI
+// ═══════════════════════════════════════════════════
+describe("evaluateAllConditions with RSI conditions", () => {
+    it("combines RSI with price condition in 'all' mode", () => {
+        const snapshot = makeSnapshot({ price: 110, rsi: 75 });
+        const conditions = [
+            { type: "price_above", value: 100 },
+            { type: "rsi_above", value: 70 },
+        ];
+        expect(evaluateAllConditions(conditions, snapshot, defaultContext, "all")).toBe(true);
+    });
+    it("fails 'all' mode when RSI condition not met", () => {
+        const snapshot = makeSnapshot({ price: 110, rsi: 65 });
+        const conditions = [
+            { type: "price_above", value: 100 },
+            { type: "rsi_above", value: 70 },
+        ];
+        expect(evaluateAllConditions(conditions, snapshot, defaultContext, "all")).toBe(false);
+    });
+    it("passes 'any' mode when only RSI condition is met", () => {
+        const snapshot = makeSnapshot({ price: 90, rsi: 25 });
+        const conditions = [
+            { type: "price_above", value: 100 },
+            { type: "rsi_below", value: 30 },
+        ];
+        expect(evaluateAllConditions(conditions, snapshot, defaultContext, "any")).toBe(true);
+    });
+    it("combines spread_above with rsi_below for entry signal", () => {
+        // Wide spread + oversold RSI = potential entry
+        const snapshot = makeSnapshot({ spreadPct: 0.5, rsi: 22 });
+        const conditions = [
+            { type: "spread_above", value: 0.3 },
+            { type: "rsi_below", value: 30 },
+        ];
+        expect(evaluateAllConditions(conditions, snapshot, defaultContext, "all")).toBe(true);
+    });
+});
+// ═══════════════════════════════════════════════════
+// Existing conditions still work (regression)
+// ═══════════════════════════════════════════════════
+describe("evaluateCondition — regression for existing conditions", () => {
+    it("always returns true", () => {
+        const cond = { type: "always", value: 0 };
+        expect(evaluateCondition(cond, makeSnapshot(), defaultContext)).toBe(true);
+    });
+    it("price_above works", () => {
+        const snapshot = makeSnapshot({ price: 110 });
+        expect(evaluateCondition({ type: "price_above", value: 100 }, snapshot, defaultContext)).toBe(true);
+        expect(evaluateCondition({ type: "price_above", value: 120 }, snapshot, defaultContext)).toBe(false);
+    });
+    it("price_below works", () => {
+        const snapshot = makeSnapshot({ price: 90 });
+        expect(evaluateCondition({ type: "price_below", value: 100 }, snapshot, defaultContext)).toBe(true);
+        expect(evaluateCondition({ type: "price_below", value: 80 }, snapshot, defaultContext)).toBe(false);
+    });
+    it("volatility_above works", () => {
+        const snapshot = makeSnapshot({ volatility24h: 15 });
+        expect(evaluateCondition({ type: "volatility_above", value: 10 }, snapshot, defaultContext)).toBe(true);
+    });
+    it("funding_rate_above works", () => {
+        const snapshot = makeSnapshot({ fundingRate: 0.001 });
+        expect(evaluateCondition({ type: "funding_rate_above", value: 0.0005 }, snapshot, defaultContext)).toBe(true);
+    });
+    it("balance_above works", () => {
+        const ctx = { ...defaultContext, equity: 15000 };
+        expect(evaluateCondition({ type: "balance_above", value: 10000 }, makeSnapshot(), ctx)).toBe(true);
+    });
+});

package/dist/__tests__/client-id-tracker.test.d.ts

@@ -0,0 +1 @@
+export {};