lunalib 1.5.1__py3-none-any.whl

mining/miner.py

@@ -0,0 +1,107 @@
+import time
+import hashlib
+import json
+import threading
+from typing import Dict, Optional
+from mining.difficulty import DifficultySystem
+from gtx.digital_bill import DigitalBill
+
+class GenesisMiner:
+    """Mines GTX Genesis bills with configurable difficulty"""
+    
+    def __init__(self):
+        self.difficulty_system = DifficultySystem()
+        self.mining_active = False
+        self.current_thread = None
+        
+    def mine_bill(self, denomination, user_address, bill_data=None):
+        """Mine a GTX Genesis bill"""
+        difficulty = self.difficulty_system.get_bill_difficulty(denomination)
+        
+        digital_bill = DigitalBill(
+            denomination=denomination,
+            user_address=user_address,
+            difficulty=difficulty,
+            bill_data=bill_data or {}
+        )
+        
+        print(f"⛏️ Mining GTX ${denomination:,} Bill - Difficulty: {difficulty} zeros")
+        
+        start_time = time.time()
+        mining_result = self._perform_mining(digital_bill, difficulty)
+        
+        if mining_result["success"]:
+            mining_time = time.time() - start_time
+            bill = digital_bill.finalize(
+                hash=mining_result["hash"],
+                nonce=mining_result["nonce"],
+                mining_time=mining_time
+            )
+            
+            print(f"✅ Successfully mined GTX ${denomination:,} bill!")
+            print(f"⏱️ Mining time: {mining_time:.2f}s")
+            
+            return bill
+        else:
+            return {"success": False, "error": "Mining failed"}
+    
+    def _perform_mining(self, digital_bill, difficulty):
+        """Perform proof-of-work mining"""
+        target = "0" * difficulty
+        nonce = 0
+        start_time = time.time()
+        
+        while self.mining_active:
+            mining_data = digital_bill.get_mining_data(nonce)
+            data_string = json.dumps(mining_data, sort_keys=True)
+            bill_hash = hashlib.sha256(data_string.encode()).hexdigest()
+            
+            if bill_hash.startswith(target):
+                mining_time = time.time() - start_time
+                return {
+                    "success": True,
+                    "hash": bill_hash,
+                    "nonce": nonce,
+                    "mining_time": mining_time
+                }
+            
+            nonce += 1
+            
+            # Progress updates
+            if nonce % 100000 == 0:
+                current_time = time.time()
+                hashrate = nonce / (current_time - start_time)
+                print(f"⏳ Attempts: {nonce:,} | Rate: {hashrate:,.0f} H/s")
+        
+        return {"success": False, "error": "Mining stopped"}
+    
+    def start_auto_mining(self, denominations, user_address, callback=None):
+        """Start auto-mining multiple bills"""
+        self.mining_active = True
+        
+        def auto_mine():
+            results = []
+            for denomination in denominations:
+                if not self.mining_active:
+                    break
+                    
+                result = self.mine_bill(denomination, user_address)
+                results.append(result)
+                
+                if callback:
+                    callback(result)
+                
+                time.sleep(1)
+            
+            return results
+        
+        self.current_thread = threading.Thread(target=auto_mine, daemon=True)
+        self.current_thread.start()
+        return True
+    
+    def stop_mining(self):
+        """Stop all mining activities"""
+        self.mining_active = False
+        if self.current_thread:
+            self.current_thread.join(timeout=5)
+        print("🛑 Mining stopped")

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}")

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