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

lunalib/core/blockchain.py

@@ -405,10 +405,12 @@ class BlockchainManager:
         }
 
     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 VERSION"""
         transactions = []
         address_lower = address.lower()
         
+        print(f"🔍 Scanning block #{block.get('index')} for address: {address}")
+        
         # Check block reward (miner rewards)
         miner = block.get('miner', '').lower()
         if miner == address_lower:
@@ -416,36 +418,221 @@ class BlockchainManager:
                 'type': 'reward',
                 'from': 'network',
                 'to': address,
-                'amount': block.get('reward', 0),
+                '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")}'
+                '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 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()
+        # 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):
+            print(f"\n  TX #{tx_index}:")
+            
+            # Convert all values to strings for easier matching
+            tx_str = str(tx).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}")
+                
+                # Use the helper method to extract information
+                enhanced_tx = self._handle_regular_transfers(tx, address_lower)
+                
+                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')}")
+                    
+                    transactions.append(enhanced_tx)
+                    continue  # Skip other parsing methods
             
-            # 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'
-                transactions.append(enhanced_tx)
+            # 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()
+                amount = float(tx.get('amount', 0))
+                fee = float(tx.get('fee', 0))
                 
-            # 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")
+                # 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
                     
-        return transactions
+                    # 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', '')
+                amount = float(tx.get('amount', 0))
+                fee = float(tx.get('fee', 0))
+                
+                # Try to find address fields
+                address_fields = ['from_address', 'from', 'sender', 'to_address', 'to', 'receiver', 'owner']
+                
+                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)}")
+        
+        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

lunalib/core/wallet.py

@@ -277,7 +277,7 @@ class LunaWallet:
     def get_transaction_history(self) -> dict:
         """Get complete transaction history (both pending and confirmed)"""
         try:
-            from lunalib.blockchain import BlockchainManager
+            from lunalib.core.blockchain import BlockchainManager
             from lunalib.core.mempool import MempoolManager
             
             blockchain = BlockchainManager()

lunalib/gtx/genesis.py

@@ -90,7 +90,7 @@ class GTXGenesis:
                 if signature == expected_signature:
                     signature_valid = True
                     verification_method = "metadata_hash_signature"
-                    print(f"✅ Verified: hash(public_key + metadata_hash)")
+                    print(f"Verified: hash(public_key + metadata_hash)")
             
             # METHOD 3: Check DigitalBill calculated hash
             elif signature_valid is None:
@@ -122,23 +122,23 @@ class GTXGenesis:
                     if signature == calculated_hash:
                         signature_valid = True
                         verification_method = "digital_bill_calculate_hash"
-                        print(f"✅ Verified: DigitalBill.calculate_hash()")
+                        print(f"Verified: DigitalBill.calculate_hash()")
                         print(f"   Calculated hash: {calculated_hash}")
                     
                     # Approach 2: Use the verify() method (checks all signature types)
                     elif digital_bill.verify():
                         signature_valid = True
                         verification_method = "digital_bill_verify_method"
-                        print(f"✅ Verified: DigitalBill.verify()")
+                        print(f"Verified: DigitalBill.verify()")
                     
                     # Approach 3: Check if signature matches metadata_hash generation
                     elif signature == digital_bill._generate_metadata_hash():
                         signature_valid = True
                         verification_method = "digital_bill_metadata_hash"
-                        print(f"✅ Verified: matches generated metadata_hash")
+                        print(f"Verified: matches generated metadata_hash")
                     
                     else:
-                        print(f"❌ DigitalBill verification failed:")
+                        print(f"DigitalBill verification failed:")
                         print(f"   Calculated hash: {calculated_hash}")
                         print(f"   Signature: {signature}")
                         print(f"   Metadata hash: {metadata_hash}")
@@ -173,19 +173,19 @@ class GTXGenesis:
                 if signature == bill_json_hash:
                     signature_valid = True
                     verification_method = "bill_json_hash"
-                    print(f"✅ Verified: hash(bill_data_json)")
+                    print(f"Verified: hash(bill_data_json)")
             
             # Final fallback: accept any non-empty signature temporarily
             if signature_valid is None and signature and len(signature) > 10:
                 signature_valid = True
                 verification_method = "fallback_accept"
-                print(f"⚠️  Using fallback acceptance for signature")
+                print(f"Using fallback acceptance for signature")
             
             # If all methods failed
             if signature_valid is None:
                 signature_valid = False
                 verification_method = "all_failed"
-                print(f"❌ All verification methods failed")
+                print(f"All verification methods failed")
             
             # Return result in same format as endpoint
             if signature_valid:

lunalib/luna_lib.py

@@ -8,6 +8,7 @@ from mining.miner import GenesisMiner
 from gtx.genesis import GTXGenesis
 from transactions.transactions import TransactionManager
 from core.blockchain import BlockchainManager
+from core.mempool import MempoolManager
 
 
 class LunaLib:
@@ -19,6 +20,7 @@ class LunaLib:
     GTX = GTXGenesis
     Transaction = TransactionManager
     Blockchain = BlockchainManager
+    Mempool = MempoolManager
     
     @staticmethod
     def get_version():
@@ -33,7 +35,8 @@ class LunaLib:
             'Miner': 'GenesisMiner - Mining operations', 
             'GTX': 'GTXGenesis - GTX token operations',
             'Transaction': 'TransactionManager - Transaction handling',
-            'Blockchain': 'BlockchainManager - Blockchain operations with endpoint support'
+            'Blockchain': 'BlockchainManager - Blockchain operations with endpoint support',
+            'Mempool': 'MempoolManager - Memory Pool management and endpoint'
         }
 
 
@@ -50,6 +53,10 @@ def create_blockchain_manager(endpoint_url="https://bank.linglin.art"):
     """Create a blockchain manager with optional endpoint URL"""
     return BlockchainManager(endpoint_url)
 
+def create_mempool_manager(endpoint_url="https://bank.linglin.art"):
+    """Create a blockchain manager with optional endpoint URL"""
+    return MempoolManager(network_endpoints=[endpoint_url])
+
 def get_transaction_manager():
     """Get transaction manager instance"""
     return TransactionManager()
@@ -63,9 +70,11 @@ __all__ = [
     'GTXGenesis', 
     'TransactionManager',
     'BlockchainManager',
+    'MempoolManager',
     'create_wallet',
     'create_miner',
     'create_blockchain_manager',
+    'create_mempool_manager',
     'get_transaction_manager'
 ]
 
@@ -74,4 +83,5 @@ LunaWallet = LunaWallet
 GenesisMiner = GenesisMiner
 GTXGenesis = GTXGenesis
 TransactionManager = TransactionManager
-BlockchainManager = BlockchainManager
+BlockchainManager = BlockchainManager
+MempoolManager = MempoolManager