@darksol/terminal 0.5.4 → 0.5.6

package/package.json

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

package/src/llm/intent.js

@@ -9,17 +9,36 @@ 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, send/receive tokens, 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, order prepaid cards, and navigate the DARKSOL ecosystem.
+
+You are embedded in a CLI/web terminal. Your responses become actions — when you output structured JSON, the terminal executes real on-chain transactions, card orders, and wallet operations. Be precise. Be careful. Real money is at stake.
 
 CAPABILITIES:
-- Parse natural language into structured trade/transfer commands
+- Parse natural language into structured trade/transfer/card-order commands
+- Execute swaps via Uniswap V3 (Base SwapRouter02, V1 on ETH/Arb/OP/Polygon)
+- Send ETH and ERC-20 tokens to any address
+- Snipe tokens via Uniswap V2 (Base, Ethereum)
+- Order prepaid Visa/Mastercard cards with crypto (via Trocador)
 - 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
-KNOWN TOKENS: ETH, USDC, USDT, DAI, WETH, AERO, VIRTUAL, ARB, OP, WMATIC
+KNOWN TOKENS PER CHAIN:
+- Base: ETH, WETH, USDC, USDbC, DAI, AERO, VIRTUAL
+- Ethereum: ETH, WETH, USDC, USDT, DAI
+- Arbitrum: ETH, WETH, USDC, USDT, ARB
+- Optimism: ETH, WETH, USDC, OP
+- Polygon: MATIC/POL (native), WETH, WMATIC, USDC, USDT
+
+WEB3 KNOWLEDGE:
+- Uniswap V3 uses fee tiers: 500 (0.05%), 3000 (0.3%), 10000 (1%). Default: 3000.
+- Slippage protection: Quoter V2 gets expected output, then applies tolerance (default 0.5%).
+- Token approvals: ERC-20 tokens need approval before swapping (approve → swap is 2 TXs).
+- Gas: Base is very cheap (~$0.01-0.05/TX), Ethereum is expensive ($2-20+/TX).
+- Never send ETH/tokens to a contract address unless you know what you're doing.
+- Always verify contract addresses — don't guess or hallucinate them.
 
 USER CONTEXT:
 - Active chain: {{chain}}
@@ -45,25 +64,80 @@ ACTIONS (use the most specific one):
 - "info" — general question about a token or protocol
 - "analyze" — deep analysis of a token
 - "gas" — gas price check
+- "cards" — order a prepaid Visa/Mastercard with crypto (e.g. "order a $50 card", "get me a prepaid card")
 - "unknown" — can't determine what the user wants
 
+CARDS ORDERING:
+When the user wants to order a prepaid card, you MUST collect:
+1. amount — ONLY these denominations: $10, $25, $50, $100, $250, $500, $1000
+2. email — delivery address for the card activation link
+3. provider — default "swype" (Global Mastercard). Also: "mpc" (US Mastercard), "reward" (US Visa)
+4. ticker — payment crypto, default "usdc"
+
+VERIFIED PAYMENT METHODS (ONLY these work — reject anything else):
+- usdc on base (DEFAULT — cheapest, fastest)
+- usdc on ERC20 (Ethereum — higher gas)
+- usdt on trc20 (Tron — cheap)
+- btc on Mainnet (Bitcoin)
+- eth on ERC20 (Ethereum)
+- sol on Mainnet (Solana)
+- xmr on Mainnet (Monero)
+
+⚠ DO NOT accept: eth/base, sol/sol, usdc/polygon, usdt/eth, or any combo not listed above.
+If the user asks for an unsupported combo (like "pay with ETH on Base"), tell them it's not available and suggest alternatives.
+
+If the user says "order me a $50 card" but doesn't provide an email, set "needsInfo": ["email"] and ask: "What email should I send the card activation link to?"
+If they mention AgentMail or "my email", suggest using their configured agent email.
+
 When parsing, respond with ONLY valid JSON:
 {
-  "action": "swap|send|snipe|dca|price|balance|info|analyze|gas|unknown",
+  "action": "swap|send|snipe|dca|price|balance|info|analyze|gas|cards|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)",
+  "email": "delivery email (for cards)",
+  "provider": "card provider (for cards, default: swype)",
+  "ticker": "payment crypto (for cards, default: usdc)",
   "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"],
+  "needsInfo": ["array of missing fields the AI should ask about"],
+  "followUp": "natural language question to ask the user if info is missing",
   "command": "the exact darksol CLI command to run"
 }
 
+CONVERSATIONAL RULES:
+- If the user's request is missing required info (email for cards, address for send, amount for swap), DON'T set action to "unknown". Set the correct action, list what's missing in "needsInfo", and write a natural "followUp" question.
+- Be conversational — "What email should I send the card to?" not "Error: email required"
+- If they mention AgentMail or "my email", suggest using their configured agent email
+- For cards without a specified provider, default to "swype" (global Mastercard)
+- For swaps without a specified chain, use the user's active chain ({{chain}})
+- Never hallucinate contract addresses — if you don't know it, say so
+- When a user asks "how do I..." give them the exact darksol CLI command
+
+AGENT/TOOL-USE BEHAVIOR:
+When an AI agent (like OpenClaw) is using this terminal programmatically:
+- Always return structured JSON for actionable intents
+- Include the exact "command" field so the agent can run it
+- Include "warnings" for anything risky (high value, unverified token, etc.)
+- If confidence < 0.6, ask for clarification rather than guessing
+- For card orders: validate amount is in [10,25,50,100,250,500,1000] and ticker is verified
+- For swaps: validate both tokens are known symbols or valid 0x addresses
+- For sends: validate "to" looks like a valid address (0x + 40 hex chars)
+
+ERROR GUIDANCE:
+When something fails, help the user fix it:
+- "CALL_EXCEPTION" → likely an RPC issue, suggest switching RPCs
+- "insufficient funds" → tell them their balance, suggest a lower amount
+- "coin not found" → the crypto/network combo isn't supported, list what works
+- "nonce" → pending transaction, wait and retry
+- Don't just say "error" — explain what went wrong and what to do next
+
 COMMAND MAPPING:
 - swap → darksol trade swap -i <tokenIn> -o <tokenOut> -a <amount>
 - send → darksol send --to <address> --amount <amount> --token <token>
@@ -72,6 +146,7 @@ COMMAND MAPPING:
 - price → darksol price <token>
 - balance → darksol wallet balance
 - gas → darksol gas <chain>
+- cards → darksol cards order -p <provider> -a <amount> -e <email> --ticker <crypto>
 - analyze → darksol ai analyze <token>`;
 
 // ──────────────────────────────────────────────────
@@ -217,7 +292,7 @@ export async function startChat(opts = {}) {
       }
 
       // Try to detect actionable intent
-      const actionKeywords = /\b(swap|send|transfer|buy|sell|snipe|dca|price|balance|gas)\b/i;
+      const actionKeywords = /\b(swap|send|transfer|buy|sell|snipe|dca|price|balance|gas|card|cards|order|prepaid|visa|mastercard)\b/i;
       const isActionable = actionKeywords.test(input);
 
       let result;
@@ -456,8 +531,27 @@ export async function executeIntent(intent, opts = {}) {
   }
 
   try {
+    // Check if the AI needs more info before executing
+    if (intent.needsInfo?.length > 0) {
+      if (intent.followUp) {
+        console.log('');
+        console.log(theme.gold('  DARKSOL AI:'));
+        console.log(theme.dim('  ') + intent.followUp);
+        console.log('');
+      }
+      return { success: false, reason: 'needs_info', needsInfo: intent.needsInfo, followUp: intent.followUp };
+    }
+
     switch (intent.action) {
       case 'swap': {
+        if (!intent.tokenIn || !intent.tokenOut) {
+          info('I need to know what tokens to swap. Example: "swap 0.1 ETH to USDC"');
+          return { success: false, reason: 'Missing token pair — tell me what to swap from and to.' };
+        }
+        if (!intent.amount) {
+          info('How much do you want to swap? Example: "swap 0.1 ETH to USDC"');
+          return { success: false, reason: 'Missing amount — how much do you want to swap?' };
+        }
         const { executeSwap } = await import('../trading/swap.js');
         return await executeSwap({
           tokenIn: intent.tokenIn,
@@ -469,29 +563,40 @@ export async function executeIntent(intent, opts = {}) {
       }
 
       case 'snipe': {
-        const { executeSnipe } = await import('../trading/snipe.js');
-        return await executeSnipe({
-          token: intent.tokenOut || intent.tokenIn,
-          amount: intent.amount,
+        const snipeToken = intent.tokenOut || intent.tokenIn;
+        if (!snipeToken || !snipeToken.startsWith('0x')) {
+          info('Snipe needs a contract address. Example: "snipe 0x1234... with 0.1 ETH"');
+          return { success: false, reason: 'I need a token contract address to snipe.' };
+        }
+        const { snipeToken: doSnipe } = await import('../trading/snipe.js');
+        return await doSnipe(snipeToken, intent.amount || '0.01', {
           chain: intent.chain,
-          gasMultiplier: intent.gasMultiplier,
-          password: opts.password,
+          slippage: intent.slippage,
+          gas: intent.gasMultiplier,
         });
       }
 
       case 'dca': {
-        const { createDCAOrder } = await import('../trading/dca.js');
-        return await createDCAOrder({
-          token: intent.tokenOut || intent.tokenIn,
+        const { createDCA } = await import('../trading/dca.js');
+        return await createDCA({
+          tokenOut: intent.tokenOut || intent.tokenIn,
           amount: intent.amount,
           interval: intent.interval || '1h',
-          orders: intent.orders || 10,
+          totalOrders: intent.orders || 10,
           chain: intent.chain,
         });
       }
 
       case 'send':
       case 'transfer': {
+        if (!intent.to) {
+          info('Where should I send it? Give me a wallet address (0x...)');
+          return { success: false, reason: 'Missing recipient address — who are you sending to?' };
+        }
+        if (!intent.amount) {
+          info('How much? Example: "send 10 USDC to 0x..."');
+          return { success: false, reason: 'Missing amount — how much do you want to send?' };
+        }
         const { sendFunds } = await import('../wallet/manager.js');
         return await sendFunds({
           to: intent.to,
@@ -507,8 +612,8 @@ export async function executeIntent(intent, opts = {}) {
           await checkPrices([token]);
           return { success: true, action: 'price' };
         }
-        info('No token specified');
-        return { success: false, reason: 'no token specified' };
+        info('Which token? Example: "price ETH" or "how much is AERO"');
+        return { success: false, reason: 'Which token do you want the price for?' };
       }
 
       case 'balance': {
@@ -523,6 +628,23 @@ export async function executeIntent(intent, opts = {}) {
         return { success: true, action: 'gas' };
       }
 
+      case 'cards': {
+        if (!intent.amount) {
+          info('What denomination? We have $10, $25, $50, $100, $250, $500, $1000');
+          return { success: false, reason: 'What card amount do you want?' };
+        }
+        if (!intent.email) {
+          info('I need an email to deliver the card activation link to.');
+          return { success: false, reason: 'What email should I send the card to?' };
+        }
+        const { cardsOrder } = await import('../services/cards.js');
+        return await cardsOrder(intent.provider || 'swype', intent.amount, {
+          email: intent.email,
+          ticker: intent.ticker || 'usdc',
+          network: intent.network,
+        });
+      }
+
       case 'info':
       case 'analyze': {
         const token = intent.tokenOut || intent.tokenIn || intent.token;
@@ -530,20 +652,37 @@ export async function executeIntent(intent, opts = {}) {
           await analyzeToken(token, opts);
           return { success: true, action: 'analyze' };
         }
-        info('No token specified for analysis');
-        return { success: false, reason: 'no token specified' };
+        info('Which token do you want me to analyze?');
+        return { success: false, reason: 'Tell me which token to look at.' };
       }
 
       default:
-        warn(`Action "${intent.action}" not yet wired for execution`);
+        warn(`I don't know how to do "${intent.action}" yet.`);
         if (intent.command) {
-          info(`Suggested command: ${theme.gold(intent.command)}`);
+          info(`Try running: ${theme.gold(intent.command)}`);
         }
-        return { success: false, reason: `unhandled action: ${intent.action}` };
+        return { success: false, reason: `Action "${intent.action}" isn't wired up yet.` };
     }
   } catch (err) {
-    error(`Execution failed: ${err.message}`);
-    return { success: false, error: err.message };
+    // Human-readable error messages
+    const msg = err.message || String(err);
+    if (msg.includes('CALL_EXCEPTION')) {
+      error('The on-chain call failed. This usually means the RPC is having issues or the contract call reverted.');
+      info('Try again in a moment, or switch to a different RPC with: darksol config set rpcs.base <url>');
+    } else if (msg.includes('insufficient funds') || msg.includes('Insufficient')) {
+      error('Not enough funds in your wallet for this transaction (including gas fees).');
+    } else if (msg.includes('nonce')) {
+      error('Transaction nonce conflict. You may have a pending transaction — wait for it to confirm or try again.');
+    } else if (msg.includes('timeout') || msg.includes('ETIMEDOUT')) {
+      error('Network timeout — the RPC server didn\'t respond in time. Try again or switch RPCs.');
+    } else if (msg.includes('could not detect network')) {
+      error('Can\'t connect to the blockchain. Check your internet connection and RPC settings.');
+    } else if (msg.includes('password') || msg.includes('decrypt')) {
+      error('Wrong wallet password. The private key couldn\'t be decrypted.');
+    } else {
+      error(`Failed: ${msg}`);
+    }
+    return { success: false, error: msg };
   }
 }
 

package/src/services/cards.js

@@ -6,40 +6,80 @@ import { showSection } from '../ui/banner.js';
 
 const BASE = () => getServiceURL('cards') || 'https://acp.darksol.net';
 
-// Verified working ticker/network combos (tested against Trocador API)
-const VALID_CRYPTO = {
-  'usdc':  { network: 'base', display: 'USDC on Base' },
-  'usdc_base': { ticker: 'usdc', network: 'base', display: 'USDC on Base' },
-  'usdc_erc20': { ticker: 'usdc', network: 'ERC20', display: 'USDC on Ethereum' },
-  'usdt':  { network: 'trc20', display: 'USDT on Tron' },
-  'usdt_trc20': { ticker: 'usdt', network: 'trc20', display: 'USDT on Tron' },
-  'btc':   { network: 'Mainnet', display: 'Bitcoin' },
-  'eth':   { network: 'ERC20', display: 'ETH on Ethereum' },
-  'sol':   { network: 'Mainnet', display: 'Solana' },
-  'xmr':   { network: 'Mainnet', display: 'Monero' },
+// ══════════════════════════════════════════════════
+// VERIFIED CRYPTO COMBOS (tested against Trocador API 2026-03-09)
+// Only these combos are allowed — everything else is rejected before hitting the API
+// ══════════════════════════════════════════════════
+const VERIFIED_COMBOS = [
+  { ticker: 'usdc', network: 'base',    display: 'USDC on Base',     default: true },
+  { ticker: 'usdc', network: 'ERC20',   display: 'USDC on Ethereum' },
+  { ticker: 'usdt', network: 'trc20',   display: 'USDT on Tron (TRC-20)' },
+  { ticker: 'btc',  network: 'Mainnet', display: 'Bitcoin (BTC)' },
+  { ticker: 'eth',  network: 'ERC20',   display: 'Ethereum (ETH)' },
+  { ticker: 'sol',  network: 'Mainnet', display: 'Solana (SOL)' },
+  { ticker: 'xmr',  network: 'Mainnet', display: 'Monero (XMR)' },
+];
+
+// Aliases: what users might type → what Trocador expects
+const TICKER_ALIASES = {
+  'ethereum': 'eth', 'ether': 'eth',
+  'bitcoin': 'btc',
+  'solana': 'sol',
+  'monero': 'xmr',
+  'tether': 'usdt',
+  'usd coin': 'usdc', 'usd-c': 'usdc',
 };
 
-// Map user-friendly network names to Trocador-compatible ones
-const NETWORK_MAP = {
+const NETWORK_ALIASES = {
   'base': 'base',
-  'ethereum': 'ERC20', 'eth': 'ERC20', 'erc20': 'ERC20',
-  'tron': 'trc20', 'trc20': 'trc20',
-  'mainnet': 'Mainnet', 'btc': 'Mainnet', 'sol': 'Mainnet', 'xmr': 'Mainnet',
+  'ethereum': 'ERC20', 'eth': 'ERC20', 'erc20': 'ERC20', 'erc-20': 'ERC20',
+  'tron': 'trc20', 'trc20': 'trc20', 'trc-20': 'trc20',
+  'mainnet': 'Mainnet', 'main': 'Mainnet',
 };
 
+const VALID_AMOUNTS = [10, 25, 50, 100, 250, 500, 1000];
+
+/**
+ * Resolve user input to a verified ticker/network combo.
+ * Returns { ticker, network, display } or null if invalid.
+ */
 function resolveTickerNetwork(ticker, network) {
-  const t = (ticker || '').toLowerCase();
-  const n = (network || '').toLowerCase();
+  const t = TICKER_ALIASES[(ticker || '').toLowerCase()] || (ticker || '').toLowerCase();
 
-  // If just ticker provided, use known defaults
-  if (t && !n) {
-    const known = VALID_CRYPTO[t];
-    if (known) return { ticker: known.ticker || t, network: known.network };
+  // If network specified, try to match exactly
+  if (network) {
+    const n = NETWORK_ALIASES[(network || '').toLowerCase()] || network;
+    const match = VERIFIED_COMBOS.find(c => c.ticker === t && c.network === n);
+    if (match) return match;
+    // Try just the ticker with its default network
   }
 
-  // Map network to Trocador format
-  const mappedNetwork = NETWORK_MAP[n] || network;
-  return { ticker: t, network: mappedNetwork };
+  // Just ticker — find the verified default for it
+  const match = VERIFIED_COMBOS.find(c => c.ticker === t);
+  if (match) return match;
+
+  return null; // Not a verified combo
+}
+
+/**
+ * Get all verified combos (for menus / agent listings)
+ */
+export function getVerifiedCombos() {
+  return VERIFIED_COMBOS;
+}
+
+/**
+ * Get the default combo
+ */
+export function getDefaultCombo() {
+  return VERIFIED_COMBOS.find(c => c.default) || VERIFIED_COMBOS[0];
+}
+
+/**
+ * Get valid amounts
+ */
+export function getValidAmounts() {
+  return VALID_AMOUNTS;
 }
 
 export async function cardsCatalog() {
@@ -87,19 +127,40 @@ export async function cardsOrder(provider, amount, opts = {}) {
     return;
   }
 
+  // Validate amount
+  const numAmount = Number(amount);
+  if (!VALID_AMOUNTS.includes(numAmount)) {
+    error(`Invalid card amount: $${amount}. Valid amounts: ${VALID_AMOUNTS.map(a => '$' + a).join(', ')}`);
+    return;
+  }
+
+  // Validate provider
+  const validProviders = ['swype', 'mpc', 'reward'];
+  if (!validProviders.includes((provider || '').toLowerCase())) {
+    error(`Invalid provider: ${provider}. Options: swype (Global MC), mpc (US MC), reward (US Visa)`);
+    return;
+  }
+
   const spin = spinner('Processing card order...').start();
   try {
     const body = {
-      provider,
-      amount: Number(amount),
+      provider: provider.toLowerCase(),
+      amount: numAmount,
       email: opts.email,
     };
-    // Resolve ticker/network to Trocador-compatible values
+
+    // Resolve and validate crypto
     if (opts.ticker) {
       const resolved = resolveTickerNetwork(opts.ticker, opts.network);
+      if (!resolved) {
+        spin.fail('Invalid payment method');
+        error(`"${opts.ticker}${opts.network ? '/' + opts.network : ''}" is not a supported payment option.`);
+        info('Supported: ' + VERIFIED_COMBOS.map(c => c.display).join(', '));
+        return;
+      }
       body.tickerFrom = resolved.ticker;
       body.networkFrom = resolved.network;
-      info(`Payment: ${resolved.ticker.toUpperCase()} on ${resolved.network}`);
+      info(`Payment: ${resolved.display}`);
     }
 
     const data = await fetchJSON(`${BASE()}/api/cards/order`, {

package/src/web/commands.js

@@ -215,9 +215,12 @@ export async function handleMenuSelect(id, value, item, ws) {
 
     case 'cards_crypto':
       if (value === 'back') return {};
-      // Execute the order
+      // Execute the order with verified combo
       return await executeCardOrder(item?.meta || {}, ws);
 
+    case 'cards_status_check':
+      return await showCardStatus(value, ws);
+
     case 'agent_action':
       if (value === 'start') {
         const { listWallets } = await import('../wallet/keystore.js');
@@ -454,7 +457,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)\b/i;
+      const nlKeywords = /\b(swap|buy|sell|send|transfer|price|what|how|should|analyze|check|balance|gas|dca|order|card|prepaid|visa|mastercard)\b/i;
       if (nlKeywords.test(cmd)) {
         return await cmdAI(cmd.split(/\s+/), ws);
       }