lunalib 1.5.2__py3-none-any.whl → 1.6.6__py3-none-any.whl

lunalib/mining/miner.py

@@ -18,6 +18,7 @@ from ..gtx.digital_bill import DigitalBill
 from ..transactions.transactions import TransactionManager
 from ..core.blockchain import BlockchainManager
 from ..core.mempool import MempoolManager
+from ..mining.cuda_manager import CUDAManager
 
 class GenesisMiner:
     """Mines GTX Genesis bills AND regular transfer transactions with configurable difficulty"""
@@ -74,7 +75,7 @@ class GenesisMiner:
                 
                 safe_print(f"✅ Successfully mined GTX ${denomination:,} bill!")
                 safe_print(f"⏱️ Mining time: {mining_time:.2f}s")
-                safe_print(f"📊 Hash attempts: {mining_result['nonce']:,}")
+                safe_print(f" Hash attempts: {mining_result['nonce']:,}")
                 safe_print(f"🔗 Bill hash: {mining_result['hash'][:32]}...")
                 
                 # Convert to GTX Genesis transaction
@@ -174,7 +175,7 @@ class GenesisMiner:
                 safe_print(f"✅ Successfully mined and validated Transaction Block #{block_height}!")
                 safe_print(f"⏱️ Mining time: {mining_time:.2f}s")
                 safe_print(f"💰 Block reward: {block['reward']:.6f} LUN")
-                safe_print(f"📊 Transactions: {block['transaction_count']}")
+                safe_print(f" Transactions: {block['transaction_count']}")
                 safe_print(f"🔗 Block hash: {mining_result['hash'][:32]}...")
                 
                 # Submit block to blockchain
@@ -298,7 +299,7 @@ class GenesisMiner:
             # Calculate merkleroot from transactions
             merkleroot = self._calculate_merkleroot(transactions)
             
-            print(f"📊 Mining proof components:")
+            print(f"  Mining proof components:")
             print(f"  Block hash: {block_hash[:16]}...")
             print(f"  Difficulty: {difficulty}")
             print(f"  Nonce: {nonce}")
@@ -623,4 +624,484 @@ class GenesisMiner:
             return {
                 "network_connected": False,
                 "error": str(e)
-            }
+            }
+
+class Miner:
+    """
+    Robust miner class that integrates with BlockchainManager, MempoolManager, 
+    DifficultySystem, and security validation to mine all transaction types.
+    """
+
+    def __init__(self, config, data_manager, mining_started_callback=None, mining_completed_callback=None, block_mined_callback=None):
+        self.config = config
+        self.data_manager = data_manager
+        self.is_mining = False
+        self.blocks_mined = 0
+        self.total_reward = 0.0
+        self.mining_started_callback = mining_started_callback
+        self.mining_completed_callback = mining_completed_callback
+        self.block_mined_callback = block_mined_callback
+
+        self.mining_history = self.data_manager.load_mining_history()
+
+        # Initialize lunalib components
+        self.blockchain_manager = BlockchainManager(endpoint_url=config.node_url)
+        self.mempool_manager = MempoolManager([config.node_url])
+        self.difficulty_system = DifficultySystem()
+        self.cuda_manager = CUDAManager()
+        
+        # Import security components
+        try:
+            from ..transactions.security import SecurityManager
+            from ..transactions.validator import TransactionValidator
+            self.security_manager = SecurityManager()
+            self.transaction_validator = TransactionValidator()
+        except ImportError:
+            self.security_manager = None
+            self.transaction_validator = None
+
+        self.current_hash = ""
+        self.current_nonce = 0
+        self.hash_rate = 0
+        self.mining_thread = None
+        self.should_stop_mining = False
+
+    def mine_block(self) -> tuple[bool, str, Optional[Dict]]:
+        """
+        Mine a block from the mempool with proper validation and difficulty calculation.
+        Returns: (success, message, block_data)
+        """
+        try:
+            # Get the latest block from the blockchain
+            latest_block = self.blockchain_manager.get_latest_block()
+            if not latest_block:
+                return False, "Could not get latest block from server", None
+
+            current_index = latest_block.get('index', 0)
+            previous_hash = latest_block.get('hash', '0' * 64)
+            new_index = current_index + 1
+
+            # Get fresh transactions from mempool
+            mempool = self._get_fresh_mempool()
+            
+            # Validate all transactions
+            valid_transactions = self._validate_transactions(mempool)
+            
+            # If no valid transactions, create a reward transaction
+            if not valid_transactions:
+                reward_tx = self._create_empty_block_reward(new_index)
+                valid_transactions = [reward_tx]
+
+            # Calculate block difficulty based on transactions
+            block_difficulty = self._calculate_block_difficulty(valid_transactions)
+            
+            # Calculate block reward using exponential difficulty system
+            total_reward = self._calculate_exponential_block_reward(block_difficulty)
+
+            # Create block data
+            block_data = {
+                'index': new_index,
+                'previous_hash': previous_hash,
+                'timestamp': time.time(),
+                'transactions': valid_transactions,
+                'miner': self.config.miner_address,
+                'difficulty': block_difficulty,
+                'nonce': 0,
+                'reward': total_reward,
+                'hash': ''
+            }
+
+            # Try CUDA mining first if available
+            if self.cuda_manager and self.cuda_manager.cuda_available:
+                cuda_result = self._cuda_mine(block_data, block_difficulty)
+                if cuda_result:
+                    return self._finalize_block(cuda_result, 'cuda', total_reward)
+
+            # Fallback to CPU mining
+            cpu_result = self._cpu_mine(block_data, block_difficulty)
+            if cpu_result:
+                return self._finalize_block(cpu_result, 'cpu', total_reward)
+
+            return False, "Mining timeout - no solution found", None
+
+        except Exception as e:
+            return False, f"Mining error: {str(e)}", None
+
+    def _get_fresh_mempool(self) -> List[Dict]:
+        """Get fresh mempool transactions with validation"""
+        try:
+            mempool = self.mempool_manager.get_pending_transactions()
+            if not mempool:
+                mempool = self.blockchain_manager.get_mempool()
+            return mempool if mempool else []
+        except Exception as e:
+            safe_print(f"Error fetching mempool: {e}")
+            return []
+
+    def _validate_transactions(self, transactions: List[Dict]) -> List[Dict]:
+        """Validate transactions using security manager"""
+        valid_transactions = []
+        
+        for tx in transactions:
+            try:
+                # Basic validation
+                if not self._validate_transaction_structure(tx):
+                    continue
+                
+                # Security validation if available
+                if self.transaction_validator:
+                    if not self.transaction_validator.validate_transaction(tx):
+                        continue
+                
+                valid_transactions.append(tx)
+            except Exception as e:
+                safe_print(f"Transaction validation error: {e}")
+                continue
+        
+        return valid_transactions
+
+    def _validate_transaction_structure(self, tx: Dict) -> bool:
+        """Basic transaction structure validation"""
+        required_fields = ['type', 'timestamp']
+        
+        for field in required_fields:
+            if field not in tx:
+                return False
+        
+        tx_type = tx.get('type')
+        
+        if tx_type == 'transaction':
+            if not all(k in tx for k in ['from', 'to', 'amount']):
+                return False
+        elif tx_type == 'genesis_bill':
+            if 'denomination' not in tx:
+                return False
+        elif tx_type == 'reward':
+            if not all(k in tx for k in ['to', 'amount']):
+                return False
+        
+        return True
+
+    def _calculate_block_difficulty(self, transactions: List[Dict]) -> int:
+        """Calculate block difficulty based on transactions using DifficultySystem"""
+        if not transactions:
+            return self.config.difficulty
+
+        max_difficulty = self.config.difficulty
+
+        for tx in transactions:
+            tx_type = tx.get('type')
+            
+            if tx_type == 'genesis_bill':
+                denomination = tx.get('denomination', 0)
+                tx_difficulty = self.difficulty_system.get_bill_difficulty(denomination)
+                max_difficulty = max(max_difficulty, tx_difficulty)
+            elif tx_type == 'transaction':
+                amount = tx.get('amount', 0)
+                tx_difficulty = self.difficulty_system.get_transaction_difficulty(amount)
+                max_difficulty = max(max_difficulty, tx_difficulty)
+            elif tx_type == 'reward':
+                max_difficulty = max(max_difficulty, 1)
+
+        return max(max_difficulty, self.config.difficulty)
+
+    def _calculate_block_reward(self, transactions: List[Dict]) -> float:
+        """Calculate total block reward based on transactions using DifficultySystem"""
+        total_reward = 0.0
+
+        for tx in transactions:
+            tx_type = tx.get('type')
+            
+            if tx_type == 'genesis_bill':
+                denomination = tx.get('denomination', 0)
+                # Use difficulty system to calculate proper reward
+                bill_difficulty = self.difficulty_system.get_bill_difficulty(denomination)
+                avg_mining_time = 15.0  # Will be updated with actual time
+                bill_reward = self.difficulty_system.calculate_mining_reward(denomination, avg_mining_time)
+                total_reward += bill_reward
+            elif tx_type == 'transaction':
+                fee = tx.get('fee', 0)
+                total_reward += fee
+            elif tx_type == 'reward':
+                reward_amount = tx.get('amount', 0)
+                total_reward += reward_amount
+
+        # Minimum reward for empty blocks
+        if total_reward == 0:
+            total_reward = 1.0
+
+        return total_reward
+    
+    def _calculate_exponential_block_reward(self, difficulty: int) -> float:
+        """Calculate block reward using exponential difficulty system
+        
+        Uses the new exponential reward system:
+        difficulty 1 = 1 LKC
+        difficulty 2 = 10 LKC  
+        difficulty 3 = 100 LKC
+        difficulty 9 = 100,000,000 LKC
+        """
+        return self.difficulty_system.calculate_block_reward(difficulty)
+
+    def _create_empty_block_reward(self, block_index: int) -> Dict:
+        """Create reward transaction for empty blocks"""
+        return {
+            'type': 'reward',
+            'from': 'network',
+            'to': self.config.miner_address,
+            'amount': 1.0,
+            'timestamp': time.time(),
+            'block_height': block_index,
+            'hash': f"reward_{block_index}_{int(time.time())}",
+            'description': 'Empty block mining reward'
+        }
+
+    def _cuda_mine(self, block_data: Dict, difficulty: int) -> Optional[Dict]:
+        """Mine using CUDA acceleration"""
+        try:
+            safe_print("Attempting CUDA mining...")
+            cuda_result = self.cuda_manager.cuda_mine_batch(
+                block_data, difficulty, batch_size=100000
+            )
+            if cuda_result and cuda_result.get('success'):
+                block_data['hash'] = cuda_result['hash']
+                block_data['nonce'] = cuda_result['nonce']
+                return block_data
+        except Exception as e:
+            safe_print(f"CUDA mining failed: {e}")
+        return None
+
+    def _cpu_mine(self, block_data: Dict, difficulty: int) -> Optional[Dict]:
+        """Mine using CPU"""
+        safe_print("Using CPU mining...")
+        start_time = time.time()
+        target = "0" * difficulty
+        nonce = 0
+        hash_count = 0
+        last_hash_update = start_time
+
+        while not self.should_stop_mining and nonce < 1000000:
+            # Calculate block hash
+            block_hash = self._calculate_block_hash(
+                block_data['index'],
+                block_data['previous_hash'],
+                block_data['timestamp'],
+                block_data['transactions'],
+                nonce,
+                block_data['miner'],
+                difficulty
+            )
+
+            if block_hash.startswith(target):
+                block_data['hash'] = block_hash
+                block_data['nonce'] = nonce
+                return block_data
+
+            nonce += 1
+            hash_count += 1
+            self.current_nonce = nonce
+            self.current_hash = block_hash
+
+            # Update hash rate
+            current_time = time.time()
+            if current_time - last_hash_update >= 1:
+                self.hash_rate = hash_count / (current_time - last_hash_update)
+                hash_count = 0
+                last_hash_update = current_time
+
+            if nonce % 1000 == 0 and not self.is_mining:
+                return None
+
+        return None
+
+    def _calculate_block_hash(self, index: int, previous_hash: str, timestamp: float, 
+                             transactions: List[Dict], nonce: int, miner: str, difficulty: int) -> str:
+        """Calculate SHA-256 hash of a block matching server validation"""
+        try:
+            block_data = {
+                "difficulty": int(difficulty),
+                "index": int(index),
+                "miner": str(miner),
+                "nonce": int(nonce),
+                "previous_hash": str(previous_hash),
+                "timestamp": float(timestamp),
+                "transactions": [],  # Empty for mining proof
+                "version": "1.0"
+            }
+
+            block_string = json.dumps(block_data, sort_keys=True)
+            calculated_hash = hashlib.sha256(block_string.encode()).hexdigest()
+            return calculated_hash
+
+        except Exception as e:
+            safe_print(f"Hash calculation error: {e}")
+            return "0" * 64
+
+    def _finalize_block(self, block_data: Dict, method: str, total_reward: float) -> tuple[bool, str, Dict]:
+        """Finalize mined block with proper record keeping and blockchain submission"""
+        mining_time = time.time() - block_data.get('timestamp', time.time())
+
+        # Validate block before submission
+        validation_result = self._validate_mined_block(block_data)
+        if not validation_result[0]:
+            safe_print(f"❌ Block validation failed: {validation_result[1]}")
+            return False, f"Block validation failed: {validation_result[1]}", None
+
+        # Block reward is already calculated based on difficulty (exponential system)
+        final_reward = block_data['reward']
+
+        # Submit block to blockchain
+        try:
+            submission_success = self.blockchain_manager.submit_mined_block(block_data)
+            
+            if not submission_success:
+                safe_print(f"⚠️  Block #{block_data['index']} submission failed")
+                return False, f"Block #{block_data['index']} mined but submission failed", None
+            
+            safe_print(f"✅ Block #{block_data['index']} submitted successfully (Reward: {final_reward} LKC)")
+            
+            # Clear mined transactions from mempool
+            self._clear_transactions_from_mempool(block_data['transactions'])
+            
+        except Exception as e:
+            safe_print(f"❌ Block submission error: {e}")
+            return False, f"Block submission error: {str(e)}", None
+
+        # Record mining history
+        mining_record = {
+            'block_index': block_data['index'],
+            'timestamp': time.time(),
+            'mining_time': mining_time,
+            'difficulty': block_data['difficulty'],
+            'nonce': block_data['nonce'],
+            'hash': block_data['hash'],
+            'method': method,
+            'reward': final_reward,
+            'status': 'success'
+        }
+        self.mining_history.append(mining_record)
+        self.save_mining_history()
+
+        self.blocks_mined += 1
+        self.total_reward += final_reward
+
+        if self.mining_completed_callback:
+            self.mining_completed_callback(True, f"Block #{block_data['index']} mined - Reward: {final_reward}")
+
+        if self.block_mined_callback:
+            self.block_mined_callback(block_data)
+
+        return True, f"Block #{block_data['index']} mined - Reward: {final_reward}", block_data
+    
+    def _validate_mined_block(self, block: Dict) -> tuple:
+        """Validate mined block before submission
+        
+        Returns: (is_valid, error_message)
+        """
+        # Validate structure
+        is_valid, error = self.difficulty_system.validate_block_structure(block)
+        if not is_valid:
+            return False, error
+        
+        # Validate hash meets difficulty
+        block_hash = block.get('hash', '')
+        difficulty = block.get('difficulty', 0)
+        
+        if not self.difficulty_system.validate_block_hash(block_hash, difficulty):
+            return False, f"Hash does not meet difficulty {difficulty} requirement"
+        
+        # Validate previous hash (get from blockchain)
+        try:
+            latest_block = self.blockchain_manager.get_latest_block()
+            if latest_block:
+                expected_prev_hash = latest_block.get('hash', '')
+                if block.get('previous_hash') != expected_prev_hash:
+                    return False, f"Previous hash mismatch: expected {expected_prev_hash[:16]}..., got {block.get('previous_hash', '')[:16]}..."
+        except Exception as e:
+            safe_print(f"⚠️  Could not validate previous hash: {e}")
+        
+        # Validate reward matches difficulty
+        expected_reward = self.difficulty_system.calculate_block_reward(difficulty)
+        actual_reward = block.get('reward', 0)
+        
+        # Allow some tolerance for floating point comparison
+        if abs(actual_reward - expected_reward) > 0.01:
+            return False, f"Reward mismatch: expected {expected_reward} LKC for difficulty {difficulty}, got {actual_reward} LKC"
+        
+        safe_print(f"✅ Block validation passed: Hash meets difficulty {difficulty}, Reward: {actual_reward} LKC")
+        return True, ""
+    
+    def _clear_transactions_from_mempool(self, transactions: List[Dict]):
+        """Remove mined transactions from mempool"""
+        try:
+            for tx in transactions:
+                # Skip reward transactions (they were created during mining)
+                if tx.get('type') == 'reward' and tx.get('from') == 'network':
+                    continue
+                
+                tx_hash = tx.get('hash')
+                if tx_hash:
+                    # Remove from mempool manager if available
+                    try:
+                        self.mempool_manager.remove_transaction(tx_hash)
+                    except:
+                        pass  # Silent fail if method doesn't exist
+            
+            safe_print(f"🧹 Cleared {len(transactions)} transactions from mempool")
+            
+        except Exception as e:
+            safe_print(f"⚠️  Error clearing mempool: {e}")
+
+    def _calculate_final_reward(self, transactions: List[Dict], actual_mining_time: float) -> float:
+        """Calculate final reward using actual mining time"""
+        total_reward = 0.0
+
+        for tx in transactions:
+            tx_type = tx.get('type')
+            
+            if tx_type == 'genesis_bill':
+                denomination = tx.get('denomination', 0)
+                bill_reward = self.difficulty_system.calculate_mining_reward(denomination, actual_mining_time)
+                total_reward += bill_reward
+            elif tx_type == 'transaction':
+                total_reward += tx.get('fee', 0)
+            elif tx_type == 'reward':
+                total_reward += tx.get('amount', 0)
+
+        if total_reward == 0:
+            total_reward = 1.0
+
+        return total_reward
+
+    def save_mining_history(self):
+        """Save mining history to storage"""
+        self.data_manager.save_mining_history(self.mining_history)
+
+    def start_mining(self):
+        """Start the mining process"""
+        if self.is_mining:
+            return
+
+        self.is_mining = True
+        self.should_stop_mining = False
+
+        if self.mining_started_callback:
+            self.mining_started_callback()
+
+    def stop_mining(self):
+        """Stop the mining process"""
+        self.is_mining = False
+        self.should_stop_mining = True
+        if self.mining_thread and self.mining_thread.is_alive():
+            self.mining_thread.join()
+
+    def get_mining_stats(self):
+        """Return the current mining statistics"""
+        return {
+            "blocks_mined": self.blocks_mined,
+            "total_reward": self.total_reward,
+            "current_hash": self.current_hash,
+            "current_nonce": self.current_nonce,
+            "hash_rate": self.hash_rate,
+            "mining_history": len(self.mining_history)
+        }

lunalib/transactions/security.py

@@ -123,22 +123,22 @@ class TransactionSecurity:
             
             # For unsigned test transactions
             if signature in ["system", "unsigned", "test"]:
-                print(f"[SECURITY] Skipping signature check for system/unsigned transaction")
+                safe_print(f"[SECURITY] Skipping signature check for system/unsigned transaction")
                 return True
             
             # Check SM2 signature length (should be 128 hex chars = 64 bytes)
             if len(signature) != 128:
-                print(f"[SECURITY] Invalid SM2 signature length: {len(signature)} (expected 128)")
+                safe_print(f"[SECURITY] Invalid SM2 signature length: {len(signature)} (expected 128)")
                 return False
             
             # Check if all characters are valid hex
             if not all(c in "0123456789abcdefABCDEF" for c in signature):
-                print(f"[SECURITY] Signature contains non-hex characters")
+                safe_print(f"[SECURITY] Signature contains non-hex characters")
                 return False
             
             # Check public key format (should start with '04' for uncompressed)
             if not public_key.startswith('04'):
-                print(f"[SECURITY] Invalid public key format: {public_key[:20]}...")
+                safe_print(f"[SECURITY] Invalid public key format: {public_key[:20]}...")
                 return False
             
             # Use KeyManager for verification if available
@@ -148,15 +148,15 @@ class TransactionSecurity:
                 
                 # Verify signature
                 is_valid = self.key_manager.verify_signature(signing_data, signature, public_key)
-                print(f"[SECURITY] SM2 signature verification: {is_valid}")
+                safe_print(f"[SECURITY] SM2 signature verification: {is_valid}")
                 return is_valid
             
             # Fallback: Basic format check if SM2 not available
-            print(f"[SECURITY] SM2 not available, using basic signature validation")
+            safe_print(f"[SECURITY] SM2 not available, using basic signature validation")
             return len(signature) == 128 and signature.startswith(('04', '03', '02'))
             
         except Exception as e:
-            print(f"[SECURITY] Signature validation error: {e}")
+            safe_print(f"[SECURITY] Signature validation error: {e}")
             return False
     
     def _get_signing_data(self, transaction: Dict) -> str:
@@ -183,7 +183,7 @@ class TransactionSecurity:
     
     def _validate_signature(self, transaction: Dict) -> bool:
         """Legacy signature validation (for backward compatibility)"""
-        print(f"[SECURITY] Using legacy signature validation")
+        safe_print(f"[SECURITY] Using legacy signature validation")
         return self._validate_signature_sm2(transaction)
     
     def _check_rate_limit(self, address: str) -> bool: