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

lunalib/mining/miner.py

@@ -18,6 +18,7 @@ from ..gtx.digital_bill import DigitalBill
 from ..transactions.transactions import TransactionManager
 from ..core.blockchain import BlockchainManager
 from ..core.mempool import MempoolManager
+from ..mining.cuda_manager import CUDAManager
 
 class GenesisMiner:
     """Mines GTX Genesis bills AND regular transfer transactions with configurable difficulty"""
@@ -627,7 +628,8 @@ class GenesisMiner:
 
 class Miner:
     """
-    Miner class that uses lunalib directly to mine transfers, GTX genesis blocks, and rewards.
+    Robust miner class that integrates with BlockchainManager, MempoolManager, 
+    DifficultySystem, and security validation to mine all transaction types.
     """
 
     def __init__(self, config, data_manager, mining_started_callback=None, mining_completed_callback=None, block_mined_callback=None):
@@ -642,10 +644,21 @@ class Miner:
 
         self.mining_history = self.data_manager.load_mining_history()
 
-        # Use lunalib components
+        # Initialize lunalib components
         self.blockchain_manager = BlockchainManager(endpoint_url=config.node_url)
+        self.mempool_manager = MempoolManager([config.node_url])
         self.difficulty_system = DifficultySystem()
         self.cuda_manager = CUDAManager()
+        
+        # Import security components
+        try:
+            from ..transactions.security import SecurityManager
+            from ..transactions.validator import TransactionValidator
+            self.security_manager = SecurityManager()
+            self.transaction_validator = TransactionValidator()
+        except ImportError:
+            self.security_manager = None
+            self.transaction_validator = None
 
         self.current_hash = ""
         self.current_nonce = 0
@@ -653,10 +666,419 @@ class Miner:
         self.mining_thread = None
         self.should_stop_mining = False
 
-    def start_mining(self, mining_type: str):
+    def mine_block(self) -> tuple[bool, str, Optional[Dict]]:
         """
-        Start mining based on the type: 'transfer', 'gtx_genesis', or 'reward'.
+        Mine a block from the mempool with proper validation and difficulty calculation.
+        Returns: (success, message, block_data)
         """
+        try:
+            # Get the latest block from the blockchain
+            latest_block = self.blockchain_manager.get_latest_block()
+            if not latest_block:
+                return False, "Could not get latest block from server", None
+
+            current_index = latest_block.get('index', 0)
+            previous_hash = latest_block.get('hash', '0' * 64)
+            new_index = current_index + 1
+
+            # Get fresh transactions from mempool
+            mempool = self._get_fresh_mempool()
+            
+            # 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)
+
+            # Create block data
+            block_data = {
+                'index': new_index,
+                'previous_hash': previous_hash,
+                'timestamp': time.time(),
+                'transactions': valid_transactions,
+                'miner': self.config.miner_address,
+                'difficulty': block_difficulty,
+                'nonce': 0,
+                'reward': total_reward,
+                'hash': ''
+            }
+
+            # Try CUDA mining first if available
+            if self.cuda_manager and self.cuda_manager.cuda_available:
+                cuda_result = self._cuda_mine(block_data, block_difficulty)
+                if cuda_result:
+                    return self._finalize_block(cuda_result, 'cuda', total_reward)
+
+            # Fallback to CPU mining
+            cpu_result = self._cpu_mine(block_data, block_difficulty)
+            if cpu_result:
+                return self._finalize_block(cpu_result, 'cpu', total_reward)
+
+            return False, "Mining timeout - no solution found", None
+
+        except Exception as e:
+            return False, f"Mining error: {str(e)}", None
+
+    def _get_fresh_mempool(self) -> List[Dict]:
+        """Get fresh mempool transactions with validation"""
+        try:
+            mempool = self.mempool_manager.get_pending_transactions()
+            if not mempool:
+                mempool = self.blockchain_manager.get_mempool()
+            return mempool if mempool else []
+        except Exception as e:
+            safe_print(f"Error fetching mempool: {e}")
+            return []
+
+    def _validate_transactions(self, transactions: List[Dict]) -> List[Dict]:
+        """Validate transactions using security manager"""
+        valid_transactions = []
+        
+        for tx in transactions:
+            try:
+                # Basic validation
+                if not self._validate_transaction_structure(tx):
+                    continue
+                
+                # Security validation if available
+                if self.transaction_validator:
+                    if not self.transaction_validator.validate_transaction(tx):
+                        continue
+                
+                valid_transactions.append(tx)
+            except Exception as e:
+                safe_print(f"Transaction validation error: {e}")
+                continue
+        
+        return valid_transactions
+
+    def _validate_transaction_structure(self, tx: Dict) -> bool:
+        """Basic transaction structure validation"""
+        required_fields = ['type', 'timestamp']
+        
+        for field in required_fields:
+            if field not in tx:
+                return False
+        
+        tx_type = tx.get('type')
+        
+        if tx_type == 'transaction':
+            if not all(k in tx for k in ['from', 'to', 'amount']):
+                return False
+        elif tx_type == 'genesis_bill':
+            if 'denomination' not in tx:
+                return False
+        elif tx_type == 'reward':
+            if not all(k in tx for k in ['to', 'amount']):
+                return False
+        
+        return True
+
+    def _calculate_block_difficulty(self, transactions: List[Dict]) -> int:
+        """Calculate block difficulty based on transactions using DifficultySystem"""
+        if not transactions:
+            return self.config.difficulty
+
+        max_difficulty = self.config.difficulty
+
+        for tx in transactions:
+            tx_type = tx.get('type')
+            
+            if tx_type == 'genesis_bill':
+                denomination = tx.get('denomination', 0)
+                tx_difficulty = self.difficulty_system.get_bill_difficulty(denomination)
+                max_difficulty = max(max_difficulty, tx_difficulty)
+            elif tx_type == 'transaction':
+                amount = tx.get('amount', 0)
+                tx_difficulty = self.difficulty_system.get_transaction_difficulty(amount)
+                max_difficulty = max(max_difficulty, tx_difficulty)
+            elif tx_type == 'reward':
+                max_difficulty = max(max_difficulty, 1)
+
+        return max(max_difficulty, self.config.difficulty)
+
+    def _calculate_block_reward(self, transactions: List[Dict]) -> float:
+        """Calculate total block reward based on transactions using DifficultySystem"""
+        total_reward = 0.0
+
+        for tx in transactions:
+            tx_type = tx.get('type')
+            
+            if tx_type == 'genesis_bill':
+                denomination = tx.get('denomination', 0)
+                # Use difficulty system to calculate proper reward
+                bill_difficulty = self.difficulty_system.get_bill_difficulty(denomination)
+                avg_mining_time = 15.0  # Will be updated with actual time
+                bill_reward = self.difficulty_system.calculate_mining_reward(denomination, avg_mining_time)
+                total_reward += bill_reward
+            elif tx_type == 'transaction':
+                fee = tx.get('fee', 0)
+                total_reward += fee
+            elif tx_type == 'reward':
+                reward_amount = tx.get('amount', 0)
+                total_reward += reward_amount
+
+        # Minimum reward for empty blocks
+        if total_reward == 0:
+            total_reward = 1.0
+
+        return total_reward
+    
+    def _calculate_exponential_block_reward(self, difficulty: int) -> float:
+        """Calculate block reward using exponential difficulty system
+        
+        Uses the new exponential reward system:
+        difficulty 1 = 1 LKC
+        difficulty 2 = 10 LKC  
+        difficulty 3 = 100 LKC
+        difficulty 9 = 100,000,000 LKC
+        """
+        return self.difficulty_system.calculate_block_reward(difficulty)
+
+    def _create_empty_block_reward(self, block_index: int) -> Dict:
+        """Create reward transaction for empty blocks"""
+        return {
+            'type': 'reward',
+            'from': 'network',
+            'to': self.config.miner_address,
+            'amount': 1.0,
+            'timestamp': time.time(),
+            'block_height': block_index,
+            'hash': f"reward_{block_index}_{int(time.time())}",
+            'description': 'Empty block mining reward'
+        }
+
+    def _cuda_mine(self, block_data: Dict, difficulty: int) -> Optional[Dict]:
+        """Mine using CUDA acceleration"""
+        try:
+            safe_print("Attempting CUDA mining...")
+            cuda_result = self.cuda_manager.cuda_mine_batch(
+                block_data, difficulty, batch_size=100000
+            )
+            if cuda_result and cuda_result.get('success'):
+                block_data['hash'] = cuda_result['hash']
+                block_data['nonce'] = cuda_result['nonce']
+                return block_data
+        except Exception as e:
+            safe_print(f"CUDA mining failed: {e}")
+        return None
+
+    def _cpu_mine(self, block_data: Dict, difficulty: int) -> Optional[Dict]:
+        """Mine using CPU"""
+        safe_print("Using CPU mining...")
+        start_time = time.time()
+        target = "0" * difficulty
+        nonce = 0
+        hash_count = 0
+        last_hash_update = start_time
+
+        while not self.should_stop_mining and nonce < 1000000:
+            # Calculate block hash
+            block_hash = self._calculate_block_hash(
+                block_data['index'],
+                block_data['previous_hash'],
+                block_data['timestamp'],
+                block_data['transactions'],
+                nonce,
+                block_data['miner'],
+                difficulty
+            )
+
+            if block_hash.startswith(target):
+                block_data['hash'] = block_hash
+                block_data['nonce'] = nonce
+                return block_data
+
+            nonce += 1
+            hash_count += 1
+            self.current_nonce = nonce
+            self.current_hash = block_hash
+
+            # Update hash rate
+            current_time = time.time()
+            if current_time - last_hash_update >= 1:
+                self.hash_rate = hash_count / (current_time - last_hash_update)
+                hash_count = 0
+                last_hash_update = current_time
+
+            if nonce % 1000 == 0 and not self.is_mining:
+                return None
+
+        return None
+
+    def _calculate_block_hash(self, index: int, previous_hash: str, timestamp: float, 
+                             transactions: List[Dict], nonce: int, miner: str, difficulty: int) -> str:
+        """Calculate SHA-256 hash of a block matching server validation"""
+        try:
+            block_data = {
+                "difficulty": int(difficulty),
+                "index": int(index),
+                "miner": str(miner),
+                "nonce": int(nonce),
+                "previous_hash": str(previous_hash),
+                "timestamp": float(timestamp),
+                "transactions": [],  # Empty for mining proof
+                "version": "1.0"
+            }
+
+            block_string = json.dumps(block_data, sort_keys=True)
+            calculated_hash = hashlib.sha256(block_string.encode()).hexdigest()
+            return calculated_hash
+
+        except Exception as e:
+            safe_print(f"Hash calculation error: {e}")
+            return "0" * 64
+
+    def _finalize_block(self, block_data: Dict, method: str, total_reward: float) -> tuple[bool, str, Dict]:
+        """Finalize mined block with proper record keeping and blockchain submission"""
+        mining_time = time.time() - block_data.get('timestamp', time.time())
+
+        # Validate block before submission
+        validation_result = self._validate_mined_block(block_data)
+        if not validation_result[0]:
+            safe_print(f"❌ Block validation failed: {validation_result[1]}")
+            return False, f"Block validation failed: {validation_result[1]}", None
+
+        # Block reward is already calculated based on difficulty (exponential system)
+        final_reward = block_data['reward']
+
+        # Submit block to blockchain
+        try:
+            submission_success = self.blockchain_manager.submit_mined_block(block_data)
+            
+            if not submission_success:
+                safe_print(f"⚠️  Block #{block_data['index']} submission failed")
+                return False, f"Block #{block_data['index']} mined but submission failed", None
+            
+            safe_print(f"✅ Block #{block_data['index']} submitted successfully (Reward: {final_reward} LKC)")
+            
+            # Clear mined transactions from mempool
+            self._clear_transactions_from_mempool(block_data['transactions'])
+            
+        except Exception as e:
+            safe_print(f"❌ Block submission error: {e}")
+            return False, f"Block submission error: {str(e)}", None
+
+        # Record mining history
+        mining_record = {
+            'block_index': block_data['index'],
+            'timestamp': time.time(),
+            'mining_time': mining_time,
+            'difficulty': block_data['difficulty'],
+            'nonce': block_data['nonce'],
+            'hash': block_data['hash'],
+            'method': method,
+            'reward': final_reward,
+            'status': 'success'
+        }
+        self.mining_history.append(mining_record)
+        self.save_mining_history()
+
+        self.blocks_mined += 1
+        self.total_reward += final_reward
+
+        if self.mining_completed_callback:
+            self.mining_completed_callback(True, f"Block #{block_data['index']} mined - Reward: {final_reward}")
+
+        if self.block_mined_callback:
+            self.block_mined_callback(block_data)
+
+        return True, f"Block #{block_data['index']} mined - Reward: {final_reward}", block_data
+    
+    def _validate_mined_block(self, block: Dict) -> tuple:
+        """Validate mined block before submission
+        
+        Returns: (is_valid, error_message)
+        """
+        # Validate structure
+        is_valid, error = self.difficulty_system.validate_block_structure(block)
+        if not is_valid:
+            return False, error
+        
+        # Validate hash meets difficulty
+        block_hash = block.get('hash', '')
+        difficulty = block.get('difficulty', 0)
+        
+        if not self.difficulty_system.validate_block_hash(block_hash, difficulty):
+            return False, f"Hash does not meet difficulty {difficulty} requirement"
+        
+        # Validate previous hash (get from blockchain)
+        try:
+            latest_block = self.blockchain_manager.get_latest_block()
+            if latest_block:
+                expected_prev_hash = latest_block.get('hash', '')
+                if block.get('previous_hash') != expected_prev_hash:
+                    return False, f"Previous hash mismatch: expected {expected_prev_hash[:16]}..., got {block.get('previous_hash', '')[:16]}..."
+        except Exception as e:
+            safe_print(f"⚠️  Could not validate previous hash: {e}")
+        
+        # Validate reward matches difficulty
+        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"
+        
+        safe_print(f"✅ Block validation passed: Hash meets difficulty {difficulty}, Reward: {actual_reward} LKC")
+        return True, ""
+    
+    def _clear_transactions_from_mempool(self, transactions: List[Dict]):
+        """Remove mined transactions from mempool"""
+        try:
+            for tx in transactions:
+                # Skip reward transactions (they were created during mining)
+                if tx.get('type') == 'reward' and tx.get('from') == 'network':
+                    continue
+                
+                tx_hash = tx.get('hash')
+                if tx_hash:
+                    # Remove from mempool manager if available
+                    try:
+                        self.mempool_manager.remove_transaction(tx_hash)
+                    except:
+                        pass  # Silent fail if method doesn't exist
+            
+            safe_print(f"🧹 Cleared {len(transactions)} transactions from mempool")
+            
+        except Exception as e:
+            safe_print(f"⚠️  Error clearing mempool: {e}")
+
+    def _calculate_final_reward(self, transactions: List[Dict], actual_mining_time: float) -> float:
+        """Calculate final reward using actual mining time"""
+        total_reward = 0.0
+
+        for tx in transactions:
+            tx_type = tx.get('type')
+            
+            if tx_type == 'genesis_bill':
+                denomination = tx.get('denomination', 0)
+                bill_reward = self.difficulty_system.calculate_mining_reward(denomination, actual_mining_time)
+                total_reward += bill_reward
+            elif tx_type == 'transaction':
+                total_reward += tx.get('fee', 0)
+            elif tx_type == 'reward':
+                total_reward += tx.get('amount', 0)
+
+        if total_reward == 0:
+            total_reward = 1.0
+
+        return total_reward
+
+    def save_mining_history(self):
+        """Save mining history to storage"""
+        self.data_manager.save_mining_history(self.mining_history)
+
+    def start_mining(self):
+        """Start the mining process"""
         if self.is_mining:
             return
 
@@ -666,51 +1088,20 @@ class Miner:
         if self.mining_started_callback:
             self.mining_started_callback()
 
-        if mining_type == 'transfer':
-            self.mine_transfers()
-        elif mining_type == 'gtx_genesis':
-            self.mine_genesis_blocks()
-        elif mining_type == 'reward':
-            self.mine_rewards()
-        else:
-            raise ValueError("Invalid mining type. Choose 'transfer', 'gtx_genesis', or 'reward'.")
-
     def stop_mining(self):
-        """Stop the mining process."""
+        """Stop the mining process"""
         self.is_mining = False
         self.should_stop_mining = True
         if self.mining_thread and self.mining_thread.is_alive():
             self.mining_thread.join()
 
-    def mine_transfers(self):
-        """Mine transfer transactions."""
-        while self.is_mining:
-            # Fetch transactions from the mempool
-            transactions = self.mempool_manager.get_pending_transactions()
-            if not transactions:
-                continue
-
-            # Mine a block with the transactions
-            block = self.blockchain_manager.create_block(transactions)
-            self.blockchain_manager.add_block(block)
-            self.mining_stats["transfers_mined"] += 1
-
-    def mine_genesis_blocks(self):
-        """Mine GTX genesis blocks."""
-        while self.is_mining:
-            # Create a genesis block
-            genesis_block = self.blockchain_manager.create_genesis_block()
-            self.blockchain_manager.add_block(genesis_block)
-            self.mining_stats["genesis_blocks_mined"] += 1
-
-    def mine_rewards(self):
-        """Mine rewards."""
-        while self.is_mining:
-            # Simulate mining rewards
-            reward = self.blockchain_manager.generate_reward()
-            self.blockchain_manager.add_reward(reward)
-            self.mining_stats["rewards_mined"] += 1
-
     def get_mining_stats(self):
-        """Return the current mining statistics."""
-        return self.mining_stats
+        """Return the current mining statistics"""
+        return {
+            "blocks_mined": self.blocks_mined,
+            "total_reward": self.total_reward,
+            "current_hash": self.current_hash,
+            "current_nonce": self.current_nonce,
+            "hash_rate": self.hash_rate,
+            "mining_history": len(self.mining_history)
+        }

{lunalib-1.6.0.dist-info → lunalib-1.6.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lunalib
-Version: 1.6.0
+Version: 1.6.7
 Summary: Cryptocurrency Ecosystem library (LunaLib)
 Home-page: 
 Author: Ling Lin

{lunalib-1.6.0.dist-info → lunalib-1.6.7.dist-info}/RECORD

@@ -1,10 +1,12 @@
 lunalib/__init__.py,sha256=fEvoHvfcC6ilDGQrhXaVmcdB4yDmuijxz6YZHkjbuBg,527
 lunalib/cli.py,sha256=SyuJIhvqld-XL9ks9XFOuyqVb44qyBUbahlqE_RDVkM,524
 lunalib/luna_lib.py,sha256=ue9Bs93xjpg7_GHSUJPKBhf8nF5YcbCIdoMIu-jDgG4,2748
-lunalib/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lunalib/core/__init__.py,sha256=V86B0jI8snFIg8yCyd_Qoi2Tl6elQn_1cT-oeR6Ig3s,361
 lunalib/core/blockchain.py,sha256=dY_zQXzT8wufrinN8rGlpDTHM_M1yejfKEIm6_s78io,36564
 lunalib/core/crypto.py,sha256=R_f2sj7ASNnMW8Dtf2LIWTw-vCUjXD33zJPqPcPQVB8,10684
+lunalib/core/daemon.py,sha256=h8I68axWR78I8w5eOrBBQwfTeAxGqOKKW0RtLoQ52yM,16189
 lunalib/core/mempool.py,sha256=itYFGQEuUde0Xh6WXcEz_n8hDsNhxkEAlRQ5g_Qiygg,14845
+lunalib/core/p2p.py,sha256=cj3dda05oL6W5oMsvJ_HT3U0qr1FL6DR-YI78k3InKg,13784
 lunalib/core/sm2.py,sha256=Eq8Er3XQW5rYJXwaPT5vw5NoVXbSWhyuvjoG1LMo-NQ,23454
 lunalib/core/wallet.py,sha256=RNrEI7_tsaJOLcCJoTy_lLj22bc_bJtoO7iR3C3u7Ls,57435
 lunalib/core/wallet_manager.py,sha256=KK58hrr_xF1vZ4qI6x_BJqrs9XXh5m0XbZYnZmi9yoU,26031
@@ -13,10 +15,10 @@ lunalib/gtx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lunalib/gtx/bill_registry.py,sha256=J1TivYIzmJEVQHNJrZxqOOEbUSlJs7rQIXfSA90ztL4,4333
 lunalib/gtx/digital_bill.py,sha256=xi2d7RVBGFwDOr8ulMCgvXXebHKl9LeeW9f5H4j_P_A,10977
 lunalib/gtx/genesis.py,sha256=dDiLz-jW0zr5WUifYo9lzsrafQGOuZ9oakv_TX6QdPg,16028
-lunalib/mining/__init__.py,sha256=Y6qgk4b7TCzICfjk55wJsDghea5aQ-SN2aRqRdKTf_8,31
-lunalib/mining/cuda_manager.py,sha256=PUnmVvpu98OTZNdKIIYpVXnY__Ng4pHyZoh8wU-tDCM,5174
-lunalib/mining/difficulty.py,sha256=tzIYmdcm1Xr9-8wyTwwkXJvJoGDyE77o_nu9d81VGvI,3927
-lunalib/mining/miner.py,sha256=LydkuXgfjpFNXPVnd6zQp8ZJFjaxBvy3Ou-n8mqeYiU,31261
+lunalib/mining/__init__.py,sha256=kOwXt_fwjHLUvV3XxieG2LZyKMW316brXLF8V8lHBUo,193
+lunalib/mining/cuda_manager.py,sha256=VjVx9KLhT2F1jOOhva8ioGP32oQIAciZjf1irWl1jJY,5136
+lunalib/mining/difficulty.py,sha256=hKCtvEovb4le5Fnhz6Mm8-Cugjm_CduJnZA2aNC2eyU,5326
+lunalib/mining/miner.py,sha256=nGzfv4oK1evDXeYyS6lzaAWc8IolFrO99F0ZucBH3Ec,47715
 lunalib/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lunalib/storage/cache.py,sha256=U-riY8OTzxCOpl8yvhpbU3YUysEKgrPlmhO4F4cI9FM,5352
 lunalib/storage/database.py,sha256=2f3Ie6JnuK7L0YGtAdZt5mgj90pokneXhSQKUyvx8Pc,8219
@@ -25,7 +27,7 @@ lunalib/transactions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 lunalib/transactions/security.py,sha256=cQJRasJ37Z8mJo8gt0JJOb0_M9CQ0QScr67y3M_NP4Q,10309
 lunalib/transactions/transactions.py,sha256=3PgyW8gDQwY-gAPGY_T3m7RE_9HzEIOjTf6CWCsOKFY,18151
 lunalib/transactions/validator.py,sha256=FQ-jVjj8VoVTlq65blB_hprAwJOtpc2peYdQk_L2xmg,2730
-lunalib-1.6.0.dist-info/METADATA,sha256=4JfUdL6HER3Sa5gkTRSzLP67SZZ_apBLQ8HgX0mQ05c,774
-lunalib-1.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lunalib-1.6.0.dist-info/top_level.txt,sha256=eLcoOCtOwfvoqUu5g5CNBZB9bdhGXbTwmjuOM7i8ylw,8
-lunalib-1.6.0.dist-info/RECORD,,
+lunalib-1.6.7.dist-info/METADATA,sha256=XkB0ZGSCQ8QoUy3XSv17UOPTAENS0ZrY1m_H_fBdgZU,774
+lunalib-1.6.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lunalib-1.6.7.dist-info/top_level.txt,sha256=eLcoOCtOwfvoqUu5g5CNBZB9bdhGXbTwmjuOM7i8ylw,8
+lunalib-1.6.7.dist-info/RECORD,,