Update parallel_miner_v3.py

parallel_miner_v3.py

@@ -1,354 +1,333 @@
-"""
-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     # 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 = 78.92e555
-        # 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
-                # Calculate and log mining estimates
-                from mining_stats import calculate_mining_estimate, log_mining_statistics
-                hash_rate = self.total_hashes / (time.time() - self.last_cycle_time)
-                stats = calculate_mining_estimate(
-                    hash_rate_per_core=hash_rate,
-                    num_cores=multiprocessing.cpu_count(),
-                    target=target,
-                    best_hash=best_hash.hex()
-                )
-                log_mining_statistics(stats)
-                
-        # 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 = 15):
-        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 = 70  # 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 = 5, 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()
-        self.last_stats_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 > 300:  # Update every 5 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
-                    current_time = time.time()
-                    elapsed = current_time - self.start_time
-                    
-                    # Log detailed stats every 30 seconds
-                    if current_time - self.last_stats_update >= 30:
-                        logging.info("\n=== Mining Statistics Update ===")
-                        grand_total = 0
-                        for core_idx, core in enumerate(self.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: {self.current_hashrate/1000:.2f} KH/s")
-                        logging.info("=============================\n")
-                        self.last_stats_update = current_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 (hash / max_target) - lower hash means higher difficulty
-                    max_target = 0xFFFF * 2**(8*(0x1d - 3))
-                    hash_difficulty = current_hash_int / float(max_target) if max_target != 0 else float('inf')
-                    
-                    # Update best hash difficulty if this is lower (lower hash = higher difficulty)
-                    if self.best_hash_difficulty == 0 or hash_difficulty < self.best_hash_difficulty:
-                        self.best_hash_difficulty = hash_difficulty
-                    
-                    # Convert to more readable format (lower is better since it's hash/target)
-                    relative_difficulty = 1.0 / hash_difficulty if hash_difficulty != 0 else 0
-                    percent_to_target = (relative_difficulty * 100)
-                    
-                    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 towards target: {percent_to_target:.8f}%")
-                
-                base_nonce += len(self.cores) * 500
-                
-        # 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=120)
-    except KeyboardInterrupt:
-        miner.mining = False
+"""
+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     # 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.92e555
+        # 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 = 15):
+        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 = 100870  # 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 = 4, 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 10 minutes
+                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) * 500
+                
+        # 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=640)
+    except KeyboardInterrupt:
+        miner.mining = False
         logging.info("\nMining stopped by user")