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

lunalib/core/wallet_sync_helper.py

@@ -0,0 +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/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
@@ -28,7 +37,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 +52,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 +72,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 +114,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 +171,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,

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}")

lunalib/storage/database.py

@@ -3,6 +3,15 @@ import sqlite3
 import json
 import time
 from typing import Dict, List, Optional, Any
+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)
 
 class WalletDatabase:
     """Manages wallet data storage"""
@@ -96,7 +105,7 @@ class WalletDatabase:
             return True
             
         except Exception as e:
-            print(f"Save wallet error: {e}")
+            safe_print(f"Save wallet error: {e}")
             return False
     
     def load_wallet(self, address: str) -> Optional[Dict]:
@@ -122,7 +131,7 @@ class WalletDatabase:
                 }
                 
         except Exception as e:
-            print(f"Load wallet error: {e}")
+            safe_print(f"Load wallet error: {e}")
             
         return None
     
@@ -157,7 +166,7 @@ class WalletDatabase:
             return True
             
         except Exception as e:
-            print(f"Save transaction error: {e}")
+            safe_print(f"Save transaction error: {e}")
             return False
     
     def get_wallet_transactions(self, wallet_address: str, limit: int = 100) -> List[Dict]:
@@ -187,7 +196,7 @@ class WalletDatabase:
             return transactions
             
         except Exception as e:
-            print(f"Get transactions error: {e}")
+            safe_print(f"Get transactions error: {e}")
             return []
     
     def save_pending_transaction(self, transaction: Dict, wallet_address: str) -> bool:
@@ -218,5 +227,5 @@ class WalletDatabase:
             return True
             
         except Exception as e:
-            print(f"Save pending transaction error: {e}")
+            safe_print(f"Save pending transaction error: {e}")
             return False

lunalib/storage/encryption.py

@@ -1,5 +1,14 @@
 import os
 import json
+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 base64
 import hashlib
 from cryptography.fernet import Fernet
@@ -37,7 +46,7 @@ class EncryptionManager:
             }
             
         except Exception as e:
-            print(f"Encryption error: {e}")
+            safe_print(f"Encryption error: {e}")
             return {}
     
     def decrypt_wallet(self, encrypted_data: Dict, password: str) -> Optional[Dict]:
@@ -65,7 +74,7 @@ class EncryptionManager:
             return wallet_data
             
         except Exception as e:
-            print(f"Decryption error: {e}")
+            safe_print(f"Decryption error: {e}")
             return None
     
     def _derive_key(self, password: str) -> bytes:

lunalib/transactions/security.py

@@ -1,9 +1,18 @@
 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
 from typing import Dict, Tuple
 
 class TransactionSecurity:
-    """Enhanced transaction security system"""
+    """Enhanced transaction security system with SM2 support"""
     
     def __init__(self):
         self.min_transaction_amount = 0.000001
@@ -11,9 +20,20 @@ class TransactionSecurity:
         self.required_fee = 0.00001
         self.rate_limits = {}
         self.blacklisted_addresses = set()
+        
+        # Try to import SM2 KeyManager
+        try:
+            from ..core.crypto import KeyManager as SM2KeyManager
+            self.key_manager = SM2KeyManager()
+            self.sm2_available = True
+            safe_print("[SECURITY] SM2 KeyManager loaded successfully")
+        except ImportError as e:
+            self.key_manager = None
+            self.sm2_available = False
+            safe_print(f"[SECURITY] SM2 KeyManager not available: {e}")
     
     def validate_transaction_security(self, transaction: Dict) -> Tuple[bool, str]:
-        """Comprehensive transaction security validation"""
+        """Comprehensive transaction security validation with SM2"""
         tx_type = transaction.get("type", "").lower()
         
         if tx_type == "gtx_genesis":
@@ -58,7 +78,7 @@ class TransactionSecurity:
         return True, "Valid reward transaction"
     
     def _validate_transfer_transaction(self, transaction: Dict) -> Tuple[bool, str]:
-        """Validate transfer transaction"""
+        """Validate transfer transaction with SM2 signature"""
         required_fields = ["from", "to", "amount", "signature", "public_key", "nonce"]
         for field in required_fields:
             if field not in transaction:
@@ -76,9 +96,9 @@ class TransactionSecurity:
         if fee < self.required_fee:
             return False, f"Insufficient fee: {fee} (required: {self.required_fee})"
         
-        # Signature validation
-        if not self._validate_signature(transaction):
-            return False, "Invalid signature"
+        # SM2 Signature validation
+        if not self._validate_signature_sm2(transaction):
+            return False, "Invalid SM2 signature"
         
         # Anti-spam checks
         from_address = transaction.get("from", "")
@@ -90,6 +110,65 @@ class TransactionSecurity:
         
         return True, "Valid transfer transaction"
     
+    def _validate_signature_sm2(self, transaction: Dict) -> bool:
+        """Validate transaction signature using SM2"""
+        try:
+            signature = transaction.get("signature", "")
+            public_key = transaction.get("public_key", "")
+            tx_type = transaction.get("type", "").lower()
+            
+            # Skip system transactions
+            if tx_type in ["gtx_genesis", "reward"]:
+                return True
+            
+            # For unsigned test transactions
+            if signature in ["system", "unsigned", "test"]:
+                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)")
+                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")
+                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]}...")
+                return False
+            
+            # Use KeyManager for verification if available
+            if self.sm2_available and self.key_manager:
+                # Create signing data string
+                signing_data = self._get_signing_data(transaction)
+                
+                # Verify signature
+                is_valid = self.key_manager.verify_signature(signing_data, signature, public_key)
+                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")
+            return len(signature) == 128 and signature.startswith(('04', '03', '02'))
+            
+        except Exception as e:
+            print(f"[SECURITY] Signature validation error: {e}")
+            return False
+    
+    def _get_signing_data(self, transaction: Dict) -> str:
+        """Create data string for signing"""
+        # Create copy without signature and hash
+        tx_copy = {k: v for k, v in transaction.items() 
+                  if k not in ['signature', 'hash']}
+        
+        # Sort keys and convert to string
+        import json
+        return json.dumps(tx_copy, sort_keys=True)
+    
     def _validate_mining_proof(self, transaction: Dict) -> bool:
         """Validate mining proof-of-work"""
         try:
@@ -103,20 +182,9 @@ class TransactionSecurity:
             return False
     
     def _validate_signature(self, transaction: Dict) -> bool:
-        """Validate transaction signature"""
-        try:
-            signature = transaction.get("signature", "")
-            public_key = transaction.get("public_key", "")
-            
-            # Basic format validation
-            if len(signature) != 64:
-                return False
-            
-            # In production, use proper ECDSA verification
-            # For now, simplified check
-            return all(c in "0123456789abcdef" for c in signature.lower())
-        except:
-            return False
+        """Legacy signature validation (for backward compatibility)"""
+        print(f"[SECURITY] Using legacy signature validation")
+        return self._validate_signature_sm2(transaction)
     
     def _check_rate_limit(self, address: str) -> bool:
         """Check transaction rate limiting"""
@@ -144,17 +212,20 @@ class TransactionSecurity:
         self.blacklisted_addresses.add(address.lower())
     
     def calculate_security_score(self, transaction: Dict) -> int:
-        """Calculate security score for transaction"""
+        """Calculate security score for transaction with SM2 bonus"""
         score = 0
         
-        # Signature strength
+        # Signature strength (SM2 gives higher score)
         signature = transaction.get("signature", "")
-        if len(signature) == 64:
+        if len(signature) == 128:  # SM2 signature
+            score += 60  # Higher score for SM2
+        elif len(signature) == 64:  # Legacy ECDSA
             score += 40
         
         # Public key presence
-        if transaction.get("public_key"):
-            score += 20
+        public_key = transaction.get("public_key", "")
+        if public_key and public_key.startswith('04'):
+            score += 30  # SM2 uncompressed format
         
         # Timestamp freshness
         timestamp = transaction.get("timestamp", 0)