Advanced Cost Calculators & Analysis

// Advanced Mining Cost Analysis Calculator
class AdvancedMiningCalculator {
    constructor() {
        this.assumptions = {
            btcPrice: 45000,
            electricityRate: 0.12, // $/kWh
            inflationRate: 0.03, // 3% annual
            discountRate: 0.10, // 10% for NPV
            equipmentDepreciation: 0.20, // 20% annual
            maintenanceRate: 0.05, // 5% of hardware cost annually
            poolFee: 0.01, // 1%
            networkGrowthRate: 0.08 // 8% monthly difficulty increase
        };
    }
    
    performComprehensiveAnalysis(config, months = 36) {
        const {
            miners,
            initialInvestment,
            electricityRate = this.assumptions.electricityRate,
            btcPrice = this.assumptions.btcPrice
        } = config;
        
        const analysis = {
            scenario: this.generateScenarios(btcPrice),
            monthlyProjections: [],
            summary: {},
            sensitivityAnalysis: {},
            riskMetrics: {}
        };
        
        // Generate monthly projections for each scenario
        for (const [scenarioName, scenario] of Object.entries(analysis.scenario)) {
            const scenarioData = this.calculateScenario(miners, initialInvestment, electricityRate, scenario, months);
            analysis.monthlyProjections.push({
                scenario: scenarioName,
                data: scenarioData
            });
        }
        
        analysis.summary = this.calculateSummary(analysis.monthlyProjections);
        analysis.sensitivityAnalysis = this.performSensitivityAnalysis(miners, initialInvestment, electricityRate);
        analysis.riskMetrics = this.calculateRiskMetrics(analysis.monthlyProjections);
        
        return analysis;
    }
    
    generateScenarios(basePrice) {
        return {
            conservative: {
                monthlyPriceGrowth: -0.01, // -1%
                monthlyDifficultyGrowth: 0.08,
                probability: 0.3
            },
            moderate: {
                monthlyPriceGrowth: 0.04, // +4%
                monthlyDifficultyGrowth: 0.10,
                probability: 0.5
            },
            optimistic: {
                monthlyPriceGrowth: 0.08, // +8%
                monthlyDifficultyGrowth: 0.12,
                probability: 0.2
            }
        };
    }
    
    calculateScenario(miners, initialInvestment, electricityRate, scenario, months) {
        const monthlyData = [];
        let cumulativeCashFlow = -initialInvestment;
        let totalDepreciation = 0;
        
        for (let month = 1; month <= months; month++) {
            // Calculate current Bitcoin price and difficulty
            const currentPrice = this.assumptions.btcPrice * 
                Math.pow(1 + scenario.monthlyPriceGrowth, month);
            const currentDifficulty = Math.pow(1 + scenario.monthlyDifficultyGrowth, month);
            
            // Calculate monthly mining revenue
            let monthlyRevenue = 0;
            let monthlyCosts = 0;
            
            miners.forEach(miner => {
                const efficiency = this.calculateMiningEfficiency(miner, currentDifficulty);
                const monthlyBitcoin = this.calculateMonthlyBitcoin(miner, efficiency);
                const minerRevenue = monthlyBitcoin * currentPrice;
                const minerPoolFee = minerRevenue * this.assumptions.poolFee;
                const minerElectricity = this.calculateMonthlyElectricity(miner, electricityRate);
                
                monthlyRevenue += minerRevenue - minerPoolFee;
                monthlyCosts += minerElectricity;
            });
            
            // Calculate other costs
            const maintenanceCost = initialInvestment * this.assumptions.maintenanceRate / 12;
            const depreciation = initialInvestment * this.assumptions.equipmentDepreciation / 12;
            
            monthlyCosts += maintenanceCost;
            totalDepreciation += depreciation;
            
            const monthlyProfit = monthlyRevenue - monthlyCosts;
            cumulativeCashFlow += monthlyProfit;
            
            // Calculate NPV for this month
            const npv = this.calculateNPV(cumulativeCashFlow, month);
            
            monthlyData.push({
                month: month,
                btcPrice: Math.round(currentPrice),
                monthlyRevenue: Math.round(monthlyRevenue),
                monthlyCosts: Math.round(monthlyCosts),
                monthlyProfit: Math.round(monthlyProfit),
                cumulativeCashFlow: Math.round(cumulativeCashFlow),
                totalDepreciation: Math.round(totalDepreciation),
                npv: Math.round(npv),
                roi: initialInvestment > 0 ? Math.round((cumulativeCashFlow / initialInvestment) * 100) : 0
            });
        }
        
        return monthlyData;
    }
    
    calculateMiningEfficiency(miner, difficultyMultiplier) {
        // Simplified efficiency calculation
        return Math.max(0.1, 1 / Math.pow(difficultyMultiplier, 0.5));
    }
    
    calculateMonthlyBitcoin(miner, efficiency) {
        // Base calculation adjusted by efficiency
        const baseDaily = (miner.hashRate / 175000) * 144 * 6.25; // Simplified
        return baseDaily * 30 * efficiency;
    }
    
    calculateMonthlyElectricity(miner, rate) {
        const dailyKWh = (miner.powerConsumption * 24) / 1000;
        return dailyKWh * rate * 30;
    }
    
    calculateNPV(cashFlow, month) {
        const rate = this.assumptions.discountRate / 12; // Monthly rate
        return cashFlow / Math.pow(1 + rate, month);
    }
    
    performSensitivityAnalysis(miners, initialInvestment, electricityRate) {
        const sensitivity = {};
        const baseConfig = { miners, initialInvestment, electricityRate, btcPrice: 45000 };
        const baseAnalysis = this.performComprehensiveAnalysis(baseConfig, 12);
        
        // Test different electricity rates
        const electricityRates = [0.08, 0.10, 0.12, 0.15, 0.20];
        sensitivity.electricityRate = electricityRates.map(rate => ({
            rate: rate,
            impact: this.calculateRateImpact(baseConfig, { electricityRate: rate })
        }));
        
        // Test different Bitcoin prices
        const btcPrices = [30000, 40000, 50000, 60000, 70000];
        sensitivity.btcPrice = btcPrices.map(price => ({
            price: price,
            impact: this.calculateRateImpact(baseConfig, { btcPrice: price })
        }));
        
        return sensitivity;
    }
    
    calculateRateImpact(baseConfig, changes) {
        const modifiedConfig = { ...baseConfig, ...changes };
        const analysis = this.performComprehensiveAnalysis(modifiedConfig, 12);
        const summary = analysis.summary.moderate;
        return {
            twelveMonthROI: summary.roi,
            breakEvenMonths: summary.breakEvenMonths,
            npv: summary.npv
        };
    }
    
    calculateSummary(projections) {
        const summary = {};
        
        projections.forEach(projection => {
            const lastMonth = projection.data[projection.data.length - 1];
            summary[projection.scenario] = {
                roi: lastMonth.roi,
                npv: lastMonth.npv,
                breakEvenMonths: this.findBreakEven(projection.data),
                finalCashFlow: lastMonth.cumulativeCashFlow
            };
        });
        
        return summary;
    }
    
    findBreakEven(monthlyData) {
        for (let data of monthlyData) {
            if (data.cumulativeCashFlow >= 0) {
                return data.month;
            }
        }
        return null;
    }
    
    calculateRiskMetrics(projections) {
        const rois = projections.map(p => p.data[p.data.length - 1].roi);
        const probabilities = projections.map(p => this.generateScenarios()[p.scenario].probability);
        
        // Expected ROI (probability weighted)
        const expectedROI = rois.reduce((sum, roi, i) => sum + (roi * probabilities[i]), 0);
        
        // Risk (standard deviation)
        const variance = rois.reduce((sum, roi, i) => sum + probabilities[i] * Math.pow(roi - expectedROI, 2), 0);
        const risk = Math.sqrt(variance);
        
        return {
            expectedROI: Math.round(expectedROI),
            risk: Math.round(risk),
            probabilityOfLoss: probabilities.reduce((sum, prob, i) => rois[i] < 0 ? sum + prob : sum, 0)
        };
    }
}

// Usage example
const calculator = new AdvancedMiningCalculator();
const config = {
    miners: [{ hashRate: 96, powerConsumption: 3068 }],
    initialInvestment: 4000,
    electricityRate: 0.12,
    btcPrice: 45000
};

const analysis = calculator.performComprehensiveAnalysis(config, 24);
console.log('Comprehensive Mining Analysis:', analysis);