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

lunalib-1.2.3.dist-info/RECORD

@@ -1,50 +0,0 @@
-core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-core/blockchain.py,sha256=KHlw1KsBUd1wkmxDunyyJiZMOlUx-Vr4wiDTl8YXdlo,6711
-core/crypto.py,sha256=rBqSbr12Lh_0FdaYQ6XqLA4k8zdZb6MJs-eAjauwm1Q,1202
-core/wallet.py,sha256=R3LVUqGaI42gDw_8lxYFsTetpVwvQvuWeMDsoO6t1eE,13934
-gtx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gtx/bill_registry.py,sha256=J1TivYIzmJEVQHNJrZxqOOEbUSlJs7rQIXfSA90ztL4,4333
-gtx/digital_bill.py,sha256=EnQvAztMNE9uHuxXWmShEpNl084y-clHagK5s1Amvpc,10614
-gtx/genesis.py,sha256=U6CEWcLAR1kb0CfhNQyFMIzh350OeQNNnWxycVJpPWc,15353
-lunalib/__init__.py,sha256=fEvoHvfcC6ilDGQrhXaVmcdB4yDmuijxz6YZHkjbuBg,527
-lunalib/cli.py,sha256=SyuJIhvqld-XL9ks9XFOuyqVb44qyBUbahlqE_RDVkM,524
-lunalib/luna_lib.py,sha256=ue9Bs93xjpg7_GHSUJPKBhf8nF5YcbCIdoMIu-jDgG4,2748
-lunalib/requirements.txt,sha256=3vNUgubGo8tCgeq5HwdGQcwrABxKthSlYsVp_76ckzw,1576
-lunalib/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lunalib/core/blockchain.py,sha256=EiWGgy9aJTW7zrxgtxLSv1H1X3A-8v6ISINQEzf1yY0,30178
-lunalib/core/crypto.py,sha256=rBqSbr12Lh_0FdaYQ6XqLA4k8zdZb6MJs-eAjauwm1Q,1202
-lunalib/core/mempool.py,sha256=N8va24VwQOvzbFcO5c99fDchjYZ3Fm70BkS8XSAg7yo,15373
-lunalib/core/wallet.py,sha256=uXyu4RwBB5Xv8_jfHk5roTV9R6RlwVvsQGPFiM7-JjQ,26969
-lunalib/gtx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lunalib/gtx/bill_registry.py,sha256=J1TivYIzmJEVQHNJrZxqOOEbUSlJs7rQIXfSA90ztL4,4333
-lunalib/gtx/digital_bill.py,sha256=EnQvAztMNE9uHuxXWmShEpNl084y-clHagK5s1Amvpc,10614
-lunalib/gtx/genesis.py,sha256=Mic48kI93fzMoz3Zm8xXGk8MXqUhfpLsNFLs8-ZJdCE,15939
-lunalib/mining/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lunalib/mining/cuda_manager.py,sha256=PUnmVvpu98OTZNdKIIYpVXnY__Ng4pHyZoh8wU-tDCM,5174
-lunalib/mining/difficulty.py,sha256=tzIYmdcm1Xr9-8wyTwwkXJvJoGDyE77o_nu9d81VGvI,3927
-lunalib/mining/miner.py,sha256=rH7Bhm378Rro4FlLqts3qYemHormtFnvz-R9SgJ0eu4,27520
-lunalib/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lunalib/storage/cache.py,sha256=1lNAeUop7ZanyjDUBSLJR6B0ATe6c_Kj0NAU9PAG2P0,4997
-lunalib/storage/database.py,sha256=TjK9xUE8QRsUn3EqNHny1qyddUVlgTJFzhNCw8td7IM,7859
-lunalib/storage/encryption.py,sha256=i_99Qk3I_gAZXwx00tL2Gy5mcALaDUC8olXZJUPAqMw,4054
-lunalib/transactions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lunalib/transactions/security.py,sha256=j23f2xjSaslQDD83_skdTSTL6FGEFD91D8xOaD6gf_M,6716
-lunalib/transactions/transactions.py,sha256=JuSAQtEhKljFuuZe6zLGNWjUHwOM_fiBo0p4xAfFTFg,25014
-lunalib/transactions/validator.py,sha256=FQ-jVjj8VoVTlq65blB_hprAwJOtpc2peYdQk_L2xmg,2730
-mining/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mining/cuda_manager.py,sha256=PUnmVvpu98OTZNdKIIYpVXnY__Ng4pHyZoh8wU-tDCM,5174
-mining/difficulty.py,sha256=tzIYmdcm1Xr9-8wyTwwkXJvJoGDyE77o_nu9d81VGvI,3927
-mining/miner.py,sha256=-Zlu6jWmW4YcFZDTz_sw_ZkvdXM-69gE89aOO7VWs2A,3800
-storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-storage/cache.py,sha256=1lNAeUop7ZanyjDUBSLJR6B0ATe6c_Kj0NAU9PAG2P0,4997
-storage/database.py,sha256=TjK9xUE8QRsUn3EqNHny1qyddUVlgTJFzhNCw8td7IM,7859
-storage/encryption.py,sha256=i_99Qk3I_gAZXwx00tL2Gy5mcALaDUC8olXZJUPAqMw,4054
-transactions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-transactions/security.py,sha256=j23f2xjSaslQDD83_skdTSTL6FGEFD91D8xOaD6gf_M,6716
-transactions/transactions.py,sha256=M0SXPtqCLXDUsSDjqE3M16UeU3FEC_gr63ISKh0VQNA,15877
-transactions/validator.py,sha256=FQ-jVjj8VoVTlq65blB_hprAwJOtpc2peYdQk_L2xmg,2730
-lunalib-1.2.3.dist-info/METADATA,sha256=zmI7cZKFmbEu1q6iChYkXjTE438LV5Mv5NvYdSmYl5k,9689
-lunalib-1.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lunalib-1.2.3.dist-info/entry_points.txt,sha256=bdt2wU-9FZOkmQ2pSy46WrxJSkpRPhVDkRFL1K_kakQ,49
-lunalib-1.2.3.dist-info/top_level.txt,sha256=jEsGPJDTyYkwfmrSSw1GvJ1UxcPvChzv0s6xx-PvaXg,45
-lunalib-1.2.3.dist-info/RECORD,,

lunalib-1.2.3.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-luna-wallet = lunalib.cli:main

lunalib-1.2.3.dist-info/top_level.txt

@@ -1,6 +0,0 @@
-core
-gtx
-lunalib
-mining
-storage
-transactions

mining/cuda_manager.py

@@ -1,137 +0,0 @@
-import time
-from typing import Optional, Dict, Any
-import hashlib
-import json
-
-try:
-    import cupy as cp
-    CUDA_AVAILABLE = True
-except ImportError:
-    CUDA_AVAILABLE = False
-    cp = None
-
-class CUDAManager:
-    """Manages CUDA acceleration for mining operations"""
-    
-    def __init__(self):
-        self.cuda_available = self._check_cuda()
-        self.device = None
-        
-        if self.cuda_available:
-            self._initialize_cuda()
-    
-    def _check_cuda(self) -> bool:
-        """Check if CUDA is available"""
-        try:
-            if not CUDA_AVAILABLE:
-                return False
-                
-            if cp.cuda.runtime.getDeviceCount() > 0:
-                print("✅ CUDA is available for accelerated mining")
-                return True
-            else:
-                print("❌ CUDA drivers found but no GPU available")
-                return False
-        except Exception as e:
-            print(f"❌ CUDA check failed: {e}")
-            return False
-    
-    def _initialize_cuda(self):
-        """Initialize CUDA device"""
-        try:
-            self.device = cp.cuda.Device(0)
-            self.device.use()
-            print(f"✅ Using CUDA device: {cp.cuda.runtime.getDeviceProperties(0)['name']}")
-        except Exception as e:
-            print(f"❌ CUDA initialization failed: {e}")
-            self.cuda_available = False
-    
-    def cuda_mine_batch(self, mining_data: Dict, difficulty: int, batch_size: int = 100000) -> Optional[Dict]:
-        """Mine using CUDA acceleration"""
-        if not self.cuda_available:
-            return None
-            
-        try:
-            target = "0" * difficulty
-            nonce_start = 0
-            start_time = time.time()
-            
-            while True:
-                # Prepare batch data for GPU
-                nonces = cp.arange(nonce_start, nonce_start + batch_size, dtype=cp.uint64)
-                mining_strings = self._prepare_mining_batch(mining_data, nonces)
-                
-                # Compute hashes on GPU
-                hashes = self._compute_hashes_gpu(mining_strings)
-                
-                # Check for successful hash
-                for i, hash_hex in enumerate(hashes):
-                    if hash_hex.startswith(target):
-                        mining_time = time.time() - start_time
-                        successful_nonce = nonce_start + i
-                        
-                        return {
-                            "success": True,
-                            "hash": hash_hex,
-                            "nonce": int(successful_nonce),
-                            "mining_time": mining_time,
-                            "method": "cuda"
-                        }
-                
-                nonce_start += batch_size
-                
-                # Progress update
-                if nonce_start % (batch_size * 10) == 0:
-                    current_time = time.time()
-                    hashrate = nonce_start / (current_time - start_time)
-                    print(f"⏳ CUDA: {nonce_start:,} attempts | {hashrate:,.0f} H/s")
-                    
-        except Exception as e:
-            print(f"CUDA mining error: {e}")
-            
-        return None
-    
-    def _prepare_mining_batch(self, mining_data: Dict, nonces) -> Any:
-        """Prepare batch mining data for GPU"""
-        mining_strings = []
-        
-        for nonce in nonces:
-            mining_data["nonce"] = int(nonce)
-            data_string = json.dumps(mining_data, sort_keys=True)
-            mining_strings.append(data_string.encode())
-            
-        return cp.array(mining_strings)
-    
-    def _compute_hashes_gpu(self, mining_strings) -> list:
-        """Compute SHA256 hashes on GPU"""
-        # Convert to CuPy array if needed
-        if not isinstance(mining_strings, cp.ndarray):
-            mining_strings = cp.array(mining_strings)
-        
-        # This is a simplified implementation
-        # In a real implementation, you'd use proper CUDA kernels
-        hashes = []
-        for data in mining_strings:
-            # For now, fall back to CPU hashing
-            # A real implementation would use CUDA-accelerated hashing
-            hash_obj = hashlib.sha256(data.tobytes())
-            hashes.append(hash_obj.hexdigest())
-            
-        return hashes
-    
-    def get_cuda_info(self) -> Dict[str, Any]:
-        """Get CUDA device information"""
-        if not self.cuda_available:
-            return {"available": False}
-            
-        try:
-            props = cp.cuda.runtime.getDeviceProperties(0)
-            return {
-                "available": True,
-                "device_name": props.get('name', 'Unknown'),
-                "compute_capability": f"{props.get('major', 0)}.{props.get('minor', 0)}",
-                "total_memory": props.get('totalGlobalMem', 0),
-                "multiprocessors": props.get('multiProcessorCount', 0)
-            }
-        except Exception as e:
-            return {"available": False, "error": str(e)}

mining/difficulty.py

@@ -1,106 +0,0 @@
-# difficulty.py
-class DifficultySystem:
-    """9-tier difficulty system for mining and transactions"""
-    
-    def get_bill_difficulty(self, denomination):
-        """Get mining difficulty based on bill denomination - 9 tiers"""
-        if denomination <= 0:
-            return 1  # Handle negative/zero amounts
-        elif denomination <= 1:
-            return 1  # Trivial
-        elif denomination <= 10:
-            return 2  # Very Easy
-        elif denomination <= 100:
-            return 3  # Easy
-        elif denomination <= 1000:
-            return 4  # Moderate
-        elif denomination <= 10000:
-            return 5  # Standard
-        elif denomination <= 100000:
-            return 6  # Challenging
-        elif denomination <= 1000000:
-            return 7  # Hard
-        elif denomination <= 10000000:
-            return 8  # Very Hard
-        else:
-            return 9  # Extreme
-    
-    def get_transaction_difficulty(self, amount):
-        """Get transaction difficulty based on amount - 9 tiers"""
-        if amount <= 0:
-            return 1  # Handle negative/zero amounts
-        elif amount <= 0.001:
-            return 1  # Trivial
-        elif amount <= 0.01:
-            return 2  # Very Easy
-        elif amount <= 0.1:
-            return 3  # Easy
-        elif amount <= 1.0:
-            return 4  # Moderate
-        elif amount <= 10.0:
-            return 5  # Standard
-        elif amount <= 100.0:
-            return 6  # Challenging
-        elif amount <= 1000.0:
-            return 7  # Hard
-        elif amount <= 10000.0:
-            return 8  # Very Hard
-        else:
-            return 9  # Extreme
-    
-    def calculate_mining_reward(self, denomination, mining_time):
-        """Calculate mining reward with time-based bonus"""
-        if denomination <= 0:
-            return 0
-            
-        base_reward = denomination  # Full denomination as base reward
-        
-        # Time bonus - faster mining gets higher reward
-        if mining_time < 10:
-            time_bonus = 0.5  # 50% bonus for very fast mining
-        elif mining_time < 30:
-            time_bonus = 0.2  # 20% bonus for fast mining
-        else:
-            time_bonus = 0.0  # No bonus for slow mining
-            
-        return base_reward * (1 + time_bonus)
-    
-    def get_difficulty_name(self, difficulty_level):
-        """Get human-readable name for difficulty level"""
-        names = {
-            1: "Trivial",
-            2: "Very Easy", 
-            3: "Easy",
-            4: "Moderate",
-            5: "Standard",
-            6: "Challenging",
-            7: "Hard",
-            8: "Very Hard",
-            9: "Extreme"
-        }
-        return names.get(difficulty_level, "Unknown")
-    
-    def get_difficulty_color(self, difficulty_level):
-        """Get color representation for difficulty level"""
-        colors = {
-            1: "🟢",  # Green - Trivial
-            2: "🟢",  # Green - Very Easy
-            3: "🟡",  # Yellow - Easy
-            4: "🟡",  # Yellow - Moderate
-            5: "🟠",  # Orange - Standard
-            6: "🟠",  # Orange - Challenging
-            7: "🔴",  # Red - Hard
-            8: "🔴",  # Red - Very Hard
-            9: "💀"   # Skull - Extreme
-        }
-        return colors.get(difficulty_level, "⚫")
-    
-    def get_expected_mining_time(self, difficulty_level, hashrate=1000000):
-        """Get expected mining time in seconds based on difficulty and hashrate"""
-        if difficulty_level < 1 or difficulty_level > 9:
-            return float('inf')
-            
-        # Rough estimate: each difficulty level increases time by ~16x
-        base_time = 0.1  # base time for difficulty 1
-        time_multiplier = 16 ** (difficulty_level - 1)
-        return base_time * time_multiplier / max(1, hashrate / 1000000)

mining/miner.py

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

@@ -1,148 +0,0 @@
-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}")