lunalib 1.6.7__py3-none-any.whl → 1.7.9__py3-none-any.whl

lunalib/core/wallet_db.py

@@ -0,0 +1,68 @@
+
+from lunalib.storage.database import WalletDatabase
+
+
+class WalletDB:
+    def __init__(self, data_dir=None):
+        # data_dir is kept for compatibility, but db_path is passed to WalletDatabase
+        import os
+        self.data_dir = data_dir or os.path.expanduser("~/.lunawallet")
+        os.makedirs(self.data_dir, exist_ok=True)
+        self.db_path = os.path.join(self.data_dir, "wallets.db")
+        print(f"[WalletDB] data_dir: {self.data_dir}")
+        print(f"[WalletDB] db_path: {self.db_path}")
+        self.db = WalletDatabase(db_path=self.db_path)
+
+    def save_wallet(self, address, label, public_key, encrypted_private_key, is_locked, created, balance, available_balance):
+        # Compose wallet_data dict for WalletDatabase
+        wallet_data = {
+            'address': address,
+            'label': label,
+            'public_key': public_key,
+            'encrypted_private_key': encrypted_private_key,
+            'balance': balance,
+            'created': created,
+            'metadata': {'is_locked': bool(is_locked), 'available_balance': available_balance}
+        }
+        return self.db.save_wallet(wallet_data)
+
+    def load_wallet(self, address):
+        w = self.db.load_wallet(address)
+        if w:
+            # For compatibility, flatten metadata fields
+            meta = w.get('metadata', {})
+            w['is_locked'] = meta.get('is_locked', False)
+            w['available_balance'] = meta.get('available_balance', 0.0)
+        return w
+
+    def list_wallets(self):
+        # Return list of tuples for compatibility: (address, label, is_locked, balance, available_balance)
+        import sqlite3
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute('SELECT address, label, metadata, balance FROM wallets')
+        rows = cursor.fetchall()
+        conn.close()
+        result = []
+        for row in rows:
+            address, label, metadata_json, balance = row
+            meta = {}
+            try:
+                meta = json.loads(metadata_json) if metadata_json else {}
+            except Exception:
+                pass
+            is_locked = meta.get('is_locked', False)
+            available_balance = meta.get('available_balance', 0.0)
+            result.append((address, label, is_locked, balance, available_balance))
+        return result
+
+
+    def close(self):
+        # No persistent connection to close in WalletDatabase
+        pass
+
+# Example usage:
+if __name__ == "__main__":
+    db = WalletDB()
+    print("Wallets:", db.list_wallets())
+    db.close()

lunalib/mining/miner.py

@@ -687,16 +687,20 @@ class Miner:
             # Validate all transactions
             valid_transactions = self._validate_transactions(mempool)
             
-            # If no valid transactions, create a reward transaction
-            if not valid_transactions:
-                reward_tx = self._create_empty_block_reward(new_index)
-                valid_transactions = [reward_tx]
-
             # Calculate block difficulty based on transactions
             block_difficulty = self._calculate_block_difficulty(valid_transactions)
             
-            # Calculate block reward using exponential difficulty system
-            total_reward = self._calculate_exponential_block_reward(block_difficulty)
+            # Calculate block reward:
+            # - Empty blocks use LINEAR system: difficulty 1 = 1 LKC, difficulty 2 = 2 LKC, etc.
+            # - Blocks with transactions use EXPONENTIAL system: 10^(difficulty-1)
+            if not valid_transactions:
+                # Empty block: linear reward
+                total_reward = float(block_difficulty)
+                reward_tx = self._create_empty_block_reward(new_index, block_difficulty, total_reward)
+                valid_transactions = [reward_tx]
+            else:
+                # Regular block: exponential reward
+                total_reward = self._calculate_exponential_block_reward(block_difficulty)
 
             # Create block data
             block_data = {
@@ -843,17 +847,19 @@ class Miner:
         """
         return self.difficulty_system.calculate_block_reward(difficulty)
 
-    def _create_empty_block_reward(self, block_index: int) -> Dict:
-        """Create reward transaction for empty blocks"""
+    def _create_empty_block_reward(self, block_index: int, difficulty: int, reward_amount: float) -> Dict:
+        """Create reward transaction for empty blocks using LINEAR reward system (difficulty = reward)"""
         return {
             'type': 'reward',
             'from': 'network',
             'to': self.config.miner_address,
-            'amount': 1.0,
+            'amount': reward_amount,
             'timestamp': time.time(),
             'block_height': block_index,
+            'difficulty': difficulty,
             'hash': f"reward_{block_index}_{int(time.time())}",
-            'description': 'Empty block mining reward'
+            'description': f'Empty block mining reward (Linear: Difficulty {difficulty} = {reward_amount} LKC)',
+            'is_empty_block': True
         }
 
     def _cuda_mine(self, block_data: Dict, difficulty: int) -> Optional[Dict]:
@@ -1021,14 +1027,27 @@ class Miner:
             safe_print(f"⚠️  Could not validate previous hash: {e}")
         
         # Validate reward matches difficulty
-        expected_reward = self.difficulty_system.calculate_block_reward(difficulty)
+        # Empty blocks use LINEAR system (difficulty = reward)
+        # Regular blocks use EXPONENTIAL system (10^(difficulty-1))
+        transactions = block.get('transactions', [])
+        is_empty_block = len(transactions) == 1 and transactions[0].get('is_empty_block', False)
+        
+        if is_empty_block:
+            # Empty block: linear reward
+            expected_reward = float(difficulty)
+        else:
+            # Regular block: exponential reward
+            expected_reward = self.difficulty_system.calculate_block_reward(difficulty)
+        
         actual_reward = block.get('reward', 0)
         
         # Allow some tolerance for floating point comparison
         if abs(actual_reward - expected_reward) > 0.01:
-            return False, f"Reward mismatch: expected {expected_reward} LKC for difficulty {difficulty}, got {actual_reward} LKC"
+            reward_type = "Linear" if is_empty_block else "Exponential"
+            return False, f"Reward mismatch ({reward_type}): expected {expected_reward} LKC for difficulty {difficulty}, got {actual_reward} LKC"
         
-        safe_print(f"✅ Block validation passed: Hash meets difficulty {difficulty}, Reward: {actual_reward} LKC")
+        reward_type = "Linear" if is_empty_block else "Exponential"
+        safe_print(f"✅ Block validation passed ({reward_type}): Hash meets difficulty {difficulty}, Reward: {actual_reward} LKC")
         return True, ""
     
     def _clear_transactions_from_mempool(self, transactions: List[Dict]):

lunalib/tests/conftest.py

@@ -0,0 +1,41 @@
+import pytest
+import tempfile
+import os
+import time
+from lunalib.core.wallet import LunaWallet
+from lunalib.mining.miner import GenesisMiner
+from lunalib.gtx.genesis import GTXGenesis
+
+@pytest.fixture
+def temp_dir():
+    """Create temporary directory for test data"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        yield tmpdir
+
+@pytest.fixture
+def test_wallet(temp_dir):
+    """Create a test wallet"""
+    wallet = LunaWallet(data_dir=temp_dir)
+    wallet_data = wallet.create_wallet("Test Wallet", "test_password")
+    return wallet, wallet_data
+
+@pytest.fixture
+def test_miner():
+    """Create a test miner"""
+    return GenesisMiner()
+
+@pytest.fixture
+def test_gtx(temp_dir):
+    """Create test GTX system"""
+    return GTXGenesis()
+
+@pytest.fixture
+def sample_transaction_data(test_wallet):
+    """Create sample transaction data"""
+    wallet, wallet_data = test_wallet
+    return {
+        "from": wallet_data["address"],
+        "to": "LUN_test_recipient_12345",
+        "amount": 100.0,
+        "memo": "Test transaction"
+    }

lunalib/tests/integration/test_integration.py

@@ -0,0 +1,62 @@
+import pytest
+import tempfile
+from lunalib.core.wallet import LunaWallet
+from lunalib.mining.miner import GenesisMiner
+from lunalib.gtx.genesis import GTXGenesis
+
+class TestIntegration:
+    def test_complete_workflow(self, temp_dir):
+        """Test complete wallet -> mining -> GTX workflow"""
+        # Create wallet
+        wallet = LunaWallet(data_dir=temp_dir)
+        wallet_data = wallet.create_wallet("Integration Test", "test_pass")
+
+        # Initialize systems
+        miner = GenesisMiner()
+        gtx = GTXGenesis()
+
+        # Mock mining a bill
+        with pytest.MonkeyPatch().context() as m:
+            m.setattr(miner, '_perform_mining', lambda *args: {
+                "success": True,
+                "hash": "000integration",
+                "nonce": 999,
+                "mining_time": 1.0
+            })
+
+            # Mine a bill
+            bill = miner.mine_bill(1000, wallet_data['address'])
+
+            assert bill['success'] is True
+            assert bill['denomination'] == 1000
+            assert bill['luna_value'] == 1000
+
+            # Create proper bill data for verification
+            metadata_hash = "test_metadata_hash_12345"
+            signature = metadata_hash  # This will pass METHOD 1 verification
+            
+            # Register the bill in GTX system for verification
+            bill_info = {
+                'bill_serial': bill['bill_serial'],
+                'denomination': 1000,
+                'user_address': wallet_data['address'],
+                'hash': "000integration",
+                'mining_time': 1.0,
+                'difficulty': 4,
+                'luna_value': 1000,
+                'timestamp': bill['timestamp'],
+                'bill_data': {
+                    'public_key': 'test_public_key',
+                    'signature': signature,  # Use the signature that matches metadata_hash
+                    'metadata_hash': metadata_hash,  # This must match signature for METHOD 1
+                    'issued_to': wallet_data['address'],
+                    'front_serial': bill['bill_serial'],
+                    'type': 'GTX_Genesis',
+                    'back_serial': ''  # Add this to avoid errors
+                }
+            }
+            gtx.bill_registry.register_bill(bill_info)
+
+            # Verify the bill
+            verification = gtx.verify_bill(bill['bill_serial'])
+            assert verification['valid'] is True

lunalib/tests/test_blockchain.py

@@ -0,0 +1,34 @@
+import pytest
+from unittest.mock import Mock, patch
+from lunalib.core.blockchain import BlockchainManager
+
+class TestBlockchain:
+    @patch('lunalib.core.blockchain.requests.get')
+    def test_blockchain_height(self, mock_get):
+        """Test blockchain height retrieval"""
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = {'height': 1500}
+        
+        blockchain = BlockchainManager()
+        height = blockchain.get_blockchain_height()
+        
+        assert height == 1500
+
+    @patch('lunalib.core.blockchain.requests.get')
+    def test_network_connection(self, mock_get):
+        """Test network connection checking"""
+        mock_get.return_value.status_code = 200
+        
+        blockchain = BlockchainManager()
+        is_connected = blockchain.check_network_connection()
+        
+        assert is_connected is True
+
+    def test_transaction_scanning(self):
+        """Test transaction scanning functionality"""
+        blockchain = BlockchainManager()
+        
+        # This would typically be mocked in a real test
+        # For now, test the method exists and returns expected type
+        transactions = blockchain.scan_transactions_for_address("LUN_test", 0, 10)
+        assert isinstance(transactions, list)

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