astreum 0.2.27__tar.gz → 0.2.29__tar.gz

{astreum-0.2.27/src/astreum.egg-info → astreum-0.2.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.27
+Version: 0.2.29
 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.27 → astreum-0.2.29}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "astreum"
-version = "0.2.27"
+version = "0.2.29"
 authors = [
   { name="Roy R. O. Okello", email="roy@stelar.xyz" },
 ]

astreum-0.2.29/src/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-0.2.29/src/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-0.2.27 → astreum-0.2.29}/src/astreum/node.py

@@ -7,92 +7,23 @@ 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.relay.peer import Peer
+from astreum.relay.route import Route
+from astreum.relay.setup import load_ed25519, load_x25519, make_routes, setup_outgoing, setup_udp
+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 Peer:
-    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:
-    def __init__(self, relay_public_key: X25519PublicKey, bucket_size: int = 16):
-        self.relay_public_key_bytes = relay_public_key.public_bytes(encoding=Encoding.Raw, format=PublicFormat.Raw)
-        self.bucket_size = bucket_size
-        self.buckets: Dict[int, List[X25519PublicKey]] = {
-            i: [] for i in range(len(self.relay_public_key_bytes) * 8)
-        }
-        self.peers = {}
-
-    @staticmethod
-    def _matching_leading_bits(a: bytes, b: bytes) -> int:
-        for byte_index, (ba, bb) in enumerate(zip(a, b)):
-            diff = ba ^ bb
-            if diff:
-                return byte_index * 8 + (8 - diff.bit_length())
-        return len(a) * 8
-
-    def add_peer(self, peer_public_key: X25519PublicKey):
-        peer_public_key_bytes = peer_public_key.public_bytes(encoding=Encoding.Raw, format=PublicFormat.Raw)
-        bucket_idx = self._matching_leading_bits(self.relay_public_key_bytes, peer_public_key_bytes)
-        if len(self.buckets[bucket_idx]) < self.bucket_size:
-            self.buckets[bucket_idx].append(peer_public_key)  
-
-
 def encode_ip_address(host: str, port: int) -> bytes:
     ip_bytes = socket.inet_pton(socket.AF_INET6 if ':' in host else socket.AF_INET, host)
     port_bytes = struct.pack("!H", port)
@@ -109,135 +40,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)
 
@@ -250,87 +64,46 @@ 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
+    def _relay_setup(self, config: dict):
+        self.use_ipv6              = config.get('use_ipv6', False)
 
-        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]
+        # key loading
+        self.relay_secret_key      = load_x25519(config.get('relay_secret_key'))
+        self.validation_secret_key = load_ed25519(config.get('validation_secret_key'))
 
-    def _relay_setup(self, config: dict):
-        self.use_ipv6 = config.get('use_ipv6', False)
-        incoming_port = config.get('incoming_port', 7373)
+        # derive pubs + routes
+        self.relay_public_key      = self.relay_secret_key.public_key()
+        self.peer_route, self.validation_route = make_routes(
+            self.relay_public_key,
+            self.validation_secret_key
+        )
 
-        if 'relay_secret_key' in config:
-            try:
-                private_key_bytes = bytes.fromhex(config['relay_secret_key'])
-                self.relay_secret_key = ed25519.Ed25519PrivateKey.from_private_bytes(private_key_bytes)
-            except Exception as e:
-                raise Exception(f"Error loading relay secret key provided: {e}")
-        else:
-            self.relay_secret_key = ed25519.Ed25519PrivateKey.generate()
-        
-        self.relay_public_key = self.relay_secret_key.public_key()
+        # sockets + queues + threads
+        (self.incoming_socket,
+         self.incoming_port,
+         self.incoming_queue,
+         self.incoming_populate_thread,
+         self.incoming_process_thread
+        ) = setup_udp(config.get('incoming_port', 7373), self.use_ipv6)
 
-        if 'validation_secret_key' in config:
-            try:
-                private_key_bytes = bytes.fromhex(config['validation_secret_key'])
-                self.validation_secret_key = x25519.X25519PrivateKey.from_private_bytes(private_key_bytes)
-            except Exception as e:
-                raise Exception(f"Error loading validation secret key provided: {e}")
-
-        # setup peer route and validation route
-        self.peer_route = Route(self.relay_public_key)
-        if self.validation_secret_key:
-            self.validation_route = Route(self.relay_public_key)
-
-        # Choose address family based on IPv4 or IPv6
-        family = socket.AF_INET6 if self.use_ipv6 else socket.AF_INET
-
-        self.incoming_socket = socket.socket(family, socket.SOCK_DGRAM)
-        if self.use_ipv6:
-            self.incoming_socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
-        bind_address = "::" if self.use_ipv6 else "0.0.0.0"
-        self.incoming_socket.bind((bind_address, incoming_port or 0))
-        self.incoming_port = self.incoming_socket.getsockname()[1]
-        self.incoming_queue = Queue()
-
-        self.incoming_populate_thread = threading.Thread(target=self._relay_incoming_queue_populating)
-        self.incoming_populate_thread.daemon = True
-        self.incoming_populate_thread.start()
-
-        self.incoming_process_thread = threading.Thread(target=self._relay_incoming_queue_processing)
-        self.incoming_process_thread.daemon = True
-        self.incoming_process_thread.start()
-
-        # outgoing thread
-        self.outgoing_socket = socket.socket(family, socket.SOCK_DGRAM)
-        self.outgoing_queue = Queue()
-        self.outgoing_thread = threading.Thread(target=self._relay_outgoing_queue_processor)
-        self.outgoing_thread.daemon = True
-        self.outgoing_thread.start()
+        (self.outgoing_socket,
+         self.outgoing_queue,
+         self.outgoing_thread
+        ) = setup_outgoing(self.use_ipv6)
 
+        # other workers & maps
         self.object_request_queue = Queue()
-
-        self.peer_manager_thread = threading.Thread(target=self._relay_peer_manager)
-        self.peer_manager_thread.daemon = True
+        self.peer_manager_thread  = threading.Thread(
+            target=self._relay_peer_manager,
+            daemon=True
+        )
         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']:
-                self._send_ping(addr)
+        self.peers, self.addresses = {}, {} # peers: Dict[X25519PublicKey,Peer], addresses: Dict[(str,int),X25519PublicKey]
 
+        # bootstrap pings
+        for addr in config.get('bootstrap', []):
+            self._send_ping(addr)
 
     def _local_object_get(self, data_hash: bytes) -> Optional[bytes]:
         if self.memory_storage is not None:
@@ -701,137 +474,10 @@ class Node:
                     return result
 
                 # # List
-                # elif first.value == "list.new":
-                #     return Expr.ListExpr([self.evaluate_expression(arg, env) for arg in expr.elements[1:]])
-
-                # elif first.value == "list.get":
-                #     args = expr.elements[1:]
-                #     if len(args) != 2:
-                #         return Expr.Error(
-                #             category="SyntaxError",
-                #             message="list.get expects exactly two arguments: a list and an index"
-                #         )
-                #     list_obj = self.evaluate_expression(args[0], env)
-                #     index = self.evaluate_expression(args[1], env)
-                #     return handle_list_get(self, list_obj, index, env)
-
-                # elif first.value == "list.insert":
-                #     args = expr.elements[1:]
-                #     if len(args) != 3:
-                #         return Expr.ListExpr([
-                #             Expr.ListExpr([]),
-                #             Expr.String("list.insert expects exactly three arguments: a list, an index, and a value")
-                #         ])
-                    
-                #     return handle_list_insert(
-                #         list=self.evaluate_expression(args[0], env),
-                #         index=self.evaluate_expression(args[1], env),
-                #         value=self.evaluate_expression(args[2], env),
-                #     )
-
-                # elif first.value == "list.remove":
-                #     args = expr.elements[1:]
-                #     if len(args) != 2:
-                #         return Expr.ListExpr([
-                #             Expr.ListExpr([]),
-                #             Expr.String("list.remove expects exactly two arguments: a list and an index")
-                #         ])
-                    
-                #     return handle_list_remove(
-                #         list=self.evaluate_expression(args[0], env),
-                #         index=self.evaluate_expression(args[1], env),
-                #     )
-
-                # elif first.value == "list.length":
-                #     args = expr.elements[1:]
-                #     if len(args) != 1:
-                #         return Expr.ListExpr([
-                #             Expr.ListExpr([]),
-                #             Expr.String("list.length expects exactly one argument: a list")
-                #         ])
-                    
-                #     list_obj = self.evaluate_expression(args[0], env)
-                #     if not isinstance(list_obj, Expr.ListExpr):
-                #         return Expr.ListExpr([
-                #             Expr.ListExpr([]),
-                #             Expr.String("Argument must be a list")
-                #         ])
-                    
-                #     return Expr.ListExpr([
-                #         Expr.Integer(len(list_obj.elements)),
-                #         Expr.ListExpr([]) 
-                #     ])
-
-                # elif first.value == "list.fold":
-                #     if len(args) != 3:
-                #         return Expr.ListExpr([
-                #             Expr.ListExpr([]),
-                #             Expr.String("list.fold expects exactly three arguments: a list, an initial value, and a function")
-                #         ])
-                    
-                #     return handle_list_fold(
-                #         machine=self,
-                #         list=self.evaluate_expression(args[0], env),
-                #         initial=self.evaluate_expression(args[1], env),
-                #         func=self.evaluate_expression(args[2], env),
-                #         env=env,
-                #     )
-
-                # elif first.value == "list.map":
-                #     if len(args) != 2:
-                #         return Expr.ListExpr([
-                #             Expr.ListExpr([]),
-                #             Expr.String("list.map expects exactly two arguments: a list and a function")
-                #         ])
-                    
-                #     return handle_list_map(
-                #         machine=self,
-                #         list=self.evaluate_expression(args[0], env),
-                #         func=self.evaluate_expression(args[1], env),
-                #         env=env,
-                #     )
-
-                # elif first.value == "list.position":
-                #     if len(args) != 2:
-                #         return Expr.ListExpr([
-                #             Expr.ListExpr([]),
-                #             Expr.String("list.position expects exactly two arguments: a list and a function")
-                #         ])
-                    
-                #     return handle_list_position(
-                #         machine=self,
-                #         list=self.evaluate_expression(args[0], env),
-                #         predicate=self.evaluate_expression(args[1], env),
-                #         env=env,
-                #     )
-
-                # elif first.value == "list.any":
-                #     if len(args) != 2:
-                #         return Expr.ListExpr([
-                #             Expr.ListExpr([]),
-                #             Expr.String("list.any expects exactly two arguments: a list and a function")
-                #         ])
-                    
-                #     return handle_list_any(
-                #         machine=self,
-                #         list=self.evaluate_expression(args[0], env),
-                #         predicate=self.evaluate_expression(args[1], env),
-                #         env=env,
-                #     )
-
-                # elif first.value == "list.all":
-                #     if len(args) != 2:
-                #         return Expr.ListExpr([
-                #             Expr.ListExpr([]),
-                #             Expr.String("list.all expects exactly two arguments: a list and a function")
-                #         ])
-                    
-                #     return handle_list_all(
-                #         machine=self,
-                #         list=self.evaluate_expression(args[0], env),
-                #         predicate=self.evaluate_expression(args[1], env),
-                #         env=env,
-                #     )
+                elif first.value == "list.each":
+                    internal_function = expr.elements[1]
+
+                
 
                 # Integer arithmetic primitives
                 elif first.value == "+":
@@ -918,6 +564,19 @@ class Node:
 
                     return Expr.Boolean(res)
 
+            if isinstance(first, Expr.Function):
+                arg_exprs = expr.elements[1:]
+                if len(arg_exprs) != len(first.params):
+                    return Expr.Error(f"arity mismatch: expected {len(first.params)}, got {len(arg_exprs)}", origin=expr)
+
+                call_env = self.machine_create_environment(parent_id=env_id)
+                for name, aexpr in zip(first.params, arg_exprs):
+                    val = self.machine_expr_eval(env_id, aexpr)
+                    if isinstance(val, Expr.Error): return val
+                    self.machine_expr_put(call_env, name, val)
+
+                return self.machine_expr_eval(env_id=call_env, expr=first.body)
+
             else:
                 evaluated_elements = [self.machine_expr_eval(env_id=env_id, expr=e) for e in expr.elements]
                 return Expr.ListExpr(evaluated_elements)

astreum-0.2.29/src/astreum/relay/peer.py

@@ -0,0 +1,9 @@
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
+from datetime import datetime, timezone
+
+class Peer:
+    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)

astreum-0.2.29/src/astreum/relay/route.py

@@ -0,0 +1,25 @@
+from typing import Dict, List
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
+
+class Route:
+    def __init__(self, relay_public_key: X25519PublicKey, bucket_size: int = 16):
+        self.relay_public_key_bytes = relay_public_key.public_bytes(encoding=Encoding.Raw, format=PublicFormat.Raw)
+        self.bucket_size = bucket_size
+        self.buckets: Dict[int, List[X25519PublicKey]] = {
+            i: [] for i in range(len(self.relay_public_key_bytes) * 8)
+        }
+        self.peers = {}
+
+    @staticmethod
+    def _matching_leading_bits(a: bytes, b: bytes) -> int:
+        for byte_index, (ba, bb) in enumerate(zip(a, b)):
+            diff = ba ^ bb
+            if diff:
+                return byte_index * 8 + (8 - diff.bit_length())
+        return len(a) * 8
+
+    def add_peer(self, peer_public_key: X25519PublicKey):
+        peer_public_key_bytes = peer_public_key.public_bytes(encoding=Encoding.Raw, format=PublicFormat.Raw)
+        bucket_idx = self._matching_leading_bits(self.relay_public_key_bytes, peer_public_key_bytes)
+        if len(self.buckets[bucket_idx]) < self.bucket_size:
+            self.buckets[bucket_idx].append(peer_public_key)  

astreum-0.2.29/src/astreum/relay/setup.py

@@ -0,0 +1,58 @@
+import socket, threading
+from queue import Queue
+from typing import Tuple, Optional
+from cryptography.hazmat.primitives.asymmetric import ed25519
+from cryptography.hazmat.primitives.asymmetric.x25519 import (
+    X25519PrivateKey,
+    X25519PublicKey,
+)
+from yourproject.routes import Route
+
+def load_x25519(hex_key: Optional[str]) -> X25519PrivateKey:
+    """DH key for relaying (always X25519)."""
+    return 
+
+def load_ed25519(hex_key: Optional[str]) -> Optional[ed25519.Ed25519PrivateKey]:
+    """Signing key for validation (Ed25519), or None if absent."""
+    return ed25519.Ed25519PrivateKey.from_private_bytes(bytes.fromhex(hex_key)) \
+           if hex_key else None
+
+def make_routes(
+    relay_pk: X25519PublicKey,
+    val_sk: Optional[ed25519.Ed25519PrivateKey]
+) -> Tuple[Route, Optional[Route]]:
+    """Peer route (DH pubkey) + optional validation route (ed pubkey)."""
+    peer_rt = Route(relay_pk)
+    val_rt  = Route(val_sk.public_key()) if val_sk else None
+    return peer_rt, val_rt
+
+def setup_udp(
+    bind_port: int,
+    use_ipv6: bool
+) -> Tuple[socket.socket, int, Queue, threading.Thread, threading.Thread]:
+    fam  = socket.AF_INET6 if use_ipv6 else socket.AF_INET
+    sock = socket.socket(fam, socket.SOCK_DGRAM)
+    if use_ipv6:
+        sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
+    sock.bind(("::" if use_ipv6 else "0.0.0.0", bind_port or 0))
+    port = sock.getsockname()[1]
+
+    q    = Queue()
+    pop  = threading.Thread(target=lambda: None, daemon=True)
+    proc = threading.Thread(target=lambda: None, daemon=True)
+    pop.start(); proc.start()
+    return sock, port, q, pop, proc
+
+def setup_outgoing(
+    use_ipv6: bool
+) -> Tuple[socket.socket, Queue, threading.Thread]:
+    fam  = socket.AF_INET6 if use_ipv6 else socket.AF_INET
+    sock = socket.socket(fam, socket.SOCK_DGRAM)
+    q    = Queue()
+    thr  = threading.Thread(target=lambda: None, daemon=True)
+    thr.start()
+    return sock, q, thr
+
+def make_maps():
+    """Empty lookup maps: peers and addresses."""
+    return 

astreum-0.2.29/src/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-0.2.29/src/astreum/storage/setup.py

@@ -0,0 +1,15 @@
+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.27 → astreum-0.2.29/src/astreum.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.27
+Version: 0.2.29
 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.27 → astreum-0.2.29}/src/astreum.egg-info/SOURCES.txt

@@ -15,6 +15,8 @@ src/astreum/crypto/quadratic_form.py
 src/astreum/crypto/wesolowski.py
 src/astreum/crypto/x25519.py
 src/astreum/lispeum/__init__.py
+src/astreum/lispeum/environment.py
+src/astreum/lispeum/expression.py
 src/astreum/lispeum/parser.py
 src/astreum/lispeum/tokenizer.py
 src/astreum/models/__init__.py
@@ -25,4 +27,11 @@ src/astreum/models/merkle.py
 src/astreum/models/message.py
 src/astreum/models/patricia.py
 src/astreum/models/transaction.py
+src/astreum/relay/__init__.py
+src/astreum/relay/peer.py
+src/astreum/relay/route.py
+src/astreum/relay/setup.py
+src/astreum/storage/__init__.py
+src/astreum/storage/object.py
+src/astreum/storage/setup.py
 tests/test_node_machine.py