lunalib 1.5.1__py3-none-any.whl

lunalib/storage/cache.py

@@ -0,0 +1,148 @@
+import os
+import sqlite3
+import pickle
+import gzip
+import time
+from typing import Dict, List, Optional
+
+class BlockchainCache:
+    """Caches blockchain data to avoid repeated network requests"""
+    
+    def __init__(self, cache_dir=None):
+        if cache_dir is None:
+            cache_dir = os.path.join(os.path.expanduser("~"), ".luna_wallet")
+        self.cache_dir = cache_dir
+        self.cache_file = os.path.join(cache_dir, "blockchain_cache.db")
+        self._init_cache()
+    
+    def _init_cache(self):
+        """Initialize cache database"""
+        conn = sqlite3.connect(self.cache_file)
+        cursor = conn.cursor()
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS blocks (
+                height INTEGER PRIMARY KEY,
+                hash TEXT UNIQUE,
+                block_data BLOB,
+                timestamp REAL,
+                last_accessed REAL
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS mempool (
+                tx_hash TEXT PRIMARY KEY,
+                tx_data BLOB,
+                received_time REAL,
+                address_involved TEXT
+            )
+        ''')
+        
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS cache_meta (
+                key TEXT PRIMARY KEY,
+                value TEXT
+            )
+        ''')
+        
+        conn.commit()
+        conn.close()
+    
+    def save_block(self, height: int, block_hash: str, block_data: Dict):
+        """Save block to cache"""
+        try:
+            conn = sqlite3.connect(self.cache_file)
+            cursor = conn.cursor()
+            
+            compressed_data = gzip.compress(pickle.dumps(block_data))
+            
+            cursor.execute('''
+                INSERT OR REPLACE INTO blocks 
+                (height, hash, block_data, timestamp, last_accessed)
+                VALUES (?, ?, ?, ?, ?)
+            ''', (height, block_hash, compressed_data, time.time(), time.time()))
+            
+            conn.commit()
+            conn.close()
+        except Exception as e:
+            print(f"Cache save error: {e}")
+    
+    def get_block(self, height: int) -> Optional[Dict]:
+        """Get block from cache"""
+        try:
+            conn = sqlite3.connect(self.cache_file)
+            cursor = conn.cursor()
+            
+            cursor.execute('SELECT block_data FROM blocks WHERE height = ?', (height,))
+            result = cursor.fetchone()
+            
+            if result:
+                # Update access time
+                cursor.execute('UPDATE blocks SET last_accessed = ? WHERE height = ?', 
+                             (time.time(), height))
+                conn.commit()
+                conn.close()
+                
+                return pickle.loads(gzip.decompress(result[0]))
+                
+            conn.close()
+        except Exception as e:
+            print(f"Cache read error: {e}")
+            
+        return None
+    
+    def get_block_range(self, start_height: int, end_height: int) -> List[Dict]:
+        """Get multiple blocks from cache"""
+        blocks = []
+        try:
+            conn = sqlite3.connect(self.cache_file)
+            cursor = conn.cursor()
+            
+            cursor.execute('''
+                SELECT height, block_data FROM blocks 
+                WHERE height BETWEEN ? AND ? 
+                ORDER BY height
+            ''', (start_height, end_height))
+            
+            results = cursor.fetchall()
+            conn.close()
+            
+            for height, block_data in results:
+                try:
+                    block = pickle.loads(gzip.decompress(block_data))
+                    blocks.append(block)
+                except:
+                    continue
+                    
+        except Exception as e:
+            print(f"Block range cache error: {e}")
+            
+        return blocks
+    
+    def get_highest_cached_height(self) -> int:
+        """Get the highest block height in cache"""
+        try:
+            conn = sqlite3.connect(self.cache_file)
+            cursor = conn.cursor()
+            
+            cursor.execute('SELECT MAX(height) FROM blocks')
+            result = cursor.fetchone()
+            conn.close()
+            
+            return result[0] if result[0] is not None else -1
+        except:
+            return -1
+    
+    def clear_old_blocks(self, max_age_hours=24):
+        """Clear blocks older than specified hours"""
+        try:
+            cutoff = time.time() - (max_age_hours * 3600)
+            conn = sqlite3.connect(self.cache_file)
+            cursor = conn.cursor()
+            
+            cursor.execute('DELETE FROM blocks WHERE last_accessed < ?', (cutoff,))
+            conn.commit()
+            conn.close()
+        except Exception as e:
+            print(f"Cache cleanup error: {e}")

lunalib/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

lunalib/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()