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

storage/database.py

@@ -0,0 +1,222 @@
+import os
+import sqlite3
+import json
+import time
+from typing import Dict, List, Optional, Any
+
+class WalletDatabase:
+    """Manages wallet data storage"""
+    
+    def __init__(self, db_path=None):
+        self.db_path = db_path or os.path.join(os.path.expanduser("~"), ".luna_wallet", "wallets.db")
+        os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
+        self._init_database()
+    
+    def _init_database(self):
+        """Initialize wallet database"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        # Wallets table
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS wallets (
+                address TEXT PRIMARY KEY,
+                label TEXT,
+                public_key TEXT,
+                encrypted_private_key TEXT,
+                balance REAL DEFAULT 0.0,
+                created REAL,
+                last_accessed REAL,
+                metadata TEXT
+            )
+        ''')
+        
+        # Transactions table
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS transactions (
+                tx_hash TEXT PRIMARY KEY,
+                wallet_address TEXT,
+                tx_type TEXT,
+                from_address TEXT,
+                to_address TEXT,
+                amount REAL,
+                fee REAL,
+                timestamp REAL,
+                block_height INTEGER,
+                status TEXT,
+                memo TEXT,
+                raw_data TEXT,
+                FOREIGN KEY (wallet_address) REFERENCES wallets (address)
+            )
+        ''')
+        
+        # Pending transactions table
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS pending_transactions (
+                tx_hash TEXT PRIMARY KEY,
+                wallet_address TEXT,
+                from_address TEXT,
+                to_address TEXT,
+                amount REAL,
+                fee REAL,
+                created_time REAL,
+                status TEXT DEFAULT 'pending',
+                retry_count INTEGER DEFAULT 0,
+                last_retry REAL,
+                raw_data TEXT
+            )
+        ''')
+        
+        conn.commit()
+        conn.close()
+    
+    def save_wallet(self, wallet_data: Dict) -> bool:
+        """Save wallet to database"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            cursor.execute('''
+                INSERT OR REPLACE INTO wallets 
+                (address, label, public_key, encrypted_private_key, balance, created, last_accessed, metadata)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            ''', (
+                wallet_data['address'],
+                wallet_data.get('label', ''),
+                wallet_data.get('public_key', ''),
+                wallet_data.get('encrypted_private_key', ''),
+                wallet_data.get('balance', 0.0),
+                wallet_data.get('created', time.time()),
+                time.time(),
+                json.dumps(wallet_data.get('metadata', {}))
+            ))
+            
+            conn.commit()
+            conn.close()
+            return True
+            
+        except Exception as e:
+            print(f"Save wallet error: {e}")
+            return False
+    
+    def load_wallet(self, address: str) -> Optional[Dict]:
+        """Load wallet from database"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            cursor.execute('SELECT * FROM wallets WHERE address = ?', (address,))
+            result = cursor.fetchone()
+            conn.close()
+            
+            if result:
+                return {
+                    'address': result[0],
+                    'label': result[1],
+                    'public_key': result[2],
+                    'encrypted_private_key': result[3],
+                    'balance': result[4],
+                    'created': result[5],
+                    'last_accessed': result[6],
+                    'metadata': json.loads(result[7]) if result[7] else {}
+                }
+                
+        except Exception as e:
+            print(f"Load wallet error: {e}")
+            
+        return None
+    
+    def save_transaction(self, transaction: Dict, wallet_address: str) -> bool:
+        """Save transaction to database"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            cursor.execute('''
+                INSERT OR REPLACE INTO transactions 
+                (tx_hash, wallet_address, tx_type, from_address, to_address, amount, fee, 
+                 timestamp, block_height, status, memo, raw_data)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ''', (
+                transaction.get('hash', ''),
+                wallet_address,
+                transaction.get('type', 'transfer'),
+                transaction.get('from', ''),
+                transaction.get('to', ''),
+                transaction.get('amount', 0),
+                transaction.get('fee', 0),
+                transaction.get('timestamp', time.time()),
+                transaction.get('block_height'),
+                transaction.get('status', 'confirmed'),
+                transaction.get('memo', ''),
+                json.dumps(transaction)
+            ))
+            
+            conn.commit()
+            conn.close()
+            return True
+            
+        except Exception as e:
+            print(f"Save transaction error: {e}")
+            return False
+    
+    def get_wallet_transactions(self, wallet_address: str, limit: int = 100) -> List[Dict]:
+        """Get transactions for a wallet"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            cursor.execute('''
+                SELECT raw_data FROM transactions 
+                WHERE wallet_address = ? 
+                ORDER BY timestamp DESC 
+                LIMIT ?
+            ''', (wallet_address, limit))
+            
+            results = cursor.fetchall()
+            conn.close()
+            
+            transactions = []
+            for result in results:
+                try:
+                    tx = json.loads(result[0])
+                    transactions.append(tx)
+                except:
+                    continue
+                    
+            return transactions
+            
+        except Exception as e:
+            print(f"Get transactions error: {e}")
+            return []
+    
+    def save_pending_transaction(self, transaction: Dict, wallet_address: str) -> bool:
+        """Save pending transaction"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            cursor.execute('''
+                INSERT OR REPLACE INTO pending_transactions 
+                (tx_hash, wallet_address, from_address, to_address, amount, fee, 
+                 created_time, status, raw_data)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ''', (
+                transaction.get('hash', ''),
+                wallet_address,
+                transaction.get('from', ''),
+                transaction.get('to', ''),
+                transaction.get('amount', 0),
+                transaction.get('fee', 0),
+                time.time(),
+                'pending',
+                json.dumps(transaction)
+            ))
+            
+            conn.commit()
+            conn.close()
+            return True
+            
+        except Exception as e:
+            print(f"Save pending transaction error: {e}")
+            return False

storage/encryption.py

@@ -0,0 +1,105 @@
+import os
+import json
+import base64
+import hashlib
+from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from typing import Dict, Optional
+class EncryptionManager:
+    """Handles encryption and decryption of sensitive data"""
+    
+    def __init__(self):
+        self.salt = b'luna_wallet_salt'  # In production, use random salt per wallet
+    
+    def encrypt_wallet(self, wallet_data: Dict, password: str) -> Dict:
+        """Encrypt wallet data"""
+        try:
+            # Derive key from password
+            key = self._derive_key(password)
+            fernet = Fernet(key)
+            
+            # Encrypt private key separately
+            private_key = wallet_data.get('private_key', '')
+            if private_key:
+                encrypted_private = fernet.encrypt(private_key.encode()).decode()
+                wallet_data['encrypted_private_key'] = encrypted_private
+                del wallet_data['private_key']
+            
+            # Encrypt entire wallet data
+            wallet_json = json.dumps(wallet_data)
+            encrypted_wallet = fernet.encrypt(wallet_json.encode()).decode()
+            
+            return {
+                'encrypted_data': encrypted_wallet,
+                'version': '1.0',
+                'salt': base64.b64encode(self.salt).decode()
+            }
+            
+        except Exception as e:
+            print(f"Encryption error: {e}")
+            return {}
+    
+    def decrypt_wallet(self, encrypted_data: Dict, password: str) -> Optional[Dict]:
+        """Decrypt wallet data"""
+        try:
+            encrypted_wallet = encrypted_data.get('encrypted_data', '')
+            if not encrypted_wallet:
+                return None
+            
+            # Derive key from password
+            key = self._derive_key(password)
+            fernet = Fernet(key)
+            
+            # Decrypt wallet
+            decrypted_data = fernet.decrypt(encrypted_wallet.encode())
+            wallet_data = json.loads(decrypted_data.decode())
+            
+            # Decrypt private key if present
+            encrypted_private = wallet_data.get('encrypted_private_key')
+            if encrypted_private:
+                private_key = fernet.decrypt(encrypted_private.encode()).decode()
+                wallet_data['private_key'] = private_key
+                del wallet_data['encrypted_private_key']
+            
+            return wallet_data
+            
+        except Exception as e:
+            print(f"Decryption error: {e}")
+            return None
+    
+    def _derive_key(self, password: str) -> bytes:
+        """Derive encryption key from password"""
+        kdf = PBKDF2HMAC(
+            algorithm=hashes.SHA256(),
+            length=32,
+            salt=self.salt,
+            iterations=100000,
+        )
+        key = base64.urlsafe_b64encode(kdf.derive(password.encode()))
+        return key
+    
+    def verify_password(self, encrypted_data: Dict, password: str) -> bool:
+        """Verify password without full decryption"""
+        try:
+            # Try to decrypt a small part to verify password
+            key = self._derive_key(password)
+            fernet = Fernet(key)
+            
+            # This will throw an exception if password is wrong
+            fernet.decrypt(encrypted_data.get('encrypted_data', 'A')[:10].encode())
+            return True
+        except:
+            return False
+    
+    def encrypt_data(self, data: str, password: str) -> str:
+        """Encrypt arbitrary data"""
+        key = self._derive_key(password)
+        fernet = Fernet(key)
+        return fernet.encrypt(data.encode()).decode()
+    
+    def decrypt_data(self, encrypted_data: str, password: str) -> str:
+        """Decrypt arbitrary data"""
+        key = self._derive_key(password)
+        fernet = Fernet(key)
+        return fernet.decrypt(encrypted_data.encode()).decode()

transactions/security.py

@@ -0,0 +1,172 @@
+import time
+import hashlib
+from typing import Dict, Tuple
+
+class TransactionSecurity:
+    """Enhanced transaction security system"""
+    
+    def __init__(self):
+        self.min_transaction_amount = 0.000001
+        self.max_transaction_amount = 100000000
+        self.required_fee = 0.00001
+        self.rate_limits = {}
+        self.blacklisted_addresses = set()
+    
+    def validate_transaction_security(self, transaction: Dict) -> Tuple[bool, str]:
+        """Comprehensive transaction security validation"""
+        tx_type = transaction.get("type", "").lower()
+        
+        if tx_type == "gtx_genesis":
+            return self._validate_genesis_transaction(transaction)
+        elif tx_type == "reward":
+            return self._validate_reward_transaction(transaction)
+        elif tx_type == "transfer":
+            return self._validate_transfer_transaction(transaction)
+        else:
+            return False, f"Unknown transaction type: {tx_type}"
+    
+    def _validate_genesis_transaction(self, transaction: Dict) -> Tuple[bool, str]:
+        """Validate GTX Genesis transaction"""
+        required_fields = ["bill_serial", "denomination", "mining_difficulty", "hash", "nonce"]
+        for field in required_fields:
+            if field not in transaction:
+                return False, f"Missing GTX field: {field}"
+        
+        # Validate denomination
+        denomination = transaction.get("denomination")
+        valid_denominations = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000]
+        if denomination not in valid_denominations:
+            return False, f"Invalid denomination: {denomination}"
+        
+        # Validate mining proof
+        if not self._validate_mining_proof(transaction):
+            return False, "Invalid mining proof"
+        
+        return True, "Valid GTX Genesis transaction"
+    
+    def _validate_reward_transaction(self, transaction: Dict) -> Tuple[bool, str]:
+        """Validate reward transaction"""
+        required_fields = ["from", "to", "amount", "block_height", "hash"]
+        for field in required_fields:
+            if field not in transaction:
+                return False, f"Missing reward field: {field}"
+        
+        # Only network can create rewards
+        if transaction.get("from") != "network":
+            return False, "Unauthorized reward creation"
+        
+        return True, "Valid reward transaction"
+    
+    def _validate_transfer_transaction(self, transaction: Dict) -> Tuple[bool, str]:
+        """Validate transfer transaction"""
+        required_fields = ["from", "to", "amount", "signature", "public_key", "nonce"]
+        for field in required_fields:
+            if field not in transaction:
+                return False, f"Missing field: {field}"
+        
+        # Amount validation
+        amount = transaction.get("amount", 0)
+        if amount < self.min_transaction_amount:
+            return False, f"Amount below minimum: {self.min_transaction_amount}"
+        if amount > self.max_transaction_amount:
+            return False, f"Amount above maximum: {self.max_transaction_amount}"
+        
+        # Fee validation
+        fee = transaction.get("fee", 0)
+        if fee < self.required_fee:
+            return False, f"Insufficient fee: {fee} (required: {self.required_fee})"
+        
+        # Signature validation
+        if not self._validate_signature(transaction):
+            return False, "Invalid signature"
+        
+        # Anti-spam checks
+        from_address = transaction.get("from", "")
+        if not self._check_rate_limit(from_address):
+            return False, "Rate limit exceeded"
+        
+        if self._is_blacklisted(from_address):
+            return False, "Address is blacklisted"
+        
+        return True, "Valid transfer transaction"
+    
+    def _validate_mining_proof(self, transaction: Dict) -> bool:
+        """Validate mining proof-of-work"""
+        try:
+            difficulty = transaction.get("mining_difficulty", 0)
+            bill_hash = transaction.get("hash", "")
+            
+            # Verify difficulty requirement
+            target = "0" * difficulty
+            return bill_hash.startswith(target)
+        except:
+            return False
+    
+    def _validate_signature(self, transaction: Dict) -> bool:
+        """Validate transaction signature"""
+        try:
+            signature = transaction.get("signature", "")
+            public_key = transaction.get("public_key", "")
+            
+            # Basic format validation
+            if len(signature) != 64:
+                return False
+            
+            # In production, use proper ECDSA verification
+            # For now, simplified check
+            return all(c in "0123456789abcdef" for c in signature.lower())
+        except:
+            return False
+    
+    def _check_rate_limit(self, address: str) -> bool:
+        """Check transaction rate limiting"""
+        now = time.time()
+        
+        if address not in self.rate_limits:
+            self.rate_limits[address] = []
+        
+        # Remove old entries (older than 1 minute)
+        self.rate_limits[address] = [t for t in self.rate_limits[address] if now - t < 60]
+        
+        # Check if over limit (10 transactions per minute)
+        if len(self.rate_limits[address]) >= 10:
+            return False
+        
+        self.rate_limits[address].append(now)
+        return True
+    
+    def _is_blacklisted(self, address: str) -> bool:
+        """Check if address is blacklisted"""
+        return address.lower() in self.blacklisted_addresses
+    
+    def blacklist_address(self, address: str):
+        """Add address to blacklist"""
+        self.blacklisted_addresses.add(address.lower())
+    
+    def calculate_security_score(self, transaction: Dict) -> int:
+        """Calculate security score for transaction"""
+        score = 0
+        
+        # Signature strength
+        signature = transaction.get("signature", "")
+        if len(signature) == 64:
+            score += 40
+        
+        # Public key presence
+        if transaction.get("public_key"):
+            score += 20
+        
+        # Timestamp freshness
+        timestamp = transaction.get("timestamp", 0)
+        if time.time() - timestamp < 600:  # 10 minutes
+            score += 20
+        
+        # Nonce uniqueness
+        if transaction.get("nonce"):
+            score += 10
+        
+        # Additional security features
+        if transaction.get("security_hash"):
+            score += 10
+        
+        return min(score, 100)