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

lunalib/core/wallet_sync_helper.py

@@ -1,163 +1,163 @@
-# lunalib/wallet_sync_helper.py
-"""
-Wallet Sync Helper
-
-Provides integration between LunaWallet, BlockchainManager, MempoolManager,
-and the WalletStateManager for seamless real-time balance and transaction updates.
-"""
-
-from typing import List, Dict, Optional, Callable
-from .wallet_manager import get_wallet_manager
-
-
-class WalletSyncHelper:
-    """
-    Helper class to sync LunaWallet with WalletStateManager using data from
-    BlockchainManager and MempoolManager.
-    """
-    
-    def __init__(self, wallet=None, blockchain=None, mempool=None):
-        """
-        Initialize sync helper.
-        
-        Parameters:
-            wallet: LunaWallet instance
-            blockchain: BlockchainManager instance
-            mempool: MempoolManager instance
-        """
-        self.wallet = wallet
-        self.blockchain = blockchain
-        self.mempool = mempool
-        self.state_manager = get_wallet_manager()
-        
-    def register_wallets_from_lunawallet(self) -> Dict:
-        """Register all wallets from LunaWallet into the state manager"""
-        if not self.wallet:
-            print("⚠️  No wallet instance provided")
-            return {}
-        
-        addresses = list(self.wallet.wallets.keys())
-        if not addresses:
-            print("⚠️  No wallets registered in LunaWallet")
-            return {}
-        
-        print(f"📱 Registering {len(addresses)} wallets with state manager...")
-        states = self.state_manager.register_wallets(addresses)
-        print(f"✅ Registered {len(states)} wallets")
-        
-        return states
-    
-    def sync_wallets_now(self) -> Dict:
-        """
-        Perform a single synchronization of all registered wallets.
-        
-        Returns: Dictionary of wallet addresses and their updated summaries
-        """
-        if not self.blockchain or not self.mempool:
-            print("⚠️  Blockchain or mempool not provided")
-            return {}
-        
-        addresses = list(self.state_manager.wallet_states.keys())
-        if not addresses:
-            print("⚠️  No wallets registered")
-            return {}
-        
-        print(f"🔄 Syncing {len(addresses)} wallets...")
-        
-        try:
-            # Get data from blockchain and mempool
-            blockchain_txs = self.blockchain.scan_transactions_for_addresses(addresses)
-            mempool_txs = self.mempool.get_pending_transactions_for_addresses(addresses)
-            
-            # Sync the state manager
-            self.state_manager.sync_wallets_from_sources(blockchain_txs, mempool_txs)
-            
-            # Update LunaWallet balances if available
-            if self.wallet:
-                self._update_lunawallet_balances()
-            
-            # Return summaries
-            return self.state_manager.get_all_summaries()
-            
-        except Exception as e:
-            print(f"❌ Sync error: {e}")
-            return {}
-    
-    def _update_lunawallet_balances(self):
-        """Update LunaWallet instance balances from state manager"""
-        if not self.wallet:
-            return
-        
-        balances = self.state_manager.get_all_balances()
-        
-        for address, balance_data in balances.items():
-            if address in self.wallet.wallets:
-                wallet_data = self.wallet.wallets[address]
-                wallet_data['balance'] = balance_data['confirmed_balance']
-                wallet_data['available_balance'] = balance_data['available_balance']
-        
-        # Update current wallet if one is selected
-        if self.wallet.current_wallet_address in balances:
-            balance_data = balances[self.wallet.current_wallet_address]
-            self.wallet.balance = balance_data['confirmed_balance']
-            self.wallet.available_balance = balance_data['available_balance']
-    
-    def start_continuous_sync(self, poll_interval: int = 30,
-                             on_balance_update: Optional[Callable] = None,
-                             on_transaction_update: Optional[Callable] = None) -> None:
-        """
-        Start continuous synchronization in the background.
-        
-        Parameters:
-            poll_interval: Seconds between syncs
-            on_balance_update: Callback function(balance_data) for balance updates
-            on_transaction_update: Callback function(transaction_data) for transaction updates
-        """
-        
-        if on_balance_update:
-            self.state_manager.on_balance_update(on_balance_update)
-        
-        if on_transaction_update:
-            self.state_manager.on_transaction_update(on_transaction_update)
-        
-        def get_blockchain_data(addresses):
-            try:
-                return self.blockchain.scan_transactions_for_addresses(addresses)
-            except Exception as e:
-                print(f"⚠️  Blockchain scan error: {e}")
-                return {}
-        
-        def get_mempool_data(addresses):
-            try:
-                return self.mempool.get_pending_transactions_for_addresses(addresses)
-            except Exception as e:
-                print(f"⚠️  Mempool fetch error: {e}")
-                return {}
-        
-        self.state_manager.sync_wallets_background(
-            get_blockchain_data,
-            get_mempool_data,
-            poll_interval
-        )
-    
-    def get_wallet_balance(self, address: str) -> Optional[Dict]:
-        """Get current balance for a wallet"""
-        return self.state_manager.get_balance(address)
-    
-    def get_wallet_transactions(self, address: str, tx_type: str = 'all') -> List[Dict]:
-        """Get transactions for a wallet"""
-        return self.state_manager.get_transactions(address, tx_type)
-    
-    def get_wallet_summary(self, address: str) -> Optional[Dict]:
-        """Get complete summary for a wallet"""
-        return self.state_manager.get_wallet_summary(address)
-    
-    def get_all_wallets_summary(self) -> Dict:
-        """Get summaries for all wallets"""
-        return self.state_manager.get_all_summaries()
-
-
-# Convenience function to create sync helper
-def create_wallet_sync_helper(wallet=None, blockchain=None, mempool=None) -> WalletSyncHelper:
-    """Create a new WalletSyncHelper instance"""
-    return WalletSyncHelper(wallet, blockchain, mempool)
+# lunalib/wallet_sync_helper.py
+"""
+Wallet Sync Helper
+
+Provides integration between LunaWallet, BlockchainManager, MempoolManager,
+and the WalletStateManager for seamless real-time balance and transaction updates.
+"""
+
+from typing import List, Dict, Optional, Callable
+from .wallet_manager import get_wallet_manager
+
+
+class WalletSyncHelper:
+    """
+    Helper class to sync LunaWallet with WalletStateManager using data from
+    BlockchainManager and MempoolManager.
+    """
+    
+    def __init__(self, wallet=None, blockchain=None, mempool=None):
+        """
+        Initialize sync helper.
+        
+        Parameters:
+            wallet: LunaWallet instance
+            blockchain: BlockchainManager instance
+            mempool: MempoolManager instance
+        """
+        self.wallet = wallet
+        self.blockchain = blockchain
+        self.mempool = mempool
+        self.state_manager = get_wallet_manager()
+        
+    def register_wallets_from_lunawallet(self) -> Dict:
+        """Register all wallets from LunaWallet into the state manager"""
+        if not self.wallet:
+            print("⚠️  No wallet instance provided")
+            return {}
+        
+        addresses = list(self.wallet.wallets.keys())
+        if not addresses:
+            print("⚠️  No wallets registered in LunaWallet")
+            return {}
+        
+        print(f"📱 Registering {len(addresses)} wallets with state manager...")
+        states = self.state_manager.register_wallets(addresses)
+        print(f"✅ Registered {len(states)} wallets")
+        
+        return states
+    
+    def sync_wallets_now(self) -> Dict:
+        """
+        Perform a single synchronization of all registered wallets.
+        
+        Returns: Dictionary of wallet addresses and their updated summaries
+        """
+        if not self.blockchain or not self.mempool:
+            print("⚠️  Blockchain or mempool not provided")
+            return {}
+        
+        addresses = list(self.state_manager.wallet_states.keys())
+        if not addresses:
+            print("⚠️  No wallets registered")
+            return {}
+        
+        print(f"🔄 Syncing {len(addresses)} wallets...")
+        
+        try:
+            # Get data from blockchain and mempool
+            blockchain_txs = self.blockchain.scan_transactions_for_addresses(addresses)
+            mempool_txs = self.mempool.get_pending_transactions_for_addresses(addresses)
+            
+            # Sync the state manager
+            self.state_manager.sync_wallets_from_sources(blockchain_txs, mempool_txs)
+            
+            # Update LunaWallet balances if available
+            if self.wallet:
+                self._update_lunawallet_balances()
+            
+            # Return summaries
+            return self.state_manager.get_all_summaries()
+            
+        except Exception as e:
+            print(f"❌ Sync error: {e}")
+            return {}
+    
+    def _update_lunawallet_balances(self):
+        """Update LunaWallet instance balances from state manager"""
+        if not self.wallet:
+            return
+        
+        balances = self.state_manager.get_all_balances()
+        
+        for address, balance_data in balances.items():
+            if address in self.wallet.wallets:
+                wallet_data = self.wallet.wallets[address]
+                wallet_data['balance'] = balance_data['confirmed_balance']
+                wallet_data['available_balance'] = balance_data['available_balance']
+        
+        # Update current wallet if one is selected
+        if self.wallet.current_wallet_address in balances:
+            balance_data = balances[self.wallet.current_wallet_address]
+            self.wallet.balance = balance_data['confirmed_balance']
+            self.wallet.available_balance = balance_data['available_balance']
+    
+    def start_continuous_sync(self, poll_interval: int = 30,
+                             on_balance_update: Optional[Callable] = None,
+                             on_transaction_update: Optional[Callable] = None) -> None:
+        """
+        Start continuous synchronization in the background.
+        
+        Parameters:
+            poll_interval: Seconds between syncs
+            on_balance_update: Callback function(balance_data) for balance updates
+            on_transaction_update: Callback function(transaction_data) for transaction updates
+        """
+        
+        if on_balance_update:
+            self.state_manager.on_balance_update(on_balance_update)
+        
+        if on_transaction_update:
+            self.state_manager.on_transaction_update(on_transaction_update)
+        
+        def get_blockchain_data(addresses):
+            try:
+                return self.blockchain.scan_transactions_for_addresses(addresses)
+            except Exception as e:
+                print(f"⚠️  Blockchain scan error: {e}")
+                return {}
+        
+        def get_mempool_data(addresses):
+            try:
+                return self.mempool.get_pending_transactions_for_addresses(addresses)
+            except Exception as e:
+                print(f"⚠️  Mempool fetch error: {e}")
+                return {}
+        
+        self.state_manager.sync_wallets_background(
+            get_blockchain_data,
+            get_mempool_data,
+            poll_interval
+        )
+    
+    def get_wallet_balance(self, address: str) -> Optional[Dict]:
+        """Get current balance for a wallet"""
+        return self.state_manager.get_balance(address)
+    
+    def get_wallet_transactions(self, address: str, tx_type: str = 'all') -> List[Dict]:
+        """Get transactions for a wallet"""
+        return self.state_manager.get_transactions(address, tx_type)
+    
+    def get_wallet_summary(self, address: str) -> Optional[Dict]:
+        """Get complete summary for a wallet"""
+        return self.state_manager.get_wallet_summary(address)
+    
+    def get_all_wallets_summary(self) -> Dict:
+        """Get summaries for all wallets"""
+        return self.state_manager.get_all_summaries()
+
+
+# Convenience function to create sync helper
+def create_wallet_sync_helper(wallet=None, blockchain=None, mempool=None) -> WalletSyncHelper:
+    """Create a new WalletSyncHelper instance"""
+    return WalletSyncHelper(wallet, blockchain, mempool)

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 = {