lunalib 1.5.1__py3-none-any.whl → 1.7.2__py3-none-any.whl

lunalib-1.5.1.dist-info/METADATA

@@ -1,283 +0,0 @@
-Metadata-Version: 2.4
-Name: lunalib
-Version: 1.5.1
-Summary: A Complete Cryptocurrency Wallet and Mining System
-Home-page: https://github.com/taellinglin/LunaLib
-Author: Ling Lin
-Author-email: taellinglin@gmail.com
-License: MIT
-Project-URL: Bug Tracker, https://github.com/taellinglin/LunaLib/issues
-Project-URL: Documentation, https://linglin.art/docs/luna-lib
-Project-URL: Source Code, https://github.com/taellinglin/LunaLib
-Keywords: cryptocurrency,blockchain,wallet,mining,bitcoin,ethereum,crypto
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Topic :: Security :: Cryptography
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Office/Business :: Financial
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Requires-Dist: requests>=2.31.0
-Requires-Dist: cryptography>=41.0.0
-Requires-Dist: qrcode[pil]>=7.4.0
-Requires-Dist: Pillow>=10.0.0
-Requires-Dist: pytest>=7.4.0
-Requires-Dist: pytest-cov>=4.1.0
-Requires-Dist: pytest-mock>=3.11.0
-Requires-Dist: coverage>=7.0.0
-Requires-Dist: black>=23.0.0
-Requires-Dist: flake8>=6.0.0
-Requires-Dist: mypy>=1.5.0
-Requires-Dist: isort>=5.12.0
-Requires-Dist: bandit>=1.7.0
-Requires-Dist: build>=0.10.0
-Requires-Dist: twine>=4.0.0
-Requires-Dist: sphinx>=7.0.0
-Requires-Dist: sphinx-rtd-theme>=1.3.0
-Requires-Dist: types-requests>=2.31.0
-Requires-Dist: typing-extensions>=4.8.0
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license
-Dynamic: project-url
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Luna Library
-
-**A Complete Cryptocurrency Wallet and Mining System**  
-*Developed by Ling Lin • [LingLin.Art](https://linglin.art) • LingLin.Art, LLC*
-
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Python 3.7+](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)
-[![Version](https://img.shields.io/badge/version-1.0.0-green.svg)]()
-
-## 🌟 Overview
-
-Luna Library is a comprehensive cryptocurrency system featuring secure wallet management, GTX Genesis digital bill mining, and blockchain transaction processing. Built with security and performance in mind, it provides the foundation for cryptocurrency applications including wallets, casinos, nodes, and treasury systems.
-
-## 🚀 Features
-
-### 💰 Wallet Management
-- **Secure Key Generation**: Cryptographically secure private/public key pairs
-- **Encrypted Storage**: AES-256 encrypted wallet files with password protection
-- **Multi-Wallet Support**: Manage multiple wallets with individual labels
-- **Import/Export**: Backup and restore wallets using private keys
-- **Transaction History**: Complete transaction tracking and balance management
-
-### ⛏️ GTX Genesis Mining
-- **Digital Bill Mining**: Mine GTX Genesis bills with denomination-based difficulty
-- **Proof-of-Work**: Configurable difficulty (2-10 leading zeros) based on bill value
-- **CUDA Acceleration**: GPU-accelerated mining for improved performance
-- **Bill Registry**: Track mined bills with verification URLs and metadata
-- **1:1 Luna Value**: Each GTX bill denomination equals equivalent Luna value
-
-### 🔗 Blockchain Integration
-- **Network Connectivity**: Connect to Luna blockchain nodes
-- **Transaction Broadcasting**: Send signed transactions to the network
-- **Blockchain Scanning**: Efficient blockchain scanning for address activity
-- **Mempool Monitoring**: Real-time transaction pool monitoring
-- **Caching System**: Optimized caching for improved performance
-
-### 🔒 Security & Validation
-- **Cryptographic Signing**: Secure transaction signing with ECDSA
-- **Transaction Validation**: Comprehensive security validation for all transaction types
-- **Anti-Spam Protection**: Rate limiting and blacklisting capabilities
-- **Risk Assessment**: Transaction risk level evaluation
-- **Network Security**: Protection against malicious activities
-
-## 📦 Installation
-
-### Prerequisites
-- Python 3.7 or higher
-- pip (Python package manager)
-
-### Install from Source
-
-1. **Clone the repository**:
-```bash
-git clone https://github.com/linglin-art/luna_lib.git
-cd luna_lib
-```
-2. **Install Requirements**
-```bash
-pip install -r requirements.txt
-```
-3. **Install with Pip**
-```bash
-pip install -e .
-```
-Optional: **CUDA Support**
-```bash
-Optional: CUDA Support
-
-For GPU-accelerated mining, install CUDA dependencies:
-```
-
-
-## Basic Usage:
-
-```python
-from luna_lib import LunaWallet, GenesisMiner, GTXGenesis
-
-# Create a new wallet
-wallet = LunaWallet()
-wallet_data = wallet.create_wallet("My Wallet", "secure_password")
-
-print(f"Wallet created: {wallet_data['address']}")
-
-# Initialize miner
-miner = GenesisMiner()
-
-# Mine a GTX $1000 bill
-bill = miner.mine_bill(1000, wallet_data['address'])
-
-if bill['success']:
-    print(f"✅ Mined GTX ${bill['denomination']:,} bill!")
-    print(f"💰 Luna value: {bill['luna_value']:,}")
-    print(f"🔗 Verification: {bill.get('verification_url', 'N/A')}")
-```
-    
-## Advanced Usage
-```python
-from luna_lib import GTXGenesis, BlockchainManager
-from luna_lib.gtx.bill_registry import BillRegistry
-
-# Check GTX portfolio
-gtx = GTXGenesis()
-portfolio = gtx.get_user_portfolio(wallet_data['address'])
-
-print(f"Total GTX bills: {portfolio['total_bills']}")
-print(f"Total Luna value: {portfolio['total_luna_value']:,}")
-
-# Scan blockchain for transactions
-blockchain = BlockchainManager()
-transactions = blockchain.scan_transactions_for_address(wallet_data['address'])
-
-print(f"Found {len(transactions)} transactions")
-
-```
-## Project Structure
-
-```
-luna_lib/
-├── core/              # Core wallet and blockchain functionality
-│   ├── wallet.py      # Wallet management
-│   ├── blockchain.py  # Blockchain interactions
-│   └── crypto.py      # Cryptographic operations
-├── mining/            # Mining-related components
-│   ├── miner.py       # Genesis bill miner
-│   ├── difficulty.py  # Difficulty calculations
-│   └── cuda_manager.py # GPU acceleration
-├── gtx/               # GTX Genesis system
-│   ├── genesis.py     # Main GTX manager
-│   ├── digital_bill.py # Digital bill representation
-│   └── bill_registry.py # Bill database
-├── transactions/      # Transaction processing
-│   ├── transaction.py # Transaction creation
-│   ├── security.py    # Security validation
-│   └── validator.py   # Transaction validation
-└── storage/           # Data storage
-    ├── database.py    # Wallet database
-    ├── cache.py       # Blockchain cache
-    └── encryption.py  # Encryption utilities
-
-```
-
-# **API Reference**
-Core Classes
-
-    LunaWallet: Main wallet management class
-
-    GenesisMiner: GTX Genesis bill mining
-
-    GTXGenesis: GTX bill management and verification
-
-    BlockchainManager: Blockchain interactions
-
-    TransactionManager: Transaction creation and signing
-
-## ***Key Methods***
-### **Wallet Management**
-```python
-wallet.create_wallet(label, password)  # Create new wallet
-wallet.unlock_wallet(address, password)  # Unlock existing wallet
-wallet.export_private_key(address, password)  # Export private key
-```
-
-## ***Mining***
-```python
-miner.mine_bill(denomination, address)  # Mine single bill
-miner.start_auto_mining(denominations, address)  # Auto-mine multiple bills
-miner.stop_mining()  # Stop mining operations
-```
-
-## **GTX Management**
-
-```python
-gtx.verify_bill(bill_serial)  # Verify bill authenticity
-gtx.get_user_portfolio(address)  # Get user's GTX portfolio
-gtx.transfer_bill(bill_serial, from_addr, to_addr, priv_key)  # Transfer bill
-```
-# Configuration
-## **Environment Variables**
-
-```bash
-export LUNA_ENDPOINT_URL="https://bank.linglin.art"  # Blockchain endpoint
-export LUNA_DATA_DIR="$HOME/.luna_wallet"  # Data directory
-```
-
-## **Bill Denominations**
-
-Supported GTX Genesis bill denominations:
-```bash
-  $1 (Difficulty: 2 zeros)
-  $10 (Difficulty: 3 zeros)
-  $100 (Difficulty: 4 zeros)
-  $1,000 (Difficulty: 5 zeros)
-  $10,000 (Difficulty: 6 zeros)
-  $100,000 (Difficulty: 7 zeros)
-  $1,000,000 (Difficulty: 8 zeros)
-  $10,000,000 (Difficulty: 9 zeros)
-  $100,000,000 (Difficulty: 10 zeros)
-```
-
-### **Contributing**
-
-We welcome contributions! Please see our Contributing Guidelines for details.
-
-   - Fork the repository
-
-   - Create a feature branch (git checkout -b feature/amazing-feature)
-
-   - Commit your changes (git commit -m 'Add amazing feature')
-
-   - Push to the branch (git push origin feature/amazing-feature)
-
-   - Open a Pull Request
-
-## License
-  This project is licensed under the MIT License - see the LICENSE file for details.
-
-### Support
-
-    Email: taellinglin@gmail.com
-    Website: LingLin.Art
-
-    Built with ❤️ by Ling Lin and the LingLin.Art, LLC team
-
-Luna Library • Empowering the future of digital currency • LingLin.Art

lunalib-1.5.1.dist-info/RECORD

@@ -1,53 +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=lyOfnaFZ1lms03AffERqYoBoonHQxB1Jb-MrUXMzZSU,16558
-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=gnlYSU1CIaa38bxByfKHlMpt8GMYpvib0EboVfNESek,36568
-lunalib/core/crypto.py,sha256=R_f2sj7ASNnMW8Dtf2LIWTw-vCUjXD33zJPqPcPQVB8,10684
-lunalib/core/mempool.py,sha256=itYFGQEuUde0Xh6WXcEz_n8hDsNhxkEAlRQ5g_Qiygg,14845
-lunalib/core/sm2.py,sha256=8GHbJkrEwil_yoemUaDWAbcY_gm7Ld2WC7SpzUkpcRU,24177
-lunalib/core/wallet.py,sha256=RNrEI7_tsaJOLcCJoTy_lLj22bc_bJtoO7iR3C3u7Ls,57435
-lunalib/core/wallet_manager.py,sha256=ZyIy4OUaKv6kKmD3-jLof4vyhV-4opNmFk5ZWcLJAm0,26669
-lunalib/core/wallet_sync_helper.py,sha256=hdZLUObaOVX7el5o9Nua2zUhOvEhAhdpbUNRpxnNwUw,6445
-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=jX4Eh4igQtiwVDhmoDGcm1tae2DRVS-JyLrRnn-n200,9924
-lunalib/transactions/transactions.py,sha256=3kLOILnuN54seif17zMxx8NH8vkDPDTI_Rdtv4FDKmc,17611
-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=NiNshlf6RFFbmxgRzpYy7K1btUJpHtI1Kx747D_xRjw,17667
-transactions/validator.py,sha256=FQ-jVjj8VoVTlq65blB_hprAwJOtpc2peYdQk_L2xmg,2730
-lunalib-1.5.1.dist-info/METADATA,sha256=Win-29gD351YAShOlGVfUfD6ACp0DKms6ILIhkC91pY,9689
-lunalib-1.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lunalib-1.5.1.dist-info/entry_points.txt,sha256=bdt2wU-9FZOkmQ2pSy46WrxJSkpRPhVDkRFL1K_kakQ,49
-lunalib-1.5.1.dist-info/top_level.txt,sha256=jEsGPJDTyYkwfmrSSw1GvJ1UxcPvChzv0s6xx-PvaXg,45
-lunalib-1.5.1.dist-info/RECORD,,

lunalib-1.5.1.dist-info/entry_points.txt

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

lunalib-1.5.1.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)