How I Built a Cross-DEX Stablecoin Arbitrage Bot That Earned $2,400 in Two Weeks

// My first terrible implementation - don't do this
async function naiveArbitrage() {
  const uniswapPrice = await getUniswapPrice('USDC', 'USDT');
  const sushiswapPrice = await getSushiswapPrice('USDC', 'USDT');
  
  if (uniswapPrice > sushiswapPrice * 1.002) { // 0.2% threshold
    // This approach failed spectacularly
    await buyOnSushiswap(1000); // $47 gas fee
    await sellOnUniswap(1000);   // $52 gas fee
    // Result: -$35 after gas costs
  }
}

import axios from 'axios';
import { ethers } from 'ethers';

class CrossDEXArbitrage {
  constructor(privateKey, rpcUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(rpcUrl);
    this.wallet = new ethers.Wallet(privateKey, this.provider);
    this.MIN_PROFIT_USD = 25; // Learned this threshold the expensive way
    this.MAX_TRADE_SIZE = 5000; // Risk management from losing $800
  }

  async findArbitrageOpportunity(tokenA, tokenB, amount) {
    try {
      // Get quotes from 0x for both directions
      const quoteAtoB = await this.get0xQuote(tokenA, tokenB, amount);
      const quoteBtoA = await this.get0xQuote(tokenB, tokenA, quoteAtoB.buyAmount);
      
      // Calculate potential profit accounting for gas
      const estimatedGas = await this.estimateGasCosts([quoteAtoB, quoteBtoA]);
      const potentialProfit = this.calculateProfit(amount, quoteBtoA.buyAmount, estimatedGas);
      
      if (potentialProfit > this.MIN_PROFIT_USD) {
        return {
          profitable: true,
          profit: potentialProfit,
          trades: [quoteAtoB, quoteBtoA],
          gasEstimate: estimatedGas
        };
      }
      
      return { profitable: false };
    } catch (error) {
      console.log(`Quote failed: ${error.message}`);
      return { profitable: false };
    }
  }
}

async get0xQuote(sellToken, buyToken, sellAmount) {
  const params = {
    sellToken,
    buyToken,
    sellAmount,
    slippagePercentage: 0.01, // 1% max slippage
    gasPrice: await this.getOptimalGasPrice(), // Dynamic gas pricing
    excludedSources: 'Bancor,mStable', // Exclude slow/expensive sources
    enableSlippageProtection: true,
    skipValidation: false // Critical for production safety
  };
  
  const response = await axios.get('https://api.0x.org/swap/v1/quote', { params });
  
  // This one line replaced 200 lines of my manual DEX integration
  return response.data;
}

async getOptimalGasPrice() {
  // I check gas prices every 30 seconds during active trading
  const gasStation = await axios.get('https://ethgasstation.info/api/ethgasAPI.json');
  const networkGasPrice = await this.provider.getGasPrice();
  
  // Use the lower of network price or gas station fast price
  const optimalPrice = Math.min(
    networkGasPrice,
    ethers.utils.parseUnits((gasStation.data.fast / 10).toString(), 'gwei')
  );
  
  // Never pay more than 150 gwei - learned this after $200 gas fee disasters
  return Math.min(optimalPrice, ethers.utils.parseUnits('150', 'gwei'));
}

async estimateGasCosts(quotes) {
  // Estimate gas for both trades plus some buffer
  const gas1 = parseInt(quotes[0].gas) * 1.2; // 20% buffer from experience
  const gas2 = parseInt(quotes[1].gas) * 1.2;
  const gasPrice = await this.getOptimalGasPrice();
  
  return (gas1 + gas2) * gasPrice;
}

async executeArbitrage(opportunity) {
  console.log(`Executing arbitrage with ${opportunity.profit}% profit potential`);
  
  try {
    // Use 0x's transaction data for atomic execution
    const tx1 = await this.wallet.sendTransaction({
      to: opportunity.trades[0].to,
      data: opportunity.trades[0].data,
      value: opportunity.trades[0].value,
      gasLimit: Math.floor(opportunity.trades[0].gas * 1.3), // Learned to add buffer
      gasPrice: await this.getOptimalGasPrice()
    });
    
    console.log(`First trade submitted: ${tx1.hash}`);
    await tx1.wait(1); // Wait for confirmation
    
    // Only proceed with second trade after first confirms
    const tx2 = await this.wallet.sendTransaction({
      to: opportunity.trades[1].to,
      data: opportunity.trades[1].data,
      value: opportunity.trades[1].value,
      gasLimit: Math.floor(opportunity.trades[1].gas * 1.3),
      gasPrice: await this.getOptimalGasPrice()
    });
    
    console.log(`Arbitrage completed! Profit: $${opportunity.profit}`);
    return { success: true, profit: opportunity.profit };
    
  } catch (error) {
    console.error(`Arbitrage failed: ${error.message}`);
    // Add failed trade to blacklist for 5 minutes
    this.blacklistPair(opportunity.pair, 300000);
    return { success: false, error: error.message };
  }
}

class RiskManager {
  constructor() {
    this.maxDailyLoss = 200;    // Stop trading if down $200 in a day
    this.maxTradeSize = 5000;   // Never risk more than $5k per trade
    this.maxConcurrentTrades = 2; // Limit simultaneous positions
    this.dailyLossTracker = 0;
  }
  
  canExecuteTrade(amount, estimatedProfit) {
    // Don't trade if we've hit daily loss limit
    if (this.dailyLossTracker >= this.maxDailyLoss) {
      console.log('Daily loss limit reached, stopping trading');
      return false;
    }
    
    // Don't trade if amount exceeds our max trade size
    if (amount > this.maxTradeSize) {
      console.log(`Trade size ${amount} exceeds max ${this.maxTradeSize}`);
      return false;
    }
    
    // Require minimum profit to cover potential losses
    if (estimatedProfit < 25) {
      console.log('Profit too small to justify risk');
      return false;
    }
    
    return true;
  }
}

async handleTransactionFailure(trade, error) {
  // Log the failure with full context
  console.error(`Trade failed: ${error.message}`, {
    pair: trade.pair,
    amount: trade.amount,
    gasPrice: trade.gasPrice,
    slippage: trade.slippage,
    timestamp: new Date().toISOString()
  });
  
  // Classify the error type for appropriate response
  if (error.message.includes('INSUFFICIENT_OUTPUT_AMOUNT')) {
    // Price moved against us - increase slippage tolerance
    this.adjustSlippageTolerance(trade.pair, 0.002); // Add 0.2%
  } else if (error.message.includes('replacement transaction underpriced')) {
    // Transaction stuck - increase gas price
    this.increaseGasPrice(trade.gasPrice, 1.1);
  } else if (error.message.includes('nonce too low')) {
    // Nonce issue - reset and retry
    await this.resetNonce();
  }
  
  // Add to failure tracking for pattern analysis
  this.trackFailure(trade, error);
}

class PriceMonitor {
  constructor(arbitrage) {
    this.arbitrage = arbitrage;
    this.monitoredPairs = [
      { tokenA: 'USDC', tokenB: 'USDT' },
      { tokenA: 'DAI', tokenB: 'USDC' },
      { tokenA: 'USDT', tokenB: 'DAI' }
    ];
    this.isMonitoring = false;
  }
  
  async startMonitoring() {
    this.isMonitoring = true;
    console.log('Starting price monitoring...');
    
    while (this.isMonitoring) {
      try {
        // Check all pairs simultaneously
        const opportunities = await Promise.all(
          this.monitoredPairs.map(pair => 
            this.arbitrage.findArbitrageOpportunity(
              pair.tokenA, 
              pair.tokenB, 
              ethers.utils.parseUnits('1000', 6) // $1000 test amount
            )
          )
        );
        
        // Execute profitable opportunities immediately
        for (const opp of opportunities) {
          if (opp.profitable && this.riskManager.canExecuteTrade(1000, opp.profit)) {
            // Fire and forget - don't wait for completion
            this.arbitrage.executeArbitrage(opp)
              .catch(error => console.error('Execution failed:', error));
          }
        }
        
        // Wait 3 seconds before next check (optimal frequency from testing)
        await this.sleep(3000);
        
      } catch (error) {
        console.error('Monitoring error:', error);
        await this.sleep(5000); // Longer wait on errors
      }
    }
  }
}

// Optimized trade history query
async getTradePerformance(timeframe = '7d') {
  const query = `
    SELECT 
      pair,
      COUNT(*) as total_trades,
      AVG(profit_usd) as avg_profit,
      SUM(profit_usd) as total_profit,
      AVG(gas_cost_usd) as avg_gas_cost,
      (COUNT(CASE WHEN profit_usd > 0 THEN 1 END) * 100.0 / COUNT(*)) as success_rate
    FROM arbitrage_trades 
    WHERE created_at > NOW() - INTERVAL '${timeframe}'
    GROUP BY pair
    ORDER BY total_profit DESC
  `;
  
  return await this.db.query(query);
}

// Clean up old price data every hour
setInterval(() => {
  this.priceHistory = this.priceHistory.filter(
    price => Date.now() - price.timestamp < 3600000 // Keep 1 hour
  );
  
  // Force garbage collection if available
  if (global.gc) global.gc();
}, 3600000);

// Preparing for multi-chain deployment
class MultiChainArbitrage {
  constructor() {
    this.chains = {
      ethereum: new CrossDEXArbitrage(process.env.ETH_PRIVATE_KEY, process.env.ETH_RPC),
      polygon: new CrossDEXArbitrage(process.env.POLYGON_PRIVATE_KEY, process.env.POLYGON_RPC),
      arbitrum: new CrossDEXArbitrage(process.env.ARB_PRIVATE_KEY, process.env.ARB_RPC)
    };
  }
  
  async findCrossChainOpportunities() {
    // Check for arbitrage opportunities across different chains
    // This is my next major development milestone
  }
}