lunalib 1.1.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

lunalib/core/blockchain.py

@@ -1,6 +1,6 @@
 # blockchain.py - Updated version
 
-from lunalib.storage.cache import BlockchainCache
+from ..storage.cache import BlockchainCache
 import requests
 import time
 import json
@@ -14,6 +14,17 @@ class BlockchainManager:
         self.endpoint_url = endpoint_url.rstrip('/')
         self.cache = BlockchainCache()
         self.network_connected = False
+        self._stop_events = []  # Track background monitors so they can be stopped
+
+    # ------------------------------------------------------------------
+    # Address helpers
+    # ------------------------------------------------------------------
+    def _normalize_address(self, addr: str) -> str:
+        """Normalize LUN addresses for comparison (lowercase, strip, drop prefix)."""
+        if not addr:
+            return ''
+        addr_str = str(addr).strip("'\" ").lower()
+        return addr_str[4:] if addr_str.startswith('lun_') else addr_str
         
     def broadcast_transaction(self, transaction: Dict) -> Tuple[bool, str]:
         """Broadcast transaction to mempool with enhanced error handling"""
@@ -257,6 +268,8 @@ class BlockchainManager:
         """Scan blockchain for transactions involving an address"""
         if end_height is None:
             end_height = self.get_blockchain_height()
+        
+        print(f"[SCAN] Scanning transactions for {address} from block {start_height} to {end_height}")
             
         transactions = []
         
@@ -264,14 +277,108 @@ class BlockchainManager:
         batch_size = 100
         for batch_start in range(start_height, end_height + 1, batch_size):
             batch_end = min(batch_start + batch_size - 1, end_height)
+            print(f"[SCAN] Processing batch {batch_start}-{batch_end}...")
             blocks = self.get_blocks_range(batch_start, batch_end)
             
             for block in blocks:
                 block_transactions = self._find_address_transactions(block, address)
                 transactions.extend(block_transactions)
-                
+        
+        print(f"[SCAN] Found {len(transactions)} total transactions for {address}")
         return transactions
 
+    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)."""
+        if not addresses:
+            return {}
+
+        if end_height is None:
+            end_height = self.get_blockchain_height()
+
+        if end_height < start_height:
+            return {addr: [] for addr in addresses}
+
+        print(f"[MULTI-SCAN] Scanning {len(addresses)} addresses from block {start_height} to {end_height}")
+
+        # Map normalized address -> original address for quick lookup
+        normalized_map = {}
+        for addr in addresses:
+            norm = self._normalize_address(addr)
+            if norm:
+                normalized_map[norm] = addr
+
+        results: Dict[str, List[Dict]] = {addr: [] for addr in addresses}
+
+        batch_size = 100
+        for batch_start in range(start_height, end_height + 1, batch_size):
+            batch_end = min(batch_start + batch_size - 1, end_height)
+            print(f"[MULTI-SCAN] Processing batch {batch_start}-{batch_end}...")
+            blocks = self.get_blocks_range(batch_start, batch_end)
+
+            for block in blocks:
+                collected = self._collect_transactions_for_addresses(block, normalized_map)
+                for original_addr, txs in collected.items():
+                    if txs:
+                        results[original_addr].extend(txs)
+
+        # Summary
+        total_txs = sum(len(txs) for txs in results.values())
+        print(f"[MULTI-SCAN] Found {total_txs} total transactions")
+        for addr in addresses:
+            print(f"  - {addr}: {len(results[addr])} transactions")
+
+        return results
+
+    def monitor_addresses(self, addresses: List[str], on_update, poll_interval: int = 15):
+        """Start background monitor for addresses; returns a stop event."""
+        import threading
+        from lunalib.core.mempool import MempoolManager
+
+        stop_event = threading.Event()
+        self._stop_events.append(stop_event)
+
+        mempool = MempoolManager()
+        last_height = self.get_blockchain_height()
+
+        def _emit_update(confirmed_map: Dict[str, List[Dict]], pending_map: Dict[str, List[Dict]], source: str):
+            try:
+                if on_update:
+                    on_update({
+                        'confirmed': confirmed_map or {},
+                        'pending': pending_map or {},
+                        'source': source
+                    })
+            except Exception as e:
+                print(f"Monitor callback error: {e}")
+
+        def _monitor_loop():
+            nonlocal last_height
+
+            # Initial emission: existing chain + current mempool
+            initial_confirmed = self.scan_transactions_for_addresses(addresses, 0, last_height)
+            initial_pending = mempool.get_pending_transactions_for_addresses(addresses)
+            _emit_update(initial_confirmed, initial_pending, source="initial")
+
+            while not stop_event.wait(poll_interval):
+                try:
+                    current_height = self.get_blockchain_height()
+                    if current_height > last_height:
+                        new_confirmed = self.scan_transactions_for_addresses(addresses, last_height + 1, current_height)
+                        if any(new_confirmed.values()):
+                            _emit_update(new_confirmed, {}, source="blockchain")
+                        last_height = current_height
+
+                    pending_now = mempool.get_pending_transactions_for_addresses(addresses)
+                    if any(pending_now.values()):
+                        _emit_update({}, pending_now, source="mempool")
+
+                except Exception as e:
+                    print(f"Monitor loop error: {e}")
+
+        thread = threading.Thread(target=_monitor_loop, daemon=True)
+        thread.start()
+        return stop_event
+
     def submit_mined_block(self, block_data: Dict) -> bool:
         """Submit a mined block to the network with built-in validation"""
         try:
@@ -404,48 +511,293 @@ class BlockchainManager:
             }
         }
 
+    def _collect_transactions_for_addresses(self, block: Dict, normalized_map: Dict[str, str]) -> Dict[str, List[Dict]]:
+        """Collect transactions in a block for multiple addresses in one pass."""
+        results: Dict[str, List[Dict]] = {original: [] for original in normalized_map.values()}
+
+        # Mining reward via block metadata
+        miner_norm = self._normalize_address(block.get('miner', ''))
+        if miner_norm in normalized_map:
+            reward_amount = float(block.get('reward', 0) or 0)
+            if reward_amount > 0:
+                target_addr = normalized_map[miner_norm]
+                reward_tx = {
+                    'type': 'reward',
+                    'from': 'network',
+                    'to': target_addr,
+                    'amount': reward_amount,
+                    'block_height': block.get('index'),
+                    'timestamp': block.get('timestamp'),
+                    'hash': f"reward_{block.get('index')}_{block.get('hash', '')[:8]}",
+                    'status': 'confirmed',
+                    'description': f"Mining reward for block #{block.get('index')}",
+                    'direction': 'incoming',
+                    'effective_amount': reward_amount,
+                    'fee': 0
+                }
+                results[target_addr].append(reward_tx)
+
+        # Regular transactions
+        for tx_index, tx in enumerate(block.get('transactions', [])):
+            tx_type = (tx.get('type') or 'transfer').lower()
+            from_norm = self._normalize_address(tx.get('from') or tx.get('sender') or '')
+            to_norm = self._normalize_address(tx.get('to') or tx.get('receiver') or '')
+
+            # Explicit reward transaction
+            if tx_type == 'reward' and to_norm in normalized_map:
+                target_addr = normalized_map[to_norm]
+                amount = float(tx.get('amount', 0) or 0)
+                enhanced = tx.copy()
+                enhanced.update({
+                    'block_height': block.get('index'),
+                    'status': 'confirmed',
+                    'tx_index': tx_index,
+                    'direction': 'incoming',
+                    'effective_amount': amount,
+                    'fee': 0,
+                })
+                enhanced.setdefault('from', 'network')
+                results[target_addr].append(enhanced)
+                continue
+
+            # Incoming transfer
+            if to_norm in normalized_map:
+                target_addr = normalized_map[to_norm]
+                amount = float(tx.get('amount', 0) or 0)
+                fee = float(tx.get('fee', 0) or tx.get('gas', 0) or 0)
+                enhanced = tx.copy()
+                enhanced.update({
+                    'block_height': block.get('index'),
+                    'status': 'confirmed',
+                    'tx_index': tx_index,
+                    'direction': 'incoming',
+                    'effective_amount': amount,
+                    'amount': amount,
+                    'fee': fee
+                })
+                results[target_addr].append(enhanced)
+
+            # Outgoing transfer
+            if from_norm in normalized_map:
+                target_addr = normalized_map[from_norm]
+                amount = float(tx.get('amount', 0) or 0)
+                fee = float(tx.get('fee', 0) or tx.get('gas', 0) or 0)
+                enhanced = tx.copy()
+                enhanced.update({
+                    'block_height': block.get('index'),
+                    'status': 'confirmed',
+                    'tx_index': tx_index,
+                    'direction': 'outgoing',
+                    'effective_amount': -(amount + fee),
+                    'amount': amount,
+                    'fee': fee
+                })
+                results[target_addr].append(enhanced)
+
+        # Trim empty entries
+        return {addr: txs for addr, txs in results.items() if txs}
+
     def _find_address_transactions(self, block: Dict, address: str) -> List[Dict]:
-        """Find transactions in block that involve the address - ENHANCED FOR REWARDS"""
+        """Find transactions in block that involve the address - FIXED REWARD DETECTION"""
         transactions = []
-        address_lower = address.lower()
-        
-        # Check block reward (miner rewards)
-        miner = block.get('miner', '').lower()
-        if miner == address_lower:
-            reward_tx = {
-                'type': 'reward',
-                'from': 'network',
-                'to': address,
-                'amount': block.get('reward', 0),
-                'block_height': block.get('index'),
-                'timestamp': block.get('timestamp'),
-                'hash': f"reward_{block.get('index')}_{address}",
-                'status': 'confirmed',
-                'description': f'Mining reward for block #{block.get("index")}'
-            }
-            transactions.append(reward_tx)
-            print(f"🎁 Found mining reward: {block.get('reward', 0)} LUN for block #{block.get('index')}")
-        
-        # Check regular transactions in the block
-        for tx in block.get('transactions', []):
-            tx_type = tx.get('type', '').lower()
-            from_addr = (tx.get('from') or '').lower()
-            to_addr = (tx.get('to') or '').lower()
+        address_lower = address.lower().strip('"\'')  # Remove quotes if present
+        
+        print(f"🔍 Scanning block #{block.get('index')} for address: {address}")
+        print(f"   Block data: {block}")
+        
+        # ==================================================================
+        # 1. CHECK BLOCK MINING REWARD (from block metadata)
+        # ==================================================================
+        miner = block.get('miner', '')
+        # Clean the miner address (remove quotes, trim)
+        miner_clean = str(miner).strip('"\' ')
+        
+        print(f"   Miner in block: '{miner_clean}'")
+        print(f"   Our address: '{address_lower}'")
+        print(f"   Block reward: {block.get('reward', 0)}")
+        
+        # Function to normalize addresses for comparison
+        def normalize_address(addr):
+            if not addr:
+                return ''
+            # Remove LUN_ prefix and quotes, convert to lowercase
+            addr_str = str(addr).strip('"\' ').lower()
+            # Remove 'lun_' prefix if present
+            if addr_str.startswith('lun_'):
+                addr_str = addr_str[4:]
+            return addr_str
+        
+        # Normalize both addresses
+        miner_normalized = normalize_address(miner_clean)
+        address_normalized = normalize_address(address_lower)
+        
+        print(f"   Miner normalized: '{miner_normalized}'")
+        print(f"   Address normalized: '{address_normalized}'")
+        
+        # Check if this block was mined by our address
+        if miner_normalized == address_normalized and miner_normalized:
+            reward_amount = float(block.get('reward', 0))
+            if reward_amount > 0:
+                reward_tx = {
+                    'type': 'reward',
+                    'from': 'network',
+                    'to': address,
+                    'amount': reward_amount,
+                    'block_height': block.get('index'),
+                    'timestamp': block.get('timestamp'),
+                    'hash': f"reward_{block.get('index')}_{block.get('hash', '')[:8]}",
+                    'status': 'confirmed',
+                    'description': f'Mining reward for block #{block.get("index")}',
+                    'direction': 'incoming',
+                    'effective_amount': reward_amount,
+                    'fee': 0
+                }
+                transactions.append(reward_tx)
+                print(f"🎁 FOUND MINING REWARD: {reward_amount} LUN for block #{block.get('index')}")
+                print(f"   Miner match: '{miner_clean}' == '{address}'")
+        else:
+            print(f"   Not our block - Miner: '{miner_clean}', Our address: '{address}'")
+        
+        # ==================================================================
+        # 2. CHECK ALL TRANSACTIONS IN THE BLOCK
+        # ==================================================================
+        block_transactions = block.get('transactions', [])
+        print(f"   Block has {len(block_transactions)} transactions")
+        
+        for tx_index, tx in enumerate(block_transactions):
+            enhanced_tx = tx.copy()
+            enhanced_tx['block_height'] = block.get('index')
+            enhanced_tx['status'] = 'confirmed'
+            enhanced_tx['tx_index'] = tx_index
+            
+            # Get transaction type
+            tx_type = tx.get('type', 'transfer').lower()
+            
+            # Helper function for address matching with normalization
+            def addresses_match(addr1, addr2):
+                if not addr1 or not addr2:
+                    return False
+                
+                # Normalize both addresses
+                addr1_norm = normalize_address(addr1)
+                addr2_norm = normalize_address(addr2)
+                
+                # Check if they match
+                return addr1_norm == addr2_norm
             
-            # Check if this transaction involves our address
-            if from_addr == address_lower or to_addr == address_lower:
-                enhanced_tx = tx.copy()
-                enhanced_tx['block_height'] = block.get('index')
-                enhanced_tx['status'] = 'confirmed'
+            # ==================================================================
+            # A) REWARD TRANSACTIONS (explicit reward transactions)
+            # ==================================================================
+            tx_type = tx.get('type', 'transfer').lower()
+            if tx_type == 'reward':
+                reward_to_address = tx.get('to', '')
+                # Compare the reward's destination with our wallet address
+                if addresses_match(reward_to_address, address):
+                    amount = float(tx.get('amount', 0))
+                    enhanced_tx['direction'] = 'incoming'
+                    enhanced_tx['effective_amount'] = amount
+                    enhanced_tx['fee'] = 0
+                    enhanced_tx.setdefault('from', 'network') # Ensure sender is set
+                    transactions.append(enhanced_tx)
+                    print(f"✅ Found mining reward: {amount} LUN (to: {reward_to_address})")
+                    continue  # Move to next transaction
+            
+            # ==================================================================
+            # B) REGULAR TRANSFERS
+            # ==================================================================
+            from_addr = tx.get('from') or tx.get('sender') or ''
+            to_addr = tx.get('to') or tx.get('receiver') or ''
+            
+            # Check if transaction involves our address
+            is_incoming = addresses_match(to_addr, address)
+            is_outgoing = addresses_match(from_addr, address)
+            
+            if is_incoming:
+                amount = float(tx.get('amount', 0))
+                fee = float(tx.get('fee', 0) or tx.get('gas', 0) or 0)
+                
+                enhanced_tx['direction'] = 'incoming'
+                enhanced_tx['effective_amount'] = amount
+                enhanced_tx['amount'] = amount
+                enhanced_tx['fee'] = fee
+                
                 transactions.append(enhanced_tx)
+                print(f"⬆️ Found incoming transaction: {amount} LUN")
+                
+            elif is_outgoing:
+                amount = float(tx.get('amount', 0))
+                fee = float(tx.get('fee', 0) or tx.get('gas', 0) or 0)
+                
+                enhanced_tx['direction'] = 'outgoing'
+                enhanced_tx['effective_amount'] = -(amount + fee)
+                enhanced_tx['amount'] = amount
+                enhanced_tx['fee'] = fee
                 
-            # SPECIFICALLY look for reward transactions sent to our address
-            elif tx_type == 'reward' and to_addr == address_lower:
-                enhanced_tx = tx.copy()
-                enhanced_tx['block_height'] = block.get('index')
-                enhanced_tx['status'] = 'confirmed'
-                enhanced_tx['type'] = 'reward'  # Ensure type is set
                 transactions.append(enhanced_tx)
-                print(f"💰 Found reward transaction: {tx.get('amount', 0)} LUN")
-                    
-        return transactions
+                print(f"⬇️ Found outgoing transaction: {amount} LUN + {fee} fee")
+        
+        print(f"📊 Scan complete for block #{block.get('index')}: {len(transactions)} transactions found")
+        return transactions
+    def _handle_regular_transfers(self, tx: Dict, address_lower: str) -> Dict:
+        """Handle regular transfer transactions that might be in different formats"""
+        enhanced_tx = tx.copy()
+        
+        # Try to extract addresses from various possible field names
+        possible_from_fields = ['from', 'sender', 'from_address', 'source', 'payer']
+        possible_to_fields = ['to', 'receiver', 'to_address', 'destination', 'payee']
+        possible_amount_fields = ['amount', 'value', 'quantity', 'transfer_amount']
+        possible_fee_fields = ['fee', 'gas', 'transaction_fee', 'gas_fee']
+        
+        # Find from address
+        from_addr = ''
+        for field in possible_from_fields:
+            if field in tx:
+                from_addr = (tx.get(field) or '').lower()
+                break
+        
+        # Find to address
+        to_addr = ''
+        for field in possible_to_fields:
+            if field in tx:
+                to_addr = (tx.get(field) or '').lower()
+                break
+        
+        # Find amount
+        amount = 0
+        for field in possible_amount_fields:
+            if field in tx:
+                amount = float(tx.get(field, 0))
+                break
+        
+        # Find fee
+        fee = 0
+        for field in possible_fee_fields:
+            if field in tx:
+                fee = float(tx.get(field, 0))
+                break
+        
+        # Set direction
+        if from_addr == address_lower:
+            enhanced_tx['direction'] = 'outgoing'
+            enhanced_tx['effective_amount'] = -(amount + fee)
+            enhanced_tx['from'] = from_addr
+            enhanced_tx['to'] = to_addr
+            enhanced_tx['amount'] = amount
+            enhanced_tx['fee'] = fee
+        elif to_addr == address_lower:
+            enhanced_tx['direction'] = 'incoming'
+            enhanced_tx['effective_amount'] = amount
+            enhanced_tx['from'] = from_addr
+            enhanced_tx['to'] = to_addr
+            enhanced_tx['amount'] = amount
+            enhanced_tx['fee'] = fee
+        else:
+            # If we can't determine direction from addresses, check other fields
+            enhanced_tx['direction'] = 'unknown'
+            enhanced_tx['effective_amount'] = amount
+        
+        # Set type if not present
+        if not enhanced_tx.get('type'):
+            enhanced_tx['type'] = 'transfer'
+        
+        return enhanced_tx