lunalib 1.2.3__py3-none-any.whl → 1.5.2__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,174 +511,232 @@ 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 - FIXED VERSION"""
+        """Find transactions in block that involve the address - FIXED REWARD DETECTION"""
         transactions = []
-        address_lower = address.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}'")
         
-        # Check block reward (miner rewards)
-        miner = block.get('miner', '').lower()
-        if miner == address_lower:
-            reward_tx = {
-                'type': 'reward',
-                'from': 'network',
-                'to': address,
-                'amount': float(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")}',
-                'direction': 'incoming',
-                'effective_amount': float(block.get('reward', 0))
-            }
-            transactions.append(reward_tx)
-            print(f"🎁 Found mining reward: {block.get('reward', 0)} LUN for block #{block.get('index')}")
-        
-        # Check all transactions in the block
+        # ==================================================================
+        # 2. CHECK ALL TRANSACTIONS IN THE BLOCK
+        # ==================================================================
         block_transactions = block.get('transactions', [])
-        print(f"  Block has {len(block_transactions)} transactions")
+        print(f"   Block has {len(block_transactions)} transactions")
         
         for tx_index, tx in enumerate(block_transactions):
-            print(f"\n  TX #{tx_index}:")
+            enhanced_tx = tx.copy()
+            enhanced_tx['block_height'] = block.get('index')
+            enhanced_tx['status'] = 'confirmed'
+            enhanced_tx['tx_index'] = tx_index
             
-            # Convert all values to strings for easier matching
-            tx_str = str(tx).lower()
+            # Get transaction type
+            tx_type = tx.get('type', 'transfer').lower()
             
-            # Method 0: Check if address appears in transaction
-            if address_lower in tx_str:
-                print(f"    🔄 Address found in transaction #{tx_index}")
-                print(f"    TX data: {tx}")
+            # Helper function for address matching with normalization
+            def addresses_match(addr1, addr2):
+                if not addr1 or not addr2:
+                    return False
                 
-                # Use the helper method to extract information
-                enhanced_tx = self._handle_regular_transfers(tx, address_lower)
+                # Normalize both addresses
+                addr1_norm = normalize_address(addr1)
+                addr2_norm = normalize_address(addr2)
                 
-                if enhanced_tx.get('direction') in ['incoming', 'outgoing']:
-                    enhanced_tx['block_height'] = block.get('index')
-                    enhanced_tx['status'] = 'confirmed'
-                    enhanced_tx['tx_index'] = tx_index
-                    enhanced_tx['hash'] = tx.get('hash') or f"tx_{block.get('index')}_{tx_index}"
-                    
-                    # Ensure amount and fee are floats
-                    enhanced_tx['amount'] = float(enhanced_tx.get('amount', 0))
-                    enhanced_tx['fee'] = float(enhanced_tx.get('fee', 0))
-                    
-                    # Calculate effective amount based on direction
-                    if enhanced_tx['direction'] == 'outgoing':
-                        # For outgoing: negative (amount + fee)
-                        enhanced_tx['effective_amount'] = -(enhanced_tx['amount'] + enhanced_tx['fee'])
-                        print(f"    ⬇️ OUTGOING: {enhanced_tx['amount']} + {enhanced_tx['fee']} fee = {enhanced_tx['effective_amount']}")
-                        print(f"      From: {enhanced_tx.get('from', 'unknown')}")
-                        print(f"      To: {enhanced_tx.get('to', 'unknown')}")
-                    else:
-                        # For incoming: positive amount only
-                        enhanced_tx['effective_amount'] = enhanced_tx['amount']
-                        print(f"    ⬆️ INCOMING: +{enhanced_tx['amount']}")
-                        print(f"      From: {enhanced_tx.get('from', 'unknown')}")
-                        print(f"      To: {enhanced_tx.get('to', 'unknown')}")
-                    
+                # Check if they match
+                return addr1_norm == addr2_norm
+            
+            # ==================================================================
+            # 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)
-                    continue  # Skip other parsing methods
+                    print(f"✅ Found mining reward: {amount} LUN (to: {reward_to_address})")
+                    continue  # Move to next transaction
             
-            # Method 1: Check for standard transfer format
-            if 'type' in tx or 'from' in tx or 'to' in tx:
-                from_addr = (tx.get('from') or '').lower()
-                to_addr = (tx.get('to') or '').lower()
+            # ==================================================================
+            # 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))
+                fee = float(tx.get('fee', 0) or tx.get('gas', 0) or 0)
                 
-                # 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'
-                    enhanced_tx['tx_index'] = tx_index
-                    
-                    # Ensure type is set
-                    if not enhanced_tx.get('type'):
-                        enhanced_tx['type'] = tx.get('bill_type', 'transfer')
-                    
-                    # Ensure amounts are floats
-                    enhanced_tx['amount'] = amount
-                    enhanced_tx['fee'] = fee
-                    
-                    # Add direction information
-                    if from_addr == address_lower:
-                        enhanced_tx['direction'] = 'outgoing'
-                        # For outgoing: negative (amount + fee)
-                        enhanced_tx['effective_amount'] = -(amount + fee)
-                        print(f"    ⬇️ STANDARD OUTGOING from our address")
-                        print(f"      From: {from_addr} (OURS)")
-                        print(f"      To: {to_addr}")
-                        print(f"      Amount: {amount}, Fee: {fee}, Total: {enhanced_tx['effective_amount']}")
-                    else:
-                        enhanced_tx['direction'] = 'incoming'
-                        enhanced_tx['effective_amount'] = amount
-                        print(f"    ⬆️ STANDARD INCOMING to our address")
-                        print(f"      From: {from_addr}")
-                        print(f"      To: {to_addr} (OURS)")
-                        print(f"      Amount: {amount}")
-                    
-                    transactions.append(enhanced_tx)
-                    continue
-            
-            # Method 2: Check for GTX/bill_type format
-            if 'bill_type' in tx:
-                bill_type = tx.get('bill_type', '')
+                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))
+                fee = float(tx.get('fee', 0) or tx.get('gas', 0) or 0)
                 
-                # Try to find address fields
-                address_fields = ['from_address', 'from', 'sender', 'to_address', 'to', 'receiver', 'owner']
+                enhanced_tx['direction'] = 'outgoing'
+                enhanced_tx['effective_amount'] = -(amount + fee)
+                enhanced_tx['amount'] = amount
+                enhanced_tx['fee'] = fee
                 
-                for field in address_fields:
-                    if field in tx:
-                        tx_addr = (tx.get(field) or '').lower()
-                        if tx_addr == address_lower:
-                            enhanced_tx = tx.copy()
-                            enhanced_tx['block_height'] = block.get('index')
-                            enhanced_tx['status'] = 'confirmed'
-                            enhanced_tx['tx_index'] = tx_index
-                            enhanced_tx['type'] = bill_type.lower()
-                            
-                            # Map bill_type to standard type
-                            if 'gtx_genesis' in bill_type.lower():
-                                enhanced_tx['type'] = 'gtx_genesis'
-                                enhanced_tx['description'] = 'GTX Genesis Transaction'
-                            
-                            enhanced_tx['amount'] = amount
-                            enhanced_tx['fee'] = fee
-                            
-                            # Determine direction
-                            if field in ['from_address', 'from', 'sender']:
-                                enhanced_tx['direction'] = 'outgoing'
-                                enhanced_tx['effective_amount'] = -(amount + fee)
-                                enhanced_tx['from'] = tx_addr
-                                enhanced_tx['to'] = tx.get('to_address') or tx.get('receiver') or tx.get('to') or 'unknown'
-                                print(f"    ⬇️ GTX OUTGOING ({bill_type})")
-                                print(f"      From: {tx_addr} (OURS)")
-                                print(f"      Amount: {amount}, Fee: {fee}, Total: {enhanced_tx['effective_amount']}")
-                            else:
-                                enhanced_tx['direction'] = 'incoming'
-                                enhanced_tx['effective_amount'] = amount
-                                enhanced_tx['from'] = tx.get('from_address') or tx.get('sender') or tx.get('from') or 'network'
-                                enhanced_tx['to'] = tx_addr
-                                print(f"    ⬆️ GTX INCOMING ({bill_type})")
-                                print(f"      To: {tx_addr} (OURS)")
-                                print(f"      Amount: {amount}")
-                            
-                            transactions.append(enhanced_tx)
-                            break
-        
-        print(f"\n  ✅ Total transactions found for address: {len(transactions)}")
-        
-        # Debug: Show transaction types found
-        incoming = [t for t in transactions if t.get('direction') == 'incoming']
-        outgoing = [t for t in transactions if t.get('direction') == 'outgoing']
-        print(f"     Incoming: {len(incoming)}, Outgoing: {len(outgoing)}")
+                transactions.append(enhanced_tx)
+                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"""