astreum 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

astreum/_node/relay/route.py

@@ -1,161 +0,0 @@
-"""
-Kademlia-style routing table implementation for Astreum node.
-"""
-
-from typing import List, Dict, Set, Tuple, Optional
-from .bucket import KBucket
-from .peer import Peer, PeerManager
-
-class RouteTable:
-    """
-    Kademlia-style routing table using k-buckets.
-    
-    The routing table consists of k-buckets, each covering a specific range of distances.
-    In Kademlia, bucket index (i) contains nodes that share exactly i bits with the local node:
-    - Bucket 0: Contains peers that don't share the first bit with our node ID
-    - Bucket 1: Contains peers that share the first bit, but differ on the second bit
-    - Bucket 2: Contains peers that share the first two bits, but differ on the third bit
-    - And so on...
-    
-    This structuring ensures efficient routing to any node in the network.
-    """
-    
-    def __init__(self, relay):
-        """
-        Initialize the routing table.
-        
-        Args:
-            relay: The relay instance this route table belongs to
-        """
-        self.relay = relay
-        self.our_node_id = relay.node_id
-        self.bucket_size = relay.config.get('max_peers_per_bucket', 20)
-        # Initialize buckets - for a 256-bit key, we need up to 256 buckets
-        self.buckets = {i: KBucket(k=self.bucket_size) for i in range(256)}
-        self.peer_manager = PeerManager(self.our_node_id)
-        
-    def add_peer(self, peer: Peer) -> bool:
-        """
-        Add a peer to the appropriate k-bucket based on bit prefix matching.
-        
-        Args:
-            peer (Peer): The peer to add
-            
-        Returns:
-            bool: True if the peer was added, False otherwise
-        """
-        # Calculate the number of matching prefix bits
-        matching_bits = self.peer_manager.calculate_distance(peer.public_key)
-        
-        # Add to the appropriate bucket based on the number of matching bits
-        return self.buckets[matching_bits].add(peer)
-        
-    def update_peer(self, addr: tuple, public_key: bytes, difficulty: int = 1) -> Peer:
-        """
-        Update or add a peer to the routing table.
-        
-        Args:
-            addr: Tuple of (ip, port)
-            public_key: Peer's public key
-            difficulty: Peer's proof-of-work difficulty
-            
-        Returns:
-            Peer: The updated or added peer
-        """
-        # Create or update the peer
-        peer = self.peer_manager.add_or_update_peer(addr, public_key)
-        peer.difficulty = difficulty
-        
-        # Add to the appropriate bucket
-        self.add_peer(peer)
-        
-        return peer
-        
-    def remove_peer(self, peer: Peer) -> bool:
-        """
-        Remove a peer from its k-bucket.
-        
-        Args:
-            peer (Peer): The peer to remove
-            
-        Returns:
-            bool: True if the peer was removed, False otherwise
-        """
-        matching_bits = self.peer_manager.calculate_distance(peer.public_key)
-        if matching_bits in self.buckets:
-            return self.buckets[matching_bits].remove(peer)
-        return False
-        
-    def get_closest_peers(self, target_id: bytes, count: int = 3) -> List[Peer]:
-        """
-        Get the closest peers to the target ID.
-        
-        Args:
-            target_id: Target ID to find peers close to
-            count: Maximum number of peers to return
-            
-        Returns:
-            List of peers closest to the target ID
-        """
-        # Calculate the number of matching prefix bits with the target
-        matching_bits = self.peer_manager.calculate_distance(target_id)
-        
-        closest_peers = []
-        
-        # First check the exact matching bucket
-        if matching_bits in self.buckets:
-            bucket_peers = self.buckets[matching_bits].get_peers()
-            closest_peers.extend(bucket_peers)
-            
-        # If we need more peers, also check adjacent buckets (farther first)
-        if len(closest_peers) < count:
-            # Check buckets with fewer matching bits (higher XOR distance)
-            for i in range(matching_bits - 1, -1, -1):
-                if i in self.buckets:
-                    bucket_peers = self.buckets[i].get_peers()
-                    closest_peers.extend(bucket_peers)
-                    if len(closest_peers) >= count:
-                        break
-                        
-            # If still not enough, check buckets with more matching bits
-            if len(closest_peers) < count:
-                for i in range(matching_bits + 1, 256):
-                    if i in self.buckets:
-                        bucket_peers = self.buckets[i].get_peers()
-                        closest_peers.extend(bucket_peers)
-                        if len(closest_peers) >= count:
-                            break
-        
-        # Return the closest peers, limited by count
-        return closest_peers[:count]
-    
-    def get_bucket_peers(self, bucket_index: int) -> List[Peer]:
-        """
-        Get all peers from a specific bucket.
-        
-        Args:
-            bucket_index: Index of the bucket to get peers from
-            
-        Returns:
-            List of peers in the bucket
-        """
-        if bucket_index in self.buckets:
-            return self.buckets[bucket_index].get_peers()
-        return []
-        
-    def has_peer(self, addr: tuple) -> bool:
-        """
-        Check if a peer with the given address exists in the routing table.
-        
-        Args:
-            addr: Tuple of (ip, port)
-            
-        Returns:
-            bool: True if the peer exists, False otherwise
-        """
-        return self.peer_manager.get_peer_by_address(addr) is not None
-    
-    @property
-    def num_buckets(self) -> int:
-        """Get the number of active buckets."""
-        return len(self.buckets)

astreum/_node/storage/storage.py

@@ -1,253 +0,0 @@
-"""
-Storage implementation for the Astreum node.
-
-This module provides a Storage class that manages persistent storage
-of data using either in-memory dictionaries or file system storage.
-It supports network-based retrieval for missing data.
-"""
-
-import threading
-import time
-from pathlib import Path
-from typing import Optional, Dict, Set, Tuple, List, Any
-
-
-class Storage:
-    def __init__(self, config: dict):
-        self.max_space = config.get('max_storage_space', 1024 * 1024 * 1024)  # Default 1GB
-        self.current_space = 0
-        
-        # 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
-        
-        # In-progress requests tracking
-        self.pending_requests = {}  # hash -> (start_time, event)
-        self.request_lock = threading.Lock()
-
-        
-
-    def put(self, data_hash: bytes, data: bytes) -> bool:
-        """Store data with its hash. Returns True if successful, False if space limit exceeded."""
-        data_size = len(data)
-        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
-        if file_path.exists():
-            return True
-
-        # Store the data
-        file_path.write_bytes(data)
-        self.current_space += data_size
-        
-        # If this was a pending request, mark it as complete
-        with self.request_lock:
-            if data_hash in self.pending_requests:
-                _, event = self.pending_requests[data_hash]
-                event.set()  # Signal that the data is now available
-        
-        return True
-
-    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()
-        return None
-
-    def get(self, data_hash: bytes, timeout: Optional[float] = None) -> Optional[bytes]:
-        """
-        Retrieve data by its hash, with network fallback.
-        
-        This function will first check local storage. If not found and a node is attached,
-        it will initiate a network request asynchronously.
-        
-        Args:
-            data_hash: The hash of the data to retrieve
-            timeout: Timeout in seconds to wait for network request, None for default
-            
-        Returns:
-            The data bytes if found, None otherwise
-        """
-        if timeout is None:
-            timeout = self.network_request_timeout
-            
-        # First check local storage
-        local_data = self._local_get(data_hash)
-        if local_data:
-            return local_data
-            
-        # If no node is attached, we can't make network requests
-        if self.node is None:
-            return None
-            
-        # Check if there's already a pending request for this hash
-        with self.request_lock:
-            if data_hash in self.pending_requests:
-                start_time, event = self.pending_requests[data_hash]
-                # If this request has been going on too long, cancel it and start a new one
-                elapsed = time.time() - start_time
-                if elapsed > timeout:
-                    # Cancel the old request
-                    self.pending_requests.pop(data_hash)
-                else:
-                    # Wait for the existing request to complete
-                    wait_time = timeout - elapsed
-            else:
-                # No existing request, create a new one
-                event = threading.Event()
-                self.pending_requests[data_hash] = (time.time(), event)
-                # Start the actual network request in a separate thread
-                threading.Thread(
-                    target=self._request_from_network,
-                    args=(data_hash,),
-                    daemon=True
-                ).start()
-                wait_time = timeout
-                
-        # Wait for the request to complete or timeout
-        if event.wait(wait_time):
-            # Event was set, data should be available now
-            with self.request_lock:
-                if data_hash in self.pending_requests:
-                    self.pending_requests.pop(data_hash)
-            
-            # Check if data is now in local storage
-            return self._local_get(data_hash)
-        else:
-            # Timed out waiting for data
-            with self.request_lock:
-                if data_hash in self.pending_requests:
-                    self.pending_requests.pop(data_hash)
-            return None
-    
-    def _request_from_network(self, data_hash: bytes):
-        """
-        Request object from the network.
-        This is meant to be run in a separate thread.
-        
-        Args:
-            data_hash: The hash of the object to request
-        """
-        try:
-            if hasattr(self.node, 'request_object'):
-                # Use the node's request_object method
-                self.node.request_object(data_hash)
-            # Note: We don't need to return anything or signal completion here
-            # The put() method will signal completion when the object is received
-        except Exception as e:
-            print(f"Error requesting object {data_hash.hex()} from network: {e}")
-
-    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, 
-                     timeout: Optional[float] = None) -> Dict[bytes, bytes]:
-        """
-        Recursively retrieve all objects starting from a root hash.
-        
-        Objects not found locally will be requested from the network.
-        This method will continue processing objects that are available
-        while waiting for network responses.
-        
-        Args:
-            root_hash: The hash of the root object
-            max_depth: Maximum recursion depth, defaults to self.max_object_recursion
-            timeout: Time to wait for each object request, None for default
-            
-        Returns:
-            Dictionary mapping object hashes to their data
-        """
-        if max_depth is None:
-            max_depth = self.max_object_recursion
-            
-        if timeout is None:
-            timeout = self.network_request_timeout
-            
-        # Start with the root object
-        objects = {}
-        pending_queue = [(root_hash, 0)]  # (hash, depth)
-        processed = set()
-        
-        # Process objects in the queue
-        while pending_queue:
-            current_hash, current_depth = pending_queue.pop(0)
-            
-            # Skip if already processed or too deep
-            if current_hash in processed or current_depth > max_depth:
-                continue
-                
-            processed.add(current_hash)
-            
-            # Try to get the object (which may start a network request)
-            obj_data = self.get(current_hash, timeout)
-            if obj_data is None:
-                # Object not found, continue with other objects
-                continue
-                
-            # Store the object
-            objects[current_hash] = obj_data
-            
-            # Queue child objects if not at max depth
-            if current_depth < max_depth:
-                # Try to detect child objects in the data
-                # This depends on the data format, so this is just a placeholder
-                # In a real implementation, you would parse the data based on its format
-                # and extract references to other objects
-                child_hashes = self._extract_child_hashes(obj_data)
-                for child_hash in child_hashes:
-                    pending_queue.append((child_hash, current_depth + 1))
-        
-        return objects
-    
-    def _extract_child_hashes(self, data: bytes) -> List[bytes]:
-        """
-        Extract child object hashes from object data.
-        This is a placeholder method that should be overridden or adapted based on the object format.
-        
-        Args:
-            data: The object data
-            
-        Returns:
-            List of child object hashes
-        """
-        # In a real implementation, this would parse the data based on its format
-        # and extract references to other objects
-        # For example, if the data is a serialized Merkle node, you might extract
-        # left and right child hashes
-        
-        # For now, return an empty list
-        return []

astreum/_node/storage/utils.py

@@ -1,137 +0,0 @@
-"""
-Utility functions for working with the storage module and Merkle trees,
-with special focus on validator stake operations and binary searches.
-"""
-
-from typing import List, Dict, Optional, Tuple, Any, Callable, TypeVar
-from .merkle import MerkleTree, MerkleProof, MerkleNode, MerkleNodeType
-from .merkle import find_first, find_all, map, binary_search
-
-T = TypeVar('T')
-
-
-def create_ordered_merkle_tree(items: List[bytes], storage=None) -> Tuple[bytes, MerkleTree]:
-    """
-    Create a new ordered Merkle tree from items.
-    
-    Args:
-        items: List of items to include in the tree, will be sorted
-        storage: Optional storage backend to persist the tree
-        
-    Returns:
-        Tuple of (root_hash, merkle_tree)
-    """
-    tree = MerkleTree(storage)
-    root_hash = tree.add_sorted(items)
-    return root_hash, tree
-
-
-def query_validator_stake(storage, stake_root_hash: bytes, validator_address: bytes) -> Optional[int]:
-    """
-    Query a validator's stake by their address from a stake Merkle tree.
-    
-    Args:
-        storage: Storage instance used by the Merkle tree
-        stake_root_hash: Root hash of the stake Merkle tree
-        validator_address: Address of the validator to look up
-        
-    Returns:
-        The validator's stake amount as an integer, or None if not found
-    """
-    # Define a comparison function for binary search (assuming address is first part of data)
-    def compare_address(data: bytes) -> int:
-        # Extract address from data (format depends on how stakes are stored)
-        # Assuming format: [address][stake]
-        data_address = data[:len(validator_address)]
-        
-        if data_address < validator_address:
-            return 1  # Data is less than target
-        elif data_address > validator_address:
-            return -1  # Data is greater than target
-        else:
-            return 0  # Match found
-    
-    # Binary search for the validator's stake
-    stake_data = binary_search(storage, stake_root_hash, compare_address)
-    
-    if stake_data:
-        # Extract stake amount from data
-        # Assuming format: [address][stake_amount as 8-byte integer]
-        address_len = len(validator_address)
-        stake_amount = int.from_bytes(stake_data[address_len:address_len+8], byteorder='big')
-        return stake_amount
-    
-    return None
-
-
-def find_validator_stakes(storage, stake_root_hash: bytes, min_stake: int = 0) -> List[Tuple[bytes, int]]:
-    """
-    Find all validators with stakes above a minimum threshold.
-    
-    Args:
-        storage: Storage instance used by the Merkle tree
-        stake_root_hash: Root hash of the stake Merkle tree
-        min_stake: Minimum stake threshold (default: 0)
-        
-    Returns:
-        List of (validator_address, stake_amount) tuples
-    """
-    # Define predicate to filter validators by minimum stake
-    def has_min_stake(data: bytes) -> bool:
-        # Assuming format: [address][stake_amount as 8-byte integer]
-        address_len = len(data) - 8  # Adjust based on your actual format
-        stake_amount = int.from_bytes(data[address_len:], byteorder='big')
-        return stake_amount >= min_stake
-    
-    # Define transform to extract address and stake
-    def extract_address_and_stake(data: bytes) -> Tuple[bytes, int]:
-        # Assuming format: [address][stake_amount as 8-byte integer]
-        address_len = len(data) - 8  # Adjust based on your actual format
-        address = data[:address_len]
-        stake = int.from_bytes(data[address_len:], byteorder='big')
-        return (address, stake)
-    
-    # Find all validators meeting criteria and transform results
-    matching_validators = find_all(storage, stake_root_hash, has_min_stake)
-    return [extract_address_and_stake(data) for data in matching_validators]
-
-
-def get_total_stake(storage, stake_root_hash: bytes) -> int:
-    """
-    Calculate the total stake across all validators.
-    
-    Args:
-        storage: Storage instance used by the Merkle tree
-        stake_root_hash: Root hash of the stake Merkle tree
-        
-    Returns:
-        Total stake amount
-    """
-    # Define transform to extract stake amount
-    def extract_stake(data: bytes) -> int:
-        # Assuming format: [address][stake_amount as 8-byte integer]
-        address_len = len(data) - 8  # Adjust based on your actual format
-        return int.from_bytes(data[address_len:], byteorder='big')
-    
-    # Map all leaves to their stake values and sum
-    stakes = map(storage, stake_root_hash, extract_stake)
-    return sum(stakes)
-
-
-def query_with_custom_resolver(storage, root_hash: bytes, 
-                              resolver_fn: Callable[[bytes], T]) -> T:
-    """
-    Query a Merkle tree using a custom resolver function.
-    
-    This is a general-purpose function that allows custom logic to be applied
-    to tree traversal and data extraction.
-    
-    Args:
-        storage: Storage instance used by the Merkle tree
-        root_hash: Root hash of the Merkle tree
-        resolver_fn: Function that takes a root hash and returns a result
-        
-    Returns:
-        Whatever the resolver function returns
-    """
-    return resolver_fn(root_hash)

astreum/_node/utils.py

@@ -1,34 +0,0 @@
-"""
-Utility functions for the Astreum blockchain.
-"""
-
-import blake3
-
-def blake3_hash(data: bytes) -> bytes:
-    """
-    Hash data using BLAKE3.
-    
-    Args:
-        data: Data to hash
-        
-    Returns:
-        32-byte BLAKE3 hash
-    """
-    return blake3.blake3(data).digest()
-
-def hash_object(obj) -> bytes:
-    """
-    Hash a Python object by converting it to a string and then hashing.
-    
-    Args:
-        obj: Python object to hash
-        
-    Returns:
-        32-byte BLAKE3 hash
-    """
-    if isinstance(obj, bytes):
-        return hash_data(obj)
-    elif isinstance(obj, str):
-        return hash_data(obj.encode('utf-8'))
-    else:
-        return hash_data(str(obj).encode('utf-8'))

astreum/_node/validation/_block/create.py

@@ -1,98 +0,0 @@
-"""
-Block creation functionality for the Astreum blockchain.
-"""
-
-import time
-from typing import Dict, List, Optional, Tuple, Set
-
-from .model import Block
-from ..account import Account
-from ...models import Transaction
-from ...utils import hash_data
-
-def create_block(
-    number: int,
-    validator: bytes,
-    previous: bytes,
-    transactions: List[Transaction],
-    timestamp: Optional[int] = None,
-    vdf: Optional[bytes] = None,
-    signature: Optional[bytes] = None,
-    proof: Optional[bytes] = None,
-    receipts: Optional[List] = None,
-    data: Optional[bytes] = None,
-    delay: Optional[int] = None,
-    difficulty: Optional[int] = None,
-    accounts: Optional[Dict] = None,
-    chain: Optional[bytes] = None
-) -> Block:
-    """
-    Create a new block.
-    
-    Args:
-        number: Block number
-        validator: Address of block validator
-        previous: Hash of previous block
-        transactions: List of transactions to include
-        timestamp: Block timestamp (defaults to current time)
-        vdf: VDF proof
-        signature: Block signature
-        proof: Additional proof data
-        receipts: Transaction receipts
-        data: Additional block data
-        delay: Block delay
-        difficulty: Block difficulty
-        accounts: Accounts state
-        chain: Chain identifier
-        
-    Returns:
-        New Block object
-    """
-    # Use current time if timestamp not provided
-    if timestamp is None:
-        timestamp = int(time.time())
-    
-    # Create and return a new Block object
-    return Block(
-        number=number,
-        validator=validator,
-        previous=previous,
-        transactions=transactions,
-        timestamp=timestamp,
-        vdf=vdf,
-        signature=signature,
-        proof=proof,
-        receipts=receipts,
-        data=data,
-        delay=delay,
-        difficulty=difficulty,
-        accounts=accounts,
-        chain=chain
-    )
-
-def create_genesis_block(validator_address: bytes) -> Block:
-    """
-    Create the genesis block.
-    
-    Args:
-        validator_address: Address of the genesis block validator
-        
-    Returns:
-        Genesis Block object
-    """
-    return create_block(
-        number=0,
-        validator=validator_address,
-        previous=None,
-        transactions=[],
-        timestamp=int(time.time()),
-        vdf=None,
-        signature=None,
-        proof=None,
-        receipts=[],
-        data=None,
-        delay=0,
-        difficulty=1,
-        accounts={},
-        chain=hash_data(b"genesis")
-    )