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

gtx/digital_bill.py

@@ -1,273 +0,0 @@
-import time
-import hashlib
-import secrets
-import json
-import base64
-from typing import Dict, Optional
-
-try:
-    from cryptography.hazmat.primitives import hashes
-    from cryptography.hazmat.primitives.asymmetric import rsa, padding
-    from cryptography.hazmat.primitives import serialization
-    from cryptography.exceptions import InvalidSignature
-    CRYPTOGRAPHY_AVAILABLE = True
-except ImportError:
-    print("Warning: cryptography library not available. Using fallback methods.")
-    CRYPTOGRAPHY_AVAILABLE = False
-
-from .bill_registry import BillRegistry
-
-class DigitalBill:
-    """Represents a GTX Genesis digital bill with cryptographic signatures"""
-    
-    def __init__(self, denomination, user_address, difficulty, bill_data=None, 
-                 bill_type="GTX_Genesis", front_serial=None, back_serial=None, 
-                 metadata_hash=None, public_key=None, signature=None):
-        # GTX Genesis properties
-        self.denomination = denomination
-        self.user_address = user_address
-        self.difficulty = difficulty
-        self.bill_data = bill_data or {}
-        self.bill_serial = front_serial or self._generate_serial()
-        self.created_time = time.time()
-        self.bill_registry = BillRegistry()
-        
-        # Signature properties
-        self.bill_type = bill_type
-        self.front_serial = front_serial or self.bill_serial
-        self.back_serial = back_serial or ""
-        self.metadata_hash = metadata_hash or self._generate_metadata_hash()
-        self.timestamp = self.created_time
-        self.issued_to = user_address
-        self.public_key = public_key
-        self.signature = signature
-    
-    def _generate_serial(self):
-        """Generate unique bill serial number"""
-        timestamp = int(time.time() * 1000)
-        random_part = secrets.token_hex(4)
-        return f"GTX{self.denomination}_{timestamp}_{random_part}"
-    
-    def _generate_metadata_hash(self):
-        """Generate metadata hash for the bill"""
-        metadata = {
-            "denomination": self.denomination,
-            "user_address": self.user_address,
-            "difficulty": self.difficulty,
-            "timestamp": self.created_time,
-            "bill_serial": self.bill_serial
-        }
-        return hashlib.sha256(json.dumps(metadata, sort_keys=True).encode()).hexdigest()
-    
-    def get_mining_data(self, nonce):
-        """Get data for mining computation"""
-        return {
-            "type": "GTX_Genesis",
-            "denomination": self.denomination,
-            "user_address": self.user_address,
-            "bill_serial": self.bill_serial,
-            "timestamp": self.created_time,
-            "difficulty": self.difficulty,
-            "previous_hash": self._get_previous_hash(),
-            "nonce": nonce,
-            "bill_data": self.bill_data
-        }
-    
-    def finalize(self, hash, nonce, mining_time, private_key=None):
-        """Finalize bill after successful mining with optional signing"""
-        # Create transaction data
-        transaction_data = {
-            "type": "GTX_Genesis",
-            "from": "genesis_network",
-            "to": self.user_address,
-            "amount": self.denomination,
-            "bill_serial": self.bill_serial,
-            "mining_difficulty": self.difficulty,
-            "mining_time": mining_time,
-            "hash": hash,
-            "timestamp": time.time(),
-            "status": "mined",
-            "front_serial": self.front_serial,
-            "issued_to": self.user_address,
-            "denomination": self.denomination,
-            "metadata_hash": self.metadata_hash
-        }
-        
-        # Generate signature if private key provided
-        if private_key:
-            self.sign(private_key)
-            transaction_data.update({
-                "public_key": self.public_key,
-                "signature": self.signature
-            })
-        
-        bill_info = {
-            "success": True,
-            "bill_serial": self.bill_serial,
-            "denomination": self.denomination,
-            "user_address": self.user_address,
-            "mining_time": mining_time,
-            "difficulty": self.difficulty,
-            "hash": hash,
-            "nonce": nonce,
-            "timestamp": time.time(),
-            "luna_value": self.denomination,  # 1:1 ratio
-            "transaction_data": transaction_data
-        }
-        
-        # Add to bill registry
-        self.bill_registry.register_bill(bill_info)
-        
-        return bill_info
-    
-    def _get_previous_hash(self):
-        """Get hash of previous genesis transaction"""
-        # In production, this would query the blockchain
-        return hashlib.sha256(str(time.time()).encode()).hexdigest()
-    
-    # Signature methods from your signatures.py
-    def to_dict(self):
-        """Convert bill data to dictionary for hashing/serialization"""
-        return {
-            'type': self.bill_type,
-            'front_serial': self.front_serial,
-            'back_serial': self.back_serial,
-            'metadata_hash': self.metadata_hash,
-            'timestamp': self.timestamp,
-            'issued_to': self.issued_to,
-            'denomination': self.denomination
-        }
-    
-    def calculate_hash(self):
-        """Calculate SHA-256 hash of the bill data"""
-        bill_string = json.dumps(self.to_dict(), sort_keys=True)
-        return hashlib.sha256(bill_string.encode()).hexdigest()
-    
-    def sign(self, private_key):
-        """Sign the bill data with a private key"""
-        if not CRYPTOGRAPHY_AVAILABLE:
-            return self._sign_fallback(private_key)
-            
-        bill_hash = self.calculate_hash()
-        
-        try:
-            # Load private key if it's in string format
-            if isinstance(private_key, str):
-                private_key_obj = serialization.load_pem_private_key(
-                    private_key.encode('utf-8'),
-                    password=None
-                )
-            else:
-                private_key_obj = private_key
-            
-            # Sign the hash
-            signature = private_key_obj.sign(
-                bill_hash.encode(),
-                padding.PSS(
-                    mgf=padding.MGF1(hashes.SHA256()),
-                    salt_length=padding.PSS.MAX_LENGTH
-                ),
-                hashes.SHA256()
-            )
-            
-            self.signature = base64.b64encode(signature).decode('utf-8')
-            
-            # Set public key
-            public_key = private_key_obj.public_key()
-            public_pem = public_key.public_bytes(
-                encoding=serialization.Encoding.PEM,
-                format=serialization.PublicFormat.SubjectPublicKeyInfo
-            )
-            self.public_key = public_pem.decode('utf-8')
-            
-            return self.signature
-        except Exception as e:
-            print(f"Cryptographic signing failed, using fallback: {e}")
-            return self._sign_fallback(private_key)
-    
-    def _sign_fallback(self, private_key):
-        """Fallback signing method using hashes"""
-        bill_hash = self.calculate_hash()
-        # Simple hash-based "signature" for when cryptography is unavailable
-        if isinstance(private_key, str):
-            signature_input = f"{private_key}{bill_hash}"
-        else:
-            signature_input = f"fallback_key{bill_hash}"
-        
-        self.signature = hashlib.sha256(signature_input.encode()).hexdigest()
-        
-        # Set fallback public key
-        if isinstance(private_key, str) and len(private_key) > 32:
-            self.public_key = hashlib.sha256(private_key.encode()).hexdigest()
-        else:
-            self.public_key = "fallback_public_key"
-        
-        return self.signature
-    
-    def verify(self):
-        """Verify signature using the exact same method as creation"""
-        if not self.public_key or not self.signature:
-            return False
-            
-        # Handle mock signatures
-        if self.signature.startswith('mock_signature_'):
-            expected_mock = 'mock_signature_' + hashlib.md5(
-                f"{self.issued_to}{self.denomination}{self.front_serial}".encode()
-            ).hexdigest()
-            return self.signature == expected_mock
-        
-        # Handle fallback signatures
-        if self.public_key == 'fallback_public_key':
-            expected_fallback = hashlib.sha256(
-                f"{self.issued_to}{self.denomination}{self.front_serial}{self.timestamp}".encode()
-            ).hexdigest()
-            return self.signature == expected_fallback
-        
-        # Handle metadata_hash based signatures
-        if self.metadata_hash:
-            verification_data = f"{self.public_key}{self.metadata_hash}"
-            expected_signature = hashlib.sha256(verification_data.encode()).hexdigest()
-            return self.signature == expected_signature
-        
-        # Final fallback - accept any signature that looks valid
-        return len(self.signature) > 0
-    
-    @staticmethod
-    def generate_key_pair():
-        """Generate a new RSA key pair for signing"""
-        if not CRYPTOGRAPHY_AVAILABLE:
-            return DigitalBill._generate_fallback_key_pair()
-            
-        private_key = rsa.generate_private_key(
-            public_exponent=65537,
-            key_size=2048
-        )
-        
-        # Get public key
-        public_key = private_key.public_key()
-        
-        # Serialize keys
-        private_pem = private_key.private_bytes(
-            encoding=serialization.Encoding.PEM,
-            format=serialization.PrivateFormat.PKCS8,
-            encryption_algorithm=serialization.NoEncryption()
-        )
-        
-        public_pem = public_key.public_bytes(
-            encoding=serialization.Encoding.PEM,
-            format=serialization.PublicFormat.SubjectPublicKeyInfo
-        )
-        
-        return private_pem.decode('utf-8'), public_pem.decode('utf-8')
-    
-    @staticmethod
-    def _generate_fallback_key_pair():
-        """Generate fallback key pair using hashes"""
-        import random
-        import string
-        
-        # Generate random strings as "keys"
-        private_key = ''.join(random.choices(string.ascii_letters + string.digits, k=64))
-        public_key = hashlib.sha256(private_key.encode()).hexdigest()
-        
-        return private_key, public_key

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)