astreum 0.1.13__py3-none-any.whl → 0.1.14__py3-none-any.whl

astreum/node/__init__.py

@@ -1,7 +1,9 @@
 import os
 import hashlib
 import time
-from typing import Tuple, Optional
+import threading
+import random
+from typing import Tuple, Optional, List
 import json
 from cryptography.hazmat.primitives.asymmetric import ed25519
 
@@ -71,6 +73,84 @@ class Node:
         # Candidate chains that might be adopted
         self.candidate_chains = {}  # chain_id -> {'latest_block': block, 'timestamp': time.time()}
         
+        # Block query timers for different routes
+        self.running = False
+        self.block_query_threads = []
+        
+    def start(self):
+        """Start the node and all its services."""
+        self.running = True
+        
+        # Start periodic block query thread for validation route
+        validation_query_thread = threading.Thread(
+            target=self._periodic_validation_route_query, 
+            daemon=True
+        )
+        validation_query_thread.start()
+        self.block_query_threads.append(validation_query_thread)
+        
+        print(f"Node started with ID {self.node_id.hex()}")
+        print(f"Listening on port {self.relay.incoming_port}")
+        
+    def stop(self):
+        """Stop the node and all its services."""
+        self.running = False
+        
+        # Stop all threads
+        for thread in self.block_query_threads:
+            if thread.is_alive():
+                thread.join(timeout=1.0)  # Give threads 1 second to shut down
+                
+        print("Node stopped")
+        
+    def _periodic_validation_route_query(self):
+        """Periodically query random peers in the validation route for latest blocks."""
+        while self.running:
+            try:
+                # Query 3 random peers from validation route for latest block
+                self._query_random_peers_for_latest_block(route_type=1, count=3)
+                
+                # Prune old candidate chains periodically
+                self._prune_candidate_chains()
+                
+                # Sleep according to validator status
+                if self.is_validator:
+                    # Validators check more frequently (every second)
+                    time.sleep(1)
+                else:
+                    # Regular nodes check less frequently (every 3 seconds)
+                    time.sleep(3)
+            except Exception as e:
+                print(f"Error in validation route query: {e}")
+                time.sleep(1)  # Sleep briefly before retrying
+                
+    def _query_random_peers_for_latest_block(self, route_type: int, count: int = 3):
+        """
+        Query random peers from specified route for latest block.
+        
+        Args:
+            route_type (int): Route type (0 for peer, 1 for validation)
+            count (int): Number of random peers to query
+        """
+        # Only continue if we're tracking this route
+        if not self.relay.is_tracking_route(route_type):
+            return
+            
+        # Get random peers from the route
+        random_peers = self.relay.get_random_peers_from_route(route_type, count)
+        
+        # Query each peer for latest block
+        for peer in random_peers:
+            try:
+                # Create empty request message
+                request_data = b''
+                
+                # Send request to peer
+                addr = (peer.ip, peer.port)
+                self.relay.send_message(request_data, Topic.LATEST_BLOCK_REQUEST, addr)
+            except Exception as e:
+                print(f"Error querying peer {peer.node_id.hex()}: {e}")
+    
     def _handle_ping(self, body: bytes, addr: Tuple[str, int], envelope):
         """
         Handle ping messages by storing peer info and responding with a pong.
@@ -383,10 +463,7 @@ class Node:
         in chain is in the previous field.
         """
         try:
-            # Check if we're in the validation route
-            # This is now already checked by the relay's _handle_message method
-            if not self.relay.is_in_validation_route():
-                return
+            # All nodes can process latest blocks now, regardless of route membership
             
             # Deserialize the block
             block = Block.from_bytes(body)
@@ -399,24 +476,28 @@ class Node:
                 if not self.followed_chain_id or block.chain_id != self.followed_chain_id:
                     self._add_candidate_chain(block)
                 return
-            
-            # Get our current latest block
-            our_latest = self.latest_block
-            
-            # Verify block hash links to our latest block
-            if our_latest and block.previous_hash == our_latest.hash:
-                # Process the valid block
-                self.machine.process_block(block)
                 
-                # Update our latest block
-                self.latest_block = block
-            # Check if this block is ahead of our current chain
-            elif our_latest and block.height > our_latest.height:
-                # Block is ahead but doesn't link directly to our latest
-                # Add to candidate chains for potential future adoption
-                self._add_candidate_chain(block)
-            
-            # No automatic broadcasting - nodes will request latest blocks when needed
+            # Only proceed if block chain_id matches what we're following
+            if self.followed_chain_id and block.chain_id != self.followed_chain_id:
+                return
+                
+            if not self.latest_block:
+                # We don't have a latest block, so this might be the first one we've seen
+                # Store it as our latest
+                self._update_latest_block(block)
+                return
+                
+            # If this block is newer than our latest, update our latest block
+            if block.height > self.latest_block.height:
+                # Verify chain continuity
+                if self.latest_block.hash_bytes in block.previous_blocks:
+                    # This is a valid continuation of our chain
+                    self._update_latest_block(block)
+                else:
+                    # This block doesn't build on our latest, check for forking
+                    # but continue tracking it as a candidate
+                    self._add_candidate_chain(block)
+                    
         except Exception as e:
             print(f"Error handling latest block: {e}")
     
@@ -506,17 +587,19 @@ class Node:
     
     def _add_candidate_chain(self, block):
         """
-        Add a block to candidate chains for potential future adoption.
+        Add a block to the candidate chains.
         
         Args:
-            block: The block to add as a candidate
+            block: Block to add
         """
         chain_id = block.chain_id
         
-        # If we already have this chain as a candidate, only update if this block is newer
+        # Check if we already have this chain as a candidate
         if chain_id in self.candidate_chains:
-            current_candidate = self.candidate_chains[chain_id]['latest_block']
-            if block.height > current_candidate.height:
+            existing_block = self.candidate_chains[chain_id]['latest_block']
+            
+            # Only update if this block is newer
+            if block.height > existing_block.height:
                 self.candidate_chains[chain_id] = {
                     'latest_block': block,
                     'timestamp': time.time()
@@ -527,10 +610,34 @@ class Node:
                 'latest_block': block,
                 'timestamp': time.time()
             }
+            
+        print(f"Added candidate chain {chain_id.hex()} with height {block.height}")
+    
+    def _update_latest_block(self, block):
+        """
+        Update our latest block and process it.
         
-        # Prune old candidates (older than 1 hour)
-        self._prune_candidate_chains()
-        
+        Args:
+            block: New latest block to set
+        """
+        # Process the block if it's new
+        if not self.latest_block or block.hash_bytes != self.latest_block.hash_bytes:
+            # Process block logic in the machine
+            self.machine.process_block(block)
+            
+            # Update our latest block reference
+            self.latest_block = block
+            
+            # Update followed chain ID if needed
+            if not self.followed_chain_id:
+                self.followed_chain_id = block.chain_id
+                
+            print(f"Updated latest block to height {block.height}, hash {block.hash}")
+            
+            # Save latest block to storage for persistence
+            if self.storage:
+                self.storage.put_latest_block(block)
+                
     def _prune_candidate_chains(self):
         """Remove candidate chains that are older than 1 hour."""
         current_time = time.time()

astreum/node/relay/__init__.py

@@ -4,6 +4,8 @@ Relay module for handling network communication in the Astreum node.
 
 import socket
 import threading
+import random
+import time
 from queue import Queue
 from typing import Tuple, Callable, Dict, Set, Optional, List
 from .message import Message, Topic
@@ -43,14 +45,16 @@ class Relay:
         # Save private key bytes for config persistence
         self.private_key_bytes = self.private_key.private_bytes_raw()
 
-        # Routes that this node participates in (0 = peer route, 1 = validation route)
+        # Routes that this node participates in 
+        # 0 = peer route, 1 = validation route
+        # All routes are tracked by default, but we only join some
         self.routes: List[int] = []
+        self.tracked_routes: List[int] = [0, 1]  # Track all routes
         
-        # Peer route is always enabled
+        # Always join peer route
         self.routes.append(0)  # Peer route
             
-        # Check if the node should join validation route
-        # This is now controlled by the parent Node class based on validation_private_key
+        # Check if this node should join validation route
         if config.get('validation_route', False):
             self.routes.append(1)  # Validation route
 
@@ -102,24 +106,53 @@ class Relay:
     def is_in_validation_route(self) -> bool:
         """Check if this node is part of the validation route."""
         return 1 in self.routes
+    
+    def is_tracking_route(self, route_type: int) -> bool:
+        """Check if this node is tracking a specific route."""
+        return route_type in self.tracked_routes
         
-    def add_peer_to_route(self, peer: Peer, route_types: List[int]):
+    def get_random_peers_from_route(self, route_type: int, count: int = 3) -> List[Peer]:
         """
-        Add a peer to specified routes.
+        Get a list of random peers from different buckets in the specified route.
         
         Args:
-            peer (Peer): The peer to add
-            route_types (List[int]): List of route types to add the peer to (0 = peer, 1 = validation)
+            route_type (int): Route type (0 for peer, 1 for validation)
+            count (int): Number of random peers to select (one from each bucket)
+            
+        Returns:
+            List[Peer]: List of randomly selected peers from different buckets
         """
-        for route_type in route_types:
-            if route_type == 0:  # Peer route
-                # Add to top of bucket, eject last if at capacity
-                self.peer_route_bucket.add(peer, to_front=True)
-            elif route_type == 1:  # Validation route
-                # Add to top of bucket, eject last if at capacity
-                self.validation_route_bucket.add(peer, to_front=True)
+        result = []
+        route_id = self._get_route_id(route_type)
+        
+        # Get all buckets that have peers for this route
+        buckets_with_peers = []
+        for i, bucket in enumerate(self.routing_table):
+            # For each bucket, collect peers that are in this route
+            route_peers_in_bucket = [peer for peer in bucket.values() 
+                                    if peer.routes and route_id in peer.routes]
+            if route_peers_in_bucket:
+                buckets_with_peers.append((i, route_peers_in_bucket))
+        
+        # If we don't have any buckets with peers, return empty list
+        if not buckets_with_peers:
+            return []
+        
+        # If we have fewer buckets than requested count, adjust count
+        sample_count = min(count, len(buckets_with_peers))
+        
+        # Sample random buckets
+        selected_buckets = random.sample(buckets_with_peers, sample_count)
+        
+        # For each selected bucket, pick one random peer
+        for bucket_idx, peers in selected_buckets:
+            # Select one random peer from this bucket
+            selected_peer = random.choice(peers)
+            result.append(selected_peer)
             
-    def get_route_peers(self, route_type: int) -> List[Peer]:
+        return result
+        
+    def get_peers_in_route(self, route_type: int) -> List[Peer]:
         """
         Get all peers in a specific route.
         
@@ -135,6 +168,22 @@ class Relay:
             return self.validation_route_bucket.get_peers()
         return []
         
+    def add_peer_to_route(self, peer: Peer, route_types: List[int]):
+        """
+        Add a peer to specified routes.
+        
+        Args:
+            peer (Peer): The peer to add
+            route_types (List[int]): List of route types to add the peer to (0 = peer, 1 = validation)
+        """
+        for route_type in route_types:
+            if route_type == 0:  # Peer route
+                # Add to top of bucket, eject last if at capacity
+                self.peer_route_bucket.add(peer, to_front=True)
+            elif route_type == 1:  # Validation route
+                # Add to top of bucket, eject last if at capacity
+                self.validation_route_bucket.add(peer, to_front=True)
+            
     def register_message_handler(self, topic: Topic, handler_func):
         """Register a handler function for a specific message topic."""
         self.message_handlers[topic] = handler_func
@@ -197,26 +246,19 @@ class Relay:
         """Handle an incoming message."""
         envelope = Envelope.from_bytes(data)
         if envelope and envelope.message.topic in self.message_handlers:
-            # Check if this is a transaction or block message that requires validation route
-            if envelope.message.topic in (Topic.TRANSACTION, Topic.BLOCK):
-                # Only process if we're part of the validation route
+            # For transaction messages, only process if we're in validation route
+            if envelope.message.topic == Topic.TRANSACTION:
                 if self.is_in_validation_route():
                     self.message_handlers[envelope.message.topic](envelope.message.body, addr, envelope)
-            elif envelope.message.topic == Topic.LATEST_BLOCK:
-                # For latest_block, we only process if we're in the validation route
+            # For block messages, only process if we're in validation route
+            elif envelope.message.topic == Topic.BLOCK:
                 if self.is_in_validation_route():
                     self.message_handlers[envelope.message.topic](envelope.message.body, addr, envelope)
-            elif envelope.message.topic in (Topic.LATEST_BLOCK_REQUEST, Topic.GET_BLOCKS):
-                # Allow all nodes to request blocks for syncing
-                self.message_handlers[envelope.message.topic](envelope.message.body, addr, envelope)
-            elif envelope.message.topic == Topic.OBJECT_REQUEST:
-                # Handle object request
-                self.message_handlers[envelope.message.topic](envelope.message.body, addr, envelope)
-            elif envelope.message.topic == Topic.OBJECT_RESPONSE:
-                # Handle object response
+            # Latest block and latest block requests can be handled by any node tracking the routes
+            elif envelope.message.topic in (Topic.LATEST_BLOCK, Topic.LATEST_BLOCK_REQUEST):
                 self.message_handlers[envelope.message.topic](envelope.message.body, addr, envelope)
+            # For other message types, always process
             else:
-                # For other message types, always process
                 self.message_handlers[envelope.message.topic](envelope.message.body, addr, envelope)
 
     def send(self, data: bytes, addr: Tuple[str, int]):

{astreum-0.1.13.dist-info → astreum-0.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: astreum
-Version: 0.1.13
+Version: 0.1.14
 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.13.dist-info → astreum-0.1.14.dist-info}/RECORD

@@ -20,9 +20,9 @@ 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=VlyhTLOjqy5VJlcLiTfTqgcsWuN3mudv_WtM5ixrojc,24121
+astreum/node/__init__.py,sha256=Zvu7_oadjB8V3TQpDR9pTdURXZpcHKI5Qhxz4Ykep7U,28271
 astreum/node/models.py,sha256=9Uf2_u55uxWG0ujjySvFJUO5Ub-EzlMnnMJWcgJHjHk,11980
-astreum/node/relay/__init__.py,sha256=k-_lEenUvLnBriSqjsqpnbwua1j6ZUghqkGD_Jc9ZYM,13493
+astreum/node/relay/__init__.py,sha256=0zvbchIbLUPqGA7QXJbXokKupcIq6Iu3X3VUpxejIQc,14981
 astreum/node/relay/bucket.py,sha256=pcmollbbM-xeHlmDxLZnzvf0Ut-9v9RoN6SijYiQuu8,2893
 astreum/node/relay/envelope.py,sha256=TfkynttoPX7smvMV7xEAdtIlfz-Z-EZjuhZ826csZxA,10078
 astreum/node/relay/message.py,sha256=uezmGjNaQK4fZmYQLCHd2YpiosaaFb8DOa3H58HS1jA,2887
@@ -30,8 +30,8 @@ astreum/node/relay/peer.py,sha256=DlvTR9j0BZQ1dW-p_9UGgfLvQqwNdpNLMSCYEW4FhyI,58
 astreum/node/relay/route.py,sha256=fyOSsAe1mfsCVeN6LtQ_OEUEb1FiC5dobZBEJKNGU9U,5814
 astreum/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/utils/bytes_format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
-astreum-0.1.13.dist-info/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.1.13.dist-info/METADATA,sha256=0wxUc4qtd3ipFd3-IwFjDcsWTBqAK8I-u3hrgBmgVX8,3261
-astreum-0.1.13.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-astreum-0.1.13.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.1.13.dist-info/RECORD,,
+astreum-0.1.14.dist-info/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.1.14.dist-info/METADATA,sha256=W3SxJCJeN-OxSs_rGNuG1FrqQunyOFYBOlaCZkjlEyk,3261
+astreum-0.1.14.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+astreum-0.1.14.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.1.14.dist-info/RECORD,,