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

transactions/security.py

@@ -1,172 +0,0 @@
-import time
-import hashlib
-from typing import Dict, Tuple
-
-class TransactionSecurity:
-    """Enhanced transaction security system"""
-    
-    def __init__(self):
-        self.min_transaction_amount = 0.000001
-        self.max_transaction_amount = 100000000
-        self.required_fee = 0.00001
-        self.rate_limits = {}
-        self.blacklisted_addresses = set()
-    
-    def validate_transaction_security(self, transaction: Dict) -> Tuple[bool, str]:
-        """Comprehensive transaction security validation"""
-        tx_type = transaction.get("type", "").lower()
-        
-        if tx_type == "gtx_genesis":
-            return self._validate_genesis_transaction(transaction)
-        elif tx_type == "reward":
-            return self._validate_reward_transaction(transaction)
-        elif tx_type == "transfer":
-            return self._validate_transfer_transaction(transaction)
-        else:
-            return False, f"Unknown transaction type: {tx_type}"
-    
-    def _validate_genesis_transaction(self, transaction: Dict) -> Tuple[bool, str]:
-        """Validate GTX Genesis transaction"""
-        required_fields = ["bill_serial", "denomination", "mining_difficulty", "hash", "nonce"]
-        for field in required_fields:
-            if field not in transaction:
-                return False, f"Missing GTX field: {field}"
-        
-        # Validate denomination
-        denomination = transaction.get("denomination")
-        valid_denominations = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000]
-        if denomination not in valid_denominations:
-            return False, f"Invalid denomination: {denomination}"
-        
-        # Validate mining proof
-        if not self._validate_mining_proof(transaction):
-            return False, "Invalid mining proof"
-        
-        return True, "Valid GTX Genesis transaction"
-    
-    def _validate_reward_transaction(self, transaction: Dict) -> Tuple[bool, str]:
-        """Validate reward transaction"""
-        required_fields = ["from", "to", "amount", "block_height", "hash"]
-        for field in required_fields:
-            if field not in transaction:
-                return False, f"Missing reward field: {field}"
-        
-        # Only network can create rewards
-        if transaction.get("from") != "network":
-            return False, "Unauthorized reward creation"
-        
-        return True, "Valid reward transaction"
-    
-    def _validate_transfer_transaction(self, transaction: Dict) -> Tuple[bool, str]:
-        """Validate transfer transaction"""
-        required_fields = ["from", "to", "amount", "signature", "public_key", "nonce"]
-        for field in required_fields:
-            if field not in transaction:
-                return False, f"Missing field: {field}"
-        
-        # Amount validation
-        amount = transaction.get("amount", 0)
-        if amount < self.min_transaction_amount:
-            return False, f"Amount below minimum: {self.min_transaction_amount}"
-        if amount > self.max_transaction_amount:
-            return False, f"Amount above maximum: {self.max_transaction_amount}"
-        
-        # Fee validation
-        fee = transaction.get("fee", 0)
-        if fee < self.required_fee:
-            return False, f"Insufficient fee: {fee} (required: {self.required_fee})"
-        
-        # Signature validation
-        if not self._validate_signature(transaction):
-            return False, "Invalid signature"
-        
-        # Anti-spam checks
-        from_address = transaction.get("from", "")
-        if not self._check_rate_limit(from_address):
-            return False, "Rate limit exceeded"
-        
-        if self._is_blacklisted(from_address):
-            return False, "Address is blacklisted"
-        
-        return True, "Valid transfer transaction"
-    
-    def _validate_mining_proof(self, transaction: Dict) -> bool:
-        """Validate mining proof-of-work"""
-        try:
-            difficulty = transaction.get("mining_difficulty", 0)
-            bill_hash = transaction.get("hash", "")
-            
-            # Verify difficulty requirement
-            target = "0" * difficulty
-            return bill_hash.startswith(target)
-        except:
-            return False
-    
-    def _validate_signature(self, transaction: Dict) -> bool:
-        """Validate transaction signature"""
-        try:
-            signature = transaction.get("signature", "")
-            public_key = transaction.get("public_key", "")
-            
-            # Basic format validation
-            if len(signature) != 64:
-                return False
-            
-            # In production, use proper ECDSA verification
-            # For now, simplified check
-            return all(c in "0123456789abcdef" for c in signature.lower())
-        except:
-            return False
-    
-    def _check_rate_limit(self, address: str) -> bool:
-        """Check transaction rate limiting"""
-        now = time.time()
-        
-        if address not in self.rate_limits:
-            self.rate_limits[address] = []
-        
-        # Remove old entries (older than 1 minute)
-        self.rate_limits[address] = [t for t in self.rate_limits[address] if now - t < 60]
-        
-        # Check if over limit (10 transactions per minute)
-        if len(self.rate_limits[address]) >= 10:
-            return False
-        
-        self.rate_limits[address].append(now)
-        return True
-    
-    def _is_blacklisted(self, address: str) -> bool:
-        """Check if address is blacklisted"""
-        return address.lower() in self.blacklisted_addresses
-    
-    def blacklist_address(self, address: str):
-        """Add address to blacklist"""
-        self.blacklisted_addresses.add(address.lower())
-    
-    def calculate_security_score(self, transaction: Dict) -> int:
-        """Calculate security score for transaction"""
-        score = 0
-        
-        # Signature strength
-        signature = transaction.get("signature", "")
-        if len(signature) == 64:
-            score += 40
-        
-        # Public key presence
-        if transaction.get("public_key"):
-            score += 20
-        
-        # Timestamp freshness
-        timestamp = transaction.get("timestamp", 0)
-        if time.time() - timestamp < 600:  # 10 minutes
-            score += 20
-        
-        # Nonce uniqueness
-        if transaction.get("nonce"):
-            score += 10
-        
-        # Additional security features
-        if transaction.get("security_hash"):
-            score += 10
-        
-        return min(score, 100)

transactions/transactions.py

@@ -1,424 +0,0 @@
-import time
-import hashlib
-import json
-from typing import Dict, Optional, Tuple, List
-
-class TransactionSecurity:
-    """Transaction security validation and risk assessment"""
-    
-    def validate_transaction(self, transaction: Dict) -> Tuple[bool, str]:
-        """Validate transaction structure"""
-        required_fields = ['from', 'to', 'amount', 'timestamp']
-        for field in required_fields:
-            if field not in transaction:
-                return False, f'Missing required field: {field}'
-        
-        # Validate amount
-        if transaction['amount'] <= 0:
-            return False, 'Amount must be positive'
-            
-        return True, 'Valid'
-    
-    def validate_transaction_security(self, transaction: Dict) -> Tuple[bool, str]:
-        """Enhanced security validation"""
-        required_fields = ['from', 'to', 'amount', 'timestamp', 'type']
-        for field in required_fields:
-            if field not in transaction:
-                return False, f'Missing required field: {field}'
-        
-        # Validate amount
-        if transaction['amount'] <= 0:
-            return False, 'Invalid amount'
-            
-        return True, 'Secure'
-    
-    def assess_risk(self, transaction: Dict) -> Tuple[str, str]:
-        """Assess transaction risk level"""
-        amount = transaction.get('amount', 0)
-        
-        if amount > 100000:
-            return 'high', 'Large transaction amount'
-        elif amount > 10000:
-            return 'medium', 'Medium transaction amount'
-        else:
-            return 'low', 'Normal transaction'
-
-class KeyManager:
-    """Key management for transaction signing"""
-    
-    def derive_public_key(self, private_key: str) -> str:
-        """Derive public key from private key"""
-        if not private_key:
-            return "default_public_key"
-        return f"pub_{private_key[-16:]}"
-    
-    def sign_data(self, data: str, private_key: str) -> str:
-        """Sign data with private key"""
-        if not private_key:
-            return "default_signature"
-        return hashlib.sha256(f"{data}{private_key}".encode()).hexdigest()
-
-class FeePoolManager:
-    """Decentralized fee pool management"""
-    
-    def __init__(self):
-        self.fee_pool_address = self._generate_fee_pool_address()
-        self.pending_fees = 0.0
-        self.distribution_blocks = 100  # Distribute fees every 100 blocks
-        self.last_distribution_block = 0
-        
-    def _generate_fee_pool_address(self) -> str:
-        """Generate deterministic fee pool address"""
-        base_data = "LUNA_FEE_POOL_V1"
-        return hashlib.sha256(base_data.encode()).hexdigest()[:32]
-    
-    def collect_fee(self, fee_amount: float, transaction_hash: str) -> bool:
-        """Collect fee into the pool"""
-        if fee_amount > 0:
-            self.pending_fees += fee_amount
-            return True
-        return False
-    
-    def should_distribute(self, current_block_height: int) -> bool:
-        """Check if it's time to distribute fees"""
-        return (current_block_height - self.last_distribution_block) >= self.distribution_blocks
-    
-    def calculate_rewards(self, stakers: List[Dict], total_stake: float) -> List[Dict]:
-        """Calculate rewards for stakers based on their stake"""
-        if total_stake <= 0 or self.pending_fees <= 0:
-            return []
-            
-        rewards = []
-        for staker in stakers:
-            stake_amount = staker.get('stake', 0)
-            if stake_amount > 0:
-                share = stake_amount / total_stake
-                reward = self.pending_fees * share
-                rewards.append({
-                    'address': staker['address'],
-                    'reward': reward,
-                    'stake_share': share
-                })
-        
-        return rewards
-    
-    def create_distribution_transactions(self, current_block_height: int, 
-                                      stakers: List[Dict], total_stake: float) -> List[Dict]:
-        """Create fee distribution transactions to stakers"""
-        if not self.should_distribute(current_block_height) or self.pending_fees <= 0:
-            return []
-        
-        rewards = self.calculate_rewards(stakers, total_stake)
-        distribution_txs = []
-        
-        for reward_info in rewards:
-            distribution_tx = {
-                "type": "fee_distribution",
-                "from": self.fee_pool_address,
-                "to": reward_info['address'],
-                "amount": reward_info['reward'],
-                "fee": 0.0,
-                "block_height": current_block_height,
-                "distribution_cycle": current_block_height // self.distribution_blocks,
-                "stake_share": reward_info['stake_share'],
-                "timestamp": time.time(),
-                "hash": self._generate_distribution_hash(reward_info['address'], reward_info['reward'], current_block_height)
-            }
-            distribution_txs.append(distribution_tx)
-        
-        # Reset pending fees after distribution
-        self.pending_fees = 0.0
-        self.last_distribution_block = current_block_height
-        
-        return distribution_txs
-    
-    def _generate_distribution_hash(self, address: str, amount: float, block_height: int) -> str:
-        """Generate unique hash for distribution transaction"""
-        data = f"fee_dist_{address}_{amount}_{block_height}_{time.time()}"
-        return hashlib.sha256(data.encode()).hexdigest()
-
-class FeeCalculator:
-    """Configurable fee calculation system"""
-    
-    def __init__(self, fee_pool_manager: FeePoolManager):
-        self.fee_pool_manager = fee_pool_manager
-        self.fee_config = {
-            'transfer': 0.00001,      # Default transfer fee
-            'gtx_genesis': 0.0,       # No fee for GTX genesis
-            'reward': 0.0,            # No fee for rewards
-            'stake': 0.0001,          # Staking fee
-            'unstake': 0.0001,        # Unstaking fee
-            'delegate': 0.00005,      # Delegation fee
-            'fee_distribution': 0.0,  # No fee for fee distributions
-        }
-        
-        # Dynamic fee tiers based on transaction amount
-        self.amount_tiers = {
-            'micro': (0, 1, 0.000001),
-            'small': (1, 100, 0.00001),
-            'medium': (100, 10000, 0.0001),
-            'large': (10000, 100000, 0.001),
-            'xlarge': (100000, float('inf'), 0.01)
-        }
-    
-    def set_fee(self, transaction_type: str, fee_amount: float):
-        """Set custom fee for a transaction type"""
-        self.fee_config[transaction_type] = max(0.0, fee_amount)
-    
-    def get_fee(self, transaction_type: str, amount: float = 0.0) -> float:
-        """Get fee for transaction type and amount"""
-        base_fee = self.fee_config.get(transaction_type, 0.00001)
-        
-        # Apply amount-based fee scaling
-        for tier_name, (min_amt, max_amt, tier_fee) in self.amount_tiers.items():
-            if min_amt <= amount < max_amt:
-                return max(base_fee, tier_fee)
-        
-        return base_fee
-    
-    def calculate_network_fee(self, transaction_size: int, priority: str = 'normal') -> float:
-        """Calculate fee based on transaction size and priority"""
-        base_fee_per_byte = 0.0000001  # Base fee per byte
-        
-        priority_multipliers = {
-            'low': 0.5,
-            'normal': 1.0,
-            'high': 2.0,
-            'urgent': 5.0
-        }
-        
-        multiplier = priority_multipliers.get(priority, 1.0)
-        return transaction_size * base_fee_per_byte * multiplier
-    
-    def process_transaction_fee(self, transaction: Dict) -> bool:
-        """Process and collect transaction fee"""
-        fee = transaction.get('fee', 0)
-        if fee > 0:
-            return self.fee_pool_manager.collect_fee(fee, transaction.get('hash', ''))
-        return True
-
-class TransactionManager:
-    """Handles transaction creation, signing, and validation"""
-    
-    def __init__(self):
-        self.security = TransactionSecurity()
-        self.key_manager = KeyManager()
-        self.fee_pool_manager = FeePoolManager()
-        self.fee_calculator = FeeCalculator(self.fee_pool_manager)
-        self.pending_by_address = {}  # Track pending transactions by address
-    
-    def create_transaction(self, from_address: str, to_address: str, amount: float, 
-                         private_key: Optional[str] = None, memo: str = "",
-                         transaction_type: str = "transfer", fee_override: Optional[float] = None,
-                         priority: str = 'normal') -> Dict:
-        """Create and sign a transaction with configurable fees"""
-        
-        # Calculate fee
-        if fee_override is not None:
-            fee = max(0.0, fee_override)
-        else:
-            fee = self.fee_calculator.get_fee(transaction_type, amount)
-        
-        transaction = {
-            "type": transaction_type,
-            "from": from_address,
-            "to": to_address,
-            "amount": float(amount),
-            "fee": fee,
-            "nonce": int(time.time() * 1000),
-            "timestamp": time.time(),
-            "memo": memo,
-            "priority": priority,
-        }
-        
-        # Only add cryptographic fields if private key is provided
-        if private_key:
-            transaction["public_key"] = self.key_manager.derive_public_key(private_key)
-            sign_data = self._get_signing_data(transaction)
-            signature = self.key_manager.sign_data(sign_data, private_key)
-            transaction["signature"] = signature
-        else:
-            # For unsigned transactions (like rewards or test transactions)
-            transaction["public_key"] = "unsigned"
-            transaction["signature"] = "unsigned"
-        
-        transaction["hash"] = self._calculate_transaction_hash(transaction)
-        
-        # Automatically collect fee
-        self.fee_calculator.process_transaction_fee(transaction)
-        
-        return transaction
-    
-    def distribute_fees(self, current_block_height: int, stakers: List[Dict], total_stake: float) -> List[Dict]:
-        """Distribute collected fees to stakers"""
-        return self.fee_pool_manager.create_distribution_transactions(
-            current_block_height, stakers, total_stake
-        )
-    
-    def get_fee_pool_balance(self) -> float:
-        """Get current fee pool balance"""
-        return self.fee_pool_manager.pending_fees
-    
-    def get_fee_pool_address(self) -> str:
-        """Get fee pool address"""
-        return self.fee_pool_manager.fee_pool_address
-    
-    def create_gtx_transaction(self, bill_info: Dict) -> Dict:
-        """Create GTX Genesis transaction from mined bill"""
-        # Ensure we return a proper transaction structure
-        if "transaction_data" in bill_info:
-            return bill_info["transaction_data"]
-        else:
-            # Fallback: create basic transaction from bill info
-            return {
-                "type": "gtx_genesis",
-                "from": "mining",
-                "to": bill_info.get("owner_address", "unknown"),
-                "amount": bill_info.get("denomination", 0),
-                "fee": 0.0,  # No fee for GTX genesis
-                "timestamp": time.time(),
-                "hash": f"gtx_{hashlib.sha256(json.dumps(bill_info).encode()).hexdigest()[:16]}"
-            }
-    
-    def create_reward_transaction(self, to_address: str, amount: float, block_height: int) -> Dict:
-        """Create block reward transaction"""
-        transaction = {
-            "type": "reward",
-            "from": "network",
-            "to": to_address,
-            "amount": float(amount),
-            "fee": 0.0,  # No fee for rewards
-            "block_height": block_height,
-            "timestamp": time.time(),
-            "hash": self._generate_reward_hash(to_address, amount, block_height)
-        }
-        
-        return transaction
-    
-    def create_stake_transaction(self, from_address: str, amount: float, 
-                               private_key: Optional[str] = None) -> Dict:
-        """Create staking transaction"""
-        return self.create_transaction(
-            from_address=from_address,
-            to_address="staking_pool",
-            amount=amount,
-            private_key=private_key,
-            transaction_type="stake"
-        )
-    
-    def create_unstake_transaction(self, from_address: str, amount: float,
-                                 private_key: Optional[str] = None) -> Dict:
-        """Create unstaking transaction"""
-        return self.create_transaction(
-            from_address="staking_pool",
-            to_address=from_address,
-            amount=amount,
-            private_key=private_key,
-            transaction_type="unstake"
-        )
-    
-    def validate_transaction(self, transaction: Dict) -> Tuple[bool, str]:
-        """Validate transaction using security module"""
-        return self.security.validate_transaction(transaction)
-    
-    def validate_transaction_security(self, transaction: Dict) -> Tuple[bool, str]:
-        """Validate transaction security"""
-        return self.security.validate_transaction_security(transaction)
-    
-    def assess_transaction_risk(self, transaction: Dict) -> Tuple[str, str]:
-        """Assess transaction risk level"""
-        return self.security.assess_risk(transaction)
-    
-    def set_transaction_fee(self, transaction_type: str, fee_amount: float):
-        """Set custom fee for transaction type"""
-        self.fee_calculator.set_fee(transaction_type, fee_amount)
-    
-    def calculate_network_fee(self, transaction_size: int, priority: str = 'normal') -> float:
-        """Calculate network fee based on size and priority"""
-        return self.fee_calculator.calculate_network_fee(transaction_size, priority)
-    
-    def _get_signing_data(self, transaction: Dict) -> str:
-        """Create data string for signing"""
-        parts = [
-            transaction["from"],
-            transaction["to"],
-            str(transaction["amount"]),
-            str(transaction.get("nonce", 0)),
-            str(transaction["timestamp"]),
-            transaction.get("memo", ""),
-            str(transaction.get("fee", 0)),
-            transaction.get("type", "transfer")
-        ]
-        return "".join(parts)
-    
-    def _calculate_transaction_hash(self, transaction: Dict) -> str:
-        """Calculate transaction hash"""
-        # Create a copy without signature for consistent hashing
-        tx_copy = transaction.copy()
-        tx_copy.pop("signature", None)
-        data_string = json.dumps(tx_copy, sort_keys=True)
-        return hashlib.sha256(data_string.encode()).hexdigest()  # FIXED: data_string instead of data
-    
-    def _generate_reward_hash(self, to_address: str, amount: float, block_height: int) -> str:
-        """Generate unique hash for reward transaction"""
-        data = f"reward_{to_address}_{amount}_{block_height}_{time.time()}"
-        return hashlib.sha256(data.encode()).hexdigest()
-    
-    def validate_against_available_balance(self, from_address: str, amount: float, 
-                                          available_balance: float) -> Tuple[bool, str]:
-        """Validate that transaction amount doesn't exceed available balance"""
-        pending_amount = self.pending_by_address.get(from_address, 0.0)
-        total_pending = pending_amount + amount
-        
-        if total_pending > available_balance:
-            shortage = total_pending - available_balance
-            return False, f'Insufficient available balance. Need {shortage} more (accounting for {pending_amount} in pending transactions)'
-        
-        return True, 'Sufficient balance'
-    
-    def add_pending_transaction(self, from_address: str, tx_hash: str, amount: float) -> bool:
-        """Track a pending transaction (added to mempool)"""
-        if from_address not in self.pending_by_address:
-            self.pending_by_address[from_address] = 0.0
-        
-        self.pending_by_address[from_address] += float(amount)
-        return True
-    
-    def confirm_transaction(self, from_address: str, amount: float) -> bool:
-        """Confirm a transaction (moved from mempool to blockchain)"""
-        if from_address in self.pending_by_address:
-            pending = self.pending_by_address[from_address]
-            new_pending = max(0.0, pending - float(amount))
-            
-            if new_pending == 0:
-                del self.pending_by_address[from_address]
-            else:
-                self.pending_by_address[from_address] = new_pending
-            
-            return True
-        return False
-    
-    def get_pending_amount(self, from_address: str) -> float:
-        """Get total pending transaction amount for address"""
-        return self.pending_by_address.get(from_address, 0.0)
-    
-    def clear_pending_for_address(self, from_address: str) -> bool:
-        """Clear all pending transactions for address (e.g., if they failed)"""
-        if from_address in self.pending_by_address:
-            del self.pending_by_address[from_address]
-        return True
-
-# Additional validator class for backward compatibility
-class TransactionValidator:
-    """Transaction validator for risk assessment and validation"""
-    
-    def __init__(self):
-        self.security = TransactionSecurity()
-    
-    def assess_risk(self, transaction: Dict) -> Tuple[str, str]:
-        """Assess transaction risk level"""
-        return self.security.assess_risk(transaction)
-    
-    def validate(self, transaction: Dict) -> Tuple[bool, str]:
-        """Validate transaction"""
-        return self.security.validate_transaction(transaction)

transactions/validator.py

@@ -1,71 +0,0 @@
-import time
-from typing import Dict, Tuple, List
-from .security import TransactionSecurity
-
-class TransactionValidator:
-    """Network-level transaction validation"""
-    
-    def __init__(self):
-        self.security = TransactionSecurity()
-        self.recent_transactions = set()
-        self.max_recent_size = 10000
-    
-    def validate_transaction(self, transaction: Dict) -> Tuple[bool, str]:
-        """Main transaction validation entry point"""
-        
-        # Check for duplicate transaction
-        tx_hash = transaction.get("hash")
-        if tx_hash in self.recent_transactions:
-            return False, "Duplicate transaction detected"
-        
-        # Security validation
-        is_valid, message = self.security.validate_transaction_security(transaction)
-        if not is_valid:
-            return False, message
-        
-        # Add to recent transactions
-        self._add_to_recent(tx_hash)
-        
-        return True, message
-    
-    def validate_transaction_batch(self, transactions: List[Dict]) -> Tuple[bool, List[str]]:
-        """Validate multiple transactions"""
-        results = []
-        all_valid = True
-        
-        for tx in transactions:
-            is_valid, message = self.validate_transaction(tx)
-            results.append(message)
-            if not is_valid:
-                all_valid = False
-        
-        return all_valid, results
-    
-    def verify_transaction_inclusion(self, transaction_hash: str, block_height: int) -> bool:
-        """Verify transaction is included in blockchain"""
-        # This would typically query the blockchain
-        # For now, we'll assume if it passed validation it's included
-        return transaction_hash in self.recent_transactions
-    
-    def get_transaction_risk_level(self, transaction: Dict) -> str:
-        """Assess transaction risk level"""
-        amount = transaction.get("amount", 0)
-        security_score = self.security.calculate_security_score(transaction)
-        
-        if amount > 1000000 and security_score < 80:
-            return "HIGH"
-        elif amount > 10000 and security_score < 60:
-            return "MEDIUM"
-        elif security_score < 40:
-            return "LOW"
-        else:
-            return "VERY_LOW"
-    
-    def _add_to_recent(self, tx_hash: str):
-        """Add transaction to recent set with size management"""
-        self.recent_transactions.add(tx_hash)
-        
-        # Manage set size
-        if len(self.recent_transactions) > self.max_recent_size:
-            # Remove oldest entries (this is simplified)
-            self.recent_transactions = set(list(self.recent_transactions)[-self.max_recent_size:])