astreum 0.1.14__tar.gz → 0.1.16__tar.gz

{astreum-0.1.14/src/astreum.egg-info → astreum-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: astreum
-Version: 0.1.14
+Version: 0.1.16
 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
@@ -13,6 +13,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pycryptodomex==3.21.0
 Requires-Dist: cryptography==44.0.2
+Requires-Dist: blake3==1.0.4
+Dynamic: license-file
 
 # lib
 

{astreum-0.1.14 → astreum-0.1.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "astreum"
-version = "0.1.14"
+version = "0.1.16"
 authors = [
   { name="Roy R. O. Okello", email="roy@stelar.xyz" },
 ]
@@ -15,6 +15,7 @@ classifiers = [
 dependencies = [
     "pycryptodomex==3.21.0",
     "cryptography==44.0.2",
+    "blake3==1.0.4"
 ]
 
 [project.urls]

{astreum-0.1.14 → astreum-0.1.16}/src/astreum/lispeum/storage.py

@@ -5,11 +5,11 @@ This module provides functions to convert Lispeum expressions to an
 object-based Merkle tree representation for storage and retrieval.
 """
 
-import hashlib
 import struct
 from typing import Dict, Tuple, Any, List, Optional
 
 from astreum.lispeum.expression import Expr
+from .utils import hash_data
 
 
 def expr_to_objects(expr: Any) -> Tuple[bytes, Dict[bytes, bytes]]:
@@ -61,7 +61,7 @@ def _serialize_expr(expr: Any, objects: Dict[bytes, bytes]) -> bytes:
         
         # Create the object with leaf flag and body
         object_bytes = struct.pack("?", is_leaf) + type_bytes
-        object_hash = hashlib.sha256(object_bytes).digest()
+        object_hash = hash_data(object_bytes)
         objects[object_hash] = object_bytes
         
         return object_hash
@@ -82,7 +82,7 @@ def _serialize_expr(expr: Any, objects: Dict[bytes, bytes]) -> bytes:
         
         # Create the object with leaf flag and body
         object_bytes = struct.pack("?", is_leaf) + type_bytes + value_bytes
-        object_hash = hashlib.sha256(object_bytes).digest()
+        object_hash = hash_data(object_bytes)
         objects[object_hash] = object_bytes
         
         return object_hash
@@ -95,7 +95,7 @@ def _serialize_expr(expr: Any, objects: Dict[bytes, bytes]) -> bytes:
         
         # Create the object with leaf flag and body
         object_bytes = struct.pack("?", is_leaf) + type_bytes + value_bytes
-        object_hash = hashlib.sha256(object_bytes).digest()
+        object_hash = hash_data(object_bytes)
         objects[object_hash] = object_bytes
         
         return object_hash
@@ -108,7 +108,7 @@ def _serialize_expr(expr: Any, objects: Dict[bytes, bytes]) -> bytes:
         
         # Create the object with leaf flag and body
         object_bytes = struct.pack("?", is_leaf) + type_bytes + value_bytes
-        object_hash = hashlib.sha256(object_bytes).digest()
+        object_hash = hash_data(object_bytes)
         objects[object_hash] = object_bytes
         
         return object_hash
@@ -121,7 +121,7 @@ def _serialize_expr(expr: Any, objects: Dict[bytes, bytes]) -> bytes:
         
         # Create the object with leaf flag and body
         object_bytes = struct.pack("?", is_leaf) + type_bytes + value_bytes
-        object_hash = hashlib.sha256(object_bytes).digest()
+        object_hash = hash_data(object_bytes)
         objects[object_hash] = object_bytes
         
         return object_hash
@@ -134,7 +134,7 @@ def _serialize_expr(expr: Any, objects: Dict[bytes, bytes]) -> bytes:
         
         # Create the object with leaf flag and body
         object_bytes = struct.pack("?", is_leaf) + type_bytes + value_bytes
-        object_hash = hashlib.sha256(object_bytes).digest()
+        object_hash = hash_data(object_bytes)
         objects[object_hash] = object_bytes
         
         return object_hash
@@ -155,7 +155,7 @@ def _serialize_expr(expr: Any, objects: Dict[bytes, bytes]) -> bytes:
         
         # Create the object with leaf flag and body
         object_bytes = struct.pack("?", is_leaf) + type_bytes + params_bytes + body_hash
-        object_hash = hashlib.sha256(object_bytes).digest()
+        object_hash = hash_data(object_bytes)
         objects[object_hash] = object_bytes
         
         return object_hash
@@ -172,7 +172,7 @@ def _serialize_expr(expr: Any, objects: Dict[bytes, bytes]) -> bytes:
         
         # Create the object with leaf flag and body
         object_bytes = struct.pack("?", is_leaf) + type_bytes + category_bytes + b'\0' + message_bytes + b'\0' + details_bytes
-        object_hash = hashlib.sha256(object_bytes).digest()
+        object_hash = hash_data(object_bytes)
         objects[object_hash] = object_bytes
         
         return object_hash
@@ -185,7 +185,7 @@ def _serialize_expr(expr: Any, objects: Dict[bytes, bytes]) -> bytes:
         
         # Create the object with leaf flag and body
         object_bytes = struct.pack("?", is_leaf) + type_bytes + value_bytes
-        object_hash = hashlib.sha256(object_bytes).digest()
+        object_hash = hash_data(object_bytes)
         objects[object_hash] = object_bytes
         
         return object_hash

astreum-0.1.16/src/astreum/lispeum/utils.py

@@ -0,0 +1,17 @@
+"""
+Utility functions for the Lispeum module.
+"""
+
+import blake3
+
+def hash_data(data: bytes) -> bytes:
+    """
+    Hash data using BLAKE3.
+    
+    Args:
+        data: Data to hash
+        
+    Returns:
+        32-byte BLAKE3 hash
+    """
+    return blake3.blake3(data).digest()

astreum-0.1.16/src/astreum/node/__init__.py

@@ -0,0 +1,480 @@
+import os
+import time
+import threading
+import random
+from typing import Tuple, Optional, List, Dict
+import json
+from cryptography.hazmat.primitives.asymmetric import ed25519
+from cryptography.hazmat.primitives import serialization
+
+from .relay import Relay, Topic
+from .relay.peer import Peer
+from .models import Storage, Block, Transaction
+from .machine import AstreumMachine
+from .utils import encode, decode, hash_data
+from astreum.lispeum.storage import store_expr, get_expr_from_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,
+    Account,
+    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, AccountAdapter
+
+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
+
+    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
+        
+        # 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)
+            
+        # Stop relay last
+        if self.relay:
+            self.relay.stop()
+            
+        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()
+                
+                # 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()
+                
+                # 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
+                
+    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()
+                
+                # 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]
+            
+        # 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
+            
+        # 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']
+            
+            # 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)
+            
+    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}")
+            
+        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
+            
+        # 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)
+            
+            # 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)
+            
+            # 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.
+        
+        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
+            
+            # 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 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 []
+                
+        return chain_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)
+            
+        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
+            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
+        
+    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
+            
+        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
+            
+        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 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]
+                        
+                    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}")

astreum-0.1.16/src/astreum/node/crypto/ed25519.py

@@ -0,0 +1,50 @@
+# EdDSA signature algorithm over Curve25519
+
+# ed25519.py
+from cryptography.hazmat.primitives.asymmetric import ed25519
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey, Ed25519PublicKey
+from cryptography.exceptions import InvalidSignature
+from typing import Tuple
+
+def generate_key_pair() -> Tuple[Ed25519PrivateKey, Ed25519PublicKey]:
+    """
+    Generate an Ed25519 private and public key pair.
+    
+    Returns:
+        Tuple[Ed25519PrivateKey, Ed25519PublicKey]: The generated key pair.
+    """
+    private_key: Ed25519PrivateKey = ed25519.Ed25519PrivateKey.generate()
+    public_key: Ed25519PublicKey = private_key.public_key()
+    return private_key, public_key
+
+def sign_message(private_key: Ed25519PrivateKey, message: bytes) -> bytes:
+    """
+    Sign a message using the provided Ed25519 private key.
+    
+    Args:
+        private_key (Ed25519PrivateKey): The private key used for signing.
+        message (bytes): The message to sign.
+    
+    Returns:
+        bytes: The signature.
+    """
+    signature: bytes = private_key.sign(message)
+    return signature
+
+def verify_signature(public_key: Ed25519PublicKey, message: bytes, signature: bytes) -> bool:
+    """
+    Verify a message signature using the provided Ed25519 public key.
+    
+    Args:
+        public_key (Ed25519PublicKey): The public key corresponding to the private key that signed.
+        message (bytes): The original message.
+        signature (bytes): The signature to verify.
+        
+    Returns:
+        bool: True if the signature is valid, False otherwise.
+    """
+    try:
+        public_key.verify(signature, message)
+        return True
+    except InvalidSignature:
+        return False