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

gtx/genesis.py

@@ -1,338 +0,0 @@
-import time
-import hashlib
-import secrets
-import json
-from typing import Dict, List, Optional
-from .digital_bill import DigitalBill
-from .bill_registry import BillRegistry
-from mining.cuda_manager import CUDAManager
-from core.blockchain import BlockchainManager
-from transactions.transactions import TransactionManager
-class GTXGenesis:
-    """Main GTX Genesis system manager"""
-    
-    def __init__(self):
-        self.bill_registry = BillRegistry()
-        self.cuda_manager = CUDAManager()
-        self.valid_denominations = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000]
-    
-    def create_genesis_bill(self, denomination: int, user_address: str, 
-                          custom_data: Optional[Dict] = None) -> DigitalBill:
-        """Create a new GTX Genesis bill"""
-        if denomination not in self.valid_denominations:
-            raise ValueError(f"Invalid denomination. Must be one of: {self.valid_denominations}")
-        
-        bill_data = custom_data or {}
-        bill_data.update({
-            "creation_timestamp": time.time(),
-            "version": "1.0",
-            "asset_type": "GTX_Genesis"
-        })
-        
-        return DigitalBill(
-            denomination=denomination,
-            user_address=user_address,
-            difficulty=self._calculate_difficulty(denomination),
-            bill_data=bill_data
-        )
-    
-    def verify_bill(self, bill_serial):
-        """Verify GTX bill validity using the same logic as the web endpoint"""
-        try:
-            if not bill_serial or len(bill_serial) == 0:
-                return {'valid': False, 'error': 'Invalid bill serial'}
-            
-            # Look up the bill in your registry/database
-            bill_data = self.bill_registry.get_bill(bill_serial)
-            if not bill_data:
-                return {'valid': False, 'error': 'Bill not found in registry'}
-            
-            # Extract signature components (same as endpoint)
-            public_key = bill_data.get('public_key')
-            signature = bill_data.get('signature')
-            metadata_hash = bill_data.get('metadata_hash', '')
-            issued_to = bill_data.get('issued_to', '')
-            denomination = bill_data.get('denomination', '')
-            front_serial = bill_data.get('front_serial', '')
-            timestamp = bill_data.get('timestamp', 0)
-            bill_type = bill_data.get('type', 'GTX_Genesis')
-            
-            print(f"🔍 GTXGenesis.verify_bill() for {front_serial}:")
-            print(f"   Signature: {signature}")
-            print(f"   Public Key: {public_key}")
-            print(f"   Metadata Hash: {metadata_hash}")
-            
-            # Use the same verification logic as the endpoint
-            verification_method = "unknown"
-            signature_valid = None
-            
-            # METHOD 1: Check if signature matches metadata_hash directly
-            if metadata_hash and signature == metadata_hash:
-                signature_valid = True
-                verification_method = "signature_is_metadata_hash"
-                print(f"✅ Verified: signature matches metadata_hash")
-            
-            # METHOD 2: Check hash of public_key + metadata_hash
-            elif signature_valid is None and metadata_hash and public_key and signature:
-                verification_data = f"{public_key}{metadata_hash}"
-                expected_signature = hashlib.sha256(verification_data.encode()).hexdigest()
-                if signature == expected_signature:
-                    signature_valid = True
-                    verification_method = "metadata_hash_signature"
-                    print(f"✅ Verified: hash(public_key + metadata_hash)")
-            
-            # METHOD 3: Check DigitalBill calculated hash
-            elif signature_valid is None:
-                try:
-                    # Use the integrated DigitalBill class from your GTX system
-                    from gtx.digital_bill import DigitalBill  # Adjust import path as needed
-                    
-                    # Create DigitalBill object with the transaction data
-                    digital_bill = DigitalBill(
-                        denomination=float(denomination) if denomination.replace('.', '').isdigit() else 0,
-                        user_address=issued_to,
-                        difficulty=0,  # Not needed for verification
-                        bill_type=bill_type,
-                        front_serial=front_serial,
-                        back_serial=tx_data.get('back_serial', ''),
-                        metadata_hash=metadata_hash,
-                        public_key=public_key,
-                        signature=signature
-                    )
-                    
-                    # Set the timestamp from the transaction data
-                    digital_bill.timestamp = timestamp
-                    digital_bill.issued_to = issued_to
-                    
-                    # Try multiple verification approaches:
-                    
-                    # Approach 1: Check if signature matches calculate_hash()
-                    calculated_hash = digital_bill.calculate_hash()
-                    if signature == calculated_hash:
-                        signature_valid = True
-                        verification_method = "digital_bill_calculate_hash"
-                        print(f"✅ Verified: DigitalBill.calculate_hash()")
-                        print(f"   Calculated hash: {calculated_hash}")
-                    
-                    # Approach 2: Use the verify() method (checks all signature types)
-                    elif digital_bill.verify():
-                        signature_valid = True
-                        verification_method = "digital_bill_verify_method"
-                        print(f"✅ Verified: DigitalBill.verify()")
-                    
-                    # Approach 3: Check if signature matches metadata_hash generation
-                    elif signature == digital_bill._generate_metadata_hash():
-                        signature_valid = True
-                        verification_method = "digital_bill_metadata_hash"
-                        print(f"✅ Verified: matches generated metadata_hash")
-                    
-                    else:
-                        print(f"❌ DigitalBill verification failed:")
-                        print(f"   Calculated hash: {calculated_hash}")
-                        print(f"   Signature: {signature}")
-                        print(f"   Metadata hash: {metadata_hash}")
-                        print(f"   Public key: {public_key}")
-                        
-                except Exception as e:
-                    print(f"DigitalBill verification error: {e}")
-                    import traceback
-                    print(f"Traceback: {traceback.format_exc()}")
-            
-            # METHOD 4: Check simple concatenation hash
-            elif signature_valid is None and signature:
-                simple_data = f"{front_serial}{denomination}{issued_to}{timestamp}"
-                expected_simple_hash = hashlib.sha256(simple_data.encode()).hexdigest()
-                if signature == expected_simple_hash:
-                    signature_valid = True
-                    verification_method = "simple_hash"
-                    print(f"✅ Verified: hash(serial+denom+issued+timestamp)")
-            
-            # METHOD 5: Check bill JSON hash
-            elif signature_valid is None:
-                bill_dict = {
-                    'type': bill_type,
-                    'front_serial': front_serial,
-                    'issued_to': issued_to,
-                    'denomination': denomination,
-                    'timestamp': timestamp,
-                    'public_key': public_key
-                }
-                bill_json = json.dumps(bill_dict, sort_keys=True)
-                bill_json_hash = hashlib.sha256(bill_json.encode()).hexdigest()
-                if signature == bill_json_hash:
-                    signature_valid = True
-                    verification_method = "bill_json_hash"
-                    print(f"✅ Verified: hash(bill_data_json)")
-            
-            # Final fallback: accept any non-empty signature temporarily
-            if signature_valid is None and signature and len(signature) > 10:
-                signature_valid = True
-                verification_method = "fallback_accept"
-                print(f"⚠️  Using fallback acceptance for signature")
-            
-            # If all methods failed
-            if signature_valid is None:
-                signature_valid = False
-                verification_method = "all_failed"
-                print(f"❌ All verification methods failed")
-            
-            # Return result in same format as endpoint
-            if signature_valid:
-                return {
-                    'valid': True,
-                    'bill': bill_serial,
-                    'verification_method': verification_method,
-                    'signature_details': {
-                        'public_key_short': public_key[:20] + '...' if public_key else 'None',
-                        'signature_short': signature[:20] + '...' if signature else 'None',
-                        'timestamp': timestamp,
-                        'verification_method': verification_method
-                    }
-                }
-            else:
-                return {
-                    'valid': False,
-                    'error': f'Signature verification failed (method: {verification_method})',
-                    'details': {
-                        'serial': bill_serial,
-                        'verification_method': verification_method,
-                        'signature_exists': bool(signature and len(signature) > 0)
-                    }
-                }
-                
-        except Exception as e:
-            return {
-                'valid': False, 
-                'error': f'Verification error: {str(e)}',
-                'exception_type': type(e).__name__
-            }
-
-    def verify_digital_signature(self, bill_serial):
-        """Verify digital signature of a bill using LunaLib cryptography"""
-        try:
-            from core.crypto import verify_signature
-            from storage.cache import get_bill_data
-            
-            # Get bill data from cache or storage
-            bill_data = get_bill_data(bill_serial)
-            if not bill_data:
-                return False
-            
-            # Extract signature components
-            signature = bill_data.get('signature')
-            public_key = bill_data.get('public_key')
-            message = bill_data.get('message', bill_serial)
-            
-            if not signature or not public_key:
-                return False
-            
-            # Use LunaLib's actual signature verification
-            return verify_signature(
-                message=message,
-                signature=signature,
-                public_key=public_key
-            )
-            
-        except Exception:
-            return False
-
-    def get_transaction_by_serial(self, serial_number):
-        """Get transaction by serial number from blockchain"""
-        try:
-            from core.blockchain import BlockchainManager
-            blockchain_mgr = BlockchainManager()
-            
-            # Search through blockchain for this serial
-            for block in blockchain_mgr.get_chain():
-                for tx in block.get('transactions', []):
-                    if (tx.get('serial_number') == serial_number or 
-                        tx.get('id') == serial_number or
-                        tx.get('hash') == serial_number):
-                        return {
-                            'valid': True,
-                            'transaction': tx,
-                            'block_height': block.get('height'),
-                            'timestamp': tx.get('timestamp')
-                        }
-            return None
-        except Exception:
-            return None
-    
-    def get_user_portfolio(self, user_address: str) -> Dict:
-        """Get user's GTX Genesis portfolio"""
-        bills = self.bill_registry.get_user_bills(user_address)
-        total_value = sum(bill['luna_value'] for bill in bills)
-        
-        return {
-            "user_address": user_address,
-            "total_bills": len(bills),
-            "total_luna_value": total_value,
-            "bills": bills,
-            "breakdown": self._get_denomination_breakdown(bills)
-        }
-    
-    def transfer_bill(self, bill_serial: str, from_address: str, to_address: str, 
-                     private_key: str) -> bool:
-        """Transfer GTX Genesis bill to another address"""
-        # Verify ownership
-        bill = self.bill_registry.get_bill(bill_serial)
-        if not bill or bill['user_address'].lower() != from_address.lower():
-            return False
-        
-        # In a real implementation, you'd verify the signature
-        # For now, we'll update the registry
-        return self.bill_registry.transfer_bill(bill_serial, to_address)
-    
-    def _calculate_difficulty(self, denomination: int) -> int:
-        """Calculate mining difficulty based on denomination"""
-        # Logarithmic scaling: higher denominations = more zeros
-        if denomination <= 1:
-            return 2
-        elif denomination <= 10:
-            return 3
-        elif denomination <= 100:
-            return 4
-        elif denomination <= 1000:
-            return 5
-        elif denomination <= 10000:
-            return 6
-        elif denomination <= 100000:
-            return 7
-        elif denomination <= 1000000:
-            return 8
-        elif denomination <= 10000000:
-            return 9
-        else:
-            return 10
-    
-    def _verify_bill_crypto(self, bill_info: Dict) -> bool:
-        """Verify bill cryptographic integrity"""
-        try:
-            # Recreate mining data
-            mining_data = {
-                "type": "GTX_Genesis",
-                "denomination": bill_info['denomination'],
-                "user_address": bill_info['user_address'],
-                "bill_serial": bill_info['bill_serial'],
-                "timestamp": bill_info['timestamp'],
-                "difficulty": bill_info['difficulty'],
-                "nonce": bill_info['nonce']
-            }
-            
-            # Verify hash matches
-            data_string = json.dumps(mining_data, sort_keys=True)
-            computed_hash = hashlib.sha256(data_string.encode()).hexdigest()
-            
-            return computed_hash == bill_info['hash']
-            
-        except Exception as e:
-            print(f"Bill verification error: {e}")
-            return False
-    
-    def _get_denomination_breakdown(self, bills: List[Dict]) -> Dict[int, int]:
-        """Get breakdown of bills by denomination"""
-        breakdown = {}
-        for bill in bills:
-            denom = bill['denomination']
-            breakdown[denom] = breakdown.get(denom, 0) + 1
-        return breakdown

lunalib/requirements.txt

@@ -1,44 +0,0 @@
-# Core dependencies
-requests>=2.31.0                    # HTTP requests for blockchain API calls
-cryptography>=41.0.0                # Encryption for wallet security
-qrcode[pil]>=7.4.0                  # QR code generation for addresses
-Pillow>=10.0.0                      # Image processing for QR codes
-
-# Development and testing
-pytest>=7.4.0                       # Test framework
-pytest-cov>=4.1.0                   # Test coverage
-pytest-mock>=3.11.0                 # Mocking for tests
-coverage>=7.0.0                     # Coverage reporting
-
-# Code quality and formatting
-black>=23.0.0                       # Code formatting
-flake8>=6.0.0                       # Linting
-mypy>=1.5.0                         # Type checking
-isort>=5.12.0                       # Import sorting
-bandit>=1.7.0                       # Security scanning
-
-# Packaging and distribution
-build>=0.10.0                       # Package building
-twine>=4.0.0                        # Package uploading
-
-# Documentation
-sphinx>=7.0.0                       # Documentation generation
-sphinx-rtd-theme>=1.3.0             # ReadTheDocs theme
-
-# Type stubs for better IDE support
-types-requests>=2.31.0
-typing-extensions>=4.8.0            # Additional type hints
-
-# Optional GPU acceleration (choose one based on your hardware)
-# Uncomment the appropriate line for your setup:
-
-# NVIDIA CUDA 12.x (latest)
-#cupy-cuda12x>=12.0.0
-
-# NVIDIA CUDA 11.x
-# cupy-cuda11x>=11.0.0
-
-# AMD ROCm
-# cupy-rocm-5-0>=12.0.0
-
-# CPU-only fallback (slower but works everywhere)

lunalib-1.5.0.dist-info/METADATA

@@ -1,283 +0,0 @@
-Metadata-Version: 2.4
-Name: lunalib
-Version: 1.5.0
-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