lunalib 1.5.0__py3-none-any.whl → 1.6.0__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/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 @@
+from .miner import GenesisMiner

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,
@@ -289,7 +298,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 +623,94 @@ class GenesisMiner:
             return {
                 "network_connected": False,
                 "error": str(e)
-            }
+            }
+
+class Miner:
+    """
+    Miner class that uses lunalib directly to mine transfers, GTX genesis blocks, and rewards.
+    """
+
+    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()
+
+        # Use lunalib components
+        self.blockchain_manager = BlockchainManager(endpoint_url=config.node_url)
+        self.difficulty_system = DifficultySystem()
+        self.cuda_manager = CUDAManager()
+
+        self.current_hash = ""
+        self.current_nonce = 0
+        self.hash_rate = 0
+        self.mining_thread = None
+        self.should_stop_mining = False
+
+    def start_mining(self, mining_type: str):
+        """
+        Start mining based on the type: 'transfer', 'gtx_genesis', or 'reward'.
+        """
+        if self.is_mining:
+            return
+
+        self.is_mining = True
+        self.should_stop_mining = False
+
+        if self.mining_started_callback:
+            self.mining_started_callback()
+
+        if mining_type == 'transfer':
+            self.mine_transfers()
+        elif mining_type == 'gtx_genesis':
+            self.mine_genesis_blocks()
+        elif mining_type == 'reward':
+            self.mine_rewards()
+        else:
+            raise ValueError("Invalid mining type. Choose 'transfer', 'gtx_genesis', or 'reward'.")
+
+    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 mine_transfers(self):
+        """Mine transfer transactions."""
+        while self.is_mining:
+            # Fetch transactions from the mempool
+            transactions = self.mempool_manager.get_pending_transactions()
+            if not transactions:
+                continue
+
+            # Mine a block with the transactions
+            block = self.blockchain_manager.create_block(transactions)
+            self.blockchain_manager.add_block(block)
+            self.mining_stats["transfers_mined"] += 1
+
+    def mine_genesis_blocks(self):
+        """Mine GTX genesis blocks."""
+        while self.is_mining:
+            # Create a genesis block
+            genesis_block = self.blockchain_manager.create_genesis_block()
+            self.blockchain_manager.add_block(genesis_block)
+            self.mining_stats["genesis_blocks_mined"] += 1
+
+    def mine_rewards(self):
+        """Mine rewards."""
+        while self.is_mining:
+            # Simulate mining rewards
+            reward = self.blockchain_manager.generate_reward()
+            self.blockchain_manager.add_reward(reward)
+            self.mining_stats["rewards_mined"] += 1
+
+    def get_mining_stats(self):
+        """Return the current mining statistics."""
+        return self.mining_stats

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: