Profitability Models & Analysis

// Advanced Bitcoin Mining Profitability Calculator
class MiningProfitabilityCalculator {
    constructor(scenario = 'moderate') {
        this.scenario = scenario;
        this.currentBTCPrice = 45000;
        this.currentDifficulty = 28000000000000000;
        this.currentHashRate = 175000; // PH/s
        
        // Scenario assumptions
        this.scenarios = {
            conservative: {
                monthlyPriceChange: -0.02, // -2% monthly
                monthlyDifficultyIncrease: 0.05, // +5% monthly
                monthlyHashRateGrowth: 0.03
            },
            moderate: {
                monthlyPriceChange: 0.03, // +3% monthly
                monthlyDifficultyIncrease: 0.08, // +8% monthly
                monthlyHashRateGrowth: 0.05
            },
            optimistic: {
                monthlyPriceChange: 0.08, // +8% monthly
                monthlyDifficultyIncrease: 0.12, // +12% monthly
                monthlyHashRateGrowth: 0.10
            }
        };
    }
    
    calculateMiningProfitability(miner, months = 24) {
        const {
            hashRate, // TH/s
            powerConsumption, // Watts
            purchasePrice,
            efficiency,
            poolFee = 0.01 // 1% pool fee
        } = miner;
        
        const scenario = this.scenarios[this.scenario];
        const results = [];
        let cumulativeProfit = -purchasePrice; // Start with negative (investment)
        
        for (let month = 1; month <= months; month++) {
            // Projected values for this month
            const projectedBTCPrice = this.currentBTCPrice * 
                Math.pow(1 + scenario.monthlyPriceChange, month);
            
            const projectedDifficulty = this.currentDifficulty * 
                Math.pow(1 + scenario.monthlyDifficultyIncrease, month);
            
            const projectedHashRate = this.currentHashRate * 
                Math.pow(1 + scenario.monthlyHashRateGrowth, month);
            
            // Calculate monthly Bitcoin earnings
            const dailyBitcoin = this.calculateDailyBitcoin(hashRate, projectedHashRate, projectedDifficulty);
            const monthlyBitcoin = dailyBitcoin * 30;
            
            // Revenue and costs
            const monthlyRevenue = monthlyBitcoin * projectedBTCPrice;
            const monthlyPowerCost = this.calculateMonthlyPowerCost(powerConsumption);
            const monthlyPoolFee = monthlyRevenue * poolFee;
            
            const monthlyProfit = monthlyRevenue - monthlyPowerCost - monthlyPoolFee;
            cumulativeProfit += monthlyProfit;
            
            results.push({
                month: month,
                btcPrice: Math.round(projectedBTCPrice),
                difficulty: Math.round(projectedDifficulty / 1e12), // Convert to readable format
                dailyBitcoin: dailyBitcoin,
                monthlyRevenue: Math.round(monthlyRevenue),
                monthlyCosts: Math.round(monthlyPowerCost + monthlyPoolFee),
                monthlyProfit: Math.round(monthlyProfit),
                cumulativeProfit: Math.round(cumulativeProfit),
                roi: purchasePrice > 0 ? Math.round((cumulativeProfit / purchasePrice) * 100) : 0
            });
        }
        
        return {
            scenario: this.scenario,
            totalInvestment: purchasePrice,
            finalCumulativeProfit: Math.round(cumulativeProfit),
            totalROI: purchasePrice > 0 ? Math.round((cumulativeProfit / purchasePrice) * 100) : 0,
            paybackMonths: this.findPaybackMonth(results),
            monthlyBreakdown: results
        };
    }
    
    calculateDailyBitcoin(hashRate, networkHashRate, difficulty) {
        const blocksPerDay = 144;
        const blockReward = 6.25;
        const hashShare = (hashRate * 1000) / (networkHashRate * 1000);
        return blocksPerDay * blockReward * hashShare;
    }
    
    calculateMonthlyPowerCost(powerConsumption, electricityRate = 0.12) {
        const dailyKWh = (powerConsumption * 24) / 1000;
        return dailyKWh * electricityRate * 30;
    }
    
    findPaybackMonth(results) {
        for (let result of results) {
            if (result.cumulativeProfit >= 0) {
                return result.month;
            }
        }
        return null; // Never reaches payback
    }
}

// Example usage with different scenarios
const miner = {
    hashRate: 110, // TH/s
    powerConsumption: 3250, // Watts
    purchasePrice: 8000, // USD
    efficiency: 29.5 // J/TH
};

// Conservative scenario
const conservativeCalc = new MiningProfitabilityCalculator('conservative');
const conservativeResults = conservativeCalc.calculateMiningProfitability(miner, 18);

console.log('Conservative Scenario Results:', conservativeResults);