@darksol/terminal 0.7.2 → 0.8.0

package/README.md

@@ -15,7 +15,7 @@ A unified CLI for market intel, trading, AI-powered analysis, on-chain oracle, c
 [![License: GPL-3.0](https://img.shields.io/badge/License-GPL--3.0-gold.svg)](https://www.gnu.org/licenses/gpl-3.0)
 [![Node](https://img.shields.io/badge/node-%3E%3D18.0.0-green.svg)](https://nodejs.org/)
 
-- Current release: **0.7.2**
+- Current release: **0.8.0**
 - Changelog: `CHANGELOG.md`
 
 ## Install
@@ -48,9 +48,14 @@ darksol watch AERO --above 2.0
 # Gas estimates
 darksol gas base
 
-# Swap tokens (Uniswap V3 with slippage protection)
+# Swap tokens (LI.FI — best route across 31 DEXs, Uniswap V3 fallback)
 darksol trade swap -i ETH -o USDC -a 0.1
 
+# Cross-chain bridge (60+ chains via LI.FI)
+darksol bridge send --from base --to arbitrum --token ETH -a 0.1
+darksol bridge status 0xTxHash...
+darksol bridge chains
+
 # AI trading assistant
 darksol ai chat
 
@@ -71,7 +76,8 @@ darksol agent start main
 
 - Arrow-key menus (`↑/↓` + `Enter`) for wallet/config/trade flows
 - **Interactive send** — token → recipient → amount → password → on-chain transfer
-- **Interactive swap** — pair picker (presets + custom) → amount → password → Uniswap V3 execution
+- **Interactive swap** — pair picker (presets + custom) → amount → password → LI.FI execution (Uniswap V3 fallback)
+- **Interactive bridge** — source chain → dest chain → token → amount → password → cross-chain via LI.FI
 - **Interactive snipe** — contract input → amount → password → fast buy
 - Wallet picker + wallet action menu (receive/send/portfolio/history/switch chain)
 - Agent signer control center (`agent`) with guided wallet selection + start/stop/status
@@ -87,7 +93,8 @@ Useful web-shell commands:
 
 ```bash
 help          # clickable command menu (arrow keys + Enter)
-trade         # interactive swap / snipe menu
+trade         # interactive swap / snipe / bridge menu
+bridge        # cross-chain bridge (LI.FI)
 send          # interactive token transfer
 wallet        # interactive wallet picker and actions
 keys          # provider status + interactive add/update
@@ -104,7 +111,8 @@ ai <prompt>   # chat with trading assistant
 | `wallet` | Create/import/manage encrypted EVM wallets | Free |
 | `send` | Send ETH or ERC-20 tokens | Gas only |
 | `receive` | Show receive address + chain safety hints | Free |
-| `trade` | Swap (Uniswap V3), snipe (V2), token trading | Gas only |
+| `trade` | Swap via LI.FI (31 DEXs) + Uniswap V3 fallback, snipe | Gas only |
+| `bridge` | Cross-chain bridge via LI.FI (60 chains, 27 bridges) | Gas only |
 | `dca` | Dollar-cost averaging engine | Gas only |
 | `ai` | LLM-powered trading assistant & intent execution | Provider dependent |
 | `agent` | Secure agent signer (PK-isolated proxy) | Free |

package/package.json

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

package/src/cli.js

@@ -13,6 +13,7 @@ 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 { 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';
 import { casinoBet, casinoTables, casinoStats, casinoReceipt, casinoHealth, casinoVerify } from './services/casino.js';
@@ -113,7 +114,7 @@ export function cli(argv) {
 
   trade
     .command('swap')
-    .description('Swap tokens via DEX (interactive if flags omitted)')
+    .description('Swap tokens via LI.FI (58 chains, 31 DEXs) with Uniswap fallback')
     .option('-i, --in <token>', 'Token to sell (symbol or address)')
     .option('-o, --out <token>', 'Token to buy (symbol or address)')
     .option('-a, --amount <amount>', 'Amount to swap')
@@ -121,6 +122,7 @@ export function cli(argv) {
     .option('-w, --wallet <name>', 'Wallet to use')
     .option('-p, --password <pw>', 'Wallet password (non-interactive)')
     .option('-y, --yes', 'Skip confirmation')
+    .option('--direct', 'Force direct Uniswap V3 (skip LI.FI)')
     .action(async (opts) => {
       let tokenIn = opts.in;
       let tokenOut = opts.out;
@@ -138,7 +140,7 @@ export function cli(argv) {
         amount = answers.amount;
       }
 
-      return executeSwap({
+      const swapOpts = {
         tokenIn,
         tokenOut,
         amount,
@@ -146,7 +148,30 @@ export function cli(argv) {
         wallet: opts.wallet,
         password: opts.password,
         confirm: opts.yes ? true : undefined,
-      });
+      };
+
+      // Try LI.FI first (unless --direct flag)
+      if (!opts.direct) {
+        try {
+          const result = await executeLifiSwap(swapOpts);
+          if (result?.success) return;
+          // If LI.FI failed (not cancelled), fall back to direct
+          if (result?.error !== 'cancelled') {
+            const { warn: showWarn, info: showInfo } = await import('./ui/components.js');
+            showWarn('LI.FI route failed — falling back to direct Uniswap V3...');
+            console.log('');
+          } else {
+            return; // User cancelled, don't fallback
+          }
+        } catch {
+          const { warn: showWarn } = await import('./ui/components.js');
+          showWarn('LI.FI unavailable — falling back to direct Uniswap V3...');
+          console.log('');
+        }
+      }
+
+      // Direct Uniswap V3 fallback
+      return executeSwap(swapOpts);
     });
 
   trade
@@ -193,6 +218,71 @@ export function cli(argv) {
       console.log('');
     });
 
+  // ═══════════════════════════════════════
+  // BRIDGE COMMANDS (LI.FI)
+  // ═══════════════════════════════════════
+  const bridge = program
+    .command('bridge')
+    .description('Cross-chain bridge — move tokens between chains via LI.FI');
+
+  bridge
+    .command('send')
+    .description('Bridge tokens to another chain')
+    .option('-f, --from <chain>', 'Source chain (e.g. base, ethereum)')
+    .option('-t, --to <chain>', 'Destination chain (e.g. arbitrum, optimism)')
+    .option('--token <symbol>', 'Token to bridge (e.g. ETH, USDC)', 'ETH')
+    .option('-a, --amount <amount>', 'Amount to bridge')
+    .option('-s, --slippage <percent>', 'Max slippage %', '0.5')
+    .option('-w, --wallet <name>', 'Wallet to use')
+    .option('-p, --password <pw>', 'Wallet password (non-interactive)')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (opts) => {
+      let fromChain = opts.from;
+      let toChain = opts.to;
+      let token = opts.token;
+      let amount = opts.amount;
+
+      if (!fromChain || !toChain || !amount) {
+        const inquirer = (await import('inquirer')).default;
+        const answers = await inquirer.prompt([
+          { type: 'input', name: 'fromChain', message: 'Source chain:', default: fromChain || getConfig('chain') || 'base' },
+          { type: 'input', name: 'toChain', message: 'Destination chain:', default: toChain || 'arbitrum' },
+          { type: 'input', name: 'token', message: 'Token to bridge:', default: token || 'ETH' },
+          { type: 'input', name: 'amount', message: 'Amount:', default: amount || '0.1' },
+        ]);
+        fromChain = answers.fromChain;
+        toChain = answers.toChain;
+        token = answers.token;
+        amount = answers.amount;
+      }
+
+      return executeLifiBridge({
+        fromChain,
+        toChain,
+        token,
+        amount,
+        slippage: parseFloat(opts.slippage),
+        wallet: opts.wallet,
+        password: opts.password,
+        confirm: opts.yes ? true : undefined,
+      });
+    });
+
+  bridge
+    .command('status <txHash>')
+    .description('Check bridge transfer status')
+    .option('-f, --from <chain>', 'Source chain')
+    .option('-t, --to <chain>', 'Destination chain')
+    .action((txHash, opts) => checkBridgeStatus(txHash, {
+      fromChain: opts.from,
+      toChain: opts.to,
+    }));
+
+  bridge
+    .command('chains')
+    .description('Show all supported chains')
+    .action(() => showSupportedChains());
+
   // ═══════════════════════════════════════
   // DCA COMMANDS
   // ═══════════════════════════════════════
@@ -1109,6 +1199,7 @@ function showCommandList() {
     ['watch', 'Live price monitoring + alerts'],
     ['gas', 'Gas prices & cost estimates'],
     ['trade', 'Swap tokens, snipe, trading'],
+    ['bridge', 'Cross-chain bridge (LI.FI)'],
     ['dca', 'Dollar-cost averaging orders'],
     ['ai chat', 'Standalone AI chat session'],
     ['ai execute', 'Parse + execute a trade via AI'],

package/src/config/keys.js

@@ -178,6 +178,14 @@ export const SERVICES = {
     docsUrl: 'https://developers.paraswap.network',
     validate: (key) => key.length > 5,
   },
+  lifi: {
+    name: 'LI.FI',
+    category: 'trading',
+    description: 'Cross-chain swaps & bridges — 58 chains, 27 bridges, 31 DEXs',
+    envVar: 'LIFI_API_KEY',
+    docsUrl: 'https://docs.li.fi/api-reference/rate-limits',
+    validate: (key) => key.length > 20,
+  },
 };
 
 // ──────────────────────────────────────────────────

package/src/services/lifi.js

@@ -0,0 +1,713 @@
+/**
+ * LI.FI API Client — Cross-chain swaps & bridges
+ * https://docs.li.fi/agents/overview
+ *
+ * Primary swap/bridge engine for DARKSOL Terminal.
+ * Free tier: 200 req/2hr (no key), 200 req/min (with key).
+ */
+
+import { getKeyAuto, getKeyFromEnv, hasKey } from '../config/keys.js';
+import { getConfig, getRPC } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, success, error, warn, info, formatAddress } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+import { getSigner } from '../wallet/manager.js';
+import { ethers } from 'ethers';
+import inquirer from 'inquirer';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const BASE_URL = 'https://li.quest/v1';
+const CACHE_DIR = join(homedir(), '.darksol', 'cache');
+const CACHE_TTL = 6 * 60 * 60 * 1000; // 6 hours for chains/tokens
+
+// Chain name → LI.FI chain ID mapping
+const CHAIN_IDS = {
+  ethereum: 1,
+  base: 8453,
+  arbitrum: 42161,
+  optimism: 10,
+  polygon: 137,
+  avalanche: 43114,
+  bsc: 56,
+  gnosis: 100,
+  fantom: 250,
+  zksync: 324,
+  scroll: 534352,
+  linea: 59144,
+  mantle: 5000,
+  celo: 42220,
+  blast: 81457,
+  mode: 34443,
+};
+
+// Reverse: chain ID → name
+const CHAIN_NAMES = Object.fromEntries(
+  Object.entries(CHAIN_IDS).map(([name, id]) => [id, name])
+);
+
+// ──────────────────────────────────────────────────
+// HTTP HELPER
+// ──────────────────────────────────────────────────
+
+function getHeaders() {
+  const headers = { 'Accept': 'application/json' };
+  // Try vault first, then env
+  const apiKey = getKeyAuto('lifi') || getKeyFromEnv('lifi');
+  if (apiKey) {
+    headers['x-lifi-api-key'] = apiKey;
+  }
+  return headers;
+}
+
+async function lifiGet(endpoint, params = {}) {
+  const url = new URL(`${BASE_URL}${endpoint}`);
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== undefined && v !== null) url.searchParams.set(k, v);
+  }
+
+  const resp = await fetch(url.toString(), { headers: getHeaders() });
+
+  if (resp.status === 429) {
+    const reset = resp.headers.get('ratelimit-reset');
+    throw new Error(`Rate limited. Resets in ${reset || '?'}s. Add a free API key: darksol keys add lifi`);
+  }
+
+  if (!resp.ok) {
+    const body = await resp.text().catch(() => '');
+    throw new Error(`LI.FI API ${resp.status}: ${body}`);
+  }
+
+  return resp.json();
+}
+
+// ──────────────────────────────────────────────────
+// CACHE HELPERS
+// ──────────────────────────────────────────────────
+
+function ensureCacheDir() {
+  if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
+}
+
+function getCached(key) {
+  try {
+    const path = join(CACHE_DIR, `lifi-${key}.json`);
+    if (!existsSync(path)) return null;
+    const data = JSON.parse(readFileSync(path, 'utf8'));
+    if (Date.now() - data.ts > CACHE_TTL) return null;
+    return data.value;
+  } catch { return null; }
+}
+
+function setCache(key, value) {
+  try {
+    ensureCacheDir();
+    writeFileSync(
+      join(CACHE_DIR, `lifi-${key}.json`),
+      JSON.stringify({ ts: Date.now(), value })
+    );
+  } catch { /* cache write failures are non-fatal */ }
+}
+
+// ──────────────────────────────────────────────────
+// PUBLIC API
+// ──────────────────────────────────────────────────
+
+/**
+ * Get supported chains (cached)
+ */
+export async function getChains() {
+  const cached = getCached('chains');
+  if (cached) return cached;
+  const data = await lifiGet('/chains');
+  setCache('chains', data.chains);
+  return data.chains;
+}
+
+/**
+ * Get supported tokens for a chain (cached)
+ */
+export async function getTokens(chainId) {
+  const cacheKey = `tokens-${chainId}`;
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+  const data = await lifiGet('/tokens', { chains: chainId });
+  const tokens = data.tokens?.[chainId] || [];
+  setCache(cacheKey, tokens);
+  return tokens;
+}
+
+/**
+ * Get a quote for a swap or bridge
+ * Returns a ready-to-sign transaction
+ */
+export async function getQuote({
+  fromChain,
+  toChain,
+  fromToken,
+  toToken,
+  fromAmount,
+  fromAddress,
+  slippage,
+}) {
+  const fromChainId = typeof fromChain === 'number' ? fromChain : CHAIN_IDS[fromChain];
+  const toChainId = typeof toChain === 'number' ? toChain : CHAIN_IDS[toChain];
+
+  if (!fromChainId) throw new Error(`Unknown chain: ${fromChain}`);
+  if (!toChainId) throw new Error(`Unknown chain: ${toChain}`);
+
+  return lifiGet('/quote', {
+    fromChain: fromChainId,
+    toChain: toChainId,
+    fromToken,
+    toToken,
+    fromAmount,
+    fromAddress,
+    slippage: slippage ? slippage / 100 : 0.005, // LI.FI uses decimal (0.005 = 0.5%)
+  });
+}
+
+/**
+ * Check transfer status (for cross-chain)
+ */
+export async function getStatus(txHash, opts = {}) {
+  return lifiGet('/status', {
+    txHash,
+    fromChain: opts.fromChain,
+    toChain: opts.toChain,
+    bridge: opts.bridge,
+  });
+}
+
+/**
+ * Get available bridges and exchanges
+ */
+export async function getTools() {
+  const cached = getCached('tools');
+  if (cached) return cached;
+  const data = await lifiGet('/tools');
+  setCache('tools', data);
+  return data;
+}
+
+/**
+ * Resolve chain name to LI.FI chain ID
+ */
+export function resolveChainId(chain) {
+  if (typeof chain === 'number') return chain;
+  return CHAIN_IDS[chain.toLowerCase()] || null;
+}
+
+/**
+ * Resolve chain ID to name
+ */
+export function resolveChainName(chainId) {
+  return CHAIN_NAMES[chainId] || `chain-${chainId}`;
+}
+
+/**
+ * Check if LI.FI has an API key configured
+ */
+export function hasLifiKey() {
+  return hasKey('lifi');
+}
+
+// ──────────────────────────────────────────────────
+// ERC20 ABI (for approvals)
+// ──────────────────────────────────────────────────
+
+const ERC20_ABI = [
+  'function approve(address spender, uint256 amount) returns (bool)',
+  'function allowance(address owner, address spender) view returns (uint256)',
+  'function balanceOf(address) view returns (uint256)',
+  'function decimals() view returns (uint8)',
+  'function symbol() view returns (string)',
+];
+
+// ──────────────────────────────────────────────────
+// SWAP VIA LI.FI
+// ──────────────────────────────────────────────────
+
+/**
+ * Execute a swap via LI.FI (same-chain)
+ */
+export async function executeLifiSwap(opts = {}) {
+  const {
+    tokenIn,
+    tokenOut,
+    amount,
+    wallet: walletName,
+    slippage,
+    password: providedPassword,
+    confirm: providedConfirm,
+  } = opts;
+
+  const chain = getConfig('chain') || 'base';
+  const chainId = resolveChainId(chain);
+  const maxSlippage = slippage || getConfig('slippage') || 0.5;
+
+  if (!chainId) {
+    error(`Unknown chain: ${chain}`);
+    return { success: false, error: 'unknown_chain' };
+  }
+
+  // Get wallet password
+  let password = providedPassword;
+  if (!password) {
+    const prompted = await inquirer.prompt([{
+      type: 'password',
+      name: 'password',
+      message: theme.gold('Wallet password:'),
+      mask: '●',
+    }]);
+    password = prompted.password;
+  }
+
+  const spin = spinner('Getting LI.FI quote...').start();
+
+  try {
+    const { signer, provider, address } = await getSigner(walletName, password);
+
+    // Resolve token symbols to addresses if needed
+    const fromToken = tokenIn.startsWith('0x') ? tokenIn : tokenIn.toUpperCase();
+    const toToken = tokenOut.startsWith('0x') ? tokenOut : tokenOut.toUpperCase();
+
+    // For native ETH, LI.FI uses the zero address or symbol
+    const isNativeIn = ['ETH', 'MATIC', 'POL'].includes(fromToken.toUpperCase());
+
+    // Get balance check
+    if (isNativeIn) {
+      const balance = await provider.getBalance(address);
+      const amountWei = ethers.parseEther(amount.toString());
+      if (balance < amountWei) {
+        spin.fail('Insufficient balance');
+        error(`Need ${amount} ${fromToken}, have ${ethers.formatEther(balance)}`);
+        return { success: false, error: 'insufficient_balance' };
+      }
+    }
+
+    // Request quote from LI.FI
+    // For token amounts, we need to figure out decimals
+    let fromAmount;
+    if (isNativeIn) {
+      fromAmount = ethers.parseEther(amount.toString()).toString();
+    } else {
+      // Try to get decimals from the token contract
+      try {
+        const tokenAddr = tokenIn.startsWith('0x') ? tokenIn : await resolveTokenAddress(tokenIn, chainId);
+        if (!tokenAddr) {
+          spin.fail('Token not found');
+          error(`Could not resolve token: ${tokenIn}. Use contract address instead.`);
+          return { success: false, error: 'token_not_found' };
+        }
+        const contract = new ethers.Contract(tokenAddr, ERC20_ABI, provider);
+        const decimals = await contract.decimals();
+        fromAmount = ethers.parseUnits(amount.toString(), decimals).toString();
+      } catch {
+        // Default to 18 decimals
+        fromAmount = ethers.parseUnits(amount.toString(), 18).toString();
+      }
+    }
+
+    const quote = await getQuote({
+      fromChain: chainId,
+      toChain: chainId,
+      fromToken,
+      toToken,
+      fromAmount,
+      fromAddress: address,
+      slippage: maxSlippage,
+    });
+
+    if (!quote?.transactionRequest) {
+      spin.fail('No route found');
+      error('LI.FI could not find a route for this swap. Try a different pair or amount.');
+      return { success: false, error: 'no_route' };
+    }
+
+    spin.succeed('Quote received');
+
+    // Display swap preview
+    const action = quote.action || {};
+    const estimate = quote.estimate || {};
+    const toolName = quote.toolDetails?.name || quote.tool || 'Unknown DEX';
+
+    showSection('SWAP PREVIEW (LI.FI)');
+    kvDisplay([
+      ['From', `${amount} ${action.fromToken?.symbol || tokenIn}`],
+      ['To', `~${estimate.toAmountMin ? ethers.formatUnits(estimate.toAmountMin, estimate.toToken?.decimals || 18) : '?'} ${action.toToken?.symbol || tokenOut}`],
+      ['Route', toolName],
+      ['Chain', chain],
+      ['Slippage', `${maxSlippage}%`],
+      ['Gas Est.', estimate.gasCosts?.[0]?.amountUSD ? `$${estimate.gasCosts[0].amountUSD}` : 'N/A'],
+    ]);
+    console.log('');
+
+    // Confirm
+    let confirm = providedConfirm;
+    if (typeof confirm !== 'boolean') {
+      const prompted = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: theme.gold('Execute swap?'),
+        default: false,
+      }]);
+      confirm = prompted.confirm;
+    }
+
+    if (!confirm) {
+      warn('Swap cancelled');
+      return { success: false, error: 'cancelled' };
+    }
+
+    const swapSpin = spinner('Executing swap...').start();
+
+    // Handle approval if needed
+    const txReq = quote.transactionRequest;
+    if (!isNativeIn && txReq.to) {
+      const tokenAddr = action.fromToken?.address;
+      if (tokenAddr && tokenAddr !== ethers.ZeroAddress) {
+        const token = new ethers.Contract(tokenAddr, ERC20_ABI, signer);
+        const allowance = await token.allowance(address, txReq.to);
+        const needed = BigInt(fromAmount);
+        if (allowance < needed) {
+          swapSpin.text = 'Approving token...';
+          const approveTx = await token.approve(txReq.to, ethers.MaxUint256);
+          await approveTx.wait();
+        }
+      }
+    }
+
+    // Send the transaction
+    swapSpin.text = 'Sending transaction...';
+    const tx = await signer.sendTransaction({
+      to: txReq.to,
+      data: txReq.data,
+      value: txReq.value ? BigInt(txReq.value) : 0n,
+      gasLimit: txReq.gasLimit ? BigInt(txReq.gasLimit) : undefined,
+      gasPrice: txReq.gasPrice ? BigInt(txReq.gasPrice) : undefined,
+    });
+
+    swapSpin.text = 'Waiting for confirmation...';
+    const receipt = await tx.wait();
+
+    swapSpin.succeed(theme.success('Swap executed via LI.FI'));
+
+    console.log('');
+    showSection('SWAP RESULT');
+    kvDisplay([
+      ['TX Hash', receipt.hash],
+      ['Block', receipt.blockNumber.toString()],
+      ['Gas Used', receipt.gasUsed.toString()],
+      ['Route', toolName],
+      ['Status', receipt.status === 1 ? theme.success('Success') : theme.error('Failed')],
+    ]);
+    console.log('');
+
+    // Nudge for API key if they don't have one
+    showKeyNudge();
+
+    return { success: true, hash: receipt.hash };
+
+  } catch (err) {
+    spin.fail('Swap failed');
+    error(err.message);
+    return { success: false, error: err.message };
+  }
+}
+
+// ──────────────────────────────────────────────────
+// BRIDGE VIA LI.FI
+// ──────────────────────────────────────────────────
+
+/**
+ * Bridge tokens cross-chain via LI.FI
+ */
+export async function executeLifiBridge(opts = {}) {
+  const {
+    fromChain: fromChainName,
+    toChain: toChainName,
+    token: tokenSymbol,
+    amount,
+    wallet: walletName,
+    slippage,
+    password: providedPassword,
+    confirm: providedConfirm,
+  } = opts;
+
+  const maxSlippage = slippage || getConfig('slippage') || 0.5;
+  const fromChainId = resolveChainId(fromChainName);
+  const toChainId = resolveChainId(toChainName);
+
+  if (!fromChainId) { error(`Unknown source chain: ${fromChainName}`); return; }
+  if (!toChainId) { error(`Unknown destination chain: ${toChainName}`); return; }
+  if (fromChainId === toChainId) { error('Source and destination chains must be different. Use `trade swap` for same-chain.'); return; }
+
+  // Get wallet password
+  let password = providedPassword;
+  if (!password) {
+    const prompted = await inquirer.prompt([{
+      type: 'password',
+      name: 'password',
+      message: theme.gold('Wallet password:'),
+      mask: '●',
+    }]);
+    password = prompted.password;
+  }
+
+  const spin = spinner('Getting bridge quote from LI.FI...').start();
+
+  try {
+    // Connect to source chain
+    const rpcUrl = getRPC(fromChainName);
+    const provider = new ethers.JsonRpcProvider(rpcUrl);
+    const { signer, address } = await getSigner(walletName, password);
+    const connectedSigner = signer.connect(provider);
+
+    const fromToken = tokenSymbol.toUpperCase();
+    const isNativeIn = ['ETH', 'MATIC', 'POL'].includes(fromToken);
+
+    // Calculate amount in wei
+    let fromAmount;
+    if (isNativeIn) {
+      fromAmount = ethers.parseEther(amount.toString()).toString();
+    } else {
+      // Default to 6 decimals for stablecoins, 18 for others
+      const isStable = ['USDC', 'USDT', 'DAI', 'USDB'].includes(fromToken);
+      fromAmount = ethers.parseUnits(amount.toString(), isStable ? 6 : 18).toString();
+    }
+
+    const quote = await getQuote({
+      fromChain: fromChainId,
+      toChain: toChainId,
+      fromToken,
+      toToken: fromToken, // Same token on dest chain by default
+      fromAmount,
+      fromAddress: address,
+      slippage: maxSlippage,
+    });
+
+    if (!quote?.transactionRequest) {
+      spin.fail('No bridge route found');
+      error('LI.FI could not find a bridge route. Try a different token or amount.');
+      return;
+    }
+
+    spin.succeed('Bridge quote received');
+
+    const action = quote.action || {};
+    const estimate = quote.estimate || {};
+    const toolName = quote.toolDetails?.name || quote.tool || 'Unknown Bridge';
+    const estTime = estimate.executionDuration ? `~${Math.ceil(estimate.executionDuration / 60)} min` : 'varies';
+
+    showSection('BRIDGE PREVIEW (LI.FI)');
+    kvDisplay([
+      ['From', `${amount} ${fromToken} on ${fromChainName}`],
+      ['To', `~${estimate.toAmountMin ? ethers.formatUnits(estimate.toAmountMin, estimate.toToken?.decimals || 18) : '?'} ${action.toToken?.symbol || fromToken} on ${toChainName}`],
+      ['Bridge', toolName],
+      ['Est. Time', estTime],
+      ['Slippage', `${maxSlippage}%`],
+      ['Gas Est.', estimate.gasCosts?.[0]?.amountUSD ? `$${estimate.gasCosts[0].amountUSD}` : 'N/A'],
+    ]);
+    console.log('');
+
+    // Confirm
+    let confirm = providedConfirm;
+    if (typeof confirm !== 'boolean') {
+      const prompted = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: theme.gold('Execute bridge?'),
+        default: false,
+      }]);
+      confirm = prompted.confirm;
+    }
+
+    if (!confirm) { warn('Bridge cancelled'); return; }
+
+    const bridgeSpin = spinner('Executing bridge...').start();
+
+    // Handle approval
+    const txReq = quote.transactionRequest;
+    if (!isNativeIn && txReq.to) {
+      const tokenAddr = action.fromToken?.address;
+      if (tokenAddr && tokenAddr !== ethers.ZeroAddress) {
+        const token = new ethers.Contract(tokenAddr, ERC20_ABI, connectedSigner);
+        const allowance = await token.allowance(address, txReq.to);
+        if (allowance < BigInt(fromAmount)) {
+          bridgeSpin.text = 'Approving token...';
+          const approveTx = await token.approve(txReq.to, ethers.MaxUint256);
+          await approveTx.wait();
+        }
+      }
+    }
+
+    // Send bridge transaction
+    bridgeSpin.text = 'Sending bridge transaction...';
+    const tx = await connectedSigner.sendTransaction({
+      to: txReq.to,
+      data: txReq.data,
+      value: txReq.value ? BigInt(txReq.value) : 0n,
+      gasLimit: txReq.gasLimit ? BigInt(txReq.gasLimit) : undefined,
+    });
+
+    bridgeSpin.text = 'Waiting for source chain confirmation...';
+    const receipt = await tx.wait();
+
+    bridgeSpin.succeed(theme.success('Bridge transaction submitted'));
+
+    console.log('');
+    showSection('BRIDGE RESULT');
+    kvDisplay([
+      ['TX Hash', receipt.hash],
+      ['Source Chain', fromChainName],
+      ['Dest Chain', toChainName],
+      ['Bridge', toolName],
+      ['Est. Arrival', estTime],
+      ['Status', receipt.status === 1 ? theme.success('Submitted') : theme.error('Failed')],
+    ]);
+    console.log('');
+    info(`Track status: darksol bridge status ${receipt.hash} --from ${fromChainName} --to ${toChainName}`);
+    console.log('');
+
+    showKeyNudge();
+
+  } catch (err) {
+    spin.fail('Bridge failed');
+    error(err.message);
+  }
+}
+
+/**
+ * Check bridge transfer status
+ */
+export async function checkBridgeStatus(txHash, opts = {}) {
+  const spin = spinner('Checking bridge status...').start();
+
+  try {
+    const status = await getStatus(txHash, {
+      fromChain: opts.fromChain ? resolveChainId(opts.fromChain) : undefined,
+      toChain: opts.toChain ? resolveChainId(opts.toChain) : undefined,
+    });
+
+    spin.succeed('Status retrieved');
+
+    showSection('BRIDGE STATUS');
+
+    const sending = status.sending || {};
+    const receiving = status.receiving || {};
+
+    kvDisplay([
+      ['Status', formatBridgeStatus(status.status)],
+      ['Substatus', status.substatus || 'N/A'],
+      ['Source TX', sending.txHash || txHash],
+      ['Source Chain', sending.chainId ? resolveChainName(sending.chainId) : 'N/A'],
+      ['Dest TX', receiving.txHash || theme.dim('pending...')],
+      ['Dest Chain', receiving.chainId ? resolveChainName(receiving.chainId) : 'N/A'],
+      ['Bridge', status.tool || 'N/A'],
+    ]);
+    console.log('');
+
+    if (status.status === 'PENDING') {
+      info('Bridge is still in progress. Check again in a few minutes.');
+    }
+
+  } catch (err) {
+    spin.fail('Status check failed');
+    error(err.message);
+  }
+}
+
+function formatBridgeStatus(status) {
+  switch (status) {
+    case 'DONE': return theme.success('✓ Complete');
+    case 'PENDING': return theme.gold('⏳ Pending');
+    case 'FAILED': return theme.error('✗ Failed');
+    case 'NOT_FOUND': return theme.dim('Not found');
+    case 'PARTIAL': return theme.accent('⚠ Partial');
+    default: return status || 'Unknown';
+  }
+}
+
+/**
+ * Show supported chains
+ */
+export async function showSupportedChains() {
+  const spin = spinner('Fetching supported chains...').start();
+
+  try {
+    const chains = await getChains();
+    spin.succeed(`${chains.length} chains supported`);
+
+    showSection('LI.FI SUPPORTED CHAINS');
+
+    // Group by type
+    const evm = chains.filter(c => c.chainType === 'EVM');
+    const svm = chains.filter(c => c.chainType === 'SVM');
+    const other = chains.filter(c => !['EVM', 'SVM'].includes(c.chainType));
+
+    console.log(theme.gold('  EVM Chains:'));
+    for (const c of evm.sort((a, b) => a.name.localeCompare(b.name))) {
+      const configured = CHAIN_IDS[c.key] ? theme.success('●') : theme.dim('○');
+      console.log(`    ${configured} ${theme.label(c.name.padEnd(20))} ${theme.dim(`id:${c.id}`)}`);
+    }
+
+    if (svm.length) {
+      console.log('');
+      console.log(theme.gold('  Solana:'));
+      for (const c of svm) {
+        console.log(`    ${theme.dim('○')} ${theme.label(c.name.padEnd(20))} ${theme.dim(`id:${c.id}`)}`);
+      }
+    }
+
+    if (other.length) {
+      console.log('');
+      console.log(theme.gold('  Other:'));
+      for (const c of other) {
+        console.log(`    ${theme.dim('○')} ${theme.label(c.name.padEnd(20))} ${theme.dim(`type:${c.chainType}`)}`);
+      }
+    }
+
+    console.log('');
+    info(`Your configured chains: ${Object.keys(CHAIN_IDS).join(', ')}`);
+    console.log('');
+
+  } catch (err) {
+    spin.fail('Failed to fetch chains');
+    error(err.message);
+  }
+}
+
+// ──────────────────────────────────────────────────
+// HELPERS
+// ──────────────────────────────────────────────────
+
+/**
+ * Resolve a token symbol to address using LI.FI token list
+ */
+async function resolveTokenAddress(symbol, chainId) {
+  try {
+    const tokens = await getTokens(chainId);
+    const match = tokens.find(t => t.symbol.toUpperCase() === symbol.toUpperCase());
+    return match?.address || null;
+  } catch {
+    return null;
+  }
+}
+
+// Track nudge state (show max once per session)
+let nudgeShown = false;
+
+/**
+ * Show a one-time nudge to add a LI.FI API key
+ */
+function showKeyNudge() {
+  if (nudgeShown || hasLifiKey()) return;
+  nudgeShown = true;
+  console.log(theme.dim('  💡 Want cross-chain bridges & faster routing? Add a free LI.FI API key:'));
+  console.log(theme.dim('     https://docs.li.fi/api-reference/rate-limits → ') + theme.label('darksol keys add lifi'));
+  console.log('');
+}
+
+export { CHAIN_IDS, CHAIN_NAMES };

package/src/trading/index.js

@@ -1,3 +1,4 @@
 export { executeSwap, resolveToken, getTokenInfo } from './swap.js';
 export { snipeToken, watchSnipe } from './snipe.js';
 export { createDCA, listDCA, cancelDCA, runDCA } from './dca.js';
+export { executeLifiSwap, executeLifiBridge, checkBridgeStatus, showSupportedChains } from '../services/lifi.js';

package/src/web/commands.js

@@ -223,7 +223,7 @@ export async function handleMenuSelect(id, value, item, ws) {
 
     case 'trade_action':
       if (value === 'swap') {
-        ws.sendMenu('trade_swap_pair', '◆ Swap Pair', [
+        ws.sendMenu('trade_swap_pair', '◆ Swap Pair (via LI.FI — best route across 31 DEXs)', [
           { value: 'ETH->USDC', label: 'ETH → USDC', desc: 'Most common' },
           { value: 'USDC->ETH', label: 'USDC → ETH', desc: 'Reverse' },
           { value: 'ETH->AERO', label: 'ETH → AERO', desc: 'Base ecosystem' },
@@ -233,6 +233,16 @@ export async function handleMenuSelect(id, value, item, ws) {
         ]);
         return {};
       }
+      if (value === 'bridge') {
+        const currentChain = getConfig('chain') || 'base';
+        const chains = ['base', 'ethereum', 'arbitrum', 'optimism', 'polygon', 'avalanche', 'bsc', 'zksync', 'scroll', 'linea'];
+        ws.sendMenu('bridge_from_chain', '◆ Bridge From Chain', chains.map(c => ({
+          value: c,
+          label: c === currentChain ? `★ ${c}` : c,
+          desc: c === currentChain ? 'current' : '',
+        })));
+        return {};
+      }
       if (value === 'snipe') {
         ws.sendPrompt('trade_snipe_token', 'Token contract (0x...):', {});
         return {};
@@ -280,6 +290,63 @@ export async function handleMenuSelect(id, value, item, ws) {
       });
       return {};
 
+    case 'bridge_from_chain': {
+      if (value === 'back') return {};
+      const chains = ['base', 'ethereum', 'arbitrum', 'optimism', 'polygon', 'avalanche', 'bsc', 'zksync', 'scroll', 'linea'];
+      const destChains = chains.filter(c => c !== value);
+      ws.sendMenu('bridge_to_chain', `◆ Bridge To Chain (from ${value})`, destChains.map(c => ({
+        value: c,
+        label: c,
+        desc: '',
+        meta: { fromChain: value },
+      })));
+      return {};
+    }
+
+    case 'bridge_to_chain': {
+      if (value === 'back') return {};
+      const fromChain = item?.meta?.fromChain || 'base';
+      ws.sendMenu('bridge_token', `◆ Token to Bridge (${fromChain} → ${value})`, [
+        { value: 'ETH', label: 'ETH', desc: 'Native token', meta: { fromChain, toChain: value } },
+        { value: 'USDC', label: 'USDC', desc: 'Stablecoin', meta: { fromChain, toChain: value } },
+        { value: 'USDT', label: 'USDT', desc: 'Tether', meta: { fromChain, toChain: value } },
+        { value: 'custom', label: 'Custom token', desc: 'Enter symbol', meta: { fromChain, toChain: value } },
+        { value: 'back', label: '← Back', desc: '' },
+      ]);
+      return {};
+    }
+
+    case 'bridge_token': {
+      if (value === 'back') return {};
+      if (value === 'custom') {
+        ws.sendPrompt('bridge_custom_token', 'Token symbol or address:', item?.meta || {});
+        return {};
+      }
+      const m = item?.meta || {};
+      ws.sendMenu('bridge_amount', `◆ Amount (${value} · ${m.fromChain} → ${m.toChain})`, [
+        { value: '0.01', label: `0.01 ${value}`, desc: 'small', meta: { ...m, token: value } },
+        { value: '0.05', label: `0.05 ${value}`, desc: 'standard', meta: { ...m, token: value } },
+        { value: '0.1', label: `0.1 ${value}`, desc: 'medium', meta: { ...m, token: value } },
+        { value: '0.5', label: `0.5 ${value}`, desc: 'large', meta: { ...m, token: value } },
+        { value: '1', label: `1 ${value}`, desc: 'large', meta: { ...m, token: value } },
+        { value: 'custom', label: 'Custom amount', desc: '', meta: { ...m, token: value } },
+      ]);
+      return {};
+    }
+
+    case 'bridge_amount': {
+      if (value === 'custom') {
+        ws.sendPrompt('bridge_custom_amount', `Amount (${item?.meta?.token || 'token'}):`, item?.meta || {});
+        return {};
+      }
+      ws.sendPrompt('bridge_password', `Wallet password (bridge ${value} ${item?.meta?.token || ''} · ${item?.meta?.fromChain || ''} → ${item?.meta?.toChain || ''}):`, {
+        ...(item?.meta || {}),
+        amount: value,
+        mask: true,
+      });
+      return {};
+    }
+
     case 'send_token':
       if (value === 'back') return {};
       if (value === 'custom') {
@@ -536,6 +603,66 @@ export async function handlePromptResponse(id, value, meta, ws) {
     return {};
   }
 
+  if (id === 'bridge_custom_token') {
+    if (!value) { ws.sendLine(`  ${ANSI.red}✗ Cancelled${ANSI.reset}`); ws.sendLine(''); return {}; }
+    const m = meta || {};
+    ws.sendMenu('bridge_amount', `◆ Amount (${value} · ${m.fromChain} → ${m.toChain})`, [
+      { value: '0.01', label: `0.01 ${value}`, desc: 'small', meta: { ...m, token: value.trim() } },
+      { value: '0.05', label: `0.05 ${value}`, desc: 'standard', meta: { ...m, token: value.trim() } },
+      { value: '0.1', label: `0.1 ${value}`, desc: 'medium', meta: { ...m, token: value.trim() } },
+      { value: '0.5', label: `0.5 ${value}`, desc: 'large', meta: { ...m, token: value.trim() } },
+      { value: '1', label: `1 ${value}`, desc: 'large', meta: { ...m, token: value.trim() } },
+      { value: 'custom', label: 'Custom amount', desc: '', meta: { ...m, token: value.trim() } },
+    ]);
+    return {};
+  }
+
+  if (id === 'bridge_custom_amount') {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0) {
+      ws.sendLine(`  ${ANSI.red}✗ Invalid amount${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+    ws.sendPrompt('bridge_password', `Wallet password (bridge ${value} ${meta?.token || ''} · ${meta?.fromChain || ''} → ${meta?.toChain || ''}):`, {
+      ...meta,
+      amount: String(value),
+      mask: true,
+    });
+    return {};
+  }
+
+  if (id === 'bridge_password') {
+    if (!meta?.fromChain || !meta?.toChain || !meta?.token || !meta?.amount || !value) {
+      ws.sendLine(`  ${ANSI.red}✗ Missing bridge details${ANSI.reset}`);
+      ws.sendLine('');
+      return {};
+    }
+
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.dim}Bridging ${meta.amount} ${meta.token} from ${meta.fromChain} → ${meta.toChain} via LI.FI...${ANSI.reset}`);
+    ws.sendLine('');
+
+    try {
+      const { executeLifiBridge } = await import('../services/lifi.js');
+      await executeLifiBridge({
+        fromChain: meta.fromChain,
+        toChain: meta.toChain,
+        token: meta.token,
+        amount: meta.amount,
+        slippage: parseFloat(getConfig('slippage') || 0.5),
+        wallet: getConfig('activeWallet'),
+        password: value,
+        confirm: true,
+      });
+      ws.sendLine(`  ${ANSI.green}✓ Bridge flow completed (check terminal output for receipt)${ANSI.reset}`);
+    } catch (err) {
+      ws.sendLine(`  ${ANSI.red}✗ Bridge failed: ${err.message}${ANSI.reset}`);
+    }
+    ws.sendLine('');
+    return {};
+  }
+
   if (id === 'trade_swap_password') {
     if (!meta?.tokenIn || !meta?.tokenOut || !meta?.amount || !value) {
       ws.sendLine(`  ${ANSI.red}✗ Missing swap details${ANSI.reset}`);
@@ -543,12 +670,13 @@ export async function handlePromptResponse(id, value, meta, ws) {
       return {};
     }
 
-    ws.sendLine(`  ${ANSI.dim}Executing swap ${meta.amount} ${meta.tokenIn} → ${meta.tokenOut}...${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}Executing swap ${meta.amount} ${meta.tokenIn} → ${meta.tokenOut} via LI.FI...${ANSI.reset}`);
     ws.sendLine('');
 
     try {
-      const { executeSwap } = await import('../trading/swap.js');
-      await executeSwap({
+      // Try LI.FI first, fall back to direct Uniswap
+      const { executeLifiSwap } = await import('../services/lifi.js');
+      const swapOpts = {
         tokenIn: meta.tokenIn,
         tokenOut: meta.tokenOut,
         amount: meta.amount,
@@ -556,8 +684,18 @@ export async function handlePromptResponse(id, value, meta, ws) {
         wallet: getConfig('activeWallet'),
         password: value,
         confirm: true,
-      });
-      ws.sendLine(`  ${ANSI.green}✓ Swap flow completed (check terminal output for receipt)${ANSI.reset}`);
+      };
+
+      const result = await executeLifiSwap(swapOpts);
+      if (result?.success) {
+        ws.sendLine(`  ${ANSI.green}✓ Swap completed via LI.FI${ANSI.reset}`);
+      } else if (result?.error !== 'cancelled') {
+        // Fallback to direct Uniswap
+        ws.sendLine(`  ${ANSI.darkGold}LI.FI route unavailable — trying direct Uniswap V3...${ANSI.reset}`);
+        const { executeSwap } = await import('../trading/swap.js');
+        await executeSwap(swapOpts);
+        ws.sendLine(`  ${ANSI.green}✓ Swap completed via Uniswap V3${ANSI.reset}`);
+      }
     } catch (err) {
       ws.sendLine(`  ${ANSI.red}✗ Swap failed: ${err.message}${ANSI.reset}`);
     }
@@ -686,6 +824,8 @@ export async function handleCommand(cmd, ws) {
       return await cmdMarket(args, ws);
     case 'trade':
       return await cmdTrade(args, ws);
+    case 'bridge':
+      return await cmdBridge(args, ws);
     case 'wallet':
       return await cmdWallet(args, ws);
     case 'mail':
@@ -719,7 +859,7 @@ export async function handleCommand(cmd, ws) {
       return await cmdChatLogs(args, ws);
     default: {
       // Fuzzy: if it looks like natural language, route to AI
-      const nlKeywords = /\b(swap|buy|sell|send|transfer|price|what|how|should|analyze|check|balance|gas|dca|order|card|prepaid|visa|mastercard|bet|coinflip|flip|dice|slots|hilo|gamble|play|casino)\b/i;
+      const nlKeywords = /\b(swap|buy|sell|send|transfer|price|what|how|should|analyze|check|balance|gas|dca|order|card|prepaid|visa|mastercard|bet|coinflip|flip|dice|slots|hilo|gamble|play|casino|bridge|cross-chain|crosschain)\b/i;
       if (nlKeywords.test(cmd)) {
         return await cmdAI(cmd.split(/\s+/), ws);
       }
@@ -986,7 +1126,8 @@ async function cmdTrade(args, ws) {
   ws.sendLine('');
 
   ws.sendMenu('trade_action', '◆ Trade Actions', [
-    { value: 'swap', label: '🔄 Swap', desc: 'Interactive token swap (password prompt)' },
+    { value: 'swap', label: '🔄 Swap', desc: 'Token swap via LI.FI (best route across 31 DEXs)' },
+    { value: 'bridge', label: '🌉 Bridge', desc: 'Cross-chain transfer via LI.FI (60 chains)' },
     { value: 'snipe', label: '⚡ Snipe', desc: 'Fast buy by token contract' },
     { value: 'watch', label: '👀 Watch Pairs', desc: 'Monitor new pairs (CLI guidance)' },
     { value: 'back', label: '← Back', desc: '' },
@@ -995,6 +1136,79 @@ async function cmdTrade(args, ws) {
   return {};
 }
 
+// ══════════════════════════════════════════════════
+// BRIDGE (LI.FI cross-chain)
+// ══════════════════════════════════════════════════
+async function cmdBridge(args, ws) {
+  const sub = (args[0] || '').toLowerCase();
+
+  if (sub === 'status' && args[1]) {
+    // Check bridge transfer status
+    ws.sendLine(`  ${ANSI.dim}Checking bridge status...${ANSI.reset}`);
+    try {
+      const { checkBridgeStatus } = await import('../services/lifi.js');
+      await checkBridgeStatus(args[1], {
+        fromChain: args.find((a, i) => args[i - 1] === '--from'),
+        toChain: args.find((a, i) => args[i - 1] === '--to'),
+      });
+    } catch (err) {
+      ws.sendLine(`  ${ANSI.red}✗ ${err.message}${ANSI.reset}`);
+    }
+    ws.sendLine('');
+    return {};
+  }
+
+  if (sub === 'chains') {
+    ws.sendLine(`  ${ANSI.dim}Fetching supported chains...${ANSI.reset}`);
+    try {
+      const { getChains } = await import('../services/lifi.js');
+      const chains = await getChains();
+      ws.sendLine('');
+      ws.sendLine(`${ANSI.gold}  ◆ LI.FI SUPPORTED CHAINS (${chains.length})${ANSI.reset}`);
+      ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+
+      const evm = chains.filter(c => c.chainType === 'EVM').sort((a, b) => a.name.localeCompare(b.name));
+      const other = chains.filter(c => c.chainType !== 'EVM');
+
+      for (const c of evm.slice(0, 30)) {
+        ws.sendLine(`    ${ANSI.green}●${ANSI.reset} ${ANSI.white}${c.name.padEnd(22)}${ANSI.reset} ${ANSI.dim}id:${c.id}${ANSI.reset}`);
+      }
+      if (evm.length > 30) {
+        ws.sendLine(`    ${ANSI.dim}...and ${evm.length - 30} more EVM chains${ANSI.reset}`);
+      }
+      if (other.length) {
+        ws.sendLine('');
+        for (const c of other) {
+          ws.sendLine(`    ${ANSI.blue}●${ANSI.reset} ${ANSI.white}${c.name.padEnd(22)}${ANSI.reset} ${ANSI.dim}${c.chainType}${ANSI.reset}`);
+        }
+      }
+      ws.sendLine('');
+    } catch (err) {
+      ws.sendLine(`  ${ANSI.red}✗ ${err.message}${ANSI.reset}`);
+      ws.sendLine('');
+    }
+    return {};
+  }
+
+  // Default: show bridge menu
+  const currentChain = getConfig('chain') || 'base';
+
+  ws.sendLine(`${ANSI.gold}  ◆ CROSS-CHAIN BRIDGE (LI.FI)${ANSI.reset}`);
+  ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.white}Move tokens between 60+ chains with optimal routing.${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.dim}Aggregates 27 bridges for best rates.${ANSI.reset}`);
+  ws.sendLine('');
+
+  const chains = ['base', 'ethereum', 'arbitrum', 'optimism', 'polygon', 'avalanche', 'bsc', 'zksync', 'scroll', 'linea'];
+  ws.sendMenu('bridge_from_chain', '◆ Bridge From Chain', chains.map(c => ({
+    value: c,
+    label: c === currentChain ? `★ ${c}` : c,
+    desc: c === currentChain ? 'current chain' : '',
+  })));
+
+  return {};
+}
+
 // ══════════════════════════════════════════════════
 // WALLET
 // ══════════════════════════════════════════════════