Upload 10 files

backend.py

@@ -0,0 +1,112 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from parallel_miner_v3 import ParallelMiner
+import threading
+from typing import Dict, Optional
+import uvicorn
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="Mining Dashboard API")
+
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, replace with your frontend URL
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global variables for mining state
+miner_instance: Optional[ParallelMiner] = None
+mining_thread: Optional[threading.Thread] = None
+is_mining = False
+
+@app.get("/status")  # Remove /api prefix since we're mounting at /api
+async def get_status() -> Dict:
+    """Get current mining status and statistics"""
+    global miner_instance, is_mining
+    
+    logger.info("Status endpoint called")
+    try:
+        if not miner_instance:
+            logger.info("No miner instance found, returning default values")
+            return {
+                "status": "Stopped",
+                "hashrate": 0,
+                "total_hashes": 0,
+                "blocks_found": 0,
+                "best_hash": None,
+                "difficulty": 0
+            }
+        
+        stats = {
+            "status": "Running" if is_mining else "Stopped",
+            "hashrate": round(miner_instance.current_hashrate / 1000, 2),  # KH/s
+            "total_hashes": miner_instance.total_hashes,
+            "blocks_found": miner_instance.blocks_found,
+            "best_hash": miner_instance.best_hash.hex() if miner_instance.best_hash else None,
+            "difficulty": miner_instance.best_hash_difficulty
+        }
+        logger.info(f"Returning stats: {stats}")
+        return stats
+    except Exception as e:
+        logger.error(f"Error getting status: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/start")  # Remove /api prefix since we're mounting at /api
+async def start_mining() -> Dict:
+    """Start the mining process"""
+    global miner_instance, mining_thread, is_mining
+    
+    logger.info("Start mining endpoint called")
+    
+    if is_mining:
+        logger.warning("Mining is already running")
+        raise HTTPException(status_code=400, detail="Mining is already running")
+    
+    try:
+        logger.info("Initializing miner...")
+        miner_instance = ParallelMiner(num_cores=5)
+        miner_instance.mining = True
+        is_mining = True
+        
+        # Start mining in background thread
+        logger.info("Starting mining thread...")
+        mining_thread = threading.Thread(
+            target=miner_instance.start_mining,
+            kwargs={"duration": None}
+        )
+        mining_thread.daemon = True
+        mining_thread.start()
+        
+        logger.info("Mining started successfully")
+        return {"message": "Mining started successfully"}
+    except Exception as e:
+        logger.error(f"Error starting mining: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/stop")
+async def stop_mining() -> Dict:
+    """Stop the mining process"""
+    global miner_instance, is_mining
+    
+    if not is_mining:
+        raise HTTPException(status_code=400, detail="Mining is not running")
+    
+    try:
+        if miner_instance:
+            miner_instance.mining = False
+            is_mining = False
+            return {"message": "Mining stopped successfully"}
+        raise HTTPException(status_code=400, detail="No active mining instance found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

requirements.txt

@@ -0,0 +1,8 @@
+transformers>=4.30.0
+torch>=2.0.0
+pillow>=9.0.0
+numpy>=1.24.0
+fastapi
+plotly
+tqdm
+accelerate

static/css/style.css

@@ -0,0 +1,141 @@
+:root {
+    --primary-color: #2ecc71;
+    --secondary-color: #3498db;
+    --background-color: #1a1a1a;
+    --card-background: #2d2d2d;
+    --text-color: #ffffff;
+    --danger-color: #e74c3c;
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    background-color: var(--background-color);
+    color: var(--text-color);
+    line-height: 1.6;
+}
+
+.container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 20px;
+}
+
+header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 30px;
+}
+
+h1 {
+    font-size: 2.5rem;
+    font-weight: 700;
+}
+
+.controls {
+    display: flex;
+    gap: 10px;
+}
+
+.btn {
+    padding: 12px 24px;
+    border: none;
+    border-radius: 8px;
+    font-size: 1rem;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.3s ease;
+}
+
+.btn.primary {
+    background-color: var(--primary-color);
+    color: white;
+}
+
+.btn.secondary {
+    background-color: var(--secondary-color);
+    color: white;
+}
+
+.btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 5px 15px rgba(0, 0, 0, 0.3);
+}
+
+.alert-box {
+    background-color: var(--card-background);
+    padding: 20px;
+    border-radius: 10px;
+    margin-bottom: 30px;
+    text-align: center;
+    font-size: 1.2rem;
+    font-weight: 600;
+    border-left: 5px solid var(--primary-color);
+}
+
+.alert-box.success {
+    border-left-color: var(--primary-color);
+}
+
+.stats-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+    gap: 20px;
+    margin-bottom: 30px;
+}
+
+.stat-card {
+    background-color: var(--card-background);
+    padding: 20px;
+    border-radius: 10px;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+}
+
+.stat-card h3 {
+    font-size: 1.1rem;
+    color: #888;
+    margin-bottom: 10px;
+}
+
+.stat-card p {
+    font-size: 1.4rem;
+    font-weight: 600;
+}
+
+.hash {
+    font-family: monospace;
+    font-size: 1rem !important;
+    word-break: break-all;
+}
+
+.charts {
+    display: grid;
+    grid-template-columns: 1fr;
+    gap: 20px;
+}
+
+#hashrateChart,
+#totalHashesChart {
+    background-color: var(--card-background);
+    border-radius: 10px;
+    padding: 20px;
+    height: 400px;
+}
+
+@media (max-width: 768px) {
+    header {
+        flex-direction: column;
+        gap: 20px;
+        text-align: center;
+    }
+
+    .stats-grid {
+        grid-template-columns: 1fr;
+    }
+}

static/index.html

@@ -0,0 +1,58 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Bitcoin Mining Dashboard</title>
+    <link rel="stylesheet" href="css/style.css">
+    <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>⛏️ Bitcoin Mining Dashboard</h1>
+            <div class="controls">
+                <button id="startMining" class="btn primary">▶️ Start Mining</button>
+                <button id="stopMining" class="btn secondary">⏹️ Stop Mining</button>
+            </div>
+        </header>
+
+        <div class="alert-box" id="blockAlert">
+            No blocks found yet
+        </div>
+
+        <div class="stats-grid">
+            <div class="stat-card">
+                <h3>Status</h3>
+                <p id="status">Stopped</p>
+            </div>
+            <div class="stat-card">
+                <h3>Hashrate</h3>
+                <p id="hashrate">0 H/s</p>
+            </div>
+            <div class="stat-card">
+                <h3>Total Hashes</h3>
+                <p id="totalHashes">0</p>
+            </div>
+            <div class="stat-card">
+                <h3>Blocks Found</h3>
+                <p id="blocksFound">0</p>
+            </div>
+            <div class="stat-card">
+                <h3>Best Hash</h3>
+                <p id="bestHash" class="hash">None</p>
+            </div>
+            <div class="stat-card">
+                <h3>Best Difficulty</h3>
+                <p id="difficulty">0</p>
+            </div>
+        </div>
+
+        <div class="charts">
+            <div id="hashrateChart"></div>
+            <div id="totalHashesChart"></div>
+        </div>
+    </div>
+    <script src="js/main.js"></script>
+</body>
+</html>

static/js/main.js

@@ -0,0 +1,142 @@
+class MiningDashboard {
+    constructor() {
+        this.statsHistory = {
+            timestamps: [],
+            hashrates: [],
+            totalHashes: [],
+            blocksFound: []
+        };
+        this.setupEventListeners();
+        this.setupCharts();
+        this.startAutoRefresh();
+    }
+
+    setupEventListeners() {
+        document.getElementById('startMining').addEventListener('click', () => this.startMining());
+        document.getElementById('stopMining').addEventListener('click', () => this.stopMining());
+    }
+
+    setupCharts() {
+        // Initialize empty charts
+        this.hashrateChart = Plotly.newPlot('hashrateChart', [{
+            x: [],
+            y: [],
+            type: 'scatter',
+            mode: 'lines+markers',
+            name: 'Hashrate',
+            line: { color: '#2ecc71' }
+        }], {
+            title: 'Mining Hashrate (KH/s)',
+            template: 'plotly_dark',
+            paper_bgcolor: '#2d2d2d',
+            plot_bgcolor: '#2d2d2d',
+            xaxis: { title: 'Time' },
+            yaxis: { title: 'Hashrate (KH/s)' }
+        });
+
+        this.totalHashesChart = Plotly.newPlot('totalHashesChart', [{
+            x: [],
+            y: [],
+            type: 'scatter',
+            mode: 'lines',
+            name: 'Total Hashes',
+            line: { color: '#3498db' }
+        }], {
+            title: 'Total Hashes',
+            template: 'plotly_dark',
+            paper_bgcolor: '#2d2d2d',
+            plot_bgcolor: '#2d2d2d',
+            xaxis: { title: 'Time' },
+            yaxis: { title: 'Total Hashes' }
+        });
+    }
+
+    async startMining() {
+        try {
+            const response = await fetch('/start_mining', { method: 'POST' });
+            const data = await response.json();
+            this.updateStatus(data.message);
+        } catch (error) {
+            console.error('Error starting mining:', error);
+            this.updateStatus('Error starting mining');
+        }
+    }
+
+    async stopMining() {
+        try {
+            const response = await fetch('/stop_mining', { method: 'POST' });
+            const data = await response.json();
+            this.updateStatus(data.message);
+        } catch (error) {
+            console.error('Error stopping mining:', error);
+            this.updateStatus('Error stopping mining');
+        }
+    }
+
+    async updateStats() {
+        try {
+            const response = await fetch('/get_stats');
+            const stats = await response.json();
+            
+            // Update stats display
+            document.getElementById('status').textContent = stats.status;
+            document.getElementById('hashrate').textContent = stats.hashrate;
+            document.getElementById('totalHashes').textContent = stats.total_hashes;
+            document.getElementById('blocksFound').textContent = stats.blocks_found;
+            document.getElementById('bestHash').textContent = stats.best_hash;
+            document.getElementById('difficulty').textContent = stats.difficulty;
+            
+            // Update block alert
+            const alertBox = document.getElementById('blockAlert');
+            alertBox.textContent = stats.block_alert;
+            alertBox.className = 'alert-box' + (stats.blocks_found > 0 ? ' success' : '');
+
+            // Update charts
+            if (stats.status === 'Running') {
+                this.updateCharts(stats);
+            }
+        } catch (error) {
+            console.error('Error updating stats:', error);
+        }
+    }
+
+    updateCharts(stats) {
+        const currentTime = new Date().toLocaleTimeString();
+        
+        // Update history
+        this.statsHistory.timestamps.push(currentTime);
+        this.statsHistory.hashrates.push(parseFloat(stats.hashrate));
+        this.statsHistory.totalHashes.push(parseInt(stats.total_hashes.replace(/,/g, '')));
+        
+        // Keep only last 100 points
+        if (this.statsHistory.timestamps.length > 100) {
+            this.statsHistory.timestamps.shift();
+            this.statsHistory.hashrates.shift();
+            this.statsHistory.totalHashes.shift();
+        }
+
+        // Update plots
+        Plotly.update('hashrateChart', {
+            x: [this.statsHistory.timestamps],
+            y: [this.statsHistory.hashrates]
+        });
+
+        Plotly.update('totalHashesChart', {
+            x: [this.statsHistory.timestamps],
+            y: [this.statsHistory.totalHashes]
+        });
+    }
+
+    startAutoRefresh() {
+        setInterval(() => this.updateStats(), 1000);
+    }
+
+    updateStatus(message) {
+        document.getElementById('status').textContent = message;
+    }
+}
+
+// Initialize dashboard when page loads
+document.addEventListener('DOMContentLoaded', () => {
+    window.dashboard = new MiningDashboard();
+});