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

lunalib/core/blockchain.py

@@ -736,7 +736,7 @@ class BlockchainManager:
                 transactions.append(enhanced_tx)
                 print(f"⬇️ Found outgoing transaction: {amount} LUN + {fee} fee")
         
-        print(f"📊 Scan complete for block #{block.get('index')}: {len(transactions)} transactions found")
+        print(f" Scan complete for block #{block.get('index')}: {len(transactions)} transactions found")
         return transactions
     def _handle_regular_transfers(self, tx: Dict, address_lower: str) -> Dict:
         """Handle regular transfer transactions that might be in different formats"""

lunalib/gtx/digital_bill.py

@@ -1,3 +1,11 @@
+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)
+safe_print("Warning: cryptography library not available. Using fallback methods.")
 import time
 import hashlib
 import secrets
@@ -12,7 +20,7 @@ try:
     from cryptography.exceptions import InvalidSignature
     CRYPTOGRAPHY_AVAILABLE = True
 except ImportError:
-    print("Warning: cryptography library not available. Using fallback methods.")
+    safe_print("Warning: cryptography library not available. Using fallback methods.")
     CRYPTOGRAPHY_AVAILABLE = False
 
 from .bill_registry import BillRegistry
@@ -182,7 +190,7 @@ class DigitalBill:
             
             return self.signature
         except Exception as e:
-            print(f"Cryptographic signing failed, using fallback: {e}")
+            safe_print(f"Cryptographic signing failed, using fallback: {e}")
             return self._sign_fallback(private_key)
     
     def _sign_fallback(self, private_key):

lunalib/gtx/genesis.py

@@ -48,7 +48,7 @@ class GTXGenesis:
                 return {'valid': False, 'error': 'Bill not found in registry'}
             
             # DEBUG: Print what we received
-            print(f"DEBUG: Full bill record: {bill_record}")
+            safe_print(f"DEBUG: Full bill record: {bill_record}")
             
             # Extract the actual bill_data from the metadata field
             bill_data = bill_record.get('metadata', {})
@@ -56,7 +56,7 @@ class GTXGenesis:
                 return {'valid': False, 'error': 'No bill data found in metadata'}
             
             # DEBUG: Print the extracted bill_data
-            print(f"DEBUG: Extracted bill_data: {bill_data}")
+            safe_print(f"DEBUG: Extracted bill_data: {bill_data}")
             
             # Extract signature components from bill_data (not from bill_record)
             public_key = bill_data.get('public_key')
@@ -68,10 +68,10 @@ class GTXGenesis:
             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}")
+            safe_print(f"🔍 GTXGenesis.verify_bill() for {front_serial}:")
+            safe_print(f"   Signature: {signature}")
+            safe_print(f"   Public Key: {public_key}")
+            safe_print(f"   Metadata Hash: {metadata_hash}")
             
             # Use the same verification logic as the endpoint
             verification_method = "unknown"
@@ -81,7 +81,7 @@ class GTXGenesis:
             if metadata_hash and signature == metadata_hash:
                 signature_valid = True
                 verification_method = "signature_is_metadata_hash"
-                print(f"✅ Verified: signature matches metadata_hash")
+                safe_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:
@@ -90,7 +90,7 @@ class GTXGenesis:
                 if signature == expected_signature:
                     signature_valid = True
                     verification_method = "metadata_hash_signature"
-                    print(f"Verified: hash(public_key + metadata_hash)")
+                    safe_print(f"Verified: hash(public_key + metadata_hash)")
             
             # METHOD 3: Check DigitalBill calculated hash
             elif signature_valid is None:
@@ -122,32 +122,31 @@ class GTXGenesis:
                     if signature == calculated_hash:
                         signature_valid = True
                         verification_method = "digital_bill_calculate_hash"
-                        print(f"Verified: DigitalBill.calculate_hash()")
+                        safe_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()")
+                        safe_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")
+                        safe_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}")
-                        
+                        safe_print(f"DigitalBill verification failed:")
+                        safe_print(f"   Calculated hash: {calculated_hash}")
+                        safe_print(f"   Signature: {signature}")
+                        safe_print(f"   Metadata hash: {metadata_hash}")
+                        safe_print(f"   Public key: {public_key}")
                 except Exception as e:
-                    print(f"DigitalBill verification error: {e}")
+                    safe_print(f"DigitalBill verification error: {e}")
                     import traceback
-                    print(f"Traceback: {traceback.format_exc()}")
+                    safe_print(f"Traceback: {traceback.format_exc()}")
             
             # METHOD 4: Check simple concatenation hash
             elif signature_valid is None and signature:
@@ -156,7 +155,7 @@ class GTXGenesis:
                 if signature == expected_simple_hash:
                     signature_valid = True
                     verification_method = "simple_hash"
-                    print(f"✅ Verified: hash(serial+denom+issued+timestamp)")
+                    safe_print(f"✅ Verified: hash(serial+denom+issued+timestamp)")
             
             # METHOD 5: Check bill JSON hash
             elif signature_valid is None:
@@ -173,19 +172,19 @@ class GTXGenesis:
                 if signature == bill_json_hash:
                     signature_valid = True
                     verification_method = "bill_json_hash"
-                    print(f"Verified: hash(bill_data_json)")
+                    safe_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")
+                safe_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")
+                safe_print(f"All verification methods failed")
             
             # Return result in same format as endpoint
             if signature_valid:
@@ -337,7 +336,7 @@ class GTXGenesis:
             return computed_hash == bill_info['hash']
             
         except Exception as e:
-            print(f"Bill verification error: {e}")
+            safe_print(f"Bill verification error: {e}")
             return False
     
     def _get_denomination_breakdown(self, bills: List[Dict]) -> Dict[int, int]:

lunalib/mining/__init__.py

@@ -0,0 +1 @@
+from .miner import GenesisMiner

lunalib/mining/miner.py

@@ -74,7 +74,7 @@ class GenesisMiner:
                 
                 safe_print(f"✅ Successfully mined GTX ${denomination:,} bill!")
                 safe_print(f"⏱️ Mining time: {mining_time:.2f}s")
-                safe_print(f"📊 Hash attempts: {mining_result['nonce']:,}")
+                safe_print(f" Hash attempts: {mining_result['nonce']:,}")
                 safe_print(f"🔗 Bill hash: {mining_result['hash'][:32]}...")
                 
                 # Convert to GTX Genesis transaction
@@ -174,7 +174,7 @@ class GenesisMiner:
                 safe_print(f"✅ Successfully mined and validated Transaction Block #{block_height}!")
                 safe_print(f"⏱️ Mining time: {mining_time:.2f}s")
                 safe_print(f"💰 Block reward: {block['reward']:.6f} LUN")
-                safe_print(f"📊 Transactions: {block['transaction_count']}")
+                safe_print(f" Transactions: {block['transaction_count']}")
                 safe_print(f"🔗 Block hash: {mining_result['hash'][:32]}...")
                 
                 # Submit block to blockchain
@@ -298,7 +298,7 @@ class GenesisMiner:
             # Calculate merkleroot from transactions
             merkleroot = self._calculate_merkleroot(transactions)
             
-            print(f"📊 Mining proof components:")
+            print(f"  Mining proof components:")
             print(f"  Block hash: {block_hash[:16]}...")
             print(f"  Difficulty: {difficulty}")
             print(f"  Nonce: {nonce}")
@@ -623,4 +623,94 @@ class GenesisMiner:
             return {
                 "network_connected": False,
                 "error": str(e)
-            }
+            }
+
+class Miner:
+    """
+    Miner class that uses lunalib directly to mine transfers, GTX genesis blocks, and rewards.
+    """
+
+    def __init__(self, config, data_manager, mining_started_callback=None, mining_completed_callback=None, block_mined_callback=None):
+        self.config = config
+        self.data_manager = data_manager
+        self.is_mining = False
+        self.blocks_mined = 0
+        self.total_reward = 0.0
+        self.mining_started_callback = mining_started_callback
+        self.mining_completed_callback = mining_completed_callback
+        self.block_mined_callback = block_mined_callback
+
+        self.mining_history = self.data_manager.load_mining_history()
+
+        # Use lunalib components
+        self.blockchain_manager = BlockchainManager(endpoint_url=config.node_url)
+        self.difficulty_system = DifficultySystem()
+        self.cuda_manager = CUDAManager()
+
+        self.current_hash = ""
+        self.current_nonce = 0
+        self.hash_rate = 0
+        self.mining_thread = None
+        self.should_stop_mining = False
+
+    def start_mining(self, mining_type: str):
+        """
+        Start mining based on the type: 'transfer', 'gtx_genesis', or 'reward'.
+        """
+        if self.is_mining:
+            return
+
+        self.is_mining = True
+        self.should_stop_mining = False
+
+        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."""
+        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

lunalib/transactions/security.py

@@ -123,22 +123,22 @@ class TransactionSecurity:
             
             # For unsigned test transactions
             if signature in ["system", "unsigned", "test"]:
-                print(f"[SECURITY] Skipping signature check for system/unsigned transaction")
+                safe_print(f"[SECURITY] Skipping signature check for system/unsigned transaction")
                 return True
             
             # Check SM2 signature length (should be 128 hex chars = 64 bytes)
             if len(signature) != 128:
-                print(f"[SECURITY] Invalid SM2 signature length: {len(signature)} (expected 128)")
+                safe_print(f"[SECURITY] Invalid SM2 signature length: {len(signature)} (expected 128)")
                 return False
             
             # Check if all characters are valid hex
             if not all(c in "0123456789abcdefABCDEF" for c in signature):
-                print(f"[SECURITY] Signature contains non-hex characters")
+                safe_print(f"[SECURITY] Signature contains non-hex characters")
                 return False
             
             # Check public key format (should start with '04' for uncompressed)
             if not public_key.startswith('04'):
-                print(f"[SECURITY] Invalid public key format: {public_key[:20]}...")
+                safe_print(f"[SECURITY] Invalid public key format: {public_key[:20]}...")
                 return False
             
             # Use KeyManager for verification if available
@@ -148,15 +148,15 @@ class TransactionSecurity:
                 
                 # Verify signature
                 is_valid = self.key_manager.verify_signature(signing_data, signature, public_key)
-                print(f"[SECURITY] SM2 signature verification: {is_valid}")
+                safe_print(f"[SECURITY] SM2 signature verification: {is_valid}")
                 return is_valid
             
             # Fallback: Basic format check if SM2 not available
-            print(f"[SECURITY] SM2 not available, using basic signature validation")
+            safe_print(f"[SECURITY] SM2 not available, using basic signature validation")
             return len(signature) == 128 and signature.startswith(('04', '03', '02'))
             
         except Exception as e:
-            print(f"[SECURITY] Signature validation error: {e}")
+            safe_print(f"[SECURITY] Signature validation error: {e}")
             return False
     
     def _get_signing_data(self, transaction: Dict) -> str:
@@ -183,7 +183,7 @@ class TransactionSecurity:
     
     def _validate_signature(self, transaction: Dict) -> bool:
         """Legacy signature validation (for backward compatibility)"""
-        print(f"[SECURITY] Using legacy signature validation")
+        safe_print(f"[SECURITY] Using legacy signature validation")
         return self._validate_signature_sm2(transaction)
     
     def _check_rate_limit(self, address: str) -> bool:

lunalib/transactions/transactions.py

@@ -235,55 +235,55 @@ class TransactionManager:
             
             # System transactions are always valid
             if signature in ["system", "unsigned", "test"]:
-                print(f"[TRANSACTIONS] Skipping signature check for {signature} transaction")
+                safe_print(f"[TRANSACTIONS] Skipping signature check for {signature} transaction")
                 return True
             
             if not self.key_manager:
-                print("[TRANSACTIONS] No key manager available for verification")
+                safe_print("[TRANSACTIONS] No key manager available for verification")
                 return False
             
             # Check SM2 signature format
             if len(signature) != 128:
-                print(f"[TRANSACTIONS] Invalid SM2 signature length: {len(signature)} (expected 128)")
+                safe_print(f"[TRANSACTIONS] Invalid SM2 signature length: {len(signature)} (expected 128)")
                 return False
             
             # Get signing data (without public_key!)
             sign_data = self._get_signing_data(transaction)
             public_key = transaction.get("public_key", "")
             
-            print(f"[TRANSACTIONS VERIFY] Signing data length: {len(sign_data)}")
-            print(f"[TRANSACTIONS VERIFY] Signing data (first 100 chars): {sign_data[:100]}")
+            safe_print(f"[TRANSACTIONS VERIFY] Signing data length: {len(sign_data)}")
+            safe_print(f"[TRANSACTIONS VERIFY] Signing data (first 100 chars): {sign_data[:100]}")
             
             # Try to verify with KeyManager
-            print(f"[TRANSACTIONS] Attempting verification...")
+            safe_print(f"[TRANSACTIONS] Attempting verification...")
             is_valid = self.key_manager.verify_signature(sign_data, signature, public_key)
             
-            print(f"[TRANSACTIONS] SM2 signature verification result: {is_valid}")
+            safe_print(f"[TRANSACTIONS] SM2 signature verification result: {is_valid}")
             
             return is_valid
             
         except Exception as e:
-            print(f"[TRANSACTIONS] Verification error: {e}")
+            safe_print(f"[TRANSACTIONS] Verification error: {e}")
             import traceback
             traceback.print_exc()
             return False
     def _debug_signature_issue(self, transaction: Dict, sign_data: str, signature: str, public_key: str):
         """Debug why signature verification is failing"""
-        print("\n" + "="*60)
-        print("DEBUGGING SIGNATURE ISSUE")
-        print("="*60)
+        safe_print("\n" + "="*60)
+        safe_print("DEBUGGING SIGNATURE ISSUE")
+        safe_print("="*60)
         
         # 1. Check if we can sign and verify a simple test
-        print("\n1. Testing SM2 with simple message...")
+        safe_print("\n1. Testing SM2 with simple message...")
         test_message = "Simple test message"
         test_private = self.key_manager.generate_private_key()
         test_public = self.key_manager.derive_public_key(test_private)
         test_sig = self.key_manager.sign_data(test_message, test_private)
         test_valid = self.key_manager.verify_signature(test_message, test_sig, test_public)
-        print(f"   Simple test verification: {test_valid}")
+        safe_print(f"   Simple test verification: {test_valid}")
         
         # 2. Try to recreate what was signed during transaction creation
-        print("\n2. Reconstructing original transaction data...")
+        safe_print("\n2. Reconstructing original transaction data...")
         # Create the exact transaction data that should have been signed
         reconstructed = {
             "amount": float(transaction["amount"]),
@@ -298,23 +298,23 @@ class TransactionManager:
         
         import json
         reconstructed_json = json.dumps(reconstructed, sort_keys=True)
-        print(f"   Reconstructed JSON: {reconstructed_json}")
-        print(f"   Current signing data: {sign_data}")
-        print(f"   Are they equal? {reconstructed_json == sign_data}")
-        print(f"   Length difference: {len(reconstructed_json)} vs {len(sign_data)}")
+        safe_print(f"   Reconstructed JSON: {reconstructed_json}")
+        safe_print(f"   Current signing data: {sign_data}")
+        safe_print(f"   Are they equal? {reconstructed_json == sign_data}")
+        safe_print(f"   Length difference: {len(reconstructed_json)} vs {len(sign_data)}")
         
         # 3. Check for whitespace differences
-        print("\n3. Checking for whitespace differences...")
-        print(f"   Reconstructed has spaces: {' ' in reconstructed_json}")
-        print(f"   Sign data has spaces: {' ' in sign_data}")
+        safe_print("\n3. Checking for whitespace differences...")
+        safe_print(f"   Reconstructed has spaces: {' ' in reconstructed_json}")
+        safe_print(f"   Sign data has spaces: {' ' in sign_data}")
         
         # 4. Check float formatting
-        print("\n4. Checking float formatting...")
-        print(f"   Amount in tx: {transaction['amount']} (type: {type(transaction['amount'])})")
-        print(f"   Amount in reconstructed: {reconstructed['amount']} (type: {type(reconstructed['amount'])})")
+        safe_print("\n4. Checking float formatting...")
+        safe_print(f"   Amount in tx: {transaction['amount']} (type: {type(transaction['amount'])})")
+        safe_print(f"   Amount in reconstructed: {reconstructed['amount']} (type: {type(reconstructed['amount'])})")
         
         # 5. Try different JSON serialization options
-        print("\n5. Trying different JSON formats...")
+        safe_print("\n5. Trying different JSON formats...")
         formats = [
             ("Compact", lambda x: json.dumps(x, sort_keys=True, separators=(',', ':'))),
             ("Default", lambda x: json.dumps(x, sort_keys=True)),
@@ -324,9 +324,9 @@ class TransactionManager:
         for name, formatter in formats:
             formatted = formatter(reconstructed)
             is_valid_test = self.key_manager.verify_signature(formatted, signature, public_key)
-            print(f"   {name} format: {is_valid_test} (length: {len(formatted)})")
+            safe_print(f"   {name} format: {is_valid_test} (length: {len(formatted)})")
         
-        print("="*60 + "\n")
+        safe_print("="*60 + "\n")
     def assess_transaction_risk(self, transaction: Dict) -> Tuple[str, str]:
         """Assess transaction risk level"""
         return self.security.assess_risk(transaction)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lunalib
-Version: 1.5.2
+Version: 1.6.0
 Summary: Cryptocurrency Ecosystem library (LunaLib)
 Home-page: 
 Author: Ling Lin
@@ -10,10 +10,16 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+Requires-Dist: cryptography
+Requires-Dist: requests
+Requires-Dist: numpy
+Requires-Dist: pytest
+Requires-Dist: pandas
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
+Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 

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

@@ -2,7 +2,7 @@ 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/blockchain.py,sha256=gnlYSU1CIaa38bxByfKHlMpt8GMYpvib0EboVfNESek,36568
+lunalib/core/blockchain.py,sha256=dY_zQXzT8wufrinN8rGlpDTHM_M1yejfKEIm6_s78io,36564
 lunalib/core/crypto.py,sha256=R_f2sj7ASNnMW8Dtf2LIWTw-vCUjXD33zJPqPcPQVB8,10684
 lunalib/core/mempool.py,sha256=itYFGQEuUde0Xh6WXcEz_n8hDsNhxkEAlRQ5g_Qiygg,14845
 lunalib/core/sm2.py,sha256=Eq8Er3XQW5rYJXwaPT5vw5NoVXbSWhyuvjoG1LMo-NQ,23454
@@ -11,21 +11,21 @@ lunalib/core/wallet_manager.py,sha256=KK58hrr_xF1vZ4qI6x_BJqrs9XXh5m0XbZYnZmi9yo
 lunalib/core/wallet_sync_helper.py,sha256=CGfSBXvf8vg4SGsLaxsjGwHVbD9dmfcuMrZ_CO0J5lE,6282
 lunalib/gtx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lunalib/gtx/bill_registry.py,sha256=J1TivYIzmJEVQHNJrZxqOOEbUSlJs7rQIXfSA90ztL4,4333
-lunalib/gtx/digital_bill.py,sha256=EnQvAztMNE9uHuxXWmShEpNl084y-clHagK5s1Amvpc,10614
-lunalib/gtx/genesis.py,sha256=Mic48kI93fzMoz3Zm8xXGk8MXqUhfpLsNFLs8-ZJdCE,15939
-lunalib/mining/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=8MYsp3-ua5K-8FneHWfEkdOezWhluDRe3ACJeIGAA-0,27930
+lunalib/mining/miner.py,sha256=LydkuXgfjpFNXPVnd6zQp8ZJFjaxBvy3Ou-n8mqeYiU,31261
 lunalib/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lunalib/storage/cache.py,sha256=U-riY8OTzxCOpl8yvhpbU3YUysEKgrPlmhO4F4cI9FM,5352
 lunalib/storage/database.py,sha256=2f3Ie6JnuK7L0YGtAdZt5mgj90pokneXhSQKUyvx8Pc,8219
 lunalib/storage/encryption.py,sha256=59g8vFFPAkc_L7t2TXas9Rs4oB3JB1t5ikmDbs4aaqM,4399
 lunalib/transactions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lunalib/transactions/security.py,sha256=3q0ENtUD9C3C6FbocwzbDtMXcedKEpeUQdEBNUVSHXA,10269
-lunalib/transactions/transactions.py,sha256=3Y0Gu-vIdtIdIwj1z2oymIJ3LPPWsYTQULny-eVtvPA,18016
+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.5.2.dist-info/METADATA,sha256=D88XMMu1LCG1mmFt7NaavHGWndGw6nIPGUoKB1LZAvI,628
-lunalib-1.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lunalib-1.5.2.dist-info/top_level.txt,sha256=eLcoOCtOwfvoqUu5g5CNBZB9bdhGXbTwmjuOM7i8ylw,8
-lunalib-1.5.2.dist-info/RECORD,,
+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,,