Update parallel_miner_v3.py

parallel_miner_v3.py

@@ -1,6 +1,5 @@
 """
-Real Bitcoin mining implementation with hardware-accurate SHA-256 and proper block finding
-Enhanced with mainnet integration and block submission
+Bitcoin mining implementation with hardware-accurate SHA-256 and proper block finding
 """
 import hashlib
 import struct
@@ -10,8 +9,9 @@ import threading
 import multiprocessing
 from datetime import datetime
 from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
-from typing import Dict, Optional, Tuple, List
+from typing import Dict, Optional, Tuple
 from multiprocessing import Manager, Lock
+from network_integration import NetworkIntegration  # Using consolidated network integration
 
 # Configure logging
 logging.basicConfig(
@@ -23,10 +23,6 @@ logging.basicConfig(
     ]
 )
 
-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):
@@ -34,7 +30,7 @@ class HashUnit:
         self.total_hashes = 0
         self.blocks_found = 0
         self.best_hash = None
-        self.found_blocks = []  # List to store (hash, nonce, timestamp) tuples
+        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
@@ -54,11 +50,7 @@ class HashUnit:
         """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]:
+    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
@@ -91,12 +83,8 @@ class HashUnit:
                 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}")
+                # Store block details
+                self.found_blocks.append((hash_result.hex(), nonce))
                 break
             
             # Track best hash even if not a valid block
@@ -104,11 +92,12 @@ class HashUnit:
                 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 = 18):
+    def __init__(self, core_id: int, num_units: int = 8):
         self.core_id = core_id
         self.units = [HashUnit(i) for i in range(num_units)]
         self.total_hashes = 0
@@ -116,7 +105,7 @@ class MiningCore:
         
     def mine_parallel(self, block_header: bytes, target: int, base_nonce: int) -> Dict:
         """Mine in parallel across all units"""
-        nonces_per_unit = 1111870
+        nonces_per_unit = 3981870  # Each unit processes this many nonces per round
         results = []
         
         for i, unit in enumerate(self.units):
@@ -143,215 +132,9 @@ class MiningCore:
             '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):
+    """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
@@ -359,26 +142,28 @@ class ParallelMiner:
         self.blocks_found = 0
         self.best_hash = None
         self.best_nonce = None
-        self.best_hash_difficulty = 0
-        self.network_difficulty = 0
+        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()
+        self.network.connect()  # Connect to network
         
-        # Get initial network stats
+        # Calculate initial network difficulty
         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}")
+            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 mainnet"""
+        """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'])
@@ -386,66 +171,54 @@ class ParallelMiner:
             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}")
+            # Pack header fields
+            header = struct.pack('<I32s32sII',
+                             version, prev_block, merkle_root,
+                             timestamp, bits)
+            header += b'\x00' * 4  # Reserve space for nonce
             
-            return header, target
+            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 fallback")
-            # Fallback values
-            version = 0x20000000
+            logging.warning(f"Failed to get network template: {e}, using fallback values")
+            # Fallback to test values
+            version = 2
             prev_block = b'\x00' * 32
             merkle_root = b'\x00' * 32
             timestamp = int(time.time())
             bits = 0x1d00ffff
-            target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
+            target = 0x0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
             
-            header = struct.pack('<I32s32sIII',
+            header = struct.pack('<I32s32sII',
                              version, prev_block, merkle_root,
-                             timestamp, bits, 0)
-            
-            return header, target
+                             timestamp, bits)
+            header += b'\x00' * 4  # Placeholder for nonce
         
-    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'))
+        return header, target
         
     def start_mining(self, duration: int = 120):
-        """Start mining across all cores with mainnet submission"""
+        """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 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")
+        logging.info("Starting parallel Bitcoin mining...")
+        logging.info(f"Cores: {len(self.cores)}")
+        logging.info(f"Units per core: {len(self.cores[0].units)}")
+        logging.info("Connected to network, getting 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
+                # Update block template every 30 seconds
                 current_time = time.time()
-                if current_time - self.last_template_update > 600:
+                if current_time - self.last_template_update > 600:  # Update every 10 minutes
                     block_header, target = self._setup_block_header()
                     self.last_template_update = current_time
-                    base_nonce = 0
-                    logging.info("🔄 Updated block template from mainnet")
+                    logging.info("Updated block template from network - continuing with current nonce range")
                 
                 futures = []
                 
@@ -455,21 +228,20 @@ class ParallelMiner:
                         core.mine_parallel,
                         block_header,
                         target,
-                        base_nonce + (core.core_id * 1000)
+                        base_nonce + (core.core_id * 100)  # Each core gets different nonce range
                     )
                     futures.append(future)
                 
-                # Process results
+                    # 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
+                    # Update hash rate every second
                     current_time = time.time()
                     time_delta = current_time - self.last_hashrate_update
                     if time_delta >= 1.0:
@@ -477,102 +249,126 @@ class ParallelMiner:
                         self.hashes_last_update = result['total_hashes']
                         self.last_hashrate_update = current_time
                     
-                    # Log progress
+                    # Log progress for this core
                     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")
+                    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 blocks
+                    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
-                            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)
+                            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']
                                 
-                                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}")
+                                # Compare with current target and submit if valid
+                                if current_hash_int < target:  # Use current target, not new template target
+                                    logging.info(f"Found valid block! Hash is below target")
+                                    logging.info(f"Core {core_id}, Unit {unit['unit_id']} found the block")
+                                    logging.info(f"Block details:")
+                                    logging.info(f"  Hash: {unit['hash'].hex()}")
+                                    logging.info(f"  Nonce: {unit['nonce']}")
+                                    logging.info(f"  Timestamp: {time.strftime('%Y-%m-%d %H:%M:%S')}")
+                                    
+                                    # Prepare block data
+                                    block_data = block_header[:-4] + struct.pack('<I', unit['nonce'])
+                                    
+                                    # Log submission attempt details
+                                    logging.info("Block submission details:")
+                                    logging.info(f"Block header length: {len(block_header)}")
+                                    logging.info(f"Final block data length: {len(block_data)}")
+                                    logging.info(f"Target used: {hex(target)}")
+                                    logging.info(f"Hash achieved: {hex(current_hash_int)}")
+                                    
+                                    try:
+                                        logging.info("🔄 Attempting to submit block to network...")
+                                        if self.network.submit_block(block_data, unit['nonce']):
+                                            logging.info("🎉 Block successfully submitted to network! 🎉")
+                                            logging.info(f"Block hash: {unit['hash'].hex()}")
+                                            logging.info(f"Nonce: {unit['nonce']}")
+                                            logging.info(f"Difficulty: {self.network_difficulty:,.2f}")
+                                            
+                                            # Extra verification
+                                            verify_hash = self.double_sha256(block_data)
+                                            verify_int = int.from_bytes(verify_hash, 'little')
+                                            logging.info(f"Verification hash: {hex(verify_int)}")
+                                            logging.info(f"Matches original: {verify_int == current_hash_int}")
+                                        else:
+                                            logging.error("❌ Block submission failed")
+                                            logging.error("Detailed diagnostics:")
+                                            logging.error(f"- Block header hex: {block_header.hex()}")
+                                            logging.error(f"- Final nonce used: {unit['nonce']}")
+                                            logging.error(f"- Hash achieved: {unit['hash'].hex()}")
+                                            logging.error("Common failure reasons:")
+                                            logging.error("- Network connectivity issues")
+                                            logging.error("- Block became stale")
+                                            logging.error("- Invalid block structure")
+                                            logging.error("- Target difficulty mismatch")
+                                    except Exception as e:
+                                        logging.error(f"❌ Exception during block submission: {str(e)}")
+                                        logging.error(f"Block data length: {len(block_data)}")
+                                        logging.error(f"Nonce value: {unit['nonce']}")
+                                        logging.exception("Full exception details:")
+                                else:
+                                    hash_hex = hex(current_hash_int)[2:].zfill(64)
+                                    target_hex = hex(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
+                                    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) * 1000
+                base_nonce += len(self.cores) * 1500  # Increment base_nonce within the main loop
                 
         # 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}")
+        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"\n🔩 Core {core.core_id} final stats:")
-            logging.info(f"  Total hashes: {core.total_hashes:,}")
-            logging.info(f"  Blocks found: {core.blocks_found}")
+            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:
-                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)
-
+                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__":
-    # Initialize miner with your wallet address
-    miner = ParallelMiner(
-        num_cores=7, 
-        wallet_address="1Ks4WtCEK96BaBF7HSuCGt3rEpVKPqcJKf"  # Your Bitcoin address
-    )
-    
+    miner = ParallelMiner()
     try:
-        # Start mining for 2 minutes (adjust as needed)
-        miner.start_mining(duration=120)
+        miner.start_mining(duration=500)
     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
+        logging.info("\nMining stopped by user")