astreum 0.2.28__tar.gz → 0.2.30__tar.gz

{astreum-0.2.28/src/astreum.egg-info → astreum-0.2.30}/PKG-INFO

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

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

{astreum-0.2.28 → astreum-0.2.30}/src/astreum/node.py

@@ -9,6 +9,9 @@ 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
 
@@ -21,39 +24,6 @@ import blake3
 import struct
 from .models.message import Message, MessageTopic
 
-
-
-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)
@@ -95,71 +65,45 @@ class Node:
         pass
 
     def _relay_setup(self, config: dict):
-        self.use_ipv6 = config.get('use_ipv6', False)
-        incoming_port = config.get('incoming_port', 7373)
-
-        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()
-
-        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.use_ipv6              = config.get('use_ipv6', False)
+
+        # key loading
+        self.relay_secret_key      = load_x25519(config.get('relay_secret_key'))
+        self.validation_secret_key = load_ed25519(config.get('validation_secret_key'))
+
+        # 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
+        )
+
+        # 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)
+
+        (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:
@@ -519,7 +463,7 @@ class Node:
                 elif first.value == "def":
                     args = expr.elements[1:]
                     if len(args) != 2:
-                        return Expr.Error(message=f"'def' expects exactly 2 arguments, got {len(args)}", origin=expr)
+                        return Expr.Error("def expects key value", origin=expr)
                     if not isinstance(args[0], Expr.Symbol):
                         return Expr.Error(message="first argument to 'def' must be a symbol", origin=args[0])
                     result = self.machine_expr_eval(env_id=env_id, expr=args[1])
@@ -529,140 +473,191 @@ class Node:
                     self.machine_expr_put(env_id=env_id, name=args[0].value, expr=result)
                     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,
-                #     )
-
-                # Integer arithmetic primitives
+                ## List: ints -> (1 2)
+                # push: (list.push 3 ints) -> (1 2 3) / (list.push 0 0 ints) -> (0 1 2)
+                elif first.value == "list.push":
+                    args = expr.elements[1:]
+                    if len(args) == 2:
+                        val_expr, list_expr = args
+                        idx = None
+                    elif len(args) == 3:
+                        idx_expr, val_expr, list_expr = args
+                        idx = self.machine_expr_eval(env_id, idx_expr)
+                        if isinstance(idx, Expr.Error): return idx
+                        if not isinstance(idx, Expr.IntExpr):
+                            return Expr.Error("index must be int", origin=idx_expr)
+                        idx = idx.value
+                    else:
+                        return Expr.Error("list.push expects (value list) or (index value list)", origin=expr)
+
+                    lst = self.machine_expr_eval(env_id, list_expr)
+                    if isinstance(lst, Expr.Error): return lst
+                    if not isinstance(lst, Expr.ListExpr):
+                        return Expr.Error("last arg to list.push must be a list", origin=list_expr)
+
+                    val = self.machine_expr_eval(env_id, val_expr)
+                    if isinstance(val, Expr.Error): return val
+
+                    elems = list(lst.elements)
+                    if idx is None:
+                        elems.append(val)
+                    else:
+                        if idx < 0 or idx > len(elems):
+                            return Expr.Error("index out of range", origin=idx_expr)
+                        elems.insert(idx, val)
+                    return Expr.ListExpr(elems)
+
+                # pop: (list.pop 1 ints) -> 2
+                elif first.value == "list.pop":
+                    if len(expr.elements) < 3:
+                        return Expr.Error("list.pop expects index list", origin=expr)
+
+                    idx_expr, list_expr = expr.elements[1], expr.elements[2]
+                    idx = self.machine_expr_eval(env_id, idx_expr)
+                    if isinstance(idx, Expr.Error): return idx
+                    if not isinstance(idx, Expr.IntExpr):
+                        return Expr.Error("index must be int", origin=idx_expr)
+                    idx = idx.value
+
+                    lst = self.machine_expr_eval(env_id, list_expr)
+                    if isinstance(lst, Expr.Error): return lst
+                    if not isinstance(lst, Expr.ListExpr):
+                        return Expr.Error("second arg to list.pop must be a list", origin=list_expr)
+
+                    elems = list(lst.elements)
+                    if idx < 0 or idx >= len(elems):
+                        return Expr.Error("index out of range", origin=idx_expr)
+                    del elems[idx]
+                    return Expr.ListExpr(elems)
+
+                # get: (list.get 1 ints) -> 2
+                elif first.value == "list.get":
+                    if len(expr.elements) < 3:
+                        return Expr.Error("list.get expects index list", origin=expr)
+
+                    idx_expr, list_expr = expr.elements[1], expr.elements[2]
+                    idx = self.machine_expr_eval(env_id, idx_expr)
+                    if isinstance(idx, Expr.Error): return idx
+                    if not isinstance(idx, Expr.IntExpr):
+                        return Expr.Error("index must be int", origin=idx_expr)
+                    idx = idx.value
+
+                    lst = self.machine_expr_eval(env_id, list_expr)
+                    if isinstance(lst, Expr.Error): return lst
+                    if not isinstance(lst, Expr.ListExpr):
+                        return Expr.Error("second arg to list.get must be a list", origin=list_expr)
+
+                    if idx < 0 or idx >= len(lst.elements):
+                        return Expr.Error("index out of range", origin=idx_expr)
+                    return lst.elements[idx]
+
+                # set: (list.set 1 3 ints) -> (1 3)
+                elif first.value == "list.set":
+                    if len(expr.elements) < 4:
+                        return Expr.Error("list.set expects index value list", origin=expr)
+                    idx_expr, val_expr, list_expr = expr.elements[1], expr.elements[2], expr.elements[3]
+                    idx = self.machine_expr_eval(env_id, idx_expr)
+                    if isinstance(idx, Expr.Error): return idx
+                    if not isinstance(idx, Expr.IntExpr):
+                        return Expr.Error("index must be int", origin=idx_expr)
+                    idx = idx.value
+
+                    val = self.machine_expr_eval(env_id, val_expr)
+                    if isinstance(val, Expr.Error): return val
+
+                    lst = self.machine_expr_eval(env_id, list_expr)
+                    if isinstance(lst, Expr.Error): return lst
+                    if not isinstance(lst, Expr.ListExpr):
+                        return Expr.Error("third arg to list.set must be a list", origin=list_expr)
+
+                    elems = list(lst.elements)
+                    if idx < 0 or idx >= len(elems):
+                        return Expr.Error("index out of range", origin=idx_expr)
+                    elems[idx] = val
+                    return Expr.ListExpr(elems)
+
+                ### each: (list.each fn list) -> ()
+                elif first.value == "list.each":
+                    if len(expr.elements) < 3:
+                        return Expr.Error("list.each expects fn list", origin=expr)
+                    fn_expr, list_expr = expr.elements[1], expr.elements[2]
+                    lst = self.machine_expr_eval(env_id, list_expr)
+                    if isinstance(lst, Expr.Error):
+                        return lst
+                    if not isinstance(lst, Expr.ListExpr):
+                        return Expr.Error("second arg to list.each must be a list", origin=list_expr)
+
+                    for el in lst.elements:
+                        res = self.machine_expr_eval(env_id, Expr.ListExpr([fn_expr, el]))
+                        if isinstance(res, Expr.Error):
+                            return res
+                    return Expr.ListExpr([])
+
+                ### fold: (list.fold fn init list) / (list.fold + 0 ints) -> 3
+                elif first.value == "list.fold":
+                    fn_expr, init_expr, list_expr = expr.elements[1], expr.elements[2], expr.elements[3]
+                    acc = self.machine_expr_eval(env_id, init_expr)
+                    if isinstance(acc, Expr.Error):
+                        return acc
+
+                    lst = self.machine_expr_eval(env_id, list_expr)
+                    if isinstance(lst, Expr.Error):
+                        return lst
+                    if not isinstance(lst, Expr.ListExpr):
+                        return Expr.Error("third arg to list.fold must be a list", origin=list_expr)
+
+                    for el in lst.elements:
+                        call = Expr.ListExpr([fn_expr, acc, el])
+                        res = self.machine_expr_eval(env_id, call)
+                        if isinstance(res, Expr.Error):
+                            return res
+                        acc = res
+
+                    return acc
+
+                ### sort: (list.sort fn list) / (list.sort (fn (a b) (a < b)) ints) -> (2 1)
+                elif first.value == "list.sort":
+                    if len(expr.elements) < 3:
+                        return Expr.Error("list.sort fn list", origin=expr)
+                    fn_e, lst_e = expr.elements[1], expr.elements[2]
+
+                    lst = self.machine_expr_eval(env_id, lst_e)
+                    if isinstance(lst, Expr.Error): return lst
+                    if not isinstance(lst, Expr.ListExpr):
+                        return Expr.Error("second arg must be list", origin=lst_e)
+
+                    elems = list(lst.elements)
+                    for i in range(1, len(elems)):
+                        j = i
+                        while j > 0:
+                            cmp_res = self.machine_expr_eval(
+                                env_id,
+                                Expr.ListExpr([fn_e, elems[j-1], elems[j]])
+                            )
+                            if isinstance(cmp_res, Expr.Error): return cmp_res
+                            if not isinstance(cmp_res, Expr.BoolExpr):
+                                return Expr.Error("comparator must return bool", origin=fn_e)
+
+                            if cmp_res.value:
+                                elems[j-1], elems[j] = elems[j], elems[j-1]
+                                j -= 1
+                            else:
+                                break
+                    return Expr.ListExpr(elems)
+
+                ### len: (list.len list) -> Int / (list.len ints) -> Integer(2)
+                elif first.value == "list.len":
+                    if len(expr.elements) < 2:
+                        return Expr.Error("list.len list", origin=expr)
+                    lst_e = expr.elements[1]
+                    lst = self.machine_expr_eval(env_id, lst_e)
+                    if isinstance(lst, Expr.Error): return lst
+                    if not isinstance(lst, Expr.ListExpr):
+                        return Expr.Error("arg must be list", origin=lst_e)
+                    return Expr.Integer(len(lst.elements))
+
+                ## Integer
+                ### add
                 elif first.value == "+":
                     args = expr.elements[1:]
                     if not args:
@@ -747,6 +742,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.30/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.30/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.30/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.28 → astreum-0.2.30}/src/astreum/storage/setup.py

@@ -1,8 +1,7 @@
 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]]:
+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, {}

{astreum-0.2.28 → astreum-0.2.30/src/astreum.egg-info}/PKG-INFO

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

@@ -27,6 +27,10 @@ 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