lunalib 1.7.3__py3-none-any.whl → 1.8.0__py3-none-any.whl

lunalib/tests/test_crypto.py

@@ -0,0 +1,42 @@
+import pytest
+from lunalib.core.crypto import KeyManager
+
+class TestCrypto:
+    def test_key_generation(self):
+        """Test cryptographic key generation"""
+        key_manager = KeyManager()
+        
+        private_key = key_manager.generate_private_key()
+        public_key = key_manager.derive_public_key(private_key)
+        address = key_manager.derive_address(public_key)
+        
+        assert len(private_key) == 64  # 32 bytes in hex
+        assert len(public_key) == 64   # 32 bytes in hex
+        assert address.startswith("LUN_")
+
+    def test_data_signing(self):
+        """Test data signing and verification"""
+        key_manager = KeyManager()
+        
+        private_key = key_manager.generate_private_key()
+        public_key = key_manager.derive_public_key(private_key)
+        
+        test_data = "Hello, Luna Library!"
+        signature = key_manager.sign_data(test_data, private_key)
+        
+        # Basic signature format check
+        assert len(signature) == 64
+        assert all(c in "0123456789abcdef" for c in signature.lower())
+
+    def test_address_generation_uniqueness(self):
+        """Test that addresses are unique"""
+        key_manager = KeyManager()
+        
+        addresses = set()
+        for _ in range(10):
+            private_key = key_manager.generate_private_key()
+            public_key = key_manager.derive_public_key(private_key)
+            address = key_manager.derive_address(public_key)
+            addresses.add(address)
+        
+        assert len(addresses) == 10  # All addresses should be unique

lunalib/tests/test_gtx.py

@@ -0,0 +1,135 @@
+import sys
+def safe_print(*args, **kwargs):
+    encoding = sys.stdout.encoding or 'utf-8'
+    try:
+        print(*args, **kwargs)
+    except UnicodeEncodeError:
+        print(*(str(a).encode(encoding, errors='replace').decode(encoding) for a in args), **kwargs)
+import pytest
+from lunalib.gtx.genesis import GTXGenesis
+from lunalib.gtx.digital_bill import DigitalBill
+import time
+class TestGTXGenesis:
+    def test_digital_bill_creation(self, test_gtx):
+        """Test digital bill creation"""
+        bill = test_gtx.create_genesis_bill(
+            denomination=1000,
+            user_address="LUN_test_address_123",
+            custom_data={"issuer": "test"}
+        )
+        
+        assert bill.denomination == 1000
+        assert bill.user_address == "LUN_test_address_123"
+        assert bill.bill_data["issuer"] == "test"
+        assert bill.bill_serial.startswith("GTX1000_")
+
+    def test_bill_mining_data(self, test_gtx):
+        """Test bill mining data generation"""
+        bill = test_gtx.create_genesis_bill(100, "LUN_test")
+        mining_data = bill.get_mining_data(nonce=123)
+        
+        assert mining_data["type"] == "GTX_Genesis"
+        assert mining_data["denomination"] == 100
+        assert mining_data["nonce"] == 123
+        assert "previous_hash" in mining_data
+
+    def test_bill_finalization(self, test_gtx):
+        """Test bill finalization after mining"""
+        bill = test_gtx.create_genesis_bill(1000, "LUN_test")
+        
+        final_bill = bill.finalize(
+            hash="000abc123",
+            nonce=12345,
+            mining_time=3.2
+        )
+        
+        assert final_bill["success"] is True
+        assert final_bill["hash"] == "000abc123"
+        assert final_bill["mining_time"] == 3.2
+        assert "transaction_data" in final_bill
+
+    def test_bill_verification(self, test_gtx, temp_dir):
+        """Test bill verification with proper bill data structure"""
+        import time
+        import hashlib
+        from unittest.mock import patch
+
+        # Create a complete bill_info structure that matches what register_bill expects
+        bill_serial = "GTX_TEST_12345"
+        timestamp = time.time()
+        denomination = 100
+        user_address = "LUN_test_verify"
+
+        # Create metadata that will pass one of the verification methods
+        metadata_hash = hashlib.sha256(f"test_metadata_{timestamp}".encode()).hexdigest()
+        public_key = f"pub_test_key_{timestamp}"
+        signature = metadata_hash  # This will pass METHOD 1 verification
+
+        # Create the complete bill_info structure
+        bill_info = {
+            'bill_serial': bill_serial,
+            'denomination': denomination,
+            'user_address': user_address,
+            'hash': hashlib.sha256(bill_serial.encode()).hexdigest(),
+            'mining_time': 1.5,
+            'difficulty': 4,
+            'luna_value': denomination,
+            'timestamp': timestamp,
+            'bill_data': {
+                'public_key': public_key,
+                'signature': signature,
+                'metadata_hash': metadata_hash,
+                'issued_to': user_address,
+                'front_serial': bill_serial,
+                'type': 'GTX_Genesis',
+                'back_serial': ''
+            }
+        }
+
+        # Register the bill first
+        test_gtx.bill_registry.register_bill(bill_info)
+
+        # DEBUG: Check what get_bill returns
+        bill_data_from_registry = test_gtx.bill_registry.get_bill(bill_serial)
+        safe_print(f"DEBUG: Bill data from registry: {bill_data_from_registry}")
+
+        # Test verification - should pass METHOD 1
+        result = test_gtx.verify_bill(bill_serial)
+        safe_print(f"DEBUG: Verification result: {result}")
+        
+        assert result["valid"] is True
+
+    def test_invalid_bill_verification(self, test_gtx):
+        """Test verification of non-existent bill"""
+        result = test_gtx.verify_bill("GTX_invalid_serial")
+        assert result["valid"] is False
+        assert "error" in result
+
+    def test_portfolio_management(self, test_gtx, temp_dir):
+        """Test user portfolio functionality"""
+        # Use a unique user address to avoid conflicts
+        unique_user = f"LUN_test_user_{int(time.time())}"
+        
+        # Add some test bills to registry
+        for denom in [100, 1000, 10000]:
+            bill = test_gtx.create_genesis_bill(denom, unique_user)
+            final_bill = bill.finalize(f"000hash{denom}", 123, 1.0)
+            
+            # Register the bill properly
+            bill_info = {
+                'bill_serial': final_bill['bill_serial'],
+                'denomination': denom,
+                'user_address': unique_user,
+                'hash': f"000hash{denom}",
+                'mining_time': 1.0,
+                'difficulty': 4,
+                'luna_value': denom,
+                'timestamp': final_bill['timestamp'],
+                'bill_data': final_bill
+            }
+            test_gtx.bill_registry.register_bill(bill_info)
+
+        portfolio = test_gtx.get_user_portfolio(unique_user)
+
+        assert portfolio["user_address"] == unique_user
+        assert portfolio["total_bills"] == 3

lunalib/tests/test_mining.py

@@ -0,0 +1,244 @@
+import pytest
+import time
+from unittest.mock import Mock, patch
+from lunalib.mining.miner import GenesisMiner
+from lunalib.mining.difficulty import DifficultySystem
+
+class TestMining:
+    def test_difficulty_system(self):
+        """Test difficulty calculations with 9-tier system"""
+        difficulty = DifficultySystem()
+        
+        # Test bill difficulties - 9 tiers
+        assert difficulty.get_bill_difficulty(1) == 1        # Trivial
+        assert difficulty.get_bill_difficulty(5) == 2        # Very Easy
+        assert difficulty.get_bill_difficulty(50) == 3       # Easy
+        assert difficulty.get_bill_difficulty(500) == 4      # Moderate
+        assert difficulty.get_bill_difficulty(5000) == 5     # Standard
+        assert difficulty.get_bill_difficulty(50000) == 6    # Challenging
+        assert difficulty.get_bill_difficulty(500000) == 7   # Hard
+        assert difficulty.get_bill_difficulty(5000000) == 8  # Very Hard
+        assert difficulty.get_bill_difficulty(50000000) == 9 # Extreme
+        
+        # Test transaction difficulties - 9 tiers
+        assert difficulty.get_transaction_difficulty(0.0005) == 1  # Trivial
+        assert difficulty.get_transaction_difficulty(0.005) == 2   # Very Easy
+        assert difficulty.get_transaction_difficulty(0.05) == 3    # Easy
+        assert difficulty.get_transaction_difficulty(0.5) == 4     # Moderate
+        assert difficulty.get_transaction_difficulty(5) == 5       # Standard
+        assert difficulty.get_transaction_difficulty(50) == 6      # Challenging
+        assert difficulty.get_transaction_difficulty(500) == 7     # Hard
+        assert difficulty.get_transaction_difficulty(5000) == 8    # Very Hard
+        assert difficulty.get_transaction_difficulty(50000) == 9   # Extreme
+        
+        # Test edge cases and boundary values
+        assert difficulty.get_bill_difficulty(0) == 1              # Zero amount
+        assert difficulty.get_bill_difficulty(-100) == 1           # Negative amount
+        assert difficulty.get_bill_difficulty(999999999999) == 9   # Huge number
+        
+        # Test boundary values for each tier
+        assert difficulty.get_bill_difficulty(1) == 1              # Tier 1 upper bound
+        assert difficulty.get_bill_difficulty(10) == 2             # Tier 2 upper bound
+        assert difficulty.get_bill_difficulty(100) == 3            # Tier 3 upper bound
+        assert difficulty.get_bill_difficulty(1000) == 4           # Tier 4 upper bound
+        assert difficulty.get_bill_difficulty(10000) == 5          # Tier 5 upper bound
+        assert difficulty.get_bill_difficulty(100000) == 6         # Tier 6 upper bound
+        assert difficulty.get_bill_difficulty(1000000) == 7        # Tier 7 upper bound
+        assert difficulty.get_bill_difficulty(10000000) == 8       # Tier 8 upper bound
+        
+        # Test transaction edge cases
+        assert difficulty.get_transaction_difficulty(0) == 1       # Zero amount
+        assert difficulty.get_transaction_difficulty(-50) == 1     # Negative amount
+        assert difficulty.get_transaction_difficulty(999999999) == 9 # Huge amount
+        
+        # Test difficulty names for all tiers
+        assert difficulty.get_difficulty_name(1) == "Trivial"
+        assert difficulty.get_difficulty_name(2) == "Very Easy"
+        assert difficulty.get_difficulty_name(3) == "Easy"
+        assert difficulty.get_difficulty_name(4) == "Moderate"
+        assert difficulty.get_difficulty_name(5) == "Standard"
+        assert difficulty.get_difficulty_name(6) == "Challenging"
+        assert difficulty.get_difficulty_name(7) == "Hard"
+        assert difficulty.get_difficulty_name(8) == "Very Hard"
+        assert difficulty.get_difficulty_name(9) == "Extreme"
+        assert difficulty.get_difficulty_name(999) == "Unknown"    # Invalid level
+        
+        # Test difficulty colors
+        assert difficulty.get_difficulty_color(1) == "🟢"
+        assert difficulty.get_difficulty_color(5) == "🟠"
+        assert difficulty.get_difficulty_color(9) == "💀"
+        
+        # Test mining rewards with 9-tier system
+        reward_fast = difficulty.calculate_mining_reward(1000, 5)   # 5 seconds - 50% bonus
+        reward_medium = difficulty.calculate_mining_reward(1000, 15) # 15 seconds - 20% bonus
+        reward_slow = difficulty.calculate_mining_reward(1000, 60)  # 60 seconds - no bonus
+        
+        assert reward_fast > reward_medium > reward_slow
+        assert reward_fast == 1500.0  # 1000 * 1.5
+        assert reward_medium == 1200.0  # 1000 * 1.2
+        assert reward_slow == 1000.0  # 1000 * 1.0
+        
+        # Test expected mining time calculations for different tiers
+        time_trivial = difficulty.get_expected_mining_time(1, 1000000)
+        time_easy = difficulty.get_expected_mining_time(3, 1000000)
+        time_standard = difficulty.get_expected_mining_time(5, 1000000)
+        time_hard = difficulty.get_expected_mining_time(7, 1000000)
+        time_extreme = difficulty.get_expected_mining_time(9, 1000000)
+        
+        # Higher difficulty should take exponentially longer
+        assert time_extreme > time_hard > time_standard > time_easy > time_trivial
+        
+        # Test invalid difficulty levels
+        assert difficulty.get_expected_mining_time(0, 1000000) == float('inf')
+        assert difficulty.get_expected_mining_time(10, 1000000) == float('inf')
+
+    def test_mining_reward_calculation(self):
+        """Test mining reward calculations with 9-tier system"""
+        difficulty = DifficultySystem()
+        
+        # Test base rewards for different denominations
+        reward_small = difficulty.calculate_mining_reward(10, 10)    # Small bill, fast mining
+        reward_medium = difficulty.calculate_mining_reward(1000, 10) # Medium bill, fast mining
+        reward_large = difficulty.calculate_mining_reward(100000, 10) # Large bill, fast mining
+        
+        # Test time-based bonuses across different tiers
+        reward_ultra_fast = difficulty.calculate_mining_reward(1000, 2)   # 2 seconds - 50% bonus
+        reward_fast = difficulty.calculate_mining_reward(1000, 5)         # 5 seconds - 50% bonus
+        reward_medium_time = difficulty.calculate_mining_reward(1000, 15) # 15 seconds - 20% bonus
+        reward_slow = difficulty.calculate_mining_reward(1000, 35)        # 35 seconds - no bonus
+        reward_very_slow = difficulty.calculate_mining_reward(1000, 70)   # 70 seconds - no bonus
+        
+        # Verify bonus tiers work correctly
+        assert reward_ultra_fast == reward_fast == 1500.0  # Both get 50% bonus
+        assert reward_medium_time == 1200.0  # 20% bonus
+        assert reward_slow == reward_very_slow == 1000.0  # No bonus
+        
+        # Verify faster mining always gives better rewards
+        assert reward_ultra_fast > reward_medium_time > reward_slow
+        
+        # Test edge cases
+        zero_reward = difficulty.calculate_mining_reward(0, 5)
+        negative_reward = difficulty.calculate_mining_reward(-100, 5)
+        assert zero_reward == 0
+        assert negative_reward == 0
+
+    @patch('lunalib.mining.miner.GenesisMiner._perform_mining')
+    def test_bill_mining_success(self, mock_mining, test_miner, test_wallet):
+        """Test successful bill mining across different tiers"""
+        wallet, wallet_data = test_wallet
+        
+        # Test mining for different difficulty tiers
+        test_cases = [
+            (10, 2),    # Very Easy tier
+            (100, 3),   # Easy tier
+            (1000, 4),  # Moderate tier
+            (10000, 5), # Standard tier
+        ]
+        
+        for denomination, expected_difficulty in test_cases:
+            # Mock successful mining
+            mock_mining.return_value = {
+                "success": True,
+                "hash": "0" * expected_difficulty + "abc123",
+                "nonce": 12345,
+                "mining_time": 2.5
+            }
+            
+            result = test_miner.mine_bill(denomination, wallet_data['address'])
+            
+            assert result['success'] is True
+            assert result['denomination'] == denomination
+            assert result['luna_value'] == denomination  # 1:1 ratio
+            assert 'bill_serial' in result
+            assert 'mining_time' in result
+
+    @patch('lunalib.mining.miner.GenesisMiner._perform_mining')
+    def test_high_difficulty_mining(self, mock_mining, test_miner, test_wallet):
+        """Test mining for high difficulty tiers"""
+        wallet, wallet_data = test_wallet
+        
+        # Test high difficulty bills
+        high_tier_cases = [
+            (100000, 6),  # Challenging tier
+            (1000000, 7), # Hard tier
+            (10000000, 8), # Very Hard tier
+        ]
+        
+        for denomination, expected_difficulty in high_tier_cases:
+            mock_mining.return_value = {
+                "success": True,
+                "hash": "0" * expected_difficulty + "def456",
+                "nonce": 99999,
+                "mining_time": 30.0  # Longer mining time for higher difficulty
+            }
+            
+            result = test_miner.mine_bill(denomination, wallet_data['address'])
+            
+            assert result['success'] is True
+            assert result['denomination'] == denomination
+            # High denomination bills might have additional validation
+            assert result['luna_value'] >= denomination
+
+    def test_mining_stop_functionality(self, test_miner):
+        """Test mining stop functionality"""
+        # Test starting and stopping mining
+        test_miner.mining_active = True
+        assert test_miner.mining_active is True
+        
+        test_miner.stop_mining()
+        assert test_miner.mining_active is False
+        
+        # Test stopping when already stopped
+        test_miner.stop_mining()
+        assert test_miner.mining_active is False
+
+    def test_invalid_denomination(self, test_miner, test_wallet):
+        """Test mining with invalid denominations"""
+        wallet, wallet_data = test_wallet
+        
+        invalid_denominations = [
+            -100,      # Negative
+            0,         # Zero
+            999,       # Unusual amount
+            -999999,   # Large negative
+        ]
+        
+        for invalid_denom in invalid_denominations:
+            result = test_miner.mine_bill(invalid_denom, wallet_data['address'])
+            assert result['success'] is False
+            assert 'error' in result
+
+    @patch('lunalib.mining.miner.GenesisMiner._perform_mining')
+    def test_mining_failure(self, mock_mining, test_miner, test_wallet):
+        """Test mining failure scenarios"""
+        wallet, wallet_data = test_wallet
+        
+        # Mock mining failure
+        mock_mining.return_value = {
+            "success": False,
+            "error": "Mining timeout"
+        }
+        
+        result = test_miner.mine_bill(100, wallet_data['address'])
+        
+        assert result['success'] is False
+        assert 'error' in result
+
+    def test_difficulty_progression(self):
+        """Test that difficulty progression makes sense"""
+        difficulty = DifficultySystem()
+        
+        # Test that each tier is more difficult than the previous
+        for i in range(1, 9):
+            time_lower = difficulty.get_expected_mining_time(i, 1000000)
+            time_higher = difficulty.get_expected_mining_time(i + 1, 1000000)
+            assert time_higher > time_lower, f"Tier {i+1} should be harder than tier {i}"
+
+    def test_mining_auto_stop(self, test_miner):
+        """Test that mining can be stopped automatically"""
+        test_miner.start_auto_mining([100, 200, 300], "test_address")
+        assert test_miner.mining_active is True
+        
+        # Stop mining and verify
+        test_miner.stop_mining()
+        assert test_miner.mining_active is False