lunalib 1.5.1__py3-none-any.whl → 1.7.2__py3-none-any.whl

lunalib/storage/database.py

@@ -3,6 +3,15 @@ import sqlite3
 import json
 import time
 from typing import Dict, List, Optional, Any
+import sys
+
+# --- Unicode-safe print for Windows console ---
+def safe_print(*args, **kwargs):
+    try:
+        print(*args, **kwargs)
+    except UnicodeEncodeError:
+        encoding = getattr(sys.stdout, 'encoding', 'utf-8')
+        print(*(str(a).encode(encoding, errors='replace').decode(encoding) for a in args), **kwargs)
 
 class WalletDatabase:
     """Manages wallet data storage"""
@@ -96,7 +105,7 @@ class WalletDatabase:
             return True
             
         except Exception as e:
-            print(f"Save wallet error: {e}")
+            safe_print(f"Save wallet error: {e}")
             return False
     
     def load_wallet(self, address: str) -> Optional[Dict]:
@@ -122,7 +131,7 @@ class WalletDatabase:
                 }
                 
         except Exception as e:
-            print(f"Load wallet error: {e}")
+            safe_print(f"Load wallet error: {e}")
             
         return None
     
@@ -157,7 +166,7 @@ class WalletDatabase:
             return True
             
         except Exception as e:
-            print(f"Save transaction error: {e}")
+            safe_print(f"Save transaction error: {e}")
             return False
     
     def get_wallet_transactions(self, wallet_address: str, limit: int = 100) -> List[Dict]:
@@ -187,7 +196,7 @@ class WalletDatabase:
             return transactions
             
         except Exception as e:
-            print(f"Get transactions error: {e}")
+            safe_print(f"Get transactions error: {e}")
             return []
     
     def save_pending_transaction(self, transaction: Dict, wallet_address: str) -> bool:
@@ -218,5 +227,5 @@ class WalletDatabase:
             return True
             
         except Exception as e:
-            print(f"Save pending transaction error: {e}")
+            safe_print(f"Save pending transaction error: {e}")
             return False

lunalib/storage/encryption.py

@@ -1,5 +1,14 @@
 import os
 import json
+import sys
+
+# --- Unicode-safe print for Windows console ---
+def safe_print(*args, **kwargs):
+    try:
+        print(*args, **kwargs)
+    except UnicodeEncodeError:
+        encoding = getattr(sys.stdout, 'encoding', 'utf-8')
+        print(*(str(a).encode(encoding, errors='replace').decode(encoding) for a in args), **kwargs)
 import base64
 import hashlib
 from cryptography.fernet import Fernet
@@ -37,7 +46,7 @@ class EncryptionManager:
             }
             
         except Exception as e:
-            print(f"Encryption error: {e}")
+            safe_print(f"Encryption error: {e}")
             return {}
     
     def decrypt_wallet(self, encrypted_data: Dict, password: str) -> Optional[Dict]:
@@ -65,7 +74,7 @@ class EncryptionManager:
             return wallet_data
             
         except Exception as e:
-            print(f"Decryption error: {e}")
+            safe_print(f"Decryption error: {e}")
             return None
     
     def _derive_key(self, password: str) -> bytes:

lunalib/transactions/security.py

@@ -1,4 +1,13 @@
 import time
+import sys
+
+# --- Unicode-safe print for Windows console ---
+def safe_print(*args, **kwargs):
+    try:
+        print(*args, **kwargs)
+    except UnicodeEncodeError:
+        encoding = getattr(sys.stdout, 'encoding', 'utf-8')
+        print(*(str(a).encode(encoding, errors='replace').decode(encoding) for a in args), **kwargs)
 import hashlib
 from typing import Dict, Tuple
 
@@ -17,11 +26,11 @@ class TransactionSecurity:
             from ..core.crypto import KeyManager as SM2KeyManager
             self.key_manager = SM2KeyManager()
             self.sm2_available = True
-            print("[SECURITY] SM2 KeyManager loaded successfully")
+            safe_print("[SECURITY] SM2 KeyManager loaded successfully")
         except ImportError as e:
             self.key_manager = None
             self.sm2_available = False
-            print(f"[SECURITY] SM2 KeyManager not available: {e}")
+            safe_print(f"[SECURITY] SM2 KeyManager not available: {e}")
     
     def validate_transaction_security(self, transaction: Dict) -> Tuple[bool, str]:
         """Comprehensive transaction security validation with SM2"""
@@ -114,22 +123,22 @@ class TransactionSecurity:
             
             # For unsigned test transactions
             if signature in ["system", "unsigned", "test"]:
-                print(f"[SECURITY] Skipping signature check for system/unsigned transaction")
+                safe_print(f"[SECURITY] Skipping signature check for system/unsigned transaction")
                 return True
             
             # Check SM2 signature length (should be 128 hex chars = 64 bytes)
             if len(signature) != 128:
-                print(f"[SECURITY] Invalid SM2 signature length: {len(signature)} (expected 128)")
+                safe_print(f"[SECURITY] Invalid SM2 signature length: {len(signature)} (expected 128)")
                 return False
             
             # Check if all characters are valid hex
             if not all(c in "0123456789abcdefABCDEF" for c in signature):
-                print(f"[SECURITY] Signature contains non-hex characters")
+                safe_print(f"[SECURITY] Signature contains non-hex characters")
                 return False
             
             # Check public key format (should start with '04' for uncompressed)
             if not public_key.startswith('04'):
-                print(f"[SECURITY] Invalid public key format: {public_key[:20]}...")
+                safe_print(f"[SECURITY] Invalid public key format: {public_key[:20]}...")
                 return False
             
             # Use KeyManager for verification if available
@@ -139,15 +148,15 @@ class TransactionSecurity:
                 
                 # Verify signature
                 is_valid = self.key_manager.verify_signature(signing_data, signature, public_key)
-                print(f"[SECURITY] SM2 signature verification: {is_valid}")
+                safe_print(f"[SECURITY] SM2 signature verification: {is_valid}")
                 return is_valid
             
             # Fallback: Basic format check if SM2 not available
-            print(f"[SECURITY] SM2 not available, using basic signature validation")
+            safe_print(f"[SECURITY] SM2 not available, using basic signature validation")
             return len(signature) == 128 and signature.startswith(('04', '03', '02'))
             
         except Exception as e:
-            print(f"[SECURITY] Signature validation error: {e}")
+            safe_print(f"[SECURITY] Signature validation error: {e}")
             return False
     
     def _get_signing_data(self, transaction: Dict) -> str:
@@ -174,7 +183,7 @@ class TransactionSecurity:
     
     def _validate_signature(self, transaction: Dict) -> bool:
         """Legacy signature validation (for backward compatibility)"""
-        print(f"[SECURITY] Using legacy signature validation")
+        safe_print(f"[SECURITY] Using legacy signature validation")
         return self._validate_signature_sm2(transaction)
     
     def _check_rate_limit(self, address: str) -> bool:

lunalib/transactions/transactions.py

@@ -1,5 +1,14 @@
 # lunalib/transactions/transactions.py
 import time
+import sys
+
+# --- Unicode-safe print for Windows console ---
+def safe_print(*args, **kwargs):
+    try:
+        print(*args, **kwargs)
+    except UnicodeEncodeError:
+        encoding = getattr(sys.stdout, 'encoding', 'utf-8')
+        print(*(str(a).encode(encoding, errors='replace').decode(encoding) for a in args), **kwargs)
 import hashlib
 import json
 from typing import Dict, Optional, Tuple, List
@@ -9,10 +18,10 @@ from ..core.mempool import MempoolManager
 try:
     from ..core.crypto import KeyManager as SM2KeyManager
     SM2_AVAILABLE = True
-    print("DEBUG: Using SM2 KeyManager from crypto module")
+    safe_print("DEBUG: Using SM2 KeyManager from crypto module")
 except ImportError as e:
     SM2_AVAILABLE = False
-    print(f"WARNING: SM2 KeyManager not available: {e}")
+    safe_print(f"WARNING: SM2 KeyManager not available: {e}")
 
 class TransactionSecurity:
     """Transaction security validation and risk assessment"""
@@ -71,7 +80,7 @@ class TransactionManager:
         if SM2_AVAILABLE:
             self.key_manager = SM2KeyManager()
         else:
-            print("ERROR: SM2 KeyManager not available - cannot sign transactions")
+            safe_print("ERROR: SM2 KeyManager not available - cannot sign transactions")
             self.key_manager = None
     
     def create_transaction(self, from_address: str, to_address: str, amount: float, 
@@ -99,33 +108,33 @@ class TransactionManager:
                 # Sign the transaction data
                 tx_string = self._get_signing_data(transaction)
                 
-                print(f"[TRANSACTIONS CREATE DEBUG] Signing data: {tx_string}")
-                print(f"[TRANSACTIONS CREATE DEBUG] Private key available: {bool(private_key)}")
-                print(f"[TRANSACTIONS CREATE DEBUG] Private key length: {len(private_key)}")
+                safe_print(f"[TRANSACTIONS CREATE DEBUG] Signing data: {tx_string}")
+                safe_print(f"[TRANSACTIONS CREATE DEBUG] Private key available: {bool(private_key)}")
+                safe_print(f"[TRANSACTIONS CREATE DEBUG] Private key length: {len(private_key)}")
                 
                 signature = self.key_manager.sign_data(tx_string, private_key)
                 
                 # Get public key from private key
                 public_key = self.key_manager.derive_public_key(private_key)
                 
-                print(f"[TRANSACTIONS CREATE DEBUG] Generated signature: {signature}")
-                print(f"[TRANSACTIONS CREATE DEBUG] Generated public key: {public_key}")
-                print(f"[TRANSACTIONS CREATE DEBUG] Signature length: {len(signature)}")
-                print(f"[TRANSACTIONS CREATE DEBUG] Public key length: {len(public_key)}")
+                safe_print(f"[TRANSACTIONS CREATE DEBUG] Generated signature: {signature}")
+                safe_print(f"[TRANSACTIONS CREATE DEBUG] Generated public key: {public_key}")
+                safe_print(f"[TRANSACTIONS CREATE DEBUG] Signature length: {len(signature)}")
+                safe_print(f"[TRANSACTIONS CREATE DEBUG] Public key length: {len(public_key)}")
                 
                 transaction["signature"] = signature
                 transaction["public_key"] = public_key
                 
                 # Immediately test verification
                 test_verify = self.key_manager.verify_signature(tx_string, signature, public_key)
-                print(f"[TRANSACTIONS CREATE DEBUG] Immediate self-verification: {test_verify}")
+                safe_print(f"[TRANSACTIONS CREATE DEBUG] Immediate self-verification: {test_verify}")
                 
                 if not test_verify:
-                    print(f"[TRANSACTIONS CREATE ERROR] Signature doesn't verify immediately!")
-                    print(f"[TRANSACTIONS CREATE ERROR] This suggests an SM2 implementation issue")
+                    safe_print(f"[TRANSACTIONS CREATE ERROR] Signature doesn't verify immediately!")
+                    safe_print(f"[TRANSACTIONS CREATE ERROR] This suggests an SM2 implementation issue")
                     
             except Exception as e:
-                print(f"[TRANSACTIONS CREATE ERROR] Signing failed: {e}")
+                safe_print(f"[TRANSACTIONS CREATE ERROR] Signing failed: {e}")
                 import traceback
                 traceback.print_exc()
                 transaction["signature"] = "unsigned"
@@ -226,55 +235,55 @@ class TransactionManager:
             
             # System transactions are always valid
             if signature in ["system", "unsigned", "test"]:
-                print(f"[TRANSACTIONS] Skipping signature check for {signature} transaction")
+                safe_print(f"[TRANSACTIONS] Skipping signature check for {signature} transaction")
                 return True
             
             if not self.key_manager:
-                print("[TRANSACTIONS] No key manager available for verification")
+                safe_print("[TRANSACTIONS] No key manager available for verification")
                 return False
             
             # Check SM2 signature format
             if len(signature) != 128:
-                print(f"[TRANSACTIONS] Invalid SM2 signature length: {len(signature)} (expected 128)")
+                safe_print(f"[TRANSACTIONS] Invalid SM2 signature length: {len(signature)} (expected 128)")
                 return False
             
             # Get signing data (without public_key!)
             sign_data = self._get_signing_data(transaction)
             public_key = transaction.get("public_key", "")
             
-            print(f"[TRANSACTIONS VERIFY] Signing data length: {len(sign_data)}")
-            print(f"[TRANSACTIONS VERIFY] Signing data (first 100 chars): {sign_data[:100]}")
+            safe_print(f"[TRANSACTIONS VERIFY] Signing data length: {len(sign_data)}")
+            safe_print(f"[TRANSACTIONS VERIFY] Signing data (first 100 chars): {sign_data[:100]}")
             
             # Try to verify with KeyManager
-            print(f"[TRANSACTIONS] Attempting verification...")
+            safe_print(f"[TRANSACTIONS] Attempting verification...")
             is_valid = self.key_manager.verify_signature(sign_data, signature, public_key)
             
-            print(f"[TRANSACTIONS] SM2 signature verification result: {is_valid}")
+            safe_print(f"[TRANSACTIONS] SM2 signature verification result: {is_valid}")
             
             return is_valid
             
         except Exception as e:
-            print(f"[TRANSACTIONS] Verification error: {e}")
+            safe_print(f"[TRANSACTIONS] Verification error: {e}")
             import traceback
             traceback.print_exc()
             return False
     def _debug_signature_issue(self, transaction: Dict, sign_data: str, signature: str, public_key: str):
         """Debug why signature verification is failing"""
-        print("\n" + "="*60)
-        print("DEBUGGING SIGNATURE ISSUE")
-        print("="*60)
+        safe_print("\n" + "="*60)
+        safe_print("DEBUGGING SIGNATURE ISSUE")
+        safe_print("="*60)
         
         # 1. Check if we can sign and verify a simple test
-        print("\n1. Testing SM2 with simple message...")
+        safe_print("\n1. Testing SM2 with simple message...")
         test_message = "Simple test message"
         test_private = self.key_manager.generate_private_key()
         test_public = self.key_manager.derive_public_key(test_private)
         test_sig = self.key_manager.sign_data(test_message, test_private)
         test_valid = self.key_manager.verify_signature(test_message, test_sig, test_public)
-        print(f"   Simple test verification: {test_valid}")
+        safe_print(f"   Simple test verification: {test_valid}")
         
         # 2. Try to recreate what was signed during transaction creation
-        print("\n2. Reconstructing original transaction data...")
+        safe_print("\n2. Reconstructing original transaction data...")
         # Create the exact transaction data that should have been signed
         reconstructed = {
             "amount": float(transaction["amount"]),
@@ -289,23 +298,23 @@ class TransactionManager:
         
         import json
         reconstructed_json = json.dumps(reconstructed, sort_keys=True)
-        print(f"   Reconstructed JSON: {reconstructed_json}")
-        print(f"   Current signing data: {sign_data}")
-        print(f"   Are they equal? {reconstructed_json == sign_data}")
-        print(f"   Length difference: {len(reconstructed_json)} vs {len(sign_data)}")
+        safe_print(f"   Reconstructed JSON: {reconstructed_json}")
+        safe_print(f"   Current signing data: {sign_data}")
+        safe_print(f"   Are they equal? {reconstructed_json == sign_data}")
+        safe_print(f"   Length difference: {len(reconstructed_json)} vs {len(sign_data)}")
         
         # 3. Check for whitespace differences
-        print("\n3. Checking for whitespace differences...")
-        print(f"   Reconstructed has spaces: {' ' in reconstructed_json}")
-        print(f"   Sign data has spaces: {' ' in sign_data}")
+        safe_print("\n3. Checking for whitespace differences...")
+        safe_print(f"   Reconstructed has spaces: {' ' in reconstructed_json}")
+        safe_print(f"   Sign data has spaces: {' ' in sign_data}")
         
         # 4. Check float formatting
-        print("\n4. Checking float formatting...")
-        print(f"   Amount in tx: {transaction['amount']} (type: {type(transaction['amount'])})")
-        print(f"   Amount in reconstructed: {reconstructed['amount']} (type: {type(reconstructed['amount'])})")
+        safe_print("\n4. Checking float formatting...")
+        safe_print(f"   Amount in tx: {transaction['amount']} (type: {type(transaction['amount'])})")
+        safe_print(f"   Amount in reconstructed: {reconstructed['amount']} (type: {type(reconstructed['amount'])})")
         
         # 5. Try different JSON serialization options
-        print("\n5. Trying different JSON formats...")
+        safe_print("\n5. Trying different JSON formats...")
         formats = [
             ("Compact", lambda x: json.dumps(x, sort_keys=True, separators=(',', ':'))),
             ("Default", lambda x: json.dumps(x, sort_keys=True)),
@@ -315,9 +324,9 @@ class TransactionManager:
         for name, formatter in formats:
             formatted = formatter(reconstructed)
             is_valid_test = self.key_manager.verify_signature(formatted, signature, public_key)
-            print(f"   {name} format: {is_valid_test} (length: {len(formatted)})")
+            safe_print(f"   {name} format: {is_valid_test} (length: {len(formatted)})")
         
-        print("="*60 + "\n")
+        safe_print("="*60 + "\n")
     def assess_transaction_risk(self, transaction: Dict) -> Tuple[str, str]:
         """Assess transaction risk level"""
         return self.security.assess_risk(transaction)

lunalib-1.7.2.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: lunalib
+Version: 1.7.2
+Summary: Cryptocurrency Ecosystem library (LunaLib)
+Home-page: 
+Author: Ling Lin
+Author-email: 
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography
+Requires-Dist: requests
+Requires-Dist: numpy
+Requires-Dist: pytest
+Requires-Dist: pandas
+Requires-Dist: base58
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+A modular cryptocurrency ecosystem library including blockchain, wallet, mining, storage, and transaction management.

lunalib-1.7.2.dist-info/RECORD

@@ -0,0 +1,33 @@
+lunalib/__init__.py,sha256=fEvoHvfcC6ilDGQrhXaVmcdB4yDmuijxz6YZHkjbuBg,527
+lunalib/cli.py,sha256=SyuJIhvqld-XL9ks9XFOuyqVb44qyBUbahlqE_RDVkM,524
+lunalib/luna_lib.py,sha256=ue9Bs93xjpg7_GHSUJPKBhf8nF5YcbCIdoMIu-jDgG4,2748
+lunalib/core/__init__.py,sha256=V86B0jI8snFIg8yCyd_Qoi2Tl6elQn_1cT-oeR6Ig3s,361
+lunalib/core/blockchain.py,sha256=yhK_PcyYuH5rAAbRZar-8DbF2kMWde7Ku2TOa1FIbrE,44530
+lunalib/core/crypto.py,sha256=R_f2sj7ASNnMW8Dtf2LIWTw-vCUjXD33zJPqPcPQVB8,10684
+lunalib/core/daemon.py,sha256=VhEky7-h-mwCBVFJp7DtoMkpvmGbdcbuoG9qNkbEvbg,21048
+lunalib/core/mempool.py,sha256=itYFGQEuUde0Xh6WXcEz_n8hDsNhxkEAlRQ5g_Qiygg,14845
+lunalib/core/p2p.py,sha256=cj3dda05oL6W5oMsvJ_HT3U0qr1FL6DR-YI78k3InKg,13784
+lunalib/core/sm2.py,sha256=Eq8Er3XQW5rYJXwaPT5vw5NoVXbSWhyuvjoG1LMo-NQ,23454
+lunalib/core/wallet.py,sha256=RCLim7zvAU_Dze5zRJBaYh-ISAMXaZE2NwPU2BtxTwo,62131
+lunalib/core/wallet_manager.py,sha256=KK58hrr_xF1vZ4qI6x_BJqrs9XXh5m0XbZYnZmi9yoU,26031
+lunalib/core/wallet_sync_helper.py,sha256=CGfSBXvf8vg4SGsLaxsjGwHVbD9dmfcuMrZ_CO0J5lE,6282
+lunalib/gtx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lunalib/gtx/bill_registry.py,sha256=J1TivYIzmJEVQHNJrZxqOOEbUSlJs7rQIXfSA90ztL4,4333
+lunalib/gtx/digital_bill.py,sha256=xi2d7RVBGFwDOr8ulMCgvXXebHKl9LeeW9f5H4j_P_A,10977
+lunalib/gtx/genesis.py,sha256=dDiLz-jW0zr5WUifYo9lzsrafQGOuZ9oakv_TX6QdPg,16028
+lunalib/mining/__init__.py,sha256=kOwXt_fwjHLUvV3XxieG2LZyKMW316brXLF8V8lHBUo,193
+lunalib/mining/cuda_manager.py,sha256=VjVx9KLhT2F1jOOhva8ioGP32oQIAciZjf1irWl1jJY,5136
+lunalib/mining/difficulty.py,sha256=hKCtvEovb4le5Fnhz6Mm8-Cugjm_CduJnZA2aNC2eyU,5326
+lunalib/mining/miner.py,sha256=WP5UBOajLYT9JzAjLAshwq-f8CsLKYdLJpUX9kY2PdI,48898
+lunalib/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lunalib/storage/cache.py,sha256=U-riY8OTzxCOpl8yvhpbU3YUysEKgrPlmhO4F4cI9FM,5352
+lunalib/storage/database.py,sha256=2f3Ie6JnuK7L0YGtAdZt5mgj90pokneXhSQKUyvx8Pc,8219
+lunalib/storage/encryption.py,sha256=59g8vFFPAkc_L7t2TXas9Rs4oB3JB1t5ikmDbs4aaqM,4399
+lunalib/transactions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lunalib/transactions/security.py,sha256=cQJRasJ37Z8mJo8gt0JJOb0_M9CQ0QScr67y3M_NP4Q,10309
+lunalib/transactions/transactions.py,sha256=3PgyW8gDQwY-gAPGY_T3m7RE_9HzEIOjTf6CWCsOKFY,18151
+lunalib/transactions/validator.py,sha256=FQ-jVjj8VoVTlq65blB_hprAwJOtpc2peYdQk_L2xmg,2730
+lunalib-1.7.2.dist-info/METADATA,sha256=mGCHaUW-45XaO5hJtKzFaE-WmJi9UDDTxMpSPcmlfQg,797
+lunalib-1.7.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lunalib-1.7.2.dist-info/top_level.txt,sha256=eLcoOCtOwfvoqUu5g5CNBZB9bdhGXbTwmjuOM7i8ylw,8
+lunalib-1.7.2.dist-info/RECORD,,

lunalib-1.7.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+lunalib

core/blockchain.py

@@ -1,172 +0,0 @@
-from storage.cache import BlockchainCache
-import requests
-import time
-import json
-from typing import Dict, List, Optional, Tuple
-
-
-class BlockchainManager:
-    """Manages blockchain interactions and scanning"""
-    
-    def __init__(self, endpoint_url="https://bank.linglin.art"):
-        self.endpoint_url = endpoint_url.rstrip('/')
-        self.cache = BlockchainCache()
-        self.network_connected = False
-        
-    def get_blockchain_height(self) -> int:
-        """Get current blockchain height"""
-        try:
-            # Try height endpoint first
-            response = requests.get(f'{self.endpoint_url}/blockchain/height', timeout=10)
-            if response.status_code == 200:
-                data = response.json()
-                return data.get('height', 0)
-            
-            # Fallback to blocks endpoint
-            response = requests.get(f'{self.endpoint_url}/blockchain/blocks', timeout=10)
-            if response.status_code == 200:
-                data = response.json()
-                blocks = data.get('blocks', [])
-                return len(blocks)
-                
-        except Exception as e:
-            print(f"Blockchain height error: {e}")
-            
-        return 0
-    
-    def get_block(self, height: int) -> Optional[Dict]:
-        """Get block by height"""
-        # Check cache first
-        cached_block = self.cache.get_block(height)
-        if cached_block:
-            return cached_block
-            
-        try:
-            response = requests.get(f'{self.endpoint_url}/blockchain/block/{height}', timeout=10)
-            if response.status_code == 200:
-                block = response.json()
-                self.cache.save_block(height, block.get('hash', ''), block)
-                return block
-        except Exception as e:
-            print(f"Get block error: {e}")
-            
-        return None
-    
-    def get_blocks_range(self, start_height: int, end_height: int) -> List[Dict]:
-        """Get range of blocks"""
-        blocks = []
-        
-        # Check cache first
-        cached_blocks = self.cache.get_block_range(start_height, end_height)
-        if len(cached_blocks) == (end_height - start_height + 1):
-            return cached_blocks
-            
-        try:
-            response = requests.get(
-                f'{self.endpoint_url}/blockchain/range?start={start_height}&end={end_height}',
-                timeout=30
-            )
-            if response.status_code == 200:
-                blocks = response.json().get('blocks', [])
-                # Cache the blocks
-                for block in blocks:
-                    height = block.get('index', 0)
-                    self.cache.save_block(height, block.get('hash', ''), block)
-            else:
-                # Fallback: get blocks individually
-                for height in range(start_height, end_height + 1):
-                    block = self.get_block(height)
-                    if block:
-                        blocks.append(block)
-                    time.sleep(0.01)  # Be nice to the API
-                        
-        except Exception as e:
-            print(f"Get blocks range error: {e}")
-            
-        return blocks
-    
-    def get_mempool(self) -> List[Dict]:
-        """Get current mempool transactions"""
-        try:
-            response = requests.get(f'{self.endpoint_url}/mempool', timeout=10)
-            if response.status_code == 200:
-                return response.json()
-        except Exception as e:
-            print(f"Mempool error: {e}")
-            
-        return []
-    
-    def broadcast_transaction(self, transaction: Dict) -> bool:
-        """Broadcast transaction to network"""
-        try:
-            response = requests.post(
-                f'{self.endpoint_url}/mempool/add',
-                json=transaction,
-                timeout=30
-            )
-            return response.status_code == 201
-        except Exception as e:
-            print(f"Broadcast error: {e}")
-            return False
-    
-    def check_network_connection(self) -> bool:
-        """Check if network is accessible"""
-        try:
-            response = requests.get(f'{self.endpoint_url}/health', timeout=5)
-            self.network_connected = response.status_code == 200
-            return self.network_connected
-        except:
-            self.network_connected = False
-            return False
-    
-    def scan_transactions_for_address(self, address: str, start_height: int = 0, end_height: int = None) -> List[Dict]:
-        """Scan blockchain for transactions involving an address"""
-        if end_height is None:
-            end_height = self.get_blockchain_height()
-            
-        transactions = []
-        
-        # Scan in batches for efficiency
-        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)
-            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)
-                
-        return transactions
-    
-    def _find_address_transactions(self, block: Dict, address: str) -> List[Dict]:
-        """Find transactions in block that involve the address"""
-        transactions = []
-        address_lower = address.lower()
-        
-        # Check block reward
-        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'
-            }
-            transactions.append(reward_tx)
-        
-        # Check regular transactions
-        for tx in block.get('transactions', []):
-            from_addr = (tx.get('from') or '').lower()
-            to_addr = (tx.get('to') or '').lower()
-            
-            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)
-                
-        return transactions

core/crypto.py

@@ -1,32 +0,0 @@
-import hashlib
-import secrets
-from typing import Optional
-
-class KeyManager:
-    """Manages cryptographic keys and signing"""
-    
-    def generate_private_key(self):
-        """Generate a new private key"""
-        return secrets.token_hex(32)
-    
-    def derive_public_key(self, private_key):
-        """Derive public key from private key"""
-        return hashlib.sha256(private_key.encode()).hexdigest()
-    
-    def derive_address(self, public_key):
-        """Derive address from public key"""
-        address_hash = hashlib.sha256(public_key.encode()).hexdigest()
-        return f"LUN_{address_hash[:16]}_{secrets.token_hex(4)}"
-    
-    def sign_data(self, data, private_key):
-        """Sign data with private key"""
-        # In production, use proper ECDSA
-        # For now, simplified implementation
-        sign_string = data + private_key
-        return hashlib.sha256(sign_string.encode()).hexdigest()
-    
-    def verify_signature(self, data, signature, public_key):
-        """Verify signature with public key"""
-        # Simplified verification
-        expected_public = self.derive_public_key(public_key)
-        return public_key == expected_public