@darksol/terminal 0.3.6 → 0.4.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darksol/terminal",
-  "version": "0.3.6",
+  "version": "0.4.0-beta.1",
   "description": "DARKSOL Terminal — unified CLI for all DARKSOL services. Market intel, trading, oracle, casino, and more.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -4,6 +4,10 @@ import { theme } from './ui/theme.js';
 import { kvDisplay, success, error, warn, info } from './ui/components.js';
 import { getConfig, setConfig, getAllConfig, getRPC, setRPC, configPath } from './config/store.js';
 import { createWallet, importWallet, showWallets, getBalance, useWallet, exportWallet } from './wallet/manager.js';
+import { showPortfolio } from './wallet/portfolio.js';
+import { showHistory } from './wallet/history.js';
+import { showGas } from './services/gas.js';
+import { watchPrice, checkPrices } from './services/watch.js';
 import { executeSwap } from './trading/swap.js';
 import { snipeToken, watchSnipe } from './trading/snipe.js';
 import { createDCA, listDCA, cancelDCA, runDCA } from './trading/dca.js';
@@ -69,6 +73,18 @@ export function cli(argv) {
     .description('Export wallet details')
     .action((name) => exportWallet(name));
 
+  wallet
+    .command('portfolio [name]')
+    .description('View balances across all EVM chains')
+    .action((name) => showPortfolio(name));
+
+  wallet
+    .command('history [name]')
+    .description('Recent transaction history')
+    .option('-c, --chain <chain>', 'Chain to check')
+    .option('-l, --limit <n>', 'Number of transactions', '10')
+    .action((name, opts) => showHistory(name, opts));
+
   // ═══════════════════════════════════════
   // TRADING COMMANDS
   // ═══════════════════════════════════════
@@ -294,6 +310,39 @@ export function cli(argv) {
     .description('Settle payment on-chain')
     .action((payment) => facilitatorSettle(payment));
 
+  // ═══════════════════════════════════════
+  // PORTFOLIO SHORTCUT
+  // ═══════════════════════════════════════
+  program
+    .command('portfolio [name]')
+    .description('Multi-chain balance view (shortcut for: wallet portfolio)')
+    .action((name) => showPortfolio(name));
+
+  // ═══════════════════════════════════════
+  // GAS COMMAND
+  // ═══════════════════════════════════════
+  program
+    .command('gas [chain]')
+    .description('Show current gas prices and estimated costs')
+    .action((chain) => showGas(chain));
+
+  // ═══════════════════════════════════════
+  // PRICE COMMANDS
+  // ═══════════════════════════════════════
+  program
+    .command('price <tokens...>')
+    .description('Quick price check for one or more tokens')
+    .action((tokens) => checkPrices(tokens));
+
+  program
+    .command('watch <token>')
+    .description('Live price monitoring with alerts')
+    .option('-i, --interval <sec>', 'Poll interval in seconds', '10')
+    .option('--above <price>', 'Alert when price goes above')
+    .option('--below <price>', 'Alert when price drops below')
+    .option('-d, --duration <min>', 'Run for N minutes then stop')
+    .action((token, opts) => watchPrice(token, opts));
+
   // ═══════════════════════════════════════
   // CHAT SHORTCUT (darksol chat = darksol ai chat)
   // ═══════════════════════════════════════
@@ -776,6 +825,10 @@ function showCommandList() {
   showSection('COMMANDS');
   const commands = [
     ['wallet', 'Create, import, manage wallets'],
+    ['portfolio', 'Multi-chain balance view'],
+    ['price', 'Quick token price check'],
+    ['watch', 'Live price monitoring + alerts'],
+    ['gas', 'Gas prices & cost estimates'],
     ['trade', 'Swap tokens, snipe, trading'],
     ['dca', 'Dollar-cost averaging orders'],
     ['ai chat', 'Standalone AI chat session'],

package/src/services/gas.js

@@ -0,0 +1,116 @@
+import { ethers } from 'ethers';
+import { getConfig, getRPC } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, success, error, warn, info } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+
+// ══════════════════════════════════════════════════
+// GAS ESTIMATOR
+// ══════════════════════════════════════════════════
+
+/**
+ * Show current gas prices for active chain
+ */
+export async function showGas(chain) {
+  chain = chain || getConfig('chain') || 'base';
+  const rpc = getRPC(chain);
+  const provider = new ethers.JsonRpcProvider(rpc);
+
+  const spin = spinner(`Fetching gas on ${chain}...`).start();
+
+  try {
+    const feeData = await provider.getFeeData();
+    const block = await provider.getBlock('latest');
+
+    spin.succeed('Gas data fetched');
+
+    const gasPrice = feeData.gasPrice ? parseFloat(ethers.formatUnits(feeData.gasPrice, 'gwei')) : 0;
+    const maxFee = feeData.maxFeePerGas ? parseFloat(ethers.formatUnits(feeData.maxFeePerGas, 'gwei')) : 0;
+    const maxPriority = feeData.maxPriorityFeePerGas ? parseFloat(ethers.formatUnits(feeData.maxPriorityFeePerGas, 'gwei')) : 0;
+    const baseFee = block?.baseFeePerGas ? parseFloat(ethers.formatUnits(block.baseFeePerGas, 'gwei')) : 0;
+
+    console.log('');
+    showSection(`GAS — ${chain.toUpperCase()}`);
+    kvDisplay([
+      ['Gas Price', `${gasPrice.toFixed(4)} gwei`],
+      ['Base Fee', `${baseFee.toFixed(4)} gwei`],
+      ['Max Fee', `${maxFee.toFixed(4)} gwei`],
+      ['Priority Fee', `${maxPriority.toFixed(4)} gwei`],
+      ['Block', `#${block?.number || '?'}`],
+    ]);
+
+    // Estimate common operations
+    console.log('');
+    showSection('ESTIMATED COSTS');
+
+    const ethPrice = await getETHPrice();
+    const estimates = [
+      { name: 'ETH Transfer', gas: 21000n },
+      { name: 'ERC-20 Transfer', gas: 65000n },
+      { name: 'ERC-20 Approve', gas: 46000n },
+      { name: 'Uniswap Swap', gas: 200000n },
+      { name: 'Uniswap + Approve', gas: 250000n },
+      { name: 'Contract Deploy (small)', gas: 500000n },
+    ];
+
+    estimates.forEach(({ name, gas }) => {
+      const costWei = gas * (feeData.gasPrice || 0n);
+      const costETH = parseFloat(ethers.formatEther(costWei));
+      const costUSD = costETH * ethPrice;
+      const label = name.padEnd(24);
+      const ethStr = costETH < 0.000001 ? '<$0.01' : `${costETH.toFixed(6)} ETH`;
+      const usdStr = costUSD < 0.01 ? '<$0.01' : `$${costUSD.toFixed(2)}`;
+      console.log(`  ${theme.dim(label)} ${ethStr.padEnd(16)} ${theme.gold(usdStr)}`);
+    });
+
+    console.log('');
+    info(`ETH price: $${ethPrice.toFixed(2)}`);
+    console.log('');
+
+    return { chain, gasPrice, baseFee, maxFee, maxPriority, ethPrice };
+  } catch (err) {
+    spin.fail('Failed to fetch gas data');
+    error(err.message);
+  }
+}
+
+/**
+ * Get ETH price (CoinGecko, fallback estimate)
+ */
+async function getETHPrice() {
+  try {
+    const fetch = (await import('node-fetch')).default;
+    const resp = await fetch('https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd');
+    const data = await resp.json();
+    return data.ethereum?.usd || 3000;
+  } catch {
+    return 3000;
+  }
+}
+
+/**
+ * Estimate gas for a specific transaction (pre-trade check)
+ */
+export async function estimateTradeGas(txParams, chain) {
+  chain = chain || getConfig('chain') || 'base';
+  const rpc = getRPC(chain);
+  const provider = new ethers.JsonRpcProvider(rpc);
+
+  try {
+    const gasEstimate = await provider.estimateGas(txParams);
+    const feeData = await provider.getFeeData();
+    const costWei = gasEstimate * (feeData.gasPrice || 0n);
+    const costETH = parseFloat(ethers.formatEther(costWei));
+    const ethPrice = await getETHPrice();
+    const costUSD = costETH * ethPrice;
+
+    return {
+      gas: gasEstimate.toString(),
+      costETH: costETH.toFixed(6),
+      costUSD: costUSD.toFixed(2),
+      gasPrice: feeData.gasPrice ? ethers.formatUnits(feeData.gasPrice, 'gwei') : '0',
+    };
+  } catch (err) {
+    return { error: err.message };
+  }
+}

package/src/services/watch.js

@@ -0,0 +1,159 @@
+import fetch from 'node-fetch';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, success, error, warn, info } from '../ui/components.js';
+import { showSection, showDivider } from '../ui/banner.js';
+
+// ══════════════════════════════════════════════════
+// PRICE WATCH — Live price monitoring with alerts
+// ══════════════════════════════════════════════════
+
+/**
+ * Watch a token's price with optional alert thresholds
+ */
+export async function watchPrice(token, opts = {}) {
+  const interval = parseInt(opts.interval || '10') * 1000;  // seconds → ms
+  const above = opts.above ? parseFloat(opts.above) : null;
+  const below = opts.below ? parseFloat(opts.below) : null;
+  const duration = opts.duration ? parseInt(opts.duration) * 60 * 1000 : null;  // minutes → ms
+
+  console.log('');
+  showSection(`PRICE WATCH — ${token.toUpperCase()}`);
+
+  if (above) info(`Alert above: $${above}`);
+  if (below) info(`Alert below: $${below}`);
+  info(`Polling every ${interval / 1000}s`);
+  if (duration) info(`Running for ${duration / 60000} minutes`);
+  console.log('');
+  info('Press Ctrl+C to stop');
+  console.log('');
+
+  const startTime = Date.now();
+  let lastPrice = null;
+  let ticks = 0;
+
+  const poll = async () => {
+    try {
+      const resp = await fetch(`https://api.dexscreener.com/latest/dex/search?q=${token}`);
+      const data = await resp.json();
+      const pair = data.pairs?.[0];
+
+      if (!pair) {
+        console.log(theme.dim(`  [${timestamp()}] No data for ${token}`));
+        return;
+      }
+
+      const price = parseFloat(pair.priceUsd);
+      const change24h = pair.priceChange?.h24 || 0;
+      const volume = pair.volume?.h24 || 0;
+
+      // Price change indicator
+      let arrow = '  ';
+      if (lastPrice !== null) {
+        if (price > lastPrice) arrow = theme.success('▲ ');
+        else if (price < lastPrice) arrow = theme.accent('▼ ');
+        else arrow = theme.dim('= ');
+      }
+
+      const priceStr = formatWatchPrice(price);
+      const changeStr = change24h >= 0 ? theme.success(`+${change24h.toFixed(2)}%`) : theme.accent(`${change24h.toFixed(2)}%`);
+      const volStr = volume > 1000000 ? `$${(volume / 1000000).toFixed(1)}M` : `$${(volume / 1000).toFixed(0)}K`;
+
+      console.log(`  ${theme.dim(timestamp())}  ${arrow}${theme.gold(priceStr.padEnd(14))} ${changeStr.padEnd(20)} vol: ${theme.dim(volStr)}`);
+
+      // Alert checks
+      if (above && price >= above) {
+        console.log('');
+        console.log(theme.success(`  🔔 ALERT: ${pair.baseToken.symbol} hit $${price} (above $${above})`));
+        console.log('');
+      }
+
+      if (below && price <= below) {
+        console.log('');
+        console.log(theme.accent(`  🔔 ALERT: ${pair.baseToken.symbol} dropped to $${price} (below $${below})`));
+        console.log('');
+      }
+
+      lastPrice = price;
+      ticks++;
+    } catch (err) {
+      console.log(theme.dim(`  [${timestamp()}] Error: ${err.message}`));
+    }
+  };
+
+  // Initial fetch
+  await poll();
+
+  // Polling loop
+  const timer = setInterval(async () => {
+    if (duration && (Date.now() - startTime) >= duration) {
+      clearInterval(timer);
+      console.log('');
+      info(`Watch ended after ${duration / 60000} minutes (${ticks} ticks)`);
+      return;
+    }
+    await poll();
+  }, interval);
+
+  // Keep alive
+  await new Promise((resolve) => {
+    process.on('SIGINT', () => {
+      clearInterval(timer);
+      console.log('');
+      info(`Watched ${ticks} ticks`);
+      resolve();
+    });
+    if (duration) {
+      setTimeout(() => {
+        clearInterval(timer);
+        resolve();
+      }, duration + 1000);
+    }
+  });
+}
+
+/**
+ * Quick price check (one-shot, multiple tokens)
+ */
+export async function checkPrices(tokens) {
+  if (!tokens || tokens.length === 0) {
+    error('Specify tokens: darksol price ETH AERO VIRTUAL');
+    return;
+  }
+
+  console.log('');
+  showSection('PRICE CHECK');
+
+  for (const token of tokens) {
+    try {
+      const resp = await fetch(`https://api.dexscreener.com/latest/dex/search?q=${token}`);
+      const data = await resp.json();
+      const pair = data.pairs?.[0];
+
+      if (!pair) {
+        console.log(`  ${theme.dim(token.toUpperCase().padEnd(10))} ${theme.dim('Not found')}`);
+        continue;
+      }
+
+      const price = parseFloat(pair.priceUsd);
+      const change = pair.priceChange?.h24 || 0;
+      const changeStr = change >= 0 ? theme.success(`+${change.toFixed(2)}%`) : theme.accent(`${change.toFixed(2)}%`);
+
+      console.log(`  ${theme.gold(pair.baseToken.symbol.padEnd(10))} ${formatWatchPrice(price).padEnd(14)} ${changeStr}`);
+    } catch {
+      console.log(`  ${theme.dim(token.padEnd(10))} ${theme.dim('Error')}`);
+    }
+  }
+
+  console.log('');
+}
+
+// Helpers
+function timestamp() {
+  return new Date().toLocaleTimeString('en-US', { hour12: false });
+}
+
+function formatWatchPrice(price) {
+  if (price >= 1) return `$${price.toFixed(2)}`;
+  if (price >= 0.01) return `$${price.toFixed(4)}`;
+  return `$${price.toFixed(8)}`;
+}

package/src/ui/banner.js

@@ -26,7 +26,7 @@ export function showBanner(opts = {}) {
   );
   console.log(
     theme.dim('  ║ ') +
-    theme.subtle(' v0.3.6') +
+    theme.subtle(' v0.4.0-beta.1') +
     theme.dim('                                                ') +
     theme.gold('🌑') +
     theme.dim(' ║')
@@ -44,7 +44,7 @@ export function showBanner(opts = {}) {
 
 export function showMiniBanner() {
   console.log('');
-  console.log(theme.gold.bold('  🌑 DARKSOL TERMINAL') + theme.dim(' v0.3.6'));
+  console.log(theme.gold.bold('  🌑 DARKSOL TERMINAL') + theme.dim(' v0.4.0-beta.1'));
   console.log(theme.dim('  ─────────────────────────────'));
   console.log('');
 }
@@ -69,3 +69,4 @@ export function showDivider() {
 
 
 
+

package/src/wallet/history.js

@@ -0,0 +1,96 @@
+import fetch from 'node-fetch';
+import { loadWallet } from './keystore.js';
+import { getConfig, getRPC } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, success, error, warn, info, table } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+
+// ══════════════════════════════════════════════════
+// TRANSACTION HISTORY
+// ══════════════════════════════════════════════════
+
+const EXPLORER_APIS = {
+  base:     { api: 'https://api.basescan.org/api',                  explorer: 'https://basescan.org' },
+  ethereum: { api: 'https://api.etherscan.io/api',                  explorer: 'https://etherscan.io' },
+  arbitrum: { api: 'https://api.arbiscan.io/api',                   explorer: 'https://arbiscan.io' },
+  optimism: { api: 'https://api-optimistic.etherscan.io/api',       explorer: 'https://optimistic.etherscan.io' },
+  polygon:  { api: 'https://api.polygonscan.com/api',               explorer: 'https://polygonscan.com' },
+};
+
+/**
+ * Show recent transaction history
+ */
+export async function showHistory(walletName, opts = {}) {
+  const name = walletName || getConfig('activeWallet');
+  if (!name) {
+    error('No wallet specified. Use: darksol wallet history <name>');
+    return;
+  }
+
+  const walletData = loadWallet(name);
+  const address = walletData.address;
+  const chain = opts.chain || walletData.chain || getConfig('chain') || 'base';
+  const limit = parseInt(opts.limit || '10');
+
+  const explorerConfig = EXPLORER_APIS[chain];
+  if (!explorerConfig) {
+    error(`No explorer API for chain: ${chain}`);
+    return;
+  }
+
+  const spin = spinner(`Fetching history on ${chain}...`).start();
+
+  try {
+    // Fetch normal transactions
+    const url = `${explorerConfig.api}?module=account&action=txlist&address=${address}&startblock=0&endblock=99999999&page=1&offset=${limit}&sort=desc`;
+    const resp = await fetch(url);
+    const data = await resp.json();
+
+    if (data.status !== '1' || !data.result?.length) {
+      spin.succeed('No transactions found');
+      info(`No recent transactions on ${chain}`);
+      return;
+    }
+
+    spin.succeed(`Found ${data.result.length} transactions`);
+
+    console.log('');
+    showSection(`HISTORY — ${name} (${chain})`);
+    console.log(theme.dim(`  ${address}`));
+    console.log('');
+
+    const rows = data.result.map(tx => {
+      const isOutgoing = tx.from.toLowerCase() === address.toLowerCase();
+      const direction = isOutgoing ? theme.accent('OUT →') : theme.success('← IN');
+      const value = parseFloat(tx.value) / 1e18;
+      const valueStr = value > 0 ? `${value.toFixed(4)} ETH` : theme.dim('0 ETH');
+      const status = tx.isError === '0' ? theme.success('✓') : theme.accent('✗');
+      const date = new Date(parseInt(tx.timeStamp) * 1000);
+      const dateStr = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+      const timeStr = date.toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit' });
+      const counterparty = isOutgoing ? tx.to : tx.from;
+      const shortAddr = counterparty ? `${counterparty.slice(0, 6)}...${counterparty.slice(-4)}` : '—';
+      const method = tx.functionName ? tx.functionName.split('(')[0] : (value > 0 ? 'transfer' : '—');
+
+      return [
+        status,
+        direction,
+        valueStr,
+        shortAddr,
+        method.slice(0, 16),
+        `${dateStr} ${timeStr}`,
+      ];
+    });
+
+    table(['', 'Dir', 'Value', 'Address', 'Method', 'Date'], rows);
+
+    console.log('');
+    info(`Explorer: ${explorerConfig.explorer}/address/${address}`);
+    console.log('');
+
+  } catch (err) {
+    spin.fail('Failed to fetch history');
+    error(err.message);
+    info('Some explorer APIs require an API key for reliable access.');
+  }
+}

package/src/wallet/portfolio.js

@@ -0,0 +1,169 @@
+import { ethers } from 'ethers';
+import { loadWallet, listWallets } from './keystore.js';
+import { getConfig, getRPC } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, success, error, warn, info, table } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+
+// ══════════════════════════════════════════════════
+// MULTI-CHAIN PORTFOLIO VIEW
+// ══════════════════════════════════════════════════
+
+const CHAINS = {
+  base:     { name: 'Base',     rpc: 'https://mainnet.base.org',        usdc: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', explorer: 'https://basescan.org' },
+  ethereum: { name: 'Ethereum', rpc: 'https://eth.llamarpc.com',        usdc: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', explorer: 'https://etherscan.io' },
+  arbitrum: { name: 'Arbitrum', rpc: 'https://arb1.arbitrum.io/rpc',    usdc: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', explorer: 'https://arbiscan.io' },
+  optimism: { name: 'Optimism', rpc: 'https://mainnet.optimism.io',     usdc: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85', explorer: 'https://optimistic.etherscan.io' },
+  polygon:  { name: 'Polygon',  rpc: 'https://polygon-rpc.com',         usdc: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359', explorer: 'https://polygonscan.com' },
+};
+
+const ERC20_ABI = [
+  'function balanceOf(address) view returns (uint256)',
+  'function decimals() view returns (uint8)',
+];
+
+/**
+ * Show portfolio across all EVM chains
+ */
+export async function showPortfolio(walletName, opts = {}) {
+  const name = walletName || getConfig('activeWallet');
+  if (!name) {
+    error('No wallet specified. Use: darksol wallet portfolio <name>');
+    return;
+  }
+
+  const walletData = loadWallet(name);
+  const address = walletData.address;
+
+  console.log('');
+  showSection(`PORTFOLIO — ${name}`);
+  console.log(theme.dim(`  ${address}`));
+  console.log('');
+
+  const spin = spinner('Scanning all chains...').start();
+  const results = [];
+  let totalUSD = 0;
+
+  // Fetch ETH price for USD conversion
+  let ethPrice = 0;
+  try {
+    const fetch = (await import('node-fetch')).default;
+    const priceResp = await fetch('https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd');
+    const priceData = await priceResp.json();
+    ethPrice = priceData.ethereum?.usd || 0;
+  } catch { ethPrice = 3000; /* fallback estimate */ }
+
+  // Scan each chain in parallel
+  const chainPromises = Object.entries(CHAINS).map(async ([chainId, chain]) => {
+    try {
+      const rpc = getRPC(chainId) || chain.rpc;
+      const provider = new ethers.JsonRpcProvider(rpc);
+
+      // ETH balance
+      const balance = await provider.getBalance(address);
+      const ethBal = parseFloat(ethers.formatEther(balance));
+
+      // USDC balance
+      let usdcBal = 0;
+      if (chain.usdc) {
+        try {
+          const usdc = new ethers.Contract(chain.usdc, ERC20_ABI, provider);
+          const raw = await usdc.balanceOf(address);
+          const decimals = await usdc.decimals();
+          usdcBal = parseFloat(ethers.formatUnits(raw, decimals));
+        } catch { }
+      }
+
+      const ethUSD = ethBal * ethPrice;
+      const chainTotal = ethUSD + usdcBal;
+
+      return {
+        chain: chain.name,
+        chainId,
+        eth: ethBal,
+        usdc: usdcBal,
+        ethUSD,
+        total: chainTotal,
+        explorer: chain.explorer,
+      };
+    } catch (err) {
+      return {
+        chain: chain.name,
+        chainId,
+        eth: 0,
+        usdc: 0,
+        ethUSD: 0,
+        total: 0,
+        error: err.message,
+      };
+    }
+  });
+
+  const chainResults = await Promise.all(chainPromises);
+  spin.succeed('Scan complete');
+
+  // Build table
+  const rows = chainResults.map(r => {
+    const ethStr = r.eth > 0 ? `${r.eth.toFixed(6)} ETH` : theme.dim('0');
+    const usdcStr = r.usdc > 0 ? `$${r.usdc.toFixed(2)}` : theme.dim('$0');
+    const totalStr = r.total > 0.01 ? theme.gold(`$${r.total.toFixed(2)}`) : theme.dim('$0');
+    const status = r.error ? theme.accent('⚠') : (r.total > 0 ? theme.success('●') : theme.dim('○'));
+    totalUSD += r.total;
+
+    return [
+      `${status} ${r.chain}`,
+      ethStr,
+      usdcStr,
+      totalStr,
+    ];
+  });
+
+  console.log('');
+  table(['Chain', 'ETH', 'USDC', 'Total USD'], rows);
+
+  // Summary
+  console.log('');
+  kvDisplay([
+    ['Total Value', theme.gold(`$${totalUSD.toFixed(2)}`)],
+    ['ETH Price', `$${ethPrice.toFixed(2)}`],
+    ['Chains', `${chainResults.filter(r => !r.error).length}/${Object.keys(CHAINS).length} connected`],
+  ]);
+
+  // Show explorer links for chains with balance
+  const withBalance = chainResults.filter(r => r.total > 0.01);
+  if (withBalance.length > 0) {
+    console.log('');
+    info('Explorer links:');
+    withBalance.forEach(r => {
+      console.log(theme.dim(`  ${r.chain}: ${r.explorer}/address/${address}`));
+    });
+  }
+
+  console.log('');
+  return { address, chains: chainResults, totalUSD, ethPrice };
+}
+
+/**
+ * Quick balance check (non-verbose, for status bar)
+ */
+export async function quickBalance(walletName) {
+  const name = walletName || getConfig('activeWallet');
+  if (!name) return null;
+
+  try {
+    const walletData = loadWallet(name);
+    const chain = walletData.chain || getConfig('chain') || 'base';
+    const rpc = getRPC(chain) || CHAINS[chain]?.rpc;
+    if (!rpc) return null;
+
+    const provider = new ethers.JsonRpcProvider(rpc);
+    const balance = await provider.getBalance(walletData.address);
+    return {
+      address: walletData.address,
+      chain,
+      eth: parseFloat(ethers.formatEther(balance)),
+    };
+  } catch {
+    return null;
+  }
+}