perp-cli 0.3.3

package/dist/__tests__/arb-new-features.test.js

@@ -0,0 +1,457 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { existsSync, unlinkSync, mkdirSync } from "fs";
+import { resolve } from "path";
+// ── Imports from actual source files ──
+import { formatNotifyMessage, notifyIfEnabled, } from "../arb-utils.js";
+import { loadArbState, saveArbState, createInitialState, setStateFilePath, resetStateFilePath, } from "../arb-state.js";
+import { computeNetSpread, computeRoundTripCostPct, isNearSettlement, isSpreadReversed, getNextSettlement, } from "../commands/arb-auto.js";
+// ══════════════════════════════════════════════════════════════════════════════
+// 1. Promise.allSettled rollback logic (mock-based)
+// ══════════════════════════════════════════════════════════════════════════════
+describe("Promise.allSettled rollback logic", () => {
+    /**
+     * Re-implements the decision logic from arb-auto.ts daemon cycle:
+     * After calling Promise.allSettled on [longOrder, shortOrder], determine
+     * what action to take based on the settlement results.
+     */
+    function evaluateDualLegResult(longResult, shortResult) {
+        const longOk = longResult.status === "fulfilled";
+        const shortOk = shortResult.status === "fulfilled";
+        if (longOk && shortOk) {
+            return { action: "success" };
+        }
+        else if (longOk !== shortOk) {
+            const filledSide = longOk ? "long" : "short";
+            const failedSide = longOk ? "short" : "long";
+            return { action: "rollback", filledSide, failedSide };
+        }
+        else {
+            return { action: "both_failed" };
+        }
+    }
+    it("both fulfilled -> indicates success", () => {
+        const longResult = { status: "fulfilled", value: "order-123" };
+        const shortResult = { status: "fulfilled", value: "order-456" };
+        const result = evaluateDualLegResult(longResult, shortResult);
+        expect(result.action).toBe("success");
+        expect(result.filledSide).toBeUndefined();
+        expect(result.failedSide).toBeUndefined();
+    });
+    it("long fulfilled, short rejected -> should attempt rollback of long", () => {
+        const longResult = { status: "fulfilled", value: "order-123" };
+        const shortResult = { status: "rejected", reason: new Error("insufficient margin") };
+        const result = evaluateDualLegResult(longResult, shortResult);
+        expect(result.action).toBe("rollback");
+        expect(result.filledSide).toBe("long");
+        expect(result.failedSide).toBe("short");
+    });
+    it("short fulfilled, long rejected -> should attempt rollback of short", () => {
+        const longResult = { status: "rejected", reason: new Error("timeout") };
+        const shortResult = { status: "fulfilled", value: "order-789" };
+        const result = evaluateDualLegResult(longResult, shortResult);
+        expect(result.action).toBe("rollback");
+        expect(result.filledSide).toBe("short");
+        expect(result.failedSide).toBe("long");
+    });
+    it("both rejected -> indicates both failed, no rollback needed", () => {
+        const longResult = { status: "rejected", reason: new Error("exchange down") };
+        const shortResult = { status: "rejected", reason: new Error("rate limited") };
+        const result = evaluateDualLegResult(longResult, shortResult);
+        expect(result.action).toBe("both_failed");
+        expect(result.filledSide).toBeUndefined();
+        expect(result.failedSide).toBeUndefined();
+    });
+    it("rollback action determines correct reverse order direction", () => {
+        // In arb-auto.ts: rollbackAction = longOk ? "sell" : "buy"
+        const longOk = true;
+        const shortOk = false;
+        const rollbackAction = longOk ? "sell" : "buy";
+        expect(rollbackAction).toBe("sell"); // reverse the long (buy) with a sell
+    });
+});
+// ══════════════════════════════════════════════════════════════════════════════
+// 2. --min-size threshold
+// ══════════════════════════════════════════════════════════════════════════════
+describe("--min-size threshold", () => {
+    /**
+     * Re-implements the min-size gate from arb-auto.ts:
+     * if (sizeIsAuto && actualSizeUsd < minSizeUsd) { continue; }
+     */
+    function shouldSkipForMinSize(sizeIsAuto, actualSizeUsd, minSizeUsd) {
+        if (sizeIsAuto && actualSizeUsd < minSizeUsd)
+            return true;
+        return false;
+    }
+    it("auto-size $25 with min-size $30 -> should skip (below floor)", () => {
+        expect(shouldSkipForMinSize(true, 25, 30)).toBe(true);
+    });
+    it("auto-size $50 with min-size $30 -> should proceed", () => {
+        expect(shouldSkipForMinSize(true, 50, 30)).toBe(false);
+    });
+    it("auto-size $30 with min-size $30 -> should proceed (exact boundary)", () => {
+        expect(shouldSkipForMinSize(true, 30, 30)).toBe(false);
+    });
+    it("non-auto mode ignores min-size even when size is below threshold", () => {
+        // When sizeIsAuto is false (fixed size mode), min-size check is skipped
+        expect(shouldSkipForMinSize(false, 25, 30)).toBe(false);
+        expect(shouldSkipForMinSize(false, 10, 30)).toBe(false);
+    });
+    it("auto-size $0 with any min-size -> should skip", () => {
+        expect(shouldSkipForMinSize(true, 0, 30)).toBe(true);
+    });
+});
+// ══════════════════════════════════════════════════════════════════════════════
+// 3. Heartbeat notification
+// ══════════════════════════════════════════════════════════════════════════════
+describe("Heartbeat notification", () => {
+    it("formatNotifyMessage('heartbeat') returns proper message with minutes and last scan time", () => {
+        const msg = formatNotifyMessage("heartbeat", {
+            lastScanTime: "2025-01-15T10:30:00.000Z",
+            minutesAgo: 12,
+        });
+        expect(msg).toContain("HEARTBEAT");
+        expect(msg).toContain("12");
+        expect(msg).toContain("2025-01-15T10:30:00.000Z");
+    });
+    it("heartbeat message includes 'minutes' wording", () => {
+        const msg = formatNotifyMessage("heartbeat", {
+            lastScanTime: "2025-01-15T08:00:00.000Z",
+            minutesAgo: 7,
+        });
+        expect(msg).toContain("minutes");
+        expect(msg).toContain("7");
+    });
+    it("notifyIfEnabled with 'heartbeat' in events -> sends notification", async () => {
+        const mockFetch = vi.fn().mockResolvedValue({ ok: true });
+        const events = ["entry", "exit", "heartbeat"];
+        await notifyIfEnabled("https://discord.com/api/webhooks/123/abc", events, "heartbeat", { lastScanTime: "2025-01-15T10:00:00Z", minutesAgo: 10 }, mockFetch);
+        expect(mockFetch).toHaveBeenCalledOnce();
+        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+        expect(body.content).toContain("HEARTBEAT");
+    });
+    it("notifyIfEnabled with 'heartbeat' NOT in events -> does not send", async () => {
+        const mockFetch = vi.fn().mockResolvedValue({ ok: true });
+        const events = ["entry", "exit", "reversal"];
+        await notifyIfEnabled("https://discord.com/api/webhooks/123/abc", events, "heartbeat", { lastScanTime: "2025-01-15T10:00:00Z", minutesAgo: 10 }, mockFetch);
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+    it("notifyIfEnabled with empty events list -> sends (empty = all events)", async () => {
+        const mockFetch = vi.fn().mockResolvedValue({ ok: true });
+        // Empty events list means "all events enabled"
+        await notifyIfEnabled("https://discord.com/api/webhooks/123/abc", [], "heartbeat", { lastScanTime: "2025-01-15T10:00:00Z", minutesAgo: 5 }, mockFetch);
+        expect(mockFetch).toHaveBeenCalledOnce();
+    });
+});
+// ══════════════════════════════════════════════════════════════════════════════
+// 4. Exit reason tagging
+// ══════════════════════════════════════════════════════════════════════════════
+describe("Exit reason tagging", () => {
+    /**
+     * Re-implements the exit reason derivation from arb-auto.ts:
+     * const exitReason = closeReason.includes("REVERSAL") ? "reversal"
+     *   : closeReason.includes("spread") ? "spread"
+     *   : "manual";
+     */
+    function deriveExitReason(closeReason) {
+        if (closeReason.includes("REVERSAL"))
+            return "reversal";
+        if (closeReason.includes("spread"))
+            return "spread";
+        return "manual";
+    }
+    it("closeReason containing 'REVERSAL' -> exitReason = 'reversal'", () => {
+        const reason = "REVERSAL DETECTED — long exchange now has higher rate than short";
+        expect(deriveExitReason(reason)).toBe("reversal");
+    });
+    it("closeReason containing 'spread' -> exitReason = 'spread'", () => {
+        const reason = "spread 3.2% <= 5%";
+        expect(deriveExitReason(reason)).toBe("spread");
+    });
+    it("manual close -> exitReason = 'manual'", () => {
+        const reason = "user requested close";
+        expect(deriveExitReason(reason)).toBe("manual");
+    });
+    it("empty closeReason -> exitReason = 'manual'", () => {
+        expect(deriveExitReason("")).toBe("manual");
+    });
+    it("exitReason appears in execution log meta structure", () => {
+        // Verify the expected shape of an arb_close execution record with exitReason
+        const record = {
+            type: "arb_close",
+            exchange: "hyperliquid+pacifica",
+            symbol: "ETH",
+            side: "close",
+            size: "0.5000",
+            status: "success",
+            dryRun: false,
+            meta: {
+                longExchange: "hyperliquid",
+                shortExchange: "pacifica",
+                currentSpread: 3.2,
+                reason: "spread 3.2% <= 5%",
+                exitReason: "spread",
+            },
+        };
+        expect(record.meta).toBeDefined();
+        expect(record.meta.exitReason).toBe("spread");
+    });
+    it("REVERSAL in closeReason takes priority over 'spread' substring", () => {
+        // If somehow both words appear, REVERSAL check is first
+        const reason = "REVERSAL — spread has flipped";
+        expect(deriveExitReason(reason)).toBe("reversal");
+    });
+});
+// ══════════════════════════════════════════════════════════════════════════════
+// 5. Funding reconciliation
+// ══════════════════════════════════════════════════════════════════════════════
+describe("Funding reconciliation", () => {
+    /**
+     * Re-implements the diff logic from arb-auto.ts arb status command:
+     * const fundingDiff = totalActualFunding - totalEstFunding;
+     * const diffPct = totalEstFunding !== 0
+     *   ? ((fundingDiff / Math.abs(totalEstFunding)) * 100).toFixed(1)
+     *   : "N/A";
+     */
+    function computeFundingReconciliation(estimated, actual) {
+        const diff = actual - estimated;
+        const diffPct = estimated !== 0
+            ? ((diff / Math.abs(estimated)) * 100).toFixed(1)
+            : "N/A";
+        return { diff, diffPct };
+    }
+    it("computes positive diff when actual > estimated", () => {
+        const result = computeFundingReconciliation(10, 12);
+        expect(result.diff).toBe(2);
+        expect(result.diffPct).toBe("20.0");
+    });
+    it("computes negative diff when actual < estimated", () => {
+        const result = computeFundingReconciliation(10, 8);
+        expect(result.diff).toBe(-2);
+        expect(result.diffPct).toBe("-20.0");
+    });
+    it("zero diff when actual = estimated", () => {
+        const result = computeFundingReconciliation(5, 5);
+        expect(result.diff).toBe(0);
+        expect(result.diffPct).toBe("0.0");
+    });
+    it("handles when estimated = 0 (returns N/A for percentage)", () => {
+        const result = computeFundingReconciliation(0, 3.5);
+        expect(result.diff).toBe(3.5);
+        expect(result.diffPct).toBe("N/A");
+    });
+    it("handles when actual = 0 (no settled funding yet)", () => {
+        const result = computeFundingReconciliation(5, 0);
+        expect(result.diff).toBe(-5);
+        expect(result.diffPct).toBe("-100.0");
+    });
+    it("handles negative estimated funding", () => {
+        const result = computeFundingReconciliation(-10, -12);
+        expect(result.diff).toBe(-2);
+        // diff / |estimated| = -2/10 = -20%
+        expect(result.diffPct).toBe("-20.0");
+    });
+});
+// ══════════════════════════════════════════════════════════════════════════════
+// 6. ArbDaemonState with lastSuccessfulScanTime
+// ══════════════════════════════════════════════════════════════════════════════
+describe("ArbDaemonState with lastSuccessfulScanTime", () => {
+    const TEST_DIR = resolve(process.env.HOME || "~", ".perp", "test-arb-new-features");
+    const TEST_FILE = resolve(TEST_DIR, "arb-state.json");
+    const TMP_FILE = TEST_FILE + ".tmp";
+    beforeEach(() => {
+        if (!existsSync(TEST_DIR))
+            mkdirSync(TEST_DIR, { recursive: true });
+        if (existsSync(TEST_FILE))
+            unlinkSync(TEST_FILE);
+        if (existsSync(TMP_FILE))
+            unlinkSync(TMP_FILE);
+        setStateFilePath(TEST_FILE);
+    });
+    afterEach(() => {
+        if (existsSync(TEST_FILE))
+            unlinkSync(TEST_FILE);
+        if (existsSync(TMP_FILE))
+            unlinkSync(TMP_FILE);
+        resetStateFilePath();
+    });
+    it("createInitialState includes lastSuccessfulScanTime", () => {
+        const state = createInitialState({
+            minSpread: 30, closeSpread: 5, size: 100,
+            holdDays: 7, bridgeCost: 0.5, maxPositions: 5, settleStrategy: "block",
+        });
+        expect(state).toHaveProperty("lastSuccessfulScanTime");
+        expect(state.lastSuccessfulScanTime).toBeTruthy();
+    });
+    it("lastSuccessfulScanTime is an ISO timestamp string", () => {
+        const state = createInitialState({
+            minSpread: 30, closeSpread: 5, size: 100,
+            holdDays: 7, bridgeCost: 0.5, maxPositions: 5, settleStrategy: "block",
+        });
+        // Validate ISO format by parsing it
+        const parsed = new Date(state.lastSuccessfulScanTime);
+        expect(parsed.getTime()).not.toBeNaN();
+        expect(state.lastSuccessfulScanTime).toMatch(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+    });
+    it("saveArbState + loadArbState preserves lastSuccessfulScanTime", () => {
+        const state = createInitialState({
+            minSpread: 30, closeSpread: 5, size: 100,
+            holdDays: 7, bridgeCost: 0.5, maxPositions: 5, settleStrategy: "block",
+        });
+        const testTimestamp = "2025-06-15T14:30:00.000Z";
+        state.lastSuccessfulScanTime = testTimestamp;
+        saveArbState(state);
+        const loaded = loadArbState();
+        expect(loaded).not.toBeNull();
+        expect(loaded.lastSuccessfulScanTime).toBe(testTimestamp);
+    });
+    it("lastSuccessfulScanTime survives state update cycle", () => {
+        const state = createInitialState({
+            minSpread: 30, closeSpread: 5, size: 100,
+            holdDays: 7, bridgeCost: 0.5, maxPositions: 5, settleStrategy: "block",
+        });
+        const ts1 = "2025-06-15T10:00:00.000Z";
+        state.lastSuccessfulScanTime = ts1;
+        saveArbState(state);
+        // Simulate daemon updating lastSuccessfulScanTime
+        const loaded = loadArbState();
+        const ts2 = "2025-06-15T11:00:00.000Z";
+        loaded.lastSuccessfulScanTime = ts2;
+        loaded.lastScanTime = ts2;
+        saveArbState(loaded);
+        const reloaded = loadArbState();
+        expect(reloaded.lastSuccessfulScanTime).toBe(ts2);
+        expect(reloaded.lastScanTime).toBe(ts2);
+    });
+});
+// ══════════════════════════════════════════════════════════════════════════════
+// 7. Exchange downtime detection logic
+// ══════════════════════════════════════════════════════════════════════════════
+describe("Exchange downtime detection logic", () => {
+    /**
+     * Re-implements the exchange health check pattern from arb-auto.ts:
+     * - Try getMarkets() for each exchange
+     * - If it throws, add to downExchanges and blockedExchanges
+     * - If a position has an exchange in downExchanges, mark as degraded
+     */
+    async function checkExchangeHealth(exchangeNames, getMarketsFn) {
+        const downExchanges = new Set();
+        const blockedExchanges = new Set();
+        for (const name of exchangeNames) {
+            try {
+                await getMarketsFn(name);
+            }
+            catch {
+                downExchanges.add(name);
+                blockedExchanges.add(name);
+            }
+        }
+        return { downExchanges, blockedExchanges };
+    }
+    function isPositionDegraded(position, downExchanges) {
+        return downExchanges.has(position.longExchange) || downExchanges.has(position.shortExchange);
+    }
+    it("getMarkets() success -> not in downExchanges", async () => {
+        const getMarkets = vi.fn().mockResolvedValue([{ symbol: "BTC", markPrice: "50000" }]);
+        const result = await checkExchangeHealth(["hyperliquid"], getMarkets);
+        expect(result.downExchanges.has("hyperliquid")).toBe(false);
+        expect(result.blockedExchanges.has("hyperliquid")).toBe(false);
+    });
+    it("getMarkets() throws -> in downExchanges and blockedExchanges", async () => {
+        const getMarkets = vi.fn().mockRejectedValue(new Error("connection refused"));
+        const result = await checkExchangeHealth(["lighter"], getMarkets);
+        expect(result.downExchanges.has("lighter")).toBe(true);
+        expect(result.blockedExchanges.has("lighter")).toBe(true);
+    });
+    it("mixed exchange health: some up, some down", async () => {
+        const getMarkets = vi.fn()
+            .mockImplementation(async (name) => {
+            if (name === "pacifica")
+                throw new Error("503 service unavailable");
+            return [{ symbol: "ETH" }];
+        });
+        const result = await checkExchangeHealth(["hyperliquid", "pacifica", "lighter"], getMarkets);
+        expect(result.downExchanges.has("pacifica")).toBe(true);
+        expect(result.blockedExchanges.has("pacifica")).toBe(true);
+        expect(result.downExchanges.has("hyperliquid")).toBe(false);
+        expect(result.downExchanges.has("lighter")).toBe(false);
+    });
+    it("position on down exchange -> marked as degraded", async () => {
+        const downExchanges = new Set(["pacifica"]);
+        const position = { longExchange: "hyperliquid", shortExchange: "pacifica" };
+        expect(isPositionDegraded(position, downExchanges)).toBe(true);
+    });
+    it("position on healthy exchanges -> not degraded", () => {
+        const downExchanges = new Set();
+        const position = { longExchange: "hyperliquid", shortExchange: "lighter" };
+        expect(isPositionDegraded(position, downExchanges)).toBe(false);
+    });
+    it("position degraded when long exchange is down", () => {
+        const downExchanges = new Set(["hyperliquid"]);
+        const position = { longExchange: "hyperliquid", shortExchange: "pacifica" };
+        expect(isPositionDegraded(position, downExchanges)).toBe(true);
+    });
+});
+// ══════════════════════════════════════════════════════════════════════════════
+// Additional: computeNetSpread, computeRoundTripCostPct, isNearSettlement
+// ══════════════════════════════════════════════════════════════════════════════
+describe("computeNetSpread", () => {
+    it("deducts round-trip cost annualized over hold period", () => {
+        // Gross 50% annual, 0.38% round trip cost, 7 day hold, no bridge
+        const net = computeNetSpread(50, 7, 0.38, 0, 0);
+        // annualized cost = (0.38 / 7) * 365 = ~19.81%
+        // net = 50 - 19.81 = ~30.19%
+        expect(net).toBeCloseTo(30.19, 0);
+    });
+    it("includes bridge cost when provided", () => {
+        // Gross 50%, 0.38% RT, 7d hold, $1 bridge, $100 position
+        const net = computeNetSpread(50, 7, 0.38, 1, 100);
+        // bridge round-trip pct = (1*2/100)*100 = 2%
+        // bridge annualized = (2/7)*365 = ~104.3%
+        // net = 50 - 19.81 - 104.3 -> very negative
+        expect(net).toBeLessThan(0);
+    });
+});
+describe("computeRoundTripCostPct", () => {
+    it("computes standard costs for default exchanges", () => {
+        const cost = computeRoundTripCostPct("hyperliquid", "pacifica", 0.05);
+        // 2 * (0.035 + 0.035) + 2 * 0.05 = 0.14 + 0.10 = 0.24%
+        expect(cost).toBeCloseTo(0.24, 2);
+    });
+});
+describe("isNearSettlement", () => {
+    it("blocks when within buffer of next settlement", () => {
+        // 15:57 UTC, next settlement at 16:00 -> 3 minutes away, within 5 min buffer
+        const now = new Date("2024-06-15T15:57:00Z");
+        const result = isNearSettlement("hyperliquid", "pacifica", 5, now);
+        expect(result.blocked).toBe(true);
+        expect(result.minutesUntil).toBeLessThanOrEqual(5);
+    });
+    it("does not block when far from settlement", () => {
+        // 15:30 UTC, next settlement at 16:00 -> 30 minutes away
+        const now = new Date("2024-06-15T15:30:00Z");
+        const result = isNearSettlement("hyperliquid", "pacifica", 5, now);
+        expect(result.blocked).toBe(false);
+    });
+});
+describe("getNextSettlement", () => {
+    it("returns next hour for hourly exchanges", () => {
+        const now = new Date("2024-06-15T14:30:00Z");
+        const next = getNextSettlement("hyperliquid", now);
+        expect(next.getUTCHours()).toBe(15);
+        expect(next.getUTCMinutes()).toBe(0);
+    });
+});
+describe("isSpreadReversed", () => {
+    it("detects reversal when long exchange has higher rate", () => {
+        // Long HL, Short PAC. If HL rate > PAC rate hourly -> reversed
+        const snapshot = { symbol: "ETH", pacRate: 0.0001, hlRate: 0.0005, ltRate: 0, spread: 0, longExch: "hyperliquid", shortExch: "pacifica", markPrice: 3000, pacMarkPrice: 0, hlMarkPrice: 0, ltMarkPrice: 0 };
+        const reversed = isSpreadReversed("hyperliquid", "pacifica", snapshot);
+        expect(reversed).toBe(true);
+    });
+    it("no reversal when short exchange has higher rate", () => {
+        // Long HL, Short PAC. PAC rate > HL rate -> NOT reversed
+        const snapshot = { symbol: "ETH", pacRate: 0.0005, hlRate: 0.0001, ltRate: 0, spread: 0, longExch: "hyperliquid", shortExch: "pacifica", markPrice: 3000, pacMarkPrice: 0, hlMarkPrice: 0, ltMarkPrice: 0 };
+        const reversed = isSpreadReversed("hyperliquid", "pacifica", snapshot);
+        expect(reversed).toBe(false);
+    });
+});

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

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

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

@@ -0,0 +1,48 @@
+import { describe, it, expect } from "vitest";
+import { computeMatchedSize } from "../arb-sizing.js";
+describe("computeMatchedSize", () => {
+    it("should compute size respecting least precise exchange", () => {
+        // HL (1 decimal) + Lighter (2 decimals) -> use 1 decimal
+        const result = computeMatchedSize(100, 50, "hyperliquid", "lighter");
+        expect(result).not.toBeNull();
+        expect(result.size).toBe("2.0"); // 100/50 = 2.0
+        expect(result.notional).toBe(100);
+    });
+    it("should round down to avoid exceeding requested size", () => {
+        const result = computeMatchedSize(100, 33, "hyperliquid", "lighter");
+        expect(result).not.toBeNull();
+        // 100/33 = 3.0303... -> floor to 3.0 (HL=1 decimal)
+        expect(result.size).toBe("3.0");
+        expect(result.notional).toBeLessThanOrEqual(100);
+    });
+    it("should return null when price is 0", () => {
+        expect(computeMatchedSize(100, 0, "hyperliquid", "lighter")).toBeNull();
+    });
+    it("should return null when size is too small for min notional", () => {
+        // $5 / $100000 = 0.00005 -> rounds to 0.0 for HL (1 decimal)
+        expect(computeMatchedSize(5, 100000, "hyperliquid", "lighter")).toBeNull();
+    });
+    it("should use more precision for pacifica", () => {
+        // Pacifica (4 decimals) + Lighter (2 decimals) -> use 2 decimals
+        const result = computeMatchedSize(100, 3500, "pacifica", "lighter");
+        expect(result).not.toBeNull();
+        // 100/3500 = 0.02857... -> floor to 0.02
+        expect(result.size).toBe("0.02");
+    });
+    it("should handle same exchange pair", () => {
+        const result = computeMatchedSize(1000, 100, "hyperliquid", "hyperliquid");
+        expect(result).not.toBeNull();
+        expect(result.size).toBe("10.0");
+    });
+    it("should try rounding up if floor is below min notional", () => {
+        // $12 / $3500 = 0.00342... -> floor to 0.0 (HL 1 decimal) -> try round up to 0.1
+        // 0.1 * 3500 = 350 which is way more than 12*1.2=14.4, so should return null
+        expect(computeMatchedSize(12, 3500, "hyperliquid", "lighter")).toBeNull();
+    });
+    it("should meet min notional of both exchanges", () => {
+        // Both HL and LT need $10 min
+        const result = computeMatchedSize(15, 150, "hyperliquid", "lighter");
+        expect(result).not.toBeNull();
+        expect(result.notional).toBeGreaterThanOrEqual(10);
+    });
+});

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

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