perp-cli 0.3.19 → 0.4.2

package/README.md

@@ -3,8 +3,11 @@
 Multi-DEX perpetual futures CLI — **Pacifica** (Solana), **Hyperliquid** (HyperEVM), **Lighter** (Ethereum).
 
 ```bash
-npm install -g perp-cli
+npm install -g perp-cli       # global install
 perp --json portfolio
+
+# Or without global install (restricted environments)
+npx -y perp-cli --json portfolio
 ```
 
 ## Features

package/dist/arb/utils.d.ts

@@ -2,6 +2,8 @@
  * Arb utilities: settlement timing strategy, basis risk monitoring, and webhook notifications.
  */
 import type { ExchangeAdapter } from "../exchanges/interface.js";
+/** Settlement schedules per exchange (UTC hours when settlement occurs) */
+export declare const SETTLEMENT_SCHEDULES: Record<string, number[]>;
 export type SettleStrategy = "block" | "aggressive" | "off";
 /**
  * Get the most recent settlement time for an exchange.

package/dist/arb/utils.js

@@ -3,7 +3,7 @@
  */
 // ── Settlement Timing Strategy ──
 /** Settlement schedules per exchange (UTC hours when settlement occurs) */
-const SETTLEMENT_SCHEDULES = {
+export const SETTLEMENT_SCHEDULES = {
     hyperliquid: Array.from({ length: 24 }, (_, i) => i), // every hour
     pacifica: Array.from({ length: 24 }, (_, i) => i), // every hour
     lighter: Array.from({ length: 24 }, (_, i) => i), // every hour

package/dist/commands/agent.js

@@ -134,7 +134,7 @@ export function registerAgentCommands(program, getAdapter, isJson) {
                         "perp account orders --json",
                         "perp account history --json",
                         "perp account trades --json",
-                        "perp status --json",
+                        "perp portfolio --json",
                     ],
                     description: "Read account state: balances, positions, open orders, trade history",
                 },
@@ -142,14 +142,14 @@ export function registerAgentCommands(program, getAdapter, isJson) {
                     category: "trading",
                     commands: [
                         "perp trade check <symbol> <side> <size> --json",
-                        "perp trade market <symbol> <buy|sell> <size> --json --client-id <id>",
+                        "perp trade market <symbol> <buy|sell> <size> --json [--smart] --client-id <id>",
                         "perp trade limit <symbol> <buy|sell> <price> <size> --json --client-id <id>",
                         "perp trade cancel <symbol> <orderId> --json",
                         "perp trade cancel-all --json",
-                        "perp trade close <symbol> --json",
-                        "perp trade close-all --json",
-                        "perp trade flatten --json",
-                        "perp trade reduce <symbol> <percent> --json",
+                        "perp trade close <symbol> --json [--smart]",
+                        "perp trade close-all --json [--smart]",
+                        "perp trade flatten --json [--smart]",
+                        "perp trade reduce <symbol> <percent> --json [--smart]",
                         "perp trade stop <symbol> <side> <stopPrice> <size> --json",
                         "perp trade tpsl <symbol> <side> --tp <price> --sl <price> --json",
                         "perp trade twap <symbol> <side> <size> <duration> --json",
@@ -170,13 +170,21 @@ export function registerAgentCommands(program, getAdapter, isJson) {
                     category: "arbitrage",
                     commands: [
                         "perp arb funding --json",
-                        "perp arb rates --json",
+                        "perp arb scan --min 5 --json",
                         "perp arb scan --json",
+                        "perp arb exec <SYM> <longEx> <shortEx> <$> --leverage 2 --isolated --json",
+                        "perp arb status --json",
+                        "perp arb close <SYM> --json",
+                        "perp arb close <SYM> --dry-run --json",
+                        "perp arb close <SYM> --pair <longEx>:<shortEx> --json",
+                        "perp arb funding-earned --json",
+                        "perp arb funding-earned --period 30 --json",
+                        "perp arb history --json",
                         "perp arb dex --json",
                         "perp arb dex-monitor --min 10",
                         "perp gap show --json",
                     ],
-                    description: "Cross-exchange + cross-dex funding arb, price gaps, HIP-3 deployed dex arb",
+                    description: "Cross-exchange funding arb: scan → exec → status → funding-earned → close. Plus cross-dex arb and price gaps.",
                 },
                 {
                     category: "risk_management",
@@ -338,10 +346,10 @@ export function registerAgentCommands(program, getAdapter, isJson) {
             }
         }
         else if (g.includes("arb") || g.includes("arbitrage") || g.includes("funding")) {
-            steps.push({ step: 1, command: "perp arb rates --json", description: "Compare funding rates across exchanges" }, { step: 2, command: "perp arb scan --json", description: "Find high-spread opportunities" }, { step: 3, command: "perp gap show --json", description: "Check price gaps" }, { step: 4, command: "perp arb auto --dry-run --min-spread 30", description: "Dry-run auto arb bot" });
+            steps.push({ step: 1, command: "perp arb scan --min 5 --json", description: "Scan funding rate arbitrage opportunities" }, { step: 2, command: "perp arb exec <SYM> <longEx> <shortEx> <$> --leverage 2 --isolated --dry-run --json", description: "Dry-run arb execution" });
         }
         else if (g.includes("status") || g.includes("check") || g.includes("overview")) {
-            steps.push({ step: 1, command: "perp status --json", description: "Full account overview" }, { step: 2, command: "perp account positions --json", description: "Detailed positions" }, { step: 3, command: "perp account orders --json", description: "Open orders" });
+            steps.push({ step: 1, command: "perp portfolio --json", description: "Balances + positions + risk" }, { step: 2, command: "perp account positions --json", description: "Detailed positions" }, { step: 3, command: "perp account orders --json", description: "Open orders" });
         }
         else if (g.includes("deposit")) {
             const amount = extractNumber(g) || "100";
@@ -357,7 +365,7 @@ export function registerAgentCommands(program, getAdapter, isJson) {
             }
         }
         else {
-            steps.push({ step: 1, command: "perp agent capabilities", description: "List all available capabilities" }, { step: 2, command: "perp status --json", description: "Check account status" });
+            steps.push({ step: 1, command: "perp agent capabilities", description: "List all available capabilities" }, { step: 2, command: "perp portfolio --json", description: "Check account status" });
         }
         printJson(jsonOk({
             goal,

package/dist/commands/arb/index.js

@@ -4,12 +4,14 @@ import { readExecutionLog, logExecution } from "../../execution-log.js";
 import { computeAnnualSpread } from "../../funding.js";
 import { fetchPacificaPrices, fetchHyperliquidMeta, fetchLighterOrderBookDetails, fetchLighterFundingRates, } from "../../shared-api.js";
 import { computeBasisRisk } from "../../arb-utils.js";
+import { smartOrder } from "../../smart-order.js";
+import { removePosition as persistRemovePosition } from "../../arb-state.js";
 import { fetchAllBalances, computeRebalancePlan } from "../../rebalance.js";
 import { EXCHANGE_TO_CHAIN, getBestQuote } from "../../bridge-engine.js";
 import { computeEnhancedStats } from "../../arb-history-stats.js";
 // ── Helpers ──
+import { DEFAULT_TAKER_FEE as TAKER_FEE } from "../../constants.js";
 const EXCHANGES = ["hyperliquid", "lighter", "pacifica"];
-const TAKER_FEE = 0.00035; // ~0.035% typical taker fee
 function formatDuration(ms) {
     const hours = Math.floor(ms / (1000 * 60 * 60));
     const days = Math.floor(hours / 24);
@@ -165,6 +167,16 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                     // Net PnL
                     const totalUpnl = longPos.unrealizedPnl + shortPos.unrealizedPnl;
                     const netPnl = totalUpnl + estimatedFundingIncome - totalFees;
+                    // Daily funding estimate from current spread
+                    const dailyFundingEstimate = currentSpread
+                        ? (currentSpread / 100) / 365 * avgNotional
+                        : 0;
+                    // Breakeven analysis
+                    const totalCosts = totalFees; // entry+exit fees
+                    const remainingToBreakeven = totalCosts - estimatedFundingIncome - totalUpnl;
+                    const daysToBreakeven = dailyFundingEstimate > 0 && remainingToBreakeven > 0
+                        ? remainingToBreakeven / dailyFundingEstimate
+                        : remainingToBreakeven <= 0 ? 0 : null;
                     arbPairs.push({
                         symbol,
                         longExchange: longPos.exchange,
@@ -195,12 +207,33 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                         estimatedFees: totalFees,
                         unrealizedPnl: totalUpnl,
                         netPnl,
+                        dailyFundingEstimate,
+                        breakeven: {
+                            daysToBreakeven,
+                            dailyIncome: dailyFundingEstimate,
+                            totalCosts,
+                            remainingToBreakeven: Math.max(0, remainingToBreakeven),
+                        },
                     });
                 }
             }
         }
         if (isJson()) {
-            return printJson(jsonOk(arbPairs));
+            const totalNotionalJ = arbPairs.reduce((s, p) => s + (p.longPosition.notionalUsd + p.shortPosition.notionalUsd) / 2, 0);
+            const totalDailyJ = arbPairs.reduce((s, p) => s + p.dailyFundingEstimate, 0);
+            return printJson(jsonOk({
+                pairs: arbPairs,
+                aggregate: {
+                    positions: arbPairs.length,
+                    totalNotionalUsd: totalNotionalJ,
+                    unrealizedPnl: arbPairs.reduce((s, p) => s + p.unrealizedPnl, 0),
+                    estimatedFunding: arbPairs.reduce((s, p) => s + p.estimatedFundingIncome, 0),
+                    estimatedFees: arbPairs.reduce((s, p) => s + p.estimatedFees, 0),
+                    netPnl: arbPairs.reduce((s, p) => s + p.netPnl, 0),
+                    dailyFundingEstimate: totalDailyJ,
+                    annualizedApr: totalNotionalJ > 0 ? (totalDailyJ * 365 / totalNotionalJ) * 100 : 0,
+                },
+            }));
         }
         if (arbPairs.length === 0) {
             console.log(chalk.gray("  No open arb positions found.\n"));
@@ -240,12 +273,20 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
         const totalFunding = arbPairs.reduce((s, p) => s + p.estimatedFundingIncome, 0);
         const totalFees = arbPairs.reduce((s, p) => s + p.estimatedFees, 0);
         const totalNet = arbPairs.reduce((s, p) => s + p.netPnl, 0);
+        const totalDailyFunding = arbPairs.reduce((s, p) => s + p.dailyFundingEstimate, 0);
+        const totalNotional = arbPairs.reduce((s, p) => s + (p.longPosition.notionalUsd + p.shortPosition.notionalUsd) / 2, 0);
+        const portfolioApr = totalNotional > 0 ? (totalDailyFunding * 365 / totalNotional) * 100 : 0;
         console.log(chalk.white.bold("\n  Summary"));
         console.log(`    Positions:       ${arbPairs.length}`);
+        console.log(`    Total Notional:  $${formatUsd(totalNotional)}`);
         console.log(`    Unrealized PnL:  ${formatPnl(totalUpnl)}`);
         console.log(`    Est. Funding:    ${chalk.yellow(`$${totalFunding.toFixed(4)}`)}`);
         console.log(`    Est. Fees:       ${chalk.red(`-$${totalFees.toFixed(4)}`)}`);
         console.log(`    Net PnL:         ${formatPnl(totalNet)}`);
+        console.log(`    Daily Income:    ${chalk.cyan(`$${totalDailyFunding.toFixed(4)}/day`)}`);
+        if (portfolioApr > 0) {
+            console.log(`    Portfolio APR:   ${chalk.cyan(`${portfolioApr.toFixed(1)}%`)}`);
+        }
         console.log(chalk.gray(`    (Fees assume ${(TAKER_FEE * 100).toFixed(3)}% taker for entry + exit.)\n`));
     });
     // ── arb close ──
@@ -254,6 +295,7 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
         .description("Manually close an arb position on both exchanges")
         .option("--dry-run", "Show what would happen without executing")
         .option("--pair <pair>", "Specify arb pair as longExchange:shortExchange (e.g. pacifica:hyperliquid)")
+        .option("--smart", "Smart execution: IOC limit at best bid/ask + 1 tick (reduces slippage)")
         .action(async (symbol, opts) => {
         const sym = symbol.toUpperCase();
         const dryRun = !!opts.dryRun || process.argv.includes("--dry-run");
@@ -389,44 +431,78 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
             console.log(chalk.yellow(`    BUY ${shortPos.size} ${shortPos.rawSymbol} on ${shortPos.exchange} (close short)\n`));
             return;
         }
-        // Execute close on both exchanges
+        // Execute close on both exchanges with retry
+        const MAX_RETRIES = 2;
         const results = [];
-        // Close both legs concurrently
-        const closePromises = [
-            (async () => {
+        async function closeWithRetry(exchange, rawSymbol, side, size, label) {
+            let lastError = "";
+            for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
                 try {
-                    const adapter = await getAdapterForExchange(longPos.exchange);
-                    await adapter.marketOrder(longPos.rawSymbol, "sell", String(longPos.size));
-                    results.push({ exchange: longPos.exchange, action: "sell (close long)", status: "success" });
+                    const adapter = await getAdapterForExchange(exchange);
+                    if (opts.smart) {
+                        await smartOrder(adapter, rawSymbol, side, String(size), { reduceOnly: true });
+                    }
+                    else {
+                        await adapter.marketOrder(rawSymbol, side, String(size));
+                    }
+                    results.push({ exchange, action: `${side} (close ${label})`, status: "success", retries: attempt });
                     if (!isJson())
-                        console.log(chalk.green(`  Closed long on ${longPos.exchange}: SELL ${longPos.size} ${sym}`));
+                        console.log(chalk.green(`  Closed ${label} on ${exchange}: ${side.toUpperCase()} ${size} ${sym}${opts.smart ? " (smart)" : ""}${attempt > 0 ? ` (retry ${attempt})` : ""}`));
+                    return;
                 }
                 catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    results.push({ exchange: longPos.exchange, action: "sell (close long)", status: "failed", error: msg });
-                    if (!isJson())
-                        console.error(chalk.red(`  Failed to close long on ${longPos.exchange}: ${msg}`));
+                    lastError = err instanceof Error ? err.message : String(err);
+                    if (attempt < MAX_RETRIES) {
+                        if (!isJson())
+                            console.log(chalk.yellow(`  Retry ${attempt + 1}/${MAX_RETRIES} for ${label} on ${exchange}...`));
+                        await new Promise(r => setTimeout(r, 1000 * (attempt + 1)));
+                    }
                 }
-            })(),
-            (async () => {
+            }
+            results.push({ exchange, action: `${side} (close ${label})`, status: "failed", error: lastError, retries: MAX_RETRIES });
+            if (!isJson())
+                console.error(chalk.red(`  Failed to close ${label} on ${exchange}: ${lastError}`));
+        }
+        // Close both legs concurrently
+        await Promise.all([
+            closeWithRetry(longPos.exchange, longPos.rawSymbol, "sell", longPos.size, "long"),
+            closeWithRetry(shortPos.exchange, shortPos.rawSymbol, "buy", shortPos.size, "short"),
+        ]);
+        const allSuccess = results.every(r => r.status === "success");
+        const anySuccess = results.some(r => r.status === "success");
+        // Verify positions are actually closed
+        let verification;
+        if (anySuccess) {
+            verification = [];
+            for (const r of results) {
+                if (r.status !== "success")
+                    continue;
                 try {
-                    const adapter = await getAdapterForExchange(shortPos.exchange);
-                    await adapter.marketOrder(shortPos.rawSymbol, "buy", String(shortPos.size));
-                    results.push({ exchange: shortPos.exchange, action: "buy (close short)", status: "success" });
-                    if (!isJson())
-                        console.log(chalk.green(`  Closed short on ${shortPos.exchange}: BUY ${shortPos.size} ${sym}`));
+                    const adapter = await getAdapterForExchange(r.exchange);
+                    const positions = await adapter.getPositions();
+                    const remaining = positions.find(p => p.symbol.replace("-PERP", "").toUpperCase() === sym);
+                    verification.push({
+                        exchange: r.exchange,
+                        remainingSize: remaining ? Math.abs(Number(remaining.size)) : 0,
+                        closed: !remaining || Math.abs(Number(remaining.size)) < 0.0001,
+                    });
                 }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    results.push({ exchange: shortPos.exchange, action: "buy (close short)", status: "failed", error: msg });
-                    if (!isJson())
-                        console.error(chalk.red(`  Failed to close short on ${shortPos.exchange}: ${msg}`));
+                catch {
+                    verification.push({ exchange: r.exchange, remainingSize: -1, closed: false });
                 }
-            })(),
-        ];
-        await Promise.all(closePromises);
-        const allSuccess = results.every(r => r.status === "success");
-        const anySuccess = results.some(r => r.status === "success");
+            }
+            const notClosed = verification.filter(v => !v.closed);
+            if (notClosed.length > 0 && !isJson()) {
+                console.log(chalk.yellow(`\n  Warning: Position may not be fully closed on: ${notClosed.map(v => v.exchange).join(", ")}`));
+            }
+        }
+        // Remove from persisted daemon state (so daemon doesn't try to re-close)
+        if (allSuccess) {
+            try {
+                persistRemovePosition(sym);
+            }
+            catch { /* state may not exist */ }
+        }
         // Log to execution log
         const arbPairId = `${sym}:${longPos.exchange}:${shortPos.exchange}`;
         logExecution({
@@ -459,6 +535,7 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
                 estimatedFees: totalFees,
                 netPnl,
                 results,
+                verification,
             }));
         }
         if (!allSuccess && anySuccess) {
@@ -918,4 +995,184 @@ export function registerArbManageCommands(program, getAdapterForExchange, isJson
             console.log(chalk.yellow("\n  To execute, use: perp rebalance execute --auto-bridge\n"));
         }
     });
+    // ── arb funding-earned ──
+    arb
+        .command("funding-earned")
+        .description("Actual funding payments received/paid for arb positions")
+        .option("--period <days>", "Number of days to look back", "7")
+        .option("--symbol <symbol>", "Filter by symbol")
+        .action(async (opts) => {
+        const periodDays = parseInt(opts.period);
+        const filterSym = opts.symbol?.toUpperCase();
+        if (!isJson())
+            console.log(chalk.cyan(`\n  Fetching funding payments (last ${periodDays} days)...\n`));
+        // Fetch positions to identify arb pairs
+        const allPositions = [];
+        for (const exName of EXCHANGES) {
+            try {
+                const adapter = await getAdapterForExchange(exName);
+                const positions = await adapter.getPositions();
+                for (const p of positions) {
+                    const normalized = p.symbol.replace("-PERP", "").toUpperCase();
+                    allPositions.push({
+                        exchange: exName,
+                        symbol: normalized,
+                        side: p.side,
+                        size: Math.abs(Number(p.size)),
+                        markPrice: Number(p.markPrice),
+                    });
+                }
+            }
+            catch {
+                // exchange not configured
+            }
+        }
+        // Identify arb pairs (long on one exchange, short on another)
+        const arbPairKeys = new Set();
+        const arbPairInfo = new Map();
+        const longs = allPositions.filter(p => p.side === "long");
+        const shorts = allPositions.filter(p => p.side === "short");
+        for (const l of longs) {
+            for (const s of shorts) {
+                if (l.exchange !== s.exchange && l.symbol === s.symbol) {
+                    const key = l.symbol;
+                    arbPairKeys.add(key);
+                    arbPairInfo.set(key, {
+                        longExchange: l.exchange,
+                        shortExchange: s.exchange,
+                        notionalUsd: (l.size * l.markPrice + s.size * s.markPrice) / 2,
+                    });
+                }
+            }
+        }
+        const allPayments = [];
+        const cutoff = Date.now() - periodDays * 24 * 60 * 60 * 1000;
+        for (const exName of EXCHANGES) {
+            try {
+                const adapter = await getAdapterForExchange(exName);
+                const payments = await adapter.getFundingPayments(200);
+                for (const p of payments) {
+                    if (p.time < cutoff)
+                        continue;
+                    const sym = p.symbol.replace("-PERP", "").toUpperCase();
+                    if (filterSym && sym !== filterSym)
+                        continue;
+                    allPayments.push({
+                        time: p.time,
+                        exchange: exName,
+                        symbol: sym,
+                        payment: typeof p.payment === "string" ? parseFloat(p.payment) : Number(p.payment),
+                    });
+                }
+            }
+            catch {
+                // exchange not configured or no payments
+            }
+        }
+        // Group by symbol, then by exchange
+        const bySymbol = new Map();
+        for (const p of allPayments) {
+            if (!bySymbol.has(p.symbol))
+                bySymbol.set(p.symbol, []);
+            bySymbol.get(p.symbol).push(p);
+        }
+        const pairs = [];
+        for (const [symbol, payments] of bySymbol) {
+            const isArb = arbPairKeys.has(symbol);
+            const pairInfo = arbPairInfo.get(symbol);
+            // Group by exchange
+            const byEx = new Map();
+            for (const p of payments) {
+                if (!byEx.has(p.exchange))
+                    byEx.set(p.exchange, []);
+                byEx.get(p.exchange).push(p);
+            }
+            const exchangeSummaries = [];
+            let totalReceived = 0;
+            let totalPaid = 0;
+            for (const [exchange, exPayments] of byEx) {
+                const received = exPayments.filter(p => p.payment > 0).reduce((s, p) => s + p.payment, 0);
+                const paid = exPayments.filter(p => p.payment < 0).reduce((s, p) => s + Math.abs(p.payment), 0);
+                const net = received - paid;
+                totalReceived += received;
+                totalPaid += paid;
+                exchangeSummaries.push({ exchange, totalReceived: received, totalPaid: paid, net, payments: exPayments.length });
+            }
+            const netEarned = totalReceived - totalPaid;
+            const dailyAvg = periodDays > 0 ? netEarned / periodDays : 0;
+            const notionalUsd = pairInfo?.notionalUsd || 0;
+            const annualizedApr = notionalUsd > 0 ? (dailyAvg * 365 / notionalUsd) * 100 : 0;
+            pairs.push({
+                symbol,
+                isArbPair: isArb,
+                longExchange: pairInfo?.longExchange ?? null,
+                shortExchange: pairInfo?.shortExchange ?? null,
+                notionalUsd,
+                byExchange: exchangeSummaries,
+                totalReceived,
+                totalPaid,
+                netEarned,
+                dailyAvg,
+                annualizedApr,
+                payments: payments.length,
+            });
+        }
+        // Sort: arb pairs first, then by netEarned
+        pairs.sort((a, b) => {
+            if (a.isArbPair !== b.isArbPair)
+                return a.isArbPair ? -1 : 1;
+            return b.netEarned - a.netEarned;
+        });
+        // Totals
+        const totals = {
+            totalReceived: pairs.reduce((s, p) => s + p.totalReceived, 0),
+            totalPaid: pairs.reduce((s, p) => s + p.totalPaid, 0),
+            netEarned: pairs.reduce((s, p) => s + p.netEarned, 0),
+            dailyAvg: pairs.reduce((s, p) => s + p.dailyAvg, 0),
+            totalNotional: pairs.filter(p => p.isArbPair).reduce((s, p) => s + p.notionalUsd, 0),
+            arbPairs: pairs.filter(p => p.isArbPair).length,
+            period: periodDays,
+        };
+        const totalArbNotional = totals.totalNotional;
+        const portfolioApr = totalArbNotional > 0
+            ? (totals.dailyAvg * 365 / totalArbNotional) * 100
+            : 0;
+        if (isJson()) {
+            return printJson(jsonOk({
+                pairs,
+                totals: { ...totals, annualizedApr: portfolioApr },
+            }));
+        }
+        if (pairs.length === 0) {
+            console.log(chalk.gray("  No funding payments found.\n"));
+            return;
+        }
+        console.log(chalk.cyan.bold("  Funding Payments Earned\n"));
+        const rows = pairs.map(p => {
+            const arbTag = p.isArbPair ? chalk.green("ARB") : chalk.gray("---");
+            const exchanges = p.byExchange.map(e => e.exchange.slice(0, 3).toUpperCase()).join("+");
+            return [
+                chalk.white.bold(p.symbol),
+                arbTag,
+                exchanges,
+                chalk.green(`$${p.totalReceived.toFixed(4)}`),
+                chalk.red(`-$${p.totalPaid.toFixed(4)}`),
+                formatPnl(p.netEarned),
+                `$${p.dailyAvg.toFixed(4)}/d`,
+                p.annualizedApr > 0 ? `${p.annualizedApr.toFixed(1)}%` : "-",
+                String(p.payments),
+            ];
+        });
+        console.log(makeTable(["Symbol", "Type", "Exchanges", "Received", "Paid", "Net", "Daily Avg", "APR", "#"], rows));
+        console.log(chalk.white.bold("\n  Totals"));
+        console.log(`    Period:       ${periodDays} days`);
+        console.log(`    Received:     ${chalk.green(`$${totals.totalReceived.toFixed(4)}`)}`);
+        console.log(`    Paid:         ${chalk.red(`-$${totals.totalPaid.toFixed(4)}`)}`);
+        console.log(`    Net Earned:   ${formatPnl(totals.netEarned)}`);
+        console.log(`    Daily Avg:    $${totals.dailyAvg.toFixed(4)}/day`);
+        if (portfolioApr > 0) {
+            console.log(`    Portfolio APR: ${chalk.cyan(`${portfolioApr.toFixed(1)}%`)} (on $${formatUsd(totalArbNotional)} arb notional)`);
+        }
+        console.log();
+    });
 }