How I Built a Real-Time Stablecoin Liquidation Tracker After Missing $2M in Risk Events

// This approach nearly crashed our infrastructure
// Don't do this - I learned the hard way
setInterval(async () => {
  try {
    const aaveLiquidations = await fetchAaveLiquidations();
    const compoundLiquidations = await fetchCompoundLiquidations();
    const makerLiquidations = await fetchMakerLiquidations();
    // ... checking 15+ protocols
  } catch (error) {
    console.log('Another API timeout...');
  }
}, 30000);

// This real-time approach changed everything
const web3 = new Web3(new Web3.providers.WebsocketProvider(WS_PROVIDER));

// Listen for liquidation events across all monitored protocols
const liquidationFilter = {
  address: PROTOCOL_ADDRESSES,
  topics: [LIQUIDATION_EVENT_SIGNATURES]
};

web3.eth.subscribe('logs', liquidationFilter, (error, result) => {
  if (error) {
    console.error('WebSocket error:', error);
    return;
  }
  
  // Process liquidation event immediately
  processLiquidationEvent(result);
});

class LiquidationTracker {
  constructor() {
    this.protocols = {
      aave: new AaveMonitor(),
      compound: new CompoundMonitor(), 
      maker: new MakerMonitor(),
      // Added 12 more protocols after initial success
    };
    
    this.riskCalculator = new RiskCalculator();
    this.alertSystem = new AlertSystem();
  }

  async startMonitoring() {
    // Learned to add redundancy after WebSocket failures
    for (const [name, monitor] of Object.entries(this.protocols)) {
      monitor.on('liquidation', this.handleLiquidation.bind(this));
      monitor.on('error', this.handleProtocolError.bind(this, name));
      
      await monitor.start();
      console.log(`✓ ${name} monitor started`);
    }
  }

  async handleLiquidation(event) {
    try {
      // This risk calculation saved us from 3 major losses
      const riskMetrics = await this.riskCalculator.analyze(event);
      
      if (riskMetrics.severity >= CRITICAL_THRESHOLD) {
        await this.alertSystem.sendCriticalAlert(event, riskMetrics);
      }
      
      // Store for trend analysis - this pattern recognition 
      // identified the Terra collapse 2 days early
      await this.storeEvent(event, riskMetrics);
      
    } catch (error) {
      // Silent failures were killing us - learned to log everything
      console.error('Failed to process liquidation:', error);
      await this.alertSystem.sendErrorAlert(error);
    }
  }
}

class RiskCalculator {
  async analyze(liquidationEvent) {
    const metrics = {
      // Size of liquidation relative to protocol TVL
      relativeSize: liquidationEvent.amount / await this.getProtocolTVL(liquidationEvent.protocol),
      
      // Profit margin for liquidators (indicates market stress)
      liquidationPremium: this.calculateLiquidationPremium(liquidationEvent),
      
      // Cascading risk - other positions at risk
      cascadingRisk: await this.analyzeCascadingRisk(liquidationEvent),
      
      // Market impact score
      marketImpact: this.calculateMarketImpact(liquidationEvent)
    };

    // This scoring system caught the FTX contagion early
    metrics.severity = this.calculateSeverityScore(metrics);
    
    return metrics;
  }

  calculateLiquidationPremium(event) {
    // Higher premiums indicate market stress
    // During Terra collapse, premiums spiked to 15%+ vs normal 2-3%
    const marketPrice = event.marketPrice;
    const liquidationPrice = event.liquidationPrice;
    
    return (liquidationPrice - marketPrice) / marketPrice;
  }
}

class AlertSystem {
  constructor() {
    this.channels = {
      critical: new SlackWebhook(process.env.CRITICAL_WEBHOOK),
      warning: new DiscordWebhook(process.env.WARNING_WEBHOOK),
      info: new EmailNotifier(process.env.TEAM_EMAIL)
    };
  }

  async sendCriticalAlert(event, metrics) {
    // This alert format saved us during the SVB banking crisis
    const alert = {
      title: `🚨 CRITICAL LIQUIDATION DETECTED`,
      protocol: event.protocol,
      amount: `$${(event.amount / 1e6).toFixed(2)}M`,
      asset: event.collateralAsset,
      severity: metrics.severity,
      cascadingRisk: metrics.cascadingRisk,
      // Added this after missing connection to broader market events
      marketContext: await this.getMarketContext(event.timestamp)
    };

    // Fire to all channels for critical events
    await Promise.all([
      this.channels.critical.send(alert),
      this.channels.warning.send(alert),
      this.sendPushNotification(alert) // Wake up the team at 3 AM if needed
    ]);
  }
}

// Aave V2 vs V3 have different liquidation mechanics
class AaveMonitor extends ProtocolMonitor {
  parseEvent(rawEvent) {
    if (this.version === 'v2') {
      // V2 includes liquidation bonus in event data
      return {
        collateralAmount: rawEvent.liquidatedCollateralAmount,
        debtAmount: rawEvent.debtToCover,
        bonus: rawEvent.liquidationBonus
      };
    } else {
      // V3 requires separate calculation - missed this for 2 weeks
      const bonus = await this.calculateV3Bonus(rawEvent);
      return {
        collateralAmount: rawEvent.liquidatedCollateralAmount,
        debtAmount: rawEvent.debtToCover,
        bonus: bonus
      };
    }
  }
}

// Compound liquidations can be partial - this was a major blind spot
class CompoundMonitor extends ProtocolMonitor {
  async enrichLiquidationData(event) {
    // Check if this was a full or partial liquidation
    const borrowerAccount = await this.compound.getAccount(event.borrower);
    const remainingDebt = borrowerAccount.totalBorrowValueInEth;
    
    // Partial liquidations often indicate more liquidations coming
    if (remainingDebt > 0) {
      event.isPartial = true;
      event.estimatedTimeToNextLiquidation = this.predictNextLiquidation(borrowerAccount);
    }
    
    return event;
  }
}

class RobustWebSocketManager {
  constructor() {
    this.providers = [
      'wss://mainnet.infura.io/ws/v3/YOUR_KEY',
      'wss://eth-mainnet.alchemyapi.io/v2/YOUR_KEY',
      'wss://mainnet.gateway.tenderly.co/YOUR_KEY'
    ];
    this.currentProviderIndex = 0;
    this.reconnectAttempts = 0;
  }

  async connect() {
    try {
      const provider = this.providers[this.currentProviderIndex];
      this.web3 = new Web3(new Web3.providers.WebsocketProvider(provider));
      
      // This heartbeat saved us during the Merge network issues
      this.heartbeat = setInterval(() => {
        this.web3.eth.getBlockNumber().catch(() => this.handleConnectionLoss());
      }, 30000);
      
    } catch (error) {
      await this.switchProvider();
    }
  }

  async switchProvider() {
    this.currentProviderIndex = (this.currentProviderIndex + 1) % this.providers.length;
    console.log(`Switching to provider ${this.currentProviderIndex}`);
    await this.connect();
  }
}

// This validation caught dozens of parsing errors
function validateLiquidationEvent(event) {
  const requiredFields = ['protocol', 'liquidator', 'borrower', 'collateralAsset', 'amount'];
  
  for (const field of requiredFields) {
    if (!event[field]) {
      throw new Error(`Missing required field: ${field}`);
    }
  }
  
  // Sanity checks that saved us from bad data
  if (event.amount <= 0) {
    throw new Error('Invalid liquidation amount');
  }
  
  if (!Web3.utils.isAddress(event.liquidator)) {
    throw new Error('Invalid liquidator address');
  }
}