Implementing Stablecoin Impermanent Loss Calculator: The Real-Time Analysis Tool That Saved My Portfolio

// Core calculator class I built after my losses
class StablecoinImpermanentLossCalculator {
  constructor(config) {
    this.tokenA = config.tokenA;
    this.tokenB = config.tokenB;
    this.initialPriceA = config.initialPriceA;
    this.initialPriceB = config.initialPriceB;
    this.initialAmountA = config.initialAmountA;
    this.initialAmountB = config.initialAmountB;
    
    // This was the key insight - track price ratios, not absolute prices
    this.initialRatio = this.initialPriceA / this.initialPriceB;
    
    this.priceAPI = new PriceDataProvider();
    this.websocket = null;
  }

  // The formula that could have saved me $2,000
  calculateImpermanentLoss(currentPriceA, currentPriceB) {
    const currentRatio = currentPriceA / currentPriceB;
    const priceRatioChange = currentRatio / this.initialRatio;
    
    // Uniswap V2 impermanent loss formula
    const multiplier = (2 * Math.sqrt(priceRatioChange)) / (1 + priceRatioChange);
    const impermanentLossPercentage = (multiplier - 1) * 100;
    
    // Calculate dollar amount based on initial position
    const initialValue = (this.initialAmountA * this.initialPriceA) + 
                        (this.initialAmountB * this.initialPriceB);
    const impermanentLossDollar = initialValue * (impermanentLossPercentage / 100);
    
    return {
      percentage: impermanentLossPercentage,
      dollarAmount: impermanentLossDollar,
      currentRatio: currentRatio,
      ratioChange: priceRatioChange
    };
  }
}

// Real-time price monitoring that I wish I had during the USDC crisis
class PriceDataProvider {
  constructor() {
    this.websockets = new Map();
    this.priceCache = new Map();
    this.callbacks = new Map();
  }

  async connectToCoingecko(tokenIds) {
    // Free tier allows 50 calls per minute - perfect for my needs
    const ws = new WebSocket('wss://ws.coingecko.com/v1');
    
    ws.onopen = () => {
      console.log('Connected to CoinGecko WebSocket');
      // Subscribe to price updates
      tokenIds.forEach(tokenId => {
        ws.send(JSON.stringify({
          type: 'subscribe',
          channels: [`price.${tokenId}`]
        }));
      });
    };

    ws.onmessage = (event) => {
      const data = JSON.parse(event.data);
      if (data.type === 'price_update') {
        this.handlePriceUpdate(data.token_id, data.price);
      }
    };

    return ws;
  }

  handlePriceUpdate(tokenId, newPrice) {
    const oldPrice = this.priceCache.get(tokenId);
    this.priceCache.set(tokenId, newPrice);
    
    // Trigger callbacks for any active calculators
    const callbacks = this.callbacks.get(tokenId) || [];
    callbacks.forEach(callback => {
      callback({
        tokenId,
        oldPrice,
        newPrice,
        timestamp: Date.now()
      });
    });
  }

  // Subscribe to price changes for specific token pairs
  subscribeToPriceUpdates(tokenA, tokenB, callback) {
    [tokenA, tokenB].forEach(token => {
      if (!this.callbacks.has(token)) {
        this.callbacks.set(token, []);
      }
      this.callbacks.get(token).push(callback);
    });
  }
}

// Alert system that could have woken me up during the USDC depeg
class StablecoinAlertSystem {
  constructor(calculator, thresholds) {
    this.calculator = calculator;
    this.thresholds = thresholds;
    this.alertHistory = [];
  }

  checkForAlerts(priceData) {
    const alerts = [];
    
    // Check for depeg events (when stablecoin deviates from $1)
    const depegThreshold = 0.02; // 2% deviation
    Object.entries(priceData).forEach(([token, price]) => {
      const deviation = Math.abs(price - 1.0);
      if (deviation > depegThreshold) {
        alerts.push({
          type: 'DEPEG_WARNING',
          token: token,
          currentPrice: price,
          deviation: deviation * 100,
          severity: deviation > 0.05 ? 'HIGH' : 'MEDIUM',
          message: `${token} has depegged by ${(deviation * 100).toFixed(2)}%`
        });
      }
    });

    // Check for impermanent loss thresholds
    const ilData = this.calculator.calculateImpermanentLoss(
      priceData[this.calculator.tokenA],
      priceData[this.calculator.tokenB]
    );

    if (Math.abs(ilData.percentage) > this.thresholds.warningLevel) {
      alerts.push({
        type: 'IMPERMANENT_LOSS_WARNING',
        percentage: ilData.percentage,
        dollarAmount: ilData.dollarAmount,
        severity: Math.abs(ilData.percentage) > this.thresholds.criticalLevel ? 'HIGH' : 'MEDIUM',
        message: `Current impermanent loss: ${ilData.percentage.toFixed(2)}% ($${ilData.dollarAmount.toFixed(2)})`
      });
    }

    // Send notifications if needed
    if (alerts.length > 0) {
      this.sendNotifications(alerts);
    }

    return alerts;
  }

  async sendNotifications(alerts) {
    // Email notifications
    if (this.emailConfig) {
      await this.sendEmail(alerts);
    }
    
    // Discord webhook for urgent alerts
    if (this.discordWebhook) {
      await this.sendDiscordAlert(alerts);
    }
    
    // SMS for critical alerts (using Twilio)
    const criticalAlerts = alerts.filter(alert => alert.severity === 'HIGH');
    if (criticalAlerts.length > 0 && this.smsConfig) {
      await this.sendSMS(criticalAlerts);
    }
  }
}

// The dashboard that now saves me from costly mistakes
import React, { useState, useEffect } from 'react';
import { Line } from 'react-chartjs-2';

const ImpermanentLossTracker = () => {
  const [positions, setPositions] = useState([]);
  const [realTimeData, setRealTimeData] = useState({});
  const [alerts, setAlerts] = useState([]);

  useEffect(() => {
    // Initialize calculator and connect to real-time feeds
    const calculator = new StablecoinImpermanentLossCalculator({
      tokenA: 'USDC',
      tokenB: 'USDT',
      initialPriceA: 1.0,
      initialPriceB: 1.0,
      initialAmountA: 10000,
      initialAmountB: 10000
    });

    const priceProvider = new PriceDataProvider();
    priceProvider.connectToCoingecko(['usd-coin', 'tether']);

    priceProvider.subscribeToPriceUpdates('usd-coin', 'tether', (priceData) => {
      const ilData = calculator.calculateImpermanentLoss(
        priceData.priceA,
        priceData.priceB
      );
      
      setRealTimeData(prev => ({
        ...prev,
        impermanentLoss: ilData,
        timestamp: Date.now()
      }));
    });

    return () => {
      // Cleanup WebSocket connections
      priceProvider.disconnect();
    };
  }, []);

  return (
    <div className="il-tracker">
      <div className="position-overview">
        <h2>Live Stablecoin Pool Positions</h2>
        
        {/* Current P&L Display */}
        <div className="pnl-display">
          <div className={`il-amount ${realTimeData.impermanentLoss?.percentage < 0 ? 'loss' : 'gain'}`}>
            <span className="label">Impermanent Loss:</span>
            <span className="value">
              {realTimeData.impermanentLoss?.percentage.toFixed(4)}%
            </span>
            <span className="dollar-value">
              (${realTimeData.impermanentLoss?.dollarAmount.toFixed(2)})
            </span>
          </div>
        </div>

        {/* Price Monitoring */}
        <div className="price-monitor">
          <div className="token-price">
            <span>USDC: ${realTimeData.priceA?.toFixed(6)}</span>
            <span className={realTimeData.priceA < 0.99 || realTimeData.priceA > 1.01 ? 'depeg-warning' : 'normal'}>
              {realTimeData.priceA < 0.99 || realTimeData.priceA > 1.01 ? '⚠️ DEPEGGED' : '✅ Pegged'}
            </span>
          </div>
          <div className="token-price">
            <span>USDT: ${realTimeData.priceB?.toFixed(6)}</span>
            <span className={realTimeData.priceB < 0.99 || realTimeData.priceB > 1.01 ? 'depeg-warning' : 'normal'}>
              {realTimeData.priceB < 0.99 || realTimeData.priceB > 1.01 ? '⚠️ DEPEGGED' : '✅ Pegged'}
            </span>
          </div>
        </div>
      </div>

      {/* Alert Panel */}
      {alerts.length > 0 && (
        <div className="alert-panel">
          <h3>🚨 Active Alerts</h3>
          {alerts.map((alert, index) => (
            <div key={index} className={`alert alert-${alert.severity.toLowerCase()}`}>
              <span className="alert-type">{alert.type}:</span>
              <span className="alert-message">{alert.message}</span>
            </div>
          ))}
        </div>
      )}

      {/* Historical Chart */}
      <div className="chart-container">
        <h3>Impermanent Loss Over Time</h3>
        <Line
          data={{
            labels: historicalData.timestamps,
            datasets: [{
              label: 'Impermanent Loss %',
              data: historicalData.impermanentLoss,
              borderColor: 'rgb(255, 99, 132)',
              backgroundColor: 'rgba(255, 99, 132, 0.2)',
            }]
          }}
          options={{
            responsive: true,
            scales: {
              y: {
                beginAtZero: true,
                title: {
                  display: true,
                  text: 'Impermanent Loss %'
                }
              }
            }
          }}
        />
      </div>
    </div>
  );
};

export default ImpermanentLossTracker;

// Backtesting function that showed me the March 2023 damage
class HistoricalAnalyzer {
  async analyzeHistoricalPerformance(tokenPair, startDate, endDate, positionSize) {
    const historicalPrices = await this.fetchHistoricalPrices(tokenPair, startDate, endDate);
    const results = [];

    let cumulativeIL = 0;
    let maxDrawdown = 0;
    let totalFeesEarned = 0;

    historicalPrices.forEach((priceData, index) => {
      if (index === 0) return; // Skip first entry (baseline)

      const calculator = new StablecoinImpermanentLossCalculator({
        tokenA: tokenPair.tokenA,
        tokenB: tokenPair.tokenB,
        initialPriceA: historicalPrices[0].priceA,
        initialPriceB: historicalPrices[0].priceB,
        initialAmountA: positionSize / 2,
        initialAmountB: positionSize / 2
      });

      const ilData = calculator.calculateImpermanentLoss(
        priceData.priceA,
        priceData.priceB
      );

      // Simulate fee earnings (approximate)
      const dailyVolume = priceData.volume || 1000000; // Default volume
      const poolTVL = 50000000; // Estimate pool size
      const feeShare = positionSize / poolTVL;
      const dailyFees = dailyVolume * 0.003 * feeShare; // 0.3% fee tier

      totalFeesEarned += dailyFees;
      cumulativeIL = ilData.dollarAmount;
      maxDrawdown = Math.min(maxDrawdown, ilData.dollarAmount);

      results.push({
        date: priceData.date,
        impermanentLoss: ilData.dollarAmount,
        impermanentLossPercentage: ilData.percentage,
        cumulativeFeesEarned: totalFeesEarned,
        netPnL: totalFeesEarned + ilData.dollarAmount,
        priceA: priceData.priceA,
        priceB: priceData.priceB
      });
    });

    return {
      summary: {
        totalImpermanentLoss: cumulativeIL,
        totalFeesEarned: totalFeesEarned,
        netProfitLoss: totalFeesEarned + cumulativeIL,
        maxDrawdown: maxDrawdown,
        sharpeRatio: this.calculateSharpeRatio(results)
      },
      dailyResults: results
    };
  }
}

// Risk management that I wish I had from day one
class RiskManager {
  calculateOptimalPositionSize(userCapital, riskTolerance, pairVolatility) {
    // Kelly Criterion adapted for LP positions
    const winRate = this.estimateWinRate(pairVolatility);
    const avgWin = this.estimateAverageWin(pairVolatility);
    const avgLoss = this.estimateAverageLoss(pairVolatility);
    
    const kellyFraction = (winRate * avgWin - (1 - winRate) * avgLoss) / avgWin;
    
    // Cap position size based on user risk tolerance
    const maxPositionPercent = riskTolerance === 'conservative' ? 0.05 : 
                               riskTolerance === 'moderate' ? 0.15 : 0.30;
    
    const recommendedPercent = Math.min(kellyFraction, maxPositionPercent);
    const recommendedAmount = userCapital * recommendedPercent;
    
    return {
      recommendedAmount: recommendedAmount,
      percentOfCapital: recommendedPercent * 100,
      reasoning: this.generateReasoning(pairVolatility, kellyFraction, recommendedPercent)
    };
  }

  generateReasoning(volatility, kelly, recommended) {
    let reasoning = [];
    
    if (volatility > 0.05) {
      reasoning.push("High volatility detected - reduced position size recommended");
    }
    
    if (kelly < 0) {
      reasoning.push("Negative expected value - consider avoiding this pair");
    }
    
    if (recommended < kelly) {
      reasoning.push("Position size capped due to risk tolerance settings");
    }
    
    return reasoning;
  }
}

// Test suite that prevents production disasters
describe('Stablecoin Impermanent Loss Calculator', () => {
  let calculator;

  beforeEach(() => {
    calculator = new StablecoinImpermanentLossCalculator({
      tokenA: 'USDC',
      tokenB: 'USDT', 
      initialPriceA: 1.0,
      initialPriceB: 1.0,
      initialAmountA: 1000,
      initialAmountB: 1000
    });
  });

  // Test the exact scenario that cost me money
  test('calculates correct impermanent loss during USDC depeg', () => {
    const result = calculator.calculateImpermanentLoss(0.87, 1.0); // March 2023 prices
    
    expect(result.percentage).toBeCloseTo(-3.23, 2); // Historical IL was ~3.23%
    expect(result.dollarAmount).toBeCloseTo(-64.6, 1); // On $2000 position
  });

  test('handles extreme depeg scenarios', () => {
    const result = calculator.calculateImpermanentLoss(0.5, 1.0); // 50% depeg
    
    expect(result.percentage).toBeLessThan(-10); // Significant loss expected
    expect(result.dollarAmount).toBeLessThan(-200); // Dollar amount calculated correctly
  });

  test('alert system triggers correctly', () => {
    const alertSystem = new StablecoinAlertSystem(calculator, {
      warningLevel: 1.0,
      criticalLevel: 5.0
    });

    const alerts = alertSystem.checkForAlerts({
      'USDC': 0.87,
      'USDT': 1.0
    });

    expect(alerts).toHaveLength(2); // Depeg warning + IL warning
    expect(alerts[0].type).toBe('DEPEG_WARNING');
    expect(alerts[1].type).toBe('IMPERMANENT_LOSS_WARNING');
  });
});

# Production deployment script that keeps everything running
#!/bin/bash

# Update the application
git pull origin main
npm install --production

# Run tests in production environment (with real API keys)
npm run test:production

# Build the frontend
npm run build

# Restart the services with zero downtime
pm2 reload il-calculator-api
pm2 reload il-calculator-websocket
pm2 reload il-calculator-alerts

# Verify everything is working
curl -f http://localhost:3001/health || exit 1

echo "Deployment successful! 🚀"