perp-cli 0.3.3

package/dist/__tests__/utils.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect } from "vitest";
+import { formatUsd, formatPnl, formatPercent, printJson } from "../utils.js";
+describe("formatUsd", () => {
+    it("formats numeric strings", () => {
+        expect(formatUsd("1234.5")).toBe("1,234.50");
+    });
+    it("formats numbers", () => {
+        expect(formatUsd(99999.999)).toBe("100,000.00");
+    });
+    it("returns original string for NaN", () => {
+        expect(formatUsd("abc")).toBe("abc");
+    });
+    it("formats zero", () => {
+        expect(formatUsd(0)).toBe("0.00");
+    });
+    it("formats negative numbers", () => {
+        expect(formatUsd(-42.1)).toBe("-42.10");
+    });
+});
+describe("formatPnl", () => {
+    it("positive PnL has + prefix", () => {
+        const result = formatPnl(100);
+        expect(result).toContain("+$100.00");
+    });
+    it("negative PnL has - prefix", () => {
+        const result = formatPnl(-50);
+        expect(result).toContain("-$50.00");
+    });
+    it("zero PnL", () => {
+        const result = formatPnl(0);
+        expect(result).toContain("$0.00");
+    });
+    it("handles string input", () => {
+        const result = formatPnl("123.456");
+        expect(result).toContain("$123.46");
+    });
+    it("handles NaN", () => {
+        expect(formatPnl("abc")).toBe("abc");
+    });
+});
+describe("formatPercent", () => {
+    it("positive percent", () => {
+        const result = formatPercent(0.0015);
+        expect(result).toContain("+0.1500%");
+    });
+    it("negative percent", () => {
+        const result = formatPercent(-0.0025);
+        expect(result).toContain("-0.2500%");
+    });
+    it("zero percent", () => {
+        const result = formatPercent(0);
+        expect(result).toContain("0.0000%");
+    });
+    it("handles NaN", () => {
+        expect(formatPercent("abc")).toBe("abc");
+    });
+});
+describe("printJson", () => {
+    it("outputs valid JSON to console", () => {
+        const logs = [];
+        const origLog = console.log;
+        console.log = (...args) => logs.push(args.join(" "));
+        printJson({ a: 1, b: "hello" });
+        console.log = origLog;
+        const parsed = JSON.parse(logs[0]);
+        expect(parsed).toEqual({ a: 1, b: "hello" });
+    });
+    it("handles arrays", () => {
+        const logs = [];
+        const origLog = console.log;
+        console.log = (...args) => logs.push(args.join(" "));
+        printJson([1, 2, 3]);
+        console.log = origLog;
+        expect(JSON.parse(logs[0])).toEqual([1, 2, 3]);
+    });
+});

package/dist/api/public/hyperliquid.d.ts

@@ -0,0 +1,18 @@
+export interface HyperliquidAsset {
+    symbol: string;
+    funding: number;
+    markPx: number;
+}
+export declare function fetchHyperliquidMeta(): Promise<HyperliquidAsset[]>;
+export declare function fetchHyperliquidMetaRaw(): Promise<unknown>;
+export declare function parseHyperliquidMetaRaw(raw: unknown): {
+    rates: Map<string, number>;
+    prices: Map<string, number>;
+};
+export declare function fetchHyperliquidAllMids(): Promise<Record<string, string>>;
+export declare function fetchHyperliquidAllMidsRaw(): Promise<unknown>;
+export declare function pingHyperliquid(): Promise<{
+    ok: boolean;
+    latencyMs: number;
+    status: number;
+}>;

package/dist/api/public/hyperliquid.js

@@ -0,0 +1,82 @@
+import { HYPERLIQUID_API_URL } from "./urls.js";
+import { withCache, TTL_MARKET } from "../../cache.js";
+// ── Internal ──
+function hlPost(type) {
+    return fetch(HYPERLIQUID_API_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ type }),
+    }).then(r => r.json());
+}
+// ── Fetchers ──
+export function fetchHyperliquidMeta() {
+    return withCache("pub:hl:metaAndAssetCtxs", TTL_MARKET, async () => {
+        try {
+            const json = await hlPost("metaAndAssetCtxs");
+            const universe = (json[0] ?? {}).universe ?? [];
+            const ctxs = (json[1] ?? []);
+            return universe.map((asset, i) => {
+                const ctx = (ctxs[i] ?? {});
+                return {
+                    symbol: String(asset.name ?? ""),
+                    funding: Number(ctx.funding ?? 0),
+                    markPx: Number(ctx.markPx ?? 0),
+                };
+            });
+        }
+        catch {
+            return [];
+        }
+    });
+}
+export function fetchHyperliquidMetaRaw() {
+    return withCache("pub:hl:metaAndAssetCtxs:raw", TTL_MARKET, () => hlPost("metaAndAssetCtxs").catch(() => null));
+}
+export function parseHyperliquidMetaRaw(raw) {
+    const rates = new Map();
+    const prices = new Map();
+    if (!raw || !Array.isArray(raw))
+        return { rates, prices };
+    const universe = raw[0];
+    const ctxs = (raw[1] ?? []);
+    const assets = (universe?.universe ?? []);
+    assets.forEach((a, i) => {
+        const ctx = (ctxs[i] ?? {});
+        const sym = String(a.name ?? "");
+        if (!sym)
+            return;
+        rates.set(sym, Number(ctx.funding ?? 0));
+        const mp = Number(ctx.markPx ?? 0);
+        if (mp > 0)
+            prices.set(sym, mp);
+    });
+    return { rates, prices };
+}
+export function fetchHyperliquidAllMids() {
+    return withCache("pub:hl:allMids", TTL_MARKET, async () => {
+        try {
+            return await hlPost("allMids");
+        }
+        catch {
+            return {};
+        }
+    });
+}
+export function fetchHyperliquidAllMidsRaw() {
+    return withCache("pub:hl:allMids:raw", TTL_MARKET, () => hlPost("allMids").catch(() => null));
+}
+// ── Health check ──
+export async function pingHyperliquid() {
+    const start = Date.now();
+    try {
+        const res = await fetch(HYPERLIQUID_API_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ type: "allMids" }),
+        });
+        return { ok: res.ok, latencyMs: Date.now() - start, status: res.status };
+    }
+    catch {
+        return { ok: false, latencyMs: Date.now() - start, status: 0 };
+    }
+}

package/dist/api/public/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Barrel export for public API fetchers.
+ * All exchange-specific fetchers, parsers, and ping functions are re-exported here.
+ */
+export * from "./urls.js";
+export * from "./pacifica.js";
+export * from "./hyperliquid.js";
+export * from "./lighter.js";

package/dist/api/public/index.js

@@ -0,0 +1,8 @@
+/**
+ * Barrel export for public API fetchers.
+ * All exchange-specific fetchers, parsers, and ping functions are re-exported here.
+ */
+export * from "./urls.js";
+export * from "./pacifica.js";
+export * from "./hyperliquid.js";
+export * from "./lighter.js";

package/dist/api/public/lighter.d.ts

@@ -0,0 +1,24 @@
+export interface LighterMarketDetail {
+    marketId: number;
+    symbol: string;
+    lastTradePrice: number;
+}
+export interface LighterFundingEntry {
+    marketId: number;
+    symbol: string;
+    rate: number;
+    markPrice: number;
+}
+export declare function fetchLighterOrderBookDetails(): Promise<LighterMarketDetail[]>;
+export declare function fetchLighterOrderBookDetailsRaw(): Promise<unknown>;
+export declare function fetchLighterFundingRates(): Promise<LighterFundingEntry[]>;
+export declare function fetchLighterFundingRatesRaw(): Promise<unknown>;
+export declare function parseLighterRaw(detailsRaw: unknown, fundingRaw: unknown): {
+    rates: Map<string, number>;
+    prices: Map<string, number>;
+};
+export declare function pingLighter(): Promise<{
+    ok: boolean;
+    latencyMs: number;
+    status: number;
+}>;

package/dist/api/public/lighter.js

@@ -0,0 +1,100 @@
+import { LIGHTER_API_URL } from "./urls.js";
+import { withCache, TTL_MARKET } from "../../cache.js";
+// ── Fetchers ──
+export function fetchLighterOrderBookDetails() {
+    return withCache("pub:lt:orderBookDetails", TTL_MARKET, async () => {
+        try {
+            const res = await fetch(`${LIGHTER_API_URL}/api/v1/orderBookDetails`);
+            const json = await res.json();
+            const details = (json.order_book_details ?? []);
+            return details.map(m => ({
+                marketId: Number(m.market_id),
+                symbol: String(m.symbol ?? ""),
+                lastTradePrice: Number(m.last_trade_price ?? 0),
+            }));
+        }
+        catch {
+            return [];
+        }
+    });
+}
+export function fetchLighterOrderBookDetailsRaw() {
+    return withCache("pub:lt:orderBookDetails:raw", TTL_MARKET, () => fetch(`${LIGHTER_API_URL}/api/v1/orderBookDetails`).then(r => r.json()).catch(() => null));
+}
+export function fetchLighterFundingRates() {
+    return withCache("pub:lt:fundingRates", TTL_MARKET, async () => {
+        try {
+            const res = await fetch(`${LIGHTER_API_URL}/api/v1/funding-rates`);
+            const json = await res.json();
+            const list = (json.funding_rates ?? []);
+            const entries = [];
+            for (const fr of list) {
+                if (String(fr.exchange ?? "").toLowerCase() !== "lighter")
+                    continue;
+                entries.push({
+                    marketId: Number(fr.market_id),
+                    symbol: String(fr.symbol ?? ""),
+                    rate: Number(fr.rate ?? fr.funding_rate ?? 0),
+                    markPrice: Number(fr.mark_price ?? 0),
+                });
+            }
+            return entries;
+        }
+        catch {
+            return [];
+        }
+    });
+}
+export function fetchLighterFundingRatesRaw() {
+    return withCache("pub:lt:fundingRates:raw", TTL_MARKET, () => fetch(`${LIGHTER_API_URL}/api/v1/funding-rates`).then(r => r.json()).catch(() => null));
+}
+export function parseLighterRaw(detailsRaw, fundingRaw) {
+    const rates = new Map();
+    const prices = new Map();
+    const idToSym = new Map();
+    const idToPrice = new Map();
+    if (detailsRaw) {
+        const details = (detailsRaw.order_book_details ?? []);
+        for (const m of details) {
+            const mid = Number(m.market_id);
+            idToSym.set(mid, String(m.symbol ?? ""));
+            const p = Number(m.last_trade_price ?? 0);
+            if (p > 0)
+                idToPrice.set(mid, p);
+        }
+    }
+    if (fundingRaw) {
+        const fundingList = (fundingRaw.funding_rates ?? []);
+        for (const fr of fundingList) {
+            // API returns rates from multiple exchanges — only use Lighter's own rates
+            if (String(fr.exchange ?? "").toLowerCase() !== "lighter")
+                continue;
+            const sym = String(fr.symbol ?? "") || idToSym.get(Number(fr.market_id)) || "";
+            if (!sym || rates.has(sym))
+                continue;
+            rates.set(sym, Number(fr.rate ?? fr.funding_rate ?? 0));
+            const mp = Number(fr.mark_price ?? 0) || idToPrice.get(Number(fr.market_id)) || 0;
+            if (mp > 0)
+                prices.set(sym, mp);
+        }
+    }
+    for (const [mid, sym] of idToSym) {
+        if (!prices.has(sym)) {
+            const p = idToPrice.get(mid);
+            if (p && p > 0)
+                prices.set(sym, p);
+        }
+    }
+    return { rates, prices };
+}
+// ── Health check ──
+export async function pingLighter() {
+    const start = Date.now();
+    try {
+        const res = await fetch(`${LIGHTER_API_URL}/api/v1/orderBookDetails`);
+        return { ok: res.ok, latencyMs: Date.now() - start, status: res.status };
+    }
+    catch {
+        return { ok: false, latencyMs: Date.now() - start, status: 0 };
+    }
+}

package/dist/api/public/pacifica.d.ts

@@ -0,0 +1,17 @@
+export interface PacificaAsset {
+    symbol: string;
+    funding: number;
+    mark: number;
+    nextFunding?: number;
+}
+export declare function fetchPacificaPrices(): Promise<PacificaAsset[]>;
+export declare function fetchPacificaPricesRaw(): Promise<unknown>;
+export declare function parsePacificaRaw(raw: unknown): {
+    rates: Map<string, number>;
+    prices: Map<string, number>;
+};
+export declare function pingPacifica(): Promise<{
+    ok: boolean;
+    latencyMs: number;
+    status: number;
+}>;

package/dist/api/public/pacifica.js

@@ -0,0 +1,54 @@
+import { PACIFICA_API_URL } from "./urls.js";
+import { withCache, TTL_MARKET } from "../../cache.js";
+// ── Fetchers ──
+export function fetchPacificaPrices() {
+    return withCache("pub:pac:prices", TTL_MARKET, async () => {
+        try {
+            const res = await fetch(PACIFICA_API_URL);
+            const json = await res.json();
+            const data = json.data ?? json;
+            if (!Array.isArray(data))
+                return [];
+            return data.map((p) => ({
+                symbol: String(p.symbol ?? ""),
+                funding: Number(p.next_funding ?? p.funding ?? 0),
+                mark: Number(p.mark ?? 0),
+                nextFunding: p.next_funding ? Number(p.next_funding) : undefined,
+            }));
+        }
+        catch {
+            return [];
+        }
+    });
+}
+export function fetchPacificaPricesRaw() {
+    return withCache("pub:pac:prices:raw", TTL_MARKET, () => fetch(PACIFICA_API_URL).then(r => r.json()).catch(() => null));
+}
+export function parsePacificaRaw(raw) {
+    const rates = new Map();
+    const prices = new Map();
+    const data = raw?.data ?? raw;
+    if (!Array.isArray(data))
+        return { rates, prices };
+    for (const p of data) {
+        const sym = String(p.symbol ?? "");
+        if (!sym)
+            continue;
+        rates.set(sym, Number(p.next_funding ?? p.funding ?? 0));
+        const mark = Number(p.mark ?? p.price ?? 0);
+        if (mark > 0)
+            prices.set(sym, mark);
+    }
+    return { rates, prices };
+}
+// ── Health check ──
+export async function pingPacifica() {
+    const start = Date.now();
+    try {
+        const res = await fetch(PACIFICA_API_URL);
+        return { ok: res.ok, latencyMs: Date.now() - start, status: res.status };
+    }
+    catch {
+        return { ok: false, latencyMs: Date.now() - start, status: 0 };
+    }
+}

package/dist/api/public/urls.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared API URL management for all exchanges.
+ * URLs are mutable to support --network testnet switching.
+ */
+export declare let PACIFICA_API_URL: string;
+export declare let HYPERLIQUID_API_URL: string;
+export declare let LIGHTER_API_URL: string;
+/**
+ * Switch shared API URLs between mainnet and testnet.
+ * Call from CLI entry point after parsing --network flag.
+ */
+export declare function setSharedApiNetwork(network: "mainnet" | "testnet"): void;

package/dist/api/public/urls.js

@@ -0,0 +1,33 @@
+/**
+ * Shared API URL management for all exchanges.
+ * URLs are mutable to support --network testnet switching.
+ */
+const MAINNET_URLS = {
+    pacifica: "https://api.pacifica.fi/api/v1/info/prices",
+    hyperliquid: "https://api.hyperliquid.xyz/info",
+    lighter: "https://mainnet.zklighter.elliot.ai",
+};
+const TESTNET_URLS = {
+    pacifica: null, // no public testnet API
+    hyperliquid: "https://api.hyperliquid-testnet.xyz/info",
+    lighter: "https://testnet.zklighter.elliot.ai",
+};
+export let PACIFICA_API_URL = MAINNET_URLS.pacifica;
+export let HYPERLIQUID_API_URL = MAINNET_URLS.hyperliquid;
+export let LIGHTER_API_URL = MAINNET_URLS.lighter;
+/**
+ * Switch shared API URLs between mainnet and testnet.
+ * Call from CLI entry point after parsing --network flag.
+ */
+export function setSharedApiNetwork(network) {
+    if (network === "testnet") {
+        PACIFICA_API_URL = TESTNET_URLS.pacifica ?? MAINNET_URLS.pacifica;
+        HYPERLIQUID_API_URL = TESTNET_URLS.hyperliquid ?? MAINNET_URLS.hyperliquid;
+        LIGHTER_API_URL = TESTNET_URLS.lighter ?? MAINNET_URLS.lighter;
+    }
+    else {
+        PACIFICA_API_URL = MAINNET_URLS.pacifica;
+        HYPERLIQUID_API_URL = MAINNET_URLS.hyperliquid;
+        LIGHTER_API_URL = MAINNET_URLS.lighter;
+    }
+}

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

@@ -0,0 +1,44 @@
+/**
+ * Enhanced arb history statistics: exchange pair performance,
+ * time-of-day analysis, and optimal hold time calculation.
+ */
+export interface ArbTradeForStats {
+    symbol: string;
+    exchanges: string;
+    entryDate: string;
+    exitDate: string | null;
+    holdDurationMs: number;
+    entrySpread: number | null;
+    exitSpread: number | null;
+    netReturn: number;
+    status: "completed" | "open" | "failed";
+}
+export interface ExchangePairPerf {
+    pair: string;
+    trades: number;
+    winRate: number;
+    avgNetPnl: number;
+    avgHoldTime: string;
+    avgHoldTimeMs: number;
+}
+export interface TimeOfDayPerf {
+    bucket: string;
+    trades: number;
+    winRate: number;
+    avgNetPnl: number;
+}
+export interface EnhancedHistoryStats {
+    avgEntrySpread: number;
+    avgExitSpread: number;
+    avgSpreadDecay: number;
+    byExchangePair: ExchangePairPerf[];
+    byTimeOfDay: TimeOfDayPerf[];
+    optimalHoldTime: string | null;
+    optimalHoldTimeMs: number | null;
+}
+/** Normalize exchange pair string to a short abbreviation like "HL/PAC" */
+export declare function normalizeExchangePair(exchanges: string): string;
+/** Get 4-hour UTC time bucket for a timestamp */
+export declare function getTimeBucket(isoTimestamp: string): string;
+/** Compute enhanced statistics from a list of trades */
+export declare function computeEnhancedStats(trades: ArbTradeForStats[]): EnhancedHistoryStats;

package/dist/arb/history-stats.js

@@ -0,0 +1,135 @@
+/**
+ * Enhanced arb history statistics: exchange pair performance,
+ * time-of-day analysis, and optimal hold time calculation.
+ */
+const EXCHANGE_ABBREVS = {
+    hyperliquid: "HL",
+    pacifica: "PAC",
+    lighter: "LT",
+};
+function abbrevExchange(name) {
+    return EXCHANGE_ABBREVS[name.toLowerCase()] ?? name.toUpperCase().slice(0, 3);
+}
+/** Normalize exchange pair string to a short abbreviation like "HL/PAC" */
+export function normalizeExchangePair(exchanges) {
+    // exchanges format: "hyperliquid+pacifica" or "lighter+hyperliquid"
+    const parts = exchanges.split("+").map(e => abbrevExchange(e.trim()));
+    parts.sort(); // alphabetical for consistency
+    return parts.join("/");
+}
+/** Get 4-hour UTC time bucket for a timestamp */
+export function getTimeBucket(isoTimestamp) {
+    const date = new Date(isoTimestamp);
+    const hour = date.getUTCHours();
+    const bucketStart = Math.floor(hour / 4) * 4;
+    const bucketEnd = bucketStart + 4;
+    return `${String(bucketStart).padStart(2, "0")}-${String(bucketEnd).padStart(2, "0")} UTC`;
+}
+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`;
+}
+/** Compute enhanced statistics from a list of trades */
+export function computeEnhancedStats(trades) {
+    const completed = trades.filter(t => t.status === "completed");
+    // Average entry/exit spreads
+    const entrySpreads = completed
+        .map(t => t.entrySpread)
+        .filter((s) => s !== null);
+    const exitSpreads = completed
+        .map(t => t.exitSpread)
+        .filter((s) => s !== null);
+    const avgEntrySpread = entrySpreads.length > 0
+        ? entrySpreads.reduce((s, v) => s + v, 0) / entrySpreads.length
+        : 0;
+    const avgExitSpread = exitSpreads.length > 0
+        ? exitSpreads.reduce((s, v) => s + v, 0) / exitSpreads.length
+        : 0;
+    // Average spread decay: how much spread typically decays from entry to exit
+    const spreadDecays = [];
+    for (const t of completed) {
+        if (t.entrySpread !== null && t.exitSpread !== null) {
+            spreadDecays.push(t.entrySpread - t.exitSpread);
+        }
+    }
+    const avgSpreadDecay = spreadDecays.length > 0
+        ? spreadDecays.reduce((s, v) => s + v, 0) / spreadDecays.length
+        : 0;
+    // ── By Exchange Pair ──
+    const pairMap = new Map();
+    for (const t of completed) {
+        const pair = normalizeExchangePair(t.exchanges);
+        if (!pairMap.has(pair))
+            pairMap.set(pair, []);
+        pairMap.get(pair).push(t);
+    }
+    const byExchangePair = [];
+    for (const [pair, pairTrades] of pairMap) {
+        const wins = pairTrades.filter(t => t.netReturn > 0).length;
+        const avgPnl = pairTrades.reduce((s, t) => s + t.netReturn, 0) / pairTrades.length;
+        const avgHoldMs = pairTrades.reduce((s, t) => s + t.holdDurationMs, 0) / pairTrades.length;
+        byExchangePair.push({
+            pair,
+            trades: pairTrades.length,
+            winRate: (wins / pairTrades.length) * 100,
+            avgNetPnl: avgPnl,
+            avgHoldTime: formatDuration(avgHoldMs),
+            avgHoldTimeMs: avgHoldMs,
+        });
+    }
+    // Sort by trade count descending
+    byExchangePair.sort((a, b) => b.trades - a.trades);
+    // ── By Time of Day ──
+    const bucketMap = new Map();
+    for (const t of completed) {
+        const bucket = getTimeBucket(t.entryDate);
+        if (!bucketMap.has(bucket))
+            bucketMap.set(bucket, []);
+        bucketMap.get(bucket).push(t);
+    }
+    const byTimeOfDay = [];
+    // Ensure all 6 buckets are represented (even if empty) for completeness
+    const allBuckets = ["00-04 UTC", "04-08 UTC", "08-12 UTC", "12-16 UTC", "16-20 UTC", "20-24 UTC"];
+    for (const bucket of allBuckets) {
+        const bucketTrades = bucketMap.get(bucket) ?? [];
+        if (bucketTrades.length === 0)
+            continue; // skip empty buckets in output
+        const wins = bucketTrades.filter(t => t.netReturn > 0).length;
+        const avgPnl = bucketTrades.reduce((s, t) => s + t.netReturn, 0) / bucketTrades.length;
+        byTimeOfDay.push({
+            bucket,
+            trades: bucketTrades.length,
+            winRate: (wins / bucketTrades.length) * 100,
+            avgNetPnl: avgPnl,
+        });
+    }
+    // ── Optimal Hold Time ──
+    // Median hold time of profitable completed trades
+    const profitableHoldTimes = completed
+        .filter(t => t.netReturn > 0)
+        .map(t => t.holdDurationMs)
+        .sort((a, b) => a - b);
+    let optimalHoldTimeMs = null;
+    if (profitableHoldTimes.length > 0) {
+        const mid = Math.floor(profitableHoldTimes.length / 2);
+        optimalHoldTimeMs = profitableHoldTimes.length % 2 === 0
+            ? (profitableHoldTimes[mid - 1] + profitableHoldTimes[mid]) / 2
+            : profitableHoldTimes[mid];
+    }
+    return {
+        avgEntrySpread,
+        avgExitSpread,
+        avgSpreadDecay,
+        byExchangePair,
+        byTimeOfDay,
+        optimalHoldTime: optimalHoldTimeMs !== null ? formatDuration(optimalHoldTimeMs) : null,
+        optimalHoldTimeMs,
+    };
+}

package/dist/arb/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./sizing.js";
+export * from "./utils.js";
+export * from "./state.js";
+export * from "./history-stats.js";

package/dist/arb/index.js

@@ -0,0 +1,4 @@
+export * from "./sizing.js";
+export * from "./utils.js";
+export * from "./state.js";
+export * from "./history-stats.js";

package/dist/arb/sizing.d.ts

@@ -0,0 +1,23 @@
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+/**
+ * Calculate the exact same size for both legs of an arb position,
+ * respecting both exchanges' minimum order and size precision constraints.
+ *
+ * @returns size string that works for both exchanges, or null if not viable
+ */
+export declare function computeMatchedSize(sizeUsd: number, price: number, longExchange: string, shortExchange: string): {
+    size: string;
+    notional: number;
+} | null;
+/**
+ * After both legs are submitted, verify actual fills match.
+ * If there's a size mismatch, place a correction order on the larger side.
+ *
+ * @returns the corrected size, or null if already matched
+ */
+export declare function reconcileArbFills(longAdapter: ExchangeAdapter, shortAdapter: ExchangeAdapter, symbol: string, log?: (msg: string) => void): Promise<{
+    matched: boolean;
+    longSize: number;
+    shortSize: number;
+    correction?: string;
+}>;