astreum 0.1.18__py3-none-any.whl → 0.1.19__py3-none-any.whl

astreum/node/__init__.py

@@ -1,475 +1,447 @@
-# import time
-# import threading
-# from typing import List
-# from cryptography.hazmat.primitives.asymmetric import ed25519
-# from cryptography.hazmat.primitives import serialization
+import time
+import threading
+from typing import List
+from cryptography.hazmat.primitives.asymmetric import ed25519
+from cryptography.hazmat.primitives import serialization
 
-# from .relay import Relay, Topic
-# from .machine import AstreumMachine
-# from .utils import hash_data
-# from .validation.block import Block
-# from .storage import Storage
+from .relay import Relay, Topic
+from ..machine import AstreumMachine
+from .utils import hash_data
+from .validation.block import Block
+from .storage import Storage
 
-# # Import our validation components using the new functional approach
-# from .validation import (
-#     validate_block,
-#     create_block,
-#     create_genesis_block,
-#     compute_vdf,
-#     verify_vdf,
-#     select_validator,
-#     select_validator_for_slot,
-#     get_validator_stake,
-#     is_validator,
-#     VALIDATION_ADDRESS,
-#     BURN_ADDRESS,
-#     MIN_STAKE_AMOUNT,
-#     SLOT_DURATION,
-#     VDF_DIFFICULTY
-# )
-# from .validation.state import (
-#     add_block_to_state,
-#     validate_and_apply_block,
-#     create_account_state,
-#     get_validator_for_slot,
-#     select_best_chain,
-#     compare_chains,
-#     get_validator_set
-# )
-# from .validation.adapter import BlockAdapter, TransactionAdapter
-
-# class Node:
-#     def __init__(self, config: dict):
-#         # Ensure config is a dictionary, but allow it to be None
-#         self.config = config if config is not None else {}
-        
-#         # Handle validation key if provided
-#         self.validation_private_key = None
-#         self.validation_public_key = None
-#         self.is_validator = False
-        
-#         # Extract validation private key from config
-#         if 'validation_private_key' in self.config:
-#             try:
-#                 key_bytes = bytes.fromhex(self.config['validation_private_key'])
-#                 self.validation_private_key = ed25519.Ed25519PrivateKey.from_private_bytes(key_bytes)
-#                 self.validation_public_key = self.validation_private_key.public_key()
-#                 self.is_validator = True
+class Node:
+    def __init__(self, config: dict):
+        # Ensure config is a dictionary, but allow it to be None
+        self.config = config if config is not None else {}
+        
+        # Handle validation key if provided
+        self.validation_private_key = None
+        self.validation_public_key = None
+        self.is_validator = False
+        
+        # Extract validation private key from config
+        if 'validation_private_key' in self.config:
+            try:
+                key_bytes = bytes.fromhex(self.config['validation_private_key'])
+                self.validation_private_key = ed25519.Ed25519PrivateKey.from_private_bytes(key_bytes)
+                self.validation_public_key = self.validation_private_key.public_key()
+                self.is_validator = True
                 
-#                 # Set validation_route to True in config so relay will join validation route
-#                 self.config['validation_route'] = True
-#                 print(f"Node is configured as a validator with validation key")
-#             except Exception as e:
-#                 print(f"Error loading validation private key: {e}")
-        
-#         # Initialize relay with our config
-#         self.relay = Relay(self.config)
-        
-#         # Get the node_id from relay
-#         self.node_id = self.relay.node_id
-        
-#         # Initialize storage
-#         self.storage = Storage(self.config)
-#         self.storage.node = self  # Set the storage node reference to self
-        
-#         # Initialize blockchain state
-#         self.blockchain = create_account_state(self.config)
-        
-#         # Store our validator info if we're a validator
-#         if self.is_validator and self.validation_public_key:
-#             self.validator_address = self.validation_public_key.public_bytes(
-#                 encoding=serialization.Encoding.Raw, 
-#                 format=serialization.PublicFormat.Raw
-#             )
-#             self.validator_private_bytes = self.validation_private_key.private_bytes(
-#                 encoding=serialization.Encoding.Raw,
-#                 format=serialization.PrivateFormat.Raw,
-#                 encryption_algorithm=serialization.NoEncryption()
-#             )
-#             print(f"Registered validator with address: {self.validator_address.hex()}")
-#         else:
-#             self.validator_address = None
-#             self.validator_private_bytes = None
-        
-#         # Latest block of the chain this node is following
-#         self.latest_block = None
-#         self.followed_chain_id = self.config.get('followed_chain_id', None)
-        
-#         # Initialize machine
-#         self.machine = AstreumMachine(node=self)
-        
-#         # Register message handlers
-#         self.relay.message_handlers[Topic.PEER_ROUTE] = self._handle_peer_route
-#         self.relay.message_handlers[Topic.PING] = self._handle_ping
-#         self.relay.message_handlers[Topic.PONG] = self._handle_pong
-#         self.relay.message_handlers[Topic.OBJECT_REQUEST] = self._handle_object_request
-#         self.relay.message_handlers[Topic.OBJECT_RESPONSE] = self._handle_object_response
-#         self.relay.message_handlers[Topic.ROUTE_REQUEST] = self._handle_route_request
-#         self.relay.message_handlers[Topic.ROUTE] = self._handle_route
-#         self.relay.message_handlers[Topic.LATEST_BLOCK_REQUEST] = self._handle_latest_block_request
-#         self.relay.message_handlers[Topic.LATEST_BLOCK] = self._handle_latest_block
-#         self.relay.message_handlers[Topic.TRANSACTION] = self._handle_transaction
-#         self.relay.message_handlers[Topic.BLOCK_REQUEST] = self._handle_block_request
-#         self.relay.message_handlers[Topic.BLOCK_RESPONSE] = self._handle_block_response
-        
-#         # Initialize latest block from storage if available
-#         self._initialize_latest_block()
-        
-#         # Candidate chains that might be adopted
-#         self.candidate_chains = {}  # chain_id -> {'latest_block': block, 'timestamp': time.time()}
-#         self.pending_blocks = {}  # block_hash -> {'block': block, 'timestamp': time.time()}
-        
-#         # Threads for validation and chain monitoring
-#         self.running = False
-#         self.main_chain_validation_thread = None
-#         self.candidate_chain_validation_thread = None
-        
-#         # Pending transactions for a block
-#         self.pending_transactions = {}  # tx_hash -> {'transaction': tx, 'timestamp': time.time()}
-        
-#         # Last block production attempt time
-#         self.last_block_attempt_time = 0
+                # Set validation_route to True in config so relay will join validation route
+                self.config['validation_route'] = True
+                print(f"Node is configured as a validator with validation key")
+            except Exception as e:
+                print(f"Error loading validation private key: {e}")
+        
+        # Initialize relay with our config
+        self.relay = Relay(self.config)
+        
+        # Get the node_id from relay
+        self.node_id = self.relay.node_id
+        
+        # Initialize storage
+        self.storage = Storage(self.config)
+        self.storage.node = self  # Set the storage node reference to self
+        
+        # Initialize blockchain state
+        self.blockchain = create_account_state(self.config)
+        
+        # Store our validator info if we're a validator
+        if self.is_validator and self.validation_public_key:
+            self.validator_address = self.validation_public_key.public_bytes(
+                encoding=serialization.Encoding.Raw, 
+                format=serialization.PublicFormat.Raw
+            )
+            self.validator_private_bytes = self.validation_private_key.private_bytes(
+                encoding=serialization.Encoding.Raw,
+                format=serialization.PrivateFormat.Raw,
+                encryption_algorithm=serialization.NoEncryption()
+            )
+            print(f"Registered validator with address: {self.validator_address.hex()}")
+        else:
+            self.validator_address = None
+            self.validator_private_bytes = None
+        
+        # Latest block of the chain this node is following
+        self.latest_block = None
+        self.followed_chain_id = self.config.get('followed_chain_id', None)
+        
+        # Initialize machine
+        self.machine = AstreumMachine(node=self)
+        
+        # Register message handlers
+        self.relay.message_handlers[Topic.PEER_ROUTE] = self._handle_peer_route
+        self.relay.message_handlers[Topic.PING] = self._handle_ping
+        self.relay.message_handlers[Topic.PONG] = self._handle_pong
+        self.relay.message_handlers[Topic.OBJECT_REQUEST] = self._handle_object_request
+        self.relay.message_handlers[Topic.OBJECT_RESPONSE] = self._handle_object_response
+        self.relay.message_handlers[Topic.ROUTE_REQUEST] = self._handle_route_request
+        self.relay.message_handlers[Topic.ROUTE] = self._handle_route
+        self.relay.message_handlers[Topic.LATEST_BLOCK_REQUEST] = self._handle_latest_block_request
+        self.relay.message_handlers[Topic.LATEST_BLOCK] = self._handle_latest_block
+        self.relay.message_handlers[Topic.TRANSACTION] = self._handle_transaction
+        self.relay.message_handlers[Topic.BLOCK_REQUEST] = self._handle_block_request
+        self.relay.message_handlers[Topic.BLOCK_RESPONSE] = self._handle_block_response
+        
+        # Initialize latest block from storage if available
+        self._initialize_latest_block()
+        
+        # Candidate chains that might be adopted
+        self.candidate_chains = {}  # chain_id -> {'latest_block': block, 'timestamp': time.time()}
+        self.pending_blocks = {}  # block_hash -> {'block': block, 'timestamp': time.time()}
+        
+        # Threads for validation and chain monitoring
+        self.running = False
+        self.main_chain_validation_thread = None
+        self.candidate_chain_validation_thread = None
+        
+        # Pending transactions for a block
+        self.pending_transactions = {}  # tx_hash -> {'transaction': tx, 'timestamp': time.time()}
+        
+        # Last block production attempt time
+        self.last_block_attempt_time = 0
 
-#     def start(self):
-#         """Start the node."""
-#         self.running = True
-        
-#         # Start relay
-#         self.relay.start()
-        
-#         # Start chain monitoring thread
-#         self.main_chain_validation_thread = threading.Thread(
-#             target=self._main_chain_validation_loop,
-#             name="MainChainValidation"
-#         )
-#         self.main_chain_validation_thread.daemon = True
-#         self.main_chain_validation_thread.start()
-        
-#         self.candidate_chain_validation_thread = threading.Thread(
-#             target=self._candidate_chain_validation_loop,
-#             name="CandidateChainValidation"
-#         )
-#         self.candidate_chain_validation_thread.daemon = True
-#         self.candidate_chain_validation_thread.start()
-        
-#         # Set up recurring block query tasks
-#         main_query_thread = threading.Thread(
-#             target=self._block_query_loop,
-#             args=('main',),
-#             daemon=True
-#         )
-#         main_query_thread.start()
-        
-#         validation_query_thread = threading.Thread(
-#             target=self._block_query_loop,
-#             args=('validation',),
-#             daemon=True
-#         )
-#         validation_query_thread.start()
-        
-#         print(f"Node started with ID {self.node_id.hex()}")
+    def start(self):
+        """Start the node."""
+        self.running = True
+        
+        # Start relay
+        self.relay.start()
+        
+        # Start chain monitoring thread
+        self.main_chain_validation_thread = threading.Thread(
+            target=self._main_chain_validation_loop,
+            name="MainChainValidation"
+        )
+        self.main_chain_validation_thread.daemon = True
+        self.main_chain_validation_thread.start()
+        
+        self.candidate_chain_validation_thread = threading.Thread(
+            target=self._candidate_chain_validation_loop,
+            name="CandidateChainValidation"
+        )
+        self.candidate_chain_validation_thread.daemon = True
+        self.candidate_chain_validation_thread.start()
+        
+        # Set up recurring block query tasks
+        main_query_thread = threading.Thread(
+            target=self._block_query_loop,
+            args=('main',),
+            daemon=True
+        )
+        main_query_thread.start()
+        
+        validation_query_thread = threading.Thread(
+            target=self._block_query_loop,
+            args=('validation',),
+            daemon=True
+        )
+        validation_query_thread.start()
+        
+        print(f"Node started with ID {self.node_id.hex()}")
 
-#     def stop(self):
-#         """Stop the node and all its services."""
-#         self.running = False
+    def stop(self):
+        """Stop the node and all its services."""
+        self.running = False
         
-#         # Stop all threads
-#         if self.main_chain_validation_thread and self.main_chain_validation_thread.is_alive():
-#             self.main_chain_validation_thread.join(timeout=1.0)
+        # Stop all threads
+        if self.main_chain_validation_thread and self.main_chain_validation_thread.is_alive():
+            self.main_chain_validation_thread.join(timeout=1.0)
             
-#         if self.candidate_chain_validation_thread and self.candidate_chain_validation_thread.is_alive():
-#             self.candidate_chain_validation_thread.join(timeout=1.0)
+        if self.candidate_chain_validation_thread and self.candidate_chain_validation_thread.is_alive():
+            self.candidate_chain_validation_thread.join(timeout=1.0)
             
-#         # Stop relay last
-#         if self.relay:
-#             self.relay.stop()
+        # Stop relay last
+        if self.relay:
+            self.relay.stop()
             
-#         print("Node stopped")
+        print("Node stopped")
     
-#     def _main_chain_validation_loop(self):
-#         """
-#         Main validation loop for the primary blockchain.
-#         This thread prioritizes validating blocks on the main chain we're following.
-#         """
-#         while self.running:
-#             try:
-#                 # Update latest block if we don't have one yet
-#                 if not self.latest_block and hasattr(self.blockchain, 'get_latest_block'):
-#                     self.latest_block = self.blockchain.get_latest_block()
+    def _main_chain_validation_loop(self):
+        """
+        Main validation loop for the primary blockchain.
+        This thread prioritizes validating blocks on the main chain we're following.
+        """
+        while self.running:
+            try:
+                # Update latest block if we don't have one yet
+                if not self.latest_block and hasattr(self.blockchain, 'get_latest_block'):
+                    self.latest_block = self.blockchain.get_latest_block()
                 
-#                 # Process any blocks that extend our main chain immediately
-#                 self._process_main_chain_blocks()
+                # Process any blocks that extend our main chain immediately
+                self._process_main_chain_blocks()
                 
-#                 # Attempt block production if we are a validator
-#                 if self.is_validator and self.validator_address:
-#                     self._attempt_block_production()
+                # Attempt block production if we are a validator
+                if self.is_validator and self.validator_address:
+                    self._attempt_block_production()
                 
-#                 # Cleanup old items
-#                 self._prune_pending_items()
+                # Cleanup old items
+                self._prune_pending_items()
                 
-#                 # Sleep to prevent high CPU usage
-#                 time.sleep(0.1)  # Short sleep for main chain validation
-#             except Exception as e:
-#                 print(f"Error in main chain validation loop: {e}")
-#                 time.sleep(1)  # Longer sleep on error
+                # Sleep to prevent high CPU usage
+                time.sleep(0.1)  # Short sleep for main chain validation
+            except Exception as e:
+                print(f"Error in main chain validation loop: {e}")
+                time.sleep(1)  # Longer sleep on error
                 
-#     def _candidate_chain_validation_loop(self):
-#         """
-#         Validation loop for candidate chains (potential forks).
-#         This thread handles validation of blocks from alternate chains 
-#         without slowing down the main chain processing.
-#         """
-#         while self.running:
-#             try:
-#                 # Process candidate chains
-#                 self._evaluate_candidate_chains()
+    def _candidate_chain_validation_loop(self):
+        """
+        Validation loop for candidate chains (potential forks).
+        This thread handles validation of blocks from alternate chains 
+        without slowing down the main chain processing.
+        """
+        while self.running:
+            try:
+                # Process candidate chains
+                self._evaluate_candidate_chains()
                 
-#                 # Prune old candidate chains
-#                 self._prune_candidate_chains()
+                # Prune old candidate chains
+                self._prune_candidate_chains()
                 
-#                 # Sleep longer for candidate chain validation (lower priority)
-#                 time.sleep(1)  # Longer sleep for candidate chain validation
-#             except Exception as e:
-#                 print(f"Error in candidate chain validation loop: {e}")
-#                 time.sleep(2)  # Even longer sleep on error
+                # Sleep longer for candidate chain validation (lower priority)
+                time.sleep(1)  # Longer sleep for candidate chain validation
+            except Exception as e:
+                print(f"Error in candidate chain validation loop: {e}")
+                time.sleep(2)  # Even longer sleep on error
                 
-#     def _prune_pending_items(self):
-#         """Remove old pending blocks and transactions."""
-#         current_time = time.time()
-        
-#         # Prune old pending blocks (older than 1 hour)
-#         blocks_to_remove = [
-#             block_hash for block_hash, data in self.pending_blocks.items()
-#             if current_time - data['timestamp'] > 3600  # 1 hour
-#         ]
-#         for block_hash in blocks_to_remove:
-#             del self.pending_blocks[block_hash]
+    def _prune_pending_items(self):
+        """Remove old pending blocks and transactions."""
+        current_time = time.time()
+        
+        # Prune old pending blocks (older than 1 hour)
+        blocks_to_remove = [
+            block_hash for block_hash, data in self.pending_blocks.items()
+            if current_time - data['timestamp'] > 3600  # 1 hour
+        ]
+        for block_hash in blocks_to_remove:
+            del self.pending_blocks[block_hash]
             
-#         # Prune old pending transactions (older than 30 minutes)
-#         txs_to_remove = [
-#             tx_hash for tx_hash, data in self.pending_transactions.items()
-#             if current_time - data['timestamp'] > 1800  # 30 minutes
-#         ]
-#         for tx_hash in txs_to_remove:
-#             del self.pending_transactions[tx_hash]
+        # Prune old pending transactions (older than 30 minutes)
+        txs_to_remove = [
+            tx_hash for tx_hash, data in self.pending_transactions.items()
+            if current_time - data['timestamp'] > 1800  # 30 minutes
+        ]
+        for tx_hash in txs_to_remove:
+            del self.pending_transactions[tx_hash]
             
-#     def _process_main_chain_blocks(self):
-#         """
-#         Process blocks that extend our current main chain.
-#         Prioritizes blocks that build on our latest block.
-#         """
-#         # Skip if we don't have a latest block yet
-#         if not self.latest_block:
-#             return
+    def _process_main_chain_blocks(self):
+        """
+        Process blocks that extend our current main chain.
+        Prioritizes blocks that build on our latest block.
+        """
+        # Skip if we don't have a latest block yet
+        if not self.latest_block:
+            return
             
-#         # Get the hash of our latest block
-#         latest_hash = self.latest_block.get_hash()
+        # Get the hash of our latest block
+        latest_hash = self.latest_block.get_hash()
         
-#         # Find any pending blocks that build on our latest block
-#         main_chain_blocks = []
-#         for block_hash, data in list(self.pending_blocks.items()):
-#             block = data['block']
+        # Find any pending blocks that build on our latest block
+        main_chain_blocks = []
+        for block_hash, data in list(self.pending_blocks.items()):
+            block = data['block']
             
-#             # Check if this block extends our latest block
-#             if block.previous == latest_hash:
-#                 main_chain_blocks.append(block)
+            # Check if this block extends our latest block
+            if block.previous == latest_hash:
+                main_chain_blocks.append(block)
                 
-#         # Process found blocks
-#         for block in main_chain_blocks:
-#             self._validate_and_process_main_chain_block(block)
+        # Process found blocks
+        for block in main_chain_blocks:
+            self._validate_and_process_main_chain_block(block)
             
-#     def _validate_and_process_main_chain_block(self, block: Block):
-#         """
-#         Validate and process a block that extends our main chain.
-        
-#         Args:
-#             block: Block to validate and process
-#         """
-#         try:
-#             # Validate block
-#             is_valid = validate_block(block, self.blockchain.get_accounts_at_block(block.previous), self.blockchain.get_blocks())
+    def _validate_and_process_main_chain_block(self, block: Block):
+        """
+        Validate and process a block that extends our main chain.
+        
+        Args:
+            block: Block to validate and process
+        """
+        try:
+            # Validate block
+            is_valid = validate_block(block, self.blockchain.get_accounts_at_block(block.previous), self.blockchain.get_blocks())
             
-#             if is_valid:
-#                 # Apply block to our state
-#                 success = validate_and_apply_block(self.blockchain, block)
-#                 if success:
-#                     print(f"Applied valid block {block.number} to blockchain state")
-#                     self._update_latest_block(block)
-#                     blocks_to_remove = [block.get_hash()]
-#                     for block_hash in blocks_to_remove:
-#                         if block_hash in self.pending_blocks:
-#                             del self.pending_blocks[block_hash]
-#                     print(f"Added block {block.number} to blockchain")
-#                     return True
-#         except Exception as e:
-#             print(f"Error validating main chain block {block.number}: {e}")
+            if is_valid:
+                # Apply block to our state
+                success = validate_and_apply_block(self.blockchain, block)
+                if success:
+                    print(f"Applied valid block {block.number} to blockchain state")
+                    self._update_latest_block(block)
+                    blocks_to_remove = [block.get_hash()]
+                    for block_hash in blocks_to_remove:
+                        if block_hash in self.pending_blocks:
+                            del self.pending_blocks[block_hash]
+                    print(f"Added block {block.number} to blockchain")
+                    return True
+        except Exception as e:
+            print(f"Error validating main chain block {block.number}: {e}")
             
-#         return False
+        return False
             
-#     def _evaluate_candidate_chains(self):
-#         """
-#         Evaluate candidate chains to determine if any should become our main chain.
-#         This will validate pending blocks and look for chains with higher cumulative difficulty.
-#         """
-#         # Skip if no candidate chains
-#         if not self.candidate_chains:
-#             return
+    def _evaluate_candidate_chains(self):
+        """
+        Evaluate candidate chains to determine if any should become our main chain.
+        This will validate pending blocks and look for chains with higher cumulative difficulty.
+        """
+        # Skip if no candidate chains
+        if not self.candidate_chains:
+            return
             
-#         # For each candidate chain, validate blocks and calculate metrics
-#         for chain_id, data in list(self.candidate_chains.items()):
-#             latest_candidate_block = data['latest_block']
+        # For each candidate chain, validate blocks and calculate metrics
+        for chain_id, data in list(self.candidate_chains.items()):
+            latest_candidate_block = data['latest_block']
             
-#             # Build the chain backwards
-#             chain_blocks = self._build_chain_from_latest(latest_candidate_block)
+            # Build the chain backwards
+            chain_blocks = self._build_chain_from_latest(latest_candidate_block)
             
-#             # Skip if we couldn't build a complete chain
-#             if not chain_blocks:
-#                 continue
+            # Skip if we couldn't build a complete chain
+            if not chain_blocks:
+                continue
                 
-#             # Validate the entire chain
-#             valid_chain = self._validate_candidate_chain(chain_blocks)
+            # Validate the entire chain
+            valid_chain = self._validate_candidate_chain(chain_blocks)
             
-#             # If valid and better than our current chain, switch to it
-#             if valid_chain and self._is_better_chain(chain_blocks):
-#                 self._switch_to_new_chain(chain_blocks)
+            # If valid and better than our current chain, switch to it
+            if valid_chain and self._is_better_chain(chain_blocks):
+                self._switch_to_new_chain(chain_blocks)
                 
-#     def _build_chain_from_latest(self, latest_block: Block) -> List[Block]:
-#         """
-#         Build a chain from the latest block back to a known point in our blockchain.
+    def _build_chain_from_latest(self, latest_block: Block) -> List[Block]:
+        """
+        Build a chain from the latest block back to a known point in our blockchain.
         
-#         Args:
-#             latest_block: Latest block in the candidate chain
+        Args:
+            latest_block: Latest block in the candidate chain
             
-#         Returns:
-#             List of blocks in the chain, ordered from oldest to newest
-#         """
-#         chain_blocks = [latest_block]
-#         current_block = latest_block
-        
-#         # Track visited blocks to avoid cycles
-#         visited = {current_block.get_hash()}
-        
-#         # Build chain backwards until we either:
-#         # 1. Find a block in our main chain
-#         # 2. Run out of blocks
-#         # 3. Detect a cycle
-#         while current_block.number > 0:
-#             previous_hash = current_block.previous
+        Returns:
+            List of blocks in the chain, ordered from oldest to newest
+        """
+        chain_blocks = [latest_block]
+        current_block = latest_block
+        
+        # Track visited blocks to avoid cycles
+        visited = {current_block.get_hash()}
+        
+        # Build chain backwards until we either:
+        # 1. Find a block in our main chain
+        # 2. Run out of blocks
+        # 3. Detect a cycle
+        while current_block.number > 0:
+            previous_hash = current_block.previous
             
-#             # Check if we have this block in our blockchain
-#             if hasattr(self.blockchain, 'has_block') and self.blockchain.has_block(previous_hash):
-#                 # Found connection to our main chain
-#                 previous_block = self.blockchain.get_block(previous_hash)
-#                 chain_blocks.insert(0, previous_block)
-#                 break
+            # Check if we have this block in our blockchain
+            if hasattr(self.blockchain, 'has_block') and self.blockchain.has_block(previous_hash):
+                # Found connection to our main chain
+                previous_block = self.blockchain.get_block(previous_hash)
+                chain_blocks.insert(0, previous_block)
+                break
                 
-#             # Check if block is in pending blocks
-#             elif previous_hash in self.pending_blocks:
-#                 previous_block = self.pending_blocks[previous_hash]['block']
+            # Check if block is in pending blocks
+            elif previous_hash in self.pending_blocks:
+                previous_block = self.pending_blocks[previous_hash]['block']
                 
-#                 # Check for cycles
-#                 if previous_hash in visited:
-#                     print(f"Cycle detected in candidate chain at block {previous_block.number}")
-#                     return []
+                # Check for cycles
+                if previous_hash in visited:
+                    print(f"Cycle detected in candidate chain at block {previous_block.number}")
+                    return []
                     
-#                 visited.add(previous_hash)
-#                 chain_blocks.insert(0, previous_block)
-#                 current_block = previous_block
-#             else:
-#                 # Missing block, cannot validate the chain
-#                 print(f"Missing block {previous_hash.hex()} in candidate chain")
-#                 return []
+                visited.add(previous_hash)
+                chain_blocks.insert(0, previous_block)
+                current_block = previous_block
+            else:
+                # Missing block, cannot validate the chain
+                print(f"Missing block {previous_hash.hex()} in candidate chain")
+                return []
                 
-#         return chain_blocks
+        return chain_blocks
         
-#     def _validate_candidate_chain(self, chain_blocks: List[Block]) -> bool:
-#         """
-#         Validate a candidate chain of blocks.
+    def _validate_candidate_chain(self, chain_blocks: List[Block]) -> bool:
+        """
+        Validate a candidate chain of blocks.
         
-#         Args:
-#             chain_blocks: List of blocks in the chain (oldest to newest)
+        Args:
+            chain_blocks: List of blocks in the chain (oldest to newest)
             
-#         Returns:
-#             True if the chain is valid, False otherwise
-#         """
-#         # Validate each block in the chain
-#         for i, block in enumerate(chain_blocks):
-#             # Skip first block, it's either genesis or a block we already have
-#             if i == 0:
-#                 continue
+        Returns:
+            True if the chain is valid, False otherwise
+        """
+        # Validate each block in the chain
+        for i, block in enumerate(chain_blocks):
+            # Skip first block, it's either genesis or a block we already have
+            if i == 0:
+                continue
                 
-#             # Validate block connections
-#             if block.previous != chain_blocks[i-1].get_hash():
-#                 print(f"Invalid chain: block {block.number} does not reference previous block")
-#                 return False
+            # Validate block connections
+            if block.previous != chain_blocks[i-1].get_hash():
+                print(f"Invalid chain: block {block.number} does not reference previous block")
+                return False
                 
-#             # Validate block
-#             is_valid = validate_block(block, self.blockchain.get_accounts_at_block(block.previous), self.blockchain.get_blocks())
-#             if not is_valid:
-#                 print(f"Invalid chain: block {block.number} is invalid")
-#                 return False
+            # Validate block
+            is_valid = validate_block(block, self.blockchain.get_accounts_at_block(block.previous), self.blockchain.get_blocks())
+            if not is_valid:
+                print(f"Invalid chain: block {block.number} is invalid")
+                return False
                 
-#         return True
+        return True
         
-#     def _is_better_chain(self, chain_blocks: List[Block]) -> bool:
-#         """
-#         Determine if a candidate chain is better than our current chain.
+    def _is_better_chain(self, chain_blocks: List[Block]) -> bool:
+        """
+        Determine if a candidate chain is better than our current chain.
         
-#         Args:
-#             chain_blocks: List of blocks in the candidate chain
+        Args:
+            chain_blocks: List of blocks in the candidate chain
             
-#         Returns:
-#             True if the candidate chain is better, False otherwise
-#         """
-#         # Get the latest block from the candidate chain
-#         candidate_latest = chain_blocks[-1]
-        
-#         # If we don't have a latest block, any valid chain is better
-#         if not self.latest_block:
-#             return True
+        Returns:
+            True if the candidate chain is better, False otherwise
+        """
+        # Get the latest block from the candidate chain
+        candidate_latest = chain_blocks[-1]
+        
+        # If we don't have a latest block, any valid chain is better
+        if not self.latest_block:
+            return True
             
-#         # Compare block numbers (longest chain rule)
-#         if candidate_latest.number > self.latest_block.number:
-#             print(f"Candidate chain is longer: {candidate_latest.number} vs {self.latest_block.number}")
-#             return True
+        # Compare block numbers (longest chain rule)
+        if candidate_latest.number > self.latest_block.number:
+            print(f"Candidate chain is longer: {candidate_latest.number} vs {self.latest_block.number}")
+            return True
             
-#         return False
-        
-#     def _switch_to_new_chain(self, chain_blocks: List[Block]):
-#         """
-#         Switch to a new chain by adding all blocks to our blockchain.
-        
-#         Args:
-#             chain_blocks: List of blocks in the chain (oldest to newest)
-#         """
-#         # Find the point where the chains diverge
-#         divergence_point = 0
-#         for i, block in enumerate(chain_blocks):
-#             # Check if we have this block in our blockchain
-#             if hasattr(self.blockchain, 'has_block') and self.blockchain.has_block(block.get_hash()):
-#                 divergence_point = i + 1
-#             else:
-#                 break
+        return False
+        
+    def _switch_to_new_chain(self, chain_blocks: List[Block]):
+        """
+        Switch to a new chain by adding all blocks to our blockchain.
+        
+        Args:
+            chain_blocks: List of blocks in the chain (oldest to newest)
+        """
+        # Find the point where the chains diverge
+        divergence_point = 0
+        for i, block in enumerate(chain_blocks):
+            # Check if we have this block in our blockchain
+            if hasattr(self.blockchain, 'has_block') and self.blockchain.has_block(block.get_hash()):
+                divergence_point = i + 1
+            else:
+                break
                 
-#         # Add all blocks after the divergence point
-#         for i in range(divergence_point, len(chain_blocks)):
-#             block = chain_blocks[i]
+        # Add all blocks after the divergence point
+        for i in range(divergence_point, len(chain_blocks)):
+            block = chain_blocks[i]
             
-#             # Add block to blockchain
-#             if hasattr(self.blockchain, 'add_block'):
-#                 try:
-#                     self.blockchain.add_block(block)
+            # Add block to blockchain
+            if hasattr(self.blockchain, 'add_block'):
+                try:
+                    self.blockchain.add_block(block)
                     
-#                     # Remove from pending blocks
-#                     block_hash = block.get_hash()
-#                     if block_hash in self.pending_blocks:
-#                         del self.pending_blocks[block_hash]
+                    # Remove from pending blocks
+                    block_hash = block.get_hash()
+                    if block_hash in self.pending_blocks:
+                        del self.pending_blocks[block_hash]
                         
-#                     print(f"Added block {block.number} to blockchain")
-#                 except Exception as e:
-#                     print(f"Error adding block {block.number} to blockchain: {e}")
-#                     return
+                    print(f"Added block {block.number} to blockchain")
+                except Exception as e:
+                    print(f"Error adding block {block.number} to blockchain: {e}")
+                    return
                     
-#         # Update latest block
-#         self._update_latest_block(chain_blocks[-1])
-#         print(f"Switched to new chain, latest block: {self.latest_block.number}")
+        # Update latest block
+        self._update_latest_block(chain_blocks[-1])
+        print(f"Switched to new chain, latest block: {self.latest_block.number}")

astreum/node/validation/__init__.py

@@ -1,84 +0,0 @@
-"""
-Validation module for the Astreum blockchain.
-
-This module provides functions for validating blocks and transactions,
-computing and verifying VDFs, and selecting validators.
-"""
-
-# Export validation functions
-from .block import (
-    validate_block,
-    create_block,
-    create_genesis_block,
-    select_validator,
-    select_validator_for_slot
-)
-
-# Export VDF functions
-from .vdf import (
-    compute_vdf,
-    verify_vdf,
-    validate_block_vdf
-)
-
-# Export account functions
-from .account import (
-    Account,
-    get_validator_stake,
-    is_validator
-)
-
-# Export constants
-from .constants import (
-    VALIDATION_ADDRESS,
-    BURN_ADDRESS,
-    MIN_STAKE_AMOUNT,
-    SLOT_DURATION,
-    VDF_DIFFICULTY
-)
-
-# Export blockchain state functions
-from .state import (
-    add_block_to_state,
-    validate_and_apply_block,
-    create_account_state,
-    get_validator_for_slot,
-    select_best_chain,
-    compare_chains,
-    get_validator_set
-)
-
-__all__ = [
-    # Block validation
-    'validate_block',
-    'create_block',
-    'create_genesis_block',
-    'select_validator',
-    'select_validator_for_slot',
-    
-    # VDF functions
-    'compute_vdf',
-    'verify_vdf',
-    'validate_block_vdf',
-    
-    # Account functions
-    'Account',
-    'get_validator_stake',
-    'is_validator',
-    
-    # Constants
-    'VALIDATION_ADDRESS',
-    'BURN_ADDRESS',
-    'MIN_STAKE_AMOUNT',
-    'SLOT_DURATION',
-    'VDF_DIFFICULTY',
-    
-    # Blockchain state
-    'add_block_to_state',
-    'validate_and_apply_block',
-    'create_account_state',
-    'get_validator_for_slot',
-    'select_best_chain',
-    'compare_chains',
-    'get_validator_set'
-]

astreum/node/validation/_block/__init__.py

@@ -1,12 +0,0 @@
-"""
-Block validation module for the Astreum blockchain.
-"""
-
-from .model import Block
-from .create import create_block, create_genesis_block
-
-__all__ = [
-    'Block',
-    'create_block',
-    'create_genesis_block',
-]

astreum/node/validation/block.py

@@ -1,29 +1,20 @@
 class Block:
+
+    def __init__(self):
+        pass
+    
     @classmethod
-    def from_bytes(cls, validator) -> 'Block':
+    def from_bytes(cls) -> 'Block':
         """
-        Deserialize an Account from its byte representation.
-        
-        Expected format: [balance, code, counter, data]
-        
-        The public_key (and optional secret_key) must be provided separately.
+        Deserialize a block from its byte representation.
     """
-        decoded = bytes_format.decode(data)
-        balance, code, counter, account_data = decoded
-        return cls(public_key, balance, code, counter, account_data, secret_key=secret_key)
-    
+        return cls()
+
     def to_bytes(self) -> bytes:
         """
-        Serialize the Account into bytes.
-        
-        Format: [balance, code, counter, data]
+        Serialize the block into bytes.
         """
-        return bytes_format.encode([
-            self.balance,
-            self.code,
-            self.counter,
-            self.data
-        ])
+        return b""
 
 class Chain:
     def __init__(self, latest_block: Block):

{astreum-0.1.18.dist-info → astreum-0.1.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.1.18
+Version: 0.1.19
 Summary: Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
 Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
 Project-URL: Homepage, https://github.com/astreum/lib

{astreum-0.1.18.dist-info → astreum-0.1.19.dist-info}/RECORD

@@ -21,7 +21,7 @@ astreum/lispeum/special/number/addition.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 astreum/machine/__init__.py,sha256=GOdZl1tS9uIJHbq5WVcplifMDPDLQroX7CVew-K2YbA,15262
 astreum/machine/environment.py,sha256=K0084U6B7wwjrDZ9b2_7cEcbBzsB7UOy_Zpbrr7B3GY,834
 astreum/machine/error.py,sha256=MvqBaZZt33rNELNhUJ2lER3TE3aS8WVqsWF2hz2AwoA,38
-astreum/node/__init__.py,sha256=zY4rD4knr8zPOmXX3eL-VENCQ-SGDccUQlTLEzzQaAA,20073
+astreum/node/__init__.py,sha256=obb-ap7YuRrMblNN7IAK79xEq__9aNBVzt1ciSTMvoU,18631
 astreum/node/utils.py,sha256=amGhNYHVMjvAO-9vBRAcim-S5LlLSRudqooBN-XPdm4,702
 astreum/node/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/node/crypto/ed25519.py,sha256=FRnvlN0kZlxn4j-sJKl-C9tqiz_0z4LZyXLj3KIj1TQ,1760
@@ -37,22 +37,21 @@ astreum/node/storage/merkle.py,sha256=sC7gfxPDUBgv3iiFs5PyxPgYbC4CoE-If5TQvkuoTG
 astreum/node/storage/patricia.py,sha256=zP4whShdB7yOFcEPLE1-1PIFfx_LdK8DyMSadnF0KT0,11588
 astreum/node/storage/storage.py,sha256=czJDhRK2rQxjOo88fhZ6j10f55RW8hWp1qq7c4yur6Y,10086
 astreum/node/storage/utils.py,sha256=CxKH9GbW31aVYs2Hwg1SirCykSnH_3_JisEayDrpOvY,5169
-astreum/node/validation/__init__.py,sha256=D9Gmc5x5V5xgXtM32axuDMSzgKiDCz7MiUShNnuFKYc,1636
+astreum/node/validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/node/validation/account.py,sha256=mKbJSi3sfQ5K9a4zwgdyPGqT3gXHekI55yDDVpzcolo,3650
-astreum/node/validation/block.py,sha256=ff4ZvMtIBuoY232SHxtRiwU3J-ku_hQOiqssHhIqbXY,934
+astreum/node/validation/block.py,sha256=KRvlpLZOmgJ3WJaSHsbk7ryh2Z1NsC2z-RWKWh1quBE,444
 astreum/node/validation/constants.py,sha256=ImIdLZFtMKx1iWg60YssEKl2tdDqZQnIa2JaJE6CX0o,422
 astreum/node/validation/stake.py,sha256=Z9EPM-X9c92fpsZIYsdVpvgz4DhxQViPM-RDktWUZq8,7141
-astreum/node/validation/state.py,sha256=QMXY7h4da-o79wMjJW93ixtepyhgcbJEf101yVuZurg,7661
 astreum/node/validation/transaction.py,sha256=Lovx1CWIxL45glFU-LBDxI1argBLxSmDAcg1TteaOlY,4701
 astreum/node/validation/vdf.py,sha256=HDdnqn9O_LicfE7SNCmncawKoR-ojLyjlpn74OvRNOU,2194
-astreum/node/validation/_block/__init__.py,sha256=n2HaMG_5cpa7y5xko-c7vbHz8rL-1wAGthmr8boNrCs,216
+astreum/node/validation/_block/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/node/validation/_block/create.py,sha256=apD9h92b9Y146zeppSzKNk_NJPgyBy7FhxoEkypQQNk,2515
 astreum/node/validation/_block/model.py,sha256=d7x3_tX2MPLnGODL_5_vNjQfLdYa405blc-zL9o8HFA,2589
 astreum/node/validation/_block/validate.py,sha256=niLexCNhEwUJLclyrdNZSvHcVa_J6jlu7J3FiWY7XBU,6232
 astreum/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/utils/bytes_format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
-astreum-0.1.18.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.1.18.dist-info/METADATA,sha256=k1Eptg-mbsR5Ddo2ky6JCIgkKlXO0WqovKe5zKDSZ3c,3312
-astreum-0.1.18.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-astreum-0.1.18.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.1.18.dist-info/RECORD,,
+astreum-0.1.19.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.1.19.dist-info/METADATA,sha256=MvTCByomvRA9Tf_iCyOyxeGCsSnNyHSrtoRChhbx0ls,3312
+astreum-0.1.19.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+astreum-0.1.19.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.1.19.dist-info/RECORD,,

{astreum-0.1.18.dist-info → astreum-0.1.19.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

astreum/node/validation/state.py

@@ -1,230 +0,0 @@
-"""
-Blockchain state management.
-
-This module manages the blockchain state, including accounts, blocks, and
-transactions.
-"""
-
-import time
-from typing import Dict, List, Optional, Set, Any
-from dataclasses import dataclass, field
-from ..utils import hash_data
-from ..models import Block, Transaction, Account as ModelAccount
-from .account import Account
-from .constants import VALIDATION_ADDRESS, BURN_ADDRESS, MIN_STAKE_AMOUNT
-
-
-class BlockchainState:
-    """
-    Manages the state of the blockchain.
-    
-    This class tracks the current state of accounts, blocks, and transactions,
-    and provides methods to update the state with new blocks and transactions.
-    """
-    
-    def __init__(self, config: Optional[dict] = None):
-        """
-        Initialize blockchain state.
-        
-        Args:
-            config: Optional configuration
-        """
-        self.config = config or {}
-        
-        # Dictionaries to track blockchain state
-        self.accounts = {}  # address -> Account
-        self.blocks = {}  # hash -> Block
-        self.transactions = {}  # hash -> Transaction
-        
-        # Track the latest block
-        self.latest_block = None
-        
-        # Pending transactions
-        self.pending_transactions = set()  # Set of transaction hashes
-        
-        # State of validators and stakes
-        self.validators = {}  # address -> stake amount
-        
-        # Initialize the genesis block if not provided
-        if not self.latest_block:
-            self._initialize_genesis()
-    
-    def _initialize_genesis(self):
-        """Initialize the genesis block and state."""
-        # In a full implementation, this would initialize the genesis
-        # block and state from configuration
-        print("Initializing genesis block and state")
-    
-    def add_block(self, block: Block) -> bool:
-        """
-        Add a block to the blockchain state.
-        
-        Args:
-            block: Block to add
-            
-        Returns:
-            True if block was added successfully, False otherwise
-        """
-        # Convert block to validation format directly
-        validation_block = {
-            'number': block.number,
-            'timestamp': block.time,
-            'producer': block.validator.public_key if block.validator else b'',
-            'previous': block.previous.get_hash() if block.previous else b'',
-            'transactions': self._extract_transactions(block),
-            'vdf_proof': block.signature[:8],  # Use part of signature as VDF proof for demo
-            'signature': block.signature
-        }
-        
-        # Check for duplicate (already processed) blocks
-        block_hash = block.get_hash()
-        if block_hash in self.blocks:
-            print(f"Block {block_hash.hex()} already in blockchain")
-            return True
-        
-        # Convert block's accounts to validation accounts
-        account_dict = {}
-        # Here we would deserialize the accounts data from the block
-        # In a real implementation, this would reconstruct accounts from serialized data
-        
-        # For now, we'll just log that we would process the block
-        print(f"Processing block at height {block.number}")
-        
-        # Add the block to our state
-        self.blocks[block_hash] = block
-        
-        # Update latest block if this is a new latest block
-        if not self.latest_block or block.number > self.latest_block.number:
-            self.latest_block = block
-        
-        # Process transactions in the block
-        # This would update account states, apply transaction effects, etc.
-        
-        return True
-    
-    def _extract_transactions(self, block: Block) -> List[dict]:
-        """
-        Extract transactions from a block.
-        
-        Args:
-            block: The model Block instance
-            
-        Returns:
-            List of transactions in validation format
-        """
-        transactions = []
-        # Parse transaction data from the block
-        # In a real implementation, this would deserialize the transactions field
-        # For now, we'll return an empty list as a placeholder
-        return transactions
-    
-    def add_transaction(self, transaction: Transaction) -> bool:
-        """
-        Add a transaction to the pending set.
-        
-        Args:
-            transaction: Transaction to add
-            
-        Returns:
-            True if transaction was added successfully, False otherwise
-        """
-        # Convert transaction to validation format directly
-        validation_tx = {
-            'sender': transaction.sender.public_key if transaction.sender else b'',
-            'recipient': transaction.receipient.public_key if transaction.receipient else b'',
-            'amount': transaction.amount,
-            'counter': transaction.counter,
-            'data': transaction.data,
-            'signature': transaction.signature
-        }
-        
-        # Generate a transaction hash
-        tx_hash = hash_data(str(validation_tx).encode())
-        
-        # Check for duplicate transactions
-        if tx_hash in self.transactions or tx_hash in self.pending_transactions:
-            print(f"Transaction {tx_hash.hex()} already processed or pending")
-            return False
-        
-        # Validate the transaction
-        # In a real implementation, this would check signature, sender balance, etc.
-        
-        # Add to pending transactions
-        self.pending_transactions.add(tx_hash)
-        
-        return True
-    
-    def is_staking_transaction(self, tx: Transaction) -> bool:
-        """
-        Check if a transaction is a staking transaction.
-        
-        Args:
-            tx: The model Transaction instance
-            
-        Returns:
-            True if this is a staking transaction, False otherwise
-        """
-        # A transaction is a staking transaction if it's sending to the validation address
-        if tx.receipient and hasattr(tx.receipient, 'public_key'):
-            return tx.receipient.public_key == VALIDATION_ADDRESS
-        return False
-    
-    def get_account(self, address: bytes) -> Optional[Account]:
-        """
-        Get an account by address.
-        
-        Args:
-            address: Account address
-            
-        Returns:
-            Account if found, None otherwise
-        """
-        return self.accounts.get(address)
-    
-    def get_validator_stake(self, address: bytes) -> int:
-        """
-        Get the stake of a validator.
-        
-        Args:
-            address: Validator address
-            
-        Returns:
-            Stake amount (0 if not a validator)
-        """
-        return self.validators.get(address, 0)
-    
-    def is_validator(self, address: bytes) -> bool:
-        """
-        Check if an address is a validator.
-        
-        Args:
-            address: Address to check
-            
-        Returns:
-            True if address is a validator, False otherwise
-        """
-        return self.get_validator_stake(address) >= MIN_STAKE_AMOUNT
-    
-    def get_pending_transactions(self) -> List[Transaction]:
-        """
-        Get all pending transactions.
-        
-        Returns:
-            List of pending transactions
-        """
-        # In a real implementation, this would return the actual transaction objects
-        # For now, we'll just return an empty list
-        return []
-
-
-def create_blockchain(config: Optional[dict] = None) -> BlockchainState:
-    """
-    Create a new blockchain state.
-    
-    Args:
-        config: Optional configuration
-        
-    Returns:
-        New BlockchainState instance
-    """
-    return BlockchainState(config)