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

lunalib/core/p2p.py

@@ -0,0 +1,346 @@
+# lunalib/core/p2p.py
+import time
+import requests
+import threading
+import json
+from typing import List, Dict, Optional, Callable
+from queue import Queue
+import hashlib
+
+
+class P2PClient:
+    """
+    P2P client for blockchain synchronization with hybrid primary/peer architecture.
+    Downloads initial state from primary node, then syncs via P2P with periodic validation.
+    """
+    
+    def __init__(self, primary_node_url: str, node_id: Optional[str] = None):
+        self.primary_node = primary_node_url
+        self.node_id = node_id or self._generate_node_id()
+        self.peers = []
+        self.last_primary_check = 0
+        self.last_peer_update = 0
+        self.peer_update_interval = 300  # 5 minutes
+        self.primary_check_interval = 3600  # 1 hour
+        
+        # Callbacks for events
+        self.on_new_block_callback = None
+        self.on_new_transaction_callback = None
+        self.on_peer_update_callback = None
+        
+        # P2P message queue
+        self.message_queue = Queue()
+        self.is_running = False
+        self.sync_thread = None
+        
+    def _generate_node_id(self) -> str:
+        """Generate unique node ID"""
+        import socket
+        hostname = socket.gethostname()
+        timestamp = str(time.time())
+        return hashlib.sha256(f"{hostname}{timestamp}".encode()).hexdigest()[:16]
+    
+    def start(self):
+        """Start P2P client"""
+        if self.is_running:
+            return
+        
+        self.is_running = True
+        
+        # Initial setup
+        self._initial_sync()
+        self._register_with_primary()
+        self._update_peer_list()
+        
+        # Start background sync thread
+        self.sync_thread = threading.Thread(target=self._sync_loop, daemon=True)
+        self.sync_thread.start()
+        
+        print(f"✅ P2P Client started (Node ID: {self.node_id})")
+    
+    def stop(self):
+        """Stop P2P client"""
+        self.is_running = False
+        if self.sync_thread:
+            self.sync_thread.join(timeout=5)
+        print("🛑 P2P Client stopped")
+    
+    def _initial_sync(self):
+        """Download initial blockchain and mempool from primary node"""
+        try:
+            print(f"📥 Initial sync from primary node: {self.primary_node}")
+            
+            # Download blockchain
+            response = requests.get(f"{self.primary_node}/api/blockchain/full", timeout=30)
+            if response.status_code == 200:
+                blockchain_data = response.json()
+                print(f"✅ Downloaded blockchain: {len(blockchain_data.get('blocks', []))} blocks")
+                return blockchain_data
+            
+        except Exception as e:
+            print(f"❌ Initial sync failed: {e}")
+            return None
+    
+    def _register_with_primary(self):
+        """Register this node with the primary daemon"""
+        try:
+            peer_info = {
+                'node_id': self.node_id,
+                'timestamp': time.time(),
+                'capabilities': ['sync', 'relay']
+            }
+            
+            response = requests.post(
+                f"{self.primary_node}/api/peers/register",
+                json=peer_info,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                print(f"✅ Registered with primary node as peer: {self.node_id}")
+                return True
+            else:
+                print(f"⚠️  Registration failed: {response.status_code}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Registration error: {e}")
+            return False
+    
+    def _update_peer_list(self):
+        """Get updated peer list from primary daemon"""
+        try:
+            response = requests.get(f"{self.primary_node}/api/peers/list", timeout=10)
+            
+            if response.status_code == 200:
+                peer_data = response.json()
+                new_peers = peer_data.get('peers', [])
+                
+                # Filter out self
+                self.peers = [p for p in new_peers if p.get('node_id') != self.node_id]
+                
+                print(f"📋 Updated peer list: {len(self.peers)} peers")
+                self.last_peer_update = time.time()
+                
+                if self.on_peer_update_callback:
+                    self.on_peer_update_callback(self.peers)
+                
+                return self.peers
+                
+        except Exception as e:
+            print(f"❌ Peer list update failed: {e}")
+            return []
+    
+    def _sync_loop(self):
+        """Background sync loop for P2P updates"""
+        while self.is_running:
+            try:
+                current_time = time.time()
+                
+                # Periodic peer list update
+                if current_time - self.last_peer_update > self.peer_update_interval:
+                    self._update_peer_list()
+                
+                # Periodic primary node validation
+                if current_time - self.last_primary_check > self.primary_check_interval:
+                    self._validate_with_primary()
+                
+                # Sync with peers
+                self._sync_from_peers()
+                
+                # Process message queue
+                self._process_messages()
+                
+                time.sleep(5)  # Check every 5 seconds
+                
+            except Exception as e:
+                print(f"❌ Sync loop error: {e}")
+                time.sleep(10)
+    
+    def _sync_from_peers(self):
+        """Sync new blocks and transactions from peers"""
+        for peer in self.peers[:5]:  # Sync with first 5 peers
+            try:
+                peer_url = peer.get('url')
+                if not peer_url:
+                    continue
+                
+                # Get latest block from peer
+                response = requests.get(f"{peer_url}/api/blockchain/latest", timeout=5)
+                if response.status_code == 200:
+                    latest_block = response.json()
+                    
+                    if self.on_new_block_callback:
+                        self.on_new_block_callback(latest_block)
+                
+            except Exception as e:
+                # Silent fail for peer sync
+                pass
+    
+    def _validate_with_primary(self):
+        """Validate local blockchain state with primary node"""
+        try:
+            print("🔍 Validating with primary node...")
+            
+            response = requests.get(f"{self.primary_node}/api/blockchain/latest", timeout=10)
+            if response.status_code == 200:
+                primary_latest = response.json()
+                primary_hash = primary_latest.get('hash')
+                primary_height = primary_latest.get('index')
+                
+                print(f"✅ Primary validation: Block #{primary_height}, Hash: {primary_hash[:16]}...")
+                self.last_primary_check = time.time()
+                
+                return primary_latest
+                
+        except Exception as e:
+            print(f"❌ Primary validation failed: {e}")
+            return None
+    
+    def _process_messages(self):
+        """Process incoming P2P messages"""
+        while not self.message_queue.empty():
+            try:
+                message = self.message_queue.get_nowait()
+                msg_type = message.get('type')
+                
+                if msg_type == 'new_block':
+                    if self.on_new_block_callback:
+                        self.on_new_block_callback(message.get('data'))
+                elif msg_type == 'new_transaction':
+                    if self.on_new_transaction_callback:
+                        self.on_new_transaction_callback(message.get('data'))
+                        
+            except Exception as e:
+                print(f"❌ Message processing error: {e}")
+    
+    def broadcast_block(self, block: Dict):
+        """Broadcast new block to peers"""
+        for peer in self.peers:
+            try:
+                peer_url = peer.get('url')
+                if peer_url:
+                    requests.post(
+                        f"{peer_url}/api/blocks/new",
+                        json=block,
+                        timeout=3
+                    )
+            except:
+                pass  # Silent fail for broadcasts
+    
+    def broadcast_transaction(self, transaction: Dict):
+        """Broadcast new transaction to peers"""
+        for peer in self.peers:
+            try:
+                peer_url = peer.get('url')
+                if peer_url:
+                    requests.post(
+                        f"{peer_url}/api/transactions/new",
+                        json=transaction,
+                        timeout=3
+                    )
+            except:
+                pass  # Silent fail for broadcasts
+    
+    def get_peers(self) -> List[Dict]:
+        """Get current peer list"""
+        return self.peers
+    
+    def set_callbacks(self, on_new_block=None, on_new_transaction=None, on_peer_update=None):
+        """Set event callbacks"""
+        self.on_new_block_callback = on_new_block
+        self.on_new_transaction_callback = on_new_transaction
+        self.on_peer_update_callback = on_peer_update
+
+
+class HybridBlockchainClient:
+    """
+    Hybrid blockchain client that combines primary node trust with P2P scalability.
+    - Initial sync from primary node
+    - P2P updates from peers
+    - Periodic validation against primary node
+    """
+    
+    def __init__(self, primary_node_url: str, blockchain_manager, mempool_manager):
+        self.primary_node = primary_node_url
+        self.blockchain = blockchain_manager
+        self.mempool = mempool_manager
+        
+        # Initialize P2P client
+        self.p2p = P2PClient(primary_node_url)
+        self.p2p.set_callbacks(
+            on_new_block=self._handle_new_block,
+            on_new_transaction=self._handle_new_transaction,
+            on_peer_update=self._handle_peer_update
+        )
+    
+    def start(self):
+        """Start hybrid client"""
+        print("🚀 Starting Hybrid Blockchain Client...")
+        self.p2p.start()
+    
+    def stop(self):
+        """Stop hybrid client"""
+        self.p2p.stop()
+    
+    def _handle_new_block(self, block: Dict):
+        """Handle new block from P2P network"""
+        try:
+            # Validate block before adding
+            if self._validate_block_with_primary(block):
+                print(f"📦 New block from P2P: #{block.get('index')}")
+                # Add to local blockchain
+                # self.blockchain.add_block(block)
+        except Exception as e:
+            print(f"❌ Block handling error: {e}")
+    
+    def _handle_new_transaction(self, transaction: Dict):
+        """Handle new transaction from P2P network"""
+        try:
+            # Validate transaction with primary node
+            if self._validate_transaction_with_primary(transaction):
+                print(f"💳 New transaction from P2P: {transaction.get('hash', 'unknown')[:16]}...")
+                # Add to local mempool
+                # self.mempool.add_transaction(transaction)
+        except Exception as e:
+            print(f"❌ Transaction handling error: {e}")
+    
+    def _handle_peer_update(self, peers: List[Dict]):
+        """Handle peer list update"""
+        print(f"👥 Peer list updated: {len(peers)} peers available")
+    
+    def _validate_block_with_primary(self, block: Dict) -> bool:
+        """Validate block against primary node"""
+        try:
+            response = requests.post(
+                f"{self.primary_node}/api/blocks/validate",
+                json=block,
+                timeout=5
+            )
+            return response.status_code == 200 and response.json().get('valid', False)
+        except:
+            return False
+    
+    def _validate_transaction_with_primary(self, transaction: Dict) -> bool:
+        """Validate transaction against primary node"""
+        try:
+            response = requests.post(
+                f"{self.primary_node}/api/transactions/validate",
+                json=transaction,
+                timeout=5
+            )
+            return response.status_code == 200 and response.json().get('valid', False)
+        except:
+            return False
+    
+    def broadcast_block(self, block: Dict):
+        """Broadcast block to P2P network"""
+        self.p2p.broadcast_block(block)
+    
+    def broadcast_transaction(self, transaction: Dict):
+        """Broadcast transaction to P2P network"""
+        self.p2p.broadcast_transaction(transaction)
+    
+    def get_peers(self) -> List[Dict]:
+        """Get current peer list"""
+        return self.p2p.get_peers()

lunalib/gtx/digital_bill.py

@@ -1,3 +1,11 @@
+import sys
+def safe_print(*args, **kwargs):
+    encoding = sys.stdout.encoding or 'utf-8'
+    try:
+        print(*args, **kwargs)
+    except UnicodeEncodeError:
+        print(*(str(a).encode(encoding, errors='replace').decode(encoding) for a in args), **kwargs)
+safe_print("Warning: cryptography library not available. Using fallback methods.")
 import time
 import hashlib
 import secrets
@@ -12,7 +20,7 @@ try:
     from cryptography.exceptions import InvalidSignature
     CRYPTOGRAPHY_AVAILABLE = True
 except ImportError:
-    print("Warning: cryptography library not available. Using fallback methods.")
+    safe_print("Warning: cryptography library not available. Using fallback methods.")
     CRYPTOGRAPHY_AVAILABLE = False
 
 from .bill_registry import BillRegistry
@@ -182,7 +190,7 @@ class DigitalBill:
             
             return self.signature
         except Exception as e:
-            print(f"Cryptographic signing failed, using fallback: {e}")
+            safe_print(f"Cryptographic signing failed, using fallback: {e}")
             return self._sign_fallback(private_key)
     
     def _sign_fallback(self, private_key):

lunalib/gtx/genesis.py

@@ -48,7 +48,7 @@ class GTXGenesis:
                 return {'valid': False, 'error': 'Bill not found in registry'}
             
             # DEBUG: Print what we received
-            print(f"DEBUG: Full bill record: {bill_record}")
+            safe_print(f"DEBUG: Full bill record: {bill_record}")
             
             # Extract the actual bill_data from the metadata field
             bill_data = bill_record.get('metadata', {})
@@ -56,7 +56,7 @@ class GTXGenesis:
                 return {'valid': False, 'error': 'No bill data found in metadata'}
             
             # DEBUG: Print the extracted bill_data
-            print(f"DEBUG: Extracted bill_data: {bill_data}")
+            safe_print(f"DEBUG: Extracted bill_data: {bill_data}")
             
             # Extract signature components from bill_data (not from bill_record)
             public_key = bill_data.get('public_key')
@@ -68,10 +68,10 @@ class GTXGenesis:
             timestamp = bill_data.get('timestamp', 0)
             bill_type = bill_data.get('type', 'GTX_Genesis')
             
-            print(f"🔍 GTXGenesis.verify_bill() for {front_serial}:")
-            print(f"   Signature: {signature}")
-            print(f"   Public Key: {public_key}")
-            print(f"   Metadata Hash: {metadata_hash}")
+            safe_print(f"🔍 GTXGenesis.verify_bill() for {front_serial}:")
+            safe_print(f"   Signature: {signature}")
+            safe_print(f"   Public Key: {public_key}")
+            safe_print(f"   Metadata Hash: {metadata_hash}")
             
             # Use the same verification logic as the endpoint
             verification_method = "unknown"
@@ -81,7 +81,7 @@ class GTXGenesis:
             if metadata_hash and signature == metadata_hash:
                 signature_valid = True
                 verification_method = "signature_is_metadata_hash"
-                print(f"✅ Verified: signature matches metadata_hash")
+                safe_print(f"✅ Verified: signature matches metadata_hash")
             
             # METHOD 2: Check hash of public_key + metadata_hash
             elif signature_valid is None and metadata_hash and public_key and signature:
@@ -90,7 +90,7 @@ class GTXGenesis:
                 if signature == expected_signature:
                     signature_valid = True
                     verification_method = "metadata_hash_signature"
-                    print(f"Verified: hash(public_key + metadata_hash)")
+                    safe_print(f"Verified: hash(public_key + metadata_hash)")
             
             # METHOD 3: Check DigitalBill calculated hash
             elif signature_valid is None:
@@ -122,32 +122,31 @@ class GTXGenesis:
                     if signature == calculated_hash:
                         signature_valid = True
                         verification_method = "digital_bill_calculate_hash"
-                        print(f"Verified: DigitalBill.calculate_hash()")
+                        safe_print(f"Verified: DigitalBill.calculate_hash()")
                         print(f"   Calculated hash: {calculated_hash}")
                     
                     # Approach 2: Use the verify() method (checks all signature types)
                     elif digital_bill.verify():
                         signature_valid = True
                         verification_method = "digital_bill_verify_method"
-                        print(f"Verified: DigitalBill.verify()")
+                        safe_print(f"Verified: DigitalBill.verify()")
                     
                     # Approach 3: Check if signature matches metadata_hash generation
                     elif signature == digital_bill._generate_metadata_hash():
                         signature_valid = True
                         verification_method = "digital_bill_metadata_hash"
-                        print(f"Verified: matches generated metadata_hash")
+                        safe_print(f"Verified: matches generated metadata_hash")
                     
                     else:
-                        print(f"DigitalBill verification failed:")
-                        print(f"   Calculated hash: {calculated_hash}")
-                        print(f"   Signature: {signature}")
-                        print(f"   Metadata hash: {metadata_hash}")
-                        print(f"   Public key: {public_key}")
-                        
+                        safe_print(f"DigitalBill verification failed:")
+                        safe_print(f"   Calculated hash: {calculated_hash}")
+                        safe_print(f"   Signature: {signature}")
+                        safe_print(f"   Metadata hash: {metadata_hash}")
+                        safe_print(f"   Public key: {public_key}")
                 except Exception as e:
-                    print(f"DigitalBill verification error: {e}")
+                    safe_print(f"DigitalBill verification error: {e}")
                     import traceback
-                    print(f"Traceback: {traceback.format_exc()}")
+                    safe_print(f"Traceback: {traceback.format_exc()}")
             
             # METHOD 4: Check simple concatenation hash
             elif signature_valid is None and signature:
@@ -156,7 +155,7 @@ class GTXGenesis:
                 if signature == expected_simple_hash:
                     signature_valid = True
                     verification_method = "simple_hash"
-                    print(f"✅ Verified: hash(serial+denom+issued+timestamp)")
+                    safe_print(f"✅ Verified: hash(serial+denom+issued+timestamp)")
             
             # METHOD 5: Check bill JSON hash
             elif signature_valid is None:
@@ -173,19 +172,19 @@ class GTXGenesis:
                 if signature == bill_json_hash:
                     signature_valid = True
                     verification_method = "bill_json_hash"
-                    print(f"Verified: hash(bill_data_json)")
+                    safe_print(f"Verified: hash(bill_data_json)")
             
             # Final fallback: accept any non-empty signature temporarily
             if signature_valid is None and signature and len(signature) > 10:
                 signature_valid = True
                 verification_method = "fallback_accept"
-                print(f"Using fallback acceptance for signature")
+                safe_print(f"Using fallback acceptance for signature")
             
             # If all methods failed
             if signature_valid is None:
                 signature_valid = False
                 verification_method = "all_failed"
-                print(f"All verification methods failed")
+                safe_print(f"All verification methods failed")
             
             # Return result in same format as endpoint
             if signature_valid:
@@ -337,7 +336,7 @@ class GTXGenesis:
             return computed_hash == bill_info['hash']
             
         except Exception as e:
-            print(f"Bill verification error: {e}")
+            safe_print(f"Bill verification error: {e}")
             return False
     
     def _get_denomination_breakdown(self, bills: List[Dict]) -> Dict[int, int]:

lunalib/mining/__init__.py

@@ -0,0 +1,5 @@
+from .miner import GenesisMiner, Miner
+from .difficulty import DifficultySystem
+from .cuda_manager import CUDAManager
+
+__all__ = ['GenesisMiner', 'Miner', 'DifficultySystem', 'CUDAManager']

lunalib/mining/cuda_manager.py

@@ -47,7 +47,7 @@ class CUDAManager:
             self.cuda_available = False
     
     def cuda_mine_batch(self, mining_data: Dict, difficulty: int, batch_size: int = 100000) -> Optional[Dict]:
-        """Mine using CUDA acceleration"""
+        """Mine using CUDA acceleration with CPU-side hash computation"""
         if not self.cuda_available:
             return None
             
@@ -56,24 +56,27 @@ class CUDAManager:
             nonce_start = 0
             start_time = time.time()
             
+            # Pre-compute the base string without nonce for efficiency
+            base_data = {k: v for k, v in mining_data.items() if k != 'nonce'}
+            
             while True:
-                # Prepare batch data for GPU
-                nonces = cp.arange(nonce_start, nonce_start + batch_size, dtype=cp.uint64)
-                mining_strings = self._prepare_mining_batch(mining_data, nonces)
+                # Generate nonces on GPU for parallel processing
+                nonces_gpu = cp.arange(nonce_start, nonce_start + batch_size, dtype=cp.int64)
+                nonces_cpu = cp.asnumpy(nonces_gpu)  # Transfer to CPU for hashing
                 
-                # Compute hashes on GPU
-                hashes = self._compute_hashes_gpu(mining_strings)
+                # Compute hashes in parallel on CPU (GPU hash acceleration requires custom CUDA kernels)
+                hashes = self._compute_hashes_parallel(base_data, nonces_cpu)
                 
                 # Check for successful hash
                 for i, hash_hex in enumerate(hashes):
                     if hash_hex.startswith(target):
                         mining_time = time.time() - start_time
-                        successful_nonce = nonce_start + i
+                        successful_nonce = int(nonces_cpu[i])
                         
                         return {
                             "success": True,
                             "hash": hash_hex,
-                            "nonce": int(successful_nonce),
+                            "nonce": successful_nonce,
                             "mining_time": mining_time,
                             "method": "cuda"
                         }
@@ -85,36 +88,28 @@ class CUDAManager:
                     current_time = time.time()
                     hashrate = nonce_start / (current_time - start_time)
                     print(f"⏳ CUDA: {nonce_start:,} attempts | {hashrate:,.0f} H/s")
+                
+                # Timeout check
+                if time.time() - start_time > 300:  # 5 minutes timeout
+                    break
                     
         except Exception as e:
             print(f"CUDA mining error: {e}")
             
         return None
     
-    def _prepare_mining_batch(self, mining_data: Dict, nonces) -> Any:
-        """Prepare batch mining data for GPU"""
-        mining_strings = []
+    def _compute_hashes_parallel(self, base_data: Dict, nonces: list) -> list:
+        """Compute SHA256 hashes in parallel on CPU (string operations not supported on GPU)"""
+        hashes = []
         
         for nonce in nonces:
+            # Create mining data with current nonce
+            mining_data = base_data.copy()
             mining_data["nonce"] = int(nonce)
-            data_string = json.dumps(mining_data, sort_keys=True)
-            mining_strings.append(data_string.encode())
             
-        return cp.array(mining_strings)
-    
-    def _compute_hashes_gpu(self, mining_strings) -> list:
-        """Compute SHA256 hashes on GPU"""
-        # Convert to CuPy array if needed
-        if not isinstance(mining_strings, cp.ndarray):
-            mining_strings = cp.array(mining_strings)
-        
-        # This is a simplified implementation
-        # In a real implementation, you'd use proper CUDA kernels
-        hashes = []
-        for data in mining_strings:
-            # For now, fall back to CPU hashing
-            # A real implementation would use CUDA-accelerated hashing
-            hash_obj = hashlib.sha256(data.tobytes())
+            # Compute hash
+            data_string = json.dumps(mining_data, sort_keys=True)
+            hash_obj = hashlib.sha256(data_string.encode())
             hashes.append(hash_obj.hexdigest())
             
         return hashes

lunalib/mining/difficulty.py

@@ -65,6 +65,44 @@ class DifficultySystem:
             
         return base_reward * (1 + time_bonus)
     
+    def calculate_block_reward(self, difficulty: int) -> float:
+        """Calculate block reward based on difficulty using exponential system
+        
+        Reward = 10^(difficulty - 1)
+        difficulty 1 = 1 LKC (10^0)
+        difficulty 2 = 10 LKC (10^1)
+        difficulty 3 = 100 LKC (10^2)
+        difficulty 9 = 100,000,000 LKC (10^8)
+        """
+        if difficulty < 1:
+            difficulty = 1
+        elif difficulty > 9:
+            difficulty = 9
+        
+        return 10 ** (difficulty - 1)
+    
+    def validate_block_hash(self, block_hash: str, difficulty: int) -> bool:
+        """Validate that block hash meets difficulty requirement"""
+        if not block_hash or difficulty < 1:
+            return False
+        
+        target_prefix = "0" * difficulty
+        return block_hash.startswith(target_prefix)
+    
+    def validate_block_structure(self, block: dict) -> tuple:
+        """Validate block has all required fields
+        
+        Returns: (is_valid, error_message)
+        """
+        required_fields = ['index', 'previous_hash', 'timestamp', 'transactions',
+                          'miner', 'difficulty', 'nonce', 'hash', 'reward']
+        
+        for field in required_fields:
+            if field not in block:
+                return False, f"Missing required field: {field}"
+        
+        return True, ""
+    
     def get_difficulty_name(self, difficulty_level):
         """Get human-readable name for difficulty level"""
         names = {