perp-cli 0.9.8 → 0.12.0

package/dist/__tests__/arb-history-stats.test.d.ts

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

package/dist/__tests__/arb-history-stats.test.js

@@ -1,176 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { computeEnhancedStats, normalizeExchangePair, getTimeBucket, } from "../arb-history-stats.js";
-function makeTrade(overrides = {}) {
-    return {
-        symbol: "ETH",
-        exchanges: "hyperliquid+pacifica",
-        entryDate: "2025-01-15T10:00:00.000Z",
-        exitDate: "2025-01-19T14:00:00.000Z",
-        holdDurationMs: 4 * 24 * 60 * 60 * 1000 + 4 * 60 * 60 * 1000, // 4d 4h
-        entrySpread: 35.0,
-        exitSpread: 8.0,
-        netReturn: 5.20,
-        status: "completed",
-        ...overrides,
-    };
-}
-describe("normalizeExchangePair", () => {
-    it("converts exchange names to abbreviations and sorts", () => {
-        expect(normalizeExchangePair("hyperliquid+pacifica")).toBe("HL/PAC");
-        expect(normalizeExchangePair("pacifica+hyperliquid")).toBe("HL/PAC");
-        expect(normalizeExchangePair("lighter+hyperliquid")).toBe("HL/LT");
-        expect(normalizeExchangePair("lighter+pacifica")).toBe("LT/PAC");
-    });
-    it("handles unknown exchanges with truncation", () => {
-        expect(normalizeExchangePair("binance+coinbase")).toBe("BIN/COI");
-    });
-});
-describe("getTimeBucket", () => {
-    it("returns correct 4-hour UTC buckets", () => {
-        expect(getTimeBucket("2025-01-15T00:00:00.000Z")).toBe("00-04 UTC");
-        expect(getTimeBucket("2025-01-15T03:59:59.000Z")).toBe("00-04 UTC");
-        expect(getTimeBucket("2025-01-15T04:00:00.000Z")).toBe("04-08 UTC");
-        expect(getTimeBucket("2025-01-15T08:30:00.000Z")).toBe("08-12 UTC");
-        expect(getTimeBucket("2025-01-15T12:00:00.000Z")).toBe("12-16 UTC");
-        expect(getTimeBucket("2025-01-15T16:45:00.000Z")).toBe("16-20 UTC");
-        expect(getTimeBucket("2025-01-15T20:00:00.000Z")).toBe("20-24 UTC");
-        expect(getTimeBucket("2025-01-15T23:59:59.000Z")).toBe("20-24 UTC");
-    });
-});
-describe("computeEnhancedStats", () => {
-    it("handles empty history gracefully", () => {
-        const stats = computeEnhancedStats([]);
-        expect(stats.avgEntrySpread).toBe(0);
-        expect(stats.avgExitSpread).toBe(0);
-        expect(stats.avgSpreadDecay).toBe(0);
-        expect(stats.byExchangePair).toEqual([]);
-        expect(stats.byTimeOfDay).toEqual([]);
-        expect(stats.optimalHoldTime).toBeNull();
-        expect(stats.optimalHoldTimeMs).toBeNull();
-    });
-    it("ignores open and failed trades in completed stats", () => {
-        const trades = [
-            makeTrade({ status: "open", netReturn: 0 }),
-            makeTrade({ status: "failed", netReturn: -1 }),
-        ];
-        const stats = computeEnhancedStats(trades);
-        expect(stats.byExchangePair).toEqual([]);
-        expect(stats.byTimeOfDay).toEqual([]);
-    });
-    it("computes average entry/exit spreads correctly", () => {
-        const trades = [
-            makeTrade({ entrySpread: 30, exitSpread: 10 }),
-            makeTrade({ entrySpread: 40, exitSpread: 6 }),
-        ];
-        const stats = computeEnhancedStats(trades);
-        expect(stats.avgEntrySpread).toBe(35);
-        expect(stats.avgExitSpread).toBe(8);
-        expect(stats.avgSpreadDecay).toBe(27); // (20 + 34) / 2
-    });
-    it("handles null spreads in averages", () => {
-        const trades = [
-            makeTrade({ entrySpread: 30, exitSpread: null }),
-            makeTrade({ entrySpread: null, exitSpread: 10 }),
-        ];
-        const stats = computeEnhancedStats(trades);
-        expect(stats.avgEntrySpread).toBe(30);
-        expect(stats.avgExitSpread).toBe(10);
-        expect(stats.avgSpreadDecay).toBe(0); // neither has both
-    });
-    it("groups by exchange pair correctly", () => {
-        const trades = [
-            makeTrade({ exchanges: "hyperliquid+pacifica", netReturn: 10 }),
-            makeTrade({ exchanges: "hyperliquid+pacifica", netReturn: 5 }),
-            makeTrade({ exchanges: "hyperliquid+pacifica", netReturn: -2 }),
-            makeTrade({ exchanges: "lighter+pacifica", netReturn: 8 }),
-            makeTrade({ exchanges: "lighter+pacifica", netReturn: 3 }),
-            makeTrade({ exchanges: "hyperliquid+lighter", netReturn: 1 }),
-        ];
-        const stats = computeEnhancedStats(trades);
-        expect(stats.byExchangePair).toHaveLength(3);
-        // Sorted by trade count descending
-        const hlPac = stats.byExchangePair.find(p => p.pair === "HL/PAC");
-        expect(hlPac).toBeDefined();
-        expect(hlPac.trades).toBe(3);
-        expect(hlPac.winRate).toBeCloseTo(66.67, 0);
-        expect(hlPac.avgNetPnl).toBeCloseTo(4.33, 1);
-        const ltPac = stats.byExchangePair.find(p => p.pair === "LT/PAC");
-        expect(ltPac).toBeDefined();
-        expect(ltPac.trades).toBe(2);
-        expect(ltPac.winRate).toBe(100);
-        expect(ltPac.avgNetPnl).toBe(5.5);
-        const hlLt = stats.byExchangePair.find(p => p.pair === "HL/LT");
-        expect(hlLt).toBeDefined();
-        expect(hlLt.trades).toBe(1);
-    });
-    it("buckets by time of day correctly", () => {
-        const trades = [
-            makeTrade({ entryDate: "2025-01-15T01:00:00.000Z", netReturn: 12 }),
-            makeTrade({ entryDate: "2025-01-16T02:30:00.000Z", netReturn: 8 }),
-            makeTrade({ entryDate: "2025-01-17T03:00:00.000Z", netReturn: 16 }),
-            makeTrade({ entryDate: "2025-01-18T08:15:00.000Z", netReturn: 5 }),
-            makeTrade({ entryDate: "2025-01-19T09:00:00.000Z", netReturn: -3 }),
-            makeTrade({ entryDate: "2025-01-20T16:00:00.000Z", netReturn: -2 }),
-            makeTrade({ entryDate: "2025-01-20T18:30:00.000Z", netReturn: 1 }),
-        ];
-        const stats = computeEnhancedStats(trades);
-        const bucket00 = stats.byTimeOfDay.find(b => b.bucket === "00-04 UTC");
-        expect(bucket00).toBeDefined();
-        expect(bucket00.trades).toBe(3);
-        expect(bucket00.winRate).toBe(100);
-        expect(bucket00.avgNetPnl).toBe(12);
-        const bucket08 = stats.byTimeOfDay.find(b => b.bucket === "08-12 UTC");
-        expect(bucket08).toBeDefined();
-        expect(bucket08.trades).toBe(2);
-        expect(bucket08.winRate).toBe(50);
-        const bucket16 = stats.byTimeOfDay.find(b => b.bucket === "16-20 UTC");
-        expect(bucket16).toBeDefined();
-        expect(bucket16.trades).toBe(2);
-        expect(bucket16.avgNetPnl).toBe(-0.5);
-    });
-    it("computes optimal hold time as median of winning trades", () => {
-        const dayMs = 24 * 60 * 60 * 1000;
-        const trades = [
-            makeTrade({ holdDurationMs: 2 * dayMs, netReturn: 5 }), // win
-            makeTrade({ holdDurationMs: 4 * dayMs, netReturn: 10 }), // win
-            makeTrade({ holdDurationMs: 6 * dayMs, netReturn: 8 }), // win
-            makeTrade({ holdDurationMs: 8 * dayMs, netReturn: -3 }), // loss
-            makeTrade({ holdDurationMs: 10 * dayMs, netReturn: 12 }), // win
-        ];
-        const stats = computeEnhancedStats(trades);
-        // Profitable hold times sorted: 2d, 4d, 6d, 10d
-        // Median of 4 items: (4d + 6d) / 2 = 5d
-        expect(stats.optimalHoldTimeMs).toBe(5 * dayMs);
-        expect(stats.optimalHoldTime).toBe("5d 0h");
-    });
-    it("optimal hold time with odd number of winning trades", () => {
-        const dayMs = 24 * 60 * 60 * 1000;
-        const trades = [
-            makeTrade({ holdDurationMs: 3 * dayMs, netReturn: 2 }),
-            makeTrade({ holdDurationMs: 5 * dayMs, netReturn: 7 }),
-            makeTrade({ holdDurationMs: 7 * dayMs, netReturn: 1 }),
-        ];
-        const stats = computeEnhancedStats(trades);
-        // Median of [3d, 5d, 7d] = 5d
-        expect(stats.optimalHoldTimeMs).toBe(5 * dayMs);
-        expect(stats.optimalHoldTime).toBe("5d 0h");
-    });
-    it("optimal hold time is null when no profitable trades", () => {
-        const trades = [
-            makeTrade({ netReturn: -5 }),
-            makeTrade({ netReturn: -2 }),
-        ];
-        const stats = computeEnhancedStats(trades);
-        expect(stats.optimalHoldTime).toBeNull();
-        expect(stats.optimalHoldTimeMs).toBeNull();
-    });
-    it("skips empty time-of-day buckets", () => {
-        const trades = [
-            makeTrade({ entryDate: "2025-01-15T02:00:00.000Z" }),
-        ];
-        const stats = computeEnhancedStats(trades);
-        // Only the 00-04 bucket should appear
-        expect(stats.byTimeOfDay).toHaveLength(1);
-        expect(stats.byTimeOfDay[0].bucket).toBe("00-04 UTC");
-    });
-});

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

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

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

@@ -1,84 +0,0 @@
-import { describe, it, expect } from "vitest";
-function determinArbDirection(snap) {
-    // Short the high-funding exchange (get paid), long the low-funding one
-    const shortExchange = snap.pacRate > snap.hlRate ? "pacifica" : "hyperliquid";
-    const longExchange = snap.pacRate > snap.hlRate ? "hyperliquid" : "pacifica";
-    return { longExchange, shortExchange };
-}
-function computeAnnualizedSpread(pacRate, hlRate) {
-    return (pacRate - hlRate) * 24 * 365 * 100;
-}
-describe("Arb direction logic", () => {
-    it("shorts high-funding exchange (Pacifica higher)", () => {
-        const snap = { symbol: "BTC", pacRate: 0.001, hlRate: 0.0002, spread: 87.6 };
-        const { longExchange, shortExchange } = determinArbDirection(snap);
-        // Pacifica rate is higher → short Pacifica (get paid funding), long HL
-        expect(shortExchange).toBe("pacifica");
-        expect(longExchange).toBe("hyperliquid");
-    });
-    it("shorts high-funding exchange (Hyperliquid higher)", () => {
-        const snap = { symbol: "ETH", pacRate: 0.0001, hlRate: 0.0008, spread: -76.65 };
-        const { longExchange, shortExchange } = determinArbDirection(snap);
-        // HL rate is higher → short HL, long Pacifica
-        expect(shortExchange).toBe("hyperliquid");
-        expect(longExchange).toBe("pacifica");
-    });
-    it("handles equal rates", () => {
-        const snap = { symbol: "SOL", pacRate: 0.0003, hlRate: 0.0003, spread: 0 };
-        const { longExchange, shortExchange } = determinArbDirection(snap);
-        // Equal rates → default to long pacifica (pacRate > hlRate is false)
-        expect(longExchange).toBe("pacifica");
-        expect(shortExchange).toBe("hyperliquid");
-    });
-    it("handles negative funding rates", () => {
-        const snap = { symbol: "DOGE", pacRate: -0.001, hlRate: -0.0002, spread: -87.6 };
-        const { longExchange, shortExchange } = determinArbDirection(snap);
-        // Pacifica rate is MORE negative → hlRate > pacRate → short HL, long Pacifica
-        expect(shortExchange).toBe("hyperliquid");
-        expect(longExchange).toBe("pacifica");
-    });
-    it("handles mixed sign funding rates", () => {
-        const snap = { symbol: "ARB", pacRate: 0.001, hlRate: -0.0005, spread: 164.25 };
-        const { longExchange, shortExchange } = determinArbDirection(snap);
-        // Pac is positive (longs pay), HL is negative (shorts pay)
-        // Short Pac (get paid) + Long HL (get paid) = double collect!
-        expect(shortExchange).toBe("pacifica");
-        expect(longExchange).toBe("hyperliquid");
-    });
-});
-describe("Spread calculation", () => {
-    it("computes annualized spread correctly", () => {
-        // 0.01% per hour difference → 0.24% per day → 87.6% per year
-        const spread = computeAnnualizedSpread(0.0002, 0.0001);
-        expect(spread).toBeCloseTo(87.6, 1);
-    });
-    it("negative spread when HL rate is higher", () => {
-        const spread = computeAnnualizedSpread(0.0001, 0.0003);
-        expect(spread).toBeLessThan(0);
-        expect(Math.abs(spread)).toBeCloseTo(175.2, 1);
-    });
-    it("zero spread when rates are equal", () => {
-        const spread = computeAnnualizedSpread(0.0001, 0.0001);
-        expect(spread).toBe(0);
-    });
-});
-describe("Entry/exit conditions", () => {
-    const minSpread = 30; // 30% annual
-    const closeSpread = 5; // 5% annual
-    it("should enter when spread exceeds threshold", () => {
-        const absSpread = 45; // 45% > 30%
-        expect(absSpread >= minSpread).toBe(true);
-    });
-    it("should NOT enter when spread below threshold", () => {
-        const absSpread = 20; // 20% < 30%
-        expect(absSpread >= minSpread).toBe(false);
-    });
-    it("should close when spread drops below close threshold", () => {
-        const currentSpread = 3; // 3% < 5%
-        expect(currentSpread <= closeSpread).toBe(true);
-    });
-    it("should NOT close when spread is still profitable", () => {
-        const currentSpread = 15; // 15% > 5%
-        expect(currentSpread <= closeSpread).toBe(false);
-    });
-});

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

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

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

@@ -1,253 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { existsSync, unlinkSync, readFileSync, writeFileSync, renameSync } from "fs";
-import { resolve } from "path";
-import { logExecution, readExecutionLog } from "../execution-log.js";
-const PERP_DIR = resolve(process.env.HOME || "~", ".perp");
-const LOG_FILE = resolve(PERP_DIR, "executions.jsonl");
-const BACKUP_FILE = resolve(PERP_DIR, "executions.jsonl.arb-manage-backup");
-function detectArbPairs(positions) {
-    const bySymbol = new Map();
-    for (const p of positions) {
-        const key = p.symbol.toUpperCase();
-        if (!bySymbol.has(key))
-            bySymbol.set(key, []);
-        bySymbol.get(key).push(p);
-    }
-    const pairs = [];
-    for (const [symbol, pos] of bySymbol) {
-        const longs = pos.filter(p => p.side === "long");
-        const shorts = pos.filter(p => p.side === "short");
-        for (const l of longs) {
-            for (const s of shorts) {
-                if (l.exchange !== s.exchange) {
-                    pairs.push({ symbol, longExchange: l.exchange, shortExchange: s.exchange, longPos: l, shortPos: s });
-                }
-            }
-        }
-    }
-    return pairs;
-}
-// ── Tests ──
-describe("Arb pair detection", () => {
-    it("matches positions on different exchanges with opposite sides", () => {
-        const positions = [
-            { exchange: "hyperliquid", symbol: "BTC", side: "long", size: 0.1, entryPrice: 100000, markPrice: 101000, unrealizedPnl: 100 },
-            { exchange: "lighter", symbol: "BTC", side: "short", size: 0.1, entryPrice: 100500, markPrice: 101000, unrealizedPnl: -50 },
-        ];
-        const pairs = detectArbPairs(positions);
-        expect(pairs).toHaveLength(1);
-        expect(pairs[0].symbol).toBe("BTC");
-        expect(pairs[0].longExchange).toBe("hyperliquid");
-        expect(pairs[0].shortExchange).toBe("lighter");
-    });
-    it("does not match positions on the same exchange", () => {
-        const positions = [
-            { exchange: "hyperliquid", symbol: "ETH", side: "long", size: 1, entryPrice: 3000, markPrice: 3100, unrealizedPnl: 100 },
-            { exchange: "hyperliquid", symbol: "ETH", side: "short", size: 1, entryPrice: 3050, markPrice: 3100, unrealizedPnl: -50 },
-        ];
-        const pairs = detectArbPairs(positions);
-        expect(pairs).toHaveLength(0);
-    });
-    it("does not match positions with same side", () => {
-        const positions = [
-            { exchange: "hyperliquid", symbol: "SOL", side: "long", size: 10, entryPrice: 150, markPrice: 155, unrealizedPnl: 50 },
-            { exchange: "lighter", symbol: "SOL", side: "long", size: 10, entryPrice: 151, markPrice: 155, unrealizedPnl: 40 },
-        ];
-        const pairs = detectArbPairs(positions);
-        expect(pairs).toHaveLength(0);
-    });
-    it("returns empty for no positions", () => {
-        const pairs = detectArbPairs([]);
-        expect(pairs).toHaveLength(0);
-    });
-    it("matches multiple arb pairs for different symbols", () => {
-        const positions = [
-            { exchange: "hyperliquid", symbol: "BTC", side: "long", size: 0.1, entryPrice: 100000, markPrice: 101000, unrealizedPnl: 100 },
-            { exchange: "lighter", symbol: "BTC", side: "short", size: 0.1, entryPrice: 100500, markPrice: 101000, unrealizedPnl: -50 },
-            { exchange: "pacifica", symbol: "ETH", side: "long", size: 1, entryPrice: 3000, markPrice: 3100, unrealizedPnl: 100 },
-            { exchange: "hyperliquid", symbol: "ETH", side: "short", size: 1, entryPrice: 3050, markPrice: 3100, unrealizedPnl: -50 },
-        ];
-        const pairs = detectArbPairs(positions);
-        expect(pairs).toHaveLength(2);
-        const symbols = pairs.map(p => p.symbol).sort();
-        expect(symbols).toEqual(["BTC", "ETH"]);
-    });
-    it("handles case-insensitive symbol matching", () => {
-        const positions = [
-            { exchange: "hyperliquid", symbol: "btc", side: "long", size: 0.1, entryPrice: 100000, markPrice: 101000, unrealizedPnl: 100 },
-            { exchange: "lighter", symbol: "BTC", side: "short", size: 0.1, entryPrice: 100500, markPrice: 101000, unrealizedPnl: -50 },
-        ];
-        const pairs = detectArbPairs(positions);
-        expect(pairs).toHaveLength(1);
-    });
-});
-describe("Arb close dry-run", () => {
-    it("dry-run flag prevents execution", () => {
-        // Simulating dry-run behavior: the flag should be passed through
-        const dryRun = true;
-        const executed = [];
-        // In dry-run mode, no orders should be placed
-        if (!dryRun) {
-            executed.push("sell");
-            executed.push("buy");
-        }
-        expect(executed).toHaveLength(0);
-    });
-    it("produces correct actions for close", () => {
-        const longPos = { exchange: "hyperliquid", symbol: "BTC", rawSymbol: "BTC", side: "long", size: 0.1 };
-        const shortPos = { exchange: "lighter", symbol: "BTC", rawSymbol: "BTC-PERP", side: "short", size: 0.1 };
-        const actions = [
-            { exchange: longPos.exchange, action: "sell", symbol: longPos.rawSymbol, size: String(longPos.size) },
-            { exchange: shortPos.exchange, action: "buy", symbol: shortPos.rawSymbol, size: String(shortPos.size) },
-        ];
-        expect(actions).toHaveLength(2);
-        expect(actions[0].action).toBe("sell"); // close long = sell
-        expect(actions[1].action).toBe("buy"); // close short = buy
-        expect(actions[0].exchange).toBe("hyperliquid");
-        expect(actions[1].exchange).toBe("lighter");
-    });
-});
-describe("Arb history grouping and stats", () => {
-    beforeEach(() => {
-        if (existsSync(LOG_FILE)) {
-            const content = readFileSync(LOG_FILE, "utf-8");
-            writeFileSync(BACKUP_FILE, content);
-        }
-        if (existsSync(LOG_FILE))
-            unlinkSync(LOG_FILE);
-    });
-    afterEach(() => {
-        if (existsSync(LOG_FILE))
-            unlinkSync(LOG_FILE);
-        if (existsSync(BACKUP_FILE)) {
-            renameSync(BACKUP_FILE, LOG_FILE);
-        }
-    });
-    it("groups arb entries and closes by symbol", () => {
-        logExecution({
-            type: "arb_entry", exchange: "hyperliquid+lighter",
-            symbol: "BTC", side: "entry", size: "0.1",
-            status: "success", dryRun: false,
-            meta: { longExchange: "hyperliquid", shortExchange: "lighter", spread: 35, markPrice: 100000 },
-        });
-        logExecution({
-            type: "arb_close", exchange: "hyperliquid+lighter",
-            symbol: "BTC", side: "close", size: "0.1",
-            status: "success", dryRun: false,
-            meta: { longExchange: "hyperliquid", shortExchange: "lighter", currentSpread: 3, unrealizedPnl: 5.5, netPnl: 4.2 },
-        });
-        const entries = readExecutionLog({ type: "arb_entry" });
-        const closes = readExecutionLog({ type: "arb_close" });
-        expect(entries).toHaveLength(1);
-        expect(closes).toHaveLength(1);
-        expect(entries[0].symbol).toBe("BTC");
-        expect(closes[0].symbol).toBe("BTC");
-        expect(entries[0].meta?.spread).toBe(35);
-        expect(closes[0].meta?.netPnl).toBe(4.2);
-    });
-    it("calculates trade stats from multiple entries", () => {
-        // Trade 1: winner
-        logExecution({
-            type: "arb_entry", exchange: "hyperliquid+lighter",
-            symbol: "BTC", side: "entry", size: "0.1",
-            status: "success", dryRun: false,
-            meta: { spread: 40, markPrice: 100000 },
-        });
-        logExecution({
-            type: "arb_close", exchange: "hyperliquid+lighter",
-            symbol: "BTC", side: "close", size: "0.1",
-            status: "success", dryRun: false,
-            meta: { unrealizedPnl: 10, netPnl: 8 },
-        });
-        // Trade 2: loser
-        logExecution({
-            type: "arb_entry", exchange: "pacifica+hyperliquid",
-            symbol: "ETH", side: "entry", size: "1.0",
-            status: "success", dryRun: false,
-            meta: { spread: 25, markPrice: 3000 },
-        });
-        logExecution({
-            type: "arb_close", exchange: "pacifica+hyperliquid",
-            symbol: "ETH", side: "close", size: "1.0",
-            status: "success", dryRun: false,
-            meta: { unrealizedPnl: -5, netPnl: -7 },
-        });
-        const allEntries = readExecutionLog()
-            .filter(r => r.type === "arb_entry" || r.type === "arb_close");
-        const entries = allEntries.filter(r => r.type === "arb_entry");
-        const closes = allEntries.filter(r => r.type === "arb_close");
-        expect(entries).toHaveLength(2);
-        expect(closes).toHaveLength(2);
-        // Verify we can compute stats
-        const completedNetPnls = closes
-            .filter(c => c.status === "success" && c.meta?.netPnl !== undefined)
-            .map(c => Number(c.meta.netPnl));
-        expect(completedNetPnls).toHaveLength(2);
-        const totalNetPnl = completedNetPnls.reduce((s, n) => s + n, 0);
-        expect(totalNetPnl).toBe(1); // 8 + (-7) = 1
-        const winners = completedNetPnls.filter(n => n > 0);
-        expect(winners).toHaveLength(1);
-        const winRate = (winners.length / completedNetPnls.length) * 100;
-        expect(winRate).toBe(50);
-    });
-    it("handles entries without matching closes (open trades)", () => {
-        logExecution({
-            type: "arb_entry", exchange: "hyperliquid+lighter",
-            symbol: "SOL", side: "entry", size: "10",
-            status: "success", dryRun: false,
-            meta: { spread: 30, markPrice: 150 },
-        });
-        const entries = readExecutionLog({ type: "arb_entry" });
-        const closes = readExecutionLog({ type: "arb_close" });
-        expect(entries).toHaveLength(1);
-        expect(closes).toHaveLength(0);
-        // Should be treated as an open trade
-        const symbol = entries[0].symbol;
-        const matchingClose = closes.find(c => c.symbol === symbol);
-        expect(matchingClose).toBeUndefined();
-    });
-    it("filters by period correctly", () => {
-        // Log an entry with a very old timestamp manually
-        const oldDate = new Date(Date.now() - 60 * 24 * 60 * 60 * 1000).toISOString();
-        const recentDate = new Date().toISOString();
-        logExecution({
-            type: "arb_entry", exchange: "hyperliquid+lighter",
-            symbol: "OLD_TRADE", side: "entry", size: "0.1",
-            status: "success", dryRun: false,
-        });
-        logExecution({
-            type: "arb_entry", exchange: "hyperliquid+lighter",
-            symbol: "NEW_TRADE", side: "entry", size: "0.1",
-            status: "success", dryRun: false,
-        });
-        // Read with 30-day filter: both are recent (logged just now), so both should appear
-        const since30d = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
-        const recent = readExecutionLog({ type: "arb_entry", since: since30d });
-        expect(recent).toHaveLength(2);
-    });
-});
-describe("Duration formatting", () => {
-    function formatDuration(ms) {
-        const hours = Math.floor(ms / (1000 * 60 * 60));
-        const days = Math.floor(hours / 24);
-        const remainingHours = hours % 24;
-        if (days > 0)
-            return `${days}d ${remainingHours}h`;
-        if (hours > 0)
-            return `${hours}h`;
-        const minutes = Math.floor(ms / (1000 * 60));
-        return `${minutes}m`;
-    }
-    it("formats minutes", () => {
-        expect(formatDuration(30 * 60 * 1000)).toBe("30m");
-    });
-    it("formats hours", () => {
-        expect(formatDuration(5 * 60 * 60 * 1000)).toBe("5h");
-    });
-    it("formats days and hours", () => {
-        expect(formatDuration(26 * 60 * 60 * 1000)).toBe("1d 2h");
-    });
-    it("formats zero", () => {
-        expect(formatDuration(0)).toBe("0m");
-    });
-});

package/dist/__tests__/arb-new-features.test.d.ts

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