astreum 0.2.26__py3-none-any.whl → 0.2.28__py3-none-any.whl

astreum/lispeum/environment.py

@@ -0,0 +1,40 @@
+from typing import Dict, Optional
+import uuid
+
+from astreum.lispeum.expression import Expr
+
+
+class Env:
+    def __init__(
+        self,
+        data: Optional[Dict[str, Expr]] = None,
+        parent_id: Optional[uuid.UUID] = None,
+        max_exprs: Optional[int] = 8,
+    ):
+        self.data: Dict[str, Expr] = data if data is not None else {}
+        self.parent_id: Optional[uuid.UUID] = parent_id
+        self.max_exprs: Optional[int] = max_exprs
+
+    def put(self, name: str, value: Expr) -> None:
+        if (
+            self.max_exprs is not None
+            and name not in self.data
+            and len(self.data) >= self.max_exprs
+        ):
+            raise RuntimeError(
+                f"environment full: {len(self.data)} ≥ max_exprs={self.max_exprs}"
+            )
+        self.data[name] = value
+
+    def get(self, name: str) -> Optional[Expr]:
+        return self.data.get(name)
+
+    def pop(self, name: str) -> Optional[Expr]:
+        return self.data.pop(name, None)
+
+    def __repr__(self) -> str:
+        return (
+            f"Env(size={len(self.data)}, "
+            f"max_exprs={self.max_exprs}, "
+            f"parent_id={self.parent_id})"
+        )

astreum/lispeum/expression.py

@@ -0,0 +1,86 @@
+
+from typing import List, Optional, Union
+
+
+class Expr:
+    class ListExpr:
+        def __init__(self, elements: List['Expr']):
+            self.elements = elements
+
+        def __eq__(self, other):
+            if not isinstance(other, Expr.ListExpr):
+                return NotImplemented
+            return self.elements == other.elements
+
+        def __ne__(self, other):
+            return not self.__eq__(other)
+
+        @property
+        def value(self):
+            inner = " ".join(str(e) for e in self.elements)
+            return f"({inner})"
+
+
+        def __repr__(self):
+            if not self.elements:
+                return "()"
+            
+            inner = " ".join(str(e) for e in self.elements)
+            return f"({inner})"
+        
+        def __iter__(self):
+            return iter(self.elements)
+        
+        def __getitem__(self, index: Union[int, slice]):
+            return self.elements[index]
+
+        def __len__(self):
+            return len(self.elements)
+
+    class Symbol:
+        def __init__(self, value: str):
+            self.value = value
+
+        def __repr__(self):
+            return self.value
+
+    class Integer:
+        def __init__(self, value: int):
+            self.value = value
+
+        def __repr__(self):
+            return str(self.value)
+
+    class String:
+        def __init__(self, value: str):
+            self.value = value
+
+        def __repr__(self):
+            return f'"{self.value}"'
+        
+    class Boolean:
+        def __init__(self, value: bool):
+            self.value = value
+
+        def __repr__(self):
+            return "true" if self.value else "false"
+
+    class Function:
+        def __init__(self, params: List[str], body: 'Expr'):
+            self.params = params
+            self.body = body
+
+        def __repr__(self):
+            params_str = " ".join(self.params)
+            body_str = str(self.body)
+            return f"(fn ({params_str}) {body_str})"
+
+    class Error:
+        def __init__(self, message: str, origin: Optional['Expr'] = None):
+            self.message = message
+            self.origin  = origin
+
+        def __repr__(self):
+            if self.origin is None:
+                return f'(error "{self.message}")'
+            return f'(error "{self.message}" in {self.origin})'

astreum/models/message.py

@@ -0,0 +1,64 @@
+from enum import IntEnum
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PublicKey
+
+class MessageTopic(IntEnum):
+    PING = 0
+    OBJECT_REQUEST = 1
+    OBJECT_RESPONSE = 2
+    ROUTE_REQUEST = 3
+    ROUTE_RESPONSE = 4
+
+class Message:
+    handshake: bool
+    sender: X25519PublicKey
+
+    topic: MessageTopic
+    content: bytes
+
+    def to_bytes(self):
+        if self.handshake:
+            # handshake byte (1) + raw public key bytes
+            return bytes([1]) + self.sender.public_bytes(
+                encoding=serialization.Encoding.Raw,
+                format=serialization.PublicFormat.Raw
+            )
+        else:
+            # normal message: 0 + topic + content
+            return bytes([0, self.topic.value]) + self.content
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> "Message":
+        if len(data) < 1:
+            raise ValueError("Cannot parse Message: no data")
+        flag = data[0]
+        # create empty instance
+        msg = cls.__new__(cls)
+
+        if flag == 1:
+            # handshake message: the rest is the peer’s public key
+            key_bytes = data[1:]
+            try:
+                sender = X25519PublicKey.from_public_bytes(key_bytes)
+            except ValueError:
+                raise ValueError("Invalid public key bytes")
+            msg.handshake = True
+            msg.sender = sender
+            msg.topic = None
+            msg.content = b''
+        elif flag == 0:
+            # normal message: next byte is topic, rest is content
+            if len(data) < 2:
+                raise ValueError("Cannot parse Message: missing topic byte")
+            topic_val = data[1]
+            try:
+                topic = MessageTopic(topic_val)
+            except ValueError:
+                raise ValueError(f"Unknown MessageTopic: {topic_val}")
+            msg.handshake = False
+            msg.sender = None
+            msg.topic = topic
+            msg.content = data[2:]
+        else:
+            raise ValueError(f"Invalid handshake flag: {flag}")
+
+        return msg

astreum/node.py

@@ -7,160 +7,27 @@ from typing import Tuple, Dict, Union, Optional, List
 from datetime import datetime, timedelta, timezone
 import uuid
 
+from astreum.lispeum.environment import Env
+from astreum.lispeum.expression import Expr
+from astreum.storage.object import ObjectRequest, ObjectRequestType, ObjectResponse, ObjectResponseType
+from astreum.storage.setup import storage_setup
+
 from .models.transaction import Transaction
 from .format import encode, decode
 from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
 from cryptography.hazmat.primitives import serialization
 from .crypto import ed25519, x25519
-from enum import IntEnum
 import blake3
 import struct
+from .models.message import Message, MessageTopic
 
-class ObjectRequestType(IntEnum):
-    OBJECT_GET = 0
-    OBJECT_PUT = 1
-
-class ObjectRequest:
-    type: ObjectRequestType
-    data: bytes
-    hash: bytes
-
-    def __init__(self, type: ObjectRequestType, data: bytes, hash: bytes = None):
-        self.type = type
-        self.data = data
-        self.hash = hash
-
-    def to_bytes(self):
-        return encode([self.type.value, self.data, self.hash])
-
-    @classmethod
-    def from_bytes(cls, data: bytes):
-        type_val, data_val, hash_val = decode(data)
-        return cls(type=ObjectRequestType(type_val[0]), data=data_val, hash=hash_val)
-
-class ObjectResponseType(IntEnum):
-    OBJECT_FOUND = 0
-    OBJECT_PROVIDER = 1
-    OBJECT_NEAREST_PEER = 2
-
-class ObjectResponse:
-    type: ObjectResponseType
-    data: bytes
-    hash: bytes
-
-    def __init__(self, type: ObjectResponseType, data: bytes, hash: bytes = None):
-        self.type = type
-        self.data = data
-        self.hash = hash
-
-    def to_bytes(self):
-        return encode([self.type.value, self.data, self.hash])
-
-    @classmethod
-    def from_bytes(cls, data: bytes):
-        type_val, data_val, hash_val = decode(data)
-        return cls(type=ObjectResponseType(type_val[0]), data=data_val, hash=hash_val)
-
-class MessageTopic(IntEnum):
-    PING = 0
-    OBJECT_REQUEST = 1
-    OBJECT_RESPONSE = 2
-    ROUTE_REQUEST = 3
-    ROUTE_RESPONSE = 4
-
-class Message:
-    body: bytes
-    topic: MessageTopic
-    
-    def to_bytes(self):
-        return encode([self.body, [self.topic.value]])
-
-    @classmethod
-    def from_bytes(cls, data: bytes):
-        body, topic = decode(data)
-        return cls(body=body, topic=MessageTopic(topic[0]))
-
-class Envelope:
-    encrypted: bool
-    message: Message
-    nonce: int
-    sender: X25519PublicKey
-    timestamp: datetime
-
-    def __init__(self, message: Message, sender: X25519PublicKey, encrypted: bool = False, nonce: int = 0, timestamp: Union[int, datetime, None] = None, difficulty: int = 1):
-        self.encrypted = encrypted
-        encrypted_bytes = b'\x01' if self.encrypted else b'\x00'
-
-        self.message = message
-        message_bytes = message.to_bytes()
-
-        self.sender = sender
-        self.sender_bytes = sender.public_bytes()
-
-        self.nonce = nonce
-    
-        if timestamp is None:
-            self.timestamp = datetime.now(timezone.utc)
-            timestamp_int = int(self.timestamp.timestamp())
-        elif isinstance(timestamp, int):
-            self.timestamp = datetime.fromtimestamp(timestamp, timezone.utc)
-            timestamp_int = timestamp
-        elif isinstance(timestamp, datetime):
-            self.timestamp = timestamp
-            timestamp_int = int(timestamp.timestamp())
-        else:
-            raise TypeError("Timestamp must be an int (Unix timestamp), datetime object, or None")
-
-        def count_leading_zero_bits(data: bytes) -> int:
-            count = 0
-            for b in data:
-                if b == 0:
-                    count += 8
-                else:
-                    count += 8 - b.bit_length()
-                    break
-            return count
 
-        while True:
-            envelope_bytes = encode([
-                encrypted_bytes,
-                message_bytes,
-                self.nonce,
-                self.sender_bytes,
-                timestamp_int
-            ])
-            envelope_hash = blake3.blake3(envelope_bytes).digest()
-            if count_leading_zero_bits(envelope_hash) >= difficulty:
-                self.hash = envelope_hash
-                break
-            self.nonce += 1
-
-    def to_bytes(self):
-        encrypted_bytes = b'\x01' if self.encrypted else b'\x00'
-        
-        return encode([
-            encrypted_bytes,
-            self.message.to_bytes(),
-            self.nonce,
-            self.sender.public_bytes(),
-            int(self.timestamp.timestamp())
-        ])
-
-    @classmethod
-    def from_bytes(cls, data: bytes):
-        encrypted_bytes, message_bytes, nonce, sender_bytes, timestamp_int = decode(data)
-        return cls(
-            encrypted=(encrypted_bytes == b'\x01'),
-            message=Message.from_bytes(message_bytes),
-            nonce=nonce,
-            sender=X25519PublicKey.from_public_bytes(sender_bytes),
-            timestamp=datetime.fromtimestamp(timestamp_int, timezone.utc)
-        )
 
 class Peer:
-    def __init__(self, node_secret_key: X25519PrivateKey, peer_public_key: X25519PublicKey, address: Tuple[str, int]):
-        self.shared_key = x25519.generate_shared_key(node_secret_key, peer_public_key)
-        self.address = address
+    shared_key: bytes
+    timestamp: datetime
+    def __init__(self, my_sec_key: X25519PrivateKey, peer_pub_key: X25519PublicKey):
+        self.shared_key = my_sec_key.exchange(peer_pub_key)
         self.timestamp = datetime.now(timezone.utc)
 
 class Route:
@@ -203,135 +70,18 @@ def decode_ip_address(data: bytes) -> tuple[str, int]:
         raise ValueError("Invalid address byte format")
     return ip, port
 
-# =========
-# MACHINE
-# =========
-
-class Expr:
-    class ListExpr:
-        def __init__(self, elements: List['Expr']):
-            self.elements = elements
-
-        def __eq__(self, other):
-            if not isinstance(other, Expr.ListExpr):
-                return NotImplemented
-            return self.elements == other.elements
-
-        def __ne__(self, other):
-            return not self.__eq__(other)
-
-        @property
-        def value(self):
-            inner = " ".join(str(e) for e in self.elements)
-            return f"({inner})"
-
-
-        def __repr__(self):
-            if not self.elements:
-                return "()"
-            
-            inner = " ".join(str(e) for e in self.elements)
-            return f"({inner})"
-        
-        def __iter__(self):
-            return iter(self.elements)
-        
-        def __getitem__(self, index: Union[int, slice]):
-            return self.elements[index]
-
-        def __len__(self):
-            return len(self.elements)
-
-    class Symbol:
-        def __init__(self, value: str):
-            self.value = value
-
-        def __repr__(self):
-            return self.value
-
-    class Integer:
-        def __init__(self, value: int):
-            self.value = value
-
-        def __repr__(self):
-            return str(self.value)
-
-    class String:
-        def __init__(self, value: str):
-            self.value = value
-
-        def __repr__(self):
-            return f'"{self.value}"'
-        
-    class Boolean:
-        def __init__(self, value: bool):
-            self.value = value
-
-        def __repr__(self):
-            return "true" if self.value else "false"
-
-    class Function:
-        def __init__(self, params: List[str], body: 'Expr'):
-            self.params = params
-            self.body = body
-
-        def __repr__(self):
-            params_str = " ".join(self.params)
-            body_str = str(self.body)
-            return f"(fn ({params_str}) {body_str})"
-
-    class Error:
-        def __init__(self, message: str, origin: Optional['Expr'] = None):
-            self.message = message
-            self.origin  = origin
-
-        def __repr__(self):
-            if self.origin is None:
-                return f'(error "{self.message}")'
-            return f'(error "{self.message}" in {self.origin})'
-
-class Env:
-    def __init__(
-        self,
-        data: Optional[Dict[str, Expr]] = None,
-        parent_id: Optional[uuid.UUID] = None,
-        max_exprs: Optional[int] = 8,
-    ):
-        self.data: Dict[str, Expr] = data if data is not None else {}
-        self.parent_id: Optional[uuid.UUID] = parent_id
-        self.max_exprs: Optional[int] = max_exprs
-
-    def put(self, name: str, value: Expr) -> None:
-        if (
-            self.max_exprs is not None
-            and name not in self.data
-            and len(self.data) >= self.max_exprs
-        ):
-            raise RuntimeError(
-                f"environment full: {len(self.data)} ≥ max_exprs={self.max_exprs}"
-            )
-        self.data[name] = value
-
-    def get(self, name: str) -> Optional[Expr]:
-        return self.data.get(name)
-
-    def pop(self, name: str) -> Optional[Expr]:
-        return self.data.pop(name, None)
-
-    def __repr__(self) -> str:
-        return (
-            f"Env(size={len(self.data)}, "
-            f"max_exprs={self.max_exprs}, "
-            f"parent_id={self.parent_id})"
-        )
-
-
 class Node:
     def __init__(self, config: dict = {}):
         self._machine_setup()
         machine_only = bool(config.get('machine-only', True))
         if not machine_only:
-            self._storage_setup(config=config)
+            (
+                self.storage_path,
+                self.memory_storage,
+                self.storage_get_relay_timeout,
+                self.storage_index
+            ) = storage_setup(config)
+
             self._relay_setup(config=config)
             self._validation_setup(config=config)
 
@@ -344,21 +94,6 @@ class Node:
     def _create_block(self):
         pass
 
-    # STORAGE METHODS
-    def _storage_setup(self, config: dict):
-        storage_path_str = config.get('storage_path')
-        if storage_path_str is None:
-            self.storage_path = None
-            self.memory_storage = {}
-        else:
-            self.storage_path = Path(storage_path_str)
-            self.storage_path.mkdir(parents=True, exist_ok=True)
-            self.memory_storage = None
-
-        self.storage_get_relay_timeout = config.get('storage_get_relay_timeout', 5)
-        # STORAGE INDEX: (object_hash, encoded (provider_public_key, provider_address))
-        self.storage_index = Dict[bytes, bytes]
-
     def _relay_setup(self, config: dict):
         self.use_ipv6 = config.get('use_ipv6', False)
         incoming_port = config.get('incoming_port', 7373)
@@ -419,6 +154,7 @@ class Node:
         self.peer_manager_thread.start()
 
         self.peers = Dict[X25519PublicKey, Peer]
+        self.addresses = Dict[Tuple[str, int], X25519PublicKey]
 
         if 'bootstrap' in config:
             for addr in config['bootstrap']:
@@ -451,9 +187,8 @@ class Node:
         # find the nearest peer route node to the hash and send an object request
         closest_peer = self._get_closest_local_peer(hash)
         if closest_peer:
-            object_request_message = Message(topic=MessageTopic.OBJECT_REQUEST, body=hash)
-            object_request_envelope = Envelope(message=object_request_message, sender=self.relay_public_key)
-            self.outgoing_queue.put((object_request_envelope.to_bytes(), self.peers[closest_peer].address))
+            object_request_message = Message(topic=MessageTopic.OBJECT_REQUEST, content=hash)
+            self.outgoing_queue.put((object_request_message.to_bytes(), self.peers[closest_peer].address))
 
         # wait for upto self.storage_get_relay_timeout seconds for the object to be stored/until local_object_get returns something
         start_time = time.time()
@@ -481,30 +216,31 @@ class Node:
         while True:
             try:
                 data, addr = self.incoming_queue.get()
-                envelope = Envelope.from_bytes(data)
-                match envelope.message.topic:
+                message = Message.from_bytes(data)
+                match message.topic:
                     case MessageTopic.PING:
-                        if envelope.sender in self.peers:
-                            self.peers[envelope.sender].timestamp = datetime.now(timezone.utc)
+                        peer_pub_key = self.addresses.get(addr)
+                        if peer_pub_key in self.peers:
+                            self.peers[peer_pub_key].timestamp = datetime.now(timezone.utc)
                             continue
 
-                        is_validator_flag = decode(envelope.message.body)
+                        is_validator_flag = decode(message.body)
 
-                        if envelope.sender not in self.peers:
+                        if peer_pub_key not in self.peers:
                             self._send_ping(addr)
 
-                        peer = Peer(self.relay_secret_key, envelope.sender, addr)
+                        peer = Peer(my_sec_key=self.relay_secret_key, peer_pub_key=peer_pub_key)
                         self.peers[peer.sender] = peer
-                        self.peer_route.add_peer(envelope.sender)
+                        self.peer_route.add_peer(peer_pub_key)
                         if is_validator_flag == [1]:
-                            self.validation_route.add_peer(envelope.sender)
+                            self.validation_route.add_peer(peer_pub_key)
 
                         if peer.timestamp < datetime.now(timezone.utc) - timedelta(minutes=5.0):
                             self._send_ping(addr)
                     
                     case MessageTopic.OBJECT_REQUEST:
                         try:
-                            object_request = ObjectRequest.from_bytes(envelope.message.body)
+                            object_request = ObjectRequest.from_bytes(message.body)
 
                             match object_request.type:
                                 # --------------  OBJECT_GET  --------------
@@ -519,9 +255,8 @@ class Node:
                                             data=local_data,
                                             hash=object_hash
                                         )
-                                        msg  = Message(topic=MessageTopic.OBJECT_RESPONSE, body=resp.to_bytes())
-                                        env  = Envelope(message=msg, sender=self.relay_public_key)
-                                        self.outgoing_queue.put((env.to_bytes(), addr))
+                                        obj_res_msg  = Message(topic=MessageTopic.OBJECT_RESPONSE, body=resp.to_bytes())
+                                        self.outgoing_queue.put((obj_res_msg.to_bytes(), addr))
                                         return  # done
 
                                     # 2. If we know a provider, tell the requester.
@@ -534,9 +269,8 @@ class Node:
                                             data=provider_bytes,
                                             hash=object_hash
                                         )
-                                        msg = Message(topic=MessageTopic.OBJECT_RESPONSE, body=resp.to_bytes())
-                                        env = Envelope(message=msg, sender=self.relay_public_key)
-                                        self.outgoing_queue.put((env.to_bytes(), addr))
+                                        obj_res_msg = Message(topic=MessageTopic.OBJECT_RESPONSE, body=resp.to_bytes())
+                                        self.outgoing_queue.put((obj_res_msg.to_bytes(), addr))
                                         return  # done
 
                                     # 3. Otherwise, direct the requester to a peer nearer to the hash.
@@ -555,14 +289,13 @@ class Node:
                                             data=peer_info,
                                             hash=object_hash
                                         )
-                                        msg = Message(topic=MessageTopic.OBJECT_RESPONSE, body=resp.to_bytes())
-                                        env = Envelope(message=msg, sender=self.relay_public_key)
-                                        self.outgoing_queue.put((env.to_bytes(), addr))
+                                        obj_res_msg = Message(topic=MessageTopic.OBJECT_RESPONSE, body=resp.to_bytes())
+                                        self.outgoing_queue.put((obj_res_msg.to_bytes(), addr))
 
                                 # --------------  OBJECT_PUT  --------------
                                 case ObjectRequestType.OBJECT_PUT:
                                     # Ensure the hash is present / correct.
-                                    obj_hash = object_request.hash or blake30.blake3(object_request.data).digest()
+                                    obj_hash = object_request.hash or blake3.blake3(object_request.data).digest()
 
                                     nearest = self._get_closest_local_peer(obj_hash)
                                     # If a strictly nearer peer exists, forward the PUT.
@@ -572,13 +305,13 @@ class Node:
                                             data=object_request.data,
                                             hash=obj_hash
                                         )
-                                        fwd_msg = Message(topic=MessageTopic.OBJECT_REQUEST, body=fwd_req.to_bytes())
-                                        fwd_env = Envelope(message=fwd_msg, sender=self.relay_public_key)
-                                        self.outgoing_queue.put((fwd_env.to_bytes(), nearest[1].address))
+                                        obj_req_msg = Message(topic=MessageTopic.OBJECT_REQUEST, body=fwd_req.to_bytes())
+                                        self.outgoing_queue.put((obj_req_msg.to_bytes(), nearest[1].address))
                                     else:
                                         # We are closest → remember who can provide the object.
+                                        peer_pub_key = self.addresses.get(addr)
                                         provider_record = encode([
-                                            envelope.sender.public_bytes(),
+                                           peer_pub_key.public_bytes(),
                                             encode_ip_address(*addr)
                                         ])
                                         if not hasattr(self, "storage_index") or not isinstance(self.storage_index, dict):
@@ -590,13 +323,13 @@ class Node:
 
                     case MessageTopic.OBJECT_RESPONSE:
                         try:
-                            object_response = ObjectResponse.from_bytes(envelope.message.body)
+                            object_response = ObjectResponse.from_bytes(message.body)
                             if object_response.hash not in self.object_request_queue:
                                 continue
                             
                             match object_response.type:
                                 case ObjectResponseType.OBJECT_FOUND:
-                                    if object_response.hash != blake30.blake3(object_response.data).digest():
+                                    if object_response.hash != blake3.blake3(object_response.data).digest():
                                         continue
                                     self.object_request_queue.remove(object_response.hash)
                                     self._local_object_put(object_response.hash, object_response.data)
@@ -604,9 +337,8 @@ class Node:
                                 case ObjectResponseType.OBJECT_PROVIDER:
                                     _provider_public_key, provider_address = decode(object_response.data)
                                     provider_ip, provider_port = decode_ip_address(provider_address)
-                                    object_request_message = Message(topic=MessageTopic.OBJECT_REQUEST, body=object_hash)
-                                    object_request_envelope = Envelope(message=object_request_message, sender=self.relay_public_key)
-                                    self.outgoing_queue.put((object_request_envelope.to_bytes(), (provider_ip, provider_port)))
+                                    obj_req_msg = Message(topic=MessageTopic.OBJECT_REQUEST, body=object_hash)
+                                    self.outgoing_queue.put((obj_req_msg.to_bytes(), (provider_ip, provider_port)))
 
                                 case ObjectResponseType.OBJECT_NEAREST_PEER:
                                     # -- decode the peer info sent back
@@ -630,23 +362,10 @@ class Node:
                                     if self._is_closer_than_local_peers(
                                         object_response.hash, nearest_peer_public_key
                                     ):
-                                        nearest_peer_ip, nearest_peer_port = decode_ip_address(
-                                            nearest_peer_address
-                                        )
-                                        object_request_message = Message(
-                                            topic=MessageTopic.OBJECT_REQUEST,
-                                            body=object_response.hash,
-                                        )
-                                        object_request_envelope = Envelope(
-                                            message=object_request_message,
-                                            sender=self.relay_public_key,
-                                        )
-                                        self.outgoing_queue.put(
-                                            (
-                                                object_request_envelope.to_bytes(),
-                                                (nearest_peer_ip, nearest_peer_port),
-                                            )
-                                        )
+                                        nearest_peer_ip, nearest_peer_port = decode_ip_address(nearest_peer_address)
+                                        obj_req_msg = Message(topic=MessageTopic.OBJECT_REQUEST, content=object_response.hash)
+                                        self.outgoing_queue.put((obj_req_msg.to_bytes(), (nearest_peer_ip, nearest_peer_port),)
+                                    )
 
           
                         except Exception as e:
@@ -678,9 +397,8 @@ class Node:
 
     def _send_ping(self, addr: Tuple[str, int]):
         is_validator_flag = encode([1] if self.validation_secret_key else [0])
-        ping_message = Message(topic=MessageTopic.PING, body=is_validator_flag)
-        ping_envelope = Envelope(message=ping_message, sender=self.relay_public_key)
-        self.outgoing_queue.put((ping_envelope.to_bytes(), addr))
+        ping_message = Message(topic=MessageTopic.PING, content=is_validator_flag)
+        self.outgoing_queue.put((ping_message.to_bytes(), addr))
 
     def _get_closest_local_peer(self, hash: bytes) -> Optional[Tuple[X25519PublicKey, Peer]]:
         # Find the globally closest peer using XOR distance

astreum/storage/object.py

@@ -0,0 +1,68 @@
+from enum import IntEnum
+
+class ObjectRequestType(IntEnum):
+    OBJECT_GET = 0
+    OBJECT_PUT = 1
+
+class ObjectRequest:
+    type: ObjectRequestType
+    data: bytes
+    hash: bytes
+
+    def __init__(self, type: ObjectRequestType, data: bytes, hash: bytes = None):
+        self.type = type
+        self.data = data
+        self.hash = hash
+
+    def to_bytes(self):
+        return [self.type.value] + self.hash + self.data
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> "ObjectRequest":
+        # need at least 1 byte for type + 32 bytes for hash
+        if len(data) < 1 + 32:
+            raise ValueError(f"Too short for ObjectRequest ({len(data)} bytes)")
+
+        type_val = data[0]
+        try:
+            req_type = ObjectRequestType(type_val)
+        except ValueError:
+            raise ValueError(f"Unknown ObjectRequestType: {type_val!r}")
+
+        hash_bytes = data[1:33]
+        payload    = data[33:]
+        return cls(req_type, payload, hash_bytes)
+
+class ObjectResponseType(IntEnum):
+    OBJECT_FOUND = 0
+    OBJECT_PROVIDER = 1
+    OBJECT_NEAREST_PEER = 2
+
+class ObjectResponse:
+    type: ObjectResponseType
+    data: bytes
+    hash: bytes
+
+    def __init__(self, type: ObjectResponseType, data: bytes, hash: bytes = None):
+        self.type = type
+        self.data = data
+        self.hash = hash
+
+    def to_bytes(self):
+        return [self.type.value] + self.hash + self.data
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> "ObjectResponse":
+        # need at least 1 byte for type + 32 bytes for hash
+        if len(data) < 1 + 32:
+            raise ValueError(f"Too short to be a valid ObjectResponse ({len(data)} bytes)")
+
+        type_val = data[0]
+        try:
+            resp_type = ObjectResponseType(type_val)
+        except ValueError:
+            raise ValueError(f"Unknown ObjectResponseType: {type_val}")
+
+        hash_bytes = data[1:33]
+        payload   = data[33:]
+        return cls(resp_type, payload, hash_bytes)

astreum/storage/setup.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+from typing import Optional, Dict, Tuple, Any
+
+def storage_setup(config: dict
+    ) -> Tuple[Optional[Path], Dict[bytes, Any], int, Dict[bytes, bytes]]:
+    storage_path_str = config.get('storage_path')
+    if storage_path_str is None:
+        storage_path, memory_storage = None, {}
+    else:
+        storage_path = Path(storage_path_str)
+        storage_path.mkdir(parents=True, exist_ok=True)
+        memory_storage = None
+
+    timeout = config.get('storage_get_relay_timeout', 5)
+    storage_index: Dict[bytes, bytes] = {}
+    return storage_path, memory_storage, timeout, storage_index

{astreum-0.2.26.dist-info → astreum-0.2.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.26
+Version: 0.2.28
 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.2.26.dist-info → astreum-0.2.28.dist-info}/RECORD

@@ -1,12 +1,14 @@
 astreum/__init__.py,sha256=y2Ok3EY_FstcmlVASr80lGR_0w-dH-SXDCCQFmL6uwA,28
 astreum/format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
-astreum/node.py,sha256=dPloCXuDyIn3-KDqxlgl3jxsonJlFMLi_quwJRsoLC8,46259
+astreum/node.py,sha256=L2YpIxyhf0f-y85_vBGBaGiItgFGzLgXYhyabDetaKM,37116
 astreum/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/crypto/ed25519.py,sha256=FRnvlN0kZlxn4j-sJKl-C9tqiz_0z4LZyXLj3KIj1TQ,1760
 astreum/crypto/quadratic_form.py,sha256=pJgbORey2NTWbQNhdyvrjy_6yjORudQ67jBz2ScHptg,4037
 astreum/crypto/wesolowski.py,sha256=SUgGXW3Id07dJtWzDcs4dluIhjqbRWQ8YWjn_mK78AQ,4092
 astreum/crypto/x25519.py,sha256=i29v4BmwKRcbz9E7NKqFDQyxzFtJUqN0St9jd7GS1uA,1137
 astreum/lispeum/__init__.py,sha256=K-NDzIjtIsXzC9X7lnYvlvIaVxjFcY7WNsgLIE3DH3U,58
+astreum/lispeum/environment.py,sha256=wolwt9psDl62scgjaVG0G59xlBs1AM4NPgryUbxzG_4,1220
+astreum/lispeum/expression.py,sha256=K8gFifDaHu394bs9qnpvP8tjeiymFGQpnDC_iW9nU4E,2379
 astreum/lispeum/parser.py,sha256=jQRzZYvBuSg8t_bxsbt1-WcHaR_LPveHNX7Qlxhaw-M,1165
 astreum/lispeum/tokenizer.py,sha256=J-I7MEd0r2ZoVqxvRPlu-Afe2ZdM0tKXXhf1R4SxYTo,1429
 astreum/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -14,10 +16,14 @@ astreum/models/account.py,sha256=sHujGSwtV13rvOGJ5LZXuMrJ4F9XUdvyuWKz-zJ9lkE,298
 astreum/models/accounts.py,sha256=aFSEWlq6zRf65-KGAdNGqEJyNVY3fpKhx8y1vU6sgSc,1164
 astreum/models/block.py,sha256=-5j7uO0woVtNi0h52__e7AxpDQSVhzKUhr6Qc-2xZsE,17870
 astreum/models/merkle.py,sha256=lvWJa9nmrBL0n_2h_uNqpB_9a5s5Hn1FceRLx0IZIVQ,6778
+astreum/models/message.py,sha256=vv8yx-ndVYjCmPM4gXRVMToCTlKY_mflPu0uKsb9iiE,2117
 astreum/models/patricia.py,sha256=ohmXrcaz7Ae561tyC4u4iPOkQPkKr8N0IWJek4upFIg,13392
 astreum/models/transaction.py,sha256=MkLL5YX18kIf9-O4LBaZ4eWjkXDAaYIrDcDehbDZoqg,3038
-astreum-0.2.26.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.26.dist-info/METADATA,sha256=fUG5PepefY7Cjfp5Gj5GwtbYF369bARQAcl0A4OJiQ0,5478
-astreum-0.2.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.26.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.26.dist-info/RECORD,,
+astreum/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astreum/storage/object.py,sha256=knFlvw_tpcC4twSu1DGNpHX31wlANN8E5dgEqIfU--Q,2041
+astreum/storage/setup.py,sha256=EhMKr4wnBaESbzF8AlE2R-8YPIzxWx3afSv5BL8X6Lo,632
+astreum-0.2.28.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.2.28.dist-info/METADATA,sha256=dB1O5if24FmM7erOlVfX-WAa923EO8KgzCl4GpaHS7o,5478
+astreum-0.2.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.2.28.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.2.28.dist-info/RECORD,,