Implementing Stablecoin Auto-Compounding: How I Built a $1.4M Beefy Finance Vault Strategy That Doubled My Yields

// Core Beefy Finance auto-compounding system for stablecoins
import { ethers } from 'ethers';
import { BeefyAPI, BeefyVault } from '@beefy-finance/sdk';
import { VaultStrategy } from './strategies/VaultStrategy';

class StablecoinAutoCompounder {
  constructor(config) {
    this.provider = new ethers.providers.JsonRpcProvider(config.rpcUrl);
    this.wallet = new ethers.Wallet(config.privateKey, this.provider);
    
    // Initialize Beefy API
    this.beefyAPI = new BeefyAPI({
      network: config.network || 'ethereum',
      apiKey: config.beefyApiKey
    });
    
    // Supported stablecoin vault categories
    this.vaultCategories = {
      'stable-lp': {
        description: 'Stablecoin LP farming (Curve, Balancer, etc)',
        riskLevel: 'LOW',
        expectedAPY: '8-25%',
        compoundFrequency: 'HIGH', // Every 4-6 hours
        gasOptimization: 'MEDIUM'
      },
      'stable-lending': {
        description: 'Lending protocol auto-compounding',
        riskLevel: 'VERY_LOW', 
        expectedAPY: '4-12%',
        compoundFrequency: 'LOW', // Every 12-24 hours
        gasOptimization: 'HIGH'
      },
      'stable-farming': {
        description: 'Single-asset stablecoin farming',
        riskLevel: 'LOW',
        expectedAPY: '6-18%',
        compoundFrequency: 'MEDIUM', // Every 6-8 hours
        gasOptimization: 'MEDIUM'
      },
      'stable-arbitrage': {
        description: 'Automated arbitrage compounding',
        riskLevel: 'MEDIUM',
        expectedAPY: '12-35%',
        compoundFrequency: 'VERY_HIGH', // Every 1-2 hours
        gasOptimization: 'LOW'
      }
    };
    
    // Active vault positions
    this.activePositions = new Map();
    this.vaultStrategies = new Map();
    this.performanceTracking = {
      totalDeposited: ethers.BigNumber.from(0),
      totalWithdrawn: ethers.BigNumber.from(0),
      totalCompounds: 0,
      totalGasPaid: ethers.BigNumber.from(0),
      totalYieldEarned: ethers.BigNumber.from(0),
      averageAPY: 0
    };
    
    // Compounding parameters
    this.compoundingConfig = {
      minCompoundAmount: ethers.utils.parseEther('10'), // $10 minimum
      maxGasPrice: 50e9, // 50 gwei max
      profitThreshold: 0.02, // 2% minimum profit after gas
      emergencyWithdrawEnabled: true,
      rebalanceThreshold: 0.1, // 10% allocation drift triggers rebalance
      maxSlippage: 0.005 // 0.5% max slippage
    };
  }

  // Initialize the auto-compounding system
  async initialize() {
    console.log('🚀 Initializing Beefy auto-compounding system...');
    
    // Connect to Beefy API and load available vaults
    await this.loadAvailableVaults();
    
    // Initialize vault strategies
    await this.initializeVaultStrategies();
    
    // Set up automated compounding schedules
    await this.setupCompoundingScheduler();
    
    // Load existing positions
    await this.loadExistingPositions();
    
    console.log('✅ Auto-compounding system initialized successfully');
    
    return {
      availableVaults: this.availableVaults.length,
      activePositions: this.activePositions.size,
      totalValue: await this.getTotalPortfolioValue()
    };
  }

  async loadAvailableVaults() {
    // Load all available Beefy vaults and filter for stablecoin strategies
    const allVaults = await this.beefyAPI.getVaults();
    
    this.availableVaults = allVaults.filter(vault => {
      // Filter for stablecoin-related vaults
      const isStablecoinVault = this.isStablecoinVault(vault);
      const hasMinTVL = vault.tvl >= 1000000; // $1M minimum TVL
      const isActive = vault.status === 'active';
      const hasRecentActivity = this.hasRecentActivity(vault);
      
      return isStablecoinVault && hasMinTVL && isActive && hasRecentActivity;
    });
    
    console.log(`📊 Loaded ${this.availableVaults.length} eligible stablecoin vaults`);
    
    // Categorize vaults by strategy type
    this.categorizeVaults();
  }

  isStablecoinVault(vault) {
    const stablecoinSymbols = ['USDC', 'USDT', 'DAI', 'FRAX', 'BUSD', 'TUSD', 'LUSD', 'sUSD'];
    const vaultAssets = vault.assets || [];
    
    // Check if vault primarily deals with stablecoins
    const stablecoinCount = vaultAssets.filter(asset => 
      stablecoinSymbols.some(stable => asset.symbol.includes(stable))
    ).length;
    
    return stablecoinCount >= vaultAssets.length * 0.7; // 70% stablecoin assets
  }

  categorizeVaults() {
    this.categorizedVaults = {
      'stable-lp': [],
      'stable-lending': [],
      'stable-farming': [],
      'stable-arbitrage': []
    };
    
    for (const vault of this.availableVaults) {
      const category = this.determineVaultCategory(vault);
      this.categorizedVaults[category].push(vault);
    }
    
    console.log('📂 Vault categorization:', 
      Object.entries(this.categorizedVaults).map(([cat, vaults]) => 
        `${cat}: ${vaults.length}`
      ).join(', ')
    );
  }

  determineVaultCategory(vault) {
    const strategyName = vault.strategy.toLowerCase();
    const platformName = vault.platform.toLowerCase();
    
    // LP farming vaults
    if (strategyName.includes('lp') || 
        platformName.includes('curve') || 
        platformName.includes('balancer') ||
        platformName.includes('uniswap')) {
      return 'stable-lp';
    }
    
    // Lending protocol vaults
    if (platformName.includes('aave') || 
        platformName.includes('compound') ||
        platformName.includes('euler') ||
        strategyName.includes('lending')) {
      return 'stable-lending';
    }
    
    // Arbitrage/complex strategy vaults
    if (strategyName.includes('arbitrage') ||
        strategyName.includes('delta') ||
        vault.riskScore > 7) {
      return 'stable-arbitrage';
    }
    
    // Default to simple farming
    return 'stable-farming';
  }

  async initializeVaultStrategies() {
    // Create strategy instances for each vault category
    for (const [category, vaults] of Object.entries(this.categorizedVaults)) {
      const strategyConfig = this.vaultCategories[category];
      
      const strategy = new VaultStrategy({
        category,
        vaults,
        config: strategyConfig,
        compounder: this
      });
      
      await strategy.initialize();
      this.vaultStrategies.set(category, strategy);
      
      console.log(`📈 Initialized ${category} strategy with ${vaults.length} vaults`);
    }
  }
}

// Intelligent vault selection and allocation system
class VaultOptimizer {
  constructor(compounder) {
    this.compounder = compounder;
    this.allocationHistory = [];
    this.performanceMetrics = new Map();
  }

  async optimizeVaultAllocation(totalAmount, userPreferences = {}) {
    // Get current market conditions
    const marketConditions = await this.assessMarketConditions();
    
    // Analyze all available vaults
    const vaultAnalysis = await this.analyzeAllVaults();
    
    // Calculate optimal allocation based on multiple factors
    const optimalAllocation = await this.calculateOptimalAllocation(
      totalAmount, 
      vaultAnalysis, 
      marketConditions,
      userPreferences
    );
    
    return optimalAllocation;
  }

  async analyzeAllVaults() {
    const analysis = [];
    
    for (const [category, vaults] of Object.entries(this.compounder.categorizedVaults)) {
      for (const vault of vaults) {
        const vaultMetrics = await this.analyzeVault(vault);
        analysis.push({
          ...vaultMetrics,
          category,
          vault
        });
      }
    }
    
    // Sort by overall score
    return analysis.sort((a, b) => b.overallScore - a.overallScore);
  }

  async analyzeVault(vault) {
    // Fetch comprehensive vault data
    const [
      currentAPY,
      historicalAPY,
      tvlTrend,
      compoundFrequency,
      gasEfficiency,
      riskMetrics
    ] = await Promise.all([
      this.getCurrentAPY(vault),
      this.getHistoricalAPY(vault, 30), // 30 days
      this.getTVLTrend(vault, 7), // 7 days
      this.getCompoundFrequency(vault),
      this.calculateGasEfficiency(vault),
      this.assessRiskMetrics(vault)
    ]);
    
    // Calculate risk-adjusted return
    const riskAdjustedReturn = this.calculateRiskAdjustedReturn(
      currentAPY, 
      riskMetrics
    );
    
    // Calculate compound efficiency score
    const compoundEfficiency = this.calculateCompoundEfficiency(
      currentAPY,
      compoundFrequency,
      gasEfficiency
    );
    
    // Calculate TVL stability score
    const tvlStability = this.calculateTVLStability(tvlTrend);
    
    // Calculate overall score
    const overallScore = this.calculateOverallScore({
      riskAdjustedReturn,
      compoundEfficiency,
      tvlStability,
      currentAPY,
      historicalAPY
    });
    
    return {
      vaultId: vault.id,
      currentAPY,
      historicalAPY,
      riskAdjustedReturn,
      compoundEfficiency,
      tvlStability,
      overallScore,
      recommendation: this.generateRecommendation(overallScore, riskMetrics)
    };
  }

  calculateRiskAdjustedReturn(apy, riskMetrics) {
    // Sharpe ratio adaptation for DeFi vaults
    const riskFreeRate = 0.02; // 2% risk-free rate
    const excessReturn = apy - riskFreeRate;
    const volatility = riskMetrics.volatility || 0.1;
    
    return excessReturn / volatility;
  }

  calculateCompoundEfficiency(apy, frequency, gasEfficiency) {
    // Calculate the benefit of auto-compounding vs manual
    const manualCompounds = 12; // Assume 12 manual compounds per year
    const autoCompounds = frequency * 365 * 24; // Hourly frequency
    
    // Calculate compound interest difference
    const manualReturn = Math.pow(1 + apy / manualCompounds, manualCompounds) - 1;
    const autoReturn = Math.pow(1 + apy / autoCompounds, autoCompounds) - 1;
    
    const compoundBenefit = (autoReturn - manualReturn) / manualReturn;
    
    // Adjust for gas efficiency
    const netBenefit = compoundBenefit * gasEfficiency;
    
    return netBenefit;
  }

  async calculateOptimalAllocation(totalAmount, vaultAnalysis, marketConditions, preferences) {
    const allocation = new Map();
    const constraints = this.buildAllocationConstraints(preferences);
    
    // Use Modern Portfolio Theory adapted for DeFi
    const returns = vaultAnalysis.map(v => v.riskAdjustedReturn);
    const risks = vaultAnalysis.map(v => v.riskMetrics?.volatility || 0.1);
    const correlations = await this.calculateVaultCorrelations(vaultAnalysis);
    
    // Quadratic optimization for optimal weights
    const optimalWeights = await this.solveOptimization(
      returns,
      risks,
      correlations,
      constraints
    );
    
    // Apply market condition adjustments
    const adjustedWeights = this.adjustForMarketConditions(
      optimalWeights,
      marketConditions
    );
    
    // Convert weights to allocation amounts
    vaultAnalysis.forEach((vault, index) => {
      const allocationAmount = totalAmount.mul(
        ethers.utils.parseEther(adjustedWeights[index].toString())
      ).div(ethers.utils.parseEther('1'));
      
      if (allocationAmount.gt(ethers.utils.parseEther('100'))) { // Minimum $100
        allocation.set(vault.vaultId, {
          amount: allocationAmount,
          weight: adjustedWeights[index],
          vault: vault.vault,
          expectedAPY: vault.currentAPY,
          riskScore: vault.riskMetrics?.score || 5
        });
      }
    });
    
    return allocation;
  }

  buildAllocationConstraints(preferences) {
    return {
      // Maximum allocation per vault
      maxVaultAllocation: preferences.maxVaultAllocation || 0.25, // 25%
      
      // Maximum allocation per category
      maxCategoryAllocation: {
        'stable-lp': preferences.maxLPAllocation || 0.5, // 50%
        'stable-lending': preferences.maxLendingAllocation || 0.4, // 40%
        'stable-farming': preferences.maxFarmingAllocation || 0.6, // 60%
        'stable-arbitrage': preferences.maxArbitrageAllocation || 0.2 // 20%
      },
      
      // Minimum allocation per vault (if selected)
      minVaultAllocation: preferences.minVaultAllocation || 0.02, // 2%
      
      // Maximum number of vaults
      maxVaults: preferences.maxVaults || 8,
      
      // Risk tolerance
      maxRiskScore: preferences.maxRiskScore || 7, // Scale 1-10
      
      // Minimum APY threshold
      minAPY: preferences.minAPY || 0.06 // 6%
    };
  }

  async solveOptimization(returns, risks, correlations, constraints) {
    // Simplified mean-variance optimization
    // In production, use a proper optimization library
    
    const numAssets = returns.length;
    let weights = new Array(numAssets).fill(1 / numAssets); // Start with equal weights
    
    const learningRate = 0.01;
    const maxIterations = 1000;
    
    for (let iter = 0; iter < maxIterations; iter++) {
      // Calculate portfolio return and risk
      const portfolioReturn = this.calculatePortfolioReturn(weights, returns);
      const portfolioRisk = this.calculatePortfolioRisk(weights, risks, correlations);
      
      // Calculate gradient for Sharpe ratio maximization
      const gradient = this.calculateSharpeGradient(weights, returns, risks, correlations);
      
      // Update weights
      for (let i = 0; i < numAssets; i++) {
        weights[i] += learningRate * gradient[i];
      }
      
      // Apply constraints
      weights = this.applyConstraints(weights, constraints);
      
      // Normalize weights to sum to 1
      const weightSum = weights.reduce((sum, w) => sum + w, 0);
      weights = weights.map(w => w / weightSum);
      
      // Check convergence
      if (this.hasConverged(gradient)) {
        break;
      }
    }
    
    return weights;
  }
}

// Advanced auto-compounding strategies for different vault types
class AdvancedCompoundingStrategies {
  constructor(compounder) {
    this.compounder = compounder;
    this.strategies = new Map();
    this.executionHistory = [];
    
    this.initializeStrategies();
  }

  initializeStrategies() {
    // Strategy 1: Gas-Optimized Compounding
    this.strategies.set('gas-optimized', {
      name: 'Gas-Optimized Compounding',
      description: 'Compounds when gas costs are optimal relative to rewards',
      execute: this.executeGasOptimizedCompounding.bind(this),
      schedule: 'dynamic', // Based on gas prices and rewards
      minRewardThreshold: 0.02, // 2% minimum reward-to-gas ratio
      gasThreshold: 30e9 // 30 gwei max
    });

    // Strategy 2: High-Frequency Micro-Compounding
    this.strategies.set('high-frequency', {
      name: 'High-Frequency Micro-Compounding',
      description: 'Frequent small compounds for maximum compound effect',
      execute: this.executeHighFrequencyCompounding.bind(this),
      schedule: 'every-4-hours',
      minRewardThreshold: 0.01, // 1% minimum
      maxGasRatio: 0.05 // 5% max gas-to-reward ratio
    });

    // Strategy 3: Batch Compounding
    this.strategies.set('batch-compound', {
      name: 'Batch Compounding',
      description: 'Compounds multiple positions in single transaction',
      execute: this.executeBatchCompounding.bind(this),
      schedule: 'daily',
      minPositions: 3, // Minimum 3 positions to batch
      gasEfficiencyThreshold: 0.3 // 30% gas savings minimum
    });

    // Strategy 4: Yield-Chasing Compounding
    this.strategies.set('yield-chasing', {
      name: 'Yield-Chasing Compounding',
      description: 'Automatically migrates to higher-yielding vaults',
      execute: this.executeYieldChasingCompounding.bind(this),
      schedule: 'weekly',
      yieldThreshold: 0.02, // 2% yield improvement minimum
      migrationCostThreshold: 0.005 // 0.5% max migration cost
    });

    // Strategy 5: Risk-Adjusted Compounding
    this.strategies.set('risk-adjusted', {
      name: 'Risk-Adjusted Compounding',
      description: 'Adjusts compounding frequency based on risk levels',
      execute: this.executeRiskAdjustedCompounding.bind(this),
      schedule: 'dynamic',
      riskMultiplier: {
        low: 1.0,    // Normal frequency for low risk
        medium: 0.7, // Reduced frequency for medium risk
        high: 0.4    // Much reduced frequency for high risk
      }
    });
  }

  async executeGasOptimizedCompounding(positions) {
    const gasPrice = await this.compounder.provider.getGasPrice();
    const strategy = this.strategies.get('gas-optimized');
    
    // Only compound if gas is below threshold
    if (gasPrice.gt(ethers.BigNumber.from(strategy.gasThreshold))) {
      console.log(`⛽ Gas too high (${ethers.utils.formatUnits(gasPrice, 'gwei')} gwei), skipping compound`);
      return { executed: false, reason: 'GAS_TOO_HIGH' };
    }
    
    const compoundablePositions = [];
    
    for (const position of positions) {
      const pendingRewards = await this.calculatePendingRewards(position);
      const gasCost = await this.estimateCompoundGasCost(position);
      
      const rewardToGasRatio = pendingRewards.div(gasCost);
      
      if (rewardToGasRatio.gte(
        ethers.utils.parseEther(strategy.minRewardThreshold.toString())
      )) {
        compoundablePositions.push({
          position,
          pendingRewards,
          gasCost,
          ratio: rewardToGasRatio
        });
      }
    }
    
    if (compoundablePositions.length === 0) {
      return { executed: false, reason: 'NO_PROFITABLE_COMPOUNDS' };
    }
    
    // Sort by profitability and compound the best ones
    compoundablePositions.sort((a, b) => b.ratio.sub(a.ratio));
    
    const results = [];
    for (const { position } of compoundablePositions) {
      try {
        const result = await this.executeCompound(position);
        results.push(result);
      } catch (error) {
        console.error(`Failed to compound ${position.vaultId}:`, error);
      }
    }
    
    return {
      executed: true,
      strategy: 'gas-optimized',
      compoundsExecuted: results.length,
      totalGasSaved: this.calculateGasSavings(results),
      results
    };
  }

  async executeHighFrequencyCompounding(positions) {
    const strategy = this.strategies.get('high-frequency');
    const results = [];
    
    for (const position of positions) {
      const timeSinceLastCompound = Date.now() - position.lastCompound;
      const minInterval = 4 * 60 * 60 * 1000; // 4 hours
      
      if (timeSinceLastCompound < minInterval) {
        continue; // Too soon to compound
      }
      
      const pendingRewards = await this.calculatePendingRewards(position);
      const gasCost = await this.estimateCompoundGasCost(position);
      
      // Check if reward justifies gas cost
      const gasRatio = gasCost.div(pendingRewards);
      
      if (gasRatio.lte(
        ethers.utils.parseEther(strategy.maxGasRatio.toString())
      )) {
        try {
          const result = await this.executeCompound(position);
          results.push(result);
          
          // Update last compound time
          position.lastCompound = Date.now();
        } catch (error) {
          console.error(`High-frequency compound failed for ${position.vaultId}:`, error);
        }
      }
    }
    
    return {
      executed: results.length > 0,
      strategy: 'high-frequency',
      compoundsExecuted: results.length,
      averageCompoundTime: this.calculateAverageCompoundTime(results),
      results
    };
  }

  async executeBatchCompounding(positions) {
    const strategy = this.strategies.get('batch-compound');
    
    // Group positions by vault contract for batching
    const batchGroups = this.groupPositionsForBatching(positions);
    const results = [];
    
    for (const [contract, groupPositions] of batchGroups.entries()) {
      if (groupPositions.length < strategy.minPositions) {
        continue; // Not enough positions to justify batching
      }
      
      const individualGasCost = await this.estimateIndividualCompoundCosts(groupPositions);
      const batchGasCost = await this.estimateBatchCompoundCost(groupPositions);
      
      const gasSavings = individualGasCost.sub(batchGasCost);
      const savingsRatio = gasSavings.div(individualGasCost);
      
      if (savingsRatio.gte(
        ethers.utils.parseEther(strategy.gasEfficiencyThreshold.toString())
      )) {
        try {
          const batchResult = await this.executeBatchCompound(groupPositions);
          results.push({
            type: 'batch',
            positions: groupPositions.length,
            gasSaved: gasSavings,
            savingsRatio,
            ...batchResult
          });
        } catch (error) {
          console.error(`Batch compound failed for ${contract}:`, error);
        }
      }
    }
    
    return {
      executed: results.length > 0,
      strategy: 'batch-compound',
      batchesExecuted: results.length,
      totalGasSaved: results.reduce((sum, r) => sum.add(r.gasSaved), ethers.BigNumber.from(0)),
      results
    };
  }

  async executeYieldChasingCompounding(positions) {
    const strategy = this.strategies.get('yield-chasing');
    const migrations = [];
    
    for (const position of positions) {
      // Find better yielding alternatives
      const currentAPY = await this.getCurrentAPY(position);
      const alternatives = await this.findBetterYieldAlternatives(position);
      
      for (const alternative of alternatives) {
        const yieldImprovement = alternative.apy - currentAPY;
        const migrationCost = await this.calculateMigrationCost(position, alternative);
        
        if (yieldImprovement >= strategy.yieldThreshold &&
            migrationCost <= strategy.migrationCostThreshold) {
          
          try {
            const migrationResult = await this.executeMigration(position, alternative);
            migrations.push({
              from: position,
              to: alternative,
              yieldImprovement,
              migrationCost,
              ...migrationResult
            });
            
            console.log(`🎯 Migrated ${position.vaultId} → ${alternative.vaultId} (+${(yieldImprovement * 100).toFixed(2)}% APY)`);
          } catch (error) {
            console.error(`Migration failed ${position.vaultId} → ${alternative.vaultId}:`, error);
          }
        }
      }
    }
    
    return {
      executed: migrations.length > 0,
      strategy: 'yield-chasing',
      migrationsExecuted: migrations.length,
      averageYieldImprovement: this.calculateAverageYieldImprovement(migrations),
      migrations
    };
  }

  async executeRiskAdjustedCompounding(positions) {
    const strategy = this.strategies.get('risk-adjusted');
    const results = [];
    
    for (const position of positions) {
      const riskLevel = await this.assessPositionRisk(position);
      const riskMultiplier = strategy.riskMultiplier[riskLevel];
      
      // Adjust compounding frequency based on risk
      const baseInterval = 6 * 60 * 60 * 1000; // 6 hours base
      const adjustedInterval = baseInterval / riskMultiplier;
      
      const timeSinceLastCompound = Date.now() - position.lastCompound;
      
      if (timeSinceLastCompound >= adjustedInterval) {
        const pendingRewards = await this.calculatePendingRewards(position);
        
        // Higher risk positions need higher reward thresholds
        const minRewardThreshold = riskLevel === 'high' ? 0.05 : 
                                  riskLevel === 'medium' ? 0.03 : 0.02;
        
        if (pendingRewards.gte(ethers.utils.parseEther(minRewardThreshold.toString()))) {
          try {
            const result = await this.executeCompound(position);
            results.push({
              ...result,
              riskLevel,
              riskMultiplier,
              adjustedInterval
            });
            
            position.lastCompound = Date.now();
          } catch (error) {
            console.error(`Risk-adjusted compound failed for ${position.vaultId}:`, error);
          }
        }
      }
    }
    
    return {
      executed: results.length > 0,
      strategy: 'risk-adjusted',
      compoundsExecuted: results.length,
      riskDistribution: this.calculateRiskDistribution(results),
      results
    };
  }

  async executeCompound(position) {
    const vault = position.vault;
    const beefyVault = new BeefyVault(vault.address, this.compounder.wallet);
    
    // Execute the compound transaction
    const tx = await beefyVault.harvest();
    const receipt = await tx.wait();
    
    // Calculate rewards earned
    const rewardsBefore = position.totalRewards || ethers.BigNumber.from(0);
    const rewardsAfter = await beefyVault.earned(this.compounder.wallet.address);
    const newRewards = rewardsAfter.sub(rewardsBefore);
    
    // Update position tracking
    position.totalRewards = rewardsAfter;
    position.lastCompound = Date.now();
    position.compoundCount = (position.compoundCount || 0) + 1;
    
    return {
      positionId: position.id,
      vaultId: position.vaultId,
      txHash: receipt.transactionHash,
      gasUsed: receipt.gasUsed,
      gasPrice: receipt.effectiveGasPrice,
      newRewards,
      totalRewards: rewardsAfter,
      compoundCount: position.compoundCount,
      timestamp: Date.now()
    };
  }
}

// Performance monitoring and analytics for auto-compounding
class CompoundingAnalytics {
  constructor(compounder) {
    this.compounder = compounder;
    this.performanceHistory = [];
    this.benchmarkData = new Map();
    this.alertThresholds = {
      lowPerformance: 0.05, // 5% below benchmark triggers alert
      highGasCosts: 0.1,    // 10% of rewards spent on gas triggers alert
      failedCompounds: 0.1, // 10% failure rate triggers alert
      apyDeviation: 0.2     // 20% APY deviation triggers alert
    };
  }

  async generatePerformanceReport(timeframe = 30) {
    const endDate = Date.now();
    const startDate = endDate - (timeframe * 24 * 60 * 60 * 1000);
    
    const report = {
      timeframe: `${timeframe} days`,
      period: { startDate, endDate },
      summary: await this.calculateSummaryMetrics(startDate, endDate),
      byStrategy: await this.calculateStrategyPerformance(startDate, endDate),
      byVault: await this.calculateVaultPerformance(startDate, endDate),
      gasAnalysis: await this.analyzeGasEfficiency(startDate, endDate),
      compoundingEffectiveness: await this.analyzeCompoundingEffectiveness(startDate, endDate),
      benchmarkComparison: await this.compareAgainstBenchmarks(startDate, endDate),
      recommendations: await this.generateRecommendations(startDate, endDate)
    };
    
    return report;
  }

  async calculateSummaryMetrics(startDate, endDate) {
    const positions = Array.from(this.compounder.activePositions.values());
    
    const totalValue = await this.compounder.getTotalPortfolioValue();
    const totalDeposited = this.compounder.performanceTracking.totalDeposited;
    const totalGasPaid = this.compounder.performanceTracking.totalGasPaid;
    const totalCompounds = this.compounder.performanceTracking.totalCompounds;
    
    // Calculate time-weighted returns
    const timeWeightedReturn = await this.calculateTimeWeightedReturn(startDate, endDate);
    
    // Calculate annualized metrics
    const daysPassed = (endDate - startDate) / (24 * 60 * 60 * 1000);
    const annualizedReturn = Math.pow(1 + timeWeightedReturn, 365 / daysPassed) - 1;
    
    // Calculate compound frequency
    const avgCompoundFrequency = totalCompounds / daysPassed; // compounds per day
    
    // Calculate gas efficiency
    const gasEfficiency = 1 - (totalGasPaid.div(totalValue)); // percentage not spent on gas
    
    return {
      totalPortfolioValue: ethers.utils.formatEther(totalValue),
      totalReturn: timeWeightedReturn,
      annualizedReturn,
      totalCompounds,
      avgCompoundFrequency,
      gasEfficiency: parseFloat(ethers.utils.formatEther(gasEfficiency)),
      activePositions: positions.length,
      failureRate: await this.calculateFailureRate(startDate, endDate)
    };
  }

  async calculateStrategyPerformance(startDate, endDate) {
    const strategies = Array.from(this.compounder.vaultStrategies.keys());
    const strategyPerformance = {};
    
    for (const strategyName of strategies) {
      const strategy = this.compounder.vaultStrategies.get(strategyName);
      const strategyPositions = await strategy.getPositions();
      
      const strategyMetrics = {
        totalValue: ethers.BigNumber.from(0),
        totalReturn: 0,
        compoundCount: 0,
        gasSpent: ethers.BigNumber.from(0),
        avgAPY: 0,
        positionCount: strategyPositions.length
      };
      
      for (const position of strategyPositions) {
        const positionMetrics = await this.calculatePositionMetrics(position, startDate, endDate);
        
        strategyMetrics.totalValue = strategyMetrics.totalValue.add(positionMetrics.currentValue);
        strategyMetrics.totalReturn += positionMetrics.return;
        strategyMetrics.compoundCount += positionMetrics.compounds;
        strategyMetrics.gasSpent = strategyMetrics.gasSpent.add(positionMetrics.gasSpent);
      }
      
      // Calculate averages
      if (strategyPositions.length > 0) {
        strategyMetrics.avgAPY = strategyMetrics.totalReturn / strategyPositions.length;
        strategyMetrics.totalReturn = strategyMetrics.totalReturn / strategyPositions.length;
      }
      
      strategyPerformance[strategyName] = {
        ...strategyMetrics,
        totalValue: ethers.utils.formatEther(strategyMetrics.totalValue),
        gasSpent: ethers.utils.formatEther(strategyMetrics.gasSpent)
      };
    }
    
    return strategyPerformance;
  }

  async analyzeCompoundingEffectiveness(startDate, endDate) {
    // Compare auto-compounding results vs theoretical manual compounding
    const positions = Array.from(this.compounder.activePositions.values());
    const effectiveness = {
      autoCompoundingReturn: 0,
      manualCompoundingReturn: 0,
      compoundingBenefit: 0,
      optimalCompoundFrequency: {},
      compoundingEfficiency: 0
    };
    
    let totalAutoReturn = 0;
    let totalManualReturn = 0;
    let positionCount = 0;
    
    for (const position of positions) {
      const positionAnalysis = await this.analyzePositionCompounding(position, startDate, endDate);
      
      totalAutoReturn += positionAnalysis.autoReturn;
      totalManualReturn += positionAnalysis.manualReturn;
      positionCount++;
      
      // Track optimal frequencies
      const vaultType = position.vault.category;
      if (!effectiveness.optimalCompoundFrequency[vaultType]) {
        effectiveness.optimalCompoundFrequency[vaultType] = [];
      }
      effectiveness.optimalCompoundFrequency[vaultType].push(
        positionAnalysis.optimalFrequency
      );
    }
    
    if (positionCount > 0) {
      effectiveness.autoCompoundingReturn = totalAutoReturn / positionCount;
      effectiveness.manualCompoundingReturn = totalManualReturn / positionCount;
      effectiveness.compoundingBenefit = effectiveness.autoCompoundingReturn - effectiveness.manualCompoundingReturn;
      effectiveness.compoundingEfficiency = effectiveness.autoCompoundingReturn / effectiveness.manualCompoundingReturn;
    }
    
    // Calculate optimal frequencies by vault type
    for (const [vaultType, frequencies] of Object.entries(effectiveness.optimalCompoundFrequency)) {
      effectiveness.optimalCompoundFrequency[vaultType] = 
        frequencies.reduce((sum, freq) => sum + freq, 0) / frequencies.length;
    }
    
    return effectiveness;
  }

  async compareAgainstBenchmarks(startDate, endDate) {
    const benchmarks = {
      'manual-compounding': await this.calculateManualCompoundingBenchmark(startDate, endDate),
      'simple-hodling': await this.calculateSimpleHodlingBenchmark(startDate, endDate),
      'traditional-savings': 0.02, // 2% APY traditional savings
      'defi-average': await this.getDeFiAverageBenchmark(startDate, endDate)
    };
    
    const ourPerformance = await this.calculateOurPerformance(startDate, endDate);
    
    const comparison = {};
    for (const [benchmarkName, benchmarkReturn] of Object.entries(benchmarks)) {
      comparison[benchmarkName] = {
        benchmark: benchmarkReturn,
        ourPerformance,
        outperformance: ourPerformance - benchmarkReturn,
        outperformanceRatio: ourPerformance / benchmarkReturn
      };
    }
    
    return comparison;
  }

  async generateRecommendations(startDate, endDate) {
    const recommendations = [];
    
    // Analyze gas efficiency
    const gasAnalysis = await this.analyzeGasEfficiency(startDate, endDate);
    if (gasAnalysis.gasToRewardRatio > 0.05) { // 5% threshold
      recommendations.push({
        type: 'GAS_OPTIMIZATION',
        priority: 'HIGH',
        description: 'Gas costs are consuming more than 5% of rewards',
        suggestion: 'Consider batching compounds or increasing compound threshold',
        potentialSavings: gasAnalysis.potentialSavings
      });
    }
    
    // Analyze compound frequency
    const compoundingAnalysis = await this.analyzeCompoundingEffectiveness(startDate, endDate);
    if (compoundingAnalysis.compoundingEfficiency < 1.1) { // Less than 10% improvement
      recommendations.push({
        type: 'FREQUENCY_OPTIMIZATION',
        priority: 'MEDIUM',
        description: 'Compounding frequency may not be optimal',
        suggestion: 'Adjust compounding frequency based on vault-specific analysis',
        potentialImprovement: '2-5% APY increase'
      });
    }
    
    // Analyze vault allocation
    const vaultPerformance = await this.calculateVaultPerformance(startDate, endDate);
    const underperformingVaults = Object.entries(vaultPerformance)
      .filter(([_, performance]) => performance.relativePerformance < -0.02) // 2% underperformance
      .map(([vaultId]) => vaultId);
    
    if (underperformingVaults.length > 0) {
      recommendations.push({
        type: 'VAULT_REALLOCATION',
        priority: 'MEDIUM',
        description: `${underperformingVaults.length} vaults are underperforming`,
        suggestion: 'Consider reallocating to better performing alternatives',
        affectedVaults: underperformingVaults
      });
    }
    
    return recommendations;
  }
}

// Key optimizations for auto-compounding systems
class AutoCompoundingOptimizations {
  
  // Dynamic gas pricing based on reward ratios
  calculateOptimalGasPrice(pendingRewards, baseGasPrice) {
    const rewardValue = pendingRewards; // in USD equivalent
    const maxGasSpend = rewardValue.mul(5).div(100); // 5% of rewards max
    
    return Math.min(baseGasPrice, maxGasSpend.div(21000)); // 21k gas estimate
  }

  // Compound frequency optimization by vault type
  getOptimalCompoundFrequency(vaultType, currentAPY, gasEfficiency) {
    const baseFrequencies = {
      'stable-lp': 6, // hours
      'stable-lending': 12,
      'stable-farming': 8,
      'stable-arbitrage': 2
    };
    
    const base = baseFrequencies[vaultType] || 8;
    
    // Adjust based on APY (higher APY = more frequent)
    const apyMultiplier = Math.max(0.5, Math.min(2.0, currentAPY / 0.1));
    
    // Adjust based on gas efficiency (lower efficiency = less frequent)
    const gasMultiplier = Math.max(0.3, gasEfficiency);
    
    return base / (apyMultiplier * gasMultiplier);
  }

  // Intelligent vault migration logic
  shouldMigrateVault(currentVault, alternativeVault, migrationCost) {
    const yieldDifference = alternativeVault.apy - currentVault.apy;
    const breakEvenTime = migrationCost / (yieldDifference * currentVault.balance);
    
    // Only migrate if break-even is less than 30 days
    return breakEvenTime < 30 && yieldDifference > 0.02; // 2% minimum improvement
  }
}