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

astreum/node/__init__.py

@@ -3,6 +3,7 @@ import hashlib
 import time
 from typing import Tuple, Optional
 import json
+from cryptography.hazmat.primitives.asymmetric import ed25519
 
 from .relay import Relay, Topic
 from .relay.peer import Peer
@@ -13,16 +14,41 @@ from astreum.lispeum.storage import store_expr, get_expr_from_storage
 
 class Node:
     def __init__(self, config: dict):
-        self.config = config
-        self.relay = Relay(config)
-        # Get the node_id from relay instead of generating our own
+        # 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
-        self.storage = Storage(config)
+        
+        # Initialize storage
+        self.storage = Storage(self.config)
         self.storage.node = self  # Set the storage node reference to self
         
         # Latest block of the chain this node is following
         self.latest_block = None
-        self.followed_chain_id = config.get('followed_chain_id', None)
+        self.followed_chain_id = self.config.get('followed_chain_id', None)
         
         # Initialize machine
         self.machine = AstreumMachine(node=self)
@@ -396,48 +422,64 @@ class Node:
     
     def _handle_transaction(self, body: bytes, addr: Tuple[str, int], envelope):
         """
-        Handle receipt of a transaction.
-        Accept if validation route is present and counter is valid relative to the latest block in our chain.
+        Handle incoming transaction messages.
+        
+        This method is called when we receive a transaction from the network.
+        Transactions should only be processed by validator nodes.
+        
+        Args:
+            body: Transaction data
+            addr: Source address
+            envelope: Full message envelope
         """
+        # Ignore if we're not a validator (don't have a validation key)
+        if not self.is_validator or not self.relay.is_in_validation_route():
+            print("Ignoring transaction as we're not a validator")
+            return
+            
         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
+            # Parse transaction data
+            tx_data = json.loads(body.decode('utf-8'))
             
-            # Deserialize the transaction
-            transaction = Transaction.from_bytes(body)
-            if not transaction:
-                return
-                
-            # Check if we're following this chain
-            if not self.machine.is_following_chain(transaction.chain_id):
-                return
-                
-            # Verify transaction has a valid validation route
-            if not transaction.has_valid_route():
-                return
-                
-            # Get latest block from this chain
-            latest_block = self.machine.get_latest_block(transaction.chain_id)
-            if not latest_block:
-                return
-                
-            # Verify transaction counter is valid relative to the latest block
-            if not transaction.is_counter_valid(latest_block):
-                return
+            # Store the transaction in our local storage
+            tx_hash = bytes.fromhex(tx_data.get('hash'))
+            tx_raw = bytes.fromhex(tx_data.get('data'))
+            
+            # Create transaction entry in storage
+            if not self.storage.contains(tx_hash):
+                self.storage.put(tx_hash, tx_raw)
+                print(f"Stored transaction {tx_hash.hex()}")
                 
-            # Process the valid transaction
-            self.machine.process_transaction(transaction)
-            
-            # Relay to other peers in the validation route
-            validation_peers = self.relay.get_route_peers(1)  # 1 = validation route
-            for peer in validation_peers:
-                if peer.address != addr:  # Don't send back to originator
-                    self.relay.send_message(body, Topic.TRANSACTION, peer.address)
+                # Process the transaction as a validator
+                self._process_transaction_as_validator(tx_hash, tx_raw)
+            
         except Exception as e:
             print(f"Error handling transaction: {e}")
             
+    def _process_transaction_as_validator(self, tx_hash: bytes, tx_raw: bytes):
+        """
+        Process a transaction as a validator node.
+        
+        This method is called when we receive a transaction and we're a validator.
+        It verifies the transaction and may include it in a future block.
+        
+        Args:
+            tx_hash: Transaction hash
+            tx_raw: Raw transaction data
+        """
+        try:
+            print(f"Processing transaction {tx_hash.hex()} as validator")
+            # Here we would verify the transaction and potentially queue it
+            # for inclusion in the next block we create
+            
+            # For now, just log that we processed it
+            print(f"Verified transaction {tx_hash.hex()}")
+            
+            # TODO: Implement transaction validation and queueing for block creation
+            
+        except Exception as e:
+            print(f"Error processing transaction as validator: {e}")
+            
     def _initialize_latest_block(self):
         """Initialize latest block from storage if available."""
         # Implementation would load the latest block from storage

astreum/node/models.py

@@ -15,8 +15,21 @@ class Storage:
     def __init__(self, config: dict):
         self.max_space = config.get('max_storage_space', 1024 * 1024 * 1024)  # Default 1GB
         self.current_space = 0
-        self.storage_path = Path(config.get('storage_path', 'storage'))
-        self.storage_path.mkdir(parents=True, exist_ok=True)
+        
+        # Check if storage_path is provided in config
+        storage_path = config.get('storage_path')
+        self.use_memory_storage = storage_path is None
+        
+        # Initialize in-memory storage if no path provided
+        self.memory_storage = {} if self.use_memory_storage else None
+        
+        # Only create storage path if not using memory storage
+        if not self.use_memory_storage:
+            self.storage_path = Path(storage_path)
+            self.storage_path.mkdir(parents=True, exist_ok=True)
+            # Calculate current space usage
+            self.current_space = sum(f.stat().st_size for f in self.storage_path.glob('*') if f.is_file())
+        
         self.max_object_recursion = config.get('max_object_recursion', 50)
         self.network_request_timeout = config.get('network_request_timeout', 5.0)  # Default 5 second timeout
         self.node = None  # Will be set by the Node after initialization
@@ -24,9 +37,6 @@ class Storage:
         # In-progress requests tracking
         self.pending_requests = {}  # hash -> (start_time, event)
         self.request_lock = threading.Lock()
-        
-        # Calculate current space usage
-        self.current_space = sum(f.stat().st_size for f in self.storage_path.glob('*') if f.is_file())
 
     def put(self, data_hash: bytes, data: bytes) -> bool:
         """Store data with its hash. Returns True if successful, False if space limit exceeded."""
@@ -34,6 +44,14 @@ class Storage:
         if self.current_space + data_size > self.max_space:
             return False
 
+        # If using memory storage, store in dictionary
+        if self.use_memory_storage:
+            if data_hash not in self.memory_storage:
+                self.memory_storage[data_hash] = data
+                self.current_space += data_size
+            return True
+
+        # Otherwise use file storage
         file_path = self.storage_path / data_hash.hex()
         
         # Don't store if already exists
@@ -54,6 +72,11 @@ class Storage:
 
     def _local_get(self, data_hash: bytes) -> Optional[bytes]:
         """Get data from local storage only, no network requests."""
+        # If using memory storage, get from dictionary
+        if self.use_memory_storage:
+            return self.memory_storage.get(data_hash)
+            
+        # Otherwise use file storage
         file_path = self.storage_path / data_hash.hex()
         if file_path.exists():
             return file_path.read_bytes()
@@ -144,6 +167,8 @@ class Storage:
 
     def contains(self, data_hash: bytes) -> bool:
         """Check if data exists in storage."""
+        if self.use_memory_storage:
+            return data_hash in self.memory_storage
         return (self.storage_path / data_hash.hex()).exists()
         
     def get_recursive(self, root_hash: bytes, max_depth: Optional[int] = None, 

astreum/node/relay/__init__.py

@@ -24,10 +24,10 @@ class Relay:
         self.num_workers = config.get('num_workers', 4)
 
         # Generate Ed25519 keypair for this node
-        if 'private_key' in config:
+        if 'relay_private_key' in config:
             # Load existing private key if provided
             try:
-                private_key_bytes = bytes.fromhex(config['private_key'])
+                private_key_bytes = bytes.fromhex(config['relay_private_key'])
                 self.private_key = ed25519.Ed25519PrivateKey.from_private_bytes(private_key_bytes)
             except Exception as e:
                 print(f"Error loading private key: {e}, generating new one")
@@ -49,6 +49,8 @@ class Relay:
         # Peer route is always enabled
         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
         if config.get('validation_route', False):
             self.routes.append(1)  # Validation route
 
@@ -101,26 +103,6 @@ class Relay:
         """Check if this node is part of the validation route."""
         return 1 in self.routes
         
-    def add_to_peer_route(self):
-        """Add this node to the peer route."""
-        if 0 not in self.routes:
-            self.routes.append(0)
-        
-    def add_to_validation_route(self):
-        """Add this node to the validation route."""
-        if 1 not in self.routes:
-            self.routes.append(1)
-        
-    def remove_from_peer_route(self):
-        """Remove this node from the peer route."""
-        if 0 in self.routes:
-            self.routes.remove(0)
-        
-    def remove_from_validation_route(self):
-        """Remove this node from the validation route."""
-        if 1 in self.routes:
-            self.routes.remove(1)
-        
     def add_peer_to_route(self, peer: Peer, route_types: List[int]):
         """
         Add a peer to specified routes.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: astreum
-Version: 0.1.10
+Version: 0.1.13
 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
@@ -28,7 +28,8 @@ When initializing an Astreum Node, you need to provide a configuration dictionar
 
 | Parameter | Type | Default | Description |
 |-----------|------|---------|-------------|
-| `private_key` | string | Auto-generated | Hex string of Ed25519 private key. If not provided, a new keypair will be generated automatically |
+| `relay_private_key` | string | Auto-generated | Hex string of Ed25519 private key for network identity. If not provided, a new keypair will be generated automatically |
+| `validation_private_key` | string | None | Hex string of Ed25519 private key for block validation. If provided, the node will join the validation route automatically |
 | `storage_path` | string | "storage" | Path to store data |
 | `max_storage_space` | int | 1073741824 (1GB) | Maximum storage space in bytes |
 | `max_object_recursion` | int | 50 | Maximum recursion depth for resolving nested objects |
@@ -47,7 +48,7 @@ When initializing an Astreum Node, you need to provide a configuration dictionar
 
 | Parameter | Type | Default | Description |
 |-----------|------|---------|-------------|
-| `validation_route` | bool | False | Whether to participate in the block validation route |
+| `validation_route` | bool | False | Whether to participate in the block validation route (automatically set to True if validation_private_key is provided) |
 | `bootstrap_peers` | list | [] | List of bootstrap peers in the format `[("hostname", port), ...]` |
 
 > **Note:** The peer route is always enabled as it's necessary for object discovery and retrieval.
@@ -59,12 +60,11 @@ from astreum.node import Node
 
 # Configuration dictionary
 config = {
-    "private_key": "my-private-key-goes-here",
+    "relay_private_key": "relay-private-key-hex-string",
+    "validation_private_key": "validation-private-key-hex-string",  # Optional, for validator nodes
     "storage_path": "./data/node1",
     "incoming_port": 7373,
     "use_ipv6": False,
-    "peer_route": True,
-    "validation_route": True,
     "bootstrap_peers": [
         ("bootstrap.astreum.org", 7373),
         ("127.0.0.1", 7374)

{astreum-0.1.10.dist-info → astreum-0.1.13.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=wvmMMACicwhJ-ipSLpR1rsEUXWuHaZ8fnsBCkUA_RA8,22387
-astreum/node/models.py,sha256=MScDCNEpR-SfaFsRSU567mVuZRhH1Lqc7gmlqb3j-nI,10980
-astreum/node/relay/__init__.py,sha256=gQNYDxllkjZqE6bvgPOYkKu3QHkjPFn11RvtP-BxtKI,13994
+astreum/node/__init__.py,sha256=VlyhTLOjqy5VJlcLiTfTqgcsWuN3mudv_WtM5ixrojc,24121
+astreum/node/models.py,sha256=9Uf2_u55uxWG0ujjySvFJUO5Ub-EzlMnnMJWcgJHjHk,11980
+astreum/node/relay/__init__.py,sha256=k-_lEenUvLnBriSqjsqpnbwua1j6ZUghqkGD_Jc9ZYM,13493
 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.10.dist-info/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.1.10.dist-info/METADATA,sha256=50hGAAYObIlHpnh2ikWSAALUtOIwmw9O_U6c1qLCre8,2942
-astreum-0.1.10.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-astreum-0.1.10.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.1.10.dist-info/RECORD,,
+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,,