@darksol/terminal 0.11.0 → 0.12.0

package/src/agent/strategy-evaluator.js

@@ -0,0 +1,166 @@
+import { topMovers } from '../services/market.js';
+import { checkPrices } from '../services/watch.js';
+import { getConfig } from '../config/store.js';
+import { estimateGasCost, getProvider, quickPrice } from '../utils/helpers.js';
+
+const DEFAULT_COOLDOWN_MS = 15 * 60 * 1000;
+
+const evaluatorDeps = {
+  quickPrice,
+  topMovers,
+  checkPrices,
+  getProvider,
+  estimateGasCost,
+  now: () => Date.now(),
+};
+
+function riskProfile(level = 'moderate') {
+  const profiles = {
+    conservative: { gasGwei: 1.5, cooldownMs: 30 * 60 * 1000, minConfidence: 0.75 },
+    moderate: { gasGwei: 3, cooldownMs: 15 * 60 * 1000, minConfidence: 0.6 },
+    aggressive: { gasGwei: 10, cooldownMs: 5 * 60 * 1000, minConfidence: 0.45 },
+  };
+  return profiles[level] || profiles.moderate;
+}
+
+function normalizeToken(symbol) {
+  return typeof symbol === 'string' ? symbol.trim().toUpperCase() : '';
+}
+
+async function collectMarketData(strategy, deps = evaluatorDeps) {
+  const primaryToken = normalizeToken(
+    strategy?.plan?.primaryToken
+    || strategy?.plan?.entry?.token
+    || strategy?.intent?.tokenOut
+    || strategy?.intent?.token
+  );
+  const quoteToken = normalizeToken(strategy?.plan?.quoteToken || strategy?.intent?.tokenIn || 'USDC');
+  const currentPrice = primaryToken ? await deps.quickPrice(primaryToken) : null;
+
+  try {
+    if (primaryToken) {
+      await deps.checkPrices([primaryToken]);
+    }
+  } catch {}
+
+  return {
+    primaryToken,
+    quoteToken,
+    currentPrice,
+    price: currentPrice?.price ? Number(currentPrice.price) : null,
+    liquidity: currentPrice?.liquidity ? Number(currentPrice.liquidity) : 0,
+    change24h: currentPrice?.change24h !== undefined ? Number(currentPrice.change24h) : null,
+    volume24h: currentPrice?.volume24h ? Number(currentPrice.volume24h) : 0,
+    timestamp: new Date(deps.now()).toISOString(),
+  };
+}
+
+export async function evaluateConditions(strategy) {
+  const deps = evaluatorDeps;
+  const profile = riskProfile(strategy?.riskLevel);
+  const marketData = await collectMarketData(strategy, deps);
+  const provider = deps.getProvider(strategy?.chains?.[0] || getConfig('chain') || 'base');
+  const gas = await deps.estimateGasCost(provider, 180000n);
+  const gasGwei = Number(gas.gwei || 0);
+  const gasTooHigh = gasGwei > profile.gasGwei;
+
+  const lastTradeAt = strategy?.lastTradeAt ? new Date(strategy.lastTradeAt).getTime() : 0;
+  const cooldownMs = strategy?.plan?.cooldownMs || profile.cooldownMs || DEFAULT_COOLDOWN_MS;
+  const inCooldown = Boolean(lastTradeAt) && (deps.now() - lastTradeAt) < cooldownMs;
+  const minLiquidity = Number(strategy?.plan?.filters?.minLiquidity || 0);
+  const priceBelow = strategy?.plan?.entry?.priceBelow;
+  const priceAbove = strategy?.plan?.entry?.priceAbove;
+  const hasPrice = typeof marketData.price === 'number' && !Number.isNaN(marketData.price);
+
+  const meetsLiquidity = marketData.liquidity >= minLiquidity;
+  const meetsPriceBelow = !priceBelow || (hasPrice && marketData.price <= priceBelow);
+  const meetsPriceAbove = !priceAbove || (hasPrice && marketData.price >= priceAbove);
+  const hasBudget = Number(strategy?.budget || 0) > Number(strategy?.spent || 0);
+  const maxPerTrade = Number(strategy?.maxPerTrade || strategy?.budget || 0);
+  const remainingBudget = Math.max(0, Number(strategy?.budget || 0) - Number(strategy?.spent || 0));
+  const tradeAmount = Math.min(maxPerTrade, remainingBudget);
+  const withinTradeLimit = tradeAmount > 0 && tradeAmount <= maxPerTrade;
+
+  return {
+    ...marketData,
+    gasGwei,
+    gasTooHigh,
+    inCooldown,
+    cooldownMs,
+    remainingBudget,
+    tradeAmount,
+    withinTradeLimit,
+    meetsLiquidity,
+    meetsEntry: hasBudget && meetsLiquidity && meetsPriceBelow && meetsPriceAbove,
+    meetsExit: Boolean(
+      hasPrice
+      && (
+        (strategy?.plan?.exit?.takeProfitPrice && marketData.price >= strategy.plan.exit.takeProfitPrice)
+        || (strategy?.plan?.exit?.stopLossPrice && marketData.price <= strategy.plan.exit.stopLossPrice)
+      )
+    ),
+  };
+}
+
+export async function shouldTrade(strategy, marketData) {
+  const profile = riskProfile(strategy?.riskLevel);
+  const conditions = marketData || await evaluateConditions(strategy);
+  const amount = Number(conditions.tradeAmount || 0);
+
+  if (!conditions.currentPrice) {
+    return { action: 'hold', reason: 'No market data for target token', confidence: 0.1 };
+  }
+  if (conditions.gasTooHigh) {
+    return { action: 'hold', reason: `Gas too high (${conditions.gasGwei.toFixed(2)} gwei)`, confidence: 0.15 };
+  }
+  if (!conditions.withinTradeLimit) {
+    return { action: 'hold', reason: 'Per-trade or budget limit reached', confidence: 0.1 };
+  }
+  if (conditions.inCooldown) {
+    return { action: 'hold', reason: 'Token cooldown active', confidence: 0.2 };
+  }
+  if (conditions.meetsExit && Number(strategy?.positionSize || 0) > 0) {
+    return { action: 'sell', reason: 'Exit conditions met', confidence: 0.8 };
+  }
+  if (!conditions.meetsEntry) {
+    const reasons = [];
+    if (!conditions.meetsLiquidity) reasons.push('liquidity below filter');
+    if (strategy?.plan?.entry?.priceBelow && conditions.price > strategy.plan.entry.priceBelow) reasons.push('price above entry threshold');
+    if (strategy?.plan?.entry?.priceAbove && conditions.price < strategy.plan.entry.priceAbove) reasons.push('price below momentum threshold');
+    if (amount <= 0) reasons.push('budget exhausted');
+    return { action: 'hold', reason: reasons.join(', ') || 'Entry conditions not met', confidence: 0.25 };
+  }
+
+  let confidence = 0.55;
+  if (strategy?.plan?.entry?.priceBelow && conditions.price <= strategy.plan.entry.priceBelow) confidence += 0.15;
+  if (conditions.liquidity >= Number(strategy?.plan?.filters?.minLiquidity || 0) * 2) confidence += 0.1;
+  if (typeof conditions.change24h === 'number') {
+    if (strategy?.plan?.mode === 'dca') confidence += 0.05;
+    else if (conditions.change24h > 0) confidence += 0.1;
+    else confidence -= 0.05;
+  }
+
+  confidence = Math.max(0, Math.min(0.99, confidence));
+  if (confidence < profile.minConfidence) {
+    return { action: 'hold', reason: 'Signal below risk threshold', confidence };
+  }
+
+  return {
+    action: 'buy',
+    reason: `Entry conditions met for ${conditions.primaryToken} using ${amount.toFixed(2)} ${conditions.quoteToken}`,
+    confidence,
+  };
+}
+
+export function __setEvaluatorDeps(overrides = {}) {
+  Object.assign(evaluatorDeps, overrides);
+}
+
+export function __resetEvaluatorDeps() {
+  evaluatorDeps.quickPrice = quickPrice;
+  evaluatorDeps.topMovers = topMovers;
+  evaluatorDeps.checkPrices = checkPrices;
+  evaluatorDeps.getProvider = getProvider;
+  evaluatorDeps.estimateGasCost = estimateGasCost;
+  evaluatorDeps.now = () => Date.now();
+}

package/src/cli.js

@@ -2,12 +2,15 @@ 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';
@@ -42,6 +45,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 +333,159 @@ export function cli(argv) {
     .description('Execute pending DCA orders')
     .action(() => runDCA());
 
+  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 +1289,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 +1592,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 +1933,7 @@ function showCommandList() {
     ['watch', 'Live price monitoring + alerts'],
     ['gas', 'Gas prices & cost estimates'],
     ['trade', 'Swap tokens, snipe, trading'],
+    ['auto', 'Autonomous trader strategies'],
     ['bridge', 'Cross-chain bridge (LI.FI)'],
     ['dca', 'Dollar-cost averaging orders'],
     ['ai chat', 'Standalone AI chat session'],
@@ -1727,6 +1944,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,12 @@ const config = new Conf({
         maxOrders: 100,
       },
     },
+    autonomous: {
+      type: 'object',
+      default: {
+        strategies: [],
+      },
+    },
     services: {
       type: 'object',
       default: {

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 {