perp-cli 0.3.3

package/dist/__tests__/arb-auto-3dex.test.js

@@ -0,0 +1,397 @@
+import { describe, it, expect } from "vitest";
+import { computeNetSpread, computeRoundTripCostPct, getNextSettlement, isNearSettlement, isSpreadReversed, } from "../commands/arb-auto.js";
+/**
+ * Mirrors the direction logic in arb-auto.ts:
+ * Sort all available exchange rates by hourly-normalized rate.
+ * Long on the lowest-rate exchange, short on the highest.
+ */
+function determine3DexDirection(snap) {
+    return {
+        longExchange: snap.longExch,
+        shortExchange: snap.shortExch,
+    };
+}
+/**
+ * Mirrors the funding accumulation logic in arb-auto:
+ * Estimate funding collected based on rate differential and elapsed time.
+ */
+function accumulateFunding(pos, current, nowMs) {
+    const elapsedHours = (nowMs - pos.lastCheckTime) / (1000 * 60 * 60);
+    const notional = parseFloat(pos.size) * current.markPrice;
+    const rateFor = (e) => e === "pacifica" ? current.pacRate : e === "hyperliquid" ? current.hlRate : current.ltRate;
+    const longHourly = rateFor(pos.longExchange) / 1; // all exchanges are hourly
+    const shortHourly = rateFor(pos.shortExchange) / 1; // all exchanges are hourly
+    const hourlyIncome = (shortHourly - longHourly) * notional;
+    return hourlyIncome * elapsedHours;
+}
+// ──────────────────────────────────────────────
+// 3-DEX direction
+// ──────────────────────────────────────────────
+describe("3-DEX direction determination", () => {
+    it("uses longExch/shortExch from snapshot (all 3 available)", () => {
+        const snap = {
+            symbol: "BTC",
+            pacRate: 0.0006, // pac = 0.0006/hr
+            hlRate: 0.0003, // hl = 0.0003/hr
+            ltRate: 0.0002, // lt = 0.0002/hr (lowest!)
+            spread: 240.9,
+            longExch: "lighter",
+            shortExch: "pacifica",
+            markPrice: 60000,
+            pacMarkPrice: 0, hlMarkPrice: 0, ltMarkPrice: 0,
+        };
+        const { longExchange, shortExchange } = determine3DexDirection(snap);
+        expect(longExchange).toBe("lighter");
+        expect(shortExchange).toBe("pacifica");
+    });
+    it("handles pac vs hl only (lighter missing)", () => {
+        const snap = {
+            symbol: "ETH",
+            pacRate: 0.002, // pac = 0.002/hr (highest)
+            hlRate: 0.00005, // hl = 0.00005/hr (lowest)
+            ltRate: 0, // no lighter
+            spread: 175.2,
+            longExch: "hyperliquid",
+            shortExch: "pacifica",
+            markPrice: 3000,
+            pacMarkPrice: 0, hlMarkPrice: 0, ltMarkPrice: 0,
+        };
+        const { longExchange, shortExchange } = determine3DexDirection(snap);
+        expect(longExchange).toBe("hyperliquid");
+        expect(shortExchange).toBe("pacifica");
+    });
+    it("handles lighter vs pac when HL missing", () => {
+        const snap = {
+            symbol: "SOL",
+            pacRate: 0.0001,
+            hlRate: 0,
+            ltRate: 0.001,
+            spread: 98.55,
+            longExch: "pacifica",
+            shortExch: "lighter",
+            markPrice: 150,
+            pacMarkPrice: 0, hlMarkPrice: 0, ltMarkPrice: 0,
+        };
+        const { longExchange, shortExchange } = determine3DexDirection(snap);
+        expect(longExchange).toBe("pacifica");
+        expect(shortExchange).toBe("lighter");
+    });
+});
+// ──────────────────────────────────────────────
+// Funding accumulation
+// ──────────────────────────────────────────────
+describe("Funding accumulation tracking", () => {
+    const baseTime = Date.now();
+    it("accumulates positive income when spread is favorable", () => {
+        const pos = {
+            symbol: "BTC",
+            longExchange: "hyperliquid", // low funding
+            shortExchange: "pacifica", // high funding
+            size: "0.1",
+            entrySpread: 50,
+            entryTime: new Date().toISOString(),
+            entryMarkPrice: 60000,
+            accumulatedFundingUsd: 0,
+            lastCheckTime: baseTime,
+        };
+        const snap = {
+            symbol: "BTC",
+            pacRate: 0.000125, // pac = 0.000125/hr (all hourly now)
+            hlRate: 0.00005, // hl = 0.00005/hr
+            ltRate: 0,
+            spread: 65.7,
+            longExch: "hyperliquid",
+            shortExch: "pacifica",
+            markPrice: 60000,
+            pacMarkPrice: 0, hlMarkPrice: 0, ltMarkPrice: 0,
+        };
+        // 1 hour elapsed
+        const income = accumulateFunding(pos, snap, baseTime + 3600_000);
+        // shortHourly = 0.000125
+        // longHourly = 0.00005
+        // diff = 0.000125 - 0.00005 = 0.000075
+        // notional = 0.1 * 60000 = 6000
+        // income = 0.000075 * 6000 * 1 = $0.45/hr
+        expect(income).toBeCloseTo(0.45, 2);
+    });
+    it("returns zero income when no time elapsed", () => {
+        const pos = {
+            symbol: "ETH",
+            longExchange: "lighter",
+            shortExchange: "pacifica",
+            size: "1",
+            entrySpread: 30,
+            entryTime: new Date().toISOString(),
+            entryMarkPrice: 3000,
+            accumulatedFundingUsd: 0,
+            lastCheckTime: baseTime,
+        };
+        const snap = {
+            symbol: "ETH",
+            pacRate: 0.0005, // all hourly now
+            hlRate: 0.0001,
+            ltRate: 0.0001,
+            spread: 43.8,
+            longExch: "lighter",
+            shortExch: "pacifica",
+            markPrice: 3000,
+            pacMarkPrice: 0, hlMarkPrice: 0, ltMarkPrice: 0,
+        };
+        const income = accumulateFunding(pos, snap, baseTime); // same time
+        expect(income).toBe(0);
+    });
+    it("scales with elapsed time", () => {
+        const pos = {
+            symbol: "BTC",
+            longExchange: "hyperliquid",
+            shortExchange: "pacifica",
+            size: "0.1",
+            entrySpread: 50,
+            entryTime: new Date().toISOString(),
+            entryMarkPrice: 60000,
+            accumulatedFundingUsd: 0,
+            lastCheckTime: baseTime,
+        };
+        const snap = {
+            symbol: "BTC",
+            pacRate: 0.000125,
+            hlRate: 0.00005,
+            ltRate: 0,
+            spread: 65.7,
+            longExch: "hyperliquid",
+            shortExch: "pacifica",
+            markPrice: 60000,
+            pacMarkPrice: 0, hlMarkPrice: 0, ltMarkPrice: 0,
+        };
+        const income1h = accumulateFunding(pos, snap, baseTime + 3600_000);
+        const income24h = accumulateFunding(pos, snap, baseTime + 24 * 3600_000);
+        expect(income24h).toBeCloseTo(income1h * 24, 2);
+    });
+    it("can produce negative income if spread reverses", () => {
+        const pos = {
+            symbol: "BTC",
+            longExchange: "pacifica", // originally was low
+            shortExchange: "hyperliquid", // originally was high
+            size: "0.1",
+            entrySpread: 20,
+            entryTime: new Date().toISOString(),
+            entryMarkPrice: 60000,
+            accumulatedFundingUsd: 0,
+            lastCheckTime: baseTime,
+        };
+        // Now PAC rate is HIGHER than HL — bad for our direction
+        const snap = {
+            symbol: "BTC",
+            pacRate: 0.00025, // pac now high: 0.00025/hr
+            hlRate: 0.00001, // hl now low: 0.00001/hr
+            ltRate: 0,
+            spread: 218.3,
+            longExch: "hyperliquid",
+            shortExch: "pacifica",
+            markPrice: 60000,
+            pacMarkPrice: 0, hlMarkPrice: 0, ltMarkPrice: 0,
+        };
+        const income = accumulateFunding(pos, snap, baseTime + 3600_000);
+        // shortHourly (HL) = 0.00001
+        // longHourly (PAC) = 0.00025
+        // diff = 0.00001 - 0.00025 = -0.00024
+        // notional = 6000
+        // income = -0.00024 * 6000 * 1 = -$1.44
+        expect(income).toBeLessThan(0);
+    });
+});
+// ──────────────────────────────────────────────
+// Entry/exit conditions with 3 DEXs
+// ──────────────────────────────────────────────
+describe("3-DEX entry/exit conditions", () => {
+    const minSpread = 30;
+    const closeSpread = 5;
+    it("enters when any 2-exchange spread exceeds threshold", () => {
+        // Only PAC and LT available, but spread is large
+        const absSpread = 45;
+        expect(absSpread >= minSpread).toBe(true);
+    });
+    it("closes when best available spread drops below close threshold", () => {
+        const currentSpread = 3;
+        expect(currentSpread <= closeSpread).toBe(true);
+    });
+    it("does not enter if max positions reached", () => {
+        const maxPositions = 3;
+        const openPositions = 3;
+        expect(openPositions >= maxPositions).toBe(true);
+    });
+    it("skips symbol already in open positions", () => {
+        const openPositions = [{
+                symbol: "BTC",
+                longExchange: "hyperliquid",
+                shortExchange: "pacifica",
+                size: "0.1",
+                entrySpread: 40,
+                entryTime: new Date().toISOString(),
+                entryMarkPrice: 60000,
+                accumulatedFundingUsd: 0.5,
+                lastCheckTime: Date.now(),
+            }];
+        const alreadyOpen = openPositions.some(p => p.symbol === "BTC");
+        expect(alreadyOpen).toBe(true);
+    });
+});
+// ──────────────────────────────────────────────
+// Net spread calculation
+// ──────────────────────────────────────────────
+describe("computeNetSpread", () => {
+    it("correctly deducts annualized round-trip cost from gross spread", () => {
+        // gross=30%, hold=7d, roundTrip=0.14% → net = 30 - (0.14/7*365) = 30 - 7.3 = 22.7
+        const net = computeNetSpread(30, 7, 0.14);
+        expect(net).toBeCloseTo(22.7, 1);
+    });
+    it("returns gross spread when costs are zero", () => {
+        const net = computeNetSpread(50, 7, 0);
+        expect(net).toBe(50);
+    });
+    it("can produce negative net spread when costs exceed gross", () => {
+        // gross=5%, hold=1d, roundTrip=0.14% → net = 5 - (0.14*365) = 5 - 51.1 = -46.1
+        const net = computeNetSpread(5, 1, 0.14);
+        expect(net).toBeLessThan(0);
+    });
+    it("longer hold periods reduce annualized cost impact", () => {
+        const net7d = computeNetSpread(30, 7, 0.14);
+        const net30d = computeNetSpread(30, 30, 0.14);
+        expect(net30d).toBeGreaterThan(net7d);
+    });
+    it("includes bridge cost in net spread calculation", () => {
+        // Without bridge cost
+        const netNoBridge = computeNetSpread(30, 7, 0.14, 0, 100);
+        // With $0.50 bridge cost, $100 position
+        // bridgeRoundTripPct = (0.5 * 2 / 100) * 100 = 1%
+        // bridgeAnnualized = (1/7) * 365 = 52.14%
+        const netWithBridge = computeNetSpread(30, 7, 0.14, 0.5, 100);
+        expect(netWithBridge).toBeLessThan(netNoBridge);
+        // Difference should be the annualized bridge cost
+        const bridgeDiff = netNoBridge - netWithBridge;
+        expect(bridgeDiff).toBeCloseTo(52.14, 0);
+    });
+    it("bridge cost impact scales inversely with position size", () => {
+        const netSmall = computeNetSpread(30, 7, 0.14, 0.5, 50); // $50 position
+        const netLarge = computeNetSpread(30, 7, 0.14, 0.5, 500); // $500 position
+        // Larger positions dilute bridge cost
+        expect(netLarge).toBeGreaterThan(netSmall);
+    });
+});
+describe("computeRoundTripCostPct", () => {
+    it("computes round-trip cost for same-fee exchanges", () => {
+        // 2 × (0.035% + 0.035%) + 2 × 0.05% = 0.24%
+        const cost = computeRoundTripCostPct("hyperliquid", "pacifica", 0.05);
+        expect(cost).toBeCloseTo(0.24, 4);
+    });
+    it("uses default slippage of 0.05%", () => {
+        const cost = computeRoundTripCostPct("hyperliquid", "lighter");
+        // 2 × (0.035% + 0.035%) + 2 × 0.05% = 0.24%
+        expect(cost).toBeCloseTo(0.24, 4);
+    });
+    it("handles custom slippage", () => {
+        const cost = computeRoundTripCostPct("hyperliquid", "pacifica", 0.1);
+        // 2 × (0.035% + 0.035%) + 2 × 0.1% = 0.34%
+        expect(cost).toBeCloseTo(0.34, 4);
+    });
+});
+// ──────────────────────────────────────────────
+// Spread reversal detection
+// ──────────────────────────────────────────────
+describe("Spread reversal detection", () => {
+    it("detects reversal when long exchange rate exceeds short", () => {
+        const snap = {
+            symbol: "BTC",
+            pacRate: 0.0001, // PAC low (was short, now low)
+            hlRate: 0.0005, // HL high (was long, now high)
+            ltRate: 0,
+            spread: 30,
+            longExch: "pacifica",
+            shortExch: "hyperliquid",
+            markPrice: 60000,
+            pacMarkPrice: 0, hlMarkPrice: 0, ltMarkPrice: 0,
+        };
+        // Position: long HL, short PAC — but now HL hourly (0.0005) > PAC hourly (0.0001)
+        const reversed = isSpreadReversed("hyperliquid", "pacifica", snap);
+        expect(reversed).toBe(true);
+    });
+    it("does not flag reversal when spread is still favorable", () => {
+        const snap = {
+            symbol: "BTC",
+            pacRate: 0.001, // PAC high (0.001/hr)
+            hlRate: 0.00005, // HL low (0.00005/hr)
+            ltRate: 0,
+            spread: 65.7,
+            longExch: "hyperliquid",
+            shortExch: "pacifica",
+            markPrice: 60000,
+            pacMarkPrice: 0, hlMarkPrice: 0, ltMarkPrice: 0,
+        };
+        // Position: long HL, short PAC — HL hourly (0.00005) < PAC hourly (0.001) → no reversal
+        const reversed = isSpreadReversed("hyperliquid", "pacifica", snap);
+        expect(reversed).toBe(false);
+    });
+    it("handles lighter vs pacifica reversal", () => {
+        const snap = {
+            symbol: "SOL",
+            pacRate: 0.0001, // PAC hourly = 0.0001
+            hlRate: 0,
+            ltRate: 0.0016, // LT 8h rate, hourly = 0.0016/8 = 0.0002
+            spread: 10,
+            longExch: "pacifica",
+            shortExch: "lighter",
+            markPrice: 150,
+            pacMarkPrice: 0, hlMarkPrice: 0, ltMarkPrice: 0,
+        };
+        // Position: long LT, short PAC — LT hourly (0.0002) > PAC hourly (0.0001) → reversed
+        const reversed = isSpreadReversed("lighter", "pacifica", snap);
+        expect(reversed).toBe(true);
+    });
+});
+// ──────────────────────────────────────────────
+// Settlement timing awareness
+// ──────────────────────────────────────────────
+describe("Settlement timing awareness", () => {
+    it("getNextSettlement returns next hour for HL", () => {
+        // At 14:30 UTC, next HL settlement is at 15:00 UTC
+        const now = new Date("2025-01-15T14:30:00Z");
+        const next = getNextSettlement("hyperliquid", now);
+        expect(next.getUTCHours()).toBe(15);
+        expect(next.getUTCMinutes()).toBe(0);
+    });
+    it("getNextSettlement returns next hour for PAC (hourly like HL)", () => {
+        // At 06:00 UTC, next PAC settlement is at 07:00 UTC
+        const now = new Date("2025-01-15T06:30:00Z");
+        const next = getNextSettlement("pacifica", now);
+        expect(next.getUTCHours()).toBe(7);
+    });
+    it("getNextSettlement wraps to next day for PAC when at 23:xx", () => {
+        // At 23:30 UTC, next PAC settlement is at 00:00 next day
+        const now = new Date("2025-01-15T23:30:00Z");
+        const next = getNextSettlement("pacifica", now);
+        expect(next.getUTCHours()).toBe(0);
+        expect(next.getUTCDate()).toBe(16);
+    });
+    it("isNearSettlement blocks entry within 5 minutes of settlement", () => {
+        // 3 minutes before 08:00 UTC settlement — all exchanges settle hourly now
+        const now = new Date("2025-01-15T07:57:00Z");
+        const result = isNearSettlement("lighter", "pacifica", 5, now);
+        expect(result.blocked).toBe(true);
+        // Both lighter and pacifica settle at 08:00, lighter checked first
+        expect(result.exchange).toBe("lighter");
+        expect(result.minutesUntil).toBeLessThanOrEqual(5);
+    });
+    it("isNearSettlement allows entry far from settlement", () => {
+        // 30 minutes past the hour — next settlement is 30 min away
+        const now = new Date("2025-01-15T15:30:00Z");
+        const result = isNearSettlement("lighter", "pacifica", 5, now);
+        expect(result.blocked).toBe(false);
+    });
+    it("isNearSettlement checks both exchanges", () => {
+        // 2 minutes before hourly HL settlement
+        const now = new Date("2025-01-15T14:58:00Z");
+        const result = isNearSettlement("hyperliquid", "pacifica", 5, now);
+        expect(result.blocked).toBe(true);
+        expect(result.exchange).toBe("hyperliquid");
+    });
+});

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

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

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

@@ -0,0 +1,176 @@
+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

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

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

@@ -0,0 +1,84 @@
+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

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