lunalib 1.5.1__py3-none-any.whl → 1.7.2__py3-none-any.whl

lunalib/mining/miner.py

@@ -1,5 +1,14 @@
 # lunalib/mining/miner.py
 import time
+import sys
+
+# --- Unicode-safe print for Windows console ---
+def safe_print(*args, **kwargs):
+    try:
+        print(*args, **kwargs)
+    except UnicodeEncodeError:
+        encoding = getattr(sys.stdout, 'encoding', 'utf-8')
+        print(*(str(a).encode(encoding, errors='replace').decode(encoding) for a in args), **kwargs)
 import hashlib
 import json
 import threading
@@ -9,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"""
@@ -28,7 +38,7 @@ class GenesisMiner:
             "total_hash_attempts": 0
         }
         
-        print("🔧 GenesisMiner initialized with integrated lunalib components")
+        safe_print("🔧 GenesisMiner initialized with integrated lunalib components")
     
     def mine_bill(self, denomination: float, user_address: str, bill_data: Dict = None) -> Dict:
         """Mine a GTX Genesis bill using DigitalBill system"""
@@ -43,7 +53,7 @@ class GenesisMiner:
                 bill_data=bill_data or {}
             )
             
-            print(f"⛏️ Mining GTX ${denomination:,} Bill - Difficulty: {difficulty} zeros")
+            safe_print(f"⛏️ Mining GTX ${denomination:,} Bill - Difficulty: {difficulty} zeros")
             
             start_time = time.time()
             mining_result = self._perform_bill_mining(digital_bill, difficulty)
@@ -63,10 +73,10 @@ class GenesisMiner:
                 self.mining_stats["total_mining_time"] += mining_time
                 self.mining_stats["total_hash_attempts"] += mining_result["nonce"]
                 
-                print(f"✅ Successfully mined GTX ${denomination:,} bill!")
-                print(f"⏱️ Mining time: {mining_time:.2f}s")
-                print(f"📊 Hash attempts: {mining_result['nonce']:,}")
-                print(f"🔗 Bill hash: {mining_result['hash'][:32]}...")
+                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"🔗 Bill hash: {mining_result['hash'][:32]}...")
                 
                 # Convert to GTX Genesis transaction
                 gtx_transaction = self._create_gtx_genesis_transaction(bill)
@@ -105,8 +115,8 @@ class GenesisMiner:
             # Calculate block difficulty
             difficulty = self.difficulty_system.get_transaction_block_difficulty(transactions)
             
-            print(f"⛏️ Mining Transaction Block #{block_height} - Difficulty: {difficulty} zeros")
-            print(f"📦 Transactions: {len(transactions)} | Previous Hash: {previous_hash[:16]}...")
+            safe_print(f"⛏️ Mining Transaction Block #{block_height} - Difficulty: {difficulty} zeros")
+            safe_print(f"📦 Transactions: {len(transactions)} | Previous Hash: {previous_hash[:16]}...")
             
             # Create block structure for mining
             block_data = {
@@ -162,20 +172,20 @@ class GenesisMiner:
                 self.mining_stats["total_mining_time"] += mining_time
                 self.mining_stats["total_hash_attempts"] += mining_result["nonce"]
                 
-                print(f"✅ Successfully mined and validated Transaction Block #{block_height}!")
-                print(f"⏱️ Mining time: {mining_time:.2f}s")
-                print(f"💰 Block reward: {block['reward']:.6f} LUN")
-                print(f"📊 Transactions: {block['transaction_count']}")
-                print(f"🔗 Block hash: {mining_result['hash'][:32]}...")
+                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"🔗 Block hash: {mining_result['hash'][:32]}...")
                 
                 # Submit block to blockchain
                 submission_success = self.blockchain_manager.submit_mined_block(block)
                 if submission_success:
-                    print("✅ Block successfully submitted to blockchain!")
+                    safe_print("✅ Block successfully submitted to blockchain!")
                     # Clear mined transactions from local mempool
                     self._clear_mined_transactions(transactions)
                 else:
-                    print("⚠️ Block mined but submission failed")
+                    safe_print("⚠️ Block mined but submission failed")
                 
                 return {
                     "success": True,
@@ -289,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}")
@@ -614,4 +624,503 @@ 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)
+            
+            # Calculate block difficulty based on transactions
+            block_difficulty = self._calculate_block_difficulty(valid_transactions)
+            
+            # Calculate block reward:
+            # - Empty blocks use LINEAR system: difficulty 1 = 1 LKC, difficulty 2 = 2 LKC, etc.
+            # - Blocks with transactions use EXPONENTIAL system: 10^(difficulty-1)
+            if not valid_transactions:
+                # Empty block: linear reward
+                total_reward = float(block_difficulty)
+                reward_tx = self._create_empty_block_reward(new_index, block_difficulty, total_reward)
+                valid_transactions = [reward_tx]
+            else:
+                # Regular block: exponential reward
+                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, difficulty: int, reward_amount: float) -> Dict:
+        """Create reward transaction for empty blocks using LINEAR reward system (difficulty = reward)"""
+        return {
+            'type': 'reward',
+            'from': 'network',
+            'to': self.config.miner_address,
+            'amount': reward_amount,
+            'timestamp': time.time(),
+            'block_height': block_index,
+            'difficulty': difficulty,
+            'hash': f"reward_{block_index}_{int(time.time())}",
+            'description': f'Empty block mining reward (Linear: Difficulty {difficulty} = {reward_amount} LKC)',
+            'is_empty_block': True
+        }
+
+    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
+        # Empty blocks use LINEAR system (difficulty = reward)
+        # Regular blocks use EXPONENTIAL system (10^(difficulty-1))
+        transactions = block.get('transactions', [])
+        is_empty_block = len(transactions) == 1 and transactions[0].get('is_empty_block', False)
+        
+        if is_empty_block:
+            # Empty block: linear reward
+            expected_reward = float(difficulty)
+        else:
+            # Regular block: exponential reward
+            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:
+            reward_type = "Linear" if is_empty_block else "Exponential"
+            return False, f"Reward mismatch ({reward_type}): expected {expected_reward} LKC for difficulty {difficulty}, got {actual_reward} LKC"
+        
+        reward_type = "Linear" if is_empty_block else "Exponential"
+        safe_print(f"✅ Block validation passed ({reward_type}): 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/storage/cache.py

@@ -1,4 +1,13 @@
 import os
+import sys
+
+# --- Unicode-safe print for Windows console ---
+def safe_print(*args, **kwargs):
+    try:
+        print(*args, **kwargs)
+    except UnicodeEncodeError:
+        encoding = getattr(sys.stdout, 'encoding', 'utf-8')
+        print(*(str(a).encode(encoding, errors='replace').decode(encoding) for a in args), **kwargs)
 import sqlite3
 import pickle
 import gzip
@@ -66,7 +75,7 @@ class BlockchainCache:
             conn.commit()
             conn.close()
         except Exception as e:
-            print(f"Cache save error: {e}")
+            safe_print(f"Cache save error: {e}")
     
     def get_block(self, height: int) -> Optional[Dict]:
         """Get block from cache"""
@@ -88,7 +97,7 @@ class BlockchainCache:
                 
             conn.close()
         except Exception as e:
-            print(f"Cache read error: {e}")
+            safe_print(f"Cache read error: {e}")
             
         return None
     
@@ -116,7 +125,7 @@ class BlockchainCache:
                     continue
                     
         except Exception as e:
-            print(f"Block range cache error: {e}")
+            safe_print(f"Block range cache error: {e}")
             
         return blocks
     
@@ -145,4 +154,4 @@ class BlockchainCache:
             conn.commit()
             conn.close()
         except Exception as e:
-            print(f"Cache cleanup error: {e}")
+            safe_print(f"Cache cleanup error: {e}")