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

core/blockchain.py

@@ -0,0 +1,172 @@
+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

@@ -0,0 +1,32 @@
+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

core/wallet.py

@@ -0,0 +1,347 @@
+# wallet.py
+import time
+import hashlib
+import json
+from cryptography.fernet import Fernet
+import base64
+import os
+
+class LunaWallet:
+    """Luna wallet implementation with proper key management"""
+    
+    def __init__(self, data_dir=None):
+        self.data_dir = data_dir
+        self.wallets = {}  # Main wallet storage: {address: wallet_data}
+        self.current_wallet_address = None  # Track which wallet is active
+        
+        # Initialize with an empty current wallet state
+        self._reset_current_wallet()
+        
+    def _reset_current_wallet(self):
+        """Reset current wallet to empty state"""
+        self.address = None
+        self.balance = 0.0
+        self.available_balance = 0.0
+        self.created = time.time()
+        self.private_key = None
+        self.public_key = None
+        self.encrypted_private_key = None
+        self.label = "New Wallet"
+        self.is_locked = True
+
+    def _generate_address(self):
+        """Generate wallet address"""
+        base_data = f"LUN_{int(time.time()*1000)}_{hashlib.sha256(str(time.time()).encode()).hexdigest()[:8]}"
+        return hashlib.sha256(base_data.encode()).hexdigest()[:32]
+    
+    def _generate_private_key(self):
+        """Generate private key"""
+        return f"priv_{hashlib.sha256(str(time.time()).encode()).hexdigest()}"
+    
+    def _derive_public_key(self, private_key=None):
+        """Derive public key from private key"""
+        priv_key = private_key or self.private_key
+        if not priv_key:
+            return None
+        return f"pub_{priv_key[-16:]}"
+    
+    def get_wallet_info(self):
+        """Get complete wallet information for current wallet"""
+        if not self.address:
+            return None
+        return {
+            'address': self.address,
+            'balance': self.balance,
+            'available_balance': self.available_balance,
+            'created': self.created,
+            'private_key': self.private_key,
+            'public_key': self.public_key,
+            'encrypted_private_key': self.encrypted_private_key,
+            'label': self.label,
+            'is_locked': self.is_locked
+        }
+
+    def create_new_wallet(self, name, password):
+        """Create a new wallet and add to collection without switching"""
+        # Generate new wallet data
+        address = self._generate_address()
+        private_key = self._generate_private_key()
+        public_key = f"pub_{private_key[-16:]}"
+        
+        # Encrypt private key
+        key = base64.urlsafe_b64encode(hashlib.sha256(password.encode()).digest())
+        fernet = Fernet(key)
+        encrypted_private_key = fernet.encrypt(private_key.encode())
+        
+        # Create new wallet data
+        new_wallet_data = {
+            'address': address,
+            'balance': 0.0,
+            'available_balance': 0.0,
+            'created': time.time(),
+            'private_key': private_key,
+            'public_key': public_key,
+            'encrypted_private_key': encrypted_private_key,
+            'label': name,
+            'is_locked': True
+        }
+        
+        # CRITICAL: Add to wallets collection
+        self.wallets[address] = new_wallet_data
+        
+        print(f"DEBUG: Created new wallet {address}, total wallets: {len(self.wallets)}")
+        
+        return new_wallet_data
+    def create_wallet(self, name, password):
+        """Create a new wallet and set it as current"""
+        # Generate new wallet data
+        address = self._generate_address()
+        private_key = self._generate_private_key()
+        public_key = f"pub_{private_key[-16:]}"
+        
+        # Encrypt private key
+        key = base64.urlsafe_b64encode(hashlib.sha256(password.encode()).digest())
+        fernet = Fernet(key)
+        encrypted_private_key = fernet.encrypt(private_key.encode())
+        
+        # Create wallet data
+        wallet_data = {
+            'address': address,
+            'balance': 0.0,
+            'available_balance': 0.0,
+            'created': time.time(),
+            'private_key': private_key,
+            'public_key': public_key,
+            'encrypted_private_key': encrypted_private_key,
+            'label': name,
+            'is_locked': True
+        }
+        
+        # CRITICAL: Add to wallets collection
+        self.wallets[address] = wallet_data
+        
+        # Set as current wallet
+        self._set_current_wallet(wallet_data)
+        
+        print(f"DEBUG: Created and switched to wallet {address}, total wallets: {len(self.wallets)}")
+        
+        return wallet_data
+    def _set_current_wallet(self, wallet_data):
+        """Set the current wallet from wallet data"""
+        self.current_wallet_address = wallet_data['address']
+        self.address = wallet_data['address']
+        self.balance = wallet_data['balance']
+        self.available_balance = wallet_data['available_balance']
+        self.created = wallet_data['created']
+        self.private_key = wallet_data['private_key']
+        self.public_key = wallet_data['public_key']
+        self.encrypted_private_key = wallet_data['encrypted_private_key']
+        self.label = wallet_data['label']
+        self.is_locked = wallet_data.get('is_locked', True)
+
+    def switch_wallet(self, address, password=None):
+        """Switch to a different wallet in the collection"""
+        if address in self.wallets:
+            wallet_data = self.wallets[address]
+            self._set_current_wallet(wallet_data)
+            
+            # If password provided, unlock the wallet
+            if password:
+                return self.unlock_wallet(address, password)
+            
+            return True
+        return False
+
+    def unlock_wallet(self, address, password):
+        """Unlock wallet with password"""
+        if address not in self.wallets:
+            return False
+            
+        wallet_data = self.wallets[address]
+        
+        try:
+            if wallet_data.get('encrypted_private_key'):
+                key = base64.urlsafe_b64encode(hashlib.sha256(password.encode()).digest())
+                fernet = Fernet(key)
+                decrypted_key = fernet.decrypt(wallet_data['encrypted_private_key'])
+                wallet_data['private_key'] = decrypted_key.decode()
+                wallet_data['is_locked'] = False
+                
+                # If this is the current wallet, update current state
+                if self.current_wallet_address == address:
+                    self.private_key = wallet_data['private_key']
+                    self.is_locked = False
+                
+                return True
+        except:
+            pass
+        return False
+    
+    @property
+    def is_unlocked(self):
+        """Check if current wallet is unlocked"""
+        if not self.current_wallet_address:
+            return False
+        wallet_data = self.wallets.get(self.current_wallet_address, {})
+        return not wallet_data.get('is_locked', True)
+    
+    def export_private_key(self, address, password):
+        """Export private key with password decryption"""
+        if address not in self.wallets:
+            return None
+            
+        wallet_data = self.wallets[address]
+        
+        try:
+            if wallet_data.get('encrypted_private_key'):
+                key = base64.urlsafe_b64encode(hashlib.sha256(password.encode()).digest())
+                fernet = Fernet(key)
+                decrypted_key = fernet.decrypt(wallet_data['encrypted_private_key'])
+                return decrypted_key.decode()
+        except:
+            pass
+        return None
+    
+    def import_wallet(self, wallet_data, password=None):
+        """Import wallet from data"""
+        if isinstance(wallet_data, dict):
+            address = wallet_data.get('address')
+            if not address:
+                return False
+                
+            # Add to wallets collection
+            self.wallets[address] = wallet_data.copy()
+            
+            # Set as current wallet
+            self._set_current_wallet(wallet_data)
+            
+            if password and wallet_data.get('encrypted_private_key'):
+                return self.unlock_wallet(address, password)
+            
+            return True
+        return False
+    
+    def update_balance(self, new_balance):
+        """Update current wallet balance"""
+        self.balance = float(new_balance)
+        self.available_balance = float(new_balance)
+        
+        # Also update in wallets collection
+        if self.current_wallet_address and self.current_wallet_address in self.wallets:
+            self.wallets[self.current_wallet_address]['balance'] = self.balance
+            self.wallets[self.current_wallet_address]['available_balance'] = self.available_balance
+        
+        return True
+    
+    def get_balance(self):
+        """Get current wallet balance"""
+        return self.balance
+    
+    def get_wallet_by_address(self, address):
+        """Get wallet by address from wallets collection"""
+        return self.wallets.get(address)
+    
+    def list_wallets(self):
+        """List all wallets in collection"""
+        return list(self.wallets.keys())
+    
+    def get_current_wallet_info(self):
+        """Get current wallet information"""
+        if not self.current_wallet_address:
+            return None
+        return self.wallets.get(self.current_wallet_address)
+    
+    def save_to_file(self, filename=None):
+        """Save wallet to file"""
+        if not self.data_dir:
+            return False
+            
+        if filename is None:
+            filename = f"wallet_{self.address}.json"
+            
+        filepath = os.path.join(self.data_dir, filename)
+        
+        try:
+            # Ensure directory exists
+            os.makedirs(self.data_dir, exist_ok=True)
+            
+            # Prepare encrypted private key for serialization
+            encrypted_key_data = None
+            if self.encrypted_private_key:
+                # Ensure it's bytes before encoding
+                if isinstance(self.encrypted_private_key, bytes):
+                    encrypted_key_data = base64.b64encode(self.encrypted_private_key).decode('utf-8')
+                else:
+                    encrypted_key_data = base64.b64encode(self.encrypted_private_key.encode()).decode('utf-8')
+            
+            # Prepare wallets for serialization (remove any non-serializable data)
+            serializable_wallets = {}
+            for addr, wallet_info in self.wallets.items():
+                serializable_wallet = wallet_info.copy()
+                # Ensure encrypted_private_key is serializable
+                if serializable_wallet.get('encrypted_private_key') and isinstance(serializable_wallet['encrypted_private_key'], bytes):
+                    serializable_wallet['encrypted_private_key'] = base64.b64encode(
+                        serializable_wallet['encrypted_private_key']
+                    ).decode('utf-8')
+                serializable_wallets[addr] = serializable_wallet
+            
+            wallet_data = {
+                'address': self.address,
+                'balance': self.balance,
+                'available_balance': self.available_balance,
+                'created': self.created,
+                'public_key': self.public_key,
+                'encrypted_private_key': encrypted_key_data,
+                'label': self.label,
+                'is_locked': self.is_locked,
+                'wallets': serializable_wallets,
+                'current_wallet_address': self.current_wallet_address
+            }
+            
+            with open(filepath, 'w') as f:
+                json.dump(wallet_data, f, indent=2)
+            return True
+        except Exception as e:
+            print(f"Error saving wallet: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
+
+    def load_from_file(self, filename, password=None):
+        """Load wallet from file"""
+        if not self.data_dir:
+            return False
+            
+        filepath = os.path.join(self.data_dir, filename)
+        
+        try:
+            with open(filepath, 'r') as f:
+                wallet_data = json.load(f)
+            
+            # Load wallets collection
+            self.wallets = wallet_data.get('wallets', {})
+            
+            # Load current wallet address
+            self.current_wallet_address = wallet_data.get('current_wallet_address')
+            
+            # If we have a current wallet, load its data
+            if self.current_wallet_address and self.current_wallet_address in self.wallets:
+                current_wallet_data = self.wallets[self.current_wallet_address]
+                self._set_current_wallet(current_wallet_data)
+                
+                # Handle encrypted private key
+                encrypted_key = wallet_data.get('encrypted_private_key')
+                if encrypted_key:
+                    self.encrypted_private_key = base64.b64decode(encrypted_key.encode())
+                    # Also update in wallets collection
+                    if self.current_wallet_address in self.wallets:
+                        self.wallets[self.current_wallet_address]['encrypted_private_key'] = self.encrypted_private_key
+            
+            # If password provided and we have encrypted key, unlock
+            if password and self.encrypted_private_key and self.current_wallet_address:
+                return self.unlock_wallet(self.current_wallet_address, password)
+            
+            return True
+        except Exception as e:
+            print(f"Error loading wallet: {e}")
+            return False

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