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

lunalib/core/wallet.py

@@ -1,21 +1,43 @@
-# wallet.py
 import time
 import hashlib
 import json
-from cryptography.fernet import Fernet
-import base64
 import os
+import secrets
+import binascii
+import base64
+import threading
+import concurrent.futures
+from typing import Optional, Callable, Dict, List, Tuple
+from cryptography.fernet import Fernet
+from ..core.crypto import KeyManager
+
 
 class LunaWallet:
-    """Luna wallet implementation with proper key management and balance tracking"""
-    
     def __init__(self, data_dir=None):
         self.data_dir = data_dir
-        self.wallets = {}  # Main wallet storage: {address: wallet_data}
-        self.current_wallet_address = None  # Track which wallet is active
+        self.wallets = {}
+        self.current_wallet_address = None
+        self.key_manager = KeyManager()
         
-        # Initialize with an empty current wallet state
+        # Threading for asynchronous balance loading
+        self.balance_thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=3)
+        self.balance_callbacks = []
+        self.balance_loading = False
+        self.last_balance_update = 0
+        self.balance_update_interval = 30  # seconds
         self._reset_current_wallet()
+        self._confirmed_tx_cache: Dict[str, List[Dict]] = {}
+        self._pending_tx_cache: Dict[str, List[Dict]] = {}
+
+    # ----------------------
+    # Address normalization
+    # ----------------------
+    def _normalize_address(self, addr: str) -> str:
+        if not addr:
+            return ''
+        addr_str = str(addr).strip("'\" ").lower()
+        return addr_str[4:] if addr_str.startswith('lun_') else addr_str
+        
         
     def _reset_current_wallet(self):
         """Reset current wallet to empty state"""
@@ -23,110 +45,452 @@ class LunaWallet:
         self.balance = 0.0  # Total balance (confirmed transactions)
         self.available_balance = 0.0  # Available balance (total - pending outgoing)
         self.created = time.time()
-        self.private_key = None
-        self.public_key = None
+        self.private_key = None  # Will store REAL SM2 private key
+        self.public_key = None   # Will store REAL SM2 public key
         self.encrypted_private_key = None
         self.label = "New Wallet"
         self.is_locked = True
+    
+    # ============================================================================
+    # REAL CRYPTOGRAPHIC KEY GENERATION (SM2 EAST ASIAN STANDARD)
+    # ============================================================================
+    
+ 
+    
+    def _sign_transaction_data(self, transaction_data):
+        """Sign transaction data with SM2 private key"""
+        if not self.private_key or self.is_locked:
+            print("DEBUG: Cannot sign - wallet locked or no private key")
+            return None
+        
+        # Convert transaction data to string for signing
+        tx_string = json.dumps(transaction_data, sort_keys=True)
+        
+        # Sign with SM2
+        signature = self.sm2.sign_message(self.private_key, tx_string)
+        
+        if signature:
+            print(f"DEBUG: Transaction signed successfully, signature: {signature[:16]}...")
+        else:
+            print("DEBUG: Failed to sign transaction")
+        
+        return signature
+    
+    def _verify_wallet_integrity(self) -> bool:
+        """Basic cryptographic key verification"""
+        # Check if keys exist
+        if not self.private_key or not self.public_key:
+            return False
+        
+        # Validate key formats
+        if len(self.private_key) != 64:  # 256-bit hex
+            return False
+        
+        if not self.public_key.startswith('04') or len(self.public_key) != 130:
+            return False
+        
+        return True
+    
+    def _generate_key_pair(self):
+        """Generate REAL SM2 key pair"""
+        return self.key_manager.generate_keypair()
 
-    def _generate_address(self):
-        """Generate unique wallet address"""
-        import secrets
-        import time
-        # Use cryptographically secure random data for uniqueness
-        random_data = secrets.token_hex(32)
-        timestamp_ns = time.time_ns()  # More precise timestamp
-        base_data = f"LUN_{timestamp_ns}_{random_data}"
-        return hashlib.sha256(base_data.encode()).hexdigest()[:32]
+    def create_wallet(self, name, password):
+        """Create a new wallet and set it as current"""
+        print(f"DEBUG: Creating wallet '{name}'")
+        
+        # Generate REAL SM2 keys
+        private_key, public_key, address = self._generate_key_pair()
+        
+        # Encrypt private key
+        key = base64.urlsafe_b64encode(hashlib.sha256(password.encode()).digest())
+        fernet = Fernet(key)
+        encrypted_private_key = fernet.encrypt(private_key.encode())
+        
+        # Create wallet data
+        wallet_data = {
+            'address': address,
+            'balance': 0.0,
+            'available_balance': 0.0,
+            'created': time.time(),
+            'private_key': private_key,  # REAL SM2 private key
+            'public_key': public_key,    # REAL SM2 public key
+            'encrypted_private_key': encrypted_private_key,
+            'label': name,
+            'is_locked': True,
+            'crypto_standard': 'SM2_GB/T_32918'
+        }
+        
+        # Add to wallets collection
+        self.wallets[address] = wallet_data
+        
+        # Set as current wallet
+        self._set_current_wallet(wallet_data)
+        
+        print(f"DEBUG: Created and set current wallet {address}")
+        
+        return wallet_data
 
+    
+    def _generate_address(self, public_key_hex):
+        """Generate address from SM2 public key"""
+        return self.key_manager.derive_address(public_key_hex)
+    def create_new_wallet(self, name, password):
+        """
+        Create a new wallet without switching to it
+        Returns: wallet_data dict
+        """
+        print(f"DEBUG: Creating additional wallet '{name}'")
+        
+        # Generate REAL cryptographic keys
+        private_key_hex, public_key_hex, address = self._generate_key_pair()
+        
+        # Encrypt private key
+        key = base64.urlsafe_b64encode(hashlib.sha256(password.encode()).digest())
+        fernet = Fernet(key)
+        encrypted_private_key = fernet.encrypt(private_key_hex.encode())
+        
+        # Create wallet data
+        new_wallet_data = {
+            'address': address,
+            'balance': 0.0,
+            'available_balance': 0.0,
+            'created': time.time(),
+            'private_key': private_key_hex,
+            'public_key': public_key_hex,
+            'encrypted_private_key': encrypted_private_key,
+            'label': name,
+            'is_locked': True,
+            'crypto_standard': 'SM2_GB/T_32918'
+        }
+        
+        # Add to wallets collection
+        self.wallets[address] = new_wallet_data
+        
+        print(f"DEBUG: Created wallet {address}, total wallets: {len(self.wallets)}")
+        
+        return new_wallet_data
+    
+    def _set_current_wallet(self, wallet_data):
+        """Set the current wallet from wallet data"""
+        self.current_wallet_address = wallet_data['address']
+        self.address = wallet_data['address']
+        self.balance = wallet_data['balance']
+        self.available_balance = wallet_data['available_balance']
+        self.created = wallet_data['created']
+        self.private_key = wallet_data['private_key']
+        self.public_key = wallet_data['public_key']
+        self.encrypted_private_key = wallet_data['encrypted_private_key']
+        self.label = wallet_data['label']
+        self.is_locked = wallet_data.get('is_locked', True)
+        
+        print(f"DEBUG: Set current wallet to {self.address}")
+    
+    def unlock_wallet(self, address, password):
+        """Unlock wallet with password"""
+        if address not in self.wallets:
+            print(f"DEBUG: Wallet {address} not found in collection")
+            return False
+        
+        wallet_data = self.wallets[address]
+        
+        try:
+            if wallet_data.get('encrypted_private_key'):
+                # Decrypt private key
+                key = base64.urlsafe_b64encode(hashlib.sha256(password.encode()).digest())
+                fernet = Fernet(key)
+                decrypted_key = fernet.decrypt(wallet_data['encrypted_private_key'])
+                
+                # Update wallet data
+                wallet_data['private_key'] = decrypted_key.decode()
+                wallet_data['is_locked'] = False
+                
+                # If this is the current wallet, update current state
+                if self.current_wallet_address == address:
+                    self.private_key = wallet_data['private_key']
+                    self.is_locked = False
+                
+                print(f"DEBUG: Wallet {address} unlocked successfully")
+                print(f"DEBUG: Private key available: {bool(self.private_key)}")
+                
+                # Verify cryptographic integrity after unlock
+                if self._verify_wallet_integrity():
+                    print(f"DEBUG: Wallet cryptographic integrity verified")
+                else:
+                    print(f"DEBUG: WARNING: Wallet unlocked but cryptographic verification failed")
+                
+                return True
+        except Exception as e:
+            print(f"DEBUG: Unlock failed: {e}")
+        
+        return False
+    
+    def switch_wallet(self, address, password=None):
+        """Switch to a different wallet in the collection"""
+        if address in self.wallets:
+            wallet_data = self.wallets[address]
+            self._set_current_wallet(wallet_data)
+            
+            # If password provided, unlock the wallet
+            if password:
+                return self.unlock_wallet(address, password)
+            
+            return True
+        
+        print(f"DEBUG: Cannot switch to {address} - not in wallet collection")
+        return False
+    
+    # ============================================================================
+    # BALANCE AND TRANSACTION METHODS
+    # ============================================================================
+    
     def calculate_available_balance(self) -> float:
         """Calculate available balance (total balance minus pending outgoing transactions)"""
         try:
-            from lunalib.core.mempool import MempoolManager
-            from lunalib.core.blockchain import BlockchainManager
-            
             # Get total balance from blockchain
             total_balance = self._get_total_balance_from_blockchain()
             
-            # Get pending outgoing transactions from mempool
-            mempool = MempoolManager()
-            pending_txs = mempool.get_pending_transactions(self.address)
+            # Get pending outgoing amount
+            pending_outgoing = self._get_pending_balance()
             
-            # Sum pending outgoing amounts
-            pending_outgoing = 0.0
-            for tx in pending_txs:
-                if tx.get('from') == self.address:
-                    pending_outgoing += float(tx.get('amount', 0)) + float(tx.get('fee', 0))
+            # Also check for any incoming pending transactions
+            incoming_pending = self._get_pending_incoming_balance()
             
             available_balance = max(0.0, total_balance - pending_outgoing)
             
             # Update both current wallet and wallets collection
             self.available_balance = available_balance
+            self.balance = total_balance  # Also update total balance
+            
             if self.current_wallet_address in self.wallets:
                 self.wallets[self.current_wallet_address]['available_balance'] = available_balance
+                self.wallets[self.current_wallet_address]['balance'] = total_balance
+            
+            print(f"DEBUG: Balance calculated - Total: {total_balance}, Pending Out: {pending_outgoing}, Available: {available_balance}")
+            
+            if incoming_pending > 0:
+                print(f"DEBUG: Also {incoming_pending} LUN incoming (pending)")
             
-            print(f"DEBUG: Available balance calculated - Total: {total_balance}, Pending Out: {pending_outgoing}, Available: {available_balance}")
             return available_balance
             
         except Exception as e:
             print(f"DEBUG: Error calculating available balance: {e}")
             return self.balance  # Fallback to total balance
 
-    def _get_total_balance_from_blockchain(self) -> float:
-        """Get total balance by scanning blockchain for confirmed transactions"""
+    def _compute_confirmed_balance(self, transactions: List[Dict]) -> float:
+        """Compute confirmed balance from a list of transactions."""
+        total_balance = 0.0
+        for tx in transactions:
+            tx_type = (tx.get('type') or '').lower()
+            direction = tx.get('direction', '')
+            amount = float(tx.get('amount', 0) or 0)
+
+            if tx_type == 'reward' or tx.get('from') == 'network':
+                total_balance += amount
+            elif direction == 'incoming':
+                total_balance += amount
+            elif direction == 'outgoing':
+                fee = float(tx.get('fee', 0) or 0)
+                total_balance -= amount
+                total_balance -= fee
+
+        return max(0.0, total_balance)
+
+    def _compute_pending_totals(self, pending_txs: List[Dict], address: str) -> Tuple[float, float]:
+        """Return (pending_outgoing, pending_incoming) for an address."""
+        pending_out = 0.0
+        pending_in = 0.0
+
+        target_norm = self._normalize_address(address)
+        for tx in pending_txs:
+            from_norm = self._normalize_address(tx.get('from') or tx.get('sender'))
+            to_norm = self._normalize_address(tx.get('to') or tx.get('receiver'))
+
+            if from_norm == target_norm:
+                amount = float(tx.get('amount', 0) or 0)
+                fee = float(tx.get('fee', 0) or tx.get('gas', 0) or 0)
+                pending_out += amount + fee
+            if to_norm == target_norm:
+                amount = float(tx.get('amount', 0) or 0)
+                pending_in += amount
+
+        return pending_out, pending_in
+
+    def _recompute_balances_from_cache(self) -> Dict[str, Dict[str, float]]:
+        """Recompute balances for all wallets from cached tx sets."""
+        updated: Dict[str, Dict[str, float]] = {}
+
+        for addr, wallet_data in self.wallets.items():
+            confirmed = self._confirmed_tx_cache.get(addr, [])
+            pending = self._pending_tx_cache.get(addr, [])
+
+            total_balance = max(0.0, self._compute_confirmed_balance(confirmed))
+            pending_out, pending_in = self._compute_pending_totals(pending, addr)
+            available_balance = max(0.0, total_balance - pending_out)
+
+            wallet_data['balance'] = total_balance
+            wallet_data['available_balance'] = available_balance
+
+            if addr == self.current_wallet_address:
+                self.balance = total_balance
+                self.available_balance = available_balance
+
+            updated[addr] = {
+                'balance': total_balance,
+                'available_balance': available_balance,
+                'pending_out': pending_out,
+                'pending_in': pending_in
+            }
+
+        return updated
+
+    def refresh_all_wallet_balances(self) -> Dict[str, Dict[str, float]]:
+        """Scan blockchain once for all wallets, then update balances with pending mempool data."""
+        addresses = list(self.wallets.keys())
+        if not addresses:
+            return {}
+
         try:
             from lunalib.core.blockchain import BlockchainManager
-            
+            from lunalib.core.mempool import MempoolManager
+
             blockchain = BlockchainManager()
-            transactions = blockchain.scan_transactions_for_address(self.address)
+            mempool = MempoolManager()
+
+            confirmed_map = blockchain.scan_transactions_for_addresses(addresses)
+            pending_map = mempool.get_pending_transactions_for_addresses(addresses, fetch_remote=True)
+
+            # Reset caches with the latest snapshots
+            self._confirmed_tx_cache = confirmed_map
+            self._pending_tx_cache = pending_map
+
+            return self._recompute_balances_from_cache()
+
+        except Exception as e:
+            print(f"DEBUG: Error refreshing all wallet balances: {e}")
+            return {}
+
+    def sync_all_wallets_once(self) -> Dict[str, Dict[str, float]]:
+        """Convenience: scan blockchain once and mempool once, update all wallet balances."""
+        return self.refresh_all_wallet_balances()
+
+    def get_all_wallets_overview(self, include_transactions: bool = True) -> Dict[str, Dict]:
+        """Return balances and (optionally) cached transactions for all wallets."""
+        overview: Dict[str, Dict] = {}
+        for addr, wallet_data in self.wallets.items():
+            confirmed = self._confirmed_tx_cache.get(addr, [])
+            pending = self._pending_tx_cache.get(addr, [])
+
+            overview[addr] = {
+                'balance': wallet_data.get('balance', 0.0),
+                'available_balance': wallet_data.get('available_balance', 0.0),
+                'pending_out': self._compute_pending_totals(pending, addr)[0],
+                'pending_in': self._compute_pending_totals(pending, addr)[1],
+            }
+
+            if include_transactions:
+                overview[addr]['confirmed_transactions'] = confirmed
+                overview[addr]['pending_transactions'] = pending
+
+        return overview
+
+    def _apply_transaction_updates(self, confirmed_map: Dict[str, List[Dict]], pending_map: Dict[str, List[Dict]]):
+        """Update caches from monitor callbacks and recompute balances."""
+        for addr, txs in confirmed_map.items():
+            self._confirmed_tx_cache.setdefault(addr, []).extend(txs)
+
+        for addr, txs in pending_map.items():
+            self._pending_tx_cache[addr] = txs
+
+        return self._recompute_balances_from_cache()
+
+    def start_wallet_monitoring(self, poll_interval: int = 15):
+        """Start monitoring blockchain and mempool for all wallets."""
+        addresses = list(self.wallets.keys())
+        if not addresses:
+            print("DEBUG: No wallets to monitor")
+            return None
+
+        from lunalib.core.blockchain import BlockchainManager
+        blockchain = BlockchainManager()
+
+        # Run an initial refresh to seed caches and balances
+        self.refresh_all_wallet_balances()
+
+        def _on_update(payload: Dict):
+            confirmed_map = payload.get('confirmed', {}) or {}
+            pending_map = payload.get('pending', {}) or {}
+            self._apply_transaction_updates(confirmed_map, pending_map)
+
+        self._monitor_stop_event = blockchain.monitor_addresses(addresses, _on_update, poll_interval=poll_interval)
+        return self._monitor_stop_event
+
+    def stop_wallet_monitoring(self):
+        """Stop the background monitor if running."""
+        stop_event = getattr(self, '_monitor_stop_event', None)
+        if stop_event:
+            stop_event.set()
+
+    def start_sync_and_monitor(self, poll_interval: int = 15):
+        """Run a one-time sync (blockchain + mempool) then start live monitoring."""
+        self.sync_all_wallets_once()
+        return self.start_wallet_monitoring(poll_interval=poll_interval)
+
+    def get_all_balances_after_sync(self, include_transactions: bool = True) -> Dict[str, Dict]:
+        """One-shot sync then return per-wallet balances (and transactions if requested)."""
+        self.sync_all_wallets_once()
+        return self.get_all_wallets_overview(include_transactions=include_transactions)
+    def _get_pending_balance(self) -> float:
+        """Get total pending balance from mempool (outgoing pending transactions)"""
+        try:
+            from lunalib.core.mempool import MempoolManager
             
-            total_balance = 0.0
-            for tx in transactions:
-                tx_type = tx.get('type', '')
-                
-                # Handle incoming transactions
-                if tx.get('to') == self.address:
-                    if tx_type in ['transfer', 'reward', 'fee_distribution', 'gtx_genesis']:
-                        total_balance += float(tx.get('amount', 0))
-                
-                # Handle outgoing transactions  
-                elif tx.get('from') == self.address:
-                    if tx_type in ['transfer', 'stake', 'delegate']:
-                        total_balance -= float(tx.get('amount', 0))
-                        total_balance -= float(tx.get('fee', 0))
+            mempool = MempoolManager()
             
-            return max(0.0, total_balance)
+            # Get pending transactions for this address
+            pending_txs = mempool.get_pending_transactions(self.address, fetch_remote=True)
+            
+            total_pending_outgoing = 0.0
+            
+            for tx in pending_txs:
+                # Only count outgoing transactions (where we're the sender)
+                if tx.get('from') == self.address:
+                    amount = float(tx.get('amount', 0))
+                    fee = float(tx.get('fee', 0) or tx.get('gas', 0) or 0)
+                    total_pending_outgoing += amount + fee
+                    print(f"🔍 Found pending outgoing: {amount} + {fee} fee = {amount + fee}")
+            
+            return total_pending_outgoing
             
         except Exception as e:
-            print(f"DEBUG: Error getting blockchain balance: {e}")
-            return self.balance
-
-    def refresh_balance(self) -> bool:
-        """Refresh both total and available balance from blockchain and mempool"""
+            print(f"DEBUG: Error calculating pending balance: {e}")
+            return 0.0
+    
+    def _get_pending_incoming_balance(self) -> float:
+        """Get total pending incoming balance from mempool"""
         try:
-            total_balance = self._get_total_balance_from_blockchain()
-            available_balance = self.calculate_available_balance()
+            from lunalib.core.mempool import MempoolManager
             
-            # Update wallet state
-            self.balance = total_balance
-            self.available_balance = available_balance
+            mempool = MempoolManager()
             
-            # Update in wallets collection
-            if self.current_wallet_address in self.wallets:
-                self.wallets[self.current_wallet_address]['balance'] = total_balance
-                self.wallets[self.current_wallet_address]['available_balance'] = available_balance
+            # Get pending transactions for this address
+            pending_txs = mempool.get_pending_transactions(self.address, fetch_remote=True)
             
-            print(f"DEBUG: Balance refreshed - Total: {total_balance}, Available: {available_balance}")
-            return True
+            total_pending_incoming = 0.0
+            
+            for tx in pending_txs:
+                # Only count incoming transactions (where we're the receiver)
+                if tx.get('to') == self.address:
+                    amount = float(tx.get('amount', 0))
+                    total_pending_incoming += amount
+                    print(f"🔍 Found pending incoming: +{amount}")
+            
+            return total_pending_incoming
             
         except Exception as e:
-            print(f"DEBUG: Error refreshing balance: {e}")
-            return False
-
-    def get_available_balance(self) -> float:
-        """Get current wallet available balance"""
-        return self.available_balance
-
+            print(f"DEBUG: Error calculating pending incoming balance: {e}")
+            return 0.0
+    
     def _get_total_balance_from_blockchain(self) -> float:
         """Get total balance by scanning blockchain for confirmed transactions"""
         try:
@@ -134,28 +498,60 @@ class LunaWallet:
             
             blockchain = BlockchainManager()
             transactions = blockchain.scan_transactions_for_address(self.address)
-            
-            total_balance = 0.0
-            for tx in transactions:
-                tx_type = tx.get('type', '')
-                
-                # Handle incoming transactions
-                if tx.get('to') == self.address:
-                    if tx_type in ['transfer', 'reward', 'fee_distribution', 'gtx_genesis']:
-                        total_balance += float(tx.get('amount', 0))
-                
-                # Handle outgoing transactions  
-                elif tx.get('from') == self.address:
-                    if tx_type in ['transfer', 'stake', 'delegate']:
-                        total_balance -= float(tx.get('amount', 0))
-                        total_balance -= float(tx.get('fee', 0))
-            
-            return max(0.0, total_balance)
+            total_balance = self._compute_confirmed_balance(transactions)
+            return total_balance
             
         except Exception as e:
             print(f"DEBUG: Error getting blockchain balance: {e}")
             return self.balance
-
+    
+    def register_balance_callback(self, callback: Callable[[float, float], None]):
+        """Register a callback to be called when balance is updated asynchronously"""
+        self.balance_callbacks.append(callback)
+    
+    def start_async_balance_loading(self):
+        """Start asynchronous balance loading in background thread"""
+        if self.balance_loading:
+            return  # Already loading
+        
+        if time.time() - self.last_balance_update < self.balance_update_interval:
+            return  # Too soon since last update
+        
+        self.balance_loading = True
+        
+        def _async_balance_update():
+            try:
+                # Load balances asynchronously
+                total_balance = self._get_total_balance_from_blockchain()
+                available_balance = self.calculate_available_balance()
+                
+                # Update wallet state
+                self.balance = total_balance
+                self.available_balance = available_balance
+                self.last_balance_update = time.time()
+                
+                # Update in wallets collection
+                if self.current_wallet_address in self.wallets:
+                    self.wallets[self.current_wallet_address]['balance'] = total_balance
+                    self.wallets[self.current_wallet_address]['available_balance'] = available_balance
+                
+                # Notify callbacks
+                for callback in self.balance_callbacks:
+                    try:
+                        callback(total_balance, available_balance)
+                    except Exception as e:
+                        print(f"Error in balance callback: {e}")
+                
+                print(f"DEBUG: Async balance updated - Total: {total_balance}, Available: {available_balance}")
+                
+            except Exception as e:
+                print(f"DEBUG: Error in async balance loading: {e}")
+            finally:
+                self.balance_loading = False
+        
+        # Start in background thread
+        self.balance_thread_pool.submit(_async_balance_update)
+    
     def refresh_balance(self) -> bool:
         """Refresh both total and available balance from blockchain and mempool"""
         try:
@@ -177,32 +573,32 @@ class LunaWallet:
         except Exception as e:
             print(f"DEBUG: Error refreshing balance: {e}")
             return False
-
+    
     def send_transaction(self, to_address: str, amount: float, memo: str = "", password: str = None) -> bool:
-        """Send transaction using lunalib transactions with proper mempool submission"""
+        """Send transaction using REAL SM2 signatures"""
         try:
-            print(f"DEBUG: send_transaction called - to: {to_address}, amount: {amount}, memo: {memo}")
+            print(f"[SM2] Sending {amount} to {to_address}")
             
-            # Refresh balances first to get latest state
-            self.refresh_balance()
+            # 1. Basic validation
+            if self.is_locked or not self.private_key:
+                print("[SM2] Wallet locked or no private key")
+                return False
             
-            # Check available balance before proceeding
-            if amount > self.available_balance:
-                print(f"DEBUG: Insufficient available balance: {self.available_balance} < {amount}")
+            # 2. Check key integrity
+            if not self._verify_wallet_integrity():
+                print("[SM2] Invalid cryptographic keys")
                 return False
             
-            # Check if wallet is unlocked
-            if self.is_locked or not self.private_key:
-                print("DEBUG: Wallet is locked or no private key available")
+            # 3. Balance check
+            self.refresh_balance()
+            if amount > self.get_available_balance():
+                print(f"[SM2] Insufficient balance: {self.get_available_balance()} < {amount}")
                 return False
             
-            # Import transaction manager
+            # 4. Create and sign transaction
             from lunalib.transactions.transactions import TransactionManager
-            
-            # Create transaction manager
             tx_manager = TransactionManager()
             
-            # Create and sign transaction
             transaction = tx_manager.create_transaction(
                 from_address=self.address,
                 to_address=to_address,
@@ -212,244 +608,305 @@ class LunaWallet:
                 transaction_type="transfer"
             )
             
-            print(f"DEBUG: Transaction created: {transaction.get('hash')}")
+            print(f"[SM2] Transaction created: {transaction.get('hash', 'no_hash')[:16]}")
             
-            # Validate transaction
+            # 5. Validate
             is_valid, message = tx_manager.validate_transaction(transaction)
             if not is_valid:
-                print(f"DEBUG: Transaction validation failed: {message}")
+                print(f"[SM2] Validation failed: {message}")
                 return False
             
-            # Send to mempool for broadcasting
+            # 6. Broadcast
             success, message = tx_manager.send_transaction(transaction)
             if success:
-                print(f"DEBUG: Transaction sent to mempool: {message}")
+                print(f"[SM2] Transaction broadcast: {message}")
                 
-                # Update available balance immediately (deduct pending transaction)
-                fee = transaction.get('fee', 0)
-                self.available_balance -= (amount + fee)
+                # Update balance immediately
+                total_cost = amount + transaction.get('fee', 0)
+                self.available_balance -= total_cost
                 if self.current_wallet_address in self.wallets:
                     self.wallets[self.current_wallet_address]['available_balance'] = self.available_balance
                 
-                print(f"DEBUG: Available balance updated - new available: {self.available_balance}")
+                # Save state
+                self.save_wallet_data()
+                
+                # Trigger async balance refresh to get accurate data
+                self.start_async_balance_loading()
+                
                 return True
             else:
-                print(f"DEBUG: Failed to send transaction to mempool: {message}")
+                print(f"[SM2] Broadcast failed: {message}")
                 return False
                 
         except Exception as e:
-            print(f"DEBUG: Error in send_transaction: {e}")
+            print(f"[SM2] Error: {e}")
+            return False
+    
+    def save_wallet_data(self):
+        """Save wallet data to file"""
+        try:
+            print(f"[WALLET] Saving wallet data...")
+            
+            # Prepare wallet data
+            wallet_data = {
+                'version': '2.0',
+                'address': self.address,
+                'public_key': self.public_key,
+                'private_key': self.private_key,  # WARNING: In production, encrypt this!
+                'balance': self.balance,
+                'available_balance': self.available_balance,
+                'transactions': self.transactions,
+                'created_at': self.created_at,
+                'last_sync': time.time(),
+                'network': self.network,
+                'key_type': 'SM2'  # Indicate SM2 key type
+            }
+            
+            # Determine save path
+            if hasattr(self, 'wallet_file'):
+                save_path = self.wallet_file
+            else:
+                # Default save location
+                import os
+                wallet_dir = os.path.expanduser('~/.lunawallet')
+                os.makedirs(wallet_dir, exist_ok=True)
+                save_path = os.path.join(wallet_dir, f'{self.address}.json')
+            
+            # Save to file
+            import json
+            with open(save_path, 'w') as f:
+                json.dump(wallet_data, f, indent=2)
+            
+            print(f"[WALLET] Wallet data saved to {save_path}")
+            return True
+            
+        except Exception as e:
+            print(f"[WALLET ERROR] Failed to save wallet data: {e}")
             import traceback
             traceback.print_exc()
             return False
-
-    def send_transaction_from(self, from_address: str, to_address: str, amount: float, memo: str = "", password: str = None) -> bool:
-        """Send transaction from specific address"""
+    
+    def load_wallet_data(self, wallet_file=None):
+        """Load wallet data from file"""
         try:
-            print(f"DEBUG: send_transaction_from called - from: {from_address}, to: {to_address}, amount: {amount}")
-            
-            # Switch to the specified wallet if different from current
-            if from_address != self.current_wallet_address:
-                if from_address in self.wallets:
-                    # Switch to the wallet first
-                    wallet_data = self.wallets[from_address]
-                    self._set_current_wallet(wallet_data)
-                    
-                    # If password provided, unlock the wallet
-                    if password:
-                        unlock_success = self.unlock_wallet(from_address, password)
-                        if not unlock_success:
-                            print("DEBUG: Failed to unlock wallet for sending")
-                            return False
-                else:
-                    print(f"DEBUG: Wallet not found: {from_address}")
+            print(f"[WALLET] Loading wallet data...")
+            
+            if wallet_file:
+                self.wallet_file = wallet_file
+                load_path = wallet_file
+            elif hasattr(self, 'wallet_file'):
+                load_path = self.wallet_file
+            else:
+                # Try to find wallet file
+                import os
+                wallet_dir = os.path.expanduser('~/.lunawallet')
+                # Look for any .json file
+                wallet_files = [f for f in os.listdir(wallet_dir) if f.endswith('.json')]
+                if not wallet_files:
+                    print("[WALLET] No wallet file found")
                     return False
+                load_path = os.path.join(wallet_dir, wallet_files[0])
+                self.wallet_file = load_path
+            
+            # Load from file
+            import json
+            with open(load_path, 'r') as f:
+                wallet_data = json.load(f)
+            
+            # Restore wallet data
+            self.address = wallet_data.get('address', '')
+            self.public_key = wallet_data.get('public_key', '')
+            self.private_key = wallet_data.get('private_key', '')
+            self.balance = wallet_data.get('balance', 0.0)
+            self.available_balance = wallet_data.get('available_balance', 0.0)
+            self.transactions = wallet_data.get('transactions', [])
+            self.created_at = wallet_data.get('created_at', time.time())
+            self.network = wallet_data.get('network', 'mainnet')
             
-            # Now use the regular send_transaction method
-            return self.send_transaction(to_address, amount, memo, password)
+            print(f"[WALLET] Wallet loaded: {self.address}")
+            print(f"[WALLET] Balance: {self.balance}")
+            
+            # Initialize SM2 if we have keys
+            if self.public_key and self.private_key:
+                self._initialize_sm2()
+            
+            # Start async balance loading
+            self.start_async_balance_loading()
+            
+            return True
             
         except Exception as e:
-            print(f"DEBUG: Error in send_transaction_from: {e}")
-            import traceback
-            traceback.print_exc()
+            print(f"[WALLET ERROR] Failed to load wallet data: {e}")
             return False
-
+    
+    def _initialize_sm2(self):
+        """Initialize SM2 crypto if keys exist"""
+        try:
+            if self.public_key and self.private_key:
+                from ..core.crypto import KeyManager
+                self.key_manager = KeyManager()
+                print(f"[WALLET] SM2 initialized with existing keys")
+                return True
+        except Exception as e:
+            print(f"[WALLET ERROR] Failed to initialize SM2: {e}")
+        return False
     def get_transaction_history(self) -> dict:
-        """Get complete transaction history (both pending and confirmed)"""
+        """Get complete transaction history (both pending and confirmed).
+        Uses cached transactions if available, otherwise scans blockchain/mempool.
+        Includes ALL reward transactions (mining rewards and explicit reward txs).
+        """
         try:
-            from lunalib.core.blockchain import BlockchainManager
-            from lunalib.core.mempool import MempoolManager
-            
-            blockchain = BlockchainManager()
-            mempool = MempoolManager()
+            # Try to use cache first (from monitoring or sync)
+            confirmed_txs = self._confirmed_tx_cache.get(self.address, [])
+            pending_txs = self._pending_tx_cache.get(self.address, [])
             
-            # Get confirmed transactions from blockchain
-            confirmed_txs = blockchain.scan_transactions_for_address(self.address)
+            # If cache is empty, perform fresh scan
+            if not confirmed_txs:
+                from lunalib.core.blockchain import BlockchainManager
+                from lunalib.core.mempool import MempoolManager
+                
+                blockchain = BlockchainManager()
+                mempool = MempoolManager()
+                
+                # Get confirmed transactions from blockchain (includes mining rewards)
+                confirmed_txs = blockchain.scan_transactions_for_address(self.address)
+                self._confirmed_tx_cache[self.address] = confirmed_txs
+                
+                # Get pending transactions from mempool
+                pending_txs = mempool.get_pending_transactions(self.address, fetch_remote=True)
+                self._pending_tx_cache[self.address] = pending_txs
             
-            # Get pending transactions from mempool
-            pending_txs = mempool.get_pending_transactions(self.address)
+            # Count by type for debugging
+            reward_count = sum(1 for tx in confirmed_txs 
+                             if tx.get('type', '').lower() in ['reward', 'mining'] 
+                             or tx.get('from') == 'network')
             
             return {
                 'confirmed': confirmed_txs,
                 'pending': pending_txs,
                 'total_confirmed': len(confirmed_txs),
-                'total_pending': len(pending_txs)
+                'total_pending': len(pending_txs),
+                'reward_count': reward_count
             }
         except Exception as e:
             print(f"DEBUG: Error getting transaction history: {e}")
-            return {'confirmed': [], 'pending': [], 'total_confirmed': 0, 'total_pending': 0}
-
-    def _generate_private_key(self):
-        """Generate private key"""
-        return f"priv_{hashlib.sha256(str(time.time()).encode()).hexdigest()}"
-    
-    def _derive_public_key(self, private_key=None):
-        """Derive public key from private key"""
-        priv_key = private_key or self.private_key
-        if not priv_key:
-            return None
-        return f"pub_{priv_key[-16:]}"
+            return {'confirmed': [], 'pending': [], 'total_confirmed': 0, 'total_pending': 0, 'reward_count': 0}
     
-    def get_wallet_info(self):
-        """Get complete wallet information for current wallet"""
-        if not self.address:
-            return None
-        
-        # Refresh balances to ensure they're current
-        self.refresh_balance()
-        
-        return {
-            'address': self.address,
-            'balance': self.balance,
-            'available_balance': self.available_balance,
-            'created': self.created,
-            'private_key': self.private_key,
-            'public_key': self.public_key,
-            'encrypted_private_key': self.encrypted_private_key,
-            'label': self.label,
-            'is_locked': self.is_locked
-        }
-
-    def create_new_wallet(self, name, password):
-        """Create a new wallet and add to collection without switching"""
-        # Generate new wallet data
-        address = self._generate_address()
-        private_key = self._generate_private_key()
-        public_key = f"pub_{private_key[-16:]}"
-        
-        # Encrypt private key
-        key = base64.urlsafe_b64encode(hashlib.sha256(password.encode()).digest())
-        fernet = Fernet(key)
-        encrypted_private_key = fernet.encrypt(private_key.encode())
-        
-        # Create new wallet data
-        new_wallet_data = {
-            'address': address,
-            'balance': 0.0,
-            'available_balance': 0.0,
-            'created': time.time(),
-            'private_key': private_key,
-            'public_key': public_key,
-            'encrypted_private_key': encrypted_private_key,
-            'label': name,
-            'is_locked': True
-        }
-        
-        # CRITICAL: Add to wallets collection
-        self.wallets[address] = new_wallet_data
-        
-        print(f"DEBUG: Created new wallet {address}, total wallets: {len(self.wallets)}")
-        
-        return new_wallet_data
-
-    def create_wallet(self, name, password):
-        """Create a new wallet and set it as current"""
-        # Generate new wallet data
-        address = self._generate_address()
-        private_key = self._generate_private_key()
-        public_key = f"pub_{private_key[-16:]}"
-        
-        # Encrypt private key
-        key = base64.urlsafe_b64encode(hashlib.sha256(password.encode()).digest())
-        fernet = Fernet(key)
-        encrypted_private_key = fernet.encrypt(private_key.encode())
-        
-        # Create wallet data
-        wallet_data = {
-            'address': address,
-            'balance': 0.0,
-            'available_balance': 0.0,
-            'created': time.time(),
-            'private_key': private_key,
-            'public_key': public_key,
-            'encrypted_private_key': encrypted_private_key,
-            'label': name,
-            'is_locked': True
-        }
+    def get_wallet_transactions(self, address: str = None, include_pending: bool = True) -> Dict[str, List[Dict]]:
+        """Get ALL transactions for a wallet including mining rewards, transfers, and pending.
         
-        # CRITICAL: Add to wallets collection
-        self.wallets[address] = wallet_data
+        This is the comprehensive transaction getter that ensures ALL reward transactions
+        (mining rewards, explicit reward transactions) are included.
         
-        # Set as current wallet
-        self._set_current_wallet(wallet_data)
+        Args:
+            address: wallet address to query (defaults to current wallet address)
+            include_pending: whether to include pending mempool transactions (default: True)
+            
+        Returns:
+            Dict with:
+                - 'confirmed': list of all confirmed transactions (transfers + mining rewards)
+                - 'pending': list of pending mempool transactions
+                - 'reward_transactions': list of only reward/mining transactions
+                - 'transfer_transactions': list of only transfer transactions
+                - 'total_rewards': count of reward transactions
+                - 'total_transfers': count of transfer transactions
+        """
+        if address is None:
+            address = self.address
         
-        print(f"DEBUG: Created and switched to wallet {address}, total wallets: {len(self.wallets)}")
+        if not address:
+            return {
+                'confirmed': [],
+                'pending': [],
+                'reward_transactions': [],
+                'transfer_transactions': [],
+                'incoming_transfers': [],
+                'outgoing_transfers': [],
+                'total_rewards': 0,
+                'total_transfers': 0,
+                'total_incoming': 0,
+                'total_outgoing': 0
+            }
         
-        return wallet_data
-
-    def _set_current_wallet(self, wallet_data):
-        """Set the current wallet from wallet data"""
-        self.current_wallet_address = wallet_data['address']
-        self.address = wallet_data['address']
-        self.balance = wallet_data['balance']
-        self.available_balance = wallet_data['available_balance']
-        self.created = wallet_data['created']
-        self.private_key = wallet_data['private_key']
-        self.public_key = wallet_data['public_key']
-        self.encrypted_private_key = wallet_data['encrypted_private_key']
-        self.label = wallet_data['label']
-        self.is_locked = wallet_data.get('is_locked', True)
-
-    def switch_wallet(self, address, password=None):
-        """Switch to a different wallet in the collection"""
-        if address in self.wallets:
-            wallet_data = self.wallets[address]
-            self._set_current_wallet(wallet_data)
+        try:
+            # Normalize address for comparison
+            norm_addr = self._normalize_address(address)
             
-            # Refresh balances for the new wallet
-            self.refresh_balance()
+            # Use cache if available
+            confirmed_txs = self._confirmed_tx_cache.get(norm_addr, [])
+            pending_txs = self._pending_tx_cache.get(norm_addr, []) if include_pending else []
             
-            # If password provided, unlock the wallet
-            if password:
-                return self.unlock_wallet(address, password)
+            # If cache is empty, perform fresh scan
+            if not confirmed_txs:
+                from lunalib.core.blockchain import BlockchainManager
+                blockchain = BlockchainManager()
+                confirmed_txs = blockchain.scan_transactions_for_address(address)
+                self._confirmed_tx_cache[norm_addr] = confirmed_txs
             
-            return True
-        return False
-
-    def unlock_wallet(self, address, password):
-        """Unlock wallet with password"""
-        if address not in self.wallets:
-            return False
+            if include_pending and not pending_txs:
+                from lunalib.core.mempool import MempoolManager
+                mempool = MempoolManager()
+                pending_txs = mempool.get_pending_transactions(address, fetch_remote=True)
+                self._pending_tx_cache[norm_addr] = pending_txs
             
-        wallet_data = self.wallets[address]
-        
-        try:
-            if wallet_data.get('encrypted_private_key'):
-                key = base64.urlsafe_b64encode(hashlib.sha256(password.encode()).digest())
-                fernet = Fernet(key)
-                decrypted_key = fernet.decrypt(wallet_data['encrypted_private_key'])
-                wallet_data['private_key'] = decrypted_key.decode()
-                wallet_data['is_locked'] = False
-                
-                # If this is the current wallet, update current state
-                if self.current_wallet_address == address:
-                    self.private_key = wallet_data['private_key']
-                    self.is_locked = False
-                
-                return True
-        except:
-            pass
-        return False
+            # Separate rewards and transfers based on type and source
+            # Rewards: explicitly marked as reward/mining type, or from network
+            reward_txs = [tx for tx in confirmed_txs 
+                         if tx.get('type', '').lower() in ['reward', 'mining', 'gtx_genesis'] 
+                         or tx.get('from') == 'network']
+            
+            # Transfers: anything that's NOT a reward (includes both incoming and outgoing)
+            transfer_txs = [tx for tx in confirmed_txs 
+                           if tx.get('type', '').lower() not in ['reward', 'mining', 'gtx_genesis'] 
+                           and tx.get('from') != 'network']
+            
+            # Separate incoming vs outgoing transfers
+            incoming_transfers = [tx for tx in transfer_txs if tx.get('direction') == 'incoming']
+            outgoing_transfers = [tx for tx in transfer_txs if tx.get('direction') == 'outgoing']
+            
+            result = {
+                'confirmed': confirmed_txs,
+                'pending': pending_txs,
+                'reward_transactions': reward_txs,
+                'transfer_transactions': transfer_txs,
+                'incoming_transfers': incoming_transfers,
+                'outgoing_transfers': outgoing_transfers,
+                'total_rewards': len(reward_txs),
+                'total_transfers': len(transfer_txs),
+                'total_incoming': len(incoming_transfers),
+                'total_outgoing': len(outgoing_transfers)
+            }
+            
+            print(f"DEBUG: get_wallet_transactions({address}):")
+            print(f"  - Mining Rewards: {len(reward_txs)}")
+            print(f"  - Incoming Transfers: {len(incoming_transfers)}")
+            print(f"  - Outgoing Transfers: {len(outgoing_transfers)}")
+            print(f"  - Total Transfers: {len(transfer_txs)}")
+            print(f"  - Pending: {len(pending_txs)}")
+            print(f"  - Total Confirmed: {len(confirmed_txs)}")
+            
+            return result
+            
+        except Exception as e:
+            print(f"DEBUG: Error getting wallet transactions: {e}")
+            import traceback
+            traceback.print_exc()
+            return {
+                'confirmed': [],
+                'pending': [],
+                'reward_transactions': [],
+                'transfer_transactions': [],
+                'incoming_transfers': [],
+                'outgoing_transfers': [],
+                'total_rewards': 0,
+                'total_transfers': 0,
+                'total_incoming': 0,
+                'total_outgoing': 0
+            }
+    
+    # ============================================================================
+    # WALLET INFO AND UTILITIES
+    # ============================================================================
     
     @property
     def is_unlocked(self):
@@ -463,7 +920,7 @@ class LunaWallet:
         """Export private key with password decryption"""
         if address not in self.wallets:
             return None
-            
+        
         wallet_data = self.wallets[address]
         
         try:
@@ -482,16 +939,17 @@ class LunaWallet:
             address = wallet_data.get('address')
             if not address:
                 return False
-                
+            
+            # Check if wallet uses SM2 cryptography
+            if wallet_data.get('crypto_standard') != 'SM2_GB/T_32918':
+                print(f"DEBUG: WARNING: Importing wallet without SM2 cryptography standard")
+            
             # Add to wallets collection
             self.wallets[address] = wallet_data.copy()
             
             # Set as current wallet
             self._set_current_wallet(wallet_data)
             
-            # Refresh balances for imported wallet
-            self.refresh_balance()
-            
             if password and wallet_data.get('encrypted_private_key'):
                 return self.unlock_wallet(address, password)
             
@@ -499,11 +957,10 @@ class LunaWallet:
         return False
     
     def update_balance(self, new_balance):
-        """Update current wallet balance (use refresh_balance instead for accurate tracking)"""
+        """Update current wallet balance"""
         self.balance = float(new_balance)
         self.available_balance = float(new_balance)
         
-        # Also update in wallets collection
         if self.current_wallet_address and self.current_wallet_address in self.wallets:
             self.wallets[self.current_wallet_address]['balance'] = self.balance
             self.wallets[self.current_wallet_address]['available_balance'] = self.available_balance
@@ -531,10 +988,203 @@ class LunaWallet:
         if not self.current_wallet_address:
             return None
         
-        # Refresh balances to ensure they're current
+        return self.wallets.get(self.current_wallet_address)
+    
+    def get_wallet_info(self):
+        """Get complete wallet information for current wallet"""
+        if not self.address:
+            return None
+        
         self.refresh_balance()
         
-        return self.wallets.get(self.current_wallet_address)
+        return {
+            'address': self.address,
+            'balance': self.balance,
+            'available_balance': self.available_balance,
+            'created': self.created,
+            'private_key': self.private_key,
+            'public_key': self.public_key,
+            'encrypted_private_key': self.encrypted_private_key,
+            'label': self.label,
+            'is_locked': self.is_locked,
+            'crypto_standard': 'SM2_GB/T_32918'
+        }
+    
+    # ============================================================================
+    # UNIFIED WALLET STATE MANAGER INTEGRATION
+    # ============================================================================
+    
+    def sync_with_state_manager(self, blockchain=None, mempool=None) -> Dict:
+        """
+        Sync all registered wallets with the unified WalletStateManager.
+        Scans blockchain once and merges mempool data for all wallets.
+        
+        Parameters:
+            blockchain: BlockchainManager instance (required)
+            mempool: MempoolManager instance (required)
+        
+        Returns: Dictionary of wallet summaries with balances and transactions
+        """
+        try:
+            if not blockchain or not mempool:
+                print("❌ blockchain and mempool instances required")
+                return {}
+            
+            from .wallet_manager import get_wallet_manager
+            
+            state_manager = get_wallet_manager()
+            
+            # Register all wallets with state manager if not already done
+            addresses = list(self.wallets.keys())
+            state_manager.register_wallets(addresses)
+            
+            print(f"🔄 Syncing {len(addresses)} wallets...")
+            
+            # Get data from blockchain and mempool (single scan)
+            blockchain_txs = blockchain.scan_transactions_for_addresses(addresses)
+            mempool_txs = mempool.get_pending_transactions_for_addresses(addresses)
+            
+            # Sync state manager with the data
+            state_manager.sync_wallets_from_sources(blockchain_txs, mempool_txs)
+            
+            # Update LunaWallet balances from state manager
+            balances = state_manager.get_all_balances()
+            for address, balance_data in balances.items():
+                if address in self.wallets:
+                    self.wallets[address]['balance'] = balance_data['confirmed_balance']
+                    self.wallets[address]['available_balance'] = balance_data['available_balance']
+            
+            # Update current wallet
+            if self.current_wallet_address and self.current_wallet_address in balances:
+                balance_data = balances[self.current_wallet_address]
+                self.balance = balance_data['confirmed_balance']
+                self.available_balance = balance_data['available_balance']
+            
+            # Return summaries
+            summaries = state_manager.get_all_summaries()
+            print(f"✅ Sync complete - {len(summaries)} wallets updated")
+            
+            return summaries
+            
+        except Exception as e:
+            print(f"❌ Sync error: {e}")
+            import traceback
+            traceback.print_exc()
+            return {}
+    
+    def get_wallet_details(self, address: str = None) -> Optional[Dict]:
+        """
+        Get detailed information for a wallet including balance and transaction summary.
+        If address is None, uses current wallet.
+        """
+        if address is None:
+            address = self.current_wallet_address
+        
+        if not address:
+            return None
+        
+        try:
+            from .wallet_manager import get_wallet_manager
+            state_manager = get_wallet_manager()
+            
+            summary = state_manager.get_wallet_summary(address)
+            if summary:
+                return summary
+            
+            # Fallback to basic wallet info
+            if address in self.wallets:
+                wallet_data = self.wallets[address]
+                return {
+                    'address': address,
+                    'label': wallet_data.get('label', 'Wallet'),
+                    'balance': wallet_data.get('balance', 0.0),
+                    'available_balance': wallet_data.get('available_balance', 0.0),
+                    'is_locked': wallet_data.get('is_locked', True),
+                }
+            
+            return None
+            
+        except Exception as e:
+            print(f"⚠️  Error getting wallet details: {e}")
+            return None
+    
+    def get_wallet_transactions(self, address: str = None, tx_type: str = 'all') -> List[Dict]:
+        """
+        Get transactions for a wallet from the state manager.
+        
+        tx_type: 'all', 'confirmed', 'pending', 'transfers', 'rewards', 'genesis'
+        """
+        if address is None:
+            address = self.current_wallet_address
+        
+        if not address:
+            return []
+        
+        try:
+            from .wallet_manager import get_wallet_manager
+            state_manager = get_wallet_manager()
+            
+            return state_manager.get_transactions(address, tx_type)
+            
+        except Exception as e:
+            print(f"⚠️  Error getting transactions: {e}")
+            return []
+    
+    def register_wallet_ui_callback(self, callback: Callable) -> None:
+        """
+        Register a callback to receive real-time wallet balance updates.
+        Callback will be called with: callback(balance_data_dict)
+        """
+        try:
+            from .wallet_manager import get_wallet_manager
+            state_manager = get_wallet_manager()
+            state_manager.on_balance_update(callback)
+        except Exception as e:
+            print(f"⚠️  Error registering callback: {e}")
+    
+    def start_continuous_sync(self, blockchain=None, mempool=None, poll_interval: int = 30) -> None:
+        """
+        Start continuous synchronization in background thread.
+        Syncs every poll_interval seconds.
+        """
+        if not blockchain or not mempool:
+            print("❌ blockchain and mempool instances required")
+            return
+        
+        try:
+            from .wallet_manager import get_wallet_manager
+            from .wallet_sync_helper import WalletSyncHelper
+            
+            state_manager = get_wallet_manager()
+            
+            # Register wallets
+            addresses = list(self.wallets.keys())
+            state_manager.register_wallets(addresses)
+            
+            def sync_callback(balance_data):
+                """Update LunaWallet when state manager updates"""
+                for address, balance_info in balance_data.items():
+                    if address in self.wallets:
+                        self.wallets[address]['balance'] = balance_info['confirmed_balance']
+                        self.wallets[address]['available_balance'] = balance_info['available_balance']
+                    
+                    if address == self.current_wallet_address:
+                        self.balance = balance_info['confirmed_balance']
+                        self.available_balance = balance_info['available_balance']
+            
+            # Create sync helper
+            sync_helper = WalletSyncHelper(self, blockchain, mempool)
+            
+            # Start continuous sync with callback
+            sync_helper.start_continuous_sync(
+                poll_interval,
+                on_balance_update=sync_callback
+            )
+            
+            print(f"🔄 Started continuous sync (interval: {poll_interval}s)")
+            
+        except Exception as e:
+            print(f"❌ Error starting continuous sync: {e}")
     
     def save_to_file(self, filename=None):
         """Save wallet to file"""
@@ -547,23 +1197,18 @@ class LunaWallet:
         filepath = os.path.join(self.data_dir, filename)
         
         try:
-            # Ensure directory exists
             os.makedirs(self.data_dir, exist_ok=True)
             
-            # Prepare encrypted private key for serialization
             encrypted_key_data = None
             if self.encrypted_private_key:
-                # Ensure it's bytes before encoding
                 if isinstance(self.encrypted_private_key, bytes):
                     encrypted_key_data = base64.b64encode(self.encrypted_private_key).decode('utf-8')
                 else:
                     encrypted_key_data = base64.b64encode(self.encrypted_private_key.encode()).decode('utf-8')
             
-            # Prepare wallets for serialization (remove any non-serializable data)
             serializable_wallets = {}
             for addr, wallet_info in self.wallets.items():
                 serializable_wallet = wallet_info.copy()
-                # Ensure encrypted_private_key is serializable
                 if serializable_wallet.get('encrypted_private_key') and isinstance(serializable_wallet['encrypted_private_key'], bytes):
                     serializable_wallet['encrypted_private_key'] = base64.b64encode(
                         serializable_wallet['encrypted_private_key']
@@ -580,18 +1225,21 @@ class LunaWallet:
                 'label': self.label,
                 'is_locked': self.is_locked,
                 'wallets': serializable_wallets,
-                'current_wallet_address': self.current_wallet_address
+                'current_wallet_address': self.current_wallet_address,
+                'crypto_standard': 'SM2_GB/T_32918'
             }
             
             with open(filepath, 'w') as f:
                 json.dump(wallet_data, f, indent=2)
+            
+            print(f"DEBUG: Wallet saved to {filepath}")
             return True
         except Exception as e:
             print(f"Error saving wallet: {e}")
             import traceback
             traceback.print_exc()
             return False
-
+    
     def load_from_file(self, filename, password=None):
         """Load wallet from file"""
         if not self.data_dir:
@@ -603,6 +1251,11 @@ class LunaWallet:
             with open(filepath, 'r') as f:
                 wallet_data = json.load(f)
             
+            # Check crypto standard
+            crypto_standard = wallet_data.get('crypto_standard')
+            if crypto_standard != 'SM2_GB/T_32918':
+                print(f"DEBUG: WARNING: Loading wallet with different crypto standard: {crypto_standard}")
+            
             # Load wallets collection
             self.wallets = wallet_data.get('wallets', {})
             
@@ -614,22 +1267,76 @@ class LunaWallet:
                 current_wallet_data = self.wallets[self.current_wallet_address]
                 self._set_current_wallet(current_wallet_data)
                 
-                # Handle encrypted private key
                 encrypted_key = wallet_data.get('encrypted_private_key')
                 if encrypted_key:
                     self.encrypted_private_key = base64.b64decode(encrypted_key.encode())
-                    # Also update in wallets collection
                     if self.current_wallet_address in self.wallets:
                         self.wallets[self.current_wallet_address]['encrypted_private_key'] = self.encrypted_private_key
             
-            # Refresh balances after loading
             self.refresh_balance()
             
-            # If password provided and we have encrypted key, unlock
             if password and self.encrypted_private_key and self.current_wallet_address:
                 return self.unlock_wallet(self.current_wallet_address, password)
             
+            print(f"DEBUG: Wallet loaded from {filepath}")
+            print(f"DEBUG: Total wallets: {len(self.wallets)}")
+            print(f"DEBUG: Current wallet: {self.current_wallet_address}")
+            
             return True
         except Exception as e:
             print(f"Error loading wallet: {e}")
-            return False
+            return False
+    
+    def debug_crypto_info(self):
+        """Debug cryptographic information"""
+        print("\n" + "="*60)
+        print("SM2 CRYPTOGRAPHY DEBUG INFO")
+        print("="*60)
+        
+        if self.current_wallet_address:
+            print(f"Current Address: {self.address}")
+            
+            # Check address format
+            if self.address.startswith('LUN_'):
+                print("✅ Address has correct LUN_ prefix")
+            else:
+                print("❌ Address missing LUN_ prefix")
+            
+            # Check private key
+            if self.private_key:
+                print(f"Private Key: {self.private_key[:16]}...")
+                if len(self.private_key) == 64:
+                    print(f"✅ Private key is 256-bit (64 hex chars)")
+                else:
+                    print(f"❌ Private key has wrong length: {len(self.private_key)} chars")
+            else:
+                print("❌ No private key available")
+            
+            # Check public key
+            if self.public_key:
+                print(f"Public Key: {self.public_key[:16]}...")
+                if len(self.public_key) >= 128:
+                    print(f"✅ Public key is valid length")
+                else:
+                    print(f"❌ Public key too short: {len(self.public_key)} chars")
+            else:
+                print("❌ No public key available")
+            
+            # Check cryptographic standard
+            wallet_data = self.wallets.get(self.address, {})
+            if wallet_data.get('crypto_standard') == 'SM2_GB/T_32918':
+                print("✅ Using SM2 GB/T 32918 East Asian cryptography standard")
+            else:
+                print("❌ Not using SM2 cryptography standard")
+            
+            # Test signing
+            if self.private_key and not self.is_locked:
+                test_sig = self._sign_transaction_data({"test": "data"})
+                if test_sig:
+                    print(f"✅ Can sign transactions, signature: {test_sig[:16]}...")
+                else:
+                    print("❌ Cannot sign transactions")
+        else:
+            print("❌ No wallet selected")
+        
+        print("="*60)