openbroker 1.3.1 → 1.4.0

package/dist/info/all-markets.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env tsx
+// All Markets - View all available markets across perps, HIP-3, spot, and HIP-4 outcomes
+import { getClient } from '../core/client.js';
+function parseArgs() {
+    const args = { type: 'all' };
+    for (let i = 2; i < process.argv.length; i++) {
+        const arg = process.argv[i];
+        if (arg === '--type' && process.argv[i + 1]) {
+            const val = process.argv[++i].toLowerCase();
+            if (['perp', 'spot', 'hip3', 'outcome', 'all'].includes(val)) {
+                args.type = val;
+            }
+        }
+        else if (arg === '--top' && process.argv[i + 1]) {
+            args.top = parseInt(process.argv[++i], 10);
+        }
+        else if (arg === '--verbose') {
+            args.verbose = true;
+        }
+        else if (arg === '--json') {
+            args.json = true;
+        }
+        else if (arg === '--help' || arg === '-h') {
+            console.log(`
+All Markets - View all available markets on Hyperliquid
+
+Usage: npx tsx scripts/info/all-markets.ts [options]
+
+Options:
+  --type <type>    Market type: perp, spot, hip3, outcome, or all (default: all)
+  --top <n>        Show only top N markets by volume
+  --json           Output as JSON (machine-readable)
+  --verbose        Show detailed output
+  --help           Show this help
+
+Examples:
+  npx tsx scripts/info/all-markets.ts                 # Show all markets
+  npx tsx scripts/info/all-markets.ts --type perp    # Show only main perps
+  npx tsx scripts/info/all-markets.ts --type hip3    # Show only HIP-3 perps
+  npx tsx scripts/info/all-markets.ts --type spot    # Show only spot markets
+  npx tsx scripts/info/all-markets.ts --type outcome # Show only HIP-4 outcomes
+  npx tsx scripts/info/all-markets.ts --top 20       # Show top 20 by volume
+  npx tsx scripts/info/all-markets.ts --json         # JSON output
+`);
+            process.exit(0);
+        }
+    }
+    return args;
+}
+function formatVolume(vol) {
+    if (vol >= 1_000_000_000)
+        return `$${(vol / 1_000_000_000).toFixed(2)}B`;
+    if (vol >= 1_000_000)
+        return `$${(vol / 1_000_000).toFixed(2)}M`;
+    if (vol >= 1_000)
+        return `$${(vol / 1_000).toFixed(2)}K`;
+    return `$${vol.toFixed(2)}`;
+}
+function formatPrice(price) {
+    const p = typeof price === 'string' ? parseFloat(price) : price;
+    if (p >= 1000)
+        return p.toFixed(2);
+    if (p >= 1)
+        return p.toFixed(4);
+    if (p >= 0.01)
+        return p.toFixed(6);
+    return p.toFixed(8);
+}
+function formatFunding(rate) {
+    const r = parseFloat(rate);
+    const annualized = r * 24 * 365 * 100;
+    const sign = annualized >= 0 ? '+' : '';
+    return `${sign}${annualized.toFixed(2)}%`;
+}
+function handleMarketFetchError(kind, error, requestedType, verbose) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (requestedType === kind) {
+        throw new Error(`Failed to fetch ${kind} markets: ${message}`);
+    }
+    if (verbose) {
+        console.error(`Failed to fetch ${kind} markets:`, error);
+    }
+}
+async function main() {
+    const args = parseArgs();
+    const client = getClient();
+    client.verbose = args.verbose ?? false;
+    if (!args.json) {
+        console.log('Fetching market data...\n');
+    }
+    const allMarkets = [];
+    // Fetch main perps
+    if (args.type === 'all' || args.type === 'perp') {
+        const meta = await client.getMetaAndAssetCtxs();
+        for (let i = 0; i < meta.meta.universe.length; i++) {
+            const asset = meta.meta.universe[i];
+            const ctx = meta.assetCtxs[i];
+            allMarkets.push({
+                type: 'perp',
+                provider: 'Hyperliquid',
+                coin: asset.name,
+                assetId: i,
+                price: ctx.markPx,
+                volume24h: parseFloat(ctx.dayNtlVlm),
+                funding: ctx.funding,
+                maxLeverage: asset.maxLeverage,
+            });
+        }
+    }
+    // Fetch HIP-3 perps
+    if (args.type === 'all' || args.type === 'hip3') {
+        if (client.isTestnet && !args.json) {
+            console.log('Note: Testnet — HIP-3 dexes not auto-loaded. Use "dexName:COIN" syntax to load a specific dex.\n');
+        }
+        try {
+            const allPerpMetas = await client.getAllPerpMetas();
+            // Skip index 0 (main dex), process HIP-3 dexs
+            for (let dexIdx = 1; dexIdx < allPerpMetas.length; dexIdx++) {
+                const dexData = allPerpMetas[dexIdx];
+                if (!dexData || !dexData.meta?.universe)
+                    continue;
+                for (let i = 0; i < dexData.meta.universe.length; i++) {
+                    const asset = dexData.meta.universe[i];
+                    const ctx = dexData.assetCtxs[i];
+                    if (!asset || !ctx)
+                        continue;
+                    let assetId = -1;
+                    try {
+                        assetId = client.getAssetIndex(asset.name);
+                    }
+                    catch { /* not registered */ }
+                    allMarkets.push({
+                        type: 'hip3',
+                        provider: dexData.dexName || `HIP-3 DEX ${dexIdx}`,
+                        coin: asset.name,
+                        assetId,
+                        price: ctx.markPx,
+                        volume24h: parseFloat(ctx.dayNtlVlm || '0'),
+                        funding: ctx.funding,
+                        maxLeverage: asset.maxLeverage,
+                    });
+                }
+            }
+        }
+        catch (e) {
+            console.error('Failed to fetch HIP-3 markets:', e);
+        }
+    }
+    // Fetch spot markets
+    if (args.type === 'all' || args.type === 'spot') {
+        try {
+            const spotData = await client.getSpotMetaAndAssetCtxs();
+            // contexts carry coin field that matches pair.name; not necessarily aligned by index
+            const ctxMap = new Map();
+            for (const ctx of spotData.assetCtxs) {
+                if (ctx.coin) {
+                    ctxMap.set(ctx.coin, ctx);
+                }
+            }
+            for (const pair of spotData.meta.universe) {
+                if (!pair)
+                    continue;
+                const ctx = ctxMap.get(pair.name);
+                if (!ctx)
+                    continue;
+                allMarkets.push({
+                    type: 'spot',
+                    provider: 'Spot',
+                    coin: pair.name,
+                    assetId: 10000 + pair.index,
+                    price: ctx.markPx,
+                    volume24h: parseFloat(ctx.dayNtlVlm || '0'),
+                });
+            }
+        }
+        catch (e) {
+            console.error('Failed to fetch spot markets:', e);
+        }
+    }
+    // Fetch HIP-4 outcomes
+    if (args.type === 'all' || args.type === 'outcome') {
+        try {
+            const outcomes = await client.getOutcomeMarkets();
+            for (const market of outcomes) {
+                for (const side of market.sides) {
+                    allMarkets.push({
+                        type: 'outcome',
+                        provider: 'HIP-4',
+                        coin: side.coin,
+                        assetId: side.assetId,
+                        price: side.midPx ?? side.markPx ?? '0',
+                        volume24h: parseFloat(side.dayNtlVlm || '0'),
+                        outcome: market.outcome,
+                        outcomeSide: side.name,
+                        outcomeName: market.name,
+                        tokenName: side.tokenName,
+                        parsedDescription: market.parsedDescription,
+                        description: market.description,
+                    });
+                }
+            }
+        }
+        catch (e) {
+            handleMarketFetchError('outcome', e, args.type, args.verbose);
+        }
+    }
+    // Sort by volume
+    allMarkets.sort((a, b) => b.volume24h - a.volume24h);
+    // Apply top filter
+    const markets = args.top ? allMarkets.slice(0, args.top) : allMarkets;
+    if (args.json) {
+        console.log(JSON.stringify(markets, null, 2));
+        return;
+    }
+    // Group by type for display
+    const perps = markets.filter((m) => m.type === 'perp');
+    const hip3 = markets.filter((m) => m.type === 'hip3');
+    const spots = markets.filter((m) => m.type === 'spot');
+    const outcomes = markets.filter((m) => m.type === 'outcome');
+    // Print summary
+    console.log('=== Market Summary ===\n');
+    console.log(`Total Markets: ${allMarkets.length}`);
+    console.log(`  - Main Perps: ${perps.length}`);
+    console.log(`  - HIP-3 Perps: ${hip3.length}`);
+    console.log(`  - Spot Markets: ${spots.length}`);
+    console.log(`  - HIP-4 Outcomes: ${outcomes.length}`);
+    console.log();
+    // Print perps
+    if (perps.length > 0) {
+        console.log('=== Main Perpetuals ===\n');
+        console.log('Coin           AssetID    Price            24h Volume    Funding (Ann.)  Leverage');
+        console.log('-'.repeat(87));
+        for (const m of perps) {
+            console.log(`${m.coin.padEnd(14)} ${String(m.assetId).padStart(7)}    ${formatPrice(m.price).padStart(16)} ${formatVolume(m.volume24h).padStart(13)} ${(m.funding ? formatFunding(m.funding) : '-').padStart(14)} ${(m.maxLeverage ? `${m.maxLeverage}x` : '-').padStart(9)}`);
+        }
+        console.log();
+    }
+    // Print HIP-3 markets
+    if (hip3.length > 0) {
+        console.log('=== HIP-3 Perpetuals ===\n');
+        console.log('Coin           Provider         AssetID    Price            24h Volume    Funding (Ann.)');
+        console.log('-'.repeat(92));
+        for (const m of hip3) {
+            console.log(`${m.coin.padEnd(14)} ${m.provider.padEnd(16)} ${String(m.assetId).padStart(7)}    ${formatPrice(m.price).padStart(16)} ${formatVolume(m.volume24h).padStart(13)} ${(m.funding ? formatFunding(m.funding) : '-').padStart(14)}`);
+        }
+        console.log();
+    }
+    // Print spot markets
+    if (spots.length > 0) {
+        console.log('=== Spot Markets ===\n');
+        console.log('Pair           AssetID    Price            24h Volume');
+        console.log('-'.repeat(62));
+        for (const m of spots) {
+            console.log(`${m.coin.padEnd(14)} ${String(m.assetId).padStart(7)}    ${formatPrice(m.price).padStart(16)} ${formatVolume(m.volume24h).padStart(13)}`);
+        }
+        console.log();
+    }
+    // Print HIP-4 outcome markets
+    if (outcomes.length > 0) {
+        console.log('=== HIP-4 Outcomes ===\n');
+        console.log('Coin           Outcome   Side      AssetID    Price       24h Volume');
+        console.log('-'.repeat(78));
+        for (const m of outcomes) {
+            console.log(`${m.coin.padEnd(14)} ${String(m.outcome ?? '-').padStart(7)}   ${(m.outcomeSide ?? '-').padEnd(8)} ${String(m.assetId).padStart(9)}    ${formatPrice(m.price).padStart(7)} ${formatVolume(m.volume24h).padStart(13)}`);
+        }
+        console.log();
+    }
+}
+main().catch((e) => {
+    console.error('Error:', e.message);
+    process.exit(1);
+});

package/dist/info/candles.d.ts

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

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

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

package/dist/info/candles.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env npx tsx
+// View OHLCV candle data from Hyperliquid
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs, normalizeCoin } from '../core/utils.js';
+const VALID_INTERVALS = ['1m', '3m', '5m', '15m', '30m', '1h', '2h', '4h', '8h', '12h', '1d', '3d', '1w', '1M'];
+const INTERVAL_MS = {
+    '1m': 60_000, '3m': 180_000, '5m': 300_000, '15m': 900_000, '30m': 1_800_000,
+    '1h': 3_600_000, '2h': 7_200_000, '4h': 14_400_000, '8h': 28_800_000, '12h': 43_200_000,
+    '1d': 86_400_000, '3d': 259_200_000, '1w': 604_800_000, '1M': 2_592_000_000,
+};
+function printUsage() {
+    console.log(`
+Usage: openbroker candles --coin <symbol> [options]
+
+Options:
+  --coin <symbol>      Asset symbol (required, e.g. ETH, BTC)
+  --interval <interval> Candle interval (default: 1h)
+                       Valid: ${VALID_INTERVALS.join(', ')}
+  --bars <n>           Number of bars to fetch (default: 24)
+  --json               Output as JSON (machine-readable)
+  --help, -h           Show this help
+
+Examples:
+  openbroker candles --coin ETH
+  openbroker candles --coin BTC --interval 4h --bars 48
+  openbroker candles --coin SOL --interval 1d --bars 30
+`);
+}
+function formatVolume(v) {
+    if (v >= 1_000_000_000)
+        return `$${(v / 1_000_000_000).toFixed(2)}B`;
+    if (v >= 1_000_000)
+        return `$${(v / 1_000_000).toFixed(2)}M`;
+    if (v >= 1_000)
+        return `$${(v / 1_000).toFixed(2)}K`;
+    return formatUsd(v);
+}
+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 interval = args.interval || '1h';
+    if (!VALID_INTERVALS.includes(interval)) {
+        console.error(`Error: invalid interval "${interval}". Valid: ${VALID_INTERVALS.join(', ')}`);
+        process.exit(1);
+    }
+    const bars = parseInt(args.bars) || 24;
+    const jsonOutput = args.json;
+    const client = getClient();
+    if (!jsonOutput) {
+        console.log(`Open Broker - ${normalizeCoin(coin)} Candles (${interval})`);
+        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 - (bars * (INTERVAL_MS[interval] || 3_600_000));
+        const candles = await client.getCandleSnapshot(normalizeCoin(coin), interval, startTime);
+        if (jsonOutput) {
+            let assetId = -1;
+            try {
+                assetId = client.getAssetIndex(normalizeCoin(coin));
+            }
+            catch { /* noop */ }
+            console.log(JSON.stringify({ coin: normalizeCoin(coin), assetId, interval, candles }, null, 2));
+            return;
+        }
+        if (candles.length === 0) {
+            console.log('No candle data found');
+            return;
+        }
+        // Table header
+        console.log('Time'.padEnd(20) +
+            'Open'.padEnd(14) +
+            'High'.padEnd(14) +
+            'Low'.padEnd(14) +
+            'Close'.padEnd(14) +
+            'Volume'.padEnd(12) +
+            'Trades');
+        console.log('─'.repeat(95));
+        for (const c of candles) {
+            const time = new Date(c.t).toLocaleString();
+            const vol = parseFloat(c.v);
+            console.log(time.padEnd(20) +
+                formatUsd(parseFloat(c.o)).padEnd(14) +
+                formatUsd(parseFloat(c.h)).padEnd(14) +
+                formatUsd(parseFloat(c.l)).padEnd(14) +
+                formatUsd(parseFloat(c.c)).padEnd(14) +
+                formatVolume(vol).padEnd(12) +
+                String(c.n));
+        }
+        // Summary
+        const opens = candles.map(c => parseFloat(c.o));
+        const highs = candles.map(c => parseFloat(c.h));
+        const lows = candles.map(c => parseFloat(c.l));
+        const closes = candles.map(c => parseFloat(c.c));
+        const totalVol = candles.reduce((s, c) => s + parseFloat(c.v), 0);
+        const totalTrades = candles.reduce((s, c) => s + c.n, 0);
+        console.log('─'.repeat(95));
+        console.log(`Bars: ${candles.length}  |  High: ${formatUsd(Math.max(...highs))}  |  Low: ${formatUsd(Math.min(...lows))}  |  Volume: ${formatVolume(totalVol)}  |  Trades: ${totalTrades}`);
+        console.log(`Change: ${formatUsd(closes[closes.length - 1] - opens[0])} (${((closes[closes.length - 1] - opens[0]) / opens[0] * 100).toFixed(2)}%)`);
+    }
+    catch (error) {
+        console.error('Error fetching candles:', error);
+        process.exit(1);
+    }
+}
+main();

package/dist/info/fees.d.ts

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

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

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

package/dist/info/fees.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env npx tsx
+// View fee schedule and trading volume from Hyperliquid
+import { getClient } from '../core/client.js';
+import { formatUsd, formatPercent, parseArgs } from '../core/utils.js';
+function printUsage() {
+    console.log(`
+Usage: openbroker fees [options]
+
+Options:
+  --address <0x...>  Look up another account's fees
+  --json             Output as JSON (machine-readable)
+  --help, -h         Show this help
+
+Examples:
+  openbroker fees
+  openbroker fees --json
+`);
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help || args.h) {
+        printUsage();
+        process.exit(0);
+    }
+    const targetAddress = args.address;
+    const jsonOutput = args.json;
+    const client = getClient();
+    const lookupAddress = targetAddress?.toLowerCase();
+    if (!jsonOutput) {
+        console.log('Open Broker - Fee Schedule');
+        console.log('=========================\n');
+        if (targetAddress) {
+            console.log(`Lookup: ${lookupAddress}\n`);
+        }
+    }
+    try {
+        const fees = await client.getUserFees(lookupAddress);
+        if (jsonOutput) {
+            console.log(JSON.stringify(fees, null, 2));
+            return;
+        }
+        // Fee rates
+        console.log('Fee Rates');
+        console.log('─'.repeat(40));
+        console.log(`Perp Taker (Cross):  ${formatPercent(parseFloat(fees.userCrossRate))}`);
+        console.log(`Perp Maker (Add):    ${formatPercent(parseFloat(fees.userAddRate))}`);
+        console.log(`Spot Taker (Cross):  ${formatPercent(parseFloat(fees.userSpotCrossRate))}`);
+        console.log(`Spot Maker (Add):    ${formatPercent(parseFloat(fees.userSpotAddRate))}`);
+        console.log('');
+        // Discounts
+        const refDiscount = parseFloat(fees.activeReferralDiscount);
+        if (refDiscount > 0) {
+            console.log(`Referral Discount:   ${formatPercent(refDiscount)}`);
+        }
+        if (fees.activeStakingDiscount) {
+            console.log(`Staking Discount:    ${fees.activeStakingDiscount.basisPoints} bps (${formatPercent(parseFloat(fees.activeStakingDiscount.discountRate))})`);
+        }
+        if (fees.stakingLink) {
+            console.log(`Staking Link:        ${fees.stakingLink.stakingUser} (${fees.stakingLink.status})`);
+        }
+        // Daily volumes
+        if (fees.dailyUserVlm && fees.dailyUserVlm.length > 0) {
+            console.log('\nRecent Daily Volume');
+            console.log('─'.repeat(60));
+            console.log('Date'.padEnd(14) +
+                'Cross Vol'.padEnd(18) +
+                'Add Vol'.padEnd(18) +
+                'Total');
+            console.log('─'.repeat(60));
+            // Show last 7 days
+            const recent = fees.dailyUserVlm.slice(-7);
+            for (const day of recent) {
+                const cross = parseFloat(day.userCross || '0');
+                const add = parseFloat(day.userAdd || '0');
+                console.log(day.date.padEnd(14) +
+                    formatUsd(cross).padEnd(18) +
+                    formatUsd(add).padEnd(18) +
+                    formatUsd(cross + add));
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error fetching fees:', error);
+        process.exit(1);
+    }
+}
+main();

package/dist/info/fills.d.ts

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

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

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

package/dist/info/fills.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env npx tsx
+// View trade fill history from Hyperliquid
+import { getClient } from '../core/client.js';
+import { formatUsd, parseArgs, normalizeCoin } from '../core/utils.js';
+function printUsage() {
+    console.log(`
+Usage: openbroker fills [options]
+
+Options:
+  --coin <symbol>      Filter by coin (e.g. ETH, BTC)
+  --side <buy|sell>    Filter by side
+  --top <n>            Show last N fills (default: 20)
+  --address <0x...>    Look up another account's fills
+  --help, -h           Show this help
+
+Examples:
+  openbroker fills
+  openbroker fills --coin ETH
+  openbroker fills --coin BTC --side buy --top 50
+  openbroker fills --address 0xabc... --coin ETH
+`);
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help || args.h) {
+        printUsage();
+        process.exit(0);
+    }
+    const filterCoin = args.coin;
+    const filterSide = args.side;
+    const top = parseInt(args.top) || 20;
+    const jsonOutput = args.json;
+    const targetAddress = args.address;
+    const client = getClient();
+    const lookupAddress = targetAddress?.toLowerCase();
+    try {
+        let fills = await client.getUserFills(lookupAddress);
+        if (filterCoin) {
+            fills = fills.filter(f => f.coin === normalizeCoin(filterCoin));
+        }
+        if (filterSide) {
+            const sideCode = filterSide.toLowerCase() === 'buy' ? 'B' : 'A';
+            fills = fills.filter(f => f.side === sideCode);
+        }
+        // Most recent first
+        fills.sort((a, b) => b.time - a.time);
+        fills = fills.slice(0, top);
+        if (jsonOutput) {
+            console.log(JSON.stringify(fills.map(f => ({
+                time: new Date(f.time).toISOString(),
+                coin: f.coin,
+                side: f.side === 'B' ? 'buy' : 'sell',
+                size: f.sz,
+                price: f.px,
+                fee: f.fee,
+                closedPnl: f.closedPnl,
+            })), null, 2));
+            return;
+        }
+        console.log('Open Broker - Trade Fills');
+        console.log('========================\n');
+        if (targetAddress) {
+            console.log(`Lookup: ${lookupAddress}\n`);
+        }
+        if (fills.length === 0) {
+            console.log('No fills found');
+            return;
+        }
+        // Table header
+        console.log('Time'.padEnd(20) +
+            'Coin'.padEnd(10) +
+            'Side'.padEnd(6) +
+            'Size'.padEnd(14) +
+            'Price'.padEnd(14) +
+            'Fee'.padEnd(12) +
+            'Closed PnL');
+        console.log('─'.repeat(90));
+        let totalFees = 0;
+        let totalPnl = 0;
+        for (const fill of fills) {
+            const time = new Date(fill.time).toLocaleString();
+            const side = fill.side === 'B' ? 'BUY' : 'SELL';
+            const fee = parseFloat(fill.fee);
+            const pnl = parseFloat(fill.closedPnl);
+            totalFees += fee;
+            totalPnl += pnl;
+            console.log(time.padEnd(20) +
+                fill.coin.padEnd(10) +
+                side.padEnd(6) +
+                fill.sz.padEnd(14) +
+                formatUsd(parseFloat(fill.px)).padEnd(14) +
+                formatUsd(fee).padEnd(12) +
+                formatUsd(pnl));
+        }
+        console.log('─'.repeat(90));
+        console.log(`Showing ${fills.length} fills`);
+        console.log(`Total Fees:       ${formatUsd(totalFees)}`);
+        console.log(`Total Closed PnL: ${formatUsd(totalPnl)}`);
+    }
+    catch (error) {
+        console.error('Error fetching fills:', error);
+        process.exit(1);
+    }
+}
+main();

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

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

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

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