perp-cli 0.3.3

package/dist/funding/history.js

@@ -0,0 +1,266 @@
+/**
+ * Historical funding rate tracking.
+ *
+ * Stores funding rate snapshots as JSONL files in ~/.perp/funding-rates/
+ * organized by month (YYYY-MM.jsonl). Provides averaging and trend analysis
+ * over configurable time windows.
+ */
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// ── Constants ──
+const DATA_DIR = join(homedir(), ".perp", "funding-rates");
+const DEDUP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+const CLEANUP_MAX_AGE_DAYS = 30;
+// ── Internal helpers ──
+function ensureDataDir() {
+    mkdirSync(DATA_DIR, { recursive: true });
+}
+function getMonthKey(date) {
+    const y = date.getFullYear();
+    const m = String(date.getMonth() + 1).padStart(2, "0");
+    return `${y}-${m}`;
+}
+function getFilePath(monthKey) {
+    return join(DATA_DIR, `${monthKey}.jsonl`);
+}
+/** Read all entries from a JSONL file, returning [] if file doesn't exist. */
+function readJsonlFile(filePath) {
+    if (!existsSync(filePath))
+        return [];
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        const entries = [];
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                entries.push(JSON.parse(trimmed));
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+/** Append entries to a JSONL file. */
+function appendToJsonl(filePath, entries) {
+    if (entries.length === 0)
+        return;
+    const lines = entries.map(e => JSON.stringify(e)).join("\n") + "\n";
+    try {
+        // Append to existing file or create new
+        const existing = existsSync(filePath) ? readFileSync(filePath, "utf-8") : "";
+        const needsNewline = existing.length > 0 && !existing.endsWith("\n");
+        writeFileSync(filePath, existing + (needsNewline ? "\n" : "") + lines);
+    }
+    catch {
+        // If append fails, try writing fresh
+        writeFileSync(filePath, lines);
+    }
+}
+/** Get entries across all relevant month files for a time range. */
+function getEntriesInRange(startTime, endTime) {
+    ensureDataDir();
+    // Determine which month files to read
+    const monthKeys = new Set();
+    const cur = new Date(startTime);
+    while (cur <= endTime) {
+        monthKeys.add(getMonthKey(cur));
+        cur.setMonth(cur.getMonth() + 1);
+        cur.setDate(1); // reset to 1st to avoid day overflow
+    }
+    // Always include the end month
+    monthKeys.add(getMonthKey(endTime));
+    const allEntries = [];
+    for (const key of monthKeys) {
+        const filePath = getFilePath(key);
+        const entries = readJsonlFile(filePath);
+        for (const entry of entries) {
+            const entryTime = new Date(entry.ts).getTime();
+            if (entryTime >= startTime.getTime() && entryTime <= endTime.getTime()) {
+                allEntries.push(entry);
+            }
+        }
+    }
+    return allEntries;
+}
+// ── Public API ──
+/**
+ * Clean up JSONL files older than 30 days.
+ * Called automatically on startup / first save.
+ */
+let _cleanupDone = false;
+export function cleanupOldFiles() {
+    if (_cleanupDone)
+        return;
+    _cleanupDone = true;
+    ensureDataDir();
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - CLEANUP_MAX_AGE_DAYS);
+    const cutoffKey = getMonthKey(cutoff);
+    try {
+        const files = readdirSync(DATA_DIR);
+        for (const file of files) {
+            if (!file.endsWith(".jsonl"))
+                continue;
+            const monthKey = file.replace(".jsonl", "");
+            // Compare YYYY-MM strings lexicographically
+            if (monthKey < cutoffKey) {
+                try {
+                    unlinkSync(join(DATA_DIR, file));
+                }
+                catch {
+                    // ignore deletion errors
+                }
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+// Export for testing
+export function _resetCleanupFlag() {
+    _cleanupDone = false;
+}
+/**
+ * Save current funding rates as a historical snapshot.
+ * Deduplicates: skips entries if same symbol+exchange was saved within 5 minutes.
+ */
+export function saveFundingSnapshot(rates) {
+    cleanupOldFiles();
+    ensureDataDir();
+    const now = new Date();
+    const monthKey = getMonthKey(now);
+    const filePath = getFilePath(monthKey);
+    const ts = now.toISOString();
+    // Read existing entries for dedup check (only current month file)
+    const existing = readJsonlFile(filePath);
+    // Build a map of latest timestamps for each symbol+exchange
+    const latestTs = new Map();
+    for (const entry of existing) {
+        const key = `${entry.symbol}:${entry.exchange}`;
+        const entryTime = new Date(entry.ts).getTime();
+        const current = latestTs.get(key) ?? 0;
+        if (entryTime > current)
+            latestTs.set(key, entryTime);
+    }
+    // Filter out rates that would be duplicates (within 5 min)
+    const nowMs = now.getTime();
+    const toSave = [];
+    for (const r of rates) {
+        if (!r.symbol)
+            continue;
+        const key = `${r.symbol.toUpperCase()}:${r.exchange}`;
+        const lastSaved = latestTs.get(key) ?? 0;
+        if (nowMs - lastSaved < DEDUP_INTERVAL_MS)
+            continue;
+        toSave.push({
+            ts,
+            symbol: r.symbol.toUpperCase(),
+            exchange: r.exchange,
+            rate: r.fundingRate,
+            hourlyRate: r.hourlyRate,
+        });
+    }
+    appendToJsonl(filePath, toSave);
+}
+/**
+ * Get average funding rate for a symbol+exchange over the last N hours.
+ * Returns null if no data available.
+ */
+export function getAvgFundingRate(symbol, exchange, hours) {
+    const endTime = new Date();
+    const startTime = new Date(endTime.getTime() - hours * 60 * 60 * 1000);
+    const entries = getEntriesInRange(startTime, endTime);
+    const filtered = entries.filter(e => e.symbol === symbol.toUpperCase() && e.exchange === exchange.toLowerCase());
+    if (filtered.length === 0)
+        return null;
+    const sum = filtered.reduce((acc, e) => acc + e.hourlyRate, 0);
+    return sum / filtered.length;
+}
+/**
+ * Get all historical rates for a symbol+exchange in a time range.
+ */
+export function getHistoricalRates(symbol, exchange, startTime, endTime) {
+    const entries = getEntriesInRange(startTime, endTime);
+    return entries
+        .filter(e => e.symbol === symbol.toUpperCase() && e.exchange === exchange.toLowerCase())
+        .map(e => ({ ts: e.ts, rate: e.rate, hourlyRate: e.hourlyRate }))
+        .sort((a, b) => new Date(a.ts).getTime() - new Date(b.ts).getTime());
+}
+/**
+ * Get averaged rates for all symbols across time windows.
+ * Returns a Map with key format "SYMBOL:exchange".
+ */
+export function getHistoricalAverages(symbols, exchanges) {
+    const result = new Map();
+    const now = new Date();
+    // Read all entries from the last 7 days (covers all windows)
+    const startTime = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+    const allEntries = getEntriesInRange(startTime, now);
+    // Group entries by symbol:exchange
+    const grouped = new Map();
+    for (const entry of allEntries) {
+        const key = `${entry.symbol}:${entry.exchange}`;
+        if (!grouped.has(key))
+            grouped.set(key, []);
+        grouped.get(key).push(entry);
+    }
+    const windows = [
+        { key: "avg1h", ms: 1 * 60 * 60 * 1000 },
+        { key: "avg8h", ms: 8 * 60 * 60 * 1000 },
+        { key: "avg24h", ms: 24 * 60 * 60 * 1000 },
+        { key: "avg7d", ms: 7 * 24 * 60 * 60 * 1000 },
+    ];
+    for (const symbol of symbols) {
+        for (const exchange of exchanges) {
+            const key = `${symbol.toUpperCase()}:${exchange.toLowerCase()}`;
+            const entries = grouped.get(key) ?? [];
+            const avgs = { avg1h: null, avg8h: null, avg24h: null, avg7d: null };
+            for (const w of windows) {
+                const cutoff = now.getTime() - w.ms;
+                const inWindow = entries.filter(e => new Date(e.ts).getTime() >= cutoff);
+                if (inWindow.length > 0) {
+                    const sum = inWindow.reduce((acc, e) => acc + e.hourlyRate, 0);
+                    avgs[w.key] = sum / inWindow.length;
+                }
+            }
+            result.set(key, avgs);
+        }
+    }
+    return result;
+}
+/**
+ * Calculate effective annualized return considering compounding frequency.
+ *
+ * All three main exchanges (HL, PAC, LT) compound every 1h (8760 times/year).
+ *
+ * Formula: (1 + rate)^(8760/compoundingHours) - 1
+ *
+ * @param hourlyRate - the per-hour funding rate
+ * @param compoundingHours - how often the exchange compounds (1 for all main exchanges)
+ * @returns effective annualized return as a decimal (not percentage)
+ */
+export function getCompoundedAnnualReturn(hourlyRate, compoundingHours) {
+    // The rate per compounding period
+    const periodRate = hourlyRate * compoundingHours;
+    // Number of compounding periods per year
+    const periodsPerYear = 8760 / compoundingHours;
+    // Compounded annual return
+    return Math.pow(1 + periodRate, periodsPerYear) - 1;
+}
+/**
+ * Get the compounding hours for an exchange.
+ * All main exchanges (HL, PAC, LT) compound every 1h.
+ */
+export function getExchangeCompoundingHours(exchange) {
+    // All main exchanges compound hourly
+    return 1;
+}

package/dist/funding/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./normalize.js";
+export * from "./rates.js";
+export * from "./history.js";

package/dist/funding/index.js

@@ -0,0 +1,3 @@
+export * from "./normalize.js";
+export * from "./rates.js";
+export * from "./history.js";

package/dist/funding/normalize.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Funding rate normalization.
+ *
+ * Exchange funding rate periods:
+ * - Hyperliquid: per 1 HOUR (settles every 1h)
+ * - Pacifica: per 1 HOUR (settles every 1h)
+ * - Lighter: per 8 HOURS (API returns 8h rate, settles every 1h)
+ *
+ * HIP-3 deployed dexes on Hyperliquid use 8h funding periods.
+ *
+ * To compare rates across exchanges, we normalize everything to
+ * a per-hour basis, then annualize from there.
+ */
+/**
+ * Get funding period in hours for an exchange.
+ * HIP-3 deployed dexes (not in the map) default to 1h (API returns hourly).
+ * HL and PAC are 1h, Lighter API returns 8h rates.
+ */
+export declare function getFundingHours(exchange: string): number;
+/** Convert a raw funding rate to per-hour rate */
+export declare function toHourlyRate(rate: number, exchange: string): number;
+/** Annualize a raw rate from a specific exchange */
+export declare function annualizeRate(rate: number, exchange: string): number;
+/** Annualize an already-normalized hourly rate (no exchange conversion needed) */
+export declare function annualizeHourlyRate(hourlyRate: number): number;
+/**
+ * Compute annualized spread between two exchange rates.
+ * Normalizes both to hourly before comparing.
+ */
+export declare function computeAnnualSpread(rateA: number, exchangeA: string, rateB: number, exchangeB: string): number;
+/**
+ * Estimate hourly funding payment for a position.
+ * @param rate - raw funding rate from the exchange
+ * @param exchange - exchange name
+ * @param positionUsd - position notional in USD
+ * @param side - "long" or "short" (longs pay positive rate, shorts receive)
+ * @returns hourly payment in USD (positive = you pay, negative = you receive)
+ */
+export declare function estimateHourlyFunding(rate: number, exchange: string, positionUsd: number, side: "long" | "short"): number;

package/dist/funding/normalize.js

@@ -0,0 +1,66 @@
+/**
+ * Funding rate normalization.
+ *
+ * Exchange funding rate periods:
+ * - Hyperliquid: per 1 HOUR (settles every 1h)
+ * - Pacifica: per 1 HOUR (settles every 1h)
+ * - Lighter: per 8 HOURS (API returns 8h rate, settles every 1h)
+ *
+ * HIP-3 deployed dexes on Hyperliquid use 8h funding periods.
+ *
+ * To compare rates across exchanges, we normalize everything to
+ * a per-hour basis, then annualize from there.
+ */
+/** Funding periods per year by convention */
+const HOURLY_PERIODS = 24 * 365; // 8760
+/** How many hours each exchange's rate covers */
+const EXCHANGE_FUNDING_HOURS = {
+    hyperliquid: 1,
+    pacifica: 1,
+    lighter: 8,
+};
+/**
+ * Get funding period in hours for an exchange.
+ * HIP-3 deployed dexes (not in the map) default to 1h (API returns hourly).
+ * HL and PAC are 1h, Lighter API returns 8h rates.
+ */
+export function getFundingHours(exchange) {
+    return EXCHANGE_FUNDING_HOURS[exchange.toLowerCase()] ?? 1;
+}
+/** Convert a raw funding rate to per-hour rate */
+export function toHourlyRate(rate, exchange) {
+    const hours = EXCHANGE_FUNDING_HOURS[exchange.toLowerCase()] ?? 1;
+    return rate / hours;
+}
+/** Annualize a raw rate from a specific exchange */
+export function annualizeRate(rate, exchange) {
+    const hourlyRate = toHourlyRate(rate, exchange);
+    return hourlyRate * HOURLY_PERIODS * 100; // as percentage
+}
+/** Annualize an already-normalized hourly rate (no exchange conversion needed) */
+export function annualizeHourlyRate(hourlyRate) {
+    return hourlyRate * HOURLY_PERIODS * 100; // as percentage
+}
+/**
+ * Compute annualized spread between two exchange rates.
+ * Normalizes both to hourly before comparing.
+ */
+export function computeAnnualSpread(rateA, exchangeA, rateB, exchangeB) {
+    const hourlyA = toHourlyRate(rateA, exchangeA);
+    const hourlyB = toHourlyRate(rateB, exchangeB);
+    return Math.abs(hourlyA - hourlyB) * HOURLY_PERIODS * 100;
+}
+/**
+ * Estimate hourly funding payment for a position.
+ * @param rate - raw funding rate from the exchange
+ * @param exchange - exchange name
+ * @param positionUsd - position notional in USD
+ * @param side - "long" or "short" (longs pay positive rate, shorts receive)
+ * @returns hourly payment in USD (positive = you pay, negative = you receive)
+ */
+export function estimateHourlyFunding(rate, exchange, positionUsd, side) {
+    const hourlyRate = toHourlyRate(rate, exchange);
+    // Long pays positive funding, short receives positive funding
+    const multiplier = side === "long" ? 1 : -1;
+    return hourlyRate * positionUsd * multiplier;
+}

package/dist/funding/rates.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Real-time 3-DEX funding rate comparison.
+ *
+ * Fetches funding rates from Pacifica, Hyperliquid, and Lighter in parallel,
+ * normalizes them to comparable hourly rates, and identifies arbitrage
+ * opportunities across exchanges.
+ */
+import { type HistoricalAverages } from "./history.js";
+export interface ExchangeFundingRate {
+    exchange: "pacifica" | "hyperliquid" | "lighter";
+    symbol: string;
+    fundingRate: number;
+    hourlyRate: number;
+    annualizedPct: number;
+    markPrice: number;
+    nextFundingTime?: number;
+    historicalAvg?: HistoricalAverages;
+}
+export interface SymbolFundingComparison {
+    symbol: string;
+    rates: ExchangeFundingRate[];
+    maxSpreadAnnual: number;
+    longExchange: string;
+    shortExchange: string;
+    bestMarkPrice: number;
+    estHourlyIncomeUsd: number;
+}
+export interface FundingRateSnapshot {
+    timestamp: string;
+    symbols: SymbolFundingComparison[];
+    exchangeStatus: Record<string, "ok" | "error">;
+}
+export declare const TOP_SYMBOLS: string[];
+/**
+ * Fetch funding rates from all 3 DEXs in parallel, normalize, and compare.
+ * Returns rates sorted by max spread (descending).
+ */
+export declare function fetchAllFundingRates(opts?: {
+    symbols?: string[];
+    minSpread?: number;
+}): Promise<FundingRateSnapshot>;
+/**
+ * Fetch rates for a single symbol across all exchanges.
+ */
+export declare function fetchSymbolFundingRates(symbol: string): Promise<SymbolFundingComparison | null>;

package/dist/funding/rates.js

@@ -0,0 +1,172 @@
+/**
+ * Real-time 3-DEX funding rate comparison.
+ *
+ * Fetches funding rates from Pacifica, Hyperliquid, and Lighter in parallel,
+ * normalizes them to comparable hourly rates, and identifies arbitrage
+ * opportunities across exchanges.
+ */
+import { toHourlyRate, annualizeRate, computeAnnualSpread, estimateHourlyFunding } from "./normalize.js";
+import { fetchPacificaPrices, fetchHyperliquidMeta, fetchLighterOrderBookDetails, fetchLighterFundingRates as fetchLtFundingRates, } from "../shared-api.js";
+import { getHistoricalAverages } from "./history.js";
+// ── Default top symbols to track ──
+export const TOP_SYMBOLS = [
+    "BTC", "ETH", "SOL", "DOGE", "SUI", "AVAX", "LINK", "ARB",
+    "WIF", "PEPE", "ONDO", "SEI", "TIA", "INJ", "NEAR",
+    "APT", "OP", "FIL", "AAVE", "MKR",
+];
+// ── Fetchers (using shared-api.ts) ──
+async function fetchPacificaRates() {
+    try {
+        const assets = await fetchPacificaPrices();
+        return assets.map(p => {
+            const hourly = toHourlyRate(p.funding, "pacifica");
+            return {
+                exchange: "pacifica",
+                symbol: p.symbol,
+                fundingRate: p.funding,
+                hourlyRate: hourly,
+                annualizedPct: annualizeRate(p.funding, "pacifica"),
+                markPrice: p.mark,
+                nextFundingTime: p.nextFunding,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+async function fetchHyperliquidRates() {
+    try {
+        const assets = await fetchHyperliquidMeta();
+        return assets.map(a => {
+            const hourly = toHourlyRate(a.funding, "hyperliquid");
+            return {
+                exchange: "hyperliquid",
+                symbol: a.symbol,
+                fundingRate: a.funding,
+                hourlyRate: hourly,
+                annualizedPct: annualizeRate(a.funding, "hyperliquid"),
+                markPrice: a.markPx,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+async function fetchLighterRates() {
+    try {
+        const [details, funding] = await Promise.all([
+            fetchLighterOrderBookDetails(),
+            fetchLtFundingRates(),
+        ]);
+        const priceMap = new Map(details.map(d => [d.marketId, d.lastTradePrice]));
+        const symMap = new Map(details.map(d => [d.marketId, d.symbol]));
+        return funding.map(fr => {
+            const symbol = fr.symbol || symMap.get(fr.marketId) || "";
+            const rate = fr.rate;
+            const hourly = toHourlyRate(rate, "lighter");
+            return {
+                exchange: "lighter",
+                symbol,
+                fundingRate: rate,
+                hourlyRate: hourly,
+                annualizedPct: annualizeRate(rate, "lighter"),
+                markPrice: fr.markPrice || priceMap.get(fr.marketId) || 0,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+// ── Core comparison logic ──
+/**
+ * Fetch funding rates from all 3 DEXs in parallel, normalize, and compare.
+ * Returns rates sorted by max spread (descending).
+ */
+export async function fetchAllFundingRates(opts) {
+    const exchangeStatus = {};
+    const [pacRates, hlRates, ltRates] = await Promise.all([
+        fetchPacificaRates().then(r => { exchangeStatus.pacifica = r.length > 0 ? "ok" : "error"; return r; }),
+        fetchHyperliquidRates().then(r => { exchangeStatus.hyperliquid = r.length > 0 ? "ok" : "error"; return r; }),
+        fetchLighterRates().then(r => { exchangeStatus.lighter = r.length > 0 ? "ok" : "error"; return r; }),
+    ]);
+    const allRates = [...pacRates, ...hlRates, ...ltRates];
+    // Build per-symbol rate map
+    const rateMap = new Map();
+    for (const r of allRates) {
+        if (!r.symbol)
+            continue;
+        if (opts?.symbols && !opts.symbols.includes(r.symbol.toUpperCase()))
+            continue;
+        const key = r.symbol.toUpperCase();
+        if (!rateMap.has(key))
+            rateMap.set(key, []);
+        rateMap.get(key).push(r);
+    }
+    // Attach historical averages when available
+    try {
+        const symbols = Array.from(rateMap.keys());
+        const exchanges = ["pacifica", "hyperliquid", "lighter"];
+        const historicals = getHistoricalAverages(symbols, exchanges);
+        for (const [, rates] of rateMap) {
+            for (const r of rates) {
+                const key = `${r.symbol.toUpperCase()}:${r.exchange}`;
+                const avg = historicals.get(key);
+                if (avg)
+                    r.historicalAvg = avg;
+            }
+        }
+    }
+    catch {
+        // Non-critical
+    }
+    const comparisons = [];
+    const minSpread = opts?.minSpread ?? 0;
+    for (const [symbol, rates] of rateMap) {
+        // Need at least 2 exchanges to compare
+        if (rates.length < 2)
+            continue;
+        // Sort by hourly rate (ascending)
+        rates.sort((a, b) => a.hourlyRate - b.hourlyRate);
+        const lowest = rates[0];
+        const highest = rates[rates.length - 1];
+        const maxSpreadAnnual = computeAnnualSpread(highest.fundingRate, highest.exchange, lowest.fundingRate, lowest.exchange);
+        if (maxSpreadAnnual < minSpread)
+            continue;
+        // Best mark price: prefer HL (most liquid), then PAC, then LT
+        const hlRate = rates.find(r => r.exchange === "hyperliquid");
+        const pacRate = rates.find(r => r.exchange === "pacifica");
+        const ltRate = rates.find(r => r.exchange === "lighter");
+        const bestMarkPrice = hlRate?.markPrice || pacRate?.markPrice || ltRate?.markPrice || 0;
+        // Estimate hourly income for $1000 notional arb
+        const notional = 1000;
+        const longIncome = estimateHourlyFunding(lowest.fundingRate, lowest.exchange, notional, "long");
+        const shortIncome = estimateHourlyFunding(highest.fundingRate, highest.exchange, notional, "short");
+        const estHourlyIncomeUsd = -(longIncome + shortIncome); // negate because income = -cost
+        comparisons.push({
+            symbol,
+            rates,
+            maxSpreadAnnual,
+            longExchange: lowest.exchange, // long where funding is lowest
+            shortExchange: highest.exchange, // short where funding is highest
+            bestMarkPrice,
+            estHourlyIncomeUsd,
+        });
+    }
+    // Sort by spread descending
+    comparisons.sort((a, b) => b.maxSpreadAnnual - a.maxSpreadAnnual);
+    return {
+        timestamp: new Date().toISOString(),
+        symbols: comparisons,
+        exchangeStatus,
+    };
+}
+/**
+ * Fetch rates for a single symbol across all exchanges.
+ */
+export async function fetchSymbolFundingRates(symbol) {
+    const snapshot = await fetchAllFundingRates({ symbols: [symbol.toUpperCase()] });
+    return snapshot.symbols[0] ?? null;
+}

package/dist/funding-history.d.ts

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

package/dist/funding-history.js

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

package/dist/funding-rates.d.ts

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

package/dist/funding-rates.js

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

package/dist/funding.d.ts

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

package/dist/funding.js

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

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};