Update parallel_miner_v3.py

parallel_miner_v3.py

@@ -1,5 +1,5 @@
 """
-Real Bitcoin mining implementation with hardware-accurate SHA-256 and proper block finding
+Bitcoin mining implementation with hardware-accurate SHA-256 and proper block finding
 """
 import hashlib
 import struct
@@ -33,7 +33,7 @@ class HashUnit:
         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
+        self.switching_frequency = 8.92e85 * 10020000    # Hz
         
         # Silicon process parameters
         self.path_length = 14e-9  # meters (14nm process node)
@@ -42,7 +42,7 @@ class HashUnit:
         # 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 = 9.98e15  # Break into millisecond cycles
+        self.ops_per_cycle = int(ops_per_second / 1000)  # Break into millisecond cycles 
         
         self.last_cycle_time = time.time()
         
@@ -60,7 +60,7 @@ class HashUnit:
         # 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
+        electron_transits = 98.92e955
         # Factor in switching frequency to determine valid operations
         operations_this_cycle = int(min(
             electron_transits, 
@@ -97,7 +97,7 @@ class HashUnit:
 
 class MiningCore:
     """Mining core that manages multiple hash units"""
-    def __init__(self, core_id: int, num_units: int = 15):
+    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
@@ -105,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 = 201870  # Each unit processes 1000 nonces per round
+        nonces_per_unit = 3981870  # Each unit processes this many nonces per round
         results = []
         
         for i, unit in enumerate(self.units):
@@ -134,7 +134,7 @@ class MiningCore:
 
 class ParallelMiner:
     """Top-level parallel miner managing multiple cores"""
-    def __init__(self, num_cores: int = 5, wallet_address: str = None):
+    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
@@ -148,7 +148,7 @@ class ParallelMiner:
         self.last_hashrate_update = time.time()
         self.current_hashrate = 0
         self.network = NetworkIntegration(wallet_address)
-        self.network.connect()  # Connect to testnet
+        self.network.connect()  # Connect to network
         
         # Calculate initial network difficulty
         template = self.network.get_block_template()
@@ -181,7 +181,7 @@ class ParallelMiner:
             logging.info(f"Network target: {hex(target)}")
             
         except Exception as e:
-            logging.warning(f"Failed to get network template: {e}, using test values")
+            logging.warning(f"Failed to get network template: {e}, using fallback values")
             # Fallback to test values
             version = 2
             prev_block = b'\x00' * 32
@@ -204,10 +204,10 @@ class ParallelMiner:
         self.last_template_update = time.time()
         block_header, target = self._setup_block_header()
         
-        logging.info("Starting parallel mining on Bitcoin testnet...")
+        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 testnet, getting real block templates")
+        logging.info("Connected to network, getting block templates")
         
         with ThreadPoolExecutor(max_workers=len(self.cores)) as executor:
             base_nonce = 0
@@ -215,11 +215,10 @@ class ParallelMiner:
             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
+                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  # Reset nonce when template updates
-                    logging.info("Updated block template from network")
+                    logging.info("Updated block template from network - continuing with current nonce range")
                 
                 futures = []
                 
@@ -253,51 +252,78 @@ class ParallelMiner:
                     # 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
+                    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 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
+                            # Track best hash
+                            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']
+                                
+                                # Check if hash is below network target and submit immediately if it is
+                                template = self.network.get_block_template()
+                                logging.info(f"Checking hash against network target...")
+                                logging.info(f"Current hash: {hex(current_hash_int)}")
+                                logging.info(f"Network target: {hex(template['target'])}")
+                                
+                                if current_hash_int < template['target']:
+                                    logging.info(f"Found valid block! Hash is below network 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')}")
+                                    
+                                    try:
+                                        block_data = block_header[:-4] + struct.pack('<I', unit['nonce'])
+                                        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}")
+                                        else:
+                                            logging.error("❌ Block submission failed")
+                                            logging.error("This could be due to:")
+                                            logging.error("- Network connectivity issues")
+                                            logging.error("- Block became stale")
+                                            logging.error("- Invalid block structure")
+                                    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(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
+                                    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)
@@ -327,7 +353,7 @@ class ParallelMiner:
 if __name__ == "__main__":
     miner = ParallelMiner()
     try:
-        miner.start_mining(duration=440)
+        miner.start_mining(duration=500)
     except KeyboardInterrupt:
         miner.mining = False
         logging.info("\nMining stopped by user")