openbroker 1.3.1 → 1.4.0

package/dist/info/funding-history.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env npx tsx
+// View historical funding rates for an asset on Hyperliquid
+import { getClient } from '../core/client.js';
+import { formatPercent, annualizeFundingRate, parseArgs, normalizeCoin } from '../core/utils.js';
+function printUsage() {
+    console.log(`
+Usage: openbroker funding-history --coin <symbol> [options]
+
+Options:
+  --coin <symbol>   Asset symbol (required, e.g. ETH, BTC)
+  --hours <n>       Hours of history to fetch (default: 24)
+  --json            Output as JSON (machine-readable)
+  --help, -h        Show this help
+
+Examples:
+  openbroker funding-history --coin ETH
+  openbroker funding-history --coin BTC --hours 168
+`);
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help || args.h) {
+        printUsage();
+        process.exit(0);
+    }
+    const coin = args.coin;
+    if (!coin) {
+        console.error('Error: --coin is required');
+        printUsage();
+        process.exit(1);
+    }
+    const hours = parseInt(args.hours) || 24;
+    const jsonOutput = args.json;
+    const client = getClient();
+    if (!jsonOutput) {
+        console.log(`Open Broker - ${normalizeCoin(coin)} Funding History (${hours}h)`);
+        console.log('='.repeat(40) + '\n');
+    }
+    try {
+        // Load metadata (needed for HIP-3 coin resolution)
+        await client.getMetaAndAssetCtxs();
+        if (client.isTestnet && coin.includes(':')) {
+            await client.loadSingleHip3Dex(coin.split(':')[0]);
+        }
+        const now = Date.now();
+        const startTime = now - (hours * 3_600_000);
+        const history = await client.getFundingHistory(normalizeCoin(coin), startTime);
+        if (jsonOutput) {
+            let assetId = -1;
+            try {
+                assetId = client.getAssetIndex(normalizeCoin(coin));
+            }
+            catch { /* noop */ }
+            console.log(JSON.stringify({ coin: normalizeCoin(coin), assetId, history }, null, 2));
+            return;
+        }
+        if (history.length === 0) {
+            console.log('No funding history found');
+            return;
+        }
+        // Table header
+        console.log('Time'.padEnd(20) +
+            'Funding Rate'.padEnd(16) +
+            'Annualized'.padEnd(14) +
+            'Premium');
+        console.log('─'.repeat(60));
+        let totalRate = 0;
+        for (const entry of history) {
+            const time = new Date(entry.time).toLocaleString();
+            const rate = parseFloat(entry.fundingRate);
+            const annualized = annualizeFundingRate(rate);
+            const premium = parseFloat(entry.premium);
+            totalRate += rate;
+            console.log(time.padEnd(20) +
+                formatPercent(rate, 6).padEnd(16) +
+                formatPercent(annualized).padEnd(14) +
+                formatPercent(premium, 4));
+        }
+        // Summary
+        const avgRate = totalRate / history.length;
+        const avgAnnualized = annualizeFundingRate(avgRate);
+        console.log('─'.repeat(60));
+        console.log(`Samples: ${history.length}`);
+        console.log(`Avg Hourly Rate:  ${formatPercent(avgRate, 6)}`);
+        console.log(`Avg Annualized:   ${formatPercent(avgAnnualized)}`);
+        if (avgRate > 0) {
+            console.log('Longs pay shorts');
+        }
+        else if (avgRate < 0) {
+            console.log('Shorts pay longs');
+        }
+    }
+    catch (error) {
+        console.error('Error fetching funding history:', error);
+        process.exit(1);
+    }
+}
+main();

package/dist/info/funding-scan.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env npx tsx
+export {};
+//# sourceMappingURL=funding-scan.d.ts.map

package/dist/info/funding-scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"funding-scan.d.ts","sourceRoot":"","sources":["../../scripts/info/funding-scan.ts"],"names":[],"mappings":""}

package/dist/info/funding-scan.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env npx tsx
+// Cross-dex funding rate scanner - scan all assets (main + HIP-3) for funding opportunities
+import { getClient } from '../core/client.js';
+import { formatUsd, annualizeFundingRate, parseArgs, sleep } from '../core/utils.js';
+function printUsage() {
+    console.log(`
+Usage: openbroker funding-scan [options]
+
+Scan funding rates across all dexes (main perps + HIP-3) and find opportunities.
+
+Options:
+  --threshold <n>   Min annualized funding rate % to show (default: 25)
+  --include-hip3    Include HIP-3 dex assets (default: true)
+  --main-only       Only scan main perps
+  --hip3-only       Only scan HIP-3 perps
+  --top <n>         Show top N results (default: 30)
+  --pairs           Show correlated pairs with opposing funding
+  --json            Output as JSON
+  --watch           Re-scan periodically
+  --interval <n>    Watch interval in seconds (default: 60)
+  --help, -h        Show this help
+
+Examples:
+  openbroker funding-scan
+  openbroker funding-scan --threshold 50 --pairs
+  openbroker funding-scan --hip3-only --top 20
+  openbroker funding-scan --watch --interval 120
+`);
+}
+async function scanFunding(client, options) {
+    const allPerps = await client.getAllPerpMetas();
+    const results = [];
+    for (const dexData of allPerps) {
+        const isMain = !dexData.dexName;
+        if (options.mainOnly && !isMain)
+            continue;
+        if (options.hip3Only && isMain)
+            continue;
+        for (let i = 0; i < dexData.meta.universe.length; i++) {
+            const asset = dexData.meta.universe[i];
+            const ctx = dexData.assetCtxs[i];
+            if (!ctx)
+                continue;
+            const hourlyRate = parseFloat(ctx.funding);
+            const annualizedPct = annualizeFundingRate(hourlyRate) * 100;
+            const openInterest = parseFloat(ctx.openInterest);
+            const markPx = parseFloat(ctx.markPx);
+            if (Math.abs(annualizedPct) < options.threshold)
+                continue;
+            if (openInterest < 100)
+                continue;
+            // API returns HIP-3 names already prefixed (e.g., "xyz:CL")
+            const coin = asset.name;
+            let assetId = isMain ? i : -1;
+            if (!isMain) {
+                try {
+                    assetId = client.getAssetIndex(coin);
+                }
+                catch { /* not registered */ }
+            }
+            results.push({
+                coin,
+                assetId,
+                dex: dexData.dexName ?? 'main',
+                hourlyRate,
+                annualizedPct,
+                direction: hourlyRate > 0 ? 'longs pay' : 'shorts pay',
+                openInterest,
+                markPx,
+            });
+        }
+    }
+    // Sort by absolute annualized rate
+    results.sort((a, b) => Math.abs(b.annualizedPct) - Math.abs(a.annualizedPct));
+    return results.slice(0, options.topN);
+}
+function printResults(results, showPairs) {
+    if (results.length === 0) {
+        console.log('No assets above threshold');
+        return;
+    }
+    // Table header
+    console.log('Coin'.padEnd(16) +
+        'Dex'.padEnd(8) +
+        'Annualized'.padEnd(14) +
+        'Direction'.padEnd(14) +
+        'OI'.padEnd(14) +
+        'Mark');
+    console.log('─'.repeat(75));
+    for (const r of results) {
+        const annStr = `${r.annualizedPct >= 0 ? '+' : ''}${r.annualizedPct.toFixed(1)}%`;
+        const oiStr = formatOI(r.openInterest);
+        console.log(r.coin.padEnd(16) +
+            r.dex.padEnd(8) +
+            annStr.padStart(12).padEnd(14) +
+            r.direction.padEnd(14) +
+            oiStr.padStart(12).padEnd(14) +
+            formatUsd(r.markPx));
+    }
+    // Show opposing pairs
+    if (showPairs) {
+        console.log('\nOpposing Funding Pairs:');
+        console.log('─'.repeat(75));
+        const longs = results.filter(r => r.annualizedPct > 0); // longs pay shorts
+        const shorts = results.filter(r => r.annualizedPct < 0); // shorts pay longs
+        const pairs = [];
+        for (const l of longs) {
+            for (const s of shorts) {
+                // Only pair across different dexes or correlated assets
+                const spread = l.annualizedPct + Math.abs(s.annualizedPct);
+                if (spread > 20) {
+                    pairs.push({ long: l, short: s, spread });
+                }
+            }
+        }
+        pairs.sort((a, b) => b.spread - a.spread);
+        for (const p of pairs.slice(0, 10)) {
+            console.log(`  SHORT ${p.long.coin.padEnd(14)} (${p.long.annualizedPct.toFixed(1)}%) ` +
+                `+ LONG ${p.short.coin.padEnd(14)} (${p.short.annualizedPct.toFixed(1)}%) ` +
+                `= ${p.spread.toFixed(1)}% spread`);
+        }
+        if (pairs.length === 0) {
+            console.log('  No strong opposing pairs found');
+        }
+    }
+}
+function formatOI(oi) {
+    if (oi >= 1_000_000)
+        return `$${(oi / 1_000_000).toFixed(2)}M`;
+    if (oi >= 1_000)
+        return `$${(oi / 1_000).toFixed(1)}K`;
+    return `$${oi.toFixed(0)}`;
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help || args.h) {
+        printUsage();
+        process.exit(0);
+    }
+    const threshold = args.threshold ? parseFloat(args.threshold) : 25;
+    const mainOnly = args['main-only'] ?? false;
+    const hip3Only = args['hip3-only'] ?? false;
+    const topN = parseInt(args.top) || 30;
+    const showPairs = args.pairs ?? false;
+    const outputJson = args.json ?? false;
+    const watch = args.watch ?? false;
+    const intervalSec = args.interval ? parseInt(args.interval) : 60;
+    const client = getClient();
+    if (args.verbose)
+        client.verbose = true;
+    console.log('Open Broker - Funding Rate Scanner');
+    console.log('==================================\n');
+    console.log(`Threshold: ${threshold}% annualized | Scope: ${mainOnly ? 'main only' : hip3Only ? 'HIP-3 only' : 'all dexes'}\n`);
+    if (client.isTestnet && !mainOnly) {
+        console.log('Note: Testnet — HIP-3 dexes not auto-loaded. Only main perps will be scanned.\n');
+    }
+    const options = { threshold, mainOnly, hip3Only, topN };
+    const runScan = async () => {
+        const results = await scanFunding(client, options);
+        if (outputJson) {
+            console.log(JSON.stringify(results, null, 2));
+        }
+        else {
+            printResults(results, showPairs);
+        }
+        return results;
+    };
+    await runScan();
+    if (watch) {
+        console.log(`\nWatching every ${intervalSec}s... (Ctrl+C to stop)\n`);
+        while (true) {
+            await sleep(intervalSec * 1000);
+            console.log(`\n[${new Date().toLocaleTimeString()}] Rescanning...\n`);
+            await runScan();
+        }
+    }
+}
+main().catch(err => { console.error(err); process.exit(1); });

package/dist/info/funding.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env npx tsx
+export {};
+//# sourceMappingURL=funding.d.ts.map

package/dist/info/funding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"funding.d.ts","sourceRoot":"","sources":["../../scripts/info/funding.ts"],"names":[],"mappings":""}

package/dist/info/funding.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env npx tsx
+// Get funding rates from Hyperliquid
+import { getClient } from '../core/client.js';
+import { annualizeFundingRate, parseArgs } from '../core/utils.js';
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const topN = parseInt(args.top) || 20;
+    const filterCoin = args.coin;
+    const sortBy = args.sort || 'annualized'; // annualized, hourly, oi
+    const showAll = args.all;
+    const jsonOutput = args.json;
+    const client = getClient();
+    const includeHip3 = args['include-hip3'] || args['hip3'] || (filterCoin?.includes(':') ?? false);
+    try {
+        const meta = await client.getMetaAndAssetCtxs();
+        const fundingData = [];
+        // Main dex assets
+        for (let i = 0; i < meta.meta.universe.length; i++) {
+            const asset = meta.meta.universe[i];
+            const ctx = meta.assetCtxs[i];
+            if (filterCoin && asset.name !== filterCoin)
+                continue;
+            const hourlyRate = parseFloat(ctx.funding);
+            const annualizedRate = annualizeFundingRate(hourlyRate);
+            const premium = parseFloat(ctx.premium ?? '0');
+            const openInterest = parseFloat(ctx.openInterest);
+            const markPx = parseFloat(ctx.markPx);
+            // Skip if OI is very low (unless showing all)
+            if (!showAll && openInterest < 10000)
+                continue;
+            fundingData.push({
+                coin: asset.name,
+                assetId: i,
+                hourlyRate,
+                annualizedRate,
+                premium,
+                openInterest,
+                markPx,
+            });
+        }
+        // Include HIP-3 dex assets
+        if (client.isTestnet && (includeHip3 || showAll) && !(filterCoin?.includes(':'))) {
+            console.log('Note: Testnet — HIP-3 dexes not auto-loaded. Use --coin dexName:COIN to view a specific HIP-3 asset.\n');
+        }
+        if (includeHip3 || showAll || (filterCoin && filterCoin.includes(':'))) {
+            // On testnet, load the specific dex on demand if user specified dex:COIN
+            if (client.isTestnet && filterCoin?.includes(':')) {
+                await client.loadSingleHip3Dex(filterCoin.split(':')[0]);
+            }
+            const allPerps = await client.getAllPerpMetas();
+            for (const dexData of allPerps) {
+                if (!dexData.dexName)
+                    continue; // Skip main dex (already loaded)
+                for (let i = 0; i < dexData.meta.universe.length; i++) {
+                    const asset = dexData.meta.universe[i];
+                    const ctx = dexData.assetCtxs[i];
+                    if (!ctx)
+                        continue;
+                    // API returns names already prefixed (e.g., "xyz:CL")
+                    const coinName = asset.name;
+                    if (filterCoin && coinName !== filterCoin)
+                        continue;
+                    const hourlyRate = parseFloat(ctx.funding);
+                    const annualizedRate = annualizeFundingRate(hourlyRate);
+                    const openInterest = parseFloat(ctx.openInterest);
+                    const markPx = parseFloat(ctx.markPx);
+                    if (!showAll && openInterest < 1000)
+                        continue;
+                    let assetId = -1;
+                    try {
+                        assetId = client.getAssetIndex(coinName);
+                    }
+                    catch { /* not registered */ }
+                    fundingData.push({
+                        coin: coinName,
+                        assetId,
+                        hourlyRate,
+                        annualizedRate,
+                        premium: 0,
+                        openInterest,
+                        markPx,
+                    });
+                }
+            }
+        }
+        // Sort
+        if (sortBy === 'hourly' || sortBy === 'annualized') {
+            fundingData.sort((a, b) => Math.abs(b.annualizedRate) - Math.abs(a.annualizedRate));
+        }
+        else if (sortBy === 'oi') {
+            fundingData.sort((a, b) => b.openInterest - a.openInterest);
+        }
+        // Limit
+        const displayData = filterCoin ? fundingData : fundingData.slice(0, topN);
+        if (jsonOutput) {
+            console.log(JSON.stringify(displayData, null, 2));
+            return;
+        }
+        if (displayData.length === 0) {
+            console.log(filterCoin ? `No data for ${filterCoin}` : 'No funding data available');
+            return;
+        }
+        console.log('Open Broker - Funding Rates');
+        console.log('===========================\n');
+        // Table header
+        console.log('Coin     | Hourly Rate | Annualized |   Premium   | Open Interest |    Mark');
+        console.log('---------|-------------|------------|-------------|---------------|----------');
+        for (const data of displayData) {
+            const hourlyStr = formatRate(data.hourlyRate * 100, 6);
+            const annualStr = formatRate(data.annualizedRate * 100, 2);
+            const premiumStr = formatRate(data.premium * 100, 4);
+            const oiStr = formatOI(data.openInterest);
+            const markStr = formatMark(data.markPx);
+            console.log(`${data.coin.padEnd(8)} | ${hourlyStr.padStart(11)} | ${annualStr.padStart(10)} | ` +
+                `${premiumStr.padStart(11)} | ${oiStr.padStart(13)} | ${markStr.padStart(8)}`);
+        }
+        // Legend
+        console.log('\nLegend:');
+        console.log('  Hourly Rate:  Funding rate per hour');
+        console.log('  Annualized:   Hourly × 8760 hours');
+        console.log('  Premium:      (Mark - Oracle) / Oracle');
+        console.log('  OI:           Open Interest in contracts');
+        // Highlight high funding opportunities
+        const highFunding = fundingData.filter(d => Math.abs(d.annualizedRate) > 0.25);
+        if (highFunding.length > 0 && !filterCoin) {
+            console.log('\n💰 High Funding Opportunities (>25% annualized):');
+            for (const data of highFunding.slice(0, 5)) {
+                const direction = data.annualizedRate > 0 ? 'SHORT pays LONG' : 'LONG pays SHORT';
+                console.log(`  ${data.coin}: ${formatRate(data.annualizedRate * 100, 1)}% - ${direction}`);
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error fetching funding rates:', error);
+        process.exit(1);
+    }
+}
+function formatRate(rate, decimals) {
+    const sign = rate >= 0 ? '+' : '';
+    return `${sign}${rate.toFixed(decimals)}%`;
+}
+function formatOI(oi) {
+    if (oi >= 1_000_000)
+        return `${(oi / 1_000_000).toFixed(2)}M`;
+    if (oi >= 1_000)
+        return `${(oi / 1_000).toFixed(1)}K`;
+    return oi.toFixed(0);
+}
+function formatMark(price) {
+    if (price >= 10000)
+        return `$${(price / 1000).toFixed(1)}K`;
+    if (price >= 100)
+        return `$${price.toFixed(0)}`;
+    if (price >= 1)
+        return `$${price.toFixed(2)}`;
+    return `$${price.toFixed(4)}`;
+}
+main();

package/dist/info/markets.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env npx tsx
+export {};
+//# sourceMappingURL=markets.d.ts.map

package/dist/info/markets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markets.d.ts","sourceRoot":"","sources":["../../scripts/info/markets.ts"],"names":[],"mappings":""}

package/dist/info/markets.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env npx tsx
+// Get market info from Hyperliquid
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs } from '../core/utils.js';
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const filterCoin = args.coin;
+    const topN = parseInt(args.top) || 30;
+    const sortBy = args.sort || 'volume'; // volume, oi, change
+    const jsonOutput = args.json;
+    const client = getClient();
+    const includeHip3 = args['include-hip3'] || args['hip3'] || (filterCoin?.includes(':') ?? false);
+    try {
+        const meta = await client.getMetaAndAssetCtxs();
+        const markets = [];
+        for (let i = 0; i < meta.meta.universe.length; i++) {
+            const asset = meta.meta.universe[i];
+            const ctx = meta.assetCtxs[i];
+            if (filterCoin && asset.name !== filterCoin)
+                continue;
+            const markPx = parseFloat(ctx.markPx);
+            const oraclePx = parseFloat(ctx.oraclePx);
+            const prevDayPx = parseFloat(ctx.prevDayPx);
+            const volume24h = parseFloat(ctx.dayNtlVlm);
+            const openInterest = parseFloat(ctx.openInterest);
+            const change24h = prevDayPx > 0 ? (markPx - prevDayPx) / prevDayPx : 0;
+            markets.push({
+                coin: asset.name,
+                assetId: i,
+                markPx,
+                oraclePx,
+                prevDayPx,
+                change24h,
+                volume24h,
+                openInterest,
+                maxLeverage: asset.maxLeverage,
+                szDecimals: asset.szDecimals,
+            });
+        }
+        // Include HIP-3 markets
+        if (client.isTestnet && includeHip3 && !(filterCoin?.includes(':'))) {
+            console.log('Note: Testnet — HIP-3 dexes not auto-loaded. Use --coin dexName:COIN to view a specific HIP-3 asset.\n');
+        }
+        if (includeHip3 || (filterCoin && filterCoin.includes(':'))) {
+            // On testnet, load the specific dex on demand if user specified dex:COIN
+            if (client.isTestnet && filterCoin?.includes(':')) {
+                await client.loadSingleHip3Dex(filterCoin.split(':')[0]);
+            }
+            const allPerps = await client.getAllPerpMetas();
+            for (const dexData of allPerps) {
+                if (!dexData.dexName)
+                    continue;
+                for (let i = 0; i < dexData.meta.universe.length; i++) {
+                    const asset = dexData.meta.universe[i];
+                    const ctx = dexData.assetCtxs[i];
+                    if (!ctx)
+                        continue;
+                    // API returns names already prefixed (e.g., "xyz:CL")
+                    const coinName = asset.name;
+                    if (filterCoin && coinName !== filterCoin)
+                        continue;
+                    const markPx = parseFloat(ctx.markPx);
+                    const oraclePx = parseFloat(ctx.oraclePx);
+                    const prevDayPx = parseFloat(ctx.prevDayPx);
+                    const volume24h = parseFloat(ctx.dayNtlVlm);
+                    const openInterest = parseFloat(ctx.openInterest);
+                    const change24h = prevDayPx > 0 ? (markPx - prevDayPx) / prevDayPx : 0;
+                    let assetId = -1;
+                    try {
+                        assetId = client.getAssetIndex(coinName);
+                    }
+                    catch { /* not registered */ }
+                    markets.push({
+                        coin: coinName,
+                        assetId,
+                        markPx,
+                        oraclePx,
+                        prevDayPx,
+                        change24h,
+                        volume24h,
+                        openInterest,
+                        maxLeverage: asset.maxLeverage,
+                        szDecimals: asset.szDecimals,
+                    });
+                }
+            }
+        }
+        // Sort
+        if (sortBy === 'volume') {
+            markets.sort((a, b) => b.volume24h - a.volume24h);
+        }
+        else if (sortBy === 'oi') {
+            markets.sort((a, b) => b.openInterest - a.openInterest);
+        }
+        else if (sortBy === 'change') {
+            markets.sort((a, b) => Math.abs(b.change24h) - Math.abs(a.change24h));
+        }
+        // Limit
+        const displayData = filterCoin ? markets : markets.slice(0, topN);
+        if (jsonOutput) {
+            console.log(JSON.stringify(displayData, null, 2));
+            return;
+        }
+        console.log('Open Broker - Markets');
+        console.log('=====================\n');
+        if (displayData.length === 0) {
+            console.log(filterCoin ? `No data for ${filterCoin}` : 'No market data available');
+            return;
+        }
+        if (filterCoin && displayData.length === 1) {
+            // Detailed view for single coin
+            const m = displayData[0];
+            console.log(`${m.coin}`);
+            console.log('─'.repeat(40));
+            console.log(`Mark Price:     ${formatUsd(m.markPx)}`);
+            console.log(`Oracle Price:   ${formatUsd(m.oraclePx)}`);
+            console.log(`24h Change:     ${formatChange(m.change24h)}`);
+            console.log(`24h Volume:     ${formatVolume(m.volume24h)}`);
+            console.log(`Open Interest:  ${formatVolume(m.openInterest * m.markPx)} (${formatOI(m.openInterest)} contracts)`);
+            console.log(`Max Leverage:   ${m.maxLeverage}x`);
+            console.log(`Size Decimals:  ${m.szDecimals}`);
+            console.log(`Min Size:       ${(10 ** -m.szDecimals).toFixed(m.szDecimals)}`);
+            return;
+        }
+        // Table view
+        console.log('Coin     |     Mark     |   24h Chg  |   24h Volume  |      OI       | Lev');
+        console.log('---------|--------------|------------|---------------|---------------|-----');
+        for (const m of displayData) {
+            console.log(`${m.coin.padEnd(8)} | ${formatUsd(m.markPx).padStart(12)} | ` +
+                `${formatChange(m.change24h).padStart(10)} | ` +
+                `${formatVolume(m.volume24h).padStart(13)} | ` +
+                `${formatVolume(m.openInterest * m.markPx).padStart(13)} | ` +
+                `${m.maxLeverage}x`);
+        }
+        // Top movers
+        if (!filterCoin) {
+            const gainers = [...markets].sort((a, b) => b.change24h - a.change24h).slice(0, 3);
+            const losers = [...markets].sort((a, b) => a.change24h - b.change24h).slice(0, 3);
+            console.log('\n📈 Top Gainers:');
+            for (const m of gainers) {
+                if (m.change24h <= 0)
+                    break;
+                console.log(`  ${m.coin}: ${formatChange(m.change24h)}`);
+            }
+            console.log('\n📉 Top Losers:');
+            for (const m of losers) {
+                if (m.change24h >= 0)
+                    break;
+                console.log(`  ${m.coin}: ${formatChange(m.change24h)}`);
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error fetching market data:', error);
+        process.exit(1);
+    }
+}
+function formatChange(change) {
+    const sign = change >= 0 ? '+' : '';
+    return `${sign}${(change * 100).toFixed(2)}%`;
+}
+function formatVolume(volume) {
+    if (volume >= 1_000_000_000)
+        return `$${(volume / 1_000_000_000).toFixed(2)}B`;
+    if (volume >= 1_000_000)
+        return `$${(volume / 1_000_000).toFixed(2)}M`;
+    if (volume >= 1_000)
+        return `$${(volume / 1_000).toFixed(1)}K`;
+    return `$${volume.toFixed(0)}`;
+}
+function formatOI(oi) {
+    if (oi >= 1_000_000)
+        return `${(oi / 1_000_000).toFixed(2)}M`;
+    if (oi >= 1_000)
+        return `${(oi / 1_000).toFixed(1)}K`;
+    return oi.toFixed(0);
+}
+main();

package/dist/info/order-status.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env npx tsx
+export {};
+//# sourceMappingURL=order-status.d.ts.map

package/dist/info/order-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-status.d.ts","sourceRoot":"","sources":["../../scripts/info/order-status.ts"],"names":[],"mappings":""}