Small-Scale Mining Rig Setup

// Small-Scale Mining Rig Configuration Tool
class MiningRigConfigurator {
    constructor() {
        this.availableMiners = {
            // Entry-level options
            'antminer-s19j-pro': {
                name: 'Antminer S19j Pro',
                hashRate: 96, // TH/s
                powerConsumption: 3068, // W
                price: 3500,
                noiseLevel: 75, // dB
                weight: 13.2, // kg
                dimensions: { width: 195, depth: 290, height: 400 } // mm
            },
            'whatsminer-m30s': {
                name: 'Whatsminer M30S',
                hashRate: 100, // TH/s
                powerConsumption: 3400, // W
                price: 2800,
                noiseLevel: 78, // dB
                weight: 15.3, // kg
                dimensions: { width: 200, depth: 295, height: 415 }
            },
            // Mid-range options
            'antminer-s19-pro': {
                name: 'Antminer S19 Pro',
                hashRate: 110, // TH/s
                powerConsumption: 3250, // W
                price: 6000,
                noiseLevel: 75, // dB
                weight: 15.5, // kg
                dimensions: { width: 195, depth: 290, height: 400 }
            }
        };
        
        this.siteConstraints = {
            maxPower: 5000, // Watts available
            maxNoise: 80, // dB limit
            maxWeight: 100, // kg floor load
            space: { width: 2000, depth: 2000, height: 2000 } // mm
        };
    }
    
    configureOptimalRig(budget = 10000, constraints = this.siteConstraints) {
        const configurations = [];
        
        // Try different combinations
        for (const [minerId, miner] of Object.entries(this.availableMiners)) {
            const maxUnits = Math.floor(budget / miner.price);
            
            for (let units = 1; units <= Math.min(maxUnits, 5); units++) {
                const config = this.evaluateConfiguration(miner, units, constraints);
                if (config.feasible) {
                    configurations.push(config);
                }
            }
        }
        
        // Sort by efficiency and total hash rate
        configurations.sort((a, b) => {
            const efficiencyA = a.totalHashRate / (a.totalPowerConsumption / 1000); // TH/s per kW
            const efficiencyB = b.totalHashRate / (b.totalPowerConsumption / 1000);
            return efficiencyB - efficiencyA;
        });
        
        return {
            recommended: configurations[0],
            alternatives: configurations.slice(1, 4),
            allOptions: configurations
        };
    }
    
    evaluateConfiguration(miner, units, constraints) {
        const totalHashRate = miner.hashRate * units;
        const totalPowerConsumption = miner.powerConsumption * units;
        const totalPrice = miner.price * units;
        const totalWeight = miner.weight * units;
        
        // Check constraints
        const powerOK = totalPowerConsumption <= constraints.maxPower;
        const noiseOK = miner.noiseLevel <= constraints.maxNoise;
        const weightOK = totalWeight <= constraints.maxWeight;
        const spaceOK = this.checkSpaceConstraints(miner, units, constraints.space);
        
        const feasible = powerOK && noiseOK && weightOK && spaceOK;
        
        return {
            miner: miner,
            units: units,
            totalHashRate: totalHashRate,
            totalPowerConsumption: totalPowerConsumption,
            totalPrice: totalPrice,
            totalWeight: totalWeight,
            feasible: feasible,
            efficiency: totalHashRate / (totalPowerConsumption / 1000), // TH/s per kW
            dailyBitcoinEst: this.estimateDailyBitcoin(totalHashRate)
        };
    }
    
    checkSpaceConstraints(miner, units, availableSpace) {
        // Simple space check - in practice, need to consider spacing between units
        const requiredWidth = miner.dimensions.width * Math.ceil(Math.sqrt(units));
        const requiredDepth = miner.dimensions.depth * Math.ceil(units / Math.ceil(Math.sqrt(units)));
        
        return requiredWidth <= availableSpace.width && requiredDepth <= availableSpace.depth;
    }
    
    estimateDailyBitcoin(totalHashRate) {
        // Simplified estimation
        const networkHashRate = 175000; // PH/s
        const blocksPerDay = 144;
        const blockReward = 6.25;
        const hashShare = (totalHashRate * 1000) / (networkHashRate * 1000);
        return blocksPerDay * blockReward * hashShare;
    }
}

// Usage example
const configurator = new MiningRigConfigurator();
const recommendations = configurator.configureOptimalRig(15000, {
    maxPower: 8000,
    maxNoise: 75,
    maxWeight: 200,
    space: { width: 3000, depth: 3000, height: 2500 }
});

console.log('Recommended Configuration:', recommendations.recommended);