@darksol/terminal 0.1.0

package/src/ui/banner.js

@@ -0,0 +1,60 @@
+import figlet from 'figlet';
+import gradient from 'gradient-string';
+import chalk from 'chalk';
+import { theme } from './theme.js';
+
+const darksol_gradient = gradient(['#B8860B', '#FFD700', '#FFF8DC', '#FFD700', '#B8860B']);
+
+export function showBanner(opts = {}) {
+  const banner = figlet.textSync('DARKSOL', {
+    font: 'ANSI Shadow',
+    horizontalLayout: 'fitted',
+  });
+
+  console.log('');
+  console.log(darksol_gradient(banner));
+  console.log('');
+  console.log(
+    theme.dim('  ╔══════════════════════════════════════════════════════════╗')
+  );
+  console.log(
+    theme.dim('  ║ ') +
+    theme.gold.bold(' DARKSOL TERMINAL') +
+    theme.dim('  —  ') +
+    theme.subtle('Ghost in the machine with teeth') +
+    theme.dim('  ║')
+  );
+  console.log(
+    theme.dim('  ║ ') +
+    theme.subtle(' v0.1.0') +
+    theme.dim('                                                ') +
+    theme.gold('🌑') +
+    theme.dim(' ║')
+  );
+  console.log(
+    theme.dim('  ╚══════════════════════════════════════════════════════════╝')
+  );
+  console.log('');
+
+  if (opts.tagline !== false) {
+    console.log(theme.subtle('  All services. One terminal. Zero trust required.'));
+    console.log('');
+  }
+}
+
+export function showMiniBanner() {
+  console.log('');
+  console.log(theme.gold.bold('  🌑 DARKSOL TERMINAL') + theme.dim(' v0.1.0'));
+  console.log(theme.dim('  ─────────────────────────────'));
+  console.log('');
+}
+
+export function showSection(title) {
+  console.log('');
+  console.log(theme.gold('  ◆ ') + theme.header(title));
+  console.log(theme.dim('  ' + '─'.repeat(50)));
+}
+
+export function showDivider() {
+  console.log(theme.dim('  ' + '─'.repeat(50)));
+}

package/src/ui/components.js

@@ -0,0 +1,126 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+import Table from 'cli-table3';
+import ora from 'ora';
+import { theme } from './theme.js';
+
+// Branded spinner
+export function spinner(text) {
+  return ora({
+    text: theme.dim(text),
+    spinner: 'dots',
+    color: 'yellow',
+  });
+}
+
+// Info card
+export function card(title, content, opts = {}) {
+  const box = boxen(content, {
+    title: theme.gold.bold(` ${title} `),
+    titleAlignment: 'left',
+    padding: 1,
+    margin: { top: 0, bottom: 0, left: 2, right: 0 },
+    borderStyle: 'round',
+    borderColor: '#FFD700',
+    ...opts,
+  });
+  console.log(box);
+}
+
+// Key-value display
+export function kvDisplay(pairs, opts = {}) {
+  const maxKey = Math.max(...pairs.map(([k]) => k.length));
+  const lines = pairs.map(([key, value]) => {
+    const paddedKey = key.padEnd(maxKey);
+    return `  ${theme.label(paddedKey)}  ${theme.value(value)}`;
+  });
+  if (opts.title) {
+    console.log('');
+    console.log(theme.gold('  ◆ ') + theme.header(opts.title));
+    console.log(theme.dim('  ' + '─'.repeat(50)));
+  }
+  lines.forEach(l => console.log(l));
+  if (opts.footer) {
+    console.log(theme.dim('  ' + '─'.repeat(50)));
+    console.log(theme.subtle(`  ${opts.footer}`));
+  }
+}
+
+// Styled table
+export function table(headers, rows, opts = {}) {
+  const t = new Table({
+    head: headers.map(h => theme.gold.bold(h)),
+    chars: {
+      'top': '─', 'top-mid': '┬', 'top-left': '┌', 'top-right': '┐',
+      'bottom': '─', 'bottom-mid': '┴', 'bottom-left': '└', 'bottom-right': '┘',
+      'left': '│', 'left-mid': '├', 'mid': '─', 'mid-mid': '┼',
+      'right': '│', 'right-mid': '┤', 'middle': '│'
+    },
+    style: {
+      head: [],
+      border: ['grey'],
+      ...opts.style,
+    },
+    ...(opts.colWidths ? { colWidths: opts.colWidths } : {}),
+  });
+
+  rows.forEach(row => t.push(row));
+  console.log(t.toString());
+}
+
+// Price formatting with color
+export function formatPrice(price, opts = {}) {
+  const num = parseFloat(price);
+  if (isNaN(num)) return theme.dim('N/A');
+
+  const formatted = opts.decimals !== undefined
+    ? num.toFixed(opts.decimals)
+    : num < 0.01 ? num.toPrecision(4) : num.toFixed(2);
+
+  return `$${formatted}`;
+}
+
+export function formatChange(change) {
+  const num = parseFloat(change);
+  if (isNaN(num)) return theme.dim('N/A');
+  const sign = num >= 0 ? '+' : '';
+  const color = num > 0 ? theme.price.up : num < 0 ? theme.price.down : theme.price.neutral;
+  return color(`${sign}${num.toFixed(2)}%`);
+}
+
+export function formatAddress(address, chars = 6) {
+  if (!address) return theme.dim('N/A');
+  return `${address.slice(0, chars)}...${address.slice(-4)}`;
+}
+
+export function formatETH(wei, decimals = 6) {
+  const eth = parseFloat(wei) / 1e18;
+  return `${eth.toFixed(decimals)} ETH`;
+}
+
+export function formatUSDC(raw, decimals = 2) {
+  const usdc = parseFloat(raw) / 1e6;
+  return `$${usdc.toFixed(decimals)} USDC`;
+}
+
+// Success/error messages
+export function success(msg) {
+  console.log(theme.success('  ✓ ') + msg);
+}
+
+export function error(msg) {
+  console.log(theme.error('  ✗ ') + msg);
+}
+
+export function warn(msg) {
+  console.log(theme.warning('  ⚠ ') + msg);
+}
+
+export function info(msg) {
+  console.log(theme.info('  ℹ ') + msg);
+}
+
+// Confirmation prompt formatting
+export function confirmLine(label, value) {
+  return `${theme.label(label.padEnd(16))} ${theme.value(value)}`;
+}

package/src/ui/theme.js

@@ -0,0 +1,46 @@
+import chalk from 'chalk';
+
+// DARKSOL Terminal Theme — gold/dark palette
+export const theme = {
+  // Primary colors
+  gold: chalk.hex('#FFD700'),
+  darkGold: chalk.hex('#B8860B'),
+  dim: chalk.hex('#666666'),
+  bright: chalk.hex('#FFFFFF'),
+  dark: chalk.hex('#1a1a2e'),
+  accent: chalk.hex('#e94560'),
+  success: chalk.hex('#00ff88'),
+  warning: chalk.hex('#ffaa00'),
+  error: chalk.hex('#ff4444'),
+  info: chalk.hex('#4488ff'),
+  muted: chalk.hex('#555555'),
+
+  // Semantic
+  price: {
+    up: chalk.hex('#00ff88'),
+    down: chalk.hex('#ff4444'),
+    neutral: chalk.hex('#888888'),
+  },
+
+  // Box styles
+  border: chalk.hex('#FFD700'),
+
+  // Format helpers
+  header: (text) => chalk.hex('#FFD700').bold(text),
+  label: (text) => chalk.hex('#B8860B')(text),
+  value: (text) => chalk.white.bold(text),
+  subtle: (text) => chalk.hex('#666666')(text),
+  link: (text) => chalk.hex('#4488ff').underline(text),
+  badge: (text) => chalk.bgHex('#FFD700').hex('#000000').bold(` ${text} `),
+  errorBadge: (text) => chalk.bgHex('#ff4444').white.bold(` ${text} `),
+  successBadge: (text) => chalk.bgHex('#00ff88').hex('#000000').bold(` ${text} `),
+};
+
+// Box drawing chars for custom borders
+export const box = {
+  tl: '╔', tr: '╗', bl: '╚', br: '╝',
+  h: '═', v: '║',
+  t: '╦', b: '╩', l: '╠', r: '╣', x: '╬',
+};
+
+export default theme;

package/src/wallet/keystore.js

@@ -0,0 +1,127 @@
+import { randomBytes, createCipheriv, createDecipheriv, scryptSync } from 'crypto';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const WALLET_DIR = join(homedir(), '.darksol', 'wallets');
+const ALGORITHM = 'aes-256-gcm';
+const SCRYPT_N = 2 ** 18;
+const SCRYPT_r = 8;
+const SCRYPT_p = 1;
+const KEY_LENGTH = 32;
+const SALT_LENGTH = 32;
+const IV_LENGTH = 16;
+const SCRYPT_MAXMEM = 512 * 1024 * 1024;
+
+function ensureDir() {
+  if (!existsSync(WALLET_DIR)) {
+    mkdirSync(WALLET_DIR, { recursive: true });
+  }
+}
+
+// Encrypt a private key with a password
+export function encryptKey(privateKey, password) {
+  const salt = randomBytes(SALT_LENGTH);
+  const iv = randomBytes(IV_LENGTH);
+  const key = scryptSync(password, salt, KEY_LENGTH, {
+    N: SCRYPT_N,
+    r: SCRYPT_r,
+    p: SCRYPT_p,
+    maxmem: SCRYPT_MAXMEM,
+  });
+
+  const cipher = createCipheriv(ALGORITHM, key, iv);
+  let encrypted = cipher.update(privateKey, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+  const tag = cipher.getAuthTag();
+
+  return {
+    version: 1,
+    algorithm: ALGORITHM,
+    kdf: 'scrypt',
+    kdfParams: { N: SCRYPT_N, r: SCRYPT_r, p: SCRYPT_p },
+    salt: salt.toString('hex'),
+    iv: iv.toString('hex'),
+    tag: tag.toString('hex'),
+    ciphertext: encrypted,
+  };
+}
+
+// Decrypt a private key with a password
+export function decryptKey(keystore, password) {
+  const salt = Buffer.from(keystore.salt, 'hex');
+  const iv = Buffer.from(keystore.iv, 'hex');
+  const tag = Buffer.from(keystore.tag, 'hex');
+
+  const key = scryptSync(password, salt, KEY_LENGTH, {
+    N: keystore.kdfParams.N,
+    r: keystore.kdfParams.r,
+    p: keystore.kdfParams.p,
+    maxmem: SCRYPT_MAXMEM,
+  });
+
+  const decipher = createDecipheriv(ALGORITHM, key, iv);
+  decipher.setAuthTag(tag);
+  let decrypted = decipher.update(keystore.ciphertext, 'hex', 'utf8');
+  decrypted += decipher.final('utf8');
+
+  return decrypted;
+}
+
+// Save wallet to disk
+export function saveWallet(name, address, keystoreData, metadata = {}) {
+  ensureDir();
+  const walletFile = join(WALLET_DIR, `${name}.json`);
+
+  const wallet = {
+    name,
+    address,
+    keystore: keystoreData,
+    chain: metadata.chain || 'base',
+    createdAt: new Date().toISOString(),
+    ...metadata,
+  };
+
+  writeFileSync(walletFile, JSON.stringify(wallet, null, 2));
+  return walletFile;
+}
+
+// Load wallet from disk
+export function loadWallet(name) {
+  const walletFile = join(WALLET_DIR, `${name}.json`);
+  if (!existsSync(walletFile)) {
+    throw new Error(`Wallet "${name}" not found`);
+  }
+  return JSON.parse(readFileSync(walletFile, 'utf8'));
+}
+
+// List all wallets
+export function listWallets() {
+  ensureDir();
+  const files = readdirSync(WALLET_DIR).filter(f => f.endsWith('.json'));
+  return files.map(f => {
+    const data = JSON.parse(readFileSync(join(WALLET_DIR, f), 'utf8'));
+    return {
+      name: data.name,
+      address: data.address,
+      chain: data.chain,
+      createdAt: data.createdAt,
+    };
+  });
+}
+
+// Delete wallet
+export function deleteWallet(name) {
+  const walletFile = join(WALLET_DIR, `${name}.json`);
+  if (!existsSync(walletFile)) {
+    throw new Error(`Wallet "${name}" not found`);
+  }
+  unlinkSync(walletFile);
+}
+
+// Check if wallet exists
+export function walletExists(name) {
+  return existsSync(join(WALLET_DIR, `${name}.json`));
+}
+
+export { WALLET_DIR };

package/src/wallet/manager.js

@@ -0,0 +1,287 @@
+import { ethers } from 'ethers';
+import { encryptKey, decryptKey, saveWallet, loadWallet, listWallets, walletExists, WALLET_DIR } from './keystore.js';
+import { getConfig, setConfig, getRPC } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { card, kvDisplay, success, error, warn, spinner, table } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+import inquirer from 'inquirer';
+
+// Create a new wallet
+export async function createWallet(name, opts = {}) {
+  if (!name) {
+    const { walletName } = await inquirer.prompt([{
+      type: 'input',
+      name: 'walletName',
+      message: theme.gold('Wallet name:'),
+      validate: (v) => v.length > 0 || 'Name required',
+    }]);
+    name = walletName;
+  }
+
+  if (walletExists(name)) {
+    error(`Wallet "${name}" already exists`);
+    return;
+  }
+
+  const { password } = await inquirer.prompt([{
+    type: 'password',
+    name: 'password',
+    message: theme.gold('Encryption password:'),
+    mask: '●',
+    validate: (v) => v.length >= 8 || 'Minimum 8 characters',
+  }]);
+
+  const { confirmPassword } = await inquirer.prompt([{
+    type: 'password',
+    name: 'confirmPassword',
+    message: theme.gold('Confirm password:'),
+    mask: '●',
+  }]);
+
+  if (password !== confirmPassword) {
+    error('Passwords do not match');
+    return;
+  }
+
+  const spin = spinner('Generating wallet...').start();
+
+  const wallet = ethers.Wallet.createRandom();
+  const keystoreData = encryptKey(wallet.privateKey, password);
+  const chain = opts.chain || getConfig('chain') || 'base';
+  saveWallet(name, wallet.address, keystoreData, { chain });
+
+  // Set as active if first wallet
+  const wallets = listWallets();
+  if (wallets.length === 1) {
+    setConfig('activeWallet', name);
+  }
+
+  spin.succeed(theme.success('Wallet created'));
+
+  console.log('');
+  showSection('NEW WALLET');
+  kvDisplay([
+    ['Name', name],
+    ['Address', wallet.address],
+    ['Chain', chain],
+    ['Stored', WALLET_DIR],
+  ]);
+  console.log('');
+  warn('Back up your password — there is NO recovery if lost.');
+  warn('Private key is AES-256-GCM encrypted with scrypt KDF.');
+  console.log('');
+}
+
+// Import wallet from private key
+export async function importWallet(name, opts = {}) {
+  if (!name) {
+    const { walletName } = await inquirer.prompt([{
+      type: 'input',
+      name: 'walletName',
+      message: theme.gold('Wallet name:'),
+      validate: (v) => v.length > 0 || 'Name required',
+    }]);
+    name = walletName;
+  }
+
+  if (walletExists(name)) {
+    error(`Wallet "${name}" already exists`);
+    return;
+  }
+
+  const { privateKey } = await inquirer.prompt([{
+    type: 'password',
+    name: 'privateKey',
+    message: theme.gold('Private key (0x...):'),
+    mask: '●',
+    validate: (v) => {
+      try {
+        new ethers.Wallet(v);
+        return true;
+      } catch {
+        return 'Invalid private key';
+      }
+    },
+  }]);
+
+  const { password } = await inquirer.prompt([{
+    type: 'password',
+    name: 'password',
+    message: theme.gold('Encryption password:'),
+    mask: '●',
+    validate: (v) => v.length >= 8 || 'Minimum 8 characters',
+  }]);
+
+  const spin = spinner('Encrypting and storing...').start();
+
+  const wallet = new ethers.Wallet(privateKey);
+  const keystoreData = encryptKey(privateKey, password);
+  const chain = opts.chain || getConfig('chain') || 'base';
+  saveWallet(name, wallet.address, keystoreData, { chain });
+
+  spin.succeed(theme.success('Wallet imported'));
+
+  console.log('');
+  showSection('IMPORTED WALLET');
+  kvDisplay([
+    ['Name', name],
+    ['Address', wallet.address],
+    ['Chain', chain],
+  ]);
+  console.log('');
+  success('Private key encrypted and stored securely.');
+}
+
+// List wallets
+export async function showWallets() {
+  const wallets = listWallets();
+  const active = getConfig('activeWallet');
+
+  if (wallets.length === 0) {
+    warn('No wallets found. Create one with: darksol wallet create');
+    return;
+  }
+
+  showSection('WALLETS');
+
+  const rows = wallets.map(w => [
+    w.name === active ? theme.gold('► ' + w.name) : '  ' + w.name,
+    w.address,
+    w.chain,
+    new Date(w.createdAt).toLocaleDateString(),
+  ]);
+
+  table(['Name', 'Address', 'Chain', 'Created'], rows);
+}
+
+// Get a signer (unlocked wallet) for transactions
+export async function getSigner(walletName, password) {
+  const name = walletName || getConfig('activeWallet');
+  if (!name) {
+    throw new Error('No active wallet. Set one with: darksol wallet use <name>');
+  }
+
+  const walletData = loadWallet(name);
+  const privateKey = decryptKey(walletData.keystore, password);
+  const rpcUrl = getRPC(walletData.chain);
+  const provider = new ethers.JsonRpcProvider(rpcUrl);
+  const signer = new ethers.Wallet(privateKey, provider);
+
+  return { signer, provider, address: walletData.address, chain: walletData.chain };
+}
+
+// Get wallet balance
+export async function getBalance(walletName) {
+  const name = walletName || getConfig('activeWallet');
+  if (!name) {
+    error('No active wallet. Set one with: darksol wallet use <name>');
+    return;
+  }
+
+  const walletData = loadWallet(name);
+  const rpcUrl = getRPC(walletData.chain);
+  const provider = new ethers.JsonRpcProvider(rpcUrl);
+
+  const spin = spinner('Fetching balance...').start();
+
+  try {
+    const balance = await provider.getBalance(walletData.address);
+    const ethBalance = ethers.formatEther(balance);
+
+    // Also check USDC balance
+    const usdcAddresses = {
+      base: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+      ethereum: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+      polygon: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359',
+      arbitrum: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+      optimism: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85',
+    };
+
+    let usdcBalance = '0.00';
+    const usdcAddr = usdcAddresses[walletData.chain];
+    if (usdcAddr) {
+      const usdc = new ethers.Contract(usdcAddr, [
+        'function balanceOf(address) view returns (uint256)',
+        'function decimals() view returns (uint8)',
+      ], provider);
+      try {
+        const raw = await usdc.balanceOf(walletData.address);
+        const decimals = await usdc.decimals();
+        usdcBalance = ethers.formatUnits(raw, decimals);
+      } catch { }
+    }
+
+    spin.succeed('Balance fetched');
+
+    console.log('');
+    showSection(`BALANCE — ${name}`);
+    kvDisplay([
+      ['Address', walletData.address],
+      ['Chain', walletData.chain],
+      ['Native', `${parseFloat(ethBalance).toFixed(6)} ETH`],
+      ['USDC', `$${parseFloat(usdcBalance).toFixed(2)}`],
+    ]);
+    console.log('');
+  } catch (err) {
+    spin.fail('Failed to fetch balance');
+    error(err.message);
+  }
+}
+
+// Set active wallet
+export function useWallet(name) {
+  if (!walletExists(name)) {
+    error(`Wallet "${name}" not found`);
+    return;
+  }
+  setConfig('activeWallet', name);
+  success(`Active wallet set to "${name}"`);
+}
+
+// Export wallet (show address only, never PK without password)
+export async function exportWallet(name) {
+  if (!name) {
+    name = getConfig('activeWallet');
+  }
+  if (!name || !walletExists(name)) {
+    error('Wallet not found');
+    return;
+  }
+
+  const walletData = loadWallet(name);
+
+  showSection(`WALLET — ${name}`);
+  kvDisplay([
+    ['Address', walletData.address],
+    ['Chain', walletData.chain],
+    ['Created', walletData.createdAt],
+    ['Keystore', 'AES-256-GCM + scrypt'],
+  ]);
+
+  const { confirm } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'confirm',
+    message: theme.accent('Export private key? (requires password)'),
+    default: false,
+  }]);
+
+  if (!confirm) return;
+
+  const { password } = await inquirer.prompt([{
+    type: 'password',
+    name: 'password',
+    message: theme.gold('Password:'),
+    mask: '●',
+  }]);
+
+  try {
+    const pk = decryptKey(walletData.keystore, password);
+    console.log('');
+    warn('PRIVATE KEY — DO NOT SHARE');
+    console.log(theme.accent(`  ${pk}`));
+    console.log('');
+    warn('This key controls all funds. Keep it safe.');
+  } catch {
+    error('Wrong password');
+  }
+}