perp-cli 0.3.3

package/dist/arb/sizing.js

@@ -0,0 +1,96 @@
+/**
+ * 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 function computeMatchedSize(sizeUsd, price, longExchange, shortExchange) {
+    if (price <= 0)
+        return null;
+    const rawSize = sizeUsd / price;
+    // Size decimals per exchange (conservative defaults)
+    const szDecimals = Math.min(getSizeDecimals(longExchange), getSizeDecimals(shortExchange));
+    // Round DOWN to the least precise exchange's decimals
+    const factor = Math.pow(10, szDecimals);
+    const roundedSize = Math.floor(rawSize * factor) / factor;
+    if (roundedSize <= 0)
+        return null;
+    // Verify notional meets minimum for both exchanges
+    const notional = roundedSize * price;
+    const minNotional = Math.max(getMinNotional(longExchange), getMinNotional(shortExchange));
+    if (notional < minNotional) {
+        // Try rounding UP instead
+        const roundedUp = Math.ceil(rawSize * factor) / factor;
+        const notionalUp = roundedUp * price;
+        // Only round up if the increase is small (< 20% over requested)
+        if (notionalUp <= sizeUsd * 1.2) {
+            return { size: roundedUp.toFixed(szDecimals), notional: notionalUp };
+        }
+        return null; // Can't meet minimum
+    }
+    return { size: roundedSize.toFixed(szDecimals), notional };
+}
+/** Size decimal precision by exchange */
+function getSizeDecimals(exchange) {
+    switch (exchange.toLowerCase()) {
+        case "hyperliquid": return 1; // Most HL perps use 1 decimal
+        case "lighter": return 2;
+        case "pacifica": return 4;
+        default: return 2;
+    }
+}
+/** Minimum notional (USD) per exchange */
+function getMinNotional(exchange) {
+    switch (exchange.toLowerCase()) {
+        case "hyperliquid": return 10;
+        case "lighter": return 10;
+        case "pacifica": return 1;
+        default: return 10;
+    }
+}
+/**
+ * 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 async function reconcileArbFills(longAdapter, shortAdapter, symbol, log) {
+    const [longPositions, shortPositions] = await Promise.all([
+        longAdapter.getPositions(),
+        shortAdapter.getPositions(),
+    ]);
+    const longPos = longPositions.find(p => p.symbol.replace("-PERP", "").toUpperCase() === symbol.toUpperCase() && p.side === "long");
+    const shortPos = shortPositions.find(p => p.symbol.replace("-PERP", "").toUpperCase() === symbol.toUpperCase() && p.side === "short");
+    const longSize = longPos ? Math.abs(Number(longPos.size)) : 0;
+    const shortSize = shortPos ? Math.abs(Number(shortPos.size)) : 0;
+    if (longSize === 0 && shortSize === 0) {
+        return { matched: true, longSize: 0, shortSize: 0 };
+    }
+    const diff = Math.abs(longSize - shortSize);
+    const maxSize = Math.max(longSize, shortSize);
+    const diffPct = maxSize > 0 ? (diff / maxSize) * 100 : 0;
+    // Allow 1% tolerance (rounding differences)
+    if (diffPct <= 1) {
+        return { matched: true, longSize, shortSize };
+    }
+    log?.(`[ARB] Size mismatch: long ${longSize} vs short ${shortSize} (diff: ${diff.toFixed(4)}, ${diffPct.toFixed(1)}%)`);
+    // Correct the larger side by reducing it
+    const correctionSize = diff.toFixed(6);
+    try {
+        if (longSize > shortSize) {
+            log?.(`[ARB] Correcting: sell ${correctionSize} ${symbol} on ${longAdapter.name} to match`);
+            await longAdapter.marketOrder(symbol, "sell", correctionSize);
+        }
+        else {
+            log?.(`[ARB] Correcting: buy ${correctionSize} ${symbol} on ${shortAdapter.name} to match`);
+            await shortAdapter.marketOrder(symbol, "buy", correctionSize);
+        }
+        log?.(`[ARB] Sizes reconciled`);
+        return { matched: true, longSize: Math.min(longSize, shortSize), shortSize: Math.min(longSize, shortSize), correction: correctionSize };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log?.(`[ARB] Correction failed: ${msg}`);
+        return { matched: false, longSize, shortSize };
+    }
+}

package/dist/arb/state.d.ts

@@ -0,0 +1,51 @@
+export declare function setStateFilePath(path: string): void;
+export declare function resetStateFilePath(): void;
+export interface ArbPositionState {
+    id: string;
+    symbol: string;
+    longExchange: string;
+    shortExchange: string;
+    longSize: number;
+    shortSize: number;
+    entryTime: string;
+    entrySpread: number;
+    entryLongPrice: number;
+    entryShortPrice: number;
+    accumulatedFunding: number;
+    lastCheckTime: string;
+}
+export interface ArbDaemonState {
+    version: 1;
+    lastStartTime: string;
+    lastScanTime: string;
+    lastSuccessfulScanTime: string;
+    positions: ArbPositionState[];
+    config: {
+        minSpread: number;
+        closeSpread: number;
+        size: number | "auto";
+        holdDays: number;
+        bridgeCost: number;
+        maxPositions: number;
+        settleStrategy: string;
+        notifyUrl?: string;
+    };
+}
+/** Load daemon state from disk. Falls back to .tmp if main file is corrupted. */
+export declare function loadArbState(): ArbDaemonState | null;
+/**
+ * Save daemon state to disk using atomic write pattern.
+ * Writes to .tmp first, then renames to main file.
+ * If crash occurs mid-write, .tmp is partial but main file is intact.
+ */
+export declare function saveArbState(state: ArbDaemonState): void;
+/** Add a position to the persisted state. */
+export declare function addPosition(pos: ArbPositionState): void;
+/** Remove a position by symbol from the persisted state. */
+export declare function removePosition(symbol: string): void;
+/** Update a position by symbol with partial updates. */
+export declare function updatePosition(symbol: string, updates: Partial<ArbPositionState>): void;
+/** Get all persisted positions. */
+export declare function getPositions(): ArbPositionState[];
+/** Create a default empty daemon state with the given config. */
+export declare function createInitialState(config: ArbDaemonState["config"]): ArbDaemonState;

package/dist/arb/state.js

@@ -0,0 +1,112 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from "fs";
+import { resolve } from "path";
+const PERP_DIR = resolve(process.env.HOME || "~", ".perp");
+const STATE_FILE = resolve(PERP_DIR, "arb-state.json");
+// Allow overriding the state file path for testing
+let stateFilePath = STATE_FILE;
+export function setStateFilePath(path) {
+    stateFilePath = path;
+}
+export function resetStateFilePath() {
+    stateFilePath = STATE_FILE;
+}
+function ensureDir() {
+    const dir = resolve(stateFilePath, "..");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+}
+/** Load daemon state from disk. Falls back to .tmp if main file is corrupted. */
+export function loadArbState() {
+    const tmpPath = stateFilePath + ".tmp";
+    // Try main file first
+    if (existsSync(stateFilePath)) {
+        try {
+            const raw = readFileSync(stateFilePath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed.version === 1)
+                return parsed;
+        }
+        catch {
+            // Main file corrupted — try .tmp fallback
+        }
+    }
+    // Fallback: recover from .tmp if main is missing or corrupted
+    if (existsSync(tmpPath)) {
+        try {
+            const raw = readFileSync(tmpPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed.version === 1) {
+                // Promote .tmp to main
+                try {
+                    renameSync(tmpPath, stateFilePath);
+                }
+                catch { /* best effort */ }
+                return parsed;
+            }
+        }
+        catch {
+            // .tmp also corrupted — give up
+        }
+    }
+    return null;
+}
+/**
+ * Save daemon state to disk using atomic write pattern.
+ * Writes to .tmp first, then renames to main file.
+ * If crash occurs mid-write, .tmp is partial but main file is intact.
+ */
+export function saveArbState(state) {
+    ensureDir();
+    const tmpPath = stateFilePath + ".tmp";
+    const json = JSON.stringify(state, null, 2);
+    writeFileSync(tmpPath, json, { mode: 0o600 });
+    renameSync(tmpPath, stateFilePath);
+}
+/** Add a position to the persisted state. */
+export function addPosition(pos) {
+    const state = loadArbState();
+    if (!state) {
+        throw new Error("No daemon state found. Initialize state before adding positions.");
+    }
+    // Avoid duplicates by symbol
+    state.positions = state.positions.filter(p => p.symbol !== pos.symbol);
+    state.positions.push(pos);
+    saveArbState(state);
+}
+/** Remove a position by symbol from the persisted state. */
+export function removePosition(symbol) {
+    const state = loadArbState();
+    if (!state)
+        return;
+    state.positions = state.positions.filter(p => p.symbol !== symbol);
+    saveArbState(state);
+}
+/** Update a position by symbol with partial updates. */
+export function updatePosition(symbol, updates) {
+    const state = loadArbState();
+    if (!state)
+        return;
+    const idx = state.positions.findIndex(p => p.symbol === symbol);
+    if (idx === -1)
+        return;
+    state.positions[idx] = { ...state.positions[idx], ...updates };
+    saveArbState(state);
+}
+/** Get all persisted positions. */
+export function getPositions() {
+    const state = loadArbState();
+    if (!state)
+        return [];
+    return state.positions;
+}
+/** Create a default empty daemon state with the given config. */
+export function createInitialState(config) {
+    return {
+        version: 1,
+        lastStartTime: new Date().toISOString(),
+        lastScanTime: new Date().toISOString(),
+        lastSuccessfulScanTime: new Date().toISOString(),
+        positions: [],
+        config,
+    };
+}

package/dist/arb/utils.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Arb utilities: settlement timing strategy, basis risk monitoring, and webhook notifications.
+ */
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export type SettleStrategy = "block" | "aggressive" | "off";
+/**
+ * Get the most recent settlement time for an exchange.
+ * @returns Date of the most recent past settlement
+ */
+export declare function getLastSettlement(exchange: string, now?: Date): Date;
+/**
+ * Get minutes since the most recent settlement for an exchange.
+ */
+export declare function getMinutesSinceSettlement(exchange: string, now?: Date): number;
+/**
+ * Compute a score boost for aggressive settlement mode.
+ * Returns a multiplier > 1.0 if within the post-settlement window, else 1.0.
+ * The boost decays linearly from 1.5x (right after settlement) to 1.0x (at windowMinutes).
+ */
+export declare function aggressiveSettleBoost(longExchange: string, shortExchange: string, windowMinutes?: number, now?: Date): number;
+/**
+ * Estimate cumulative funding between now and the next settlement.
+ *
+ * Since all three exchanges (HL, PAC, LT) settle every hour, both sides
+ * accumulate funding at the same frequency. The function estimates
+ * cumulative funding over the given time horizon.
+ *
+ * @param hlHourlyRate - HL per-hour funding rate (raw, not %)
+ * @param pacHourlyRate - PAC per-hour funding rate (raw, not %)
+ * @param positionSize - position notional in USD
+ * @param hoursUntilSettlement - hours until next settlement
+ * @returns { hlCumulative, pacPayment, netFunding } in USD (positive = you receive)
+ */
+export declare function estimateFundingUntilSettlement(hlHourlyRate: number, pacHourlyRate: number, positionSize: number, hoursUntilSettlement: number): {
+    hlCumulative: number;
+    pacPayment: number;
+    netFunding: number;
+};
+export interface BasisRisk {
+    symbol: string;
+    longExchange: string;
+    shortExchange: string;
+    longMarkPrice: number;
+    shortMarkPrice: number;
+    divergencePct: number;
+    warning: boolean;
+}
+/**
+ * Check basis risk (mark price divergence) for open arb positions.
+ * Fetches current mark prices from each exchange and computes divergence.
+ */
+export declare function checkBasisRisk(positions: Array<{
+    symbol: string;
+    longExchange: string;
+    shortExchange: string;
+}>, adapters: Map<string, ExchangeAdapter>, maxDivergencePct?: number): Promise<BasisRisk[]>;
+/**
+ * Compute basis risk from pre-fetched prices (no async, for use in tests and monitor).
+ */
+export declare function computeBasisRisk(longPrice: number, shortPrice: number, maxDivergencePct?: number): {
+    divergencePct: number;
+    warning: boolean;
+};
+export type ArbNotifyEvent = "entry" | "exit" | "reversal" | "margin" | "basis" | "heartbeat";
+/**
+ * Format a notification message for an arb event.
+ */
+export declare function formatNotifyMessage(event: ArbNotifyEvent, data: Record<string, unknown>): string;
+/**
+ * Send a notification to a webhook URL (Discord, Telegram, or generic).
+ *
+ * @param webhookUrl - The webhook URL
+ * @param event - The event type
+ * @param data - Event data
+ * @param fetchFn - Optional fetch function for testing
+ */
+export declare function sendNotification(webhookUrl: string, event: ArbNotifyEvent, data: Record<string, unknown>, fetchFn?: typeof fetch): Promise<void>;
+/**
+ * Helper to send notification only if the event is in the allowed list.
+ */
+export declare function notifyIfEnabled(webhookUrl: string | undefined, enabledEvents: ArbNotifyEvent[], event: ArbNotifyEvent, data: Record<string, unknown>, fetchFn?: typeof fetch): Promise<void>;

package/dist/arb/utils.js

@@ -0,0 +1,267 @@
+/**
+ * Arb utilities: settlement timing strategy, basis risk monitoring, and webhook notifications.
+ */
+// ── Settlement Timing Strategy ──
+/** Settlement schedules per exchange (UTC hours when settlement occurs) */
+const SETTLEMENT_SCHEDULES = {
+    hyperliquid: Array.from({ length: 24 }, (_, i) => i), // every hour
+    pacifica: Array.from({ length: 24 }, (_, i) => i), // every hour
+    lighter: Array.from({ length: 24 }, (_, i) => i), // every hour
+};
+/**
+ * Get the most recent settlement time for an exchange.
+ * @returns Date of the most recent past settlement
+ */
+export function getLastSettlement(exchange, now = new Date()) {
+    const schedule = SETTLEMENT_SCHEDULES[exchange.toLowerCase()];
+    if (!schedule || schedule.length === 0) {
+        return getLastSettlement("pacifica", now);
+    }
+    const currentHour = now.getUTCHours();
+    const currentMinutes = now.getUTCMinutes();
+    const currentSeconds = now.getUTCSeconds();
+    // Find the most recent settlement hour at or before now
+    for (let i = schedule.length - 1; i >= 0; i--) {
+        const hour = schedule[i];
+        if (hour < currentHour || (hour === currentHour && (currentMinutes > 0 || currentSeconds > 0))) {
+            const last = new Date(now);
+            last.setUTCHours(hour, 0, 0, 0);
+            return last;
+        }
+        // Exactly at settlement time
+        if (hour === currentHour && currentMinutes === 0 && currentSeconds === 0) {
+            const last = new Date(now);
+            last.setUTCHours(hour, 0, 0, 0);
+            return last;
+        }
+    }
+    // Wrap to previous day's last settlement
+    const last = new Date(now);
+    last.setUTCDate(last.getUTCDate() - 1);
+    last.setUTCHours(schedule[schedule.length - 1], 0, 0, 0);
+    return last;
+}
+/**
+ * Get minutes since the most recent settlement for an exchange.
+ */
+export function getMinutesSinceSettlement(exchange, now = new Date()) {
+    const lastSettle = getLastSettlement(exchange, now);
+    return (now.getTime() - lastSettle.getTime()) / (1000 * 60);
+}
+/**
+ * Compute a score boost for aggressive settlement mode.
+ * Returns a multiplier > 1.0 if within the post-settlement window, else 1.0.
+ * The boost decays linearly from 1.5x (right after settlement) to 1.0x (at windowMinutes).
+ */
+export function aggressiveSettleBoost(longExchange, shortExchange, windowMinutes = 10, now = new Date()) {
+    const longMinutes = getMinutesSinceSettlement(longExchange, now);
+    const shortMinutes = getMinutesSinceSettlement(shortExchange, now);
+    // Use the minimum of the two — we want BOTH exchanges to have recently settled
+    const minMinutes = Math.min(longMinutes, shortMinutes);
+    if (minMinutes <= windowMinutes) {
+        // Linear decay from 1.5 to 1.0
+        const factor = 1.0 + 0.5 * (1 - minMinutes / windowMinutes);
+        return factor;
+    }
+    return 1.0;
+}
+/**
+ * Estimate cumulative funding between now and the next settlement.
+ *
+ * Since all three exchanges (HL, PAC, LT) settle every hour, both sides
+ * accumulate funding at the same frequency. The function estimates
+ * cumulative funding over the given time horizon.
+ *
+ * @param hlHourlyRate - HL per-hour funding rate (raw, not %)
+ * @param pacHourlyRate - PAC per-hour funding rate (raw, not %)
+ * @param positionSize - position notional in USD
+ * @param hoursUntilSettlement - hours until next settlement
+ * @returns { hlCumulative, pacPayment, netFunding } in USD (positive = you receive)
+ */
+export function estimateFundingUntilSettlement(hlHourlyRate, pacHourlyRate, positionSize, hoursUntilSettlement) {
+    // Both exchanges settle every hour, so we accumulate over the same period
+    const hlCumulative = Math.abs(hlHourlyRate) * positionSize * hoursUntilSettlement;
+    // PAC also settles every hour, so cumulative over same period
+    const pacPayment = Math.abs(pacHourlyRate) * positionSize * hoursUntilSettlement;
+    // Net assumes: short high-rate exchange (receive), long low-rate (pay less)
+    // In a typical arb, we short the high-rate and long the low-rate
+    // The net is the difference we collect
+    const netFunding = hlCumulative - pacPayment;
+    return { hlCumulative, pacPayment, netFunding };
+}
+/**
+ * Check basis risk (mark price divergence) for open arb positions.
+ * Fetches current mark prices from each exchange and computes divergence.
+ */
+export async function checkBasisRisk(positions, adapters, maxDivergencePct = 3) {
+    const results = [];
+    for (const pos of positions) {
+        const longAdapter = adapters.get(pos.longExchange);
+        const shortAdapter = adapters.get(pos.shortExchange);
+        if (!longAdapter || !shortAdapter)
+            continue;
+        try {
+            const [longMarkets, shortMarkets] = await Promise.all([
+                longAdapter.getMarkets(),
+                shortAdapter.getMarkets(),
+            ]);
+            const longMarket = longMarkets.find(m => m.symbol.replace("-PERP", "").toUpperCase() === pos.symbol.toUpperCase());
+            const shortMarket = shortMarkets.find(m => m.symbol.replace("-PERP", "").toUpperCase() === pos.symbol.toUpperCase());
+            if (!longMarket || !shortMarket)
+                continue;
+            const longPrice = Number(longMarket.markPrice);
+            const shortPrice = Number(shortMarket.markPrice);
+            if (longPrice <= 0 || shortPrice <= 0)
+                continue;
+            const avgPrice = (longPrice + shortPrice) / 2;
+            const divergencePct = Math.abs(longPrice - shortPrice) / avgPrice * 100;
+            results.push({
+                symbol: pos.symbol,
+                longExchange: pos.longExchange,
+                shortExchange: pos.shortExchange,
+                longMarkPrice: longPrice,
+                shortMarkPrice: shortPrice,
+                divergencePct,
+                warning: divergencePct >= maxDivergencePct,
+            });
+        }
+        catch {
+            // Skip positions where we can't fetch prices
+        }
+    }
+    return results;
+}
+/**
+ * Compute basis risk from pre-fetched prices (no async, for use in tests and monitor).
+ */
+export function computeBasisRisk(longPrice, shortPrice, maxDivergencePct = 3) {
+    if (longPrice <= 0 || shortPrice <= 0) {
+        return { divergencePct: 0, warning: false };
+    }
+    const avgPrice = (longPrice + shortPrice) / 2;
+    const divergencePct = Math.abs(longPrice - shortPrice) / avgPrice * 100;
+    return { divergencePct, warning: divergencePct >= maxDivergencePct };
+}
+/**
+ * Format a notification message for an arb event.
+ */
+export function formatNotifyMessage(event, data) {
+    switch (event) {
+        case "entry": {
+            const symbol = data.symbol ?? "???";
+            const longExch = data.longExchange ?? "?";
+            const shortExch = data.shortExchange ?? "?";
+            const size = data.size ?? "?";
+            const netSpread = typeof data.netSpread === "number" ? data.netSpread.toFixed(1) : "?";
+            return `Entered ${symbol} arb: Long ${longExch} / Short ${shortExch}, $${size}/leg, spread ${netSpread}% net`;
+        }
+        case "exit": {
+            const symbol = data.symbol ?? "???";
+            const pnl = typeof data.pnl === "number" ? (data.pnl >= 0 ? `+$${data.pnl.toFixed(2)}` : `-$${Math.abs(data.pnl).toFixed(2)}`) : "?";
+            const duration = data.duration ?? "?";
+            return `Closed ${symbol} arb: ${pnl} net, held ${duration}`;
+        }
+        case "reversal": {
+            const symbol = data.symbol ?? "???";
+            return `REVERSAL: ${symbol} spread reversed, emergency close triggered`;
+        }
+        case "margin": {
+            const exchange = data.exchange ?? "?";
+            const marginPct = typeof data.marginPct === "number" ? data.marginPct.toFixed(1) : "?";
+            const threshold = typeof data.threshold === "number" ? data.threshold.toFixed(1) : "?";
+            return `LOW MARGIN: ${exchange} margin at ${marginPct}%, below ${threshold}% threshold`;
+        }
+        case "basis": {
+            const symbol = data.symbol ?? "???";
+            const divergence = typeof data.divergencePct === "number" ? data.divergencePct.toFixed(1) : "?";
+            const longExch = data.longExchange ?? "?";
+            const shortExch = data.shortExchange ?? "?";
+            return `BASIS RISK: ${symbol} price divergence ${divergence}% between ${longExch}/${shortExch}`;
+        }
+        case "heartbeat": {
+            const lastScan = data.lastScanTime ?? "unknown";
+            const minutesAgo = typeof data.minutesAgo === "number" ? data.minutesAgo.toFixed(0) : "?";
+            return `HEARTBEAT: No successful scan in ${minutesAgo} minutes (last: ${lastScan})`;
+        }
+        default:
+            return `Arb event: ${event} - ${JSON.stringify(data)}`;
+    }
+}
+/**
+ * Detect if a URL is a Discord webhook, Telegram bot API, or generic webhook.
+ */
+function detectWebhookType(url) {
+    if (url.includes("discord.com/api/webhooks") || url.includes("discordapp.com/api/webhooks")) {
+        return "discord";
+    }
+    if (url.includes("api.telegram.org/bot")) {
+        return "telegram";
+    }
+    return "generic";
+}
+/**
+ * Extract Telegram chat_id from a URL like:
+ *   https://api.telegram.org/bot<TOKEN>/sendMessage?chat_id=<CHAT_ID>
+ * or from the data parameter if the URL just has the bot token.
+ */
+function parseTelegramUrl(url) {
+    const urlObj = new URL(url);
+    const chatId = urlObj.searchParams.get("chat_id") || "";
+    // Remove chat_id from URL params to build clean API URL
+    urlObj.searchParams.delete("chat_id");
+    // Ensure path ends with /sendMessage
+    if (!urlObj.pathname.endsWith("/sendMessage")) {
+        urlObj.pathname = urlObj.pathname.replace(/\/$/, "") + "/sendMessage";
+    }
+    return { apiUrl: urlObj.toString(), chatId };
+}
+/**
+ * Send a notification to a webhook URL (Discord, Telegram, or generic).
+ *
+ * @param webhookUrl - The webhook URL
+ * @param event - The event type
+ * @param data - Event data
+ * @param fetchFn - Optional fetch function for testing
+ */
+export async function sendNotification(webhookUrl, event, data, fetchFn = globalThis.fetch) {
+    const message = formatNotifyMessage(event, data);
+    const type = detectWebhookType(webhookUrl);
+    try {
+        if (type === "discord") {
+            await fetchFn(webhookUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ content: message }),
+            });
+        }
+        else if (type === "telegram") {
+            const { apiUrl, chatId } = parseTelegramUrl(webhookUrl);
+            await fetchFn(apiUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ chat_id: chatId, text: message }),
+            });
+        }
+        else {
+            // Generic webhook: POST with JSON body
+            await fetchFn(webhookUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ event, message, data }),
+            });
+        }
+    }
+    catch {
+        // Silently fail — notifications should never crash the bot
+    }
+}
+/**
+ * Helper to send notification only if the event is in the allowed list.
+ */
+export async function notifyIfEnabled(webhookUrl, enabledEvents, event, data, fetchFn) {
+    if (!webhookUrl)
+        return;
+    if (enabledEvents.length > 0 && !enabledEvents.includes(event))
+        return;
+    await sendNotification(webhookUrl, event, data, fetchFn);
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Barrel re-export wrapper for backward compatibility.
+ * Actual implementation moved to src/arb/history-stats.ts.
+ */
+export * from "./arb/history-stats.js";

package/dist/arb-history-stats.js

@@ -0,0 +1,5 @@
+/**
+ * Barrel re-export wrapper for backward compatibility.
+ * Actual implementation moved to src/arb/history-stats.ts.
+ */
+export * from "./arb/history-stats.js";

package/dist/arb-sizing.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Barrel re-export wrapper for backward compatibility.
+ * Actual implementation moved to src/arb/sizing.ts.
+ */
+export * from "./arb/sizing.js";

package/dist/arb-sizing.js

@@ -0,0 +1,5 @@
+/**
+ * Barrel re-export wrapper for backward compatibility.
+ * Actual implementation moved to src/arb/sizing.ts.
+ */
+export * from "./arb/sizing.js";

package/dist/arb-state.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Barrel re-export wrapper for backward compatibility.
+ * Actual implementation moved to src/arb/state.ts.
+ */
+export * from "./arb/state.js";

package/dist/arb-state.js

@@ -0,0 +1,5 @@
+/**
+ * Barrel re-export wrapper for backward compatibility.
+ * Actual implementation moved to src/arb/state.ts.
+ */
+export * from "./arb/state.js";

package/dist/arb-utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Barrel re-export wrapper for backward compatibility.
+ * Actual implementation moved to src/arb/utils.ts.
+ */
+export * from "./arb/utils.js";

package/dist/arb-utils.js

@@ -0,0 +1,5 @@
+/**
+ * Barrel re-export wrapper for backward compatibility.
+ * Actual implementation moved to src/arb/utils.ts.
+ */
+export * from "./arb/utils.js";