perp-cli 0.3.3

package/dist/__tests__/config.test.d.ts

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

package/dist/__tests__/config.test.js

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { loadPrivateKey, parseSolanaKeypair, isEvmPrivateKey } from "../config.js";
+import { Keypair } from "@solana/web3.js";
+import bs58 from "bs58";
+describe("isEvmPrivateKey", () => {
+    it("returns true for valid EVM private key", () => {
+        const key = "0x" + "a".repeat(64);
+        expect(isEvmPrivateKey(key)).toBe(true);
+    });
+    it("returns false without 0x prefix", () => {
+        expect(isEvmPrivateKey("a".repeat(64))).toBe(false);
+    });
+    it("returns false for wrong length", () => {
+        expect(isEvmPrivateKey("0x" + "a".repeat(32))).toBe(false);
+    });
+});
+describe("parseSolanaKeypair", () => {
+    it("parses base58-encoded private key", () => {
+        const kp = Keypair.generate();
+        const b58 = bs58.encode(kp.secretKey);
+        const parsed = parseSolanaKeypair(b58);
+        expect(parsed.publicKey.toBase58()).toBe(kp.publicKey.toBase58());
+    });
+    it("parses JSON byte array format", () => {
+        const kp = Keypair.generate();
+        const jsonArr = JSON.stringify(Array.from(kp.secretKey));
+        const parsed = parseSolanaKeypair(jsonArr);
+        expect(parsed.publicKey.toBase58()).toBe(kp.publicKey.toBase58());
+    });
+    it("throws for invalid input", () => {
+        expect(() => parseSolanaKeypair("not-a-valid-key")).toThrow("Invalid Solana private key");
+    });
+});
+describe("loadPrivateKey", () => {
+    const originalEnv = { ...process.env };
+    beforeEach(() => {
+        // Clear relevant env vars
+        delete process.env.PACIFICA_PRIVATE_KEY;
+        delete process.env.pk;
+        delete process.env.HYPERLIQUID_PRIVATE_KEY;
+        delete process.env.HL_PRIVATE_KEY;
+        delete process.env.LIGHTER_PRIVATE_KEY;
+        delete process.env.PRIVATE_KEY;
+    });
+    afterEach(() => {
+        process.env = { ...originalEnv };
+    });
+    it("returns pkOverride when provided", async () => {
+        const result = await loadPrivateKey("pacifica", "my-override-key");
+        expect(result).toBe("my-override-key");
+    });
+    it("reads exchange-specific env var for pacifica", async () => {
+        process.env.PACIFICA_PRIVATE_KEY = "pac-key-123";
+        const result = await loadPrivateKey("pacifica");
+        expect(result).toBe("pac-key-123");
+    });
+    it("reads exchange-specific env var for hyperliquid", async () => {
+        process.env.HYPERLIQUID_PRIVATE_KEY = "hl-key-456";
+        const result = await loadPrivateKey("hyperliquid");
+        expect(result).toBe("hl-key-456");
+    });
+    it("reads HL_PRIVATE_KEY for hyperliquid", async () => {
+        process.env.HL_PRIVATE_KEY = "hl-alt-key";
+        const result = await loadPrivateKey("hyperliquid");
+        expect(result).toBe("hl-alt-key");
+    });
+    it("reads LIGHTER_PRIVATE_KEY for lighter", async () => {
+        process.env.LIGHTER_PRIVATE_KEY = "lighter-key-789";
+        const result = await loadPrivateKey("lighter");
+        expect(result).toBe("lighter-key-789");
+    });
+    it("falls back to PRIVATE_KEY", async () => {
+        process.env.PRIVATE_KEY = "generic-key";
+        const result = await loadPrivateKey("pacifica");
+        expect(result).toBe("generic-key");
+    });
+    it("throws when no key is found", async () => {
+        await expect(loadPrivateKey("pacifica")).rejects.toThrow("No private key configured");
+    });
+    it("prefers exchange-specific over generic", async () => {
+        process.env.PACIFICA_PRIVATE_KEY = "specific";
+        process.env.PRIVATE_KEY = "generic";
+        const result = await loadPrivateKey("pacifica");
+        expect(result).toBe("specific");
+    });
+});

package/dist/__tests__/cross-chain-margin.test.d.ts

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

package/dist/__tests__/cross-chain-margin.test.js

@@ -0,0 +1,287 @@
+import { describe, it, expect, vi } from "vitest";
+import { checkChainMargins, isCriticalMargin, shouldBlockEntries, computeAutoSize, } from "../cross-chain-margin.js";
+// ── Mock adapter factory ──
+function mockAdapter(opts) {
+    const bal = {
+        equity: String(opts.equity),
+        available: String(opts.available ?? opts.equity - opts.marginUsed),
+        marginUsed: String(opts.marginUsed),
+        unrealizedPnl: "0",
+    };
+    return {
+        name: opts.name,
+        getBalance: vi.fn().mockResolvedValue(bal),
+        getOrderbook: vi.fn().mockResolvedValue({
+            asks: opts.asks ?? [["100", "10"], ["101", "5"], ["102", "3"]],
+            bids: opts.bids ?? [["99", "8"], ["98", "6"], ["97", "4"]],
+        }),
+        getMarkets: vi.fn(),
+        getRecentTrades: vi.fn(),
+        getFundingHistory: vi.fn(),
+        getKlines: vi.fn(),
+        getPositions: vi.fn(),
+        getOpenOrders: vi.fn(),
+        getOrderHistory: vi.fn(),
+        getTradeHistory: vi.fn(),
+        getFundingPayments: vi.fn(),
+        marketOrder: vi.fn(),
+        limitOrder: vi.fn(),
+        editOrder: vi.fn(),
+        cancelOrder: vi.fn(),
+        cancelAllOrders: vi.fn(),
+        setLeverage: vi.fn(),
+        stopOrder: vi.fn(),
+    };
+}
+// ── checkChainMargins ──
+describe("checkChainMargins", () => {
+    it("returns correct margin status for healthy exchange", async () => {
+        const adapters = new Map();
+        adapters.set("hyperliquid", mockAdapter({ name: "hyperliquid", equity: 1000, marginUsed: 200 }));
+        const statuses = await checkChainMargins(adapters, 30);
+        expect(statuses).toHaveLength(1);
+        expect(statuses[0].exchange).toBe("hyperliquid");
+        expect(statuses[0].chain).toBe("hyperliquid");
+        expect(statuses[0].equity).toBe(1000);
+        expect(statuses[0].usedMargin).toBe(200);
+        expect(statuses[0].freeMargin).toBe(800);
+        // marginRatio = (800/1000)*100 = 80%
+        expect(statuses[0].marginRatio).toBe(80);
+        expect(statuses[0].belowThreshold).toBe(false);
+    });
+    it("detects low margin below threshold", async () => {
+        const adapters = new Map();
+        adapters.set("lighter", mockAdapter({ name: "lighter", equity: 1000, marginUsed: 800 }));
+        const statuses = await checkChainMargins(adapters, 30);
+        expect(statuses).toHaveLength(1);
+        // marginRatio = (200/1000)*100 = 20% < 30%
+        expect(statuses[0].marginRatio).toBe(20);
+        expect(statuses[0].belowThreshold).toBe(true);
+    });
+    it("handles multiple exchanges", async () => {
+        const adapters = new Map();
+        adapters.set("hyperliquid", mockAdapter({ name: "hyperliquid", equity: 1000, marginUsed: 100 }));
+        adapters.set("pacifica", mockAdapter({ name: "pacifica", equity: 500, marginUsed: 400 }));
+        adapters.set("lighter", mockAdapter({ name: "lighter", equity: 2000, marginUsed: 500 }));
+        const statuses = await checkChainMargins(adapters, 30);
+        expect(statuses).toHaveLength(3);
+        const hl = statuses.find(s => s.exchange === "hyperliquid");
+        expect(hl.marginRatio).toBe(90); // (900/1000)*100
+        expect(hl.belowThreshold).toBe(false);
+        expect(hl.chain).toBe("hyperliquid");
+        const pac = statuses.find(s => s.exchange === "pacifica");
+        expect(pac.marginRatio).toBe(20); // (100/500)*100
+        expect(pac.belowThreshold).toBe(true);
+        expect(pac.chain).toBe("solana");
+        const lt = statuses.find(s => s.exchange === "lighter");
+        expect(lt.marginRatio).toBe(75); // (1500/2000)*100
+        expect(lt.belowThreshold).toBe(false);
+        expect(lt.chain).toBe("arbitrum");
+    });
+    it("handles zero equity", async () => {
+        const adapters = new Map();
+        adapters.set("hyperliquid", mockAdapter({ name: "hyperliquid", equity: 0, marginUsed: 0 }));
+        const statuses = await checkChainMargins(adapters, 30);
+        expect(statuses[0].marginRatio).toBe(0);
+        expect(statuses[0].belowThreshold).toBe(true);
+    });
+});
+// ── isCriticalMargin ──
+describe("isCriticalMargin", () => {
+    it("returns true when margin ratio below 15%", () => {
+        const status = {
+            exchange: "test",
+            chain: "arbitrum",
+            equity: 1000,
+            usedMargin: 900,
+            freeMargin: 100,
+            marginRatio: 10,
+            belowThreshold: true,
+        };
+        expect(isCriticalMargin(status)).toBe(true);
+    });
+    it("returns false when margin ratio above 15%", () => {
+        const status = {
+            exchange: "test",
+            chain: "arbitrum",
+            equity: 1000,
+            usedMargin: 700,
+            freeMargin: 300,
+            marginRatio: 30,
+            belowThreshold: false,
+        };
+        expect(isCriticalMargin(status)).toBe(false);
+    });
+    it("returns false at exactly 15%", () => {
+        const status = {
+            exchange: "test",
+            chain: "arbitrum",
+            equity: 1000,
+            usedMargin: 850,
+            freeMargin: 150,
+            marginRatio: 15,
+            belowThreshold: true,
+        };
+        expect(isCriticalMargin(status)).toBe(false);
+    });
+});
+// ── shouldBlockEntries ──
+describe("shouldBlockEntries", () => {
+    it("blocks when below threshold", () => {
+        const status = {
+            exchange: "test",
+            chain: "solana",
+            equity: 1000,
+            usedMargin: 800,
+            freeMargin: 200,
+            marginRatio: 20,
+            belowThreshold: true,
+        };
+        expect(shouldBlockEntries(status, 30)).toBe(true);
+    });
+    it("allows when above threshold", () => {
+        const status = {
+            exchange: "test",
+            chain: "solana",
+            equity: 1000,
+            usedMargin: 500,
+            freeMargin: 500,
+            marginRatio: 50,
+            belowThreshold: false,
+        };
+        expect(shouldBlockEntries(status, 30)).toBe(false);
+    });
+});
+// ── computeAutoSize ──
+describe("computeAutoSize", () => {
+    it("picks the smaller side from orderbook depth", async () => {
+        // Long side (asks): 3 levels -> $100*10 + $101*5 + $102*3 = $1000+$505+$306 = $1811
+        // Short side (bids): 3 levels -> $99*8 + $98*6 + $97*4 = $792+$588+$388 = $1768
+        // Min is $1768 (short side)
+        const longAdapter = mockAdapter({
+            name: "hyperliquid",
+            equity: 10000,
+            marginUsed: 0,
+            asks: [["100", "10"], ["101", "5"], ["102", "3"]],
+        });
+        const shortAdapter = mockAdapter({
+            name: "pacifica",
+            equity: 10000,
+            marginUsed: 0,
+            bids: [["99", "8"], ["98", "6"], ["97", "4"]],
+        });
+        const size = await computeAutoSize(longAdapter, shortAdapter, "BTC", 5.0);
+        // Should be capped by risk maxPositionUsd (5000 default) or the orderbook depth
+        expect(size).toBeGreaterThan(0);
+        expect(size).toBeLessThanOrEqual(5000); // risk limit
+    });
+    it("respects 50% free margin cap", async () => {
+        // Both sides have huge depth but small free margin
+        const longAdapter = mockAdapter({
+            name: "hyperliquid",
+            equity: 200,
+            marginUsed: 100,
+            asks: [["100", "100"]], // $10000 depth
+        });
+        const shortAdapter = mockAdapter({
+            name: "pacifica",
+            equity: 300,
+            marginUsed: 100,
+            bids: [["99", "100"]], // $9900 depth
+        });
+        const size = await computeAutoSize(longAdapter, shortAdapter, "BTC", 5.0);
+        // Free margin: long=100, short=200 -> min=100 -> 50% = 50
+        expect(size).toBeLessThanOrEqual(50);
+        expect(size).toBeGreaterThan(0);
+    });
+    it("returns 0 when orderbook is empty", async () => {
+        const longAdapter = mockAdapter({
+            name: "hyperliquid",
+            equity: 10000,
+            marginUsed: 0,
+            asks: [],
+        });
+        const shortAdapter = mockAdapter({
+            name: "pacifica",
+            equity: 10000,
+            marginUsed: 0,
+            bids: [["99", "10"]],
+        });
+        const size = await computeAutoSize(longAdapter, shortAdapter, "BTC", 0.3);
+        expect(size).toBe(0);
+    });
+    it("caps at maxPositionUsd from risk config", async () => {
+        // Huge depth and margin, should be capped by risk limits
+        const longAdapter = mockAdapter({
+            name: "hyperliquid",
+            equity: 1_000_000,
+            marginUsed: 0,
+            asks: [["100", "10000"]], // $1M depth
+        });
+        const shortAdapter = mockAdapter({
+            name: "pacifica",
+            equity: 1_000_000,
+            marginUsed: 0,
+            bids: [["99", "10000"]], // $990K depth
+        });
+        const size = await computeAutoSize(longAdapter, shortAdapter, "BTC", 5.0);
+        // Default maxPositionUsd is 5000
+        expect(size).toBeLessThanOrEqual(5000);
+    });
+});
+// ── Rebalance computation ──
+describe("Rebalance computation", () => {
+    it("computes correct transfers for 50:50 target", async () => {
+        // Import the compute function
+        const { computeRebalancePlan } = await import("../rebalance.js");
+        const snapshots = [
+            { exchange: "lighter", equity: 800, available: 700, marginUsed: 100, unrealizedPnl: 0 },
+            { exchange: "pacifica", equity: 200, available: 200, marginUsed: 0, unrealizedPnl: 0 },
+        ];
+        const plan = computeRebalancePlan(snapshots, {
+            weights: { lighter: 0.5, pacifica: 0.5 },
+            minMove: 10,
+            reserve: 10,
+        });
+        // Total available = 900, each should have 450
+        // Lighter has 700 (surplus ~250), Pacifica has 200 (deficit ~250)
+        expect(plan.moves.length).toBeGreaterThan(0);
+        // The move should be from lighter to pacifica
+        const move = plan.moves[0];
+        expect(move.from).toBe("lighter");
+        expect(move.to).toBe("pacifica");
+        expect(move.amount).toBeGreaterThan(100); // Should move ~230+ (minus reserve)
+    });
+    it("returns no moves when already balanced", async () => {
+        const { computeRebalancePlan } = await import("../rebalance.js");
+        const snapshots = [
+            { exchange: "lighter", equity: 500, available: 500, marginUsed: 0, unrealizedPnl: 0 },
+            { exchange: "pacifica", equity: 500, available: 500, marginUsed: 0, unrealizedPnl: 0 },
+        ];
+        const plan = computeRebalancePlan(snapshots, {
+            weights: { lighter: 0.5, pacifica: 0.5 },
+            minMove: 10,
+            reserve: 10,
+        });
+        expect(plan.moves.length).toBe(0);
+    });
+    it("respects 33:33:33 three-way split", async () => {
+        const { computeRebalancePlan } = await import("../rebalance.js");
+        const snapshots = [
+            { exchange: "lighter", equity: 900, available: 900, marginUsed: 0, unrealizedPnl: 0 },
+            { exchange: "pacifica", equity: 0, available: 0, marginUsed: 0, unrealizedPnl: 0 },
+            { exchange: "hyperliquid", equity: 0, available: 0, marginUsed: 0, unrealizedPnl: 0 },
+        ];
+        const plan = computeRebalancePlan(snapshots, {
+            weights: { lighter: 1 / 3, pacifica: 1 / 3, hyperliquid: 1 / 3 },
+            minMove: 10,
+            reserve: 10,
+        });
+        // Should move funds from lighter to the other two
+        expect(plan.moves.length).toBeGreaterThanOrEqual(1);
+        for (const m of plan.moves) {
+            expect(m.from).toBe("lighter");
+            expect(["pacifica", "hyperliquid"]).toContain(m.to);
+        }
+    });
+});

package/dist/__tests__/dex-asset-map.test.d.ts

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

package/dist/__tests__/dex-asset-map.test.js

@@ -0,0 +1,191 @@
+import { describe, it, expect } from "vitest";
+import { findDexArbPairs } from "../dex-asset-map.js";
+function makeAsset(overrides) {
+    return {
+        maxLeverage: 10,
+        openInterest: 1000,
+        volume24h: 50000,
+        szDecimals: 3,
+        ...overrides,
+    };
+}
+describe("findDexArbPairs — exact name matching", () => {
+    it("finds arb pair for TSLA across xyz and cash dexes", () => {
+        const assets = [
+            makeAsset({ raw: "xyz:TSLA", base: "TSLA", dex: "xyz", markPrice: 392.81, fundingRate: 0.00001 }),
+            makeAsset({ raw: "cash:TSLA", base: "TSLA", dex: "cash", markPrice: 392.65, fundingRate: -0.00005 }),
+        ];
+        const pairs = findDexArbPairs(assets);
+        expect(pairs).toHaveLength(1);
+        expect(pairs[0].underlying).toBe("TSLA");
+        expect(pairs[0].long.dex).not.toBe(pairs[0].short.dex);
+        expect(pairs[0].annualSpread).toBeGreaterThan(0);
+        expect(pairs[0].priceGapPct).toBeLessThan(1);
+    });
+    it("finds multiple pairs for NVDA across 4 dexes", () => {
+        const assets = [
+            makeAsset({ raw: "xyz:NVDA", base: "NVDA", dex: "xyz", markPrice: 175.97, fundingRate: 0.00004 }),
+            makeAsset({ raw: "flx:NVDA", base: "NVDA", dex: "flx", markPrice: 176.02, fundingRate: 0.0 }),
+            makeAsset({ raw: "km:NVDA", base: "NVDA", dex: "km", markPrice: 176.01, fundingRate: -0.00006 }),
+            makeAsset({ raw: "cash:NVDA", base: "NVDA", dex: "cash", markPrice: 176.19, fundingRate: -0.000001 }),
+        ];
+        const pairs = findDexArbPairs(assets);
+        // 4 dexes → C(4,2) = 6 pairs
+        expect(pairs.length).toBe(6);
+        // All should be NVDA
+        for (const p of pairs) {
+            expect(p.underlying).toBe("NVDA");
+        }
+        // Sorted by spread descending
+        for (let i = 1; i < pairs.length; i++) {
+            expect(pairs[i].annualSpread).toBeLessThanOrEqual(pairs[i - 1].annualSpread);
+        }
+    });
+    it("includes native HL perps when includeNative=true", () => {
+        const assets = [
+            makeAsset({ raw: "BTC", base: "BTC", dex: "hl", markPrice: 68000, fundingRate: 0.00001 }),
+            makeAsset({ raw: "hyna:BTC", base: "BTC", dex: "hyna", markPrice: 68010, fundingRate: 0.00003 }),
+        ];
+        const withNative = findDexArbPairs(assets, { includeNative: true });
+        expect(withNative).toHaveLength(1);
+        expect(withNative[0].underlying).toBe("BTC");
+        const withoutNative = findDexArbPairs(assets, { includeNative: false });
+        expect(withoutNative).toHaveLength(0); // only 1 non-native asset
+    });
+});
+describe("findDexArbPairs — alias matching", () => {
+    it("matches CL and OIL as same underlying (CRUDE_OIL_WTI)", () => {
+        const assets = [
+            makeAsset({ raw: "xyz:CL", base: "CL", dex: "xyz", markPrice: 93.34, fundingRate: -0.0005 }),
+            makeAsset({ raw: "flx:OIL", base: "OIL", dex: "flx", markPrice: 93.38, fundingRate: 0.0 }),
+        ];
+        const pairs = findDexArbPairs(assets);
+        expect(pairs).toHaveLength(1);
+        expect(pairs[0].underlying).toBe("CRUDE_OIL_WTI");
+    });
+    it("matches kPEPE and 1000PEPE as same underlying", () => {
+        const assets = [
+            makeAsset({ raw: "kPEPE", base: "kPEPE", dex: "hl", markPrice: 0.015, fundingRate: 0.0001 }),
+            makeAsset({ raw: "hyna:1000PEPE", base: "1000PEPE", dex: "hyna", markPrice: 0.0151, fundingRate: 0.0003 }),
+        ];
+        const pairs = findDexArbPairs(assets);
+        expect(pairs).toHaveLength(1);
+        expect(pairs[0].underlying).toBe("1000PEPE");
+    });
+});
+describe("findDexArbPairs — blacklist & price gap filtering", () => {
+    it("rejects USAR vs US500 (blacklisted)", () => {
+        const assets = [
+            makeAsset({ raw: "xyz:USAR", base: "USAR", dex: "xyz", markPrice: 17.63, fundingRate: 0.0003 }),
+            makeAsset({ raw: "km:US500", base: "US500", dex: "km", markPrice: 666.69, fundingRate: 0.00001 }),
+        ];
+        // Even without blacklist, price gap (>5%) would filter this out
+        const pairs = findDexArbPairs(assets);
+        expect(pairs).toHaveLength(0);
+    });
+    it("rejects SEMI vs SEMIS (blacklisted)", () => {
+        const assets = [
+            makeAsset({ raw: "km:SEMI", base: "SEMI", dex: "km", markPrice: 319.38, fundingRate: 0.00008 }),
+            makeAsset({ raw: "vntl:SEMIS", base: "SEMIS", dex: "vntl", markPrice: 381.21, fundingRate: 0.00001 }),
+        ];
+        const pairs = findDexArbPairs(assets);
+        expect(pairs).toHaveLength(0);
+    });
+    it("rejects pairs with >5% price gap even if same name", () => {
+        const assets = [
+            makeAsset({ raw: "dexA:FOO", base: "FOO", dex: "dexA", markPrice: 100, fundingRate: 0.001 }),
+            makeAsset({ raw: "dexB:FOO", base: "FOO", dex: "dexB", markPrice: 110, fundingRate: -0.001 }),
+        ];
+        // ~9.5% gap → should be filtered
+        const pairs = findDexArbPairs(assets, { maxPriceGapPct: 5 });
+        expect(pairs).toHaveLength(0);
+        // Increase tolerance
+        const pairsLoose = findDexArbPairs(assets, { maxPriceGapPct: 15 });
+        expect(pairsLoose).toHaveLength(1);
+    });
+    it("accepts pairs with <5% price gap", () => {
+        const assets = [
+            makeAsset({ raw: "xyz:GOLD", base: "GOLD", dex: "xyz", markPrice: 5164.60, fundingRate: -0.00001 }),
+            makeAsset({ raw: "cash:GOLD", base: "GOLD", dex: "cash", markPrice: 5176.04, fundingRate: -0.00005 }),
+        ];
+        const pairs = findDexArbPairs(assets);
+        expect(pairs).toHaveLength(1);
+        expect(pairs[0].priceGapPct).toBeLessThan(1);
+    });
+});
+describe("findDexArbPairs — spread calculation", () => {
+    it("correctly determines long/short direction", () => {
+        const assets = [
+            // dexA: high positive funding → expensive to be long
+            makeAsset({ raw: "dexA:ETH", base: "ETH", dex: "dexA", markPrice: 1974, fundingRate: 0.001 }),
+            // dexB: negative funding → get paid to be long
+            makeAsset({ raw: "dexB:ETH", base: "ETH", dex: "dexB", markPrice: 1975, fundingRate: -0.001 }),
+        ];
+        const pairs = findDexArbPairs(assets);
+        expect(pairs).toHaveLength(1);
+        // Should long on dexB (lower funding) and short on dexA (higher funding)
+        expect(pairs[0].long.dex).toBe("dexB");
+        expect(pairs[0].short.dex).toBe("dexA");
+    });
+    it("all dexes use 1h funding period (including HIP-3 deployed)", () => {
+        const assets = [
+            // Native HL: 1h funding
+            makeAsset({ raw: "BTC", base: "BTC", dex: "hl", markPrice: 68000, fundingRate: 0.001 }),
+            // Deployed dex: also 1h funding (same rate = no spread)
+            makeAsset({ raw: "hyna:BTC", base: "BTC", dex: "hyna", markPrice: 68010, fundingRate: 0.001 }),
+        ];
+        const pairs = findDexArbPairs(assets, { minAnnualSpread: 0 });
+        // Same rate on both → spread ≈ 0
+        if (pairs.length > 0) {
+            expect(pairs[0].annualSpread).toBeLessThan(1);
+        }
+    });
+    it("filters by minAnnualSpread", () => {
+        const assets = [
+            makeAsset({ raw: "xyz:TSLA", base: "TSLA", dex: "xyz", markPrice: 392, fundingRate: 0.00001 }),
+            makeAsset({ raw: "cash:TSLA", base: "TSLA", dex: "cash", markPrice: 393, fundingRate: 0.00002 }),
+        ];
+        const allPairs = findDexArbPairs(assets, { minAnnualSpread: 0 });
+        expect(allPairs.length).toBeGreaterThanOrEqual(1);
+        const highOnly = findDexArbPairs(assets, { minAnnualSpread: 999 });
+        expect(highOnly).toHaveLength(0);
+    });
+});
+describe("findDexArbPairs — same dex exclusion", () => {
+    it("does not pair assets from the same dex", () => {
+        const assets = [
+            makeAsset({ raw: "xyz:TSLA", base: "TSLA", dex: "xyz", markPrice: 392, fundingRate: 0.001 }),
+            makeAsset({ raw: "xyz:NVDA", base: "NVDA", dex: "xyz", markPrice: 176, fundingRate: -0.001 }),
+        ];
+        const pairs = findDexArbPairs(assets);
+        expect(pairs).toHaveLength(0); // different assets, no match
+    });
+    it("does not pair same asset within same dex", () => {
+        // Edge case: shouldn't happen but be safe
+        const assets = [
+            makeAsset({ raw: "xyz:TSLA", base: "TSLA", dex: "xyz", markPrice: 392, fundingRate: 0.001 }),
+            makeAsset({ raw: "xyz:TSLA", base: "TSLA", dex: "xyz", markPrice: 392, fundingRate: 0.001 }),
+        ];
+        const pairs = findDexArbPairs(assets);
+        expect(pairs).toHaveLength(0);
+    });
+});
+describe("findDexArbPairs — edge cases", () => {
+    it("handles empty assets list", () => {
+        expect(findDexArbPairs([])).toHaveLength(0);
+    });
+    it("handles single asset", () => {
+        const assets = [
+            makeAsset({ raw: "BTC", base: "BTC", dex: "hl", markPrice: 68000, fundingRate: 0.001 }),
+        ];
+        expect(findDexArbPairs(assets)).toHaveLength(0);
+    });
+    it("handles all assets from one dex only", () => {
+        const assets = [
+            makeAsset({ raw: "xyz:TSLA", base: "TSLA", dex: "xyz", markPrice: 392, fundingRate: 0.001 }),
+            makeAsset({ raw: "xyz:NVDA", base: "NVDA", dex: "xyz", markPrice: 176, fundingRate: -0.001 }),
+            makeAsset({ raw: "xyz:GOLD", base: "GOLD", dex: "xyz", markPrice: 5164, fundingRate: 0.0 }),
+        ];
+        expect(findDexArbPairs(assets)).toHaveLength(0);
+    });
+});

package/dist/__tests__/errors.test.d.ts

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