@darksol/terminal 0.11.0 → 0.13.0

package/src/cli.js

@@ -2,17 +2,21 @@ import { Command } from 'commander';
 import { showBanner, showMiniBanner, showSection } from './ui/banner.js';
 import { theme } from './ui/theme.js';
 import { kvDisplay, success, error, warn, info } from './ui/components.js';
+import { createDashboard } from './ui/dashboard.js';
 import { getConfig, setConfig, getAllConfig, getRPC, setRPC, configPath } from './config/store.js';
 import { createWallet, importWallet, showWallets, getBalance, useWallet, exportWallet, sendFunds, receiveAddress } 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 { getWhaleActivity, listTracked, mirrorTrade, stopTracking, trackWallet } from './services/whale.js';
+import { startWhaleFeed } from './services/whale-monitor.js';
 import { mailSetup, mailCreate, mailInboxes, mailSend, mailList, mailRead, mailReply, mailForward, mailThreads, mailDelete, mailUse, mailStats, mailStatus } from './services/mail.js';
 import { startWebShell } from './web/server.js';
 import { executeSwap } from './trading/swap.js';
 import { snipeToken, watchSnipe } from './trading/snipe.js';
 import { createDCA, listDCA, cancelDCA, runDCA } from './trading/dca.js';
+import { arbScan, arbMonitor, arbExecute, arbStats, arbConfig, arbAddEndpoint, arbAddPair, arbRemovePair, arbInfo } from './trading/arb.js';
 import { executeLifiSwap, executeLifiBridge, checkBridgeStatus, showSupportedChains } from './services/lifi.js';
 import { topMovers, tokenDetail, compareTokens } from './services/market.js';
 import { oracleFlip, oracleDice, oracleNumber, oracleShuffle, oracleHealth } from './services/oracle.js';
@@ -42,6 +46,7 @@ import { runSetupWizard } from './setup/wizard.js';
 import { displaySoul, hasSoul, resetSoul, runSoulSetup } from './soul/index.js';
 import { clearMemories, exportMemories, getRecentMemories, searchMemories } from './memory/index.js';
 import { getAgentStatus, planAgentGoal, runAgentTask } from './agent/index.js';
+import { getAuditLog, getStatus as getAutoStatus, listStrategies as listAutoStrategies, startAutonomous, stopAutonomous } from './agent/autonomous.js';
 import { daemonStart, daemonStop, daemonStatus, daemonRestart } from './daemon/index.js';
 import { telegramSetup, telegramStartForeground, telegramStopCommand, telegramStatusCommand, telegramSendCommand } from './services/telegram.js';
 import { createRequire } from 'module';
@@ -329,6 +334,225 @@ export function cli(argv) {
     .description('Execute pending DCA orders')
     .action(() => runDCA());
 
+  // ═══════════════════════════════════════
+  // ARBITRAGE COMMANDS
+  // ═══════════════════════════════════════
+  const arb = program
+    .command('arb')
+    .description('Cross-DEX arbitrage - scan, monitor, execute');
+
+  arb
+    .command('scan')
+    .description('One-shot scan across DEXs for price differences')
+    .option('-c, --chain <chain>', 'Target chain', 'base')
+    .option('-p, --pair <pair>', 'Token pair to scan (e.g. WETH/USDC)')
+    .option('-m, --min-profit <usd>', 'Minimum profit threshold in USD', '0.50')
+    .option('-s, --trade-size <eth>', 'Trade size in ETH', '0.1')
+    .action((opts) => arbScan({
+      chain: opts.chain,
+      pair: opts.pair,
+      minProfit: parseFloat(opts.minProfit),
+      tradeSize: parseFloat(opts.tradeSize),
+    }));
+
+  arb
+    .command('monitor')
+    .description('Real-time block-by-block arb monitoring (WSS recommended)')
+    .option('-c, --chain <chain>', 'Target chain', 'base')
+    .option('-e, --execute', 'Auto-execute profitable arbs')
+    .option('-d, --dry-run', 'Dry-run mode (no real transactions)')
+    .option('-m, --min-profit <usd>', 'Minimum profit threshold in USD', '0.50')
+    .action((opts) => arbMonitor({
+      chain: opts.chain,
+      execute: opts.execute,
+      dryRun: opts.dryRun !== undefined ? opts.dryRun : undefined,
+      minProfit: opts.minProfit,
+    }));
+
+  arb
+    .command('stats')
+    .description('View arb history and performance stats')
+    .option('-d, --days <days>', 'Number of days to show', '7')
+    .action((opts) => arbStats({ days: opts.days }));
+
+  arb
+    .command('config')
+    .description('Interactive arb configuration (thresholds, dry-run, DEXes)')
+    .action(() => arbConfig());
+
+  arb
+    .command('add-endpoint <chain> <url>')
+    .description('Add a custom WSS or RPC endpoint for faster arb detection')
+    .action((chain, url) => arbAddEndpoint({ chain, url }));
+
+  arb
+    .command('add-pair <tokenA> <tokenB>')
+    .description('Add a token pair to the arb scan list')
+    .action((tokenA, tokenB) => arbAddPair({ tokenA, tokenB }));
+
+  arb
+    .command('remove-pair <tokenA> <tokenB>')
+    .description('Remove a token pair from the arb scan list')
+    .action((tokenA, tokenB) => arbRemovePair({ tokenA, tokenB }));
+
+  arb
+    .command('info')
+    .description('How arbitrage works, setup guide, and risk warnings')
+    .action(() => arbInfo());
+
+  const auto = program
+    .command('auto')
+    .description('Autonomous trader mode - goal-based automated execution');
+
+  auto
+    .command('start <goal>')
+    .description('Start an autonomous strategy from a natural language goal')
+    .requiredOption('--budget <amount>', 'Total USDC budget')
+    .requiredOption('--max-per-trade <amount>', 'Per-trade cap')
+    .option('--risk <level>', 'Risk level (conservative|moderate|aggressive)', 'moderate')
+    .option('--interval <minutes>', 'Evaluation interval in minutes', '5')
+    .option('--chain <chain>', 'Target chain (repeatable)', (value, previous = []) => previous.concat(value), [])
+    .option('--dry-run', 'Simulate decisions without executing swaps')
+    .action(async (goal, opts) => {
+      showMiniBanner();
+      showSection('AUTONOMOUS START');
+      const strategy = await startAutonomous(goal, {
+        budget: parseFloat(opts.budget),
+        maxPerTrade: parseFloat(opts.maxPerTrade),
+        riskLevel: opts.risk,
+        interval: parseFloat(opts.interval),
+        chains: opts.chain,
+        dryRun: opts.dryRun,
+      });
+
+      kvDisplay([
+        ['ID', strategy.id],
+        ['Goal', strategy.goal],
+        ['Budget', `${strategy.budget} USDC`],
+        ['Max / Trade', `${strategy.maxPerTrade} USDC`],
+        ['Risk', strategy.riskLevel],
+        ['Mode', strategy.dryRun ? 'dry-run' : 'live'],
+        ['Next Check', strategy.nextCheckAt],
+      ]);
+      console.log('');
+    });
+
+  auto
+    .command('stop <id>')
+    .description('Stop a running autonomous strategy')
+    .action((id) => {
+      showMiniBanner();
+      showSection('AUTONOMOUS STOP');
+      const strategy = stopAutonomous(id);
+      if (!strategy) {
+        warn(`Strategy not found: ${id}`);
+        console.log('');
+        return;
+      }
+      success(`Stopped ${strategy.id}`);
+      console.log('');
+    });
+
+  auto
+    .command('status [id]')
+    .description('Show one autonomous strategy or all active strategies')
+    .action((id) => {
+      showMiniBanner();
+      showSection('AUTONOMOUS STATUS');
+
+      if (!id) {
+        const items = getAutoStatus();
+        if (!items.length) {
+          warn('No autonomous strategies found');
+          console.log('');
+          return;
+        }
+        items.forEach((item) => {
+          kvDisplay([
+            ['ID', item.id],
+            ['Status', item.status],
+            ['Spent', `${item.spent}/${item.budget} USDC`],
+            ['Trades', String(item.tradesExecuted)],
+            ['PnL', `${item.pnl}`],
+            ['Next Check', item.nextCheckAt || '-'],
+          ]);
+          console.log('');
+        });
+        return;
+      }
+
+      const strategy = getAutoStatus(id);
+      if (!strategy) {
+        warn(`Strategy not found: ${id}`);
+        console.log('');
+        return;
+      }
+
+      kvDisplay([
+        ['ID', strategy.id],
+        ['Goal', strategy.goal],
+        ['Status', strategy.status],
+        ['Spent', `${strategy.spent}/${strategy.budget} USDC`],
+        ['Trades', String(strategy.tradesExecuted)],
+        ['PnL', `${strategy.pnl}`],
+        ['Risk', strategy.riskLevel],
+        ['Mode', strategy.dryRun ? 'dry-run' : 'live'],
+        ['Next Check', strategy.nextCheckAt || '-'],
+        ['Last Decision', strategy.lastDecision || '-'],
+      ]);
+      console.log('');
+    });
+
+  auto
+    .command('log <id>')
+    .description('Show the recent autonomous audit log')
+    .option('--limit <n>', 'Number of audit entries', '20')
+    .action((id, opts) => {
+      showMiniBanner();
+      showSection('AUTONOMOUS AUDIT');
+      const entries = getAuditLog(id, parseInt(opts.limit, 10));
+      if (!entries.length) {
+        warn('No audit entries found');
+        console.log('');
+        return;
+      }
+
+      entries.forEach((entry) => {
+        const headline = `${entry.timestamp}  ${entry.type}${entry.action ? ` ${entry.action}` : ''}`;
+        console.log(`  ${theme.gold(headline)}`);
+        if (entry.reason) console.log(`  ${theme.dim(entry.reason)}`);
+        if (entry.message) console.log(`  ${theme.dim(entry.message)}`);
+        if (entry.price !== undefined) console.log(`  ${theme.dim(`price: ${entry.price}`)}`);
+        console.log('');
+      });
+    });
+
+  auto
+    .command('list')
+    .description('List all autonomous strategies')
+    .action(() => {
+      showMiniBanner();
+      showSection('AUTONOMOUS STRATEGIES');
+      const items = listAutoStrategies();
+      if (!items.length) {
+        warn('No autonomous strategies found');
+        console.log('');
+        return;
+      }
+
+      items.forEach((item) => {
+        kvDisplay([
+          ['ID', item.id],
+          ['Status', item.status],
+          ['Spent', `${item.spent}/${item.budget} USDC`],
+          ['Trades', String(item.tradesExecuted)],
+          ['PnL', `${item.pnl}`],
+          ['Next Check', item.nextCheckAt || '-'],
+        ]);
+        console.log('');
+      });
+    });
+
   // ═══════════════════════════════════════
   // MARKET COMMANDS
   // ═══════════════════════════════════════
@@ -1132,6 +1356,52 @@ export function cli(argv) {
     .option('-p, --port <port>', 'Health server port', '18792')
     .action((opts) => daemonRestart(opts));
 
+  const whale = program
+    .command('whale')
+    .description('Whale Radar - wallet tracking and mirror trades');
+
+  whale
+    .command('track <address>')
+    .description('Track a wallet for new activity')
+    .option('-c, --chain <chain>', 'Chain to monitor', 'base')
+    .option('-l, --label <label>', 'Friendly wallet label')
+    .option('--notify', 'Enable terminal notifications', true)
+    .action((address, opts) => trackWallet(address, opts));
+
+  whale
+    .command('list')
+    .description('List tracked whale wallets')
+    .action(() => listTracked());
+
+  whale
+    .command('stop <address>')
+    .description('Stop tracking a wallet')
+    .action((address) => stopTracking(address));
+
+  whale
+    .command('mirror <address>')
+    .description('Enable copy-trading for a tracked whale')
+    .option('--max <amount>', 'Max USDC-equivalent per trade')
+    .option('-s, --slippage <pct>', 'Mirror trade slippage %', '2')
+    .option('--dry-run', 'Log mirror trades without executing')
+    .action((address, opts) => mirrorTrade(address, {
+      maxPerTrade: opts.max ? parseFloat(opts.max) : null,
+      slippage: parseFloat(opts.slippage),
+      dryRun: Boolean(opts.dryRun),
+    }));
+
+  whale
+    .command('activity <address>')
+    .description('Show recent activity for a whale wallet')
+    .option('-l, --limit <n>', 'Number of transactions', '10')
+    .option('-c, --chain <chain>', 'Chain to query', 'base')
+    .action((address, opts) => getWhaleActivity(address, parseInt(opts.limit, 10), opts));
+
+  whale
+    .command('feed')
+    .description('Open the live whale event feed')
+    .action(() => startWhaleFeed());
+
   // ═══════════════════════════════════════
   // TELEGRAM COMMANDS
   // ═══════════════════════════════════════
@@ -1389,6 +1659,19 @@ export function cli(argv) {
       }
     });
 
+  program
+    .command('dash')
+    .description('Launch the live terminal dashboard')
+    .option('--refresh <seconds>', 'Refresh interval in seconds', '30')
+    .option('--compact', 'Use the compact 2-panel layout')
+    .action(async (opts) => {
+      const dashboard = createDashboard({
+        refresh: parseInt(opts.refresh, 10),
+        compact: Boolean(opts.compact),
+      });
+      await dashboard.ready;
+    });
+
   // ═══════════════════════════════════════
   // FUZZY / NATURAL LANGUAGE FALLBACK
   // ═══════════════════════════════════════
@@ -1717,6 +2000,8 @@ function showCommandList() {
     ['watch', 'Live price monitoring + alerts'],
     ['gas', 'Gas prices & cost estimates'],
     ['trade', 'Swap tokens, snipe, trading'],
+    ['arb', 'Cross-DEX arbitrage scanner'],
+    ['auto', 'Autonomous trader strategies'],
     ['bridge', 'Cross-chain bridge (LI.FI)'],
     ['dca', 'Dollar-cost averaging orders'],
     ['ai chat', 'Standalone AI chat session'],
@@ -1727,6 +2012,7 @@ function showCommandList() {
     ['memory', 'Persistent cross-session memory'],
     ['script', 'Execution scripts & strategies'],
     ['market', 'Market intel & token data'],
+    ['whale', 'Whale Radar - wallet tracking'],
     ['oracle', 'On-chain random oracle'],
     ['casino', 'The Clawsino - betting'],
     ['poker', 'GTO Poker Arena — heads-up holdem'],

package/src/config/keys.js

@@ -126,6 +126,14 @@ export const SERVICES = {
     docsUrl: 'https://docs.dexscreener.com',
     validate: (key) => key.length > 10,
   },
+  etherscan: {
+    name: 'Etherscan',
+    category: 'data',
+    description: 'Explorer APIs — Etherscan, Basescan, Arbiscan, Polygonscan',
+    envVar: 'ETHERSCAN_API_KEY',
+    docsUrl: 'https://etherscan.io/apis',
+    validate: (key) => key.length > 10,
+  },
   defillama: {
     name: 'DefiLlama',
     category: 'data',
@@ -298,6 +306,14 @@ export function getKeyFromEnv(service) {
   return null;
 }
 
+/**
+ * Get an API key without prompting.
+ * Prefers auto-stored keys, then environment variables.
+ */
+export function getApiKey(service) {
+  return getKeyAuto(service) || getKeyFromEnv(service);
+}
+
 /**
  * Remove a key
  */

package/src/config/store.js

@@ -51,6 +51,40 @@ const config = new Conf({
         maxOrders: 100,
       },
     },
+    autonomous: {
+      type: 'object',
+      default: {
+        strategies: [],
+      },
+    },
+    arb: {
+      type: 'object',
+      default: {
+        enabled: false,
+        minProfitUsd: 0.50,
+        maxTradeSize: 1.0,
+        gasCeiling: 0.01,
+        cooldownMs: 5000,
+        dryRun: true,
+        tokenAllowlist: [],
+        tokenDenylist: [],
+        endpoints: {
+          wss: {},
+          rpc: {},
+        },
+        dexes: {
+          base:     ['uniswapV3', 'aerodrome', 'sushiswap'],
+          ethereum: ['uniswapV3', 'sushiswap'],
+          arbitrum: ['uniswapV3', 'sushiswap', 'camelot'],
+          optimism: ['uniswapV3', 'velodrome'],
+          polygon:  ['uniswapV3', 'quickswap'],
+        },
+        pairs: [
+          { tokenA: 'WETH', tokenB: 'USDC' },
+          { tokenA: 'WETH', tokenB: 'USDT' },
+        ],
+      },
+    },
     services: {
       type: 'object',
       default: {

package/src/llm/intent.js

@@ -66,6 +66,8 @@ ACTIONS (use the most specific one):
 - "gas" — gas price check
 - "cards" — order a prepaid Visa/Mastercard with crypto (e.g. "order a $50 card", "get me a prepaid card")
 - "casino" — play a casino game (coinflip, dice, hilo, slots). All bets are $1 USDC. (e.g. "flip a coin", "bet on heads", "play slots", "roll dice over 3")
+- "arb_scan" — scan for cross-DEX arbitrage opportunities (e.g. "find arb opportunities", "scan for price differences", "check arb on base")
+- "arb_monitor" — start real-time arbitrage monitoring (e.g. "monitor arb", "watch for arb opportunities")
 - "unknown" — can't determine what the user wants
 
 CASINO GAMES:

package/src/services/gas.js

@@ -1,49 +1,49 @@
 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 { spinner, kvDisplay, error, 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);
+export async function fetchGasSnapshot(chain) {
+  const resolvedChain = chain || getConfig('chain') || 'base';
+  const rpc = getRPC(resolvedChain);
   const provider = new ethers.JsonRpcProvider(rpc);
+  const feeData = await provider.getFeeData();
+  const block = await provider.getBlock('latest');
+
+  return {
+    chain: resolvedChain,
+    blockNumber: block?.number || null,
+    feeData,
+    gasPrice: feeData.gasPrice ? parseFloat(ethers.formatUnits(feeData.gasPrice, 'gwei')) : 0,
+    maxFee: feeData.maxFeePerGas ? parseFloat(ethers.formatUnits(feeData.maxFeePerGas, 'gwei')) : 0,
+    maxPriority: feeData.maxPriorityFeePerGas ? parseFloat(ethers.formatUnits(feeData.maxPriorityFeePerGas, 'gwei')) : 0,
+    baseFee: block?.baseFeePerGas ? parseFloat(ethers.formatUnits(block.baseFeePerGas, 'gwei')) : 0,
+    ethPrice: await getETHPrice(),
+  };
+}
 
-  const spin = spinner(`Fetching gas on ${chain}...`).start();
+export async function showGas(chain) {
+  const resolvedChain = chain || getConfig('chain') || 'base';
+  const spin = spinner(`Fetching gas on ${resolvedChain}...`).start();
 
   try {
-    const feeData = await provider.getFeeData();
-    const block = await provider.getBlock('latest');
-
+    const snapshot = await fetchGasSnapshot(resolvedChain);
     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()}`);
+    showSection(`GAS - ${resolvedChain.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 || '?'}`],
+      ['Gas Price', `${snapshot.gasPrice.toFixed(4)} gwei`],
+      ['Base Fee', `${snapshot.baseFee.toFixed(4)} gwei`],
+      ['Max Fee', `${snapshot.maxFee.toFixed(4)} gwei`],
+      ['Priority Fee', `${snapshot.maxPriority.toFixed(4)} gwei`],
+      ['Block', `#${snapshot.blockNumber || '?'}`],
     ]);
 
-    // 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 },
@@ -54,29 +54,25 @@ export async function showGas(chain) {
     ];
 
     estimates.forEach(({ name, gas }) => {
-      const costWei = gas * (feeData.gasPrice || 0n);
+      const costWei = gas * (snapshot.feeData.gasPrice || 0n);
       const costETH = parseFloat(ethers.formatEther(costWei));
-      const costUSD = costETH * ethPrice;
-      const label = name.padEnd(24);
+      const costUSD = costETH * snapshot.ethPrice;
       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(`  ${theme.dim(name.padEnd(24))} ${ethStr.padEnd(16)} ${theme.gold(usdStr)}`);
     });
 
     console.log('');
-    info(`ETH price: $${ethPrice.toFixed(2)}`);
+    info(`ETH price: $${snapshot.ethPrice.toFixed(2)}`);
     console.log('');
 
-    return { chain, gasPrice, baseFee, maxFee, maxPriority, ethPrice };
+    return snapshot;
   } 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;
@@ -88,12 +84,9 @@ async function getETHPrice() {
   }
 }
 
-/**
- * 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 resolvedChain = chain || getConfig('chain') || 'base';
+  const rpc = getRPC(resolvedChain);
   const provider = new ethers.JsonRpcProvider(rpc);
 
   try {