lunalib 1.5.1__py3-none-any.whl

lunalib/core/wallet_sync_helper.py

@@ -0,0 +1,163 @@
+# lunalib/wallet_sync_helper.py
+"""
+Wallet Sync Helper
+
+Provides integration between LunaWallet, BlockchainManager, MempoolManager,
+and the WalletStateManager for seamless real-time balance and transaction updates.
+"""
+
+from typing import List, Dict, Optional, Callable
+from .wallet_manager import get_wallet_manager
+
+
+class WalletSyncHelper:
+    """
+    Helper class to sync LunaWallet with WalletStateManager using data from
+    BlockchainManager and MempoolManager.
+    """
+    
+    def __init__(self, wallet=None, blockchain=None, mempool=None):
+        """
+        Initialize sync helper.
+        
+        Parameters:
+            wallet: LunaWallet instance
+            blockchain: BlockchainManager instance
+            mempool: MempoolManager instance
+        """
+        self.wallet = wallet
+        self.blockchain = blockchain
+        self.mempool = mempool
+        self.state_manager = get_wallet_manager()
+        
+    def register_wallets_from_lunawallet(self) -> Dict:
+        """Register all wallets from LunaWallet into the state manager"""
+        if not self.wallet:
+            print("⚠️  No wallet instance provided")
+            return {}
+        
+        addresses = list(self.wallet.wallets.keys())
+        if not addresses:
+            print("⚠️  No wallets registered in LunaWallet")
+            return {}
+        
+        print(f"📱 Registering {len(addresses)} wallets with state manager...")
+        states = self.state_manager.register_wallets(addresses)
+        print(f"✅ Registered {len(states)} wallets")
+        
+        return states
+    
+    def sync_wallets_now(self) -> Dict:
+        """
+        Perform a single synchronization of all registered wallets.
+        
+        Returns: Dictionary of wallet addresses and their updated summaries
+        """
+        if not self.blockchain or not self.mempool:
+            print("⚠️  Blockchain or mempool not provided")
+            return {}
+        
+        addresses = list(self.state_manager.wallet_states.keys())
+        if not addresses:
+            print("⚠️  No wallets registered")
+            return {}
+        
+        print(f"🔄 Syncing {len(addresses)} wallets...")
+        
+        try:
+            # Get data from blockchain and mempool
+            blockchain_txs = self.blockchain.scan_transactions_for_addresses(addresses)
+            mempool_txs = self.mempool.get_pending_transactions_for_addresses(addresses)
+            
+            # Sync the state manager
+            self.state_manager.sync_wallets_from_sources(blockchain_txs, mempool_txs)
+            
+            # Update LunaWallet balances if available
+            if self.wallet:
+                self._update_lunawallet_balances()
+            
+            # Return summaries
+            return self.state_manager.get_all_summaries()
+            
+        except Exception as e:
+            print(f"❌ Sync error: {e}")
+            return {}
+    
+    def _update_lunawallet_balances(self):
+        """Update LunaWallet instance balances from state manager"""
+        if not self.wallet:
+            return
+        
+        balances = self.state_manager.get_all_balances()
+        
+        for address, balance_data in balances.items():
+            if address in self.wallet.wallets:
+                wallet_data = self.wallet.wallets[address]
+                wallet_data['balance'] = balance_data['confirmed_balance']
+                wallet_data['available_balance'] = balance_data['available_balance']
+        
+        # Update current wallet if one is selected
+        if self.wallet.current_wallet_address in balances:
+            balance_data = balances[self.wallet.current_wallet_address]
+            self.wallet.balance = balance_data['confirmed_balance']
+            self.wallet.available_balance = balance_data['available_balance']
+    
+    def start_continuous_sync(self, poll_interval: int = 30,
+                             on_balance_update: Optional[Callable] = None,
+                             on_transaction_update: Optional[Callable] = None) -> None:
+        """
+        Start continuous synchronization in the background.
+        
+        Parameters:
+            poll_interval: Seconds between syncs
+            on_balance_update: Callback function(balance_data) for balance updates
+            on_transaction_update: Callback function(transaction_data) for transaction updates
+        """
+        
+        if on_balance_update:
+            self.state_manager.on_balance_update(on_balance_update)
+        
+        if on_transaction_update:
+            self.state_manager.on_transaction_update(on_transaction_update)
+        
+        def get_blockchain_data(addresses):
+            try:
+                return self.blockchain.scan_transactions_for_addresses(addresses)
+            except Exception as e:
+                print(f"⚠️  Blockchain scan error: {e}")
+                return {}
+        
+        def get_mempool_data(addresses):
+            try:
+                return self.mempool.get_pending_transactions_for_addresses(addresses)
+            except Exception as e:
+                print(f"⚠️  Mempool fetch error: {e}")
+                return {}
+        
+        self.state_manager.sync_wallets_background(
+            get_blockchain_data,
+            get_mempool_data,
+            poll_interval
+        )
+    
+    def get_wallet_balance(self, address: str) -> Optional[Dict]:
+        """Get current balance for a wallet"""
+        return self.state_manager.get_balance(address)
+    
+    def get_wallet_transactions(self, address: str, tx_type: str = 'all') -> List[Dict]:
+        """Get transactions for a wallet"""
+        return self.state_manager.get_transactions(address, tx_type)
+    
+    def get_wallet_summary(self, address: str) -> Optional[Dict]:
+        """Get complete summary for a wallet"""
+        return self.state_manager.get_wallet_summary(address)
+    
+    def get_all_wallets_summary(self) -> Dict:
+        """Get summaries for all wallets"""
+        return self.state_manager.get_all_summaries()
+
+
+# Convenience function to create sync helper
+def create_wallet_sync_helper(wallet=None, blockchain=None, mempool=None) -> WalletSyncHelper:
+    """Create a new WalletSyncHelper instance"""
+    return WalletSyncHelper(wallet, blockchain, mempool)

lunalib/gtx/bill_registry.py

@@ -0,0 +1,122 @@
+import os
+import json
+import sqlite3
+from typing import Dict, List, Optional
+
+class BillRegistry:
+    """Manages bill database with verification links and metadata"""
+    
+    def __init__(self, db_path=None):
+        self.db_path = db_path or os.path.join(os.path.expanduser("~"), ".luna_wallet", "bills.db")
+        os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
+        self._init_database()
+    
+    def _init_database(self):
+        """Initialize bill database"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS bills (
+                bill_serial TEXT PRIMARY KEY,
+                denomination INTEGER,
+                user_address TEXT,
+                hash TEXT,
+                mining_time REAL,
+                difficulty INTEGER,
+                luna_value REAL,
+                timestamp REAL,
+                verification_url TEXT,
+                image_url TEXT,
+                metadata TEXT,
+                status TEXT DEFAULT 'active'
+            )
+        ''')
+        
+        conn.commit()
+        conn.close()
+    
+    def register_bill(self, bill_info):
+        """Register a new bill in the database"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        # Generate verification URL
+        verification_url = f"https://bank.linglin.art/verify/{bill_info['hash']}"
+        image_url = f"https://bank.linglin.art/bills/{bill_info['bill_serial']}.png"
+        
+        cursor.execute('''
+            INSERT OR REPLACE INTO bills 
+            (bill_serial, denomination, user_address, hash, mining_time, 
+             difficulty, luna_value, timestamp, verification_url, image_url, metadata)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ''', (
+            bill_info['bill_serial'],
+            bill_info['denomination'],
+            bill_info['user_address'],
+            bill_info['hash'],
+            bill_info['mining_time'],
+            bill_info['difficulty'],
+            bill_info['luna_value'],
+            bill_info['timestamp'],
+            verification_url,
+            image_url,
+            json.dumps(bill_info.get('bill_data', {}))
+        ))
+        
+        conn.commit()
+        conn.close()
+    
+    def get_bill(self, bill_serial):
+        """Retrieve bill information"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('SELECT * FROM bills WHERE bill_serial = ?', (bill_serial,))
+        result = cursor.fetchone()
+        conn.close()
+        
+        if result:
+            return {
+                'bill_serial': result[0],
+                'denomination': result[1],
+                'user_address': result[2],
+                'hash': result[3],
+                'mining_time': result[4],
+                'difficulty': result[5],
+                'luna_value': result[6],
+                'timestamp': result[7],
+                'verification_url': result[8],
+                'image_url': result[9],
+                'metadata': json.loads(result[10]) if result[10] else {},
+                'status': result[11]
+            }
+        return None
+    
+    def get_user_bills(self, user_address):
+        """Get all bills for a user"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        cursor.execute('SELECT * FROM bills WHERE user_address = ? ORDER BY timestamp DESC', (user_address,))
+        results = cursor.fetchall()
+        conn.close()
+        
+        bills = []
+        for result in results:
+            bills.append({
+                'bill_serial': result[0],
+                'denomination': result[1],
+                'user_address': result[2],
+                'hash': result[3],
+                'mining_time': result[4],
+                'difficulty': result[5],
+                'luna_value': result[6],
+                'timestamp': result[7],
+                'verification_url': result[8],
+                'image_url': result[9],
+                'metadata': json.loads(result[10]) if result[10] else {},
+                'status': result[11]
+            })
+        
+        return bills

lunalib/gtx/digital_bill.py

@@ -0,0 +1,273 @@
+import time
+import hashlib
+import secrets
+import json
+import base64
+from typing import Dict, Optional
+
+try:
+    from cryptography.hazmat.primitives import hashes
+    from cryptography.hazmat.primitives.asymmetric import rsa, padding
+    from cryptography.hazmat.primitives import serialization
+    from cryptography.exceptions import InvalidSignature
+    CRYPTOGRAPHY_AVAILABLE = True
+except ImportError:
+    print("Warning: cryptography library not available. Using fallback methods.")
+    CRYPTOGRAPHY_AVAILABLE = False
+
+from .bill_registry import BillRegistry
+
+class DigitalBill:
+    """Represents a GTX Genesis digital bill with cryptographic signatures"""
+    
+    def __init__(self, denomination, user_address, difficulty, bill_data=None, 
+                 bill_type="GTX_Genesis", front_serial=None, back_serial=None, 
+                 metadata_hash=None, public_key=None, signature=None):
+        # GTX Genesis properties
+        self.denomination = denomination
+        self.user_address = user_address
+        self.difficulty = difficulty
+        self.bill_data = bill_data or {}
+        self.bill_serial = front_serial or self._generate_serial()
+        self.created_time = time.time()
+        self.bill_registry = BillRegistry()
+        
+        # Signature properties
+        self.bill_type = bill_type
+        self.front_serial = front_serial or self.bill_serial
+        self.back_serial = back_serial or ""
+        self.metadata_hash = metadata_hash or self._generate_metadata_hash()
+        self.timestamp = self.created_time
+        self.issued_to = user_address
+        self.public_key = public_key
+        self.signature = signature
+    
+    def _generate_serial(self):
+        """Generate unique bill serial number"""
+        timestamp = int(time.time() * 1000)
+        random_part = secrets.token_hex(4)
+        return f"GTX{self.denomination}_{timestamp}_{random_part}"
+    
+    def _generate_metadata_hash(self):
+        """Generate metadata hash for the bill"""
+        metadata = {
+            "denomination": self.denomination,
+            "user_address": self.user_address,
+            "difficulty": self.difficulty,
+            "timestamp": self.created_time,
+            "bill_serial": self.bill_serial
+        }
+        return hashlib.sha256(json.dumps(metadata, sort_keys=True).encode()).hexdigest()
+    
+    def get_mining_data(self, nonce):
+        """Get data for mining computation"""
+        return {
+            "type": "GTX_Genesis",
+            "denomination": self.denomination,
+            "user_address": self.user_address,
+            "bill_serial": self.bill_serial,
+            "timestamp": self.created_time,
+            "difficulty": self.difficulty,
+            "previous_hash": self._get_previous_hash(),
+            "nonce": nonce,
+            "bill_data": self.bill_data
+        }
+    
+    def finalize(self, hash, nonce, mining_time, private_key=None):
+        """Finalize bill after successful mining with optional signing"""
+        # Create transaction data
+        transaction_data = {
+            "type": "GTX_Genesis",
+            "from": "genesis_network",
+            "to": self.user_address,
+            "amount": self.denomination,
+            "bill_serial": self.bill_serial,
+            "mining_difficulty": self.difficulty,
+            "mining_time": mining_time,
+            "hash": hash,
+            "timestamp": time.time(),
+            "status": "mined",
+            "front_serial": self.front_serial,
+            "issued_to": self.user_address,
+            "denomination": self.denomination,
+            "metadata_hash": self.metadata_hash
+        }
+        
+        # Generate signature if private key provided
+        if private_key:
+            self.sign(private_key)
+            transaction_data.update({
+                "public_key": self.public_key,
+                "signature": self.signature
+            })
+        
+        bill_info = {
+            "success": True,
+            "bill_serial": self.bill_serial,
+            "denomination": self.denomination,
+            "user_address": self.user_address,
+            "mining_time": mining_time,
+            "difficulty": self.difficulty,
+            "hash": hash,
+            "nonce": nonce,
+            "timestamp": time.time(),
+            "luna_value": self.denomination,  # 1:1 ratio
+            "transaction_data": transaction_data
+        }
+        
+        # Add to bill registry
+        self.bill_registry.register_bill(bill_info)
+        
+        return bill_info
+    
+    def _get_previous_hash(self):
+        """Get hash of previous genesis transaction"""
+        # In production, this would query the blockchain
+        return hashlib.sha256(str(time.time()).encode()).hexdigest()
+    
+    # Signature methods from your signatures.py
+    def to_dict(self):
+        """Convert bill data to dictionary for hashing/serialization"""
+        return {
+            'type': self.bill_type,
+            'front_serial': self.front_serial,
+            'back_serial': self.back_serial,
+            'metadata_hash': self.metadata_hash,
+            'timestamp': self.timestamp,
+            'issued_to': self.issued_to,
+            'denomination': self.denomination
+        }
+    
+    def calculate_hash(self):
+        """Calculate SHA-256 hash of the bill data"""
+        bill_string = json.dumps(self.to_dict(), sort_keys=True)
+        return hashlib.sha256(bill_string.encode()).hexdigest()
+    
+    def sign(self, private_key):
+        """Sign the bill data with a private key"""
+        if not CRYPTOGRAPHY_AVAILABLE:
+            return self._sign_fallback(private_key)
+            
+        bill_hash = self.calculate_hash()
+        
+        try:
+            # Load private key if it's in string format
+            if isinstance(private_key, str):
+                private_key_obj = serialization.load_pem_private_key(
+                    private_key.encode('utf-8'),
+                    password=None
+                )
+            else:
+                private_key_obj = private_key
+            
+            # Sign the hash
+            signature = private_key_obj.sign(
+                bill_hash.encode(),
+                padding.PSS(
+                    mgf=padding.MGF1(hashes.SHA256()),
+                    salt_length=padding.PSS.MAX_LENGTH
+                ),
+                hashes.SHA256()
+            )
+            
+            self.signature = base64.b64encode(signature).decode('utf-8')
+            
+            # Set public key
+            public_key = private_key_obj.public_key()
+            public_pem = public_key.public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo
+            )
+            self.public_key = public_pem.decode('utf-8')
+            
+            return self.signature
+        except Exception as e:
+            print(f"Cryptographic signing failed, using fallback: {e}")
+            return self._sign_fallback(private_key)
+    
+    def _sign_fallback(self, private_key):
+        """Fallback signing method using hashes"""
+        bill_hash = self.calculate_hash()
+        # Simple hash-based "signature" for when cryptography is unavailable
+        if isinstance(private_key, str):
+            signature_input = f"{private_key}{bill_hash}"
+        else:
+            signature_input = f"fallback_key{bill_hash}"
+        
+        self.signature = hashlib.sha256(signature_input.encode()).hexdigest()
+        
+        # Set fallback public key
+        if isinstance(private_key, str) and len(private_key) > 32:
+            self.public_key = hashlib.sha256(private_key.encode()).hexdigest()
+        else:
+            self.public_key = "fallback_public_key"
+        
+        return self.signature
+    
+    def verify(self):
+        """Verify signature using the exact same method as creation"""
+        if not self.public_key or not self.signature:
+            return False
+            
+        # Handle mock signatures
+        if self.signature.startswith('mock_signature_'):
+            expected_mock = 'mock_signature_' + hashlib.md5(
+                f"{self.issued_to}{self.denomination}{self.front_serial}".encode()
+            ).hexdigest()
+            return self.signature == expected_mock
+        
+        # Handle fallback signatures
+        if self.public_key == 'fallback_public_key':
+            expected_fallback = hashlib.sha256(
+                f"{self.issued_to}{self.denomination}{self.front_serial}{self.timestamp}".encode()
+            ).hexdigest()
+            return self.signature == expected_fallback
+        
+        # Handle metadata_hash based signatures
+        if self.metadata_hash:
+            verification_data = f"{self.public_key}{self.metadata_hash}"
+            expected_signature = hashlib.sha256(verification_data.encode()).hexdigest()
+            return self.signature == expected_signature
+        
+        # Final fallback - accept any signature that looks valid
+        return len(self.signature) > 0
+    
+    @staticmethod
+    def generate_key_pair():
+        """Generate a new RSA key pair for signing"""
+        if not CRYPTOGRAPHY_AVAILABLE:
+            return DigitalBill._generate_fallback_key_pair()
+            
+        private_key = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=2048
+        )
+        
+        # Get public key
+        public_key = private_key.public_key()
+        
+        # Serialize keys
+        private_pem = private_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption()
+        )
+        
+        public_pem = public_key.public_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo
+        )
+        
+        return private_pem.decode('utf-8'), public_pem.decode('utf-8')
+    
+    @staticmethod
+    def _generate_fallback_key_pair():
+        """Generate fallback key pair using hashes"""
+        import random
+        import string
+        
+        # Generate random strings as "keys"
+        private_key = ''.join(random.choices(string.ascii_letters + string.digits, k=64))
+        public_key = hashlib.sha256(private_key.encode()).hexdigest()
+        
+        return private_key, public_key