lunalib 1.5.0__py3-none-any.whl → 1.5.2__py3-none-any.whl

storage/database.py

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

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

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