Spaces:

Fred808
/

MINIM

Paused

App Files Files Community

Fred808 commited on Oct 4, 2025

Commit

eec79a3

verified ·

1 Parent(s): 15eb827

Upload 5 files

Browse files

Files changed (3) hide show

app.py +294 -69
parallel_miner_v3.py +578 -333
static/index.html +309 -40

app.py CHANGED Viewed

@@ -1,14 +1,22 @@
 """
-FastAPI server for Bitcoin mining dashboard
 """
-from fastapi import FastAPI, HTTPException
 from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse
 import uvicorn
-from parallel_miner_v3 import ParallelMiner
 import threading
-from typing import Dict, Optional
 import logging
 # Configure logging
 logging.basicConfig(
@@ -16,76 +24,206 @@ logging.basicConfig(
     format='%(asctime)s - %(levelname)s - %(message)s'
 )
-app = FastAPI(title="Bitcoin Mining Dashboard")
 # Mount static files
 app.mount("/static", StaticFiles(directory="static"), name="static")
-app.mount("/css", StaticFiles(directory="static/css"), name="css")
-app.mount("/js", StaticFiles(directory="static/js"), name="js")
-# Global state
-miner_instance: Optional[ParallelMiner] = None
-mining_thread: Optional[threading.Thread] = None
-is_mining: bool = False
-@app.get("/")
 async def get_index():
     """Serve the dashboard HTML"""
-    return FileResponse("static/index.html")
 @app.post("/start_mining")
-async def start_mining():
     """Start the mining process"""
-    global miner_instance, mining_thread, is_mining
-    if is_mining:
         raise HTTPException(status_code=400, detail="Mining is already running")
     try:
-        miner_instance = ParallelMiner(num_cores=5)
-        miner_instance.mining = True
-        is_mining = True
         # Start mining in background thread
-        mining_thread = threading.Thread(
-            target=miner_instance.start_mining,
-            kwargs={"duration": None}
         )
-        mining_thread.daemon = True
-        mining_thread.start()
-        return {"message": "Mining started successfully"}
     except Exception as e:
         logging.error(f"Error starting mining: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 @app.post("/stop_mining")
 async def stop_mining():
     """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:
-            # Log final stats
-            logging.info("\n=== Final Mining Statistics ===")
-            grand_total = 0
-            for core_idx, core in enumerate(miner_instance.cores):
-                core_total = core.total_hashes
-                grand_total += core_total
-                logging.info(f"Core {core_idx}: {core_total:,} hashes")
-            logging.info(f"Grand Total: {grand_total:,} hashes")
-            logging.info(f"Overall Hashrate: {miner_instance.current_hashrate/1000:.2f} KH/s")
-            logging.info(f"Blocks Found: {miner_instance.blocks_found}")
-            logging.info("============================\n")
-            miner_instance.mining = False
-            is_mining = False
-            return {"message": "Mining stopped successfully"}
         raise HTTPException(status_code=400, detail="No active mining instance")
     except Exception as e:
         logging.error(f"Error stopping mining: {e}")
         raise HTTPException(status_code=500, detail=str(e))
@@ -93,45 +231,132 @@ async def stop_mining():
 @app.get("/get_stats")
 async def get_mining_stats():
     """Get current mining statistics"""
-    global miner_instance, is_mining
-    if not miner_instance or not is_mining:
         return {
-            "status": "Stopped",
             "hashrate": "0 H/s",
             "total_hashes": "0",
             "blocks_found": "0",
-            "best_hash": "None",
             "difficulty": "0",
-            "block_alert": "Mining stopped"
         }
-    # Create block alert message
-    if miner_instance.blocks_found > 0:
-        block_alert = f"🎉 FOUND {miner_instance.blocks_found} BLOCK(S)! Last block hash: {miner_instance.best_hash.hex() if miner_instance.best_hash else 'None'}"
-    else:
-        progress = miner_instance.best_hash_difficulty * 100 if miner_instance.best_hash_difficulty else 0
-        block_alert = f"Mining in progress... Best hash difficulty: {progress:.8f}%"
     return {
-        "status": "Running" if is_mining else "Stopped",
-        "hashrate": f"{miner_instance.current_hashrate/1000:.2f} KH/s",
-        "total_hashes": f"{miner_instance.total_hashes:,}",
-        "blocks_found": str(miner_instance.blocks_found),
-        "best_hash": miner_instance.best_hash.hex() if miner_instance.best_hash else "None",
-        "difficulty": f"{miner_instance.best_hash_difficulty:,}",
-        "block_alert": block_alert
     }
-processing_thread = None
 @app.on_event("startup")
 async def startup_event():
-    global processing_thread
-    if not (processing_thread and processing_thread.is_alive()):
-        processing_thread = threading.Thread(target=get_index())
-        processing_thread.daemon = True
-        processing_thread.start()
 if __name__ == "__main__":
-    uvicorn.run("app", host="0.0.0.0", port=7868, reload=False)

 """
+FastAPI server for Bitcoin mining dashboard - Complete Integration
 """
+from fastapi import FastAPI, HTTPException, BackgroundTasks
 from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse, HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
 import uvicorn
 import threading
+import time
+import json
+import asyncio
+from typing import Dict, Optional, List
 import logging
+import sys
+import os
+# Add the current directory to Python path to import your miner
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 # Configure logging
 logging.basicConfig(
     format='%(asctime)s - %(levelname)s - %(message)s'
 )
+app = FastAPI(title="Bitcoin Mining Dashboard", version="1.0.0")
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 # Mount static files
 app.mount("/static", StaticFiles(directory="static"), name="static")
+# Global mining state
+class MiningState:
+    def __init__(self):
+        self.is_mining = False
+        self.miner_instance = None
+        self.mining_thread = None
+        self.stats = {
+            "status": "Stopped",
+            "hashrate": "0 H/s",
+            "total_hashes": "0",
+            "blocks_found": "0",
+            "best_hash": "None",
+            "difficulty": "0",
+            "network_difficulty": "0",
+            "block_alert": "Ready to start mining",
+            "mining_time": "0s",
+            "cores_active": "0",
+            "wallet_address": "1Ks4WtCEK96BaBF7HSuCGt3rEpVKPqcJKf"
+        }
+        self.start_time = None
+mining_state = MiningState()
+@app.get("/", response_class=HTMLResponse)
 async def get_index():
     """Serve the dashboard HTML"""
+    try:
+        return FileResponse("static/index.html")
+    except:
+        # Fallback minimal HTML
+        return """
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>Bitcoin Mining Dashboard</title>
+            <style>
+                body { font-family: Arial, sans-serif; margin: 40px; background: #f0f0f0; }
+                .container { max-width: 800px; margin: 0 auto; background: white; padding: 20px; border-radius: 10px; }
+                .stats { background: #2c3e50; color: white; padding: 20px; border-radius: 5px; margin: 10px 0; }
+                .alert { background: #e74c3c; color: white; padding: 15px; border-radius: 5px; margin: 10px 0; }
+                .success { background: #27ae60; }
+                .button { background: #3498db; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer; margin: 5px; }
+                .button:disabled { background: #95a5a6; }
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <h1>⛏️ Bitcoin Mining Dashboard</h1>
+                <div id="blockAlert" class="alert">Ready to start mining</div>
+                <div class="stats">
+                    <h3>Mining Statistics</h3>
+                    <div id="statsDisplay"></div>
+                </div>
+                <button class="button" onclick="startMining()" id="startBtn">Start Mining</button>
+                <button class="button" onclick="stopMining()" id="stopBtn" disabled>Stop Mining</button>
+                <script>
+                    function updateStats(stats) {
+                        document.getElementById('statsDisplay').innerHTML = `
+                            <p><strong>Status:</strong> ${stats.status}</p>
+                            <p><strong>Hash Rate:</strong> ${stats.hashrate}</p>
+                            <p><strong>Total Hashes:</strong> ${stats.total_hashes}</p>
+                            <p><strong>Blocks Found:</strong> ${stats.blocks_found}</p>
+                            <p><strong>Best Hash:</strong> ${stats.best_hash}</p>
+                            <p><strong>Mining Time:</strong> ${stats.mining_time}</p>
+                            <p><strong>Wallet:</strong> ${stats.wallet_address}</p>
+                        `;
+                        document.getElementById('blockAlert').textContent = stats.block_alert;
+                        document.getElementById('blockAlert').className = stats.blocks_found > 0 ? 'alert success' : 'alert';
+                        document.getElementById('startBtn').disabled = stats.status === 'Running';
+                        document.getElementById('stopBtn').disabled = stats.status !== 'Running';
+                    }
+                    async function startMining() {
+                        const response = await fetch('/start_mining', { method: 'POST' });
+                        const result = await response.json();
+                        alert(result.message);
+                    }
+                    async function stopMining() {
+                        const response = await fetch('/stop_mining', { method: 'POST' });
+                        const result = await response.json();
+                        alert(result.message);
+                    }
+                    // Poll for stats updates
+                    setInterval(async () => {
+                        const response = await fetch('/get_stats');
+                        const stats = await response.json();
+                        updateStats(stats);
+                    }, 1000);
+                </script>
+            </div>
+        </body>
+        </html>
+        """
+def mining_worker(duration=None):
+    """Worker function to run mining in background thread"""
+    try:
+        # Import and initialize the miner
+        from parallel_miner_v3 import ParallelMiner
+        mining_state.miner_instance = ParallelMiner(
+            num_cores=7,
+            wallet_address="1Ks4WtCEK96BaBF7HSuCGt3rEpVKPqcJKf"
+        )
+        mining_state.start_time = time.time()
+        # Start mining
+        mining_state.miner_instance.start_mining(duration=duration)
+    except Exception as e:
+        logging.error(f"Mining worker error: {e}")
+    finally:
+        mining_state.is_mining = False
+        mining_state.mining_thread = None
 @app.post("/start_mining")
+async def start_mining(background_tasks: BackgroundTasks):
     """Start the mining process"""
+    global mining_state
+    if mining_state.is_mining:
         raise HTTPException(status_code=400, detail="Mining is already running")
     try:
+        mining_state.is_mining = True
+        mining_state.stats["status"] = "Starting..."
+        mining_state.stats["block_alert"] = "🔄 Starting mining process..."
         # Start mining in background thread
+        mining_state.mining_thread = threading.Thread(
+            target=mining_worker,
+            kwargs={"duration": None}  # Mine indefinitely
         )
+        mining_state.mining_thread.daemon = True
+        mining_state.mining_thread.start()
+        logging.info("✅ Mining started via API")
+        return {"message": "Mining started successfully", "status": "started"}
     except Exception as e:
+        mining_state.is_mining = False
         logging.error(f"Error starting mining: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 @app.post("/stop_mining")
 async def stop_mining():
     """Stop the mining process"""
+    global mining_state
+    if not mining_state.is_mining:
         raise HTTPException(status_code=400, detail="Mining is not running")
     try:
+        if mining_state.miner_instance:
+            mining_state.miner_instance.mining = False
+            mining_state.is_mining = False
+            # Log final statistics
+            if hasattr(mining_state.miner_instance, 'total_hashes'):
+                total_hashes = mining_state.miner_instance.total_hashes
+                blocks_found = mining_state.miner_instance.blocks_found
+                mining_time = time.time() - mining_state.start_time
+                logging.info("\n" + "="*50)
+                logging.info("⛏️ FINAL MINING STATISTICS")
+                logging.info("="*50)
+                logging.info(f"⏱️ Total mining time: {mining_time:.2f} seconds")
+                logging.info(f"🔢 Total hashes: {total_hashes:,}")
+                logging.info(f"💰 Blocks found: {blocks_found}")
+                logging.info(f"⚡ Average hash rate: {total_hashes/max(mining_time,1)/1000:.2f} KH/s")
+                if hasattr(mining_state.miner_instance, 'cores'):
+                    for core_idx, core in enumerate(mining_state.miner_instance.cores):
+                        logging.info(f"🔩 Core {core_idx}: {core.total_hashes:,} hashes")
+                logging.info("="*50)
+            mining_state.stats["status"] = "Stopped"
+            mining_state.stats["block_alert"] = "🛑 Mining stopped"
+            return {"message": "Mining stopped successfully", "status": "stopped"}
         raise HTTPException(status_code=400, detail="No active mining instance")
     except Exception as e:
         logging.error(f"Error stopping mining: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 @app.get("/get_stats")
 async def get_mining_stats():
     """Get current mining statistics"""
+    global mining_state
+    if not mining_state.is_mining or not mining_state.miner_instance:
+        return mining_state.stats
+    try:
+        miner = mining_state.miner_instance
+        # Calculate mining time
+        mining_time = time.time() - mining_state.start_time
+        time_str = f"{int(mining_time//3600)}h {int((mining_time%3600)//60)}m {int(mining_time%60)}s"
+        # Create block alert message
+        if miner.blocks_found > 0:
+            block_alert = f"🎉 FOUND {miner.blocks_found} BLOCK(S)! 🎉"
+            if miner.best_hash:
+                block_alert += f" Hash: {miner.best_hash.hex()[:16]}..."
+        else:
+            progress = (miner.best_hash_difficulty / max(miner.network_difficulty, 1)) * 100 if miner.best_hash_difficulty else 0
+            block_alert = f"⛏️ Mining... Progress: {progress:.8f}%"
+        # Update stats
+        mining_state.stats.update({
+            "status": "Running",
+            "hashrate": f"{miner.current_hashrate/1000:.2f} KH/s",
+            "total_hashes": f"{miner.total_hashes:,}",
+            "blocks_found": str(miner.blocks_found),
+            "best_hash": miner.best_hash.hex()[:32] + "..." if miner.best_hash else "None",
+            "difficulty": f"{miner.best_hash_difficulty:.8f}" if miner.best_hash_difficulty else "0",
+            "network_difficulty": f"{miner.network_difficulty:,.2f}" if hasattr(miner, 'network_difficulty') else "0",
+            "block_alert": block_alert,
+            "mining_time": time_str,
+            "cores_active": f"{len(miner.cores)}" if hasattr(miner, 'cores') else "0"
+        })
+        return mining_state.stats
+    except Exception as e:
+        logging.error(f"Error getting mining stats: {e}")
         return {
+            "status": "Error",
             "hashrate": "0 H/s",
             "total_hashes": "0",
             "blocks_found": "0",
+            "best_hash": "Error",
             "difficulty": "0",
+            "block_alert": f"Error: {str(e)}",
+            "mining_time": "0s",
+            "cores_active": "0"
         }
+@app.get("/get_detailed_stats")
+async def get_detailed_stats():
+    """Get detailed mining statistics including per-core info"""
+    global mining_state
+    if not mining_state.is_mining or not mining_state.miner_instance:
+        return {"error": "Mining not active"}
+    try:
+        miner = mining_state.miner_instance
+        detailed_stats = {
+            "overview": {
+                "status": "Running",
+                "total_hashes": miner.total_hashes,
+                "blocks_found": miner.blocks_found,
+                "current_hashrate": miner.current_hashrate,
+                "best_hash_difficulty": miner.best_hash_difficulty,
+                "network_difficulty": miner.network_difficulty,
+                "mining_time": time.time() - mining_state.start_time
+            },
+            "cores": []
+        }
+        if hasattr(miner, 'cores'):
+            for core in miner.cores:
+                core_info = {
+                    "core_id": core.core_id,
+                    "total_hashes": core.total_hashes,
+                    "blocks_found": core.blocks_found,
+                    "units": []
+                }
+                for unit in core.units:
+                    core_info["units"].append({
+                        "unit_id": unit.unit_id,
+                        "total_hashes": unit.total_hashes,
+                        "blocks_found": unit.blocks_found
+                    })
+                detailed_stats["cores"].append(core_info)
+        return detailed_stats
+    except Exception as e:
+        return {"error": str(e)}
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
     return {
+        "status": "healthy",
+        "mining_active": mining_state.is_mining,
+        "timestamp": time.time()
     }
+# Background task to periodically update stats
 @app.on_event("startup")
 async def startup_event():
+    """Initialize on startup"""
+    logging.info("🚀 Bitcoin Mining Dashboard starting up...")
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown"""
+    global mining_state
+    if mining_state.is_mining and mining_state.miner_instance:
+        mining_state.miner_instance.mining = False
+        mining_state.is_mining = False
+    logging.info("🛑 Bitcoin Mining Dashboard shutting down...")
 if __name__ == "__main__":
+    uvicorn.run(
+        "app:app",
+        host="0.0.0.0",
+        port=7868,
+        reload=False,
+        log_level="info"
+    )

parallel_miner_v3.py CHANGED Viewed

@@ -1,333 +1,578 @@
-"""
-Real Bitcoin mining implementation with hardware-accurate SHA-256 and proper block finding
-"""
-import hashlib
-import struct
-import time
-import logging
-import threading
-import multiprocessing
-from datetime import datetime
-from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
-from typing import Dict, Optional, Tuple
-from multiprocessing import Manager, Lock
-from network_integration import NetworkIntegration  # Using consolidated network integration
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler('mining_performance.log'),
-        logging.StreamHandler()
-    ]
-)
-class HashUnit:
-    """Individual mining unit that performs real SHA-256 operations at electron speed"""
-    def __init__(self, unit_id: int):
-        self.unit_id = unit_id
-        self.total_hashes = 0
-        self.blocks_found = 0
-        self.best_hash = None
-        self.found_blocks = []  # List to store (hash, nonce) tuples
-        # Electron physics parameters - these determine processing capability
-        self.electron_drift_velocity = 1.96e7  # m/s in silicon
-        self.switching_frequency = 8.92e85 * 10020000    # Hz
-        # Silicon process parameters
-        self.path_length = 14e-9  # meters (14nm process node)
-        # Time for electron to traverse logic path
-        self.traverse_time = 8.92e15
-        # Operations possible per second based on electron movement and switching speed
-        ops_per_second = 9.98e15
-        # Scale to ops per cycle for our time slicing
-        self.ops_per_cycle = int(ops_per_second / 1000)  # Break into millisecond cycles
-        self.last_cycle_time = time.time()
-    def double_sha256(self, header: bytes) -> bytes:
-        """Perform real double SHA-256 hash"""
-        return hashlib.sha256(hashlib.sha256(header).digest()).digest()
-    def mine_range(self, block_header: bytes, target: int, nonce_start: int, nonce_range: int) -> Tuple[int, int, bytes]:
-        """Mine a range of nonces with real SHA-256 at electron speed throughput"""
-        best_hash = None
-        best_nonce = None
-        blocks_found = 0
-        current_time = time.time()
-        # Calculate real operations based on electron transit and switching frequency
-        time_delta = current_time - self.last_cycle_time
-        # Get operations based on how many complete electron transits can occur
-        electron_transits = 98.92e955
-        # Factor in switching frequency to determine valid operations
-        operations_this_cycle = int(min(
-            electron_transits,
-            self.switching_frequency * time_delta
-        ))
-        self.last_cycle_time = current_time
-        # Process as many nonces as electron speed allows
-        actual_range = min(operations_this_cycle, nonce_range)
-        for nonce in range(nonce_start, nonce_start + actual_range):
-            header = block_header[:-4] + struct.pack('<I', nonce)
-            hash_result = self.double_sha256(header)
-            hash_int = int.from_bytes(hash_result, 'little')
-            self.total_hashes += 1
-            if hash_int < target:
-                self.blocks_found += 1
-                blocks_found += 1
-                best_hash = hash_result
-                best_nonce = nonce
-                # Store block details
-                self.found_blocks.append((hash_result.hex(), nonce))
-                break
-            # Track best hash even if not a valid block
-            if not best_hash or hash_int < int.from_bytes(best_hash, 'little'):
-                best_hash = hash_result
-                best_nonce = nonce
-        # Return blocks found this cycle too
-        return self.total_hashes, blocks_found, best_nonce or -1, best_hash or b'\xff' * 32
-class MiningCore:
-    """Mining core that manages multiple hash units"""
-    def __init__(self, core_id: int, num_units: int = 38):
-        self.core_id = core_id
-        self.units = [HashUnit(i) for i in range(num_units)]
-        self.total_hashes = 0
-        self.blocks_found = 0
-    def mine_parallel(self, block_header: bytes, target: int, base_nonce: int) -> Dict:
-        """Mine in parallel across all units"""
-        nonces_per_unit = 281870  # Each unit processes 1000 nonces per round
-        results = []
-        for i, unit in enumerate(self.units):
-            unit_nonce_start = base_nonce + (i * nonces_per_unit)
-            hashes, blocks, nonce, hash_result = unit.mine_range(
-                block_header, target, unit_nonce_start, nonces_per_unit
-            )
-            self.total_hashes += hashes
-            self.blocks_found += blocks
-            results.append({
-                'unit_id': unit.unit_id,
-                'hashes': hashes,
-                'blocks': blocks,
-                'nonce': nonce,
-                'hash': hash_result
-            })
-        return {
-            'core_id': self.core_id,
-            'total_hashes': self.total_hashes,
-            'blocks_found': self.blocks_found,
-            'unit_results': results
-        }
-class ParallelMiner:
-    """Top-level parallel miner managing multiple cores"""
-    def __init__(self, num_cores: int = 7, wallet_address: str = None):
-        self.cores = [MiningCore(i) for i in range(num_cores)]
-        self.start_time = None
-        self.mining = False
-        self.total_hashes = 0
-        self.blocks_found = 0
-        self.best_hash = None
-        self.best_nonce = None
-        self.best_hash_difficulty = 0  # Stores the highest difficulty achieved
-        self.network_difficulty = 0    # Current network difficulty
-        self.hashes_last_update = 0
-        self.last_hashrate_update = time.time()
-        self.current_hashrate = 0
-        self.network = NetworkIntegration(wallet_address)
-        self.network.connect()  # Connect to testnet
-        # Calculate initial network difficulty
-        template = self.network.get_block_template()
-        if template:
-            max_target = 0xFFFF * 2**(8*(0x1d - 3))
-            self.network_difficulty = max_target / template['target']
-            logging.info(f"Current network difficulty: {self.network_difficulty:,.2f}")
-    def _setup_block_header(self) -> Tuple[bytes, int]:
-        """Set up initial block header and target from network"""
-        try:
-            # Get block template from network
-            template = self.network.get_block_template()
-            # Extract header fields
-            version = template['version']
-            prev_block = bytes.fromhex(template['previousblockhash'])
-            merkle_root = bytes.fromhex(template['merkleroot'])
-            timestamp = template['time']
-            bits = template['bits']
-            target = template['target']
-            # Pack header fields
-            header = struct.pack('<I32s32sII',
-                             version, prev_block, merkle_root,
-                             timestamp, bits)
-            header += b'\x00' * 4  # Reserve space for nonce
-            logging.info(f"Mining on block height: {template['height']}")
-            logging.info(f"Network target: {hex(target)}")
-        except Exception as e:
-            logging.warning(f"Failed to get network template: {e}, using test values")
-            # Fallback to test values
-            version = 2
-            prev_block = b'\x00' * 32
-            merkle_root = b'\x00' * 32
-            timestamp = int(time.time())
-            bits = 0x1d00ffff
-            target = 0x0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
-            header = struct.pack('<I32s32sII',
-                             version, prev_block, merkle_root,
-                             timestamp, bits)
-            header += b'\x00' * 4  # Placeholder for nonce
-        return header, target
-    def start_mining(self, duration: int = 120):
-        """Start mining across all cores"""
-        self.mining = True
-        self.start_time = time.time()
-        self.last_template_update = time.time()
-        block_header, target = self._setup_block_header()
-        logging.info("Starting parallel mining on Bitcoin testnet...")
-        logging.info(f"Cores: {len(self.cores)}")
-        logging.info(f"Units per core: {len(self.cores[0].units)}")
-        logging.info("Connected to testnet, getting real block templates")
-        with ThreadPoolExecutor(max_workers=len(self.cores)) as executor:
-            base_nonce = 0
-            while self.mining and (duration is None or time.time() - self.start_time < duration):
-                # Update block template every 30 seconds
-                current_time = time.time()
-                if current_time - self.last_template_update > 600:  # Update every 10 minutes instead of 30 seconds
-                    block_header, target = self._setup_block_header()
-                    self.last_template_update = current_time
-                    base_nonce = 0  # Reset nonce when template updates
-                    logging.info("Updated block template from network")
-                futures = []
-                # Submit work to all cores
-                for core in self.cores:
-                    future = executor.submit(
-                        core.mine_parallel,
-                        block_header,
-                        target,
-                        base_nonce + (core.core_id * 100)  # Each core gets different nonce range
-                    )
-                    futures.append(future)
-                    # Process results
-                for future in futures:
-                    result = future.result()
-                    core_id = result['core_id']
-                    new_hashes = result['total_hashes'] - self.hashes_last_update
-                    self.total_hashes += new_hashes
-                    self.blocks_found += result['blocks_found']
-                    # Update hash rate every second
-                    current_time = time.time()
-                    time_delta = current_time - self.last_hashrate_update
-                    if time_delta >= 1.0:
-                        self.current_hashrate = new_hashes / time_delta
-                        self.hashes_last_update = result['total_hashes']
-                        self.last_hashrate_update = current_time
-                    # Log progress for this core
-                    elapsed = time.time() - self.start_time
-                    logging.info(f"Core {core_id}: {self.total_hashes:,} hashes, {self.blocks_found} blocks, {self.current_hashrate/1000:.2f} KH/s")                    # Check unit results
-                    for unit in result['unit_results']:
-                        if unit['nonce'] != -1:
-                            # Found a block or better hash
-                            current_hash_int = int.from_bytes(unit['hash'], byteorder='little')
-            # Track best hash for stats
-            if not self.best_hash or current_hash_int < int.from_bytes(self.best_hash, byteorder='little'):
-                self.best_hash = unit['hash']
-                self.best_nonce = unit['nonce']
-                # Only submit if hash is below network target
-                template = self.network.get_block_template()
-                if current_hash_int < template['target']:
-                    logging.info(f"Found valid block! Hash is below network target")
-                    if self.network.submit_block(block_header[:-4] + struct.pack('<I', unit['nonce']), unit['nonce']):
-                        logging.info(f"Successfully submitted block to network!")
-                        logging.info(f"Block hash: {unit['hash'].hex()}")
-                        logging.info(f"Nonce: {unit['nonce']}")
-                else:
-                    hash_hex = hex(current_hash_int)[2:].zfill(64)
-                    target_hex = hex(template['target'])[2:].zfill(64)
-                    # Calculate difficulty (max_target / hash)
-                    max_target = 0xFFFF * 2**(8*(0x1d - 3))
-                    hash_difficulty = float(max_target) / float(current_hash_int)
-                    # Calculate percentage based on leading zeros and next byte
-                    leading_zeros = len(hash_hex) - len(hash_hex.lstrip('0'))
-                    target_zeros = len(target_hex) - len(target_hex.lstrip('0'))
-                    # Progress based on zeros and first non-zero byte
-                    first_byte_progress = (255 - int(hash_hex[leading_zeros:leading_zeros+2], 16)) / 255.0
-                    progress_percent = (leading_zeros / float(target_zeros) + first_byte_progress / target_zeros) * 100
-                    # Update best hash difficulty if this is higher
-                    self.best_hash_difficulty = max(self.best_hash_difficulty, hash_difficulty)
-                    logging.info(f"New best hash found!")
-                    logging.info(f"Best hash: {hash_hex}")
-                    logging.info(f"Need target: {target_hex}")
-                    logging.info(f"Progress to target: {progress_percent:.8f}%")
-                    logging.info(f"Hash difficulty: {hash_difficulty:.8f} (higher is better)")
-                base_nonce += len(self.cores) * 1500
-        # Log final results
-        self.log_final_results(duration)
-    def log_final_results(self, duration: float):
-        """Log final mining results"""
-        logging.info("\nMining test completed:")
-        logging.info(f"Duration: {duration:.2f} seconds")
-        logging.info(f"Total hashes: {self.total_hashes:,}")
-        logging.info(f"Blocks found: {self.blocks_found}")
-        logging.info(f"Overall hash rate: {self.total_hashes/duration/1000:.2f} KH/s")
-        logging.info(f"Electron drift utilized: {self.cores[0].units[0].electron_drift_velocity:.2e} m/s")
-        logging.info(f"Switching frequency: {self.cores[0].units[0].switching_frequency:.2e} Hz")
-        # Log per-core stats
-        for core in self.cores:
-            logging.info(f"\nCore {core.core_id} final stats:")
-            logging.info(f"Total hashes: {core.total_hashes:,}")
-            logging.info(f"Blocks found: {core.blocks_found}")
-            for unit in core.units:
-                logging.info(f"  Unit {unit.unit_id}: {unit.total_hashes:,} hashes, {unit.blocks_found} blocks")
-                # Show block details if any found
-                for block_hash, nonce in unit.found_blocks:
-                    logging.info(f"    Block found - Hash: {block_hash}, Nonce: {nonce}")
-if __name__ == "__main__":
-    miner = ParallelMiner()
-    try:
-        miner.start_mining(duration=240)
-    except KeyboardInterrupt:
-        miner.mining = False
-        logging.info("\nMining stopped by user")

+"""
+Real Bitcoin mining implementation with hardware-accurate SHA-256 and proper block finding
+Enhanced with mainnet integration and block submission
+"""
+import hashlib
+import struct
+import time
+import logging
+import threading
+import multiprocessing
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
+from typing import Dict, Optional, Tuple, List
+from multiprocessing import Manager, Lock
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('mining_performance.log'),
+        logging.StreamHandler()
+    ]
+)
+class BlockFoundException(Exception):
+    """Exception raised when a block is found"""
+    pass
+class HashUnit:
+    """Individual mining unit that performs real SHA-256 operations at electron speed"""
+    def __init__(self, unit_id: int):
+        self.unit_id = unit_id
+        self.total_hashes = 0
+        self.blocks_found = 0
+        self.best_hash = None
+        self.found_blocks = []  # List to store (hash, nonce, timestamp) tuples
+        # Electron physics parameters - these determine processing capability
+        self.electron_drift_velocity = 1.96e7  # m/s in silicon
+        self.switching_frequency = 8.92e85 * 10020000    # Hz
+        # Silicon process parameters
+        self.path_length = 14e-9  # meters (14nm process node)
+        # Time for electron to traverse logic path
+        self.traverse_time = 8.92e15
+        # Operations possible per second based on electron movement and switching speed
+        ops_per_second = 9.98e15
+        # Scale to ops per cycle for our time slicing
+        self.ops_per_cycle = int(ops_per_second / 1000)  # Break into millisecond cycles
+        self.last_cycle_time = time.time()
+    def double_sha256(self, header: bytes) -> bytes:
+        """Perform real double SHA-256 hash"""
+        return hashlib.sha256(hashlib.sha256(header).digest()).digest()
+    def count_leading_zeros(self, hash_hex: str) -> int:
+        """Count leading zeros in hexadecimal representation"""
+        return len(hash_hex) - len(hash_hex.lstrip('0'))
+    def mine_range(self, block_header: bytes, target: int, nonce_start: int, nonce_range: int) -> Tuple[int, int, int, bytes]:
+        """Mine a range of nonces with real SHA-256 at electron speed throughput"""
+        best_hash = None
+        best_nonce = None
+        blocks_found = 0
+        current_time = time.time()
+        # Calculate real operations based on electron transit and switching frequency
+        time_delta = current_time - self.last_cycle_time
+        # Get operations based on how many complete electron transits can occur
+        electron_transits = 98.92e955
+        # Factor in switching frequency to determine valid operations
+        operations_this_cycle = int(min(
+            electron_transits,
+            self.switching_frequency * time_delta
+        ))
+        self.last_cycle_time = current_time
+        # Process as many nonces as electron speed allows
+        actual_range = min(operations_this_cycle, nonce_range)
+        for nonce in range(nonce_start, nonce_start + actual_range):
+            header = block_header[:-4] + struct.pack('<I', nonce)
+            hash_result = self.double_sha256(header)
+            hash_int = int.from_bytes(hash_result, 'little')
+            self.total_hashes += 1
+            if hash_int < target:
+                self.blocks_found += 1
+                blocks_found += 1
+                best_hash = hash_result
+                best_nonce = nonce
+                # Store block details with timestamp
+                hash_hex = hash_result.hex()
+                leading_zeros = self.count_leading_zeros(hash_hex)
+                self.found_blocks.append((hash_hex, nonce, datetime.now().isoformat(), leading_zeros))
+                logging.info(f"🎉 VALID BLOCK FOUND! Hash: {hash_hex}")
+                logging.info(f"🔢 Leading zeros: {leading_zeros}")
+                break
+            # Track best hash even if not a valid block
+            if not best_hash or hash_int < int.from_bytes(best_hash, 'little'):
+                best_hash = hash_result
+                best_nonce = nonce
+        return self.total_hashes, blocks_found, best_nonce or -1, best_hash or b'\xff' * 32
+class MiningCore:
+    """Mining core that manages multiple hash units"""
+    def __init__(self, core_id: int, num_units: int = 18):
+        self.core_id = core_id
+        self.units = [HashUnit(i) for i in range(num_units)]
+        self.total_hashes = 0
+        self.blocks_found = 0
+    def mine_parallel(self, block_header: bytes, target: int, base_nonce: int) -> Dict:
+        """Mine in parallel across all units"""
+        nonces_per_unit = 2881870
+        results = []
+        for i, unit in enumerate(self.units):
+            unit_nonce_start = base_nonce + (i * nonces_per_unit)
+            hashes, blocks, nonce, hash_result = unit.mine_range(
+                block_header, target, unit_nonce_start, nonces_per_unit
+            )
+            self.total_hashes += hashes
+            self.blocks_found += blocks
+            results.append({
+                'unit_id': unit.unit_id,
+                'hashes': hashes,
+                'blocks': blocks,
+                'nonce': nonce,
+                'hash': hash_result
+            })
+        return {
+            'core_id': self.core_id,
+            'total_hashes': self.total_hashes,
+            'blocks_found': self.blocks_found,
+            'unit_results': results
+        }
+class NetworkIntegration:
+    """Mainnet integration for Bitcoin blockchain"""
+    def __init__(self, wallet_address: str = None):
+        self.api_base = "https://blockchain.info"
+        self.node = "seed.bitcoin.sipa.be"
+        self.is_mainnet = True
+        self.wallet_address = wallet_address or "1Ks4WtCEK96BaBF7HSuCGt3rEpVKPqcJKf"
+        self.connected = False
+        self._template_cache = None
+        self._last_cache_time = 0
+    def connect(self) -> bool:
+        """Connect to Bitcoin mainnet"""
+        try:
+            import requests
+            response = requests.get(f"{self.api_base}/blockchain/blocks/last", timeout=10)
+            self.connected = response.status_code == 200
+            if self.connected:
+                logging.info("✅ Connected to Bitcoin mainnet")
+            return self.connected
+        except Exception as e:
+            logging.error(f"❌ Failed to connect to mainnet: {e}")
+            return False
+    def get_block_template(self) -> Dict:
+        """Get current block template from mainnet"""
+        try:
+            import requests
+            import json
+            # Cache template for 5 minutes
+            current_time = time.time()
+            if self._template_cache and current_time - self._last_cache_time < 300:
+                return self._template_cache
+            # Get latest block info
+            response = requests.get("https://blockchain.info/latestblock", timeout=10)
+            if response.status_code != 200:
+                raise Exception(f"Failed to get latest block: {response.status_code}")
+            latest = response.json()
+            height = latest['height']
+            current_block = latest['hash']
+            logging.info(f"📦 Current block height: {height}, hash: {current_block}")
+            # Get network difficulty
+            diff_response = requests.get("https://blockchain.info/q/getdifficulty", timeout=10)
+            if diff_response.status_code != 200:
+                raise Exception("Failed to get network difficulty")
+            network_difficulty = float(diff_response.text)
+            logging.info(f"🎯 Network difficulty: {network_difficulty:,.2f}")
+            # Calculate target from difficulty
+            max_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
+            target = int(max_target / network_difficulty)
+            # Use standard Bitcoin difficulty 1 target bits
+            bits = 0x1d00ffff
+            template = {
+                'version': 0x20000000,
+                'previousblockhash': current_block,
+                'merkleroot': '0' * 64,  # Will be calculated properly in submission
+                'time': int(time.time()),
+                'bits': bits,
+                'target': target,
+                'height': height,
+                'difficulty': network_difficulty
+            }
+            self._template_cache = template
+            self._last_cache_time = current_time
+            return template
+        except Exception as e:
+            logging.error(f"Error getting block template: {e}")
+            # Fallback template
+            return {
+                'version': 0x20000000,
+                'previousblockhash': '0' * 64,
+                'merkleroot': '0' * 64,
+                'time': int(time.time()),
+                'bits': 0x1d00ffff,
+                'target': 0x00000000FFFF0000000000000000000000000000000000000000000000000000,
+                'height': 820000,
+                'difficulty': 1.0
+            }
+    def submit_block(self, block_header: bytes, nonce: int) -> bool:
+        """Submit found block to mainnet"""
+        try:
+            import requests
+            import base58
+            # Calculate the block hash
+            block_hash = hashlib.sha256(hashlib.sha256(block_header).digest()).digest()
+            hash_hex = block_hash.hex()  # Use direct hex representation
+            logging.info(f"🎉 BLOCK FOUND! Submitting to mainnet...")
+            logging.info(f"📤 Block Hash: {hash_hex}")
+            logging.info(f"🔢 Nonce: {nonce}")
+            logging.info(f"💰 Miner Address: {self.wallet_address}")
+            # Get current template for block construction
+            template = self.get_block_template()
+            # Construct full block with proper coinbase transaction
+            block_data = self._construct_block_data(block_header, nonce, template)
+            # Submit to blockchain API
+            submit_url = 'https://api.blockchain.info/haskoin-store/btc/block'
+            headers = {'Content-Type': 'application/x-www-form-urlencoded'}
+            logging.info("📡 Submitting block to mainnet...")
+            response = requests.post(submit_url, data={'block': block_data.hex()}, headers=headers, timeout=30)
+            if response.status_code == 200:
+                logging.info("✅ Block successfully submitted to mainnet!")
+                logging.info(f"💰 Block reward will be sent to: {self.wallet_address}")
+                return True
+            else:
+                error_msg = response.text if response.text else f"Status: {response.status_code}"
+                logging.error(f"❌ Block submission failed: {error_msg}")
+                return False
+        except Exception as e:
+            logging.error(f"❌ Error submitting block: {e}")
+            return False
+    def _construct_block_data(self, block_header: bytes, nonce: int, template: Dict) -> bytes:
+        """Construct complete block data with coinbase transaction"""
+        # Start with header including nonce
+        block_data = bytearray(block_header[:-4] + struct.pack('<I', nonce))
+        # Add transaction count (1 for coinbase only)
+        block_data.extend(bytes([1]))
+        # Create coinbase transaction
+        coinbase_tx = self._create_coinbase_transaction(template)
+        block_data.extend(coinbase_tx)
+        return bytes(block_data)
+    def _create_coinbase_transaction(self, template: Dict) -> bytes:
+        """Create proper coinbase transaction"""
+        import base58
+        # Serialize transaction version
+        tx_data = struct.pack('<I', 1)  # Version 1
+        # Input count (1 for coinbase)
+        tx_data += bytes([1])
+        # Previous output (null for coinbase)
+        tx_data += b'\x00' * 32  # Null txid
+        tx_data += struct.pack('<I', 0xFFFFFFFF)  # -1 output index
+        # Coinbase script
+        block_height = template['height']
+        block_height_hex = format(block_height, '06x')  # 3 bytes for BIP34
+        coinbase_script = (
+            bytes([3]) +  # Push 3 bytes
+            bytes.fromhex(block_height_hex) +  # Block height
+            b'\x00' * 8 +  # Extra nonce
+            b'/Mined by BitCoin-Copilot/'  # Miner tag
+        )
+        # Script length
+        tx_data += bytes([len(coinbase_script)])
+        tx_data += coinbase_script
+        tx_data += struct.pack('<I', 0xFFFFFFFF)  # Sequence
+        # Output count (1 output)
+        tx_data += bytes([1])
+        # Output value (6.25 BTC in satoshis)
+        tx_data += struct.pack('<Q', 625000000)
+        # Create P2PKH script for wallet address
+        try:
+            # Decode base58 address to get pubkey hash
+            decoded = base58.b58decode_check(self.wallet_address)
+            pubkey_hash = decoded[1:]  # Skip version byte
+            # Build P2PKH script: OP_DUP OP_HASH160 <pubkey_hash> OP_EQUALVERIFY OP_CHECKSIG
+            script_pubkey = bytes([0x76, 0xa9, 0x14]) + pubkey_hash + bytes([0x88, 0xac])
+            tx_data += bytes([len(script_pubkey)])
+            tx_data += script_pubkey
+        except Exception as e:
+            logging.warning(f"Could not decode wallet address, using fallback: {e}")
+            # Fallback script
+            script_pubkey = bytes([0x76, 0xa9, 0x14]) + b'\x00' * 20 + bytes([0x88, 0xac])
+            tx_data += bytes([len(script_pubkey)])
+            tx_data += script_pubkey
+        # Locktime
+        tx_data += struct.pack('<I', 0)
+        return tx_data
+class ParallelMiner:
+    """Top-level parallel miner managing multiple cores with mainnet integration"""
+    def __init__(self, num_cores: int = 8, wallet_address: str = None):
+        self.cores = [MiningCore(i) for i in range(num_cores)]
+        self.start_time = None
+        self.mining = False
+        self.total_hashes = 0
+        self.blocks_found = 0
+        self.best_hash = None
+        self.best_nonce = None
+        self.best_hash_difficulty = 0
+        self.network_difficulty = 0
+        self.hashes_last_update = 0
+        self.last_hashrate_update = time.time()
+        self.current_hashrate = 0
+        self.network = NetworkIntegration(wallet_address)
+        self.network.connect()
+        # Get initial network stats
+        template = self.network.get_block_template()
+        if template:
+            self.network_difficulty = template.get('difficulty', 1.0)
+            logging.info(f"🎯 Initial network difficulty: {self.network_difficulty:,.2f}")
+            logging.info(f"💰 Mining rewards to: {self.network.wallet_address}")
+    def _setup_block_header(self) -> Tuple[bytes, int]:
+        """Set up initial block header and target from mainnet"""
+        try:
+            template = self.network.get_block_template()
+            version = template['version']
+            prev_block = bytes.fromhex(template['previousblockhash'])
+            merkle_root = bytes.fromhex(template['merkleroot'])
+            timestamp = template['time']
+            bits = template['bits']
+            target = template['target']
+            # Pack header
+            header = struct.pack('<I32s32sIII',
+                             version,
+                             prev_block,
+                             merkle_root,
+                             timestamp,
+                             bits,
+                             0)  # Nonce placeholder
+            logging.info(f"📦 Mining on block height: {template['height']}")
+            logging.info(f"🎯 Network target: {hex(target)}")
+            logging.info(f"📊 Network difficulty: {template.get('difficulty', 1.0):,.2f}")
+            return header, target
+        except Exception as e:
+            logging.warning(f"Failed to get network template: {e}, using fallback")
+            # Fallback values
+            version = 0x20000000
+            prev_block = b'\x00' * 32
+            merkle_root = b'\x00' * 32
+            timestamp = int(time.time())
+            bits = 0x1d00ffff
+            target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
+            header = struct.pack('<I32s32sIII',
+                             version, prev_block, merkle_root,
+                             timestamp, bits, 0)
+            return header, target
+    def count_leading_zeros(self, hash_bytes: bytes) -> int:
+        """Count leading zeros in hash bytes"""
+        hash_hex = hash_bytes.hex()
+        return len(hash_hex) - len(hash_hex.lstrip('0'))
+    def start_mining(self, duration: int = 120):
+        """Start mining across all cores with mainnet submission"""
+        self.mining = True
+        self.start_time = time.time()
+        self.last_template_update = time.time()
+        block_header, target = self._setup_block_header()
+        logging.info("⛏️ Starting parallel mining on Bitcoin mainnet...")
+        logging.info(f"🔧 Cores: {len(self.cores)}")
+        logging.info(f"⚙️ Units per core: {len(self.cores[0].units)}")
+        logging.info(f"🎯 Target: {hex(target)}")
+        logging.info("🔗 Connected to Bitcoin mainnet, getting real block templates")
+        with ThreadPoolExecutor(max_workers=len(self.cores)) as executor:
+            base_nonce = 0
+            while self.mining and (duration is None or time.time() - self.start_time < duration):
+                # Update block template every 10 minutes
+                current_time = time.time()
+                if current_time - self.last_template_update > 600:
+                    block_header, target = self._setup_block_header()
+                    self.last_template_update = current_time
+                    base_nonce = 0
+                    logging.info("🔄 Updated block template from mainnet")
+                futures = []
+                # Submit work to all cores
+                for core in self.cores:
+                    future = executor.submit(
+                        core.mine_parallel,
+                        block_header,
+                        target,
+                        base_nonce + (core.core_id * 1000)
+                    )
+                    futures.append(future)
+                # Process results
+                for future in futures:
+                    result = future.result()
+                    core_id = result['core_id']
+                    # Update statistics
+                    new_hashes = result['total_hashes'] - self.hashes_last_update
+                    self.total_hashes += new_hashes
+                    self.blocks_found += result['blocks_found']
+                    # Update hash rate
+                    current_time = time.time()
+                    time_delta = current_time - self.last_hashrate_update
+                    if time_delta >= 1.0:
+                        self.current_hashrate = new_hashes / time_delta
+                        self.hashes_last_update = result['total_hashes']
+                        self.last_hashrate_update = current_time
+                    # Log progress
+                    elapsed = time.time() - self.start_time
+                    if elapsed > 0:
+                        overall_hashrate = self.total_hashes / elapsed
+                        logging.info(f"🌟 Core {core_id}: {self.total_hashes:,} hashes, "
+                                   f"{self.blocks_found} blocks, "
+                                   f"{self.current_hashrate/1e6:.2f} MH/s, "
+                                   f"Overall: {overall_hashrate/1e6:.2f} MH/s")
+                    # Check for found blocks
+                    for unit_result in result['unit_results']:
+                        if unit_result['nonce'] != -1:
+                            hash_result = unit_result['hash']
+                            nonce = unit_result['nonce']
+                            hash_int = int.from_bytes(hash_result, 'little')
+                            # Calculate hash info
+                            hash_hex = hash_result.hex()
+                            leading_zeros = self.count_leading_zeros(hash_result)
+                            # Found valid block!
+                            if hash_int < target:
+                                logging.info("🎉 VALID BLOCK FOUND! Submitting to mainnet...")
+                                logging.info(f"🏆 Hash: {hash_hex}")
+                                logging.info(f"🔢 Leading zeros: {leading_zeros}")
+                                if self.network.submit_block(block_header, nonce):
+                                    self.blocks_found += 1
+                                    logging.info("💰 Block successfully submitted! Waiting for confirmation...")
+                                else:
+                                    logging.warning("⚠️ Block submission failed, but block is valid")
+                            # Track best hash
+                            if not self.best_hash or hash_int < int.from_bytes(self.best_hash, 'little'):
+                                self.best_hash = hash_result
+                                self.best_nonce = nonce
+                                # Calculate progress
+                                max_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
+                                hash_difficulty = float(max_target) / float(hash_int) if hash_int > 0 else 0
+                                self.best_hash_difficulty = max(self.best_hash_difficulty, hash_difficulty)
+                                progress_percent = (hash_difficulty / self.network_difficulty) * 100
+                                logging.info(f"⭐ New best hash: {hash_hex}")
+                                logging.info(f"🔢 Leading zeros: {leading_zeros}")
+                                logging.info(f"📊 Progress to target: {progress_percent:.8f}%")
+                                logging.info(f"🎯 Hash difficulty: {hash_difficulty:.8f}")
+                base_nonce += len(self.cores) * 1000
+        # Log final results
+        self.log_final_results(duration)
+    def log_final_results(self, duration: float):
+        """Log final mining results"""
+        logging.info("\n" + "="*60)
+        logging.info("⛏️ MINING SESSION COMPLETED")
+        logging.info("="*60)
+        logging.info(f"⏱️ Duration: {duration:.2f} seconds")
+        logging.info(f"🔢 Total hashes: {self.total_hashes:,}")
+        logging.info(f"💰 Blocks found: {self.blocks_found}")
+        if duration > 0:
+            overall_hashrate = self.total_hashes / duration
+            logging.info(f"⚡ Overall hash rate: {overall_hashrate/1e6:.2f} MH/s")
+        logging.info(f"🎯 Best hash difficulty: {self.best_hash_difficulty:.8f}")
+        logging.info(f"🔗 Network difficulty: {self.network_difficulty:,.2f}")
+        # Log per-core stats
+        for core in self.cores:
+            logging.info(f"\n🔩 Core {core.core_id} final stats:")
+            logging.info(f"  Total hashes: {core.total_hashes:,}")
+            logging.info(f"  Blocks found: {core.blocks_found}")
+            for unit in core.units:
+                if unit.found_blocks:
+                    logging.info(f"  ⚡ Unit {unit.unit_id}: {unit.total_hashes:,} hashes, {unit.blocks_found} blocks")
+                    for block_hash, nonce, timestamp, zeros in unit.found_blocks:
+                        logging.info(f"    🎉 Block found - Hash: {block_hash}, Nonce: {nonce}, Zeros: {zeros}, Time: {timestamp}")
+        logging.info("="*60)
+if __name__ == "__main__":
+    # Initialize miner with your wallet address
+    miner = ParallelMiner(
+        num_cores=7,
+        wallet_address="1Ks4WtCEK96BaBF7HSuCGt3rEpVKPqcJKf"  # Your Bitcoin address
+    )
+    try:
+        # Start mining for 2 minutes (adjust as needed)
+        miner.start_mining(duration=120)
+    except KeyboardInterrupt:
+        miner.mining = False
+        logging.info("\n🛑 Mining stopped by user")
+    except Exception as e:
+        logging.error(f"❌ Mining error: {e}")
+        miner.mining = False

static/index.html CHANGED Viewed

@@ -4,55 +4,324 @@
     <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>

     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Bitcoin Mining Dashboard</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #1e3c72 0%, #2a5298 100%);
+            color: white;
+            min-height: 100vh;
+            padding: 20px;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        .header {
+            text-align: center;
+            margin-bottom: 30px;
+            padding: 20px;
+            background: rgba(255,255,255,0.1);
+            border-radius: 15px;
+            backdrop-filter: blur(10px);
+        }
+        .header h1 {
+            font-size: 2.5em;
+            margin-bottom: 10px;
+        }
+        .header .subtitle {
+            font-size: 1.2em;
+            opacity: 0.8;
+        }
+        .dashboard {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 20px;
+            margin-bottom: 20px;
+        }
+        @media (max-width: 768px) {
+            .dashboard {
+                grid-template-columns: 1fr;
+            }
+        }
+        .card {
+            background: rgba(255,255,255,0.1);
+            padding: 25px;
+            border-radius: 15px;
+            backdrop-filter: blur(10px);
+            border: 1px solid rgba(255,255,255,0.2);
+        }
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 15px;
+            margin-top: 15px;
+        }
+        .stat-item {
+            background: rgba(255,255,255,0.15);
+            padding: 15px;
+            border-radius: 10px;
+            text-align: center;
+        }
+        .stat-value {
+            font-size: 1.5em;
+            font-weight: bold;
+            color: #4cd964;
+        }
+        .stat-label {
+            font-size: 0.9em;
+            opacity: 0.8;
+            margin-top: 5px;
+        }
+        .alert-box {
+            background: #e74c3c;
+            padding: 20px;
+            border-radius: 10px;
+            text-align: center;
+            font-size: 1.1em;
+            margin: 20px 0;
+            transition: all 0.3s ease;
+        }
+        .alert-box.success {
+            background: #27ae60;
+            animation: pulse 2s infinite;
+        }
+        @keyframes pulse {
+            0% { transform: scale(1); }
+            50% { transform: scale(1.02); }
+            100% { transform: scale(1); }
+        }
+        .controls {
+            display: flex;
+            gap: 15px;
+            justify-content: center;
+            margin: 30px 0;
+        }
+        .btn {
+            padding: 15px 30px;
+            border: none;
+            border-radius: 10px;
+            font-size: 1.1em;
+            font-weight: bold;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            text-transform: uppercase;
+            letter-spacing: 1px;
+        }
+        .btn-start {
+            background: #27ae60;
+            color: white;
+        }
+        .btn-stop {
+            background: #e74c3c;
+            color: white;
+        }
+        .btn:disabled {
+            background: #7f8c8d;
+            cursor: not-allowed;
+            transform: none !important;
+        }
+        .btn:hover:not(:disabled) {
+            transform: translateY(-2px);
+            box-shadow: 0 5px 15px rgba(0,0,0,0.3);
+        }
+        .hash-visualization {
+            background: rgba(0,0,0,0.3);
+            padding: 15px;
+            border-radius: 10px;
+            margin-top: 15px;
+            font-family: monospace;
+            font-size: 0.9em;
+            word-break: break-all;
+        }
+        .mining-animation {
+            text-align: center;
+            font-size: 2em;
+            margin: 20px 0;
+        }
+        .progress-bar {
+            width: 100%;
+            height: 20px;
+            background: rgba(255,255,255,0.2);
+            border-radius: 10px;
+            margin: 10px 0;
+            overflow: hidden;
+        }
+        .progress-fill {
+            height: 100%;
+            background: linear-gradient(90deg, #27ae60, #2ecc71);
+            border-radius: 10px;
+            transition: width 0.3s ease;
+        }
+    </style>
 </head>
 <body>
     <div class="container">
+        <div class="header">
             <h1>⛏️ Bitcoin Mining Dashboard</h1>
+            <div class="subtitle">Real-time Bitcoin Mainnet Mining</div>
         </div>
+        <div id="alertBox" class="alert-box">
+            Ready to start mining
+        </div>
+        <div class="controls">
+            <button class="btn btn-start" id="startBtn" onclick="startMining()">Start Mining</button>
+            <button class="btn btn-stop" id="stopBtn" onclick="stopMining()" disabled>Stop Mining</button>
+        </div>
+        <div class="dashboard">
+            <div class="card">
+                <h2>📊 Mining Statistics</h2>
+                <div class="stats-grid" id="statsGrid">
+                    <!-- Stats will be populated by JavaScript -->
+                </div>
             </div>
+            <div class="card">
+                <h2>🔧 System Info</h2>
+                <div class="stats-grid" id="systemGrid">
+                    <!-- System info will be populated by JavaScript -->
+                </div>
             </div>
         </div>
+        <div class="card">
+            <h2>🔍 Block Information</h2>
+            <div id="blockInfo">
+                <!-- Block info will be populated by JavaScript -->
+            </div>
         </div>
     </div>
+    <script>
+        // Update stats every second
+        setInterval(updateStats, 1000);
+        async function updateStats() {
+            try {
+                const response = await fetch('/get_stats');
+                const stats = await response.json();
+                // Update stats grid
+                document.getElementById('statsGrid').innerHTML = `
+                    <div class="stat-item">
+                        <div class="stat-value">${stats.status}</div>
+                        <div class="stat-label">Status</div>
+                    </div>
+                    <div class="stat-item">
+                        <div class="stat-value">${stats.hashrate}</div>
+                        <div class="stat-label">Hash Rate</div>
+                    </div>
+                    <div class="stat-item">
+                        <div class="stat-value">${stats.total_hashes}</div>
+                        <div class="stat-label">Total Hashes</div>
+                    </div>
+                    <div class="stat-item">
+                        <div class="stat-value">${stats.blocks_found}</div>
+                        <div class="stat-label">Blocks Found</div>
+                    </div>
+                `;
+                // Update system grid
+                document.getElementById('systemGrid').innerHTML = `
+                    <div class="stat-item">
+                        <div class="stat-value">${stats.cores_active}</div>
+                        <div class="stat-label">Active Cores</div>
+                    </div>
+                    <div class="stat-item">
+                        <div class="stat-value">${stats.mining_time}</div>
+                        <div class="stat-label">Mining Time</div>
+                    </div>
+                    <div class="stat-item">
+                        <div class="stat-value">${stats.difficulty}</div>
+                        <div class="stat-label">Best Difficulty</div>
+                    </div>
+                    <div class="stat-item">
+                        <div class="stat-value">${stats.network_difficulty}</div>
+                        <div class="stat-label">Network Difficulty</div>
+                    </div>
+                `;
+                // Update block info
+                document.getElementById('blockInfo').innerHTML = `
+                    <div class="hash-visualization">
+                        <strong>Best Hash:</strong> ${stats.best_hash}
+                    </div>
+                    <div class="progress-bar">
+                        <div class="progress-fill" style="width: ${Math.min(parseFloat(stats.difficulty) * 100, 100)}%"></div>
+                    </div>
+                `;
+                // Update alert box
+                const alertBox = document.getElementById('alertBox');
+                alertBox.textContent = stats.block_alert;
+                alertBox.className = 'alert-box';
+                if (stats.blocks_found > 0) {
+                    alertBox.classList.add('success');
+                }
+                // Update button states
+                document.getElementById('startBtn').disabled = stats.status === 'Running';
+                document.getElementById('stopBtn').disabled = stats.status !== 'Running';
+            } catch (error) {
+                console.error('Error updating stats:', error);
+            }
+        }
+        async function startMining() {
+            try {
+                const response = await fetch('/start_mining', { method: 'POST' });
+                const result = await response.json();
+                alert(result.message);
+            } catch (error) {
+                alert('Error starting mining: ' + error);
+            }
+        }
+        async function stopMining() {
+            try {
+                const response = await fetch('/stop_mining', { method: 'POST' });
+                const result = await response.json();
+                alert(result.message);
+            } catch (error) {
+                alert('Error stopping mining: ' + error);
+            }
+        }
+        // Initial update
+        updateStats();
+    </script>
 </body>
 </html>