Update network_integration.py

network_integration.py

@@ -1,399 +1,453 @@
-"""
-Integrates the mining system with Bitcoin mainnet
-"""
-from typing import Dict, Any, Optional
-import time
-import requests
-import hashlib
-import json
-import logging
-import struct
-
-# Configure detailed logging
-logging.basicConfig(
-    level=logging.DEBUG,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler('network_debug.log'),
-        logging.StreamHandler()
-    ]
-)
-
-class NetworkIntegration:
-    def __init__(self, wallet_address: str = None):
-        self.api_base = "https://blockchain.info"  # Changed to more reliable API
-        self.node = "seed.bitcoin.sipa.be"  # Bitcoin mainnet seed node
-        self.is_mainnet = True  # Force mainnet mode
-        # Use the provided wallet address or load from my_wallet.json
-        if wallet_address:
-            self.wallet_address = wallet_address
-        else:
-            try:
-                with open('my_wallet.json', 'r') as f:
-                    wallet_data = json.load(f)
-                self.wallet_address = wallet_data['address']
-                print(f"Using wallet address: {self.wallet_address}")
-            except Exception as e:
-                print(f"Error loading wallet: {e}")
-                self.wallet_address = "1Ks4WtCEK96BaBF7HSuCGt3rEpVKPqcJKf"  # Your default address
-        
-    def connect(self) -> bool:
-        """Connect to Bitcoin mainnet"""
-        try:
-            # Test connection by getting latest block
-            response = requests.get(f"{self.api_base}/blockchain/blocks/last")
-            return response.status_code == 200
-        except Exception as e:
-            print(f"Failed to connect to mainnet: {e}")
-            return False
-        
-    def get_block_template(self) -> Dict[str, Any]:
-        """Get current block template from mainnet"""
-        try:
-            # Cache the blockchain API response for 5 minutes
-            current_time = time.time()
-            if not hasattr(self, '_template_cache') or current_time - self._last_cache_time > 300:
-                logging.debug("Cache expired, fetching new block template")
-                # Get latest block info from a more reliable API
-                response = requests.get("https://blockchain.info/latestblock")
-                logging.debug(f"Latest block API response status: {response.status_code}")
-                
-                if response.status_code != 200:
-                    logging.error(f"Failed to get latest block. Status code: {response.status_code}")
-                    if hasattr(self, '_template_cache'):
-                        logging.info("Using cached template")
-                        return self._template_cache
-                    raise Exception("Failed to get latest block")
-                    
-                latest = response.json()
-                logging.debug(f"Latest block response: {latest}")
-                
-                height = latest['height']
-                current_block = latest['hash']
-                logging.info(f"Current block height: {height}, hash: {current_block}")
-                
-                # Get current network stats and difficulty
-                logging.debug("Fetching network stats...")
-                diff_response = requests.get("https://blockchain.info/q/getdifficulty")
-                if diff_response.status_code != 200:
-                    raise Exception("Failed to get network difficulty")
-                
-                network_difficulty = float(diff_response.text)
-                logging.info(f"Current network difficulty: {network_difficulty}")
-                
-                # Calculate target from difficulty
-                max_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
-                target = int(max_target / network_difficulty)
-                bits = f"{0x1d:02x}{(target >> 208) & 0xffffff:06x}"
-                
-                logging.debug(f"Target calculated from difficulty: {hex(target)}")
-                
-                # Use fixed bits for target calculation
-                bits = 0x1d00ffff  # Standard Bitcoin difficulty 1 target
-                
-                # Calculate target from bits
-                exp = ((bits >> 24) & 0xff)
-                coeff = bits & 0x00ffffff
-                current_target = coeff * (2 ** (8 * (exp - 3)))
-                
-                # Create block template
-                template = {
-                    'version': 2,
-                    'previousblockhash': current_block,
-                    'merkleroot': '0' * 64,  # Placeholder merkle root
-                    'time': int(time.time()),
-                    'bits': bits,
-                    'target': current_target,
-                    'height': height
-                }
-                
-                logging.debug(f"Target calculated from bits {hex(bits)}: {hex(current_target)}")
-                
-                # Construct template with required fields
-                template = {
-                    'version': 2,  # Current Bitcoin version
-                    'previousblockhash': current_block,  # Use current block as previous for next block
-                    'merkleroot': '0' * 64,  # Placeholder merkle root
-                    'time': int(time.time()),
-                    'bits': bits,  # Original bits value
-                    'height': int(height),  # Ensure height is integer
-                    'target': current_target  # Correctly calculated target from bits
-                }
-                
-                # Update cache
-                self._template_cache = template
-                self._last_cache_time = current_time
-                
-            return self._template_cache
-            
-        except Exception as e:
-            logging.error(f"Error getting block template: {str(e)}")
-            # Return fallback template
-            # Get real mainnet difficulty from blockchain.info
-            diff_url = "https://blockchain.info/q/getdifficulty"
-            try:
-                diff_response = requests.get(diff_url)
-                if diff_response.status_code == 200:
-                    network_difficulty = float(diff_response.text)
-                    bits = hex(int((0xffff * 2**(8*(0x1d - 3))) / network_difficulty))[2:]
-                    target = int((0xffff * 2**(8*(0x1d - 3))) / network_difficulty)
-                    logging.info(f"Got mainnet difficulty: {network_difficulty}")
-                else:
-                    # Use more reasonable fallback difficulty for mainnet
-                    network_difficulty = 137533144484879.19  # Recent mainnet difficulty
-                    target = int((0xffff * 2**(8*(0x1d - 3))) / network_difficulty)
-                    bits = f"{0x1d:02x}{target & 0xffffff:06x}"
-            except Exception as e:
-                logging.error(f"Error getting mainnet difficulty: {e}")
-                # Use more reasonable fallback difficulty for mainnet
-                network_difficulty = 137533144484879.19  # Recent mainnet difficulty
-                target = int((0xffff * 2**(8*(0x1d - 3))) / network_difficulty)
-                bits = f"{0x1d:02x}{target & 0xffffff:06x}"
-            
-            return {
-                'version': 2,
-                'previousblockhash': '0' * 64,
-                'merkleroot': '0' * 64,
-                'time': int(time.time()),
-                'bits': bits,
-                'height': 0,
-                'target': target
-            }
-            
-            print(f"Mining at difficulty: {network_difficulty}")
-            print(f"Network target: {hex(target)}")
-            
-            # Create proper coinbase input script
-            block_height_hex = hex(height)[2:].zfill(6)  # BIP34: Block height
-            coinbase_script = (
-                "03" +  # Push 3 bytes
-                block_height_hex +  # BIP34: Block height
-                "0000000000000000" +  # Extra nonce space
-                "2f4d696e656420627920426974436f696e2d436f70696c6f742f"  # /Mined by BitCoin-Copilot/
-            )
-
-            # Create coinbase transaction
-            coinbase_tx = {
-                'version': 1,
-                'vin': [{
-                    'txid': '0' * 64,  # Null hash for coinbase
-                    'vout': 0xFFFFFFFF,  # -1 (4 bytes) for coinbase
-                    'scriptSig': coinbase_script,  # Block height + extra nonce + miner tag
-                    'sequence': 0xFFFFFFFF
-                }],
-                'vout': [{
-                    'value': 625000000,  # 6.25 BTC reward
-                    'scriptPubKey': '76a914' + hashlib.new("ripemd160", hashlib.sha256(self.wallet_address.encode()).digest()).hexdigest() + '88ac'  # P2PKH to miner address
-                }]
-            }
-            
-            # Construct proper block template with real network data
-            template = {
-                'version': 0x20000000,  # Version 2 with BIP9 bits
-                'previousblockhash': prev_block,  # Changed to match Bitcoin Core naming
-                'merkleroot': current_block['mrkl_root'],  # Changed to match Bitcoin Core naming
-                'time': int(time.time()),  # Changed to match Bitcoin Core naming
-                'bits': bits_int,  # Using parsed bits value
-                'height': height,
-                'target': target,
-                'difficulty': network_difficulty,  # Changed to match Bitcoin Core naming
-                'coinbasetx': coinbase_tx,  # Changed to match Bitcoin Core naming
-                'sizelimit': 4000000,  # Changed to match Bitcoin Core naming
-                'transactions': []  # Pending transactions (empty for now)
-            }
-            
-            return template
-            
-        except Exception as e:
-            logging.error(f"Error getting block template: {str(e)}")
-            # Use fallback difficulty and target
-            network_difficulty = 137533144484879.19  # Recent mainnet difficulty
-            max_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
-            target = int(max_target / network_difficulty)
-            bits = f"{0x1d:02x}{(target >> 208) & 0xffffff:06x}"
-            
-            logging.info(f"Using fallback difficulty: {network_difficulty}")
-            block_height = 917362  # Recent block height
-            prev_block = "00000000000000000000635542f008dfb9ba9f4d25e53539c62918aa5c5b852a"  # Recent block hash
-            
-            # Get real network difficulty even in fallback
-            diff_url = "https://blockchain.info/q/getdifficulty"
-            try:
-                diff_response = requests.get(diff_url)
-                if diff_response.status_code == 200:
-                    network_difficulty = float(diff_response.text)
-                    target = int((0xffff * 2**(8*(0x1d - 3))) / network_difficulty)
-                else:
-                    target = 0x00000000ffff0000000000000000000000000000000000000000000000000000
-            except:
-                target = 0x00000000ffff0000000000000000000000000000000000000000000000000000
-            
-            template = {
-                'version': 0x20000000,
-                'previous_block': prev_block,
-                'merkle_root': '4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b',
-                'timestamp': int(time.time()),
-                'bits': 0x1d00ffff,
-                'target': target,
-                'height': block_height,
-                'network_difficulty': network_difficulty if 'network_difficulty' in locals() else None
-            }
-            return template
-        try:
-            # Get latest block info
-            response = requests.get(self.bitcoin_network.latest_block_url)
-            if response.status_code != 200:
-                raise Exception("Failed to get latest block")
-            
-            latest = response.json()
-            # Construct proper block template with real network data
-            template = {
-                'version': 0x20000000,  # Version 2 with BIP9 bits
-                'previousblockhash': prev_block,  # Changed to match Bitcoin Core naming
-                'merkleroot': '0' * 64,  # Will be calculated from transactions
-                'time': int(time.time()),  # Current time
-                'bits': bits_int,  # Using parsed bits value
-                'height': height,
-                'target': target,
-                'difficulty': network_difficulty,
-                'coinbasetx': coinbase_tx,
-                'sizelimit': 4000000,  # 4MB block size limit
-                'transactions': []  # Pending transactions (empty for now)
-            }
-            return template
-        except Exception as e:
-            print(f"Error getting block template: {str(e)}")
-            # Create fallback template
-            template = {
-                'version': 0x20000000,  # Version 2 with BIP9 bits
-                'previousblockhash': '000000000000000000024bead8df69990852c202db0e0097c1a12ea637d7e96d',
-                'merkleroot': '4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b',
-                'time': int(time.time()),
-                'bits': 0x1d00ffff,
-                'target': 0x00000000ffff0000000000000000000000000000000000000000000000000000,
-                'height': 2_500_000,
-                'difficulty': 1.0,
-                'coinbasetx': {
-                    'version': 1,
-                    'vin': [{
-                        'txid': '0' * 64,
-                        'vout': 0xFFFFFFFF,
-                        'scriptSig': '03' + hex(2_500_000)[2:].zfill(6) + '0000000000000000',
-                        'sequence': 0xFFFFFFFF
-                    }],
-                    'vout': [{
-                        'value': 625000000,
-                        'scriptPubKey': '76a914' + hashlib.new("ripemd160", hashlib.sha256(self.wallet_address.encode()).digest()).hexdigest() + '88ac'
-                    }]
-                },
-                'sizelimit': 4000000,
-                'transactions': []
-            }
-            return template
-        
-    def submit_block(self, block_header: bytes, nonce: int) -> bool:
-        """Submit found block to network"""
-        try:
-            # Get current template
-            template = self.get_block_template()
-            
-            # Create block data starting with header including nonce
-            block_data = bytearray(block_header[:-4] + struct.pack('<I', nonce))
-            
-            # Add transaction count varint (1 for coinbase only)
-            block_data.extend(bytes([1]))
-            
-            # Create proper coinbase transaction
-            block_height = template['height']
-            block_height_hex = hex(block_height)[2:].zfill(6)  # BIP34: Block height
-            
-            # Create proper coinbase script
-            coinbase_script = bytes.fromhex(
-                "03" +  # Push 3 bytes
-                block_height_hex +  # Block height (BIP34)
-                "0000000000000000" +  # Extra nonce
-                "2f4d696e656420627920426974436f696e2d436f70696c6f742f"  # /Mined by BitCoin-Copilot/
-            )
-            
-            # Start serializing the coinbase transaction
-            tx_data = struct.pack('<I', 1)  # Version 1
-            
-            # Input count (always 1 for coinbase)
-            tx_data += bytes([1])
-            
-            # Coinbase input with proper null txid (must be exactly 32 bytes)
-            tx_data += b'\x00' * 32  # Previous txid (null for coinbase)
-            tx_data += struct.pack('<I', 0xFFFFFFFF)  # Previous output index (-1 for coinbase)
-            
-            # Create proper coinbase input script with proper length prefix
-            script_len = len(coinbase_script)
-            if script_len < 0xfd:
-                tx_data += bytes([script_len])
-            elif script_len <= 0xffff:
-                tx_data += bytes([0xfd]) + struct.pack('<H', script_len)
-            elif script_len <= 0xffffffff:
-                tx_data += bytes([0xfe]) + struct.pack('<I', script_len)
-            else:
-                tx_data += bytes([0xff]) + struct.pack('<Q', script_len)
-            
-            tx_data += coinbase_script  # Coinbase script
-            tx_data += struct.pack('<I', 0xFFFFFFFF)  # Sequence
-            
-            # Output count (1 output paying the miner)
-            tx_data += bytes([1])
-            
-            # Miner's reward output (6.25 BTC)
-            tx_data += struct.pack('<Q', 625000000)  # Value in satoshis
-            
-            # Create proper P2PKH script for payout
-            # First decode the base58 address to get the pubkey hash
-            from base58 import b58decode_check
-            decoded = b58decode_check(self.wallet_address)
-            pubkey_hash = decoded[1:]  # Skip version byte
-            
-            # Build P2PKH script
-            script_pubkey = bytes([0x76, 0xa9, 0x14]) + pubkey_hash + bytes([0x88, 0xac])
-            tx_data += bytes([len(script_pubkey)])  # Script length 
-            tx_data += script_pubkey  # P2PKH script
-            
-            # Add locktime 
-            tx_data += struct.pack('<I', 0)  # nLockTime
-            
-            # Add serialized coinbase transaction to block
-            block_data.extend(tx_data)
-            
-            # Submit block using blockchain.info API
-            submit_url = 'https://api.blockchain.info/haskoin-store/btc/block'
-            headers = {'Content-Type': 'application/x-www-form-urlencoded'}
-            response = requests.post(submit_url, data={'block': block_data.hex()}, headers=headers)
-            
-            if response.status_code == 200:
-                print(f"Block successfully submitted!")
-                logging.info("Block submission successful")
-                return True
-            elif response.status_code == 400 and 'bad-txns-vin-empty' in response.text:
-                print("Block rejected: Invalid coinbase transaction structure")
-                logging.error("Block rejected due to invalid coinbase transaction")
-                return False
-            else:
-                error_msg = response.text if response.text else f"Status code: {response.status_code}"
-                print(f"Block submission failed: {error_msg}")
-                logging.error(f"Block submission failed: {error_msg}")
-                return False
-            
-        except Exception as e:
-            print(f"Error submitting block: {str(e)}")
-            return False
-        try:
-            block_hash = hashlib.sha256(hashlib.sha256(block_header).digest()).digest()
-            return self.bitcoin_network.submit_block(block_header, nonce)
-        except Exception as e:
-            print(f"Block submission error: {e}")
-            return False
-            
-    def _bits_to_target(self, bits: str) -> int:
-        """Convert compact bits to target"""
-        bits = int(bits, 16)
-        shift = (bits >> 24) & 0xff
-        target = (bits & 0x00ffffff) * (2 ** (8 * (shift - 3)))
+"""
+Integrates the mining system with Bitcoin mainnet
+"""
+from typing import Dict, Any, Optional
+import time
+import requests
+import hashlib
+import json
+import logging
+import struct
+
+# Configure detailed logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('network_debug.log'),
+        logging.StreamHandler()
+    ]
+)
+
+class NetworkIntegration:
+    def __init__(self, wallet_address: str = None, use_testnet: bool = False):
+        self.is_mainnet = not use_testnet
+        if use_testnet:
+            self.api_base = "https://testnet.blockchain.info"
+            self.node = "testnet-seed.bitcoin.jonasschnelli.ch"  # Bitcoin testnet seed node
+        else:
+            self.api_base = "https://blockchain.info"  # Changed to more reliable API
+            self.node = "seed.bitcoin.sipa.be"  # Bitcoin mainnet seed node
+        
+        # Use the provided wallet address or load from my_wallet.json
+        if wallet_address:
+            self.wallet_address = wallet_address
+        else:
+            try:
+                with open('my_wallet.json', 'r') as f:
+                    wallet_data = json.load(f)
+                self.wallet_address = wallet_data['address']
+                print(f"Using wallet address: {self.wallet_address}")
+            except Exception as e:
+                print(f"Error loading wallet: {e}")
+                self.wallet_address = "1Ks4WtCEK96BaBF7HSuCGt3rEpVKPqcJKf"  # Your default address
+        
+    def connect(self) -> bool:
+        """Connect to Bitcoin mainnet"""
+        try:
+            # Test connection by getting latest block
+            response = requests.get(f"{self.api_base}/blockchain/blocks/last")
+            return response.status_code == 200
+        except Exception as e:
+            print(f"Failed to connect to mainnet: {e}")
+            return False
+        
+    def get_block_template(self) -> Dict[str, Any]:
+        """Get current block template from mainnet"""
+        try:
+            # Cache the blockchain API response for 5 minutes
+            current_time = time.time()
+            if not hasattr(self, '_template_cache') or current_time - self._last_cache_time > 300:
+                logging.debug("Cache expired, fetching new block template")
+                # Get latest block info from a more reliable API
+                response = requests.get("https://blockchain.info/latestblock")
+                logging.debug(f"Latest block API response status: {response.status_code}")
+                
+                if response.status_code != 200:
+                    logging.error(f"Failed to get latest block. Status code: {response.status_code}")
+                    if hasattr(self, '_template_cache'):
+                        logging.info("Using cached template")
+                        return self._template_cache
+                    raise Exception("Failed to get latest block")
+                    
+                latest = response.json()
+                logging.debug(f"Latest block response: {latest}")
+                
+                height = latest['height']
+                current_block = latest['hash']
+                logging.info(f"Current block height: {height}, hash: {current_block}")
+                
+                # Get current network stats and difficulty
+                logging.debug("Fetching network stats...")
+                diff_response = requests.get("https://blockchain.info/q/getdifficulty")
+                if diff_response.status_code != 200:
+                    raise Exception("Failed to get network difficulty")
+                
+                network_difficulty = float(diff_response.text)
+                logging.info(f"Current network difficulty: {network_difficulty}")
+                
+                # Calculate target from real network difficulty
+                max_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
+                target = int(max_target / network_difficulty)
+                
+                # Calculate bits from real target
+                exp = 0x1d
+                coeff = (target >> (8 * (0x1d - 3))) & 0xffffff
+                bits = (exp << 24) | coeff
+                
+                logging.debug(f"Target calculated from difficulty: {hex(target)}")
+                current_target = target  # Use actual network target
+                
+                # Create block template
+                template = {
+                    'version': 2,
+                    'previousblockhash': current_block,
+                    'merkleroot': '0' * 64,  # Placeholder merkle root
+                    'time': int(time.time()),
+                    'bits': bits,
+                    'target': current_target,
+                    'height': height
+                }
+                
+                logging.debug(f"Target calculated from bits {hex(bits)}: {hex(current_target)}")
+                
+                # Construct template with required fields
+                template = {
+                    'version': 2,  # Current Bitcoin version
+                    'previousblockhash': current_block,  # Use current block as previous for next block
+                    'merkleroot': '0' * 64,  # Placeholder merkle root
+                    'time': int(time.time()),
+                    'bits': bits,  # Original bits value
+                    'height': int(height),  # Ensure height is integer
+                    'target': current_target  # Correctly calculated target from bits
+                }
+                
+                # Update cache
+                self._template_cache = template
+                self._last_cache_time = current_time
+                
+            return self._template_cache
+            
+        except Exception as e:
+            logging.error(f"Error getting block template: {str(e)}")
+            # Return fallback template
+            # Get real mainnet difficulty from blockchain.info
+            diff_url = "https://blockchain.info/q/getdifficulty"
+            try:
+                diff_response = requests.get(diff_url)
+                if diff_response.status_code == 200:
+                    network_difficulty = float(diff_response.text)
+                    bits = hex(int((0xffff * 2**(8*(0x1d - 3))) / network_difficulty))[2:]
+                    target = int((0xffff * 2**(8*(0x1d - 3))) / network_difficulty)
+                    logging.info(f"Got mainnet difficulty: {network_difficulty}")
+                else:
+                    # Use more reasonable fallback difficulty for mainnet
+                    network_difficulty = 137533144484879.19  # Recent mainnet difficulty
+                    target = int((0xffff * 2**(8*(0x1d - 3))) / network_difficulty)
+                    bits = f"{0x1d:02x}{target & 0xffffff:06x}"
+            except Exception as e:
+                logging.error(f"Error getting mainnet difficulty: {e}")
+                # Use more reasonable fallback difficulty for mainnet
+                network_difficulty = 137533144484879.19  # Recent mainnet difficulty
+                target = int((0xffff * 2**(8*(0x1d - 3))) / network_difficulty)
+                bits = f"{0x1d:02x}{target & 0xffffff:06x}"
+            
+            return {
+                'version': 2,
+                'previousblockhash': '0' * 64,
+                'merkleroot': '0' * 64,
+                'time': int(time.time()),
+                'bits': bits,
+                'height': 0,
+                'target': target
+            }
+            
+              
+        except Exception as e:
+            logging.error(f"Error getting block template: {str(e)}")
+            # Use fallback difficulty and target
+            network_difficulty = 137533144484879.19  # Recent mainnet difficulty
+            max_target = 0x00000000FFFF0000000000000000000000000000000000000000000000000000
+            target = int(max_target / network_difficulty)
+            bits = f"{0x1d:02x}{(target >> 208) & 0xffffff:06x}"
+            
+            logging.info(f"Using fallback difficulty: {network_difficulty}")
+            block_height = 917362  # Recent block height
+            prev_block = "00000000000000000000635542f008dfb9ba9f4d25e53539c62918aa5c5b852a"  # Recent block hash
+            
+            # Get real network difficulty even in fallback
+            diff_url = "https://blockchain.info/q/getdifficulty"
+            try:
+                diff_response = requests.get(diff_url)
+                if diff_response.status_code == 200:
+                    network_difficulty = float(diff_response.text)
+                    target = int((0xffff * 2**(8*(0x1d - 3))) / network_difficulty)
+                else:
+                    target = 0x00000000ffff0000000000000000000000000000000000000000000000000000
+            except:
+                target = 0x00000000ffff0000000000000000000000000000000000000000000000000000
+            
+            template = {
+                'version': 0x20000000,
+                'previous_block': prev_block,
+                'merkle_root': '4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b',
+                'timestamp': int(time.time()),
+                'bits': 0x1d00ffff,
+                'target': target,
+                'height': block_height,
+                'network_difficulty': network_difficulty if 'network_difficulty' in locals() else None
+            }
+            return template
+        try:
+            # Get latest block info
+            response = requests.get(self.bitcoin_network.latest_block_url)
+            if response.status_code != 200:
+                raise Exception("Failed to get latest block")
+            
+            latest = response.json()
+            # Construct proper block template with real network data
+            template = {
+                'version': 0x20000000,  # Version 2 with BIP9 bits
+                'previousblockhash': prev_block,  # Changed to match Bitcoin Core naming
+                'merkleroot': '0' * 64,  # Will be calculated from transactions
+                'time': int(time.time()),  # Current time
+                'bits': bits_int,  # Using parsed bits value
+                'height': height,
+                'target': target,
+                'difficulty': network_difficulty,
+                'coinbasetx': coinbase_tx,
+                'sizelimit': 4000000,  # 4MB block size limit
+                'transactions': []  # Pending transactions (empty for now)
+            }
+            return template
+        except Exception as e:
+            print(f"Error getting block template: {str(e)}")
+            # Create fallback template
+            template = {
+                'version': 0x20000000,  # Version 2 with BIP9 bits
+                'previousblockhash': '000000000000000000024bead8df69990852c202db0e0097c1a12ea637d7e96d',
+                'merkleroot': '4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b',
+                'time': int(time.time()),
+                'bits': 0x1d00ffff,
+                'target': 0x00000000ffff0000000000000000000000000000000000000000000000000000,
+                'height': 2_500_000,
+                'difficulty': 1.0,
+                'coinbasetx': {
+                    'version': 1,
+                    'vin': [{
+                        'txid': '0' * 64,
+                        'vout': 0xFFFFFFFF,
+                        'scriptSig': '03' + hex(2_500_000)[2:].zfill(6) + '0000000000000000',
+                        'sequence': 0xFFFFFFFF
+                    }],
+                    'vout': [{
+                        'value': 625000000,
+                        'scriptPubKey': '76a914' + hashlib.new("ripemd160", hashlib.sha256(self.wallet_address.encode()).digest()).hexdigest() + '88ac'
+                    }]
+                },
+                'sizelimit': 4000000,
+                'transactions': []
+            }
+            return template
+        
+    def submit_block(self, block_header: bytes, nonce: int) -> bool:
+        """Submit found block to network"""
+        try:
+            # Get current template
+            template = self.get_block_template()
+            
+            # Verify the block hash first
+            full_header = block_header[:-4] + struct.pack('<I', nonce)
+            block_hash = hashlib.sha256(hashlib.sha256(full_header).digest()).digest()
+            block_hash_hex = block_hash.hex()
+            block_hash_int = int.from_bytes(block_hash, 'little')
+            
+            # Log detailed hash information
+            logging.info(f"Block hash: {block_hash_hex}")
+            logging.info(f"Leading zeros: {len(block_hash_hex) - len(block_hash_hex.lstrip('0'))}")
+            logging.info(f"Hash value: {int(block_hash_hex, 16)}")
+            logging.info(f"Target value: {template['target']}")
+            
+            if block_hash_int >= template['target']:
+                logging.error("Block hash doesn't meet target requirement")
+                logging.error(f"Hash/Target ratio: {block_hash_int / template['target']:.2f}")
+                return False
+                
+            # Create block data starting with header including nonce
+            block_data = bytearray(full_header)
+            
+            # Add transaction count varint (1 for coinbase only)
+            block_data.extend(bytes([1]))
+            
+            # Create proper coinbase transaction with our wallet address
+            block_height = template['height']
+            block_height_hex = hex(block_height)[2:].zfill(6)  # BIP34: Block height
+            
+            # Create proper coinbase script with required elements
+            coinbase_script = (
+                bytes([3]) +  # Push 3 bytes (block height)
+                bytes.fromhex(block_height_hex) +  # Block height (BIP34)
+                bytes.fromhex("0000000000000000") +  # Extra nonce space
+                b"/Mined by Elias/"  # Miner tag
+            )
+            
+            # Import required for base58 decoding
+            from base58 import b58decode_check
+            
+            # Decode wallet address to get public key hash
+            try:
+                decoded = b58decode_check(self.wallet_address)
+                pubkey_hash = decoded[1:]  # Remove version byte
+            except Exception as e:
+                logging.error(f"Error decoding wallet address: {e}")
+                return False
+            
+            # Create complete coinbase transaction
+            coinbase_tx = (
+                struct.pack('<I', 1) +  # Version
+                bytes([1]) +  # Input count
+                bytes.fromhex('0' * 64) +  # Previous tx hash (null for coinbase)
+                struct.pack('<I', 0xFFFFFFFF) +  # Previous output index
+                bytes([len(coinbase_script)]) +  # Script length
+                coinbase_script +  # Coinbase script
+                struct.pack('<I', 0xFFFFFFFF) +  # Sequence
+                bytes([1]) +  # Output count
+                struct.pack('<Q', 625000000) +  # 6.25 BTC reward in satoshis
+                bytes([25]) +  # Output script length (25 bytes for P2PKH)
+                bytes([
+                    0x76,  # OP_DUP
+                    0xa9,  # OP_HASH160
+                    0x14   # Push 20 bytes
+                ]) +
+                pubkey_hash +  # Public key hash from decoded address
+                bytes([
+                    0x88,  # OP_EQUALVERIFY
+                    0xac   # OP_CHECKSIG
+                ]) +
+                struct.pack('<I', 0)  # Locktime
+            )
+            
+            # Add coinbase transaction to block
+            block_data.extend(coinbase_tx)
+            
+            # Add empty witness commitment
+            block_data.extend(bytes([0]))  # No witness data
+            
+            # Submit to more reliable nodes
+            successful = False
+            nodes = [
+                "https://btc.getblock.io/mainnet/",  # Primary
+                "https://blockchain.info/pushtx",     # Backup 1
+                "https://api.bitcore.io/api/BTC/mainnet/tx/send", # Backup 2
+                self.api_base + "/submitblock"  # Original endpoint as fallback
+            ]
+            
+            for node in nodes:
+                try:
+                    logging.info(f"Attempting submission to {node}")
+                    response = requests.post(
+                        node,
+                        data={'block': block_data.hex()},
+                        headers={'Content-Type': 'application/x-www-form-urlencoded'},
+                        timeout=10
+                    )
+                    
+                    if response.status_code == 200:
+                        logging.info(f"Successfully submitted block {block_hash.hex()}")
+                        logging.info(f"Block reward sent to {self.wallet_address}")
+                        successful = True
+                        break
+                    else:
+                        logging.warning(f"Submission failed for {node}: {response.text}")
+                except Exception as e:
+                    logging.warning(f"Error submitting to {node}: {e}")
+                    continue
+            
+            return successful
+                
+        except Exception as e:
+            logging.error(f"Error submitting block: {str(e)}")
+            return False
+            
+            # Start serializing the coinbase transaction
+            tx_data = struct.pack('<I', 1)  # Version 1
+            
+            # Input count (always 1 for coinbase)
+            tx_data += bytes([1])
+            
+            # Coinbase input with proper null txid (must be exactly 32 bytes)
+            tx_data += b'\x00' * 32  # Previous txid (null for coinbase)
+            tx_data += struct.pack('<I', 0xFFFFFFFF)  # Previous output index (-1 for coinbase)
+            
+            # Create proper coinbase input script with proper length prefix
+            script_len = len(coinbase_script)
+            if script_len < 0xfd:
+                tx_data += bytes([script_len])
+            elif script_len <= 0xffff:
+                tx_data += bytes([0xfd]) + struct.pack('<H', script_len)
+            elif script_len <= 0xffffffff:
+                tx_data += bytes([0xfe]) + struct.pack('<I', script_len)
+            else:
+                tx_data += bytes([0xff]) + struct.pack('<Q', script_len)
+            
+            tx_data += coinbase_script  # Coinbase script
+            tx_data += struct.pack('<I', 0xFFFFFFFF)  # Sequence
+            
+            # Output count (1 output paying the miner)
+            tx_data += bytes([1])
+            
+            # Miner's reward output (6.25 BTC)
+            tx_data += struct.pack('<Q', 625000000)  # Value in satoshis
+            
+            # Create proper P2PKH script for payout
+            # First decode the base58 address to get the pubkey hash
+            from base58 import b58decode_check
+            decoded = b58decode_check(self.wallet_address)
+            pubkey_hash = decoded[1:]  # Skip version byte
+            
+            # Build P2PKH script
+            script_pubkey = bytes([0x76, 0xa9, 0x14]) + pubkey_hash + bytes([0x88, 0xac])
+            tx_data += bytes([len(script_pubkey)])  # Script length 
+            tx_data += script_pubkey  # P2PKH script
+            
+            # Add locktime 
+            tx_data += struct.pack('<I', 0)  # nLockTime
+            
+            # Add serialized coinbase transaction to block
+            block_data.extend(tx_data)
+            
+            # Submit block using blockchain.info API
+            submit_url = 'https://api.blockchain.info/haskoin-store/btc/block'
+            headers = {'Content-Type': 'application/x-www-form-urlencoded'}
+            response = requests.post(submit_url, data={'block': block_data.hex()}, headers=headers)
+            
+            if response.status_code == 200:
+                print(f"Block successfully submitted!")
+                logging.info("Block submission successful")
+                return True
+            elif response.status_code == 400 and 'bad-txns-vin-empty' in response.text:
+                print("Block rejected: Invalid coinbase transaction structure")
+                logging.error("Block rejected due to invalid coinbase transaction")
+                return False
+            else:
+                error_msg = response.text if response.text else f"Status code: {response.status_code}"
+                print(f"Block submission failed: {error_msg}")
+                logging.error(f"Block submission failed: {error_msg}")
+                return False
+            
+        except Exception as e:
+            print(f"Error submitting block: {str(e)}")
+            return False
+        try:
+            block_hash = hashlib.sha256(hashlib.sha256(block_header).digest()).digest()
+            return self.bitcoin_network.submit_block(block_header, nonce)
+        except Exception as e:
+            print(f"Block submission error: {e}")
+            return False
+            
+    def _bits_to_target(self, bits: str) -> int:
+        """Convert compact bits to target"""
+        bits = int(bits, 16)
+        shift = (bits >> 24) & 0xff
+        target = (bits & 0x00ffffff) * (2 ** (8 * (shift - 3)))
         return target