lunalib 1.6.7__py3-none-any.whl → 1.7.9__py3-none-any.whl

lunalib/.gitignore

@@ -0,0 +1,3 @@
+.venv
+build
+.__pycache__

lunalib/core/blockchain.py

@@ -4,17 +4,23 @@ from ..storage.cache import BlockchainCache
 import requests
 import time
 import json
-from typing import Dict, List, Optional, Tuple
+import asyncio
+import threading
+from concurrent.futures import ThreadPoolExecutor, Future
+from typing import Dict, List, Optional, Tuple, Callable
 
 
 class BlockchainManager:
     """Manages blockchain interactions and scanning with transaction broadcasting"""
     
-    def __init__(self, endpoint_url="https://bank.linglin.art"):
+    def __init__(self, endpoint_url="https://bank.linglin.art", max_workers=10):
         self.endpoint_url = endpoint_url.rstrip('/')
         self.cache = BlockchainCache()
         self.network_connected = False
         self._stop_events = []  # Track background monitors so they can be stopped
+        self.executor = ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix="BlockchainWorker")
+        self._async_tasks = {}  # Track async tasks by ID
+        self._task_callbacks = {}  # Callbacks for task completion
 
     # ------------------------------------------------------------------
     # Address helpers
@@ -26,6 +32,30 @@ class BlockchainManager:
         addr_str = str(addr).strip("'\" ").lower()
         return addr_str[4:] if addr_str.startswith('lun_') else addr_str
         
+    def broadcast_transaction_async(self, transaction: Dict, callback: Callable = None) -> str:
+        """Async version: Broadcast transaction in background thread
+        
+        Returns: task_id that can be used to check status
+        """
+        task_id = f"broadcast_{transaction.get('hash', 'unknown')}_{int(time.time())}"
+        
+        def _broadcast_task():
+            try:
+                success, message = self.broadcast_transaction(transaction)
+                if callback:
+                    callback(success=success, result=message, error=None if success else message)
+                return (success, message)
+            except Exception as e:
+                print(f"❌ Async broadcast error: {e}")
+                if callback:
+                    callback(success=False, result=None, error=str(e))
+                return (False, str(e))
+        
+        future = self.executor.submit(_broadcast_task)
+        self._async_tasks[task_id] = future
+        print(f"🔄 Started async broadcast: {task_id}")
+        return task_id
+    
     def broadcast_transaction(self, transaction: Dict) -> Tuple[bool, str]:
         """Broadcast transaction to mempool with enhanced error handling"""
         try:
@@ -210,6 +240,30 @@ class BlockchainManager:
             
         return None
     
+    def get_blocks_range_async(self, start_height: int, end_height: int, callback: Callable = None) -> str:
+        """Async version: Get range of blocks in background thread
+        
+        Returns: task_id that can be used to check status
+        """
+        task_id = f"blocks_range_{start_height}_{end_height}_{int(time.time())}"
+        
+        def _fetch_task():
+            try:
+                result = self.get_blocks_range(start_height, end_height)
+                if callback:
+                    callback(success=True, result=result, error=None)
+                return result
+            except Exception as e:
+                print(f"❌ Async blocks fetch error: {e}")
+                if callback:
+                    callback(success=False, result=None, error=str(e))
+                return None
+        
+        future = self.executor.submit(_fetch_task)
+        self._async_tasks[task_id] = future
+        print(f"🔄 Started async blocks fetch: {task_id}")
+        return task_id
+    
     def get_blocks_range(self, start_height: int, end_height: int) -> List[Dict]:
         """Get range of blocks"""
         blocks = []
@@ -286,6 +340,31 @@ class BlockchainManager:
         
         print(f"[SCAN] Found {len(transactions)} total transactions for {address}")
         return transactions
+    
+    def scan_transactions_for_address_async(self, address: str, callback: Callable = None, 
+                                           start_height: int = 0, end_height: int = None) -> str:
+        """Async version: Scan blockchain in background thread, call callback when done
+        
+        Returns: task_id that can be used to check status
+        """
+        task_id = f"scan_{address}_{int(time.time())}"
+        
+        def _scan_task():
+            try:
+                result = self.scan_transactions_for_address(address, start_height, end_height)
+                if callback:
+                    callback(success=True, result=result, error=None)
+                return result
+            except Exception as e:
+                print(f"❌ Async scan error: {e}")
+                if callback:
+                    callback(success=False, result=None, error=str(e))
+                return None
+        
+        future = self.executor.submit(_scan_task)
+        self._async_tasks[task_id] = future
+        print(f"🔄 Started async scan task: {task_id}")
+        return task_id
 
     def scan_transactions_for_addresses(self, addresses: List[str], start_height: int = 0, end_height: int = None) -> Dict[str, List[Dict]]:
         """Scan the blockchain once for multiple addresses (rewards and transfers)."""
@@ -328,7 +407,84 @@ class BlockchainManager:
             print(f"  - {addr}: {len(results[addr])} transactions")
 
         return results
+    
+    def scan_transactions_for_addresses_async(self, addresses: List[str], callback: Callable = None,
+                                             start_height: int = 0, end_height: int = None) -> str:
+        """Async version: Scan blockchain for multiple addresses in background thread
+        
+        Returns: task_id that can be used to check status
+        """
+        task_id = f"multi_scan_{int(time.time())}"
+        
+        def _scan_task():
+            try:
+                result = self.scan_transactions_for_addresses(addresses, start_height, end_height)
+                if callback:
+                    callback(success=True, result=result, error=None)
+                return result
+            except Exception as e:
+                print(f"❌ Async multi-scan error: {e}")
+                if callback:
+                    callback(success=False, result=None, error=str(e))
+                return None
+        
+        future = self.executor.submit(_scan_task)
+        self._async_tasks[task_id] = future
+        print(f"🔄 Started async multi-scan task: {task_id}")
+        return task_id
 
+    def get_task_status(self, task_id: str) -> Dict:
+        """Check status of an async task
+        
+        Returns: {'status': 'running'|'completed'|'failed'|'not_found', 'result': any, 'error': str}
+        """
+        if task_id not in self._async_tasks:
+            return {'status': 'not_found', 'result': None, 'error': 'Task not found'}
+        
+        future = self._async_tasks[task_id]
+        
+        if future.running():
+            return {'status': 'running', 'result': None, 'error': None}
+        elif future.done():
+            try:
+                result = future.result(timeout=0)
+                return {'status': 'completed', 'result': result, 'error': None}
+            except Exception as e:
+                return {'status': 'failed', 'result': None, 'error': str(e)}
+        else:
+            return {'status': 'pending', 'result': None, 'error': None}
+    
+    def cancel_task(self, task_id: str) -> bool:
+        """Cancel a running async task
+        
+        Returns: True if cancelled, False otherwise
+        """
+        if task_id in self._async_tasks:
+            future = self._async_tasks[task_id]
+            if future.cancel():
+                del self._async_tasks[task_id]
+                print(f"✅ Task cancelled: {task_id}")
+                return True
+        return False
+    
+    def get_active_tasks(self) -> List[str]:
+        """Get list of active task IDs"""
+        return [task_id for task_id, future in self._async_tasks.items() if future.running()]
+    
+    def cleanup_completed_tasks(self):
+        """Remove completed tasks from tracking"""
+        completed = [task_id for task_id, future in self._async_tasks.items() if future.done()]
+        for task_id in completed:
+            del self._async_tasks[task_id]
+        if completed:
+            print(f"🧹 Cleaned up {len(completed)} completed tasks")
+    
+    def shutdown(self):
+        """Shutdown the thread pool executor"""
+        print("🛑 Shutting down BlockchainManager executor...")
+        self.executor.shutdown(wait=True)
+        print("✅ Executor shutdown complete")
+    
     def monitor_addresses(self, addresses: List[str], on_update, poll_interval: int = 15):
         """Start background monitor for addresses; returns a stop event."""
         import threading
@@ -379,6 +535,30 @@ class BlockchainManager:
         thread.start()
         return stop_event
 
+    def submit_mined_block_async(self, block_data: Dict, callback: Callable = None) -> str:
+        """Async version: Submit mined block in background thread
+        
+        Returns: task_id that can be used to check status
+        """
+        task_id = f"submit_block_{block_data.get('index', 'unknown')}_{int(time.time())}"
+        
+        def _submit_task():
+            try:
+                success = self.submit_mined_block(block_data)
+                if callback:
+                    callback(success=success, result=block_data if success else None, error=None if success else "Submission failed")
+                return success
+            except Exception as e:
+                print(f"❌ Async block submission error: {e}")
+                if callback:
+                    callback(success=False, result=None, error=str(e))
+                return False
+        
+        future = self.executor.submit(_submit_task)
+        self._async_tasks[task_id] = future
+        print(f"🔄 Started async block submission: {task_id}")
+        return task_id
+    
     def submit_mined_block(self, block_data: Dict) -> bool:
         """Submit a mined block to the network with built-in validation"""
         try:

lunalib/core/daemon.py

@@ -1,7 +1,8 @@
 # lunalib/core/daemon.py
 import time
 import threading
-from typing import Dict, List, Optional
+from concurrent.futures import ThreadPoolExecutor
+from typing import Dict, List, Optional, Callable
 import json
 from datetime import datetime
 
@@ -12,7 +13,7 @@ class BlockchainDaemon:
     Validates all transactions, manages peer registry, and serves as source of truth.
     """
     
-    def __init__(self, blockchain_manager, mempool_manager, security_manager=None):
+    def __init__(self, blockchain_manager, mempool_manager, security_manager=None, max_workers=5):
         self.blockchain = blockchain_manager
         self.mempool = mempool_manager
         self.security = security_manager
@@ -21,6 +22,10 @@ class BlockchainDaemon:
         from ..mining.difficulty import DifficultySystem
         self.difficulty_system = DifficultySystem()
         
+        # Thread pool for async operations
+        self.executor = ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix="DaemonWorker")
+        self._async_tasks = {}  # Track async tasks
+        
         # Peer registry
         self.peers = {}  # {node_id: peer_info}
         self.peer_lock = threading.Lock()
@@ -64,6 +69,10 @@ class BlockchainDaemon:
         if self.cleanup_thread:
             self.cleanup_thread.join(timeout=5)
         
+        # Shutdown executor
+        print("🛑 Shutting down daemon executor...")
+        self.executor.shutdown(wait=True)
+        
         print("🛑 Blockchain Daemon stopped")
     
     def register_peer(self, peer_info: Dict) -> Dict:
@@ -140,6 +149,30 @@ class BlockchainDaemon:
             if node_id in self.peers:
                 self.peers[node_id]['last_seen'] = time.time()
     
+    def validate_block_async(self, block: Dict, callback: Callable = None) -> str:
+        """Async version: Validate block in background thread
+        
+        Returns: task_id that can be used to check status
+        """
+        task_id = f"validate_block_{block.get('index', 'unknown')}_{int(time.time())}"
+        
+        def _validate_task():
+            try:
+                result = self.validate_block(block)
+                if callback:
+                    callback(success=result['valid'], result=result, error=None if result['valid'] else result['message'])
+                return result
+            except Exception as e:
+                print(f"❌ Async validation error: {e}")
+                if callback:
+                    callback(success=False, result=None, error=str(e))
+                return {'valid': False, 'message': str(e), 'errors': [str(e)]}
+        
+        future = self.executor.submit(_validate_task)
+        self._async_tasks[task_id] = future
+        print(f"🔄 Started async block validation: {task_id}")
+        return task_id
+    
     def validate_block(self, block: Dict) -> Dict:
         """
         Validate a block submitted by a peer or miner.
@@ -174,13 +207,26 @@ class BlockchainDaemon:
             if not self.difficulty_system.validate_block_hash(block_hash, difficulty):
                 errors.append(f"Hash doesn't meet difficulty {difficulty} requirement (needs {difficulty} leading zeros)")
             
-            # Validate exponential reward matches difficulty
-            expected_reward = self.difficulty_system.calculate_block_reward(difficulty)
+            # Validate reward matches difficulty
+            # Empty blocks use LINEAR system (difficulty = reward)
+            # Regular blocks use EXPONENTIAL system (10^(difficulty-1))
+            transactions = block.get('transactions', [])
+            is_empty_block = len(transactions) == 1 and transactions[0].get('is_empty_block', False)
+            
+            if is_empty_block:
+                # Empty block: linear reward (difficulty 1 = 1 LKC, difficulty 2 = 2 LKC, etc.)
+                expected_reward = float(difficulty)
+                reward_type = "Linear"
+            else:
+                # Regular block: exponential reward (10^(difficulty-1))
+                expected_reward = self.difficulty_system.calculate_block_reward(difficulty)
+                reward_type = "Exponential"
+            
             actual_reward = block.get('reward', 0)
             
             # Allow small tolerance for floating point comparison
             if abs(actual_reward - expected_reward) > 0.01:
-                errors.append(f"Reward mismatch: expected {expected_reward} LKC for difficulty {difficulty}, got {actual_reward} LKC")
+                errors.append(f"Reward mismatch ({reward_type}): expected {expected_reward} LKC for difficulty {difficulty}, got {actual_reward} LKC")
             
             # Validate transactions
             for tx in block.get('transactions', []):
@@ -251,6 +297,30 @@ class BlockchainDaemon:
         except Exception as e:
             return {'valid': False, 'message': f'Validation error: {str(e)}', 'errors': [str(e)]}
     
+    def process_incoming_block_async(self, block: Dict, from_peer: Optional[str] = None, callback: Callable = None) -> str:
+        """Async version: Process incoming block in background thread
+        
+        Returns: task_id that can be used to check status
+        """
+        task_id = f"process_block_{block.get('index', 'unknown')}_{int(time.time())}"
+        
+        def _process_task():
+            try:
+                result = self.process_incoming_block(block, from_peer)
+                if callback:
+                    callback(success=result.get('success', False), result=result, error=None if result.get('success') else result.get('message'))
+                return result
+            except Exception as e:
+                print(f"❌ Async block processing error: {e}")
+                if callback:
+                    callback(success=False, result=None, error=str(e))
+                return {'success': False, 'message': str(e)}
+        
+        future = self.executor.submit(_process_task)
+        self._async_tasks[task_id] = future
+        print(f"🔄 Started async block processing: {task_id}")
+        return task_id
+    
     def process_incoming_block(self, block: Dict, from_peer: Optional[str] = None) -> Dict:
         """
         Process an incoming block from P2P network.
@@ -362,6 +432,39 @@ class BlockchainDaemon:
                 print(f"❌ Cleanup loop error: {e}")
                 time.sleep(60)
     
+    def get_task_status(self, task_id: str) -> Dict:
+        """Check status of an async task
+        
+        Returns: {'status': 'running'|'completed'|'failed'|'not_found', 'result': any, 'error': str}
+        """
+        if task_id not in self._async_tasks:
+            return {'status': 'not_found', 'result': None, 'error': 'Task not found'}
+        
+        future = self._async_tasks[task_id]
+        
+        if future.running():
+            return {'status': 'running', 'result': None, 'error': None}
+        elif future.done():
+            try:
+                result = future.result(timeout=0)
+                return {'status': 'completed', 'result': result, 'error': None}
+            except Exception as e:
+                return {'status': 'failed', 'result': None, 'error': str(e)}
+        else:
+            return {'status': 'pending', 'result': None, 'error': None}
+    
+    def get_active_tasks(self) -> List[str]:
+        """Get list of active task IDs"""
+        return [task_id for task_id, future in self._async_tasks.items() if future.running()]
+    
+    def cleanup_completed_tasks(self):
+        """Remove completed tasks from tracking"""
+        completed = [task_id for task_id, future in self._async_tasks.items() if future.done()]
+        for task_id in completed:
+            del self._async_tasks[task_id]
+        if completed:
+            print(f"🧹 Cleaned up {len(completed)} completed tasks")
+    
     def get_stats(self) -> Dict:
         """Get daemon statistics"""
         uptime = time.time() - self.stats['start_time']

lunalib/core/mempool.py

@@ -211,6 +211,7 @@ class MempoolManager:
             to_norm = self._normalize_address(tx.get('to') or tx.get('receiver'))
             if target_norm and (from_norm == target_norm or to_norm == target_norm):
                 transactions.append(tx)
+        print(f"[MEMPOOL] get_pending_transactions for {address}: {len(transactions)} txs returned")
         return transactions
 
     def get_pending_transactions_for_addresses(self, addresses: List[str], fetch_remote: bool = True) -> Dict[str, List[Dict]]: