@darksol/terminal 0.1.0

package/src/trading/dca.js

@@ -0,0 +1,249 @@
+import { ethers } from 'ethers';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getSigner } from '../wallet/manager.js';
+import { getConfig } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, success, error, warn, table } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+import { resolveToken, getTokenInfo } from './swap.js';
+import inquirer from 'inquirer';
+
+const DCA_DIR = join(homedir(), '.darksol', 'dca');
+const DCA_FILE = join(DCA_DIR, 'orders.json');
+
+function ensureDir() {
+  if (!existsSync(DCA_DIR)) mkdirSync(DCA_DIR, { recursive: true });
+}
+
+function loadOrders() {
+  ensureDir();
+  if (!existsSync(DCA_FILE)) return [];
+  return JSON.parse(readFileSync(DCA_FILE, 'utf8'));
+}
+
+function saveOrders(orders) {
+  ensureDir();
+  writeFileSync(DCA_FILE, JSON.stringify(orders, null, 2));
+}
+
+// Create a new DCA order
+export async function createDCA(opts = {}) {
+  const chain = getConfig('chain') || 'base';
+
+  showSection('CREATE DCA ORDER');
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'tokenIn',
+      message: theme.gold('Spend token (e.g. ETH, USDC):'),
+      default: 'ETH',
+    },
+    {
+      type: 'input',
+      name: 'tokenOut',
+      message: theme.gold('Buy token (symbol or address):'),
+      validate: v => v.length > 0 || 'Required',
+    },
+    {
+      type: 'input',
+      name: 'amountPerOrder',
+      message: theme.gold('Amount per order:'),
+      validate: v => parseFloat(v) > 0 || 'Must be positive',
+    },
+    {
+      type: 'list',
+      name: 'interval',
+      message: theme.gold('Interval:'),
+      choices: [
+        { name: 'Every 1 hour', value: 3600 },
+        { name: 'Every 4 hours', value: 14400 },
+        { name: 'Every 12 hours', value: 43200 },
+        { name: 'Every 24 hours', value: 86400 },
+        { name: 'Every 7 days', value: 604800 },
+      ],
+    },
+    {
+      type: 'input',
+      name: 'totalOrders',
+      message: theme.gold('Total number of orders:'),
+      default: '10',
+      validate: v => parseInt(v) > 0 || 'Must be positive',
+    },
+  ]);
+
+  const tokenInAddr = resolveToken(answers.tokenIn, chain);
+  const tokenOutAddr = resolveToken(answers.tokenOut, chain);
+
+  if (!tokenInAddr) {
+    error(`Unknown token: ${answers.tokenIn}`);
+    return;
+  }
+  if (!tokenOutAddr) {
+    error(`Unknown token: ${answers.tokenOut}`);
+    return;
+  }
+
+  const order = {
+    id: `dca_${Date.now()}`,
+    chain,
+    tokenIn: answers.tokenIn.toUpperCase(),
+    tokenInAddress: tokenInAddr,
+    tokenOut: answers.tokenOut.toUpperCase(),
+    tokenOutAddress: tokenOutAddr,
+    amountPerOrder: answers.amountPerOrder,
+    interval: answers.interval,
+    totalOrders: parseInt(answers.totalOrders),
+    executedOrders: 0,
+    status: 'active',
+    createdAt: new Date().toISOString(),
+    nextExecution: new Date(Date.now() + answers.interval * 1000).toISOString(),
+    history: [],
+  };
+
+  const totalSpend = parseFloat(answers.amountPerOrder) * parseInt(answers.totalOrders);
+
+  console.log('');
+  kvDisplay([
+    ['Order ID', order.id],
+    ['Buy', `${answers.tokenOut} with ${answers.tokenIn}`],
+    ['Per Order', `${answers.amountPerOrder} ${answers.tokenIn}`],
+    ['Interval', formatInterval(answers.interval)],
+    ['Total Orders', answers.totalOrders],
+    ['Total Spend', `${totalSpend} ${answers.tokenIn}`],
+    ['First Exec', order.nextExecution],
+  ]);
+
+  const { confirm } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'confirm',
+    message: theme.gold('Create DCA order?'),
+    default: true,
+  }]);
+
+  if (!confirm) {
+    warn('DCA order cancelled');
+    return;
+  }
+
+  const orders = loadOrders();
+  orders.push(order);
+  saveOrders(orders);
+
+  success(`DCA order created: ${order.id}`);
+  console.log(theme.dim('  Run the DCA executor to start: darksol dca run'));
+}
+
+// List DCA orders
+export function listDCA() {
+  const orders = loadOrders();
+
+  if (orders.length === 0) {
+    warn('No DCA orders. Create one with: darksol dca create');
+    return;
+  }
+
+  showSection('DCA ORDERS');
+
+  const rows = orders.map(o => [
+    o.id.slice(4, 17),
+    `${o.tokenIn} → ${o.tokenOut}`,
+    o.amountPerOrder,
+    formatInterval(o.interval),
+    `${o.executedOrders}/${o.totalOrders}`,
+    o.status === 'active' ? theme.success('Active') : theme.dim(o.status),
+  ]);
+
+  table(['ID', 'Pair', 'Amount', 'Interval', 'Progress', 'Status'], rows);
+}
+
+// Cancel a DCA order
+export async function cancelDCA(orderId) {
+  const orders = loadOrders();
+  const idx = orders.findIndex(o => o.id === orderId || o.id.includes(orderId));
+
+  if (idx === -1) {
+    error(`Order not found: ${orderId}`);
+    return;
+  }
+
+  orders[idx].status = 'cancelled';
+  saveOrders(orders);
+  success(`DCA order cancelled: ${orders[idx].id}`);
+}
+
+// Execute pending DCA orders
+export async function runDCA(opts = {}) {
+  const orders = loadOrders();
+  const active = orders.filter(o =>
+    o.status === 'active' &&
+    o.executedOrders < o.totalOrders &&
+    new Date(o.nextExecution) <= new Date()
+  );
+
+  if (active.length === 0) {
+    console.log(theme.dim('  No DCA orders ready for execution'));
+    const nextOrder = orders
+      .filter(o => o.status === 'active')
+      .sort((a, b) => new Date(a.nextExecution) - new Date(b.nextExecution))[0];
+
+    if (nextOrder) {
+      console.log(theme.dim(`  Next execution: ${nextOrder.nextExecution}`));
+    }
+    return;
+  }
+
+  showSection(`DCA EXECUTION — ${active.length} order(s) ready`);
+
+  if (!opts.password) {
+    const { password } = await inquirer.prompt([{
+      type: 'password',
+      name: 'password',
+      message: theme.gold('Wallet password (for all orders):'),
+      mask: '●',
+    }]);
+    opts.password = password;
+  }
+
+  for (const order of active) {
+    const spin = spinner(`Executing DCA: ${order.tokenIn} → ${order.tokenOut}`).start();
+
+    try {
+      // TODO: integrate with swap execution
+      // For now, mark as executed and log
+      order.executedOrders++;
+      order.history.push({
+        timestamp: new Date().toISOString(),
+        amount: order.amountPerOrder,
+        status: 'simulated', // Change to 'executed' when wired
+      });
+
+      if (order.executedOrders >= order.totalOrders) {
+        order.status = 'completed';
+      } else {
+        order.nextExecution = new Date(Date.now() + order.interval * 1000).toISOString();
+      }
+
+      spin.succeed(`DCA ${order.executedOrders}/${order.totalOrders}: ${order.amountPerOrder} ${order.tokenIn} → ${order.tokenOut}`);
+    } catch (err) {
+      spin.fail(`DCA failed: ${err.message}`);
+      order.history.push({
+        timestamp: new Date().toISOString(),
+        amount: order.amountPerOrder,
+        status: 'failed',
+        error: err.message,
+      });
+    }
+  }
+
+  saveOrders(orders);
+  success('DCA execution complete');
+}
+
+function formatInterval(seconds) {
+  if (seconds < 3600) return `${seconds / 60}m`;
+  if (seconds < 86400) return `${seconds / 3600}h`;
+  return `${seconds / 86400}d`;
+}

package/src/trading/index.js

@@ -0,0 +1,3 @@
+export { executeSwap, resolveToken, getTokenInfo } from './swap.js';
+export { snipeToken, watchSnipe } from './snipe.js';
+export { createDCA, listDCA, cancelDCA, runDCA } from './dca.js';

package/src/trading/snipe.js

@@ -0,0 +1,195 @@
+import { ethers } from 'ethers';
+import { getSigner } from '../wallet/manager.js';
+import { getConfig, getRPC } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, success, error, warn } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+import { resolveToken, getTokenInfo } from './swap.js';
+import inquirer from 'inquirer';
+
+// Uniswap V2 Factory ABI (for pair creation events)
+const FACTORY_ABI = [
+  'event PairCreated(address indexed token0, address indexed token1, address pair, uint)',
+];
+
+// Uniswap V2 Router ABI
+const ROUTER_V2_ABI = [
+  'function swapExactETHForTokens(uint amountOutMin, address[] path, address to, uint deadline) payable returns (uint[] amounts)',
+  'function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] path, address to, uint deadline) returns (uint[] amounts)',
+  'function getAmountsOut(uint amountIn, address[] path) view returns (uint[] amounts)',
+];
+
+const V2_ROUTERS = {
+  base: '0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24', // Uniswap V2 on Base
+  ethereum: '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D',
+};
+
+const WETH = {
+  base: '0x4200000000000000000000000000000000000006',
+  ethereum: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+};
+
+// Snipe a token — buy immediately with ETH
+export async function snipeToken(tokenAddress, amount, opts = {}) {
+  const chain = getConfig('chain') || 'base';
+  const maxSlippage = opts.slippage || getConfig('slippage') || 1.0;
+  const gasMultiplier = opts.gas || getConfig('gasMultiplier') || 1.5;
+
+  if (!tokenAddress || !tokenAddress.startsWith('0x')) {
+    error('Provide a valid token contract address');
+    return;
+  }
+
+  if (!amount || parseFloat(amount) <= 0) {
+    error('Provide an ETH amount to spend');
+    return;
+  }
+
+  // Get password
+  const { password } = await inquirer.prompt([{
+    type: 'password',
+    name: 'password',
+    message: theme.gold('Wallet password:'),
+    mask: '●',
+  }]);
+
+  const spin = spinner('Preparing snipe...').start();
+
+  try {
+    const { signer, provider, address } = await getSigner(opts.wallet, password);
+
+    const routerAddr = V2_ROUTERS[chain];
+    if (!routerAddr) {
+      spin.fail('No V2 router for this chain');
+      return;
+    }
+
+    const wethAddr = WETH[chain];
+    const router = new ethers.Contract(routerAddr, ROUTER_V2_ABI, signer);
+    const amountIn = ethers.parseEther(amount.toString());
+
+    // Check ETH balance
+    const balance = await provider.getBalance(address);
+    if (balance < amountIn) {
+      spin.fail('Insufficient ETH');
+      error(`Need ${amount} ETH, have ${ethers.formatEther(balance)}`);
+      return;
+    }
+
+    // Get token info
+    let tokenInfo;
+    try {
+      tokenInfo = await getTokenInfo(tokenAddress, provider);
+    } catch {
+      tokenInfo = { symbol: 'UNKNOWN', name: 'Unknown Token', decimals: 18 };
+    }
+
+    // Get estimated output
+    let estimatedOut;
+    try {
+      const amounts = await router.getAmountsOut(amountIn, [wethAddr, tokenAddress]);
+      estimatedOut = amounts[1];
+    } catch {
+      estimatedOut = null;
+    }
+
+    spin.succeed('Snipe ready');
+
+    showSection('SNIPE PREVIEW');
+    kvDisplay([
+      ['Token', `${tokenInfo.symbol} (${tokenInfo.name})`],
+      ['Contract', tokenAddress],
+      ['Spend', `${amount} ETH`],
+      ['Est. Output', estimatedOut ? ethers.formatUnits(estimatedOut, tokenInfo.decimals) + ' ' + tokenInfo.symbol : 'Unable to estimate'],
+      ['Slippage', `${maxSlippage}%`],
+      ['Gas Boost', `${gasMultiplier}x`],
+      ['Chain', chain],
+    ]);
+    console.log('');
+
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: theme.accent('Execute snipe? This is HIGH RISK.'),
+      default: false,
+    }]);
+
+    if (!confirm) {
+      warn('Snipe cancelled');
+      return;
+    }
+
+    const snipeSpin = spinner('Executing snipe...').start();
+
+    const deadline = Math.floor(Date.now() / 1000) + 120; // 2 min tight deadline
+    const minOut = estimatedOut
+      ? (estimatedOut * BigInt(Math.floor((100 - maxSlippage) * 100))) / 10000n
+      : 0n;
+
+    // Boost gas for priority
+    const feeData = await provider.getFeeData();
+    const maxFeePerGas = feeData.maxFeePerGas
+      ? (feeData.maxFeePerGas * BigInt(Math.floor(gasMultiplier * 100))) / 100n
+      : undefined;
+    const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas
+      ? (feeData.maxPriorityFeePerGas * BigInt(Math.floor(gasMultiplier * 100))) / 100n
+      : undefined;
+
+    const tx = await router.swapExactETHForTokens(
+      minOut,
+      [wethAddr, tokenAddress],
+      address,
+      deadline,
+      {
+        value: amountIn,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+      }
+    );
+
+    snipeSpin.text = 'Waiting for confirmation...';
+    const receipt = await tx.wait();
+
+    snipeSpin.succeed(theme.success('Snipe executed!'));
+
+    console.log('');
+    showSection('SNIPE RESULT');
+    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('');
+    warn('Check your token balance with: darksol wallet balance');
+
+  } catch (err) {
+    spin.fail('Snipe failed');
+    error(err.message);
+  }
+}
+
+// Watch for new pairs and auto-snipe (monitor mode)
+export async function watchSnipe(opts = {}) {
+  const chain = getConfig('chain') || 'base';
+  const rpc = getRPC(chain);
+
+  showSection('SNIPE WATCHER');
+  console.log(theme.accent('  ⚡ Monitoring for new token pairs...'));
+  console.log(theme.dim(`  Chain: ${chain} | RPC: ${rpc}`));
+  console.log(theme.dim('  Press Ctrl+C to stop'));
+  console.log('');
+
+  const provider = new ethers.WebSocketProvider(
+    rpc.replace('https://', 'wss://').replace('http://', 'ws://')
+  );
+
+  // Listen for pending transactions to the factory
+  // This is a simplified version — production would use mempool monitoring
+  console.log(theme.warning('  ⚠ Watch mode is experimental. Use at your own risk.'));
+  console.log(theme.dim('  Auto-snipe requires --auto flag and pre-set amount'));
+
+  provider.on('block', (blockNumber) => {
+    process.stdout.write(theme.dim(`  Block: ${blockNumber}\r`));
+  });
+}

package/src/trading/swap.js

@@ -0,0 +1,233 @@
+import { ethers } from 'ethers';
+import { getSigner } from '../wallet/manager.js';
+import { getConfig, getRPC } from '../config/store.js';
+import { theme } from '../ui/theme.js';
+import { spinner, kvDisplay, success, error, warn, formatAddress } from '../ui/components.js';
+import { showSection } from '../ui/banner.js';
+import inquirer from 'inquirer';
+
+// Known DEX router addresses
+const ROUTERS = {
+  base: {
+    uniswapV3: '0x2626664c2603336E57B271c5C0b26F421741e481',
+    aerodrome: '0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43',
+  },
+  ethereum: {
+    uniswapV3: '0xE592427A0AEce92De3Edee1F18E0157C05861564',
+  },
+  arbitrum: {
+    uniswapV3: '0xE592427A0AEce92De3Edee1F18E0157C05861564',
+  },
+};
+
+// Common token addresses per chain
+const TOKENS = {
+  base: {
+    ETH: ethers.ZeroAddress,
+    WETH: '0x4200000000000000000000000000000000000006',
+    USDC: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+    USDbC: '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA',
+    DAI: '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb',
+    AERO: '0x940181a94A35A4569E4529A3CDfB74e38FD98631',
+    VIRTUAL: '0x0b3e328455c4059EEb9e3f84b5543F74E24e7E1b',
+  },
+  ethereum: {
+    ETH: ethers.ZeroAddress,
+    WETH: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+    USDC: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    USDT: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+    DAI: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
+  },
+};
+
+// ERC20 ABI for approvals and balance checks
+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)',
+  'function name() view returns (string)',
+];
+
+// Uniswap V3 SwapRouter ABI (exactInputSingle)
+const SWAP_ROUTER_ABI = [
+  'function exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96)) external payable returns (uint256 amountOut)',
+  'function multicall(uint256 deadline, bytes[] data) external payable returns (bytes[])',
+];
+
+// Resolve token symbol to address
+export function resolveToken(symbol, chain) {
+  const upper = symbol.toUpperCase();
+  const chainTokens = TOKENS[chain] || TOKENS.base;
+  if (chainTokens[upper]) return chainTokens[upper];
+  // If it looks like an address, use it directly
+  if (symbol.startsWith('0x') && symbol.length === 42) return symbol;
+  return null;
+}
+
+// Get token info
+export async function getTokenInfo(address, provider) {
+  if (address === ethers.ZeroAddress) {
+    return { symbol: 'ETH', name: 'Ether', decimals: 18, address };
+  }
+  const contract = new ethers.Contract(address, ERC20_ABI, provider);
+  const [symbol, name, decimals] = await Promise.all([
+    contract.symbol(),
+    contract.name(),
+    contract.decimals(),
+  ]);
+  return { symbol, name, decimals: Number(decimals), address };
+}
+
+// Execute a swap via Uniswap V3
+export async function executeSwap(opts = {}) {
+  const {
+    tokenIn: tokenInSymbol,
+    tokenOut: tokenOutSymbol,
+    amount,
+    wallet: walletName,
+    slippage,
+  } = opts;
+
+  const chain = getConfig('chain') || 'base';
+  const maxSlippage = slippage || getConfig('slippage') || 0.5;
+
+  // Resolve tokens
+  const tokenInAddr = resolveToken(tokenInSymbol, chain);
+  const tokenOutAddr = resolveToken(tokenOutSymbol, chain);
+
+  if (!tokenInAddr) {
+    error(`Unknown token: ${tokenInSymbol}. Use symbol (ETH, USDC) or contract address.`);
+    return;
+  }
+  if (!tokenOutAddr) {
+    error(`Unknown token: ${tokenOutSymbol}. Use symbol (ETH, USDC) or contract address.`);
+    return;
+  }
+
+  // Get password for wallet
+  const { password } = await inquirer.prompt([{
+    type: 'password',
+    name: 'password',
+    message: theme.gold('Wallet password:'),
+    mask: '●',
+  }]);
+
+  const spin = spinner('Preparing swap...').start();
+
+  try {
+    const { signer, provider, address } = await getSigner(walletName, password);
+    const router = ROUTERS[chain]?.uniswapV3;
+    if (!router) {
+      spin.fail('No router available');
+      error(`No DEX router configured for ${chain}`);
+      return;
+    }
+
+    // Get token info
+    const isNativeIn = tokenInAddr === ethers.ZeroAddress;
+    const actualTokenIn = isNativeIn ? TOKENS[chain]?.WETH : tokenInAddr;
+    const tokenOutInfo = await getTokenInfo(tokenOutAddr === ethers.ZeroAddress ? TOKENS[chain]?.WETH : tokenOutAddr, provider);
+    const tokenInInfo = await getTokenInfo(actualTokenIn, provider);
+
+    const amountIn = ethers.parseUnits(amount.toString(), isNativeIn ? 18 : tokenInInfo.decimals);
+
+    // Check balance
+    if (isNativeIn) {
+      const balance = await provider.getBalance(address);
+      if (balance < amountIn) {
+        spin.fail('Insufficient balance');
+        error(`Need ${amount} ETH, have ${ethers.formatEther(balance)}`);
+        return;
+      }
+    } else {
+      const token = new ethers.Contract(actualTokenIn, ERC20_ABI, signer);
+      const balance = await token.balanceOf(address);
+      if (balance < amountIn) {
+        spin.fail('Insufficient balance');
+        error(`Need ${amount} ${tokenInInfo.symbol}, have ${ethers.formatUnits(balance, tokenInInfo.decimals)}`);
+        return;
+      }
+    }
+
+    spin.text = 'Swap details ready';
+    spin.succeed();
+
+    // Show swap details
+    showSection('SWAP PREVIEW');
+    kvDisplay([
+      ['From', `${amount} ${isNativeIn ? 'ETH' : tokenInInfo.symbol}`],
+      ['To', tokenOutInfo.symbol],
+      ['Router', formatAddress(router)],
+      ['Chain', chain],
+      ['Slippage', `${maxSlippage}%`],
+    ]);
+    console.log('');
+
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: theme.gold('Execute swap?'),
+      default: false,
+    }]);
+
+    if (!confirm) {
+      warn('Swap cancelled');
+      return;
+    }
+
+    const swapSpin = spinner('Executing swap...').start();
+
+    // Approve if needed (non-native)
+    if (!isNativeIn) {
+      const token = new ethers.Contract(actualTokenIn, ERC20_ABI, signer);
+      const allowance = await token.allowance(address, router);
+      if (allowance < amountIn) {
+        swapSpin.text = 'Approving token...';
+        const approveTx = await token.approve(router, ethers.MaxUint256);
+        await approveTx.wait();
+      }
+    }
+
+    // Execute swap
+    swapSpin.text = 'Sending swap transaction...';
+    const swapRouter = new ethers.Contract(router, SWAP_ROUTER_ABI, signer);
+
+    const deadline = Math.floor(Date.now() / 1000) + 300; // 5 min
+    const amountOutMin = 0; // TODO: get quote for proper slippage protection
+
+    const swapParams = {
+      tokenIn: actualTokenIn,
+      tokenOut: tokenOutAddr === ethers.ZeroAddress ? TOKENS[chain]?.WETH : tokenOutAddr,
+      fee: 3000, // 0.3% fee tier
+      recipient: address,
+      deadline,
+      amountIn,
+      amountOutMinimum: amountOutMin,
+      sqrtPriceLimitX96: 0,
+    };
+
+    const txOpts = isNativeIn ? { value: amountIn } : {};
+    const tx = await swapRouter.exactInputSingle(swapParams, txOpts);
+
+    swapSpin.text = 'Waiting for confirmation...';
+    const receipt = await tx.wait();
+
+    swapSpin.succeed(theme.success('Swap executed'));
+
+    console.log('');
+    showSection('SWAP RESULT');
+    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('Swap failed');
+    error(err.message);
+  }
+}