@darksol/terminal 0.4.3 → 0.4.5

package/package.json

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

package/src/cli.js

@@ -3,7 +3,7 @@ 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 { getConfig, setConfig, getAllConfig, getRPC, setRPC, configPath } from './config/store.js';
-import { createWallet, importWallet, showWallets, getBalance, useWallet, exportWallet } from './wallet/manager.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';
@@ -73,6 +73,20 @@ export function cli(argv) {
     .description('Set active wallet')
     .action((name) => useWallet(name));
 
+  wallet
+    .command('send')
+    .description('Send ETH or tokens')
+    .option('--to <address>', 'Recipient address')
+    .option('-a, --amount <amount>', 'Amount to send')
+    .option('-t, --token <token>', 'Token (ETH, USDC, or 0x address)', 'ETH')
+    .option('-w, --wallet <name>', 'Wallet to send from')
+    .action((opts) => sendFunds(opts));
+
+  wallet
+    .command('receive [name]')
+    .description('Show your address for receiving funds')
+    .action((name) => receiveAddress(name));
+
   wallet
     .command('export [name]')
     .description('Export wallet details')
@@ -420,6 +434,25 @@ export function cli(argv) {
     .description('Multi-chain balance view (shortcut for: wallet portfolio)')
     .action((name) => showPortfolio(name));
 
+  // ═══════════════════════════════════════
+  // SEND SHORTCUT
+  // ═══════════════════════════════════════
+  program
+    .command('send')
+    .description('Send ETH or tokens (shortcut for: wallet send)')
+    .option('--to <address>', 'Recipient address')
+    .option('-a, --amount <amount>', 'Amount')
+    .option('-t, --token <token>', 'Token (ETH, USDC, or 0x address)', 'ETH')
+    .action((opts) => sendFunds(opts));
+
+  // ═══════════════════════════════════════
+  // RECEIVE SHORTCUT
+  // ═══════════════════════════════════════
+  program
+    .command('receive')
+    .description('Show your address for receiving (shortcut for: wallet receive)')
+    .action(() => receiveAddress());
+
   // ═══════════════════════════════════════
   // GAS COMMAND
   // ═══════════════════════════════════════
@@ -483,18 +516,53 @@ export function cli(argv) {
     .description('One-shot AI query')
     .option('-p, --provider <name>', 'LLM provider')
     .option('-m, --model <model>', 'Model name')
+    .option('-x, --execute', 'Auto-execute if confidence > 60%')
     .action(async (promptParts, opts) => {
       const prompt = promptParts.join(' ');
       const result = await parseIntent(prompt, opts);
       if (result.action !== 'error' && result.action !== 'unknown') {
         showSection('PARSED INTENT');
-        kvDisplay(Object.entries(result)
-          .filter(([k]) => !['raw', 'model'].includes(k))
-          .map(([k, v]) => [k, Array.isArray(v) ? v.join(', ') : String(v)])
-        );
+        const displayEntries = Object.entries(result)
+          .filter(([k]) => !['raw', 'model', 'reasoning'].includes(k))
+          .map(([k, v]) => [k, Array.isArray(v) ? v.join(', ') : String(v)]);
+        kvDisplay(displayEntries);
+
+        if (result.reasoning) {
+          console.log('');
+          info(result.reasoning);
+        }
+
+        if (result.warnings?.length > 0) {
+          result.warnings.forEach(w => warn(w));
+        }
+
         if (result.command) {
           console.log('');
-          info(`Suggested command: ${theme.gold(result.command)}`);
+          info(`Command: ${theme.gold(result.command)}`);
+        }
+
+        // Offer to execute actionable intents
+        const actionable = ['swap', 'send', 'transfer', 'snipe', 'dca', 'price', 'balance', 'gas', 'analyze'];
+        if (actionable.includes(result.action)) {
+          if (opts.execute && result.confidence >= 0.6) {
+            console.log('');
+            await executeIntent(result, {});
+          } else if (!opts.execute) {
+            console.log('');
+            const inquirer = (await import('inquirer')).default;
+            const { run } = await inquirer.prompt([{
+              type: 'confirm',
+              name: 'run',
+              message: theme.gold('Execute this?'),
+              default: result.confidence >= 0.7,
+            }]);
+            if (run) await executeIntent(result, {});
+          }
+        }
+      } else {
+        if (result.raw) {
+          console.log('');
+          console.log(theme.dim('  ') + result.raw);
         }
       }
     });
@@ -965,6 +1033,8 @@ function showCommandList() {
   showSection('COMMANDS');
   const commands = [
     ['wallet', 'Create, import, manage wallets'],
+    ['send', 'Send ETH or tokens'],
+    ['receive', 'Show address to receive funds'],
     ['portfolio', 'Multi-chain balance view'],
     ['price', 'Quick token price check'],
     ['watch', 'Live price monitoring + alerts'],

package/src/llm/intent.js

@@ -9,42 +9,70 @@ import { showSection } from '../ui/banner.js';
 // INTENT SYSTEM PROMPT
 // ──────────────────────────────────────────────────
 
-const INTENT_SYSTEM_PROMPT = `You are DARKSOL Terminal's trading AI assistant. You help users execute trades, analyze markets, manage DCA strategies, and navigate the DARKSOL ecosystem.
+const INTENT_SYSTEM_PROMPT = `You are DARKSOL Terminal's trading AI assistant. You help users execute trades, send/receive tokens, analyze markets, manage DCA strategies, and navigate the DARKSOL ecosystem.
 
 CAPABILITIES:
-- Parse natural language trade instructions into structured commands
-- Analyze token prices, liquidity, and market conditions  
+- Parse natural language into structured trade/transfer commands
+- Analyze token prices, liquidity, and market conditions
 - Suggest DCA strategies based on user goals
 - Explain transaction results and gas costs
 - Warn about risks (low liquidity, high slippage, unverified contracts)
 
 SUPPORTED CHAINS: Base (default), Ethereum, Polygon, Arbitrum, Optimism
-
-RESPONSE RULES:
-- Be concise and direct
-- Always include risk warnings for trades
-- When parsing trade intent, output structured JSON
-- Never reveal private keys or sensitive wallet info
-- If uncertain about a token, say so
-- Use plain numbers, avoid scientific notation
+KNOWN TOKENS: ETH, USDC, USDT, DAI, WETH, AERO, VIRTUAL, ARB, OP, WMATIC
 
 USER CONTEXT:
 - Active chain: {{chain}}
 - Active wallet: {{wallet}}
 - Slippage setting: {{slippage}}%
 
-When parsing trade instructions, respond with JSON:
+RESPONSE RULES:
+- Be concise and direct
+- Always include risk warnings for trades
+- When parsing trade/transfer intent, output structured JSON
+- Never reveal private keys or sensitive wallet info
+- If uncertain about a token, say so — don't guess contract addresses
+- Use plain numbers, avoid scientific notation
+- For ambiguous amounts, ask for clarification (confidence < 0.5)
+
+ACTIONS (use the most specific one):
+- "swap" — exchange one token for another (e.g. "swap ETH to USDC", "buy VIRTUAL with 0.1 ETH")
+- "send" — transfer tokens to an address (e.g. "send 10 USDC to 0x...", "transfer 0.5 ETH to vitalik.eth")
+- "snipe" — fast-buy a new/low-liquidity token with ETH
+- "dca" — set up recurring buys (e.g. "DCA $100 into ETH over 30 days")
+- "price" — check current price (e.g. "price of AERO", "how much is VIRTUAL")
+- "balance" — check wallet balance
+- "info" — general question about a token or protocol
+- "analyze" — deep analysis of a token
+- "gas" — gas price check
+- "unknown" — can't determine what the user wants
+
+When parsing, respond with ONLY valid JSON:
 {
-  "action": "swap|snipe|dca|transfer|info|analyze|unknown",
-  "tokenIn": "symbol or address",
-  "tokenOut": "symbol or address",
-  "amount": "number",
-  "chain": "chain name",
-  "confidence": 0-1,
-  "reasoning": "brief explanation",
+  "action": "swap|send|snipe|dca|price|balance|info|analyze|gas|unknown",
+  "tokenIn": "symbol or address (for swaps)",
+  "tokenOut": "symbol or address (for swaps)",
+  "token": "symbol (for send/price/analyze)",
+  "amount": "number as string",
+  "to": "recipient address (for send)",
+  "chain": "chain name if specified, null if not",
+  "interval": "for DCA: 1h, 4h, 1d, etc.",
+  "orders": "for DCA: number of orders",
+  "confidence": 0.0-1.0,
+  "reasoning": "brief explanation of interpretation",
   "warnings": ["array of risk warnings"],
-  "command": "the CLI command to execute"
-}`;
+  "command": "the exact darksol CLI command to run"
+}
+
+COMMAND MAPPING:
+- swap → darksol trade swap -i <tokenIn> -o <tokenOut> -a <amount>
+- send → darksol send --to <address> --amount <amount> --token <token>
+- snipe → darksol trade snipe <address> <ethAmount>
+- dca → darksol dca create -t <token> -a <amount> -i <interval> -n <orders>
+- price → darksol price <token>
+- balance → darksol wallet balance
+- gas → darksol gas <chain>
+- analyze → darksol ai analyze <token>`;
 
 // ──────────────────────────────────────────────────
 // INTENT PARSER
@@ -126,7 +154,8 @@ export async function parseIntent(input, opts = {}) {
 export async function startChat(opts = {}) {
   showSection('DARKSOL AI — TRADING ASSISTANT');
   console.log(theme.dim('  Natural language trading. Type "exit" to quit.'));
-  console.log(theme.dim('  Examples: "buy 0.1 ETH worth of VIRTUAL", "what\'s the price of AERO?"'));
+  console.log(theme.dim('  Try: "swap 0.1 ETH to USDC", "send 5 USDC to 0x...", "price of AERO"'));
+  console.log(theme.dim('  Actions auto-detected — you\'ll be asked to confirm before execution.'));
   console.log('');
 
   const spin = spinner('Initializing AI...').start();
@@ -187,7 +216,31 @@ export async function startChat(opts = {}) {
         enriched += `\n\n[Live data: ${priceData.join(', ')}]`;
       }
 
-      const result = await llm.chat(enriched);
+      // Try to detect actionable intent
+      const actionKeywords = /\b(swap|send|transfer|buy|sell|snipe|dca|price|balance|gas)\b/i;
+      const isActionable = actionKeywords.test(input);
+
+      let result;
+      let parsedIntent = null;
+
+      if (isActionable) {
+        // Use JSON mode to get structured intent
+        const intentResult = await llm.json(
+          `Parse this as a trading/transfer instruction:\n\n"${enriched}"`,
+          { ephemeral: true }
+        );
+
+        if (intentResult.parsed && intentResult.parsed.action && intentResult.parsed.action !== 'unknown') {
+          parsedIntent = intentResult.parsed;
+          // Also get a human-readable response
+          result = await llm.chat(enriched);
+        } else {
+          result = await llm.chat(enriched);
+        }
+      } else {
+        result = await llm.chat(enriched);
+      }
+
       spin2.succeed('');
 
       // Display response
@@ -199,6 +252,41 @@ export async function startChat(opts = {}) {
       }
       console.log('');
 
+      // If actionable intent was detected, offer to execute
+      if (parsedIntent) {
+        const execActions = ['swap', 'send', 'transfer', 'snipe', 'dca', 'price', 'balance', 'gas'];
+        if (execActions.includes(parsedIntent.action)) {
+          const displayPairs = [];
+          if (parsedIntent.action) displayPairs.push(['Action', parsedIntent.action]);
+          if (parsedIntent.tokenIn) displayPairs.push(['From', parsedIntent.tokenIn]);
+          if (parsedIntent.tokenOut) displayPairs.push(['To token', parsedIntent.tokenOut]);
+          if (parsedIntent.token) displayPairs.push(['Token', parsedIntent.token]);
+          if (parsedIntent.amount) displayPairs.push(['Amount', parsedIntent.amount]);
+          if (parsedIntent.to) displayPairs.push(['Recipient', parsedIntent.to]);
+          if (parsedIntent.confidence) displayPairs.push(['Confidence', `${(parsedIntent.confidence * 100).toFixed(0)}%`]);
+
+          if (displayPairs.length > 1) {
+            showSection('DETECTED INTENT');
+            kvDisplay(displayPairs);
+            if (parsedIntent.warnings?.length > 0) {
+              parsedIntent.warnings.forEach(w => warn(w));
+            }
+            console.log('');
+
+            const { execute } = await inquirer.prompt([{
+              type: 'confirm',
+              name: 'execute',
+              message: theme.gold(`Execute ${parsedIntent.action}?`),
+              default: false,
+            }]);
+
+            if (execute) {
+              await executeIntent(parsedIntent, {});
+            }
+          }
+        }
+      }
+
     } catch (err) {
       spin2.fail('Error');
       error(err.message);
@@ -402,11 +490,37 @@ export async function executeIntent(intent, opts = {}) {
         });
       }
 
+      case 'send':
       case 'transfer': {
-        // Transfer intent — use execution script engine
-        info(`Transfer intent detected. Use: darksol script create (template: transfer)`);
-        info(`To: ${intent.to || 'specify address'}, Amount: ${intent.amount || 'specify amount'}`);
-        return { success: true, action: 'transfer', note: 'Use script system for transfers' };
+        const { sendFunds } = await import('../wallet/manager.js');
+        return await sendFunds({
+          to: intent.to,
+          amount: intent.amount,
+          token: intent.token || intent.tokenIn || 'ETH',
+        });
+      }
+
+      case 'price': {
+        const token = intent.token || intent.tokenOut || intent.tokenIn;
+        if (token) {
+          const { checkPrices } = await import('../services/watch.js');
+          await checkPrices([token]);
+          return { success: true, action: 'price' };
+        }
+        info('No token specified');
+        return { success: false, reason: 'no token specified' };
+      }
+
+      case 'balance': {
+        const { getBalance } = await import('../wallet/manager.js');
+        await getBalance();
+        return { success: true, action: 'balance' };
+      }
+
+      case 'gas': {
+        const { showGas } = await import('../services/gas.js');
+        await showGas(intent.chain || getConfig('chain') || 'base');
+        return { success: true, action: 'gas' };
       }
 
       case 'info':

package/src/wallet/manager.js

@@ -248,6 +248,270 @@ export function useWallet(name) {
   success(`Active wallet set to "${name}"`);
 }
 
+// ═══════════════════════════════════════
+// SEND — ETH and ERC-20 transfers
+// ═══════════════════════════════════════
+
+const COMMON_TOKENS = {
+  base:     { USDC: { addr: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', decimals: 6 } },
+  ethereum: { USDC: { addr: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', decimals: 6 }, USDT: { addr: '0xdAC17F958D2ee523a2206206994597C13D831ec7', decimals: 6 } },
+  arbitrum: { USDC: { addr: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', decimals: 6 } },
+  optimism: { USDC: { addr: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85', decimals: 6 } },
+  polygon:  { USDC: { addr: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359', decimals: 6 } },
+};
+
+const ERC20_SEND_ABI = [
+  'function transfer(address to, uint256 amount) returns (bool)',
+  'function balanceOf(address) view returns (uint256)',
+  'function decimals() view returns (uint8)',
+  'function symbol() view returns (string)',
+];
+
+export async function sendFunds(opts = {}) {
+  const name = opts.wallet || getConfig('activeWallet');
+  if (!name) {
+    error('No active wallet. Set one: darksol wallet use <name>');
+    return;
+  }
+
+  const chain = getConfig('chain') || 'base';
+  const walletData = loadWallet(name);
+
+  // Interactive prompt if flags not provided
+  let to = opts.to;
+  let amount = opts.amount;
+  let token = opts.token || 'ETH';
+
+  console.log('');
+  showSection(`SEND — ${name}`);
+  console.log(theme.dim(`  ${walletData.address}`));
+  console.log(theme.dim(`  Chain: ${chain}`));
+  console.log('');
+
+  if (!to) {
+    ({ to } = await inquirer.prompt([{
+      type: 'input',
+      name: 'to',
+      message: theme.gold('Recipient address (0x...):'),
+      validate: (v) => {
+        if (!v.startsWith('0x') || v.length !== 42) return 'Enter a valid 0x address (42 chars)';
+        return true;
+      },
+    }]));
+  }
+
+  if (!amount) {
+    // Show available tokens
+    const tokenChoices = ['ETH'];
+    const chainTokens = COMMON_TOKENS[chain] || {};
+    Object.keys(chainTokens).forEach(t => tokenChoices.push(t));
+    tokenChoices.push('Custom token (paste address)');
+
+    ({ token } = await inquirer.prompt([{
+      type: 'list',
+      name: 'token',
+      message: theme.gold('What to send?'),
+      choices: tokenChoices,
+    }]));
+
+    if (token === 'Custom token (paste address)') {
+      ({ token } = await inquirer.prompt([{
+        type: 'input',
+        name: 'token',
+        message: theme.gold('Token contract address (0x...):'),
+        validate: (v) => v.startsWith('0x') && v.length === 42 || 'Invalid address',
+      }]));
+    }
+
+    ({ amount } = await inquirer.prompt([{
+      type: 'input',
+      name: 'amount',
+      message: theme.gold(`Amount to send (${token}):`),
+      validate: (v) => parseFloat(v) > 0 || 'Enter a positive amount',
+    }]));
+  }
+
+  // Password
+  const { password } = await inquirer.prompt([{
+    type: 'password',
+    name: 'password',
+    message: theme.gold('Wallet password:'),
+    mask: '●',
+  }]);
+
+  const spin = spinner('Preparing transaction...').start();
+
+  try {
+    const { signer, provider, address } = await getSigner(name, password);
+
+    const isETH = token.toUpperCase() === 'ETH';
+    const isSymbol = !token.startsWith('0x');
+    let tokenAddr = null;
+    let tokenDecimals = 18;
+    let tokenSymbol = token.toUpperCase();
+
+    if (!isETH) {
+      // Resolve token
+      const chainTokens = COMMON_TOKENS[chain] || {};
+      if (isSymbol && chainTokens[token.toUpperCase()]) {
+        const info = chainTokens[token.toUpperCase()];
+        tokenAddr = info.addr;
+        tokenDecimals = info.decimals;
+        tokenSymbol = token.toUpperCase();
+      } else if (token.startsWith('0x')) {
+        tokenAddr = token;
+        const contract = new ethers.Contract(tokenAddr, ERC20_SEND_ABI, provider);
+        tokenDecimals = Number(await contract.decimals());
+        tokenSymbol = await contract.symbol();
+      } else {
+        spin.fail('Unknown token');
+        error(`Token "${token}" not recognized. Use a symbol (USDC) or contract address.`);
+        return;
+      }
+    }
+
+    // Check balance
+    let balanceStr;
+    if (isETH) {
+      const balance = await provider.getBalance(address);
+      const amountWei = ethers.parseEther(amount);
+      balanceStr = `${parseFloat(ethers.formatEther(balance)).toFixed(6)} ETH`;
+      if (balance < amountWei) {
+        spin.fail('Insufficient balance');
+        error(`Need ${amount} ETH, have ${balanceStr}`);
+        return;
+      }
+    } else {
+      const contract = new ethers.Contract(tokenAddr, ERC20_SEND_ABI, provider);
+      const balance = await contract.balanceOf(address);
+      const amountParsed = ethers.parseUnits(amount, tokenDecimals);
+      balanceStr = `${parseFloat(ethers.formatUnits(balance, tokenDecimals)).toFixed(tokenDecimals > 6 ? 6 : 2)} ${tokenSymbol}`;
+      if (balance < amountParsed) {
+        spin.fail('Insufficient balance');
+        error(`Need ${amount} ${tokenSymbol}, have ${balanceStr}`);
+        return;
+      }
+    }
+
+    // Estimate gas
+    let gasEstimate;
+    const feeData = await provider.getFeeData();
+    if (isETH) {
+      gasEstimate = 21000n;
+    } else {
+      const contract = new ethers.Contract(tokenAddr, ERC20_SEND_ABI, signer);
+      gasEstimate = await contract.transfer.estimateGas(to, ethers.parseUnits(amount, tokenDecimals));
+    }
+    const gasCostWei = gasEstimate * (feeData.gasPrice || 0n);
+    const gasCostEth = parseFloat(ethers.formatEther(gasCostWei));
+
+    spin.succeed('Transaction ready');
+
+    // Confirmation
+    console.log('');
+    showSection('SEND PREVIEW');
+    kvDisplay([
+      ['From', `${name} (${address.slice(0, 6)}...${address.slice(-4)})`],
+      ['To', to],
+      ['Amount', `${amount} ${tokenSymbol}`],
+      ['Balance', balanceStr],
+      ['Est. Gas', `${gasCostEth.toFixed(6)} ETH`],
+      ['Chain', chain],
+    ]);
+    console.log('');
+
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: theme.accent('Send this transaction?'),
+      default: false,
+    }]);
+
+    if (!confirm) {
+      warn('Transaction cancelled');
+      return;
+    }
+
+    const txSpin = spinner('Sending...').start();
+
+    let tx;
+    if (isETH) {
+      tx = await signer.sendTransaction({
+        to,
+        value: ethers.parseEther(amount),
+      });
+    } else {
+      const contract = new ethers.Contract(tokenAddr, ERC20_SEND_ABI, signer);
+      tx = await contract.transfer(to, ethers.parseUnits(amount, tokenDecimals));
+    }
+
+    txSpin.text = 'Waiting for confirmation...';
+    const receipt = await tx.wait();
+
+    txSpin.succeed(theme.success('Transaction confirmed!'));
+
+    console.log('');
+    showSection('TRANSACTION RECEIPT');
+    kvDisplay([
+      ['TX Hash', receipt.hash],
+      ['Block', receipt.blockNumber.toString()],
+      ['Gas Used', receipt.gasUsed.toString()],
+      ['Status', receipt.status === 1 ? theme.success('✓ Success') : theme.error('✗ Failed')],
+    ]);
+    console.log('');
+
+  } catch (err) {
+    spin.fail('Send failed');
+    if (err.message.includes('incorrect password') || err.message.includes('bad decrypt')) {
+      error('Wrong password');
+    } else {
+      error(err.message);
+    }
+  }
+}
+
+// ═══════════════════════════════════════
+// RECEIVE — Show address + QR-friendly display
+// ═══════════════════════════════════════
+
+export async function receiveAddress(walletName) {
+  const name = walletName || getConfig('activeWallet');
+  if (!name) {
+    error('No active wallet. Set one: darksol wallet use <name>');
+    return;
+  }
+
+  const walletData = loadWallet(name);
+  const chain = getConfig('chain') || 'base';
+
+  console.log('');
+  showSection(`RECEIVE — ${name}`);
+  console.log('');
+  console.log(theme.gold('  Your address:'));
+  console.log('');
+  console.log(theme.gold.bold(`  ${walletData.address}`));
+  console.log('');
+
+  // Visual box around address for easy copy
+  const addr = walletData.address;
+  const boxWidth = addr.length + 4;
+  console.log(theme.dim(`  ┌${'─'.repeat(boxWidth)}┐`));
+  console.log(theme.dim(`  │  `) + theme.gold(addr) + theme.dim(`  │`));
+  console.log(theme.dim(`  └${'─'.repeat(boxWidth)}┘`));
+  console.log('');
+
+  console.log(theme.dim('  This address works on ALL EVM chains:'));
+  console.log(theme.dim('  Base • Ethereum • Arbitrum • Optimism • Polygon'));
+  console.log('');
+  console.log(theme.dim(`  Active chain: ${theme.gold(chain)}`));
+  console.log(theme.dim('  Make sure the sender is on the same chain!'));
+  console.log('');
+
+  warn('Double-check the address before sharing.');
+  warn('Only send EVM-compatible tokens to this address.');
+  console.log('');
+}
+
 // Export wallet (show address only, never PK without password)
 export async function exportWallet(name) {
   if (!name) {

package/src/web/commands.js

@@ -72,6 +72,10 @@ export async function handleCommand(cmd, ws) {
       return await cmdCasino(args, ws);
     case 'facilitator':
       return await cmdFacilitator(args, ws);
+    case 'send':
+      return await cmdSend(args, ws);
+    case 'receive':
+      return await cmdReceive(ws);
     default:
       return {
         output: `\r\n  ${ANSI.red}✗ Unknown command: ${cmd}${ANSI.reset}\r\n  ${ANSI.dim}Type ${ANSI.gold}help${ANSI.dim} for available commands.${ANSI.reset}\r\n\r\n`,
@@ -504,6 +508,84 @@ async function cmdConfig(ws) {
   return {};
 }
 
+// ══════════════════════════════════════════════════
+// SEND / RECEIVE (web shell — info only, actual sends require CLI)
+// ══════════════════════════════════════════════════
+async function cmdSend(args, ws) {
+  const chain = getConfig('chain') || 'base';
+  const wallet = getConfig('activeWallet');
+
+  ws.sendLine(`${ANSI.gold}  ◆ SEND TOKENS${ANSI.reset}`);
+  ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+  ws.sendLine('');
+
+  if (!wallet) {
+    ws.sendLine(`  ${ANSI.red}No wallet configured.${ANSI.reset}`);
+    ws.sendLine(`  Create one: ${ANSI.gold}darksol wallet create <name>${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
+
+  ws.sendLine(`  ${ANSI.white}Send ETH or any ERC-20 token from your wallet.${ANSI.reset}`);
+  ws.sendLine('');
+  ws.sendLine(`  ${ANSI.darkGold}Usage:${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.gold}darksol send --to 0x... --amount 0.1 --token ETH${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.gold}darksol send --to 0x... --amount 50 --token USDC${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.gold}darksol send${ANSI.reset}  ${ANSI.dim}(interactive mode — prompts for everything)${ANSI.reset}`);
+  ws.sendLine('');
+  ws.sendLine(`  ${ANSI.darkGold}Features:${ANSI.reset}`);
+  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} ETH and any ERC-20 token`);
+  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} Balance check before sending`);
+  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} Gas estimation in preview`);
+  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} Confirmation prompt before execution`);
+  ws.sendLine(`  ${ANSI.dim}•${ANSI.reset} On-chain receipt after confirmation`);
+  ws.sendLine('');
+  ws.sendLine(`  ${ANSI.darkGold}Active:${ANSI.reset} ${ANSI.white}${wallet}${ANSI.reset} on ${ANSI.white}${chain}${ANSI.reset}`);
+  ws.sendLine('');
+  ws.sendLine(`  ${ANSI.dim}⚠ Sending requires the CLI. Install: npm i -g @darksol/terminal${ANSI.reset}`);
+  ws.sendLine('');
+  return {};
+}
+
+async function cmdReceive(ws) {
+  const chain = getConfig('chain') || 'base';
+  const wallet = getConfig('activeWallet');
+
+  ws.sendLine(`${ANSI.gold}  ◆ RECEIVE${ANSI.reset}`);
+  ws.sendLine(`${ANSI.dim}  ${'─'.repeat(50)}${ANSI.reset}`);
+  ws.sendLine('');
+
+  if (!wallet) {
+    ws.sendLine(`  ${ANSI.red}No wallet configured.${ANSI.reset}`);
+    ws.sendLine(`  Create one: ${ANSI.gold}darksol wallet create <name>${ANSI.reset}`);
+    ws.sendLine('');
+    return {};
+  }
+
+  try {
+    const { loadWallet } = await import('../wallet/keystore.js');
+    const walletData = loadWallet(wallet);
+    const addr = walletData.address;
+
+    ws.sendLine(`  ${ANSI.white}Your address:${ANSI.reset}`);
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.dim}┌${'─'.repeat(addr.length + 4)}┐${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}│  ${ANSI.gold}${addr}${ANSI.dim}  │${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}└${'─'.repeat(addr.length + 4)}┘${ANSI.reset}`);
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.dim}Works on ALL EVM chains:${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.dim}Base • Ethereum • Arbitrum • Optimism • Polygon${ANSI.reset}`);
+    ws.sendLine('');
+    ws.sendLine(`  ${ANSI.darkGold}Active chain:${ANSI.reset} ${ANSI.white}${chain}${ANSI.reset}`);
+    ws.sendLine(`  ${ANSI.red}Make sure the sender is on the same chain!${ANSI.reset}`);
+    ws.sendLine('');
+  } catch {
+    ws.sendLine(`  ${ANSI.dim}Run: darksol wallet receive${ANSI.reset}`);
+    ws.sendLine('');
+  }
+  return {};
+}
+
 // ══════════════════════════════════════════════════
 // HELPERS
 // ══════════════════════════════════════════════════