I Built a Stablecoin Arbitrage Scanner and Found $50K in Daily Opportunities

// My WebSocket manager that saved the entire project
class ExchangeStreamManager {
  constructor(exchanges) {
    this.exchanges = exchanges;
    this.connections = new Map();
    this.priceData = new Map();
    // Learned this the hard way: always include reconnection logic
    this.reconnectAttempts = new Map();
  }

  async initializeStreams(pairs) {
    for (const exchange of this.exchanges) {
      try {
        const ws = await this.createWebSocketConnection(exchange, pairs);
        this.connections.set(exchange, ws);
        
        // This error handling prevented 90% of my production issues
        ws.on('error', (error) => {
          console.error(`${exchange} connection error:`, error);
          this.handleReconnection(exchange, pairs);
        });
        
      } catch (error) {
        console.error(`Failed to connect to ${exchange}:`, error);
      }
    }
  }

  // The heartbeat that keeps everything running
  handleReconnection(exchange, pairs) {
    const attempts = this.reconnectAttempts.get(exchange) || 0;
    if (attempts < 5) {
      setTimeout(() => {
        this.initializeStreams([exchange]);
        this.reconnectAttempts.set(exchange, attempts + 1);
      }, Math.pow(2, attempts) * 1000); // Exponential backoff
    }
  }
}

class ArbitrageDetector {
  constructor(minProfitThreshold = 0.05) {
    this.minProfitThreshold = minProfitThreshold; // 0.05% minimum
    this.exchangeFees = {
      'binance': { maker: 0.1, taker: 0.1 },
      'coinbase': { maker: 0.5, taker: 0.5 },
      'kraken': { maker: 0.16, taker: 0.26 }
    };
  }

  detectOpportunities(priceData) {
    const opportunities = [];
    const pairs = Object.keys(priceData);
    
    for (const pair of pairs) {
      const prices = priceData[pair];
      const exchanges = Object.keys(prices);
      
      // Find highest and lowest prices
      let maxPrice = { exchange: '', price: 0 };
      let minPrice = { exchange: '', price: Infinity };
      
      for (const exchange of exchanges) {
        if (prices[exchange] > maxPrice.price) {
          maxPrice = { exchange, price: prices[exchange] };
        }
        if (prices[exchange] < minPrice.price) {
          minPrice = { exchange, price: prices[exchange] };
        }
      }
      
      // Calculate net profit after fees
      const opportunity = this.calculateNetProfit(minPrice, maxPrice, pair);
      
      if (opportunity.profitPercent >= this.minProfitThreshold) {
        opportunities.push(opportunity);
      }
    }
    
    return opportunities.sort((a, b) => b.profitPercent - a.profitPercent);
  }

  calculateNetProfit(buyExchange, sellExchange, pair) {
    const buyFee = this.exchangeFees[buyExchange.exchange].taker / 100;
    const sellFee = this.exchangeFees[sellExchange.exchange].taker / 100;
    
    const buyPrice = buyExchange.price * (1 + buyFee);
    const sellPrice = sellExchange.price * (1 - sellFee);
    
    const profitPercent = ((sellPrice - buyPrice) / buyPrice) * 100;
    
    return {
      pair,
      buyExchange: buyExchange.exchange,
      sellExchange: sellExchange.exchange,
      buyPrice,
      sellPrice,
      profitPercent,
      timestamp: Date.now()
    };
  }
}

class AlertManager {
  constructor() {
    this.slackWebhook = process.env.SLACK_WEBHOOK;
    this.twilioClient = new Twilio(process.env.TWILIO_SID, process.env.TWILIO_TOKEN);
    this.alertHistory = new Map();
  }

  async processOpportunity(opportunity) {
    const alertKey = `${opportunity.pair}-${opportunity.buyExchange}-${opportunity.sellExchange}`;
    
    // Prevent spam by tracking recent alerts
    if (this.wasRecentlyAlerted(alertKey)) {
      return;
    }
    
    if (opportunity.profitPercent >= 0.2) {
      await this.sendUrgentAlert(opportunity);
    } else if (opportunity.profitPercent >= 0.08) {
      await this.sendSlackAlert(opportunity);
    }
    
    // Always log to database for analysis
    await this.logOpportunity(opportunity);
    this.alertHistory.set(alertKey, Date.now());
  }

  async sendUrgentAlert(opportunity) {
    const message = `🚨 HIGH PROFIT ARBITRAGE DETECTED 🚨
    Pair: ${opportunity.pair}
    Buy: ${opportunity.buyExchange} @ $${opportunity.buyPrice.toFixed(4)}
    Sell: ${opportunity.sellExchange} @ $${opportunity.sellPrice.toFixed(4)}
    Profit: ${opportunity.profitPercent.toFixed(3)}%
    
    Time to act: <5 minutes`;
    
    // This SMS saved me from missing a 0.34% USDC opportunity
    await this.twilioClient.messages.create({
      body: message,
      from: process.env.TWILIO_PHONE,
      to: process.env.MY_PHONE
    });
  }
}

// InfluxDB setup for price tracking
const influx = new InfluxDB.InfluxDB({
  url: process.env.INFLUXDB_URL,
  token: process.env.INFLUXDB_TOKEN,
  org: 'arbitrage-scanner'
});

class DataLogger {
  async logPriceUpdate(exchange, pair, price, volume) {
    const point = new Point('price_data')
      .tag('exchange', exchange)
      .tag('pair', pair)
      .floatField('price', price)
      .floatField('volume', volume)
      .timestamp(new Date());
    
    await influx.writeApi.writePoint(point);
  }

  // This query helped me identify the best trading windows
  async getAverageSpreadsByHour(pair, days = 7) {
    const query = `
      from(bucket: "arbitrage")
        |> range(start: -${days}d)
        |> filter(fn: (r) => r._measurement == "opportunities")
        |> filter(fn: (r) => r.pair == "${pair}")
        |> aggregateWindow(every: 1h, fn: mean)
        |> group(columns: ["_time"])
    `;
    
    return await influx.queryApi.queryRows(query);
  }
}

// Parallel opportunity detection
class OptimizedScanner {
  constructor() {
    this.workerPool = new Pool({
      create: () => new Worker('./opportunity-worker.js'),
      destroy: (worker) => worker.terminate(),
      max: 4,
      min: 2
    });
  }

  async processMarketData(data) {
    const chunks = this.chunkMarketData(data, 4);
    
    // Process chunks in parallel instead of sequentially
    const results = await Promise.all(
      chunks.map(chunk => this.workerPool.use(worker => 
        worker.postMessage({ type: 'ANALYZE_CHUNK', data: chunk })
      ))
    );
    
    return results.flat().filter(opportunity => 
      opportunity.profitPercent >= this.minThreshold
    );
  }
}

class RiskManager {
  calculateMaxPosition(opportunity, accountBalance) {
    // Never risk more than 5% of total capital per trade
    const maxRiskAmount = accountBalance * 0.05;
    
    // Consider order book depth to avoid slippage
    const liquidityLimit = this.estimateMaxTradeSize(opportunity);
    
    // Factor in exchange withdrawal limits
    const withdrawalLimit = this.getWithdrawalLimit(opportunity.sellExchange);
    
    return Math.min(maxRiskAmount, liquidityLimit, withdrawalLimit);
  }
  
  // This saved me from a costly mistake with low-liquidity pairs
  estimateMaxTradeSize(opportunity) {
    const buyOrderBook = this.getOrderBook(opportunity.buyExchange, opportunity.pair);
    const sellOrderBook = this.getOrderBook(opportunity.sellExchange, opportunity.pair);
    
    // Calculate how much we can trade before slippage kills profitability
    const maxBuySize = this.calculateSlippageLimit(buyOrderBook, opportunity.buyPrice, 0.02);
    const maxSellSize = this.calculateSlippageLimit(sellOrderBook, opportunity.sellPrice, 0.02);
    
    return Math.min(maxBuySize, maxSellSize);
  }
}