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

astreum/_node/relay/envelope.py

@@ -1,280 +0,0 @@
-"""
-Envelope related classes and utilities for Astreum node network.
-
-Message Structure:
-                    + - - - - - - - +
-                    |   Envelope    |
-                    + - - - - - - - +
-                            ^
-                    . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - .
-                    ^                       ^                       ^                       ^
-            + - - - - - - - +       + - - - - - - - +       + - - - - - - - +       + - - - - - - - +
-            |     Time      |       |   Encrypted   |       |     Nonce     |       |    Message    |
-            + - - - - - - - +       + - - - - - - - +       + - - - - - - - +       + - - - - - - - +
-                                                                                            ^
-                                                                                . - - - - - - - - - - - .
-                                                                                ^                       ^
-                                                                         + - - - - - - - +       + - - - - - - - +
-                                                                         |     Topic     |       |     Body      |
-                                                                         + - - - - - - - +       + - - - - - - - +
-
-The Envelope uses a Merkle tree structure with the following leaves:
-- Timestamp
-- Encrypted flag
-- Nonce
-- Message bytes
-
-The root hash of this Merkle tree must have a specified number of leading zero bits,
-determined by the difficulty parameter. The nonce is adjusted until this requirement is met.
-"""
-
-import struct
-import time
-import os
-from dataclasses import dataclass
-from typing import Optional, Tuple, List
-from .message import Message, Topic
-from astreum.format import encode, decode
-from ..utils import hash_data
-
-@dataclass
-class Envelope:
-    """
-    Represents an envelope that wraps a message with additional metadata.
-    
-    Attributes:
-        encrypted (bool): True if the message is encrypted, False otherwise
-        message (Message): The message being sent
-        nonce (bytes): Nonce for encryption and proof of work
-        timestamp (int): Time when the envelope was created
-    """
-    encrypted: bool
-    message: Message
-    nonce: bytes
-    timestamp: int
-    
-    @classmethod
-    def create(cls, body: bytes, topic: Topic, encrypted: bool = False, difficulty: int = 1) -> 'Envelope':
-        """
-        Create a new envelope with the current timestamp and a nonce that satisfies
-        the given difficulty level using a Merkle tree structure.
-        
-        Args:
-            body (bytes): The message body
-            topic (Topic): The message topic
-            encrypted (bool): Whether the message is encrypted
-            difficulty (int): Number of leading zero bits required in the Merkle root hash
-            
-        Returns:
-            Envelope: A new envelope with a valid nonce
-        """
-        timestamp = int(time.time())
-        message = Message(body=body, topic=topic)
-        
-        # Generate a valid nonce for the Merkle tree
-        nonce = cls._generate_nonce(message, timestamp, encrypted, difficulty)
-        
-        return cls(
-            encrypted=encrypted,
-            message=message,
-            nonce=nonce,
-            timestamp=timestamp
-        )
-    
-    @staticmethod
-    def _generate_nonce(message: Message, timestamp: int, encrypted: bool, difficulty: int) -> bytes:
-        """
-        Generate a nonce that results in a Merkle tree root hash with the specified
-        number of leading zero bits.
-        
-        Args:
-            message (Message): The message to include in the Merkle tree
-            timestamp (int): The timestamp to include in the Merkle tree
-            encrypted (bool): Whether the message is encrypted
-            difficulty (int): Number of leading zero bits required
-            
-        Returns:
-            bytes: A valid nonce
-        """
-        # Prepare the message data
-        message_data = message.to_bytes()
-        timestamp_data = struct.pack('!Q', timestamp)
-        encrypted_flag = b'\x01' if encrypted else b'\x00'
-        
-        # Calculate how many bytes need to be zero
-        zero_bytes = difficulty // 8
-        # Calculate how many bits in the last byte need to be zero
-        remaining_bits = difficulty % 8
-        
-        # Create a mask for the remaining bits
-        mask = 0
-        if remaining_bits > 0:
-            mask = 0xFF >> remaining_bits
-        
-        while True:
-            # Generate a random nonce
-            nonce = os.urandom(32)
-            
-            # Calculate the Merkle root using the leaves
-            merkle_root = Envelope._calculate_merkle_root([
-                timestamp_data,
-                encrypted_flag,
-                nonce,
-                message_data
-            ])
-            
-            # Check if it meets the difficulty requirement
-            valid = True
-            
-            # Check full zero bytes
-            for i in range(zero_bytes):
-                if merkle_root[i] != 0:
-                    valid = False
-                    break
-            
-            # If we need to check partial bits in a byte
-            if valid and remaining_bits > 0:
-                # The next byte should have required number of leading zeros
-                if (merkle_root[zero_bytes] & (0xFF ^ mask)) != 0:
-                    valid = False
-            
-            if valid:
-                return nonce
-    
-    @staticmethod
-    def _calculate_merkle_root(leaves: List[bytes]) -> bytes:
-        """
-        Calculate the Merkle root hash from a list of leaf node data.
-        
-        Args:
-            leaves (List[bytes]): List of leaf node data
-            
-        Returns:
-            bytes: The Merkle root hash
-        """
-        if not leaves:
-            return hash_data(b'')
-        
-        if len(leaves) == 1:
-            return hash_data(leaves[0])
-            
-        # Hash all leaf nodes
-        hashed_leaves = [hash_data(leaf) for leaf in leaves]
-        
-        # Build the Merkle tree
-        while len(hashed_leaves) > 1:
-            if len(hashed_leaves) % 2 != 0:
-                # Duplicate the last element if there's an odd number
-                hashed_leaves.append(hashed_leaves[-1])
-                
-            # Combine adjacent pairs and hash them
-            next_level = []
-            for i in range(0, len(hashed_leaves), 2):
-                combined = hashed_leaves[i] + hashed_leaves[i+1]
-                next_level.append(hash_data(combined))
-                
-            hashed_leaves = next_level
-            
-        # Return the root hash
-        return hashed_leaves[0]
-
-    def verify_nonce(self, difficulty: int = 1) -> bool:
-        """
-        Verify that the nonce produces a valid Merkle tree root hash
-        with the specified number of leading zero bits.
-        
-        Args:
-            difficulty (int): Number of leading zero bits required in the root hash
-        
-        Returns:
-            bool: True if the nonce is valid, False otherwise
-        """
-        # Prepare the message data
-        message_data = self.message.to_bytes()
-        timestamp_data = struct.pack('!Q', self.timestamp)
-        encrypted_flag = b'\x01' if self.encrypted else b'\x00'
-        
-        # Calculate the Merkle root
-        merkle_root = self._calculate_merkle_root([
-            timestamp_data,
-            encrypted_flag,
-            self.nonce,
-            message_data
-        ])
-        
-        # Calculate how many bytes need to be zero
-        zero_bytes = difficulty // 8
-        # Calculate how many bits in the last byte need to be zero
-        remaining_bits = difficulty % 8
-        
-        # Create a mask for the remaining bits
-        mask = 0
-        if remaining_bits > 0:
-            mask = 0xFF >> remaining_bits
-        
-        # Check if it meets the difficulty requirement
-        valid = True
-        
-        # Check full zero bytes
-        for i in range(zero_bytes):
-            if merkle_root[i] != 0:
-                valid = False
-                break
-        
-        # If we need to check partial bits in a byte
-        if valid and remaining_bits > 0:
-            # The next byte should have required number of leading zeros
-            if (merkle_root[zero_bytes] & (0xFF ^ mask)) != 0:
-                valid = False
-        
-        return valid
-    
-    def to_bytes(self) -> bytes:
-        """
-        Convert this Envelope to bytes.
-        
-        Returns:
-            bytes: Serialized envelope
-        """
-        return encode([
-            struct.pack('!Q', self.timestamp),
-            b'\x01' if self.encrypted else b'\x00',
-            self.nonce,
-            self.message.to_bytes()
-        ])
-    
-    @classmethod
-    def from_bytes(cls, data: bytes) -> Optional['Envelope']:
-        """
-        Create an Envelope from its serialized form.
-        
-        Args:
-            data (bytes): Serialized envelope
-            
-        Returns:
-            Optional[Envelope]: The deserialized envelope, or None if the data is invalid
-        """
-        try:
-            parts = decode(data)
-            if len(parts) != 4:
-                return None
-                
-            timestamp_data, encrypted_flag, nonce, message_data = parts
-            
-            timestamp = struct.unpack('!Q', timestamp_data)[0]
-            encrypted = encrypted_flag == b'\x01'
-            nonce = nonce
-            message = Message.from_bytes(message_data)
-            
-            if not message:
-                return None
-                
-            return cls(
-                encrypted=encrypted,
-                message=message,
-                nonce=nonce,
-                timestamp=timestamp
-            )
-        except (ValueError, struct.error) as e:
-            print(f"Error deserializing envelope: {e}")
-            return None

astreum/_node/relay/message.py

@@ -1,110 +0,0 @@
-"""
-Message related classes and utilities for Astreum node network.
-"""
-
-import struct
-from enum import IntEnum, auto
-from dataclasses import dataclass
-from typing import Optional
-from astreum.format import encode, decode
-
-class Topic(IntEnum):
-    """
-    Enum for different message topics in the Astreum network.
-    """
-    PEER_ROUTE = 1
-    LATEST_BLOCK_REQUEST = 2
-    LATEST_BLOCK_RESPONSE = 3
-    GET_BLOCKS = 4
-    BLOCKS = 5
-    TRANSACTION = 6
-    BLOCK_COMMIT = 7
-    OBJECT_REQUEST = 8
-    OBJECT_RESPONSE = 9
-    PING = 10
-    PONG = 11
-    ROUTE = 12
-    ROUTE_REQUEST = 13
-    LATEST_BLOCK = 14
-    BLOCK = 15
-    
-    def to_bytes(self) -> bytes:
-        """
-        Convert this Topic enum value to bytes.
-        
-        Returns:
-            bytes: Single byte representing the topic
-        """
-        return struct.pack('!B', self.value)
-    
-    @classmethod
-    def from_bytes(cls, data: bytes) -> Optional['Topic']:
-        """
-        Create a Topic from its serialized form.
-        
-        Args:
-            data (bytes): Serialized topic (single byte)
-            
-        Returns:
-            Optional[Topic]: The deserialized topic, or None if the data is invalid
-        """
-        if not data or len(data) != 1:
-            return None
-            
-        try:
-            topic_value = struct.unpack('!B', data)[0]
-            return cls(topic_value)
-        except (struct.error, ValueError) as e:
-            print(f"Error deserializing topic: {e}")
-            return None
-
-@dataclass
-class Message:
-    """
-    Represents a message in the Astreum network.
-    
-    Attributes:
-        body (bytes): The actual content of the message
-        topic (Topic): The topic/type of the message
-    """
-    body: bytes
-    topic: Topic
-    
-    def to_bytes(self) -> bytes:
-        """
-        Convert this Message to bytes using bytes_format.
-        
-        Returns:
-            bytes: Serialized message
-        """
-        return encode([
-            self.topic.to_bytes(),
-            self.body
-        ])
-    
-    @classmethod
-    def from_bytes(cls, data: bytes) -> Optional['Message']:
-        """
-        Create a Message from its serialized form using bytes_format.
-        
-        Args:
-            data (bytes): Serialized message
-            
-        Returns:
-            Optional[Message]: The deserialized message, or None if the data is invalid
-        """
-        try:
-            parts = decode(data)
-            if len(parts) != 2:
-                return None
-                
-            topic_data, body = parts
-            topic = Topic.from_bytes(topic_data)
-            
-            if not topic:
-                return None
-                
-            return cls(body=body, topic=topic)
-        except (ValueError, struct.error) as e:
-            print(f"Error deserializing message: {e}")
-            return None

astreum/_node/relay/peer.py

@@ -1,174 +0,0 @@
-"""
-Peer management for Astreum node's Kademlia-style network.
-"""
-
-from dataclasses import dataclass
-from typing import Tuple, Optional
-import time
-
-@dataclass
-class Peer:
-    """
-    Represents a peer in the Astreum network.
-    
-    Attributes:
-        address (Tuple[str, int]): The network address (host, port)
-        public_key (bytes): The public key of the peer
-        difficulty (int): The proof-of-work difficulty required for this peer
-        last_seen (int): Timestamp when the peer was last seen
-        failed_attempts (int): Number of consecutive failed communication attempts
-    """
-    address: Tuple[str, int]
-    public_key: bytes
-    difficulty: int = 1
-    last_seen: int = 0
-    failed_attempts: int = 0
-    
-    def __post_init__(self):
-        if self.last_seen == 0:
-            self.last_seen = int(time.time())
-    
-    def update_last_seen(self):
-        """Update the last seen timestamp to current time."""
-        self.last_seen = int(time.time())
-        self.failed_attempts = 0
-    
-    def register_failed_attempt(self):
-        """Register a failed communication attempt with this peer."""
-        self.failed_attempts += 1
-    
-    def is_active(self, max_age: int = 3600, max_failures: int = 3) -> bool:
-        """
-        Check if the peer is considered active.
-        
-        Args:
-            max_age (int): Maximum age in seconds before peer is considered inactive
-            max_failures (int): Maximum consecutive failures before peer is considered inactive
-            
-        Returns:
-            bool: True if the peer is active, False otherwise
-        """
-        current_time = int(time.time())
-        return (
-            (current_time - self.last_seen) <= max_age and 
-            self.failed_attempts < max_failures
-        )
-
-class PeerManager:
-    """
-    Manages a collection of peers and provides utilities for peer operations.
-    """
-    
-    def __init__(self, our_node_id: bytes):
-        """
-        Initialize a peer manager.
-        
-        Args:
-            our_node_id (bytes): Our node's unique identifier
-        """
-        self.our_node_id = our_node_id
-        self.peers_by_id = {}  # node_id: Peer
-        self.peers_by_address = {}  # address: Peer
-    
-    def add_or_update_peer(self, address: Tuple[str, int], public_key: bytes) -> Peer:
-        """
-        Add a new peer or update an existing one.
-        
-        Args:
-            address (Tuple[str, int]): Network address (host, port)
-            public_key (bytes): The public key of the peer
-            
-        Returns:
-            Peer: The added or updated peer
-        """
-        # Check if we already know this peer by ID
-        if public_key in self.peers_by_id:
-            peer = self.peers_by_id[public_key]
-            # Update address if changed
-            if peer.address != address:
-                if peer.address in self.peers_by_address:
-                    del self.peers_by_address[peer.address]
-                peer.address = address
-                self.peers_by_address[address] = peer
-            peer.update_last_seen()
-            return peer
-        
-        # Check if address exists with different ID
-        if address in self.peers_by_address:
-            old_peer = self.peers_by_address[address]
-            if old_peer.public_key in self.peers_by_id:
-                del self.peers_by_id[old_peer.public_key]
-        
-        # Create and add new peer
-        peer = Peer(address=address, public_key=public_key)
-        self.peers_by_id[public_key] = peer
-        self.peers_by_address[address] = peer
-        return peer
-    
-    def get_peer_by_id(self, public_key: bytes) -> Optional[Peer]:
-        """
-        Get a peer by its public key.
-        
-        Args:
-            public_key (bytes): The peer's public key
-            
-        Returns:
-            Optional[Peer]: The peer if found, None otherwise
-        """
-        return self.peers_by_id.get(public_key)
-    
-    def get_peer_by_address(self, address: Tuple[str, int]) -> Optional[Peer]:
-        """
-        Get a peer by its network address.
-        
-        Args:
-            address (Tuple[str, int]): The peer's network address
-            
-        Returns:
-            Optional[Peer]: The peer if found, None otherwise
-        """
-        return self.peers_by_address.get(address)
-    
-    def remove_peer(self, public_key: bytes) -> bool:
-        """
-        Remove a peer by its public key.
-        
-        Args:
-            public_key (bytes): The peer's public key
-            
-        Returns:
-            bool: True if the peer was removed, False otherwise
-        """
-        if public_key in self.peers_by_id:
-            peer = self.peers_by_id[public_key]
-            del self.peers_by_id[public_key]
-            if peer.address in self.peers_by_address:
-                del self.peers_by_address[peer.address]
-            return True
-        return False
-    
-    def calculate_distance(self, public_key: bytes) -> int:
-        """
-        Calculate the XOR distance between our node ID and the given public key.
-        
-        In Kademlia, peers are organized into buckets based on the XOR distance.
-        The bucket index (0-255) represents the position of the first bit that differs.
-        
-        Args:
-            public_key (bytes): The remote node's public key
-            
-        Returns:
-            int: XOR distance (0-255)
-        """
-        # Assuming IDs are 256-bit (32 bytes)
-        for i in range(min(len(self.our_node_id), len(public_key))):
-            xor_byte = self.our_node_id[i] ^ public_key[i]
-            if xor_byte == 0:
-                continue
-                
-            # Find the most significant bit
-            for bit in range(7, -1, -1):
-                if (xor_byte >> bit) & 1:
-                    return (i * 8) + (7 - bit)
-        
-        return 255  # Default maximum distance