perp-cli 0.4.2 → 0.4.9

package/dist/commands/bot.js

@@ -3,6 +3,12 @@ import { printJson, jsonOk } from "../utils.js";
 import { loadBotConfig, quickGridConfig, quickDCAConfig } from "../bot/config.js";
 import { runBot } from "../bot/engine.js";
 import { PRESETS, getPreset, getPresetsByStrategy } from "../bot/presets.js";
+import { updateJobState } from "../jobs.js";
+import { runTWAP } from "../strategies/twap.js";
+import { runFundingArb } from "../strategies/funding-arb.js";
+import { runGrid } from "../strategies/grid.js";
+import { runDCA } from "../strategies/dca.js";
+import { runTrailingStop } from "../strategies/trailing-stop.js";
 export function registerBotCommands(program, getAdapter, getAdapterFor, isJson) {
     const bot = program.command("bot").description("Automated trading bots with condition monitoring & risk management");
     // ── bot start <config> ──
@@ -326,6 +332,8 @@ export function registerBotCommands(program, getAdapter, getAdapterFor, isJson)
         console.log(chalk.gray(`  Usage: perp bot start ~/.perp/bots/eth-grid.yaml`));
         console.log(chalk.gray(`         perp bot start ~/.perp/bots/eth-grid.yaml --background\n`));
     });
+    // Strategy subcommands: twap, funding-arb, grid, dca, trailing-stop
+    registerRunSubcommands(bot, getAdapter, getAdapterFor, isJson);
 }
 function makeLog() {
     return (msg) => {
@@ -410,3 +418,202 @@ const ARB_EXAMPLE = chalk.gray(`  name: funding-arb
   risk:
     max_drawdown: 200
     max_daily_loss: 50`);
+// ── Run subcommands (twap, funding-arb, grid, dca, trailing-stop) ──
+function registerRunSubcommands(parent, getAdapter, getAdapterFor, isJson) {
+    const run = parent;
+    const twapCmd = run
+        .command("twap <symbol> <side> <size> <duration>")
+        .description("Run client-side TWAP (splits market orders over time)");
+    twapCmd
+        .option("-s, --slices <n>", "Number of slices (default: auto)")
+        .option("--job-id <id>", "Job ID (set automatically for background jobs)")
+        .action(async (symbol, side, size, duration, opts) => {
+        const s = side.toLowerCase();
+        if (s !== "buy" && s !== "sell") {
+            console.error(chalk.red("Side must be buy or sell"));
+            process.exit(1);
+        }
+        const adapter = await getAdapter();
+        const params = {
+            symbol: symbol.toUpperCase(),
+            side: s,
+            totalSize: parseFloat(size),
+            durationSec: parseInt(duration),
+            slices: opts.slices ? parseInt(opts.slices) : undefined,
+        };
+        const log = (msg) => {
+            const ts = new Date().toLocaleTimeString();
+            console.log(`${chalk.gray(ts)} ${msg}`);
+        };
+        const result = await runTWAP(adapter, params, opts.jobId, log);
+        if (isJson())
+            printJson(jsonOk(result));
+        if (opts.jobId) {
+            updateJobState(opts.jobId, { status: "done" });
+        }
+    });
+    run
+        .command("funding-arb")
+        .description("Run funding rate arbitrage monitor/executor")
+        .option("--min-spread <pct>", "Min annual spread % to enter", "10")
+        .option("--close-spread <pct>", "Close when spread drops below (%)", "5")
+        .option("--size <size>", "Position size per leg (base amount)", "0.01")
+        .option("--size-usd <usd>", "Position size per leg in USD (alternative)")
+        .option("--symbols <list>", "Comma-separated symbol filter")
+        .option("--interval <sec>", "Check interval in seconds", "60")
+        .option("--auto-execute", "Actually place trades (default: monitor only)")
+        .option("--max-positions <n>", "Max simultaneous positions", "3")
+        .option("--exchanges <list>", "Comma-separated exchanges to use", "pacifica,hyperliquid,lighter")
+        .option("--auto-rebalance", "Trigger rebalance alerts when exchange balance is low")
+        .option("--rebalance-threshold <usd>", "Rebalance when available < this ($)", "100")
+        .option("--max-drawdown <usd>", "Close all positions if total uPnL exceeds this loss ($)")
+        .option("--job-id <id>", "Job ID (set automatically for background jobs)")
+        .action(async (opts) => {
+        const exchangeNames = opts.exchanges.split(",").map((e) => e.trim());
+        const adapters = new Map();
+        for (const name of exchangeNames) {
+            try {
+                const a = await getAdapterFor(name);
+                adapters.set(name, a);
+            }
+            catch {
+                if (!isJson())
+                    console.log(chalk.yellow(`  Skipping ${name} (no credentials)`));
+            }
+        }
+        if (adapters.size < 2) {
+            console.error(chalk.red("Need at least 2 exchanges for arbitrage. Set credentials for 2+ exchanges."));
+            process.exit(1);
+        }
+        const params = {
+            minSpread: parseFloat(opts.minSpread),
+            closeSpread: parseFloat(opts.closeSpread),
+            size: opts.size,
+            sizeUsd: opts.sizeUsd ? parseFloat(opts.sizeUsd) : undefined,
+            symbols: opts.symbols ? opts.symbols.split(",").map((s) => s.trim().toUpperCase()) : undefined,
+            intervalSec: parseInt(opts.interval),
+            autoExecute: opts.autoExecute ?? false,
+            maxPositions: parseInt(opts.maxPositions),
+            autoRebalance: opts.autoRebalance ?? false,
+            rebalanceThreshold: parseFloat(opts.rebalanceThreshold),
+            maxDrawdown: opts.maxDrawdown ? parseFloat(opts.maxDrawdown) : undefined,
+        };
+        const log = (msg) => {
+            const ts = new Date().toLocaleTimeString();
+            console.log(`${chalk.gray(ts)} ${msg}`);
+        };
+        await runFundingArb(adapters, params, opts.jobId, log);
+    });
+    // ── Grid Bot ──
+    const gridCmd = run
+        .command("grid <symbol>")
+        .description("Run grid trading bot (places limit orders across a price range)");
+    gridCmd
+        .requiredOption("--upper <price>", "Upper price bound")
+        .requiredOption("--lower <price>", "Lower price bound")
+        .option("--grids <n>", "Number of grid lines", "10")
+        .option("--size <size>", "Total position size (base)", "0.1")
+        .option("--side <side>", "Grid bias: long, short, neutral", "neutral")
+        .option("--leverage <n>", "Leverage to set")
+        .option("--interval <sec>", "Check interval in seconds", "10")
+        .option("--max-runtime <sec>", "Max runtime in seconds (0 = forever)", "0")
+        .option("--trailing-stop <pct>", "Stop if equity drops by this % from peak")
+        .option("--job-id <id>", "Job ID (set automatically for background jobs)")
+        .action(async (symbol, opts) => {
+        const side = opts.side.toLowerCase();
+        if (side !== "long" && side !== "short" && side !== "neutral") {
+            console.error(chalk.red("Side must be long, short, or neutral"));
+            process.exit(1);
+        }
+        const adapter = await getAdapter();
+        const params = {
+            symbol: symbol.toUpperCase(),
+            side: side,
+            upperPrice: parseFloat(opts.upper),
+            lowerPrice: parseFloat(opts.lower),
+            grids: parseInt(opts.grids),
+            totalSize: parseFloat(opts.size),
+            leverage: opts.leverage ? parseInt(opts.leverage) : undefined,
+            intervalSec: parseInt(opts.interval),
+            maxRuntime: parseInt(opts.maxRuntime),
+            trailingStop: opts.trailingStop ? parseFloat(opts.trailingStop) : undefined,
+        };
+        const log = (msg) => {
+            const ts = new Date().toLocaleTimeString();
+            console.log(`${chalk.gray(ts)} ${msg}`);
+        };
+        const result = await runGrid(adapter, params, opts.jobId, log);
+        if (isJson())
+            printJson(jsonOk(result));
+        if (opts.jobId) {
+            updateJobState(opts.jobId, { status: "done" });
+        }
+    });
+    // ── DCA (Dollar Cost Averaging) ──
+    const dcaCmd = run
+        .command("dca <symbol> <side> <amount> <interval>")
+        .description("Run DCA strategy (periodic market orders at fixed intervals)");
+    dcaCmd
+        .option("--orders <n>", "Total number of orders (0 = unlimited)", "0")
+        .option("--price-limit <price>", "Stop buying above / selling below this price")
+        .option("--max-runtime <sec>", "Max runtime in seconds (0 = forever)", "0")
+        .option("--job-id <id>", "Job ID (set automatically for background jobs)")
+        .action(async (symbol, side, amount, interval, opts) => {
+        const s = side.toLowerCase();
+        if (s !== "buy" && s !== "sell") {
+            console.error(chalk.red("Side must be buy or sell"));
+            process.exit(1);
+        }
+        const adapter = await getAdapter();
+        const params = {
+            symbol: symbol.toUpperCase(),
+            side: s,
+            amountPerOrder: parseFloat(amount),
+            intervalSec: parseInt(interval),
+            totalOrders: parseInt(opts.orders),
+            priceLimit: opts.priceLimit ? parseFloat(opts.priceLimit) : undefined,
+            maxRuntime: parseInt(opts.maxRuntime),
+        };
+        const log = (msg) => {
+            const ts = new Date().toLocaleTimeString();
+            console.log(`${chalk.gray(ts)} ${msg}`);
+        };
+        const result = await runDCA(adapter, params, opts.jobId, log);
+        if (isJson())
+            printJson(jsonOk(result));
+        if (opts.jobId) {
+            updateJobState(opts.jobId, { status: "done" });
+        }
+    });
+    // ── Trailing Stop ──
+    const tsCmd = run
+        .command("trailing-stop <symbol>")
+        .description("Run client-side trailing stop (monitors price, closes position when trail % hit)");
+    tsCmd
+        .requiredOption("--trail <pct>", "Trail percentage")
+        .option("--interval <sec>", "Check interval in seconds", "5")
+        .option("--activation <price>", "Only start trailing after price reaches this level")
+        .option("--job-id <id>", "Job ID (set automatically for background jobs)")
+        .action(async (symbol, opts) => {
+        const sym = symbol.toUpperCase();
+        const trailPct = parseFloat(opts.trail);
+        const intervalSec = parseInt(opts.interval);
+        const activationPrice = opts.activation ? parseFloat(opts.activation) : undefined;
+        const adapter = await getAdapter();
+        const log = (msg) => {
+            const ts = new Date().toLocaleTimeString();
+            console.log(`${chalk.gray(ts)} ${msg}`);
+        };
+        const result = await runTrailingStop(adapter, {
+            symbol: sym,
+            trailPct,
+            intervalSec,
+            activationPrice,
+        }, opts.jobId, log);
+        if (isJson())
+            printJson(jsonOk(result));
+        if (opts.jobId) {
+            updateJobState(opts.jobId, { status: "done" });
+        }
+    });
+}

package/dist/commands/dex.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { HyperliquidAdapter } from "../exchanges/hyperliquid.js";
-import { printJson, jsonOk, makeTable, formatUsd, withJsonErrors } from "../utils.js";
+import { printJson, jsonOk, jsonError, makeTable, formatUsd, withJsonErrors } from "../utils.js";
 export function registerDexCommands(program, getAdapter, isJson) {
     const dex = program.command("dex").description("HIP-3 deployed perp dex commands (Hyperliquid)");
     // ── dex list ──
@@ -11,6 +11,8 @@ export function registerDexCommands(program, getAdapter, isJson) {
         await withJsonErrors(isJson(), async () => {
             const adapter = await getAdapter();
             if (!(adapter instanceof HyperliquidAdapter)) {
+                if (isJson())
+                    return printJson(jsonError("INVALID_EXCHANGE", "HIP-3 dexes are only available on Hyperliquid. Use -e hyperliquid."));
                 console.error(chalk.red("\n  HIP-3 dexes are only available on Hyperliquid. Use -e hyperliquid.\n"));
                 return;
             }
@@ -41,6 +43,8 @@ export function registerDexCommands(program, getAdapter, isJson) {
         await withJsonErrors(isJson(), async () => {
             const adapter = await getAdapter();
             if (!(adapter instanceof HyperliquidAdapter)) {
+                if (isJson())
+                    return printJson(jsonError("INVALID_EXCHANGE", "HIP-3 dexes are only available on Hyperliquid. Use -e hyperliquid."));
                 console.error(chalk.red("\n  HIP-3 dexes are only available on Hyperliquid. Use -e hyperliquid.\n"));
                 return;
             }
@@ -80,6 +84,8 @@ export function registerDexCommands(program, getAdapter, isJson) {
         await withJsonErrors(isJson(), async () => {
             const adapter = await getAdapter();
             if (!(adapter instanceof HyperliquidAdapter)) {
+                if (isJson())
+                    return printJson(jsonError("INVALID_EXCHANGE", "HIP-3 dexes are only available on Hyperliquid. Use -e hyperliquid."));
                 console.error(chalk.red("\n  HIP-3 dexes are only available on Hyperliquid. Use -e hyperliquid.\n"));
                 return;
             }

package/dist/commands/funding.d.ts

@@ -1,2 +1,3 @@
 import { Command } from "commander";
-export declare function registerFundingCommands(program: Command, isJson: () => boolean): void;
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export declare function registerFundingCommands(program: Command, isJson: () => boolean, getAdapterForExchange?: (exchange: string) => Promise<ExchangeAdapter>): void;

package/dist/commands/funding.js

@@ -1,9 +1,10 @@
 import chalk from "chalk";
-import { makeTable, formatPercent, formatUsd, printJson, jsonOk } from "../utils.js";
+import { makeTable, formatPercent, formatUsd, formatPnl, printJson, jsonOk, jsonError, withJsonErrors } from "../utils.js";
 import { fetchAllFundingRates, fetchSymbolFundingRates, TOP_SYMBOLS, } from "../funding-rates.js";
-import { annualizeHourlyRate } from "../funding.js";
+import { estimateHourlyFunding, annualizeHourlyRate, annualizeRate, toHourlyRate } from "../funding.js";
 import { saveFundingSnapshot, getHistoricalRates, getCompoundedAnnualReturn, getExchangeCompoundingHours, } from "../funding-history.js";
-export function registerFundingCommands(program, isJson) {
+const ALL_EXCHANGES = ["hyperliquid", "pacifica", "lighter"];
+export function registerFundingCommands(program, isJson, getAdapterForExchange) {
     const funding = program.command("funding").description("Funding rate comparison across exchanges");
     // ── perp funding rates ── (default: show top symbols)
     funding
@@ -38,8 +39,15 @@ export function registerFundingCommands(program, isJson) {
                 saveFundingSnapshot(allRates);
         }
         catch { /* non-critical */ }
-        if (isJson())
+        if (isJson()) {
+            // When --ndjson or --fields is used, return the symbols array directly
+            // so each symbol gets its own line / fields can be picked per element.
+            // Otherwise return the full snapshot (includes exchangeStatus metadata).
+            if (process.argv.includes("--ndjson") || process.argv.includes("--fields")) {
+                return printJson(jsonOk(snapshot.symbols));
+            }
             return printJson(jsonOk(snapshot));
+        }
         printSnapshotTable(snapshot);
         printExchangeStatus(snapshot);
         console.log(chalk.gray("  * Rates shown are current predictions. Actual settled rates may differ.\n"));
@@ -234,6 +242,205 @@ export function registerFundingCommands(program, isJson) {
             await new Promise(r => setTimeout(r, intervalSec * 1000));
         }
     });
+    // ── perp funding positions ── (funding impact on open positions)
+    funding
+        .command("positions")
+        .description("Show funding rate impact on your current positions")
+        .option("--exchanges <list>", "Comma-separated exchanges to check (default: all with keys)")
+        .action(async (opts) => {
+        if (!getAdapterForExchange) {
+            const msg = "funding positions requires adapter access";
+            if (isJson())
+                return printJson(jsonError("INTERNAL", msg));
+            console.log(chalk.red(`  ${msg}\n`));
+            return;
+        }
+        await withJsonErrors(isJson(), async () => {
+            const targetExchanges = opts.exchanges
+                ? opts.exchanges.split(",").map(s => s.trim().toLowerCase())
+                : [...ALL_EXCHANGES];
+            if (!isJson())
+                console.log(chalk.cyan("  Fetching positions and funding rates...\n"));
+            const results = [];
+            const exchangeErrors = {};
+            await Promise.all(targetExchanges.map(async (exchange) => {
+                try {
+                    const adapter = await getAdapterForExchange(exchange);
+                    const [positions, markets, fundingPayments] = await Promise.all([
+                        adapter.getPositions(),
+                        adapter.getMarkets(),
+                        adapter.getFundingPayments(100).catch(() => []),
+                    ]);
+                    if (positions.length === 0)
+                        return;
+                    // Build symbol → funding rate map
+                    const fundingMap = new Map();
+                    for (const m of markets) {
+                        const sym = m.symbol.toUpperCase().replace(/-PERP$/, "");
+                        fundingMap.set(sym, {
+                            rate: Number(m.fundingRate) || 0,
+                            markPrice: Number(m.markPrice) || 0,
+                        });
+                    }
+                    // Aggregate actual funding payments per symbol (last 24h)
+                    const now = Date.now();
+                    const dayAgo = now - 24 * 60 * 60 * 1000;
+                    const actualFunding = new Map();
+                    for (const fp of fundingPayments) {
+                        if (fp.time < dayAgo)
+                            continue;
+                        const sym = fp.symbol.toUpperCase().replace(/-PERP$/, "");
+                        const amt = Number(fp.payment) || 0;
+                        if (!actualFunding.has(sym))
+                            actualFunding.set(sym, { received: 0, paid: 0 });
+                        const entry = actualFunding.get(sym);
+                        if (amt > 0)
+                            entry.received += amt;
+                        else
+                            entry.paid += Math.abs(amt);
+                    }
+                    for (const pos of positions) {
+                        const sym = pos.symbol.toUpperCase().replace(/-PERP$/, "");
+                        const fdata = fundingMap.get(sym);
+                        const fundingRate = fdata?.rate ?? 0;
+                        const mark = Number(pos.markPrice) || fdata?.markPrice || 0;
+                        const size = Math.abs(Number(pos.size));
+                        const notionalUsd = size * mark;
+                        const hourlyRate = toHourlyRate(fundingRate, exchange);
+                        const annualPct = annualizeRate(fundingRate, exchange);
+                        const hourlyPayment = estimateHourlyFunding(fundingRate, exchange, notionalUsd, pos.side);
+                        const dailyPayment = hourlyPayment * 24;
+                        const actual = actualFunding.get(sym);
+                        const actualReceived24h = actual?.received ?? 0;
+                        const actualPaid24h = actual?.paid ?? 0;
+                        const actualNet24h = actualReceived24h - actualPaid24h;
+                        results.push({
+                            exchange,
+                            symbol: sym,
+                            side: pos.side,
+                            size: pos.size,
+                            entryPrice: pos.entryPrice,
+                            markPrice: pos.markPrice,
+                            unrealizedPnl: pos.unrealizedPnl,
+                            leverage: pos.leverage,
+                            notionalUsd,
+                            fundingRate,
+                            hourlyRate,
+                            annualPct,
+                            hourlyPayment,
+                            dailyPayment,
+                            actualReceived24h,
+                            actualPaid24h,
+                            actualNet24h,
+                        });
+                    }
+                }
+                catch (err) {
+                    exchangeErrors[exchange] = err instanceof Error ? err.message : String(err);
+                }
+            }));
+            if (results.length === 0) {
+                if (isJson()) {
+                    return printJson(jsonOk({
+                        positions: [],
+                        totals: {
+                            predicted: { hourly: 0, daily: 0 },
+                            actual24h: { net: 0 },
+                            notionalUsd: 0,
+                        },
+                        errors: exchangeErrors,
+                    }));
+                }
+                console.log(chalk.gray("  No open positions found on any exchange.\n"));
+                if (Object.keys(exchangeErrors).length > 0) {
+                    for (const [ex, err] of Object.entries(exchangeErrors)) {
+                        console.log(chalk.yellow(`  ${ex}: ${err}`));
+                    }
+                    console.log();
+                }
+                return;
+            }
+            // Sort: biggest daily payment impact first
+            results.sort((a, b) => Math.abs(b.dailyPayment) - Math.abs(a.dailyPayment));
+            const totalHourly = results.reduce((s, r) => s + r.hourlyPayment, 0);
+            const totalDaily = results.reduce((s, r) => s + r.dailyPayment, 0);
+            const totalNotional = results.reduce((s, r) => s + r.notionalUsd, 0);
+            const totalActualNet = results.reduce((s, r) => s + r.actualNet24h, 0);
+            if (isJson()) {
+                return printJson(jsonOk({
+                    positions: results.map(r => ({
+                        exchange: r.exchange,
+                        symbol: r.symbol,
+                        side: r.side,
+                        size: r.size,
+                        notionalUsd: Number(r.notionalUsd.toFixed(2)),
+                        fundingRate: r.fundingRate,
+                        annualPct: Number(r.annualPct.toFixed(2)),
+                        predicted: {
+                            hourly: Number(r.hourlyPayment.toFixed(6)),
+                            daily: Number(r.dailyPayment.toFixed(4)),
+                        },
+                        actual24h: {
+                            received: Number(r.actualReceived24h.toFixed(6)),
+                            paid: Number(r.actualPaid24h.toFixed(6)),
+                            net: Number(r.actualNet24h.toFixed(6)),
+                        },
+                        unrealizedPnl: r.unrealizedPnl,
+                    })),
+                    totals: {
+                        predicted: {
+                            hourly: Number(totalHourly.toFixed(6)),
+                            daily: Number(totalDaily.toFixed(4)),
+                        },
+                        actual24h: {
+                            net: Number(totalActualNet.toFixed(6)),
+                        },
+                        notionalUsd: Number(totalNotional.toFixed(2)),
+                    },
+                    errors: Object.keys(exchangeErrors).length > 0 ? exchangeErrors : undefined,
+                }));
+            }
+            const exAbbr = (e) => e === "pacifica" ? "PAC" : e === "hyperliquid" ? "HL" : e === "lighter" ? "LT" : e.toUpperCase();
+            console.log(chalk.cyan.bold("  Position Funding Impact\n"));
+            const rows = results.map(r => {
+                const sideColor = r.side === "long" ? chalk.green : chalk.red;
+                const rateColor = r.fundingRate > 0 ? chalk.red : r.fundingRate < 0 ? chalk.green : chalk.white;
+                // actual net: positive = received, negative = paid
+                const actualColor = r.actualNet24h > 0 ? chalk.green : r.actualNet24h < 0 ? chalk.red : chalk.gray;
+                const actualStr = r.actualNet24h !== 0
+                    ? actualColor(`${r.actualNet24h > 0 ? "+" : ""}$${r.actualNet24h.toFixed(4)}`)
+                    : chalk.gray("-");
+                return [
+                    chalk.white.bold(exAbbr(r.exchange)),
+                    chalk.white.bold(r.symbol),
+                    sideColor(r.side.toUpperCase()),
+                    `$${formatUsd(r.notionalUsd)}`,
+                    rateColor(formatPercent(r.fundingRate)),
+                    rateColor(`${r.annualPct.toFixed(1)}%`),
+                    actualStr,
+                    formatPnl(r.unrealizedPnl),
+                ];
+            });
+            console.log(makeTable(["Ex", "Symbol", "Side", "Notional", "Rate(now)", "Annual(now)", "Actual 24h", "uPnL"], rows));
+            // Summary
+            const actualNetColor = totalActualNet >= 0 ? chalk.green : chalk.red;
+            const predictColor = totalDaily >= 0 ? chalk.red : chalk.green;
+            const predictSign = totalDaily >= 0 ? "-" : "+";
+            console.log();
+            console.log(`  Total Notional:      $${formatUsd(totalNotional)}`);
+            console.log(`  Actual Net (24h):    ${actualNetColor(`${totalActualNet >= 0 ? "+" : ""}$${totalActualNet.toFixed(4)}`)}`);
+            console.log(`  Predicted (now rate): ${predictColor(`${predictSign}$${Math.abs(totalDaily).toFixed(4)}/d`)}`);
+            if (Object.keys(exchangeErrors).length > 0) {
+                console.log();
+                for (const [ex, err] of Object.entries(exchangeErrors)) {
+                    console.log(chalk.yellow(`  ${exAbbr(ex)}: ${err}`));
+                }
+            }
+            console.log(chalk.gray("\n  Actual 24h: real funding received/paid in the last 24 hours."));
+            console.log(chalk.gray("  Predicted: based on current rate only (changes every hour)."));
+            console.log(chalk.gray("  + = received, - = paid\n"));
+        });
+    });
 }
 // ── Display helpers ──
 function formatAvgRate(rate) {

package/dist/commands/funds.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+import type { Network } from "../pacifica/index.js";
+export declare function registerFundsCommands(program: Command, getAdapter: () => Promise<ExchangeAdapter>, isJson: () => boolean, getNetwork: () => Network): void;