astreum 0.2.36__tar.gz → 0.2.37__tar.gz

{astreum-0.2.36/src/astreum.egg-info → astreum-0.2.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.36
+Version: 0.2.37
 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
@@ -79,7 +79,7 @@ The Lispeum virtual machine (VM) is embedded inside `astreum.Node`. You feed it
 # Define a named function int.add (stack body) and call it with bytes 1 and 2
 
 import uuid
-from astreum._node import Node, Env, Expr
+from astreum import Node, Env, Expr
 
 # 1) Spin‑up a stand‑alone VM
 node = Node()
@@ -139,6 +139,8 @@ except ParseError as e:
 ## Testing
 
 ```bash
+python3 -m venv venv
 source venv/bin/activate
+pip install -e .
 python3 -m unittest discover -s tests
 ```

{astreum-0.2.36 → astreum-0.2.37}/README.md

@@ -61,7 +61,7 @@ The Lispeum virtual machine (VM) is embedded inside `astreum.Node`. You feed it
 # Define a named function int.add (stack body) and call it with bytes 1 and 2
 
 import uuid
-from astreum._node import Node, Env, Expr
+from astreum import Node, Env, Expr
 
 # 1) Spin‑up a stand‑alone VM
 node = Node()
@@ -121,6 +121,8 @@ except ParseError as e:
 ## Testing
 
 ```bash
+python3 -m venv venv
 source venv/bin/activate
+pip install -e .
 python3 -m unittest discover -s tests
 ```

{astreum-0.2.36 → astreum-0.2.37}/pyproject.toml

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

astreum-0.2.37/src/astreum/__init__.py

@@ -0,0 +1,9 @@
+"""Lightweight package initializer to avoid circular imports during tests.
+
+Exports are intentionally minimal; import submodules directly as needed:
+ - Node, Expr, Env, tokenize, parse -> from astreum._node or astreum.lispeum
+ - Validation types -> from astreum._validation
+ - Storage types -> from astreum._storage
+"""
+
+__all__: list[str] = []

astreum-0.2.37/src/astreum/_communication/__init__.py

@@ -0,0 +1,9 @@
+from .peer import Peer
+from .route import Route
+from .setup import communication_setup
+
+__all__ = [
+    "Peer",
+    "Route",
+    "communication_setup",
+]

astreum-0.2.37/src/astreum/_communication/peer.py

@@ -0,0 +1,11 @@
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
+from datetime import datetime, timezone
+
+class Peer:
+    shared_key: bytes
+    timestamp: datetime
+    latest_block: bytes
+
+    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.37/src/astreum/_communication/setup.py

@@ -0,0 +1,104 @@
+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 typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from .. import Node
+
+from .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 
+
+def communication_setup(node: "Node", config: dict):
+    node.use_ipv6              = config.get('use_ipv6', False)
+
+    # key loading
+    node.relay_secret_key      = load_x25519(config.get('relay_secret_key'))
+    node.validation_secret_key = load_ed25519(config.get('validation_secret_key'))
+
+    # derive pubs + routes
+    node.relay_public_key      = node.relay_secret_key.public_key()
+    node.peer_route, node.validation_route = make_routes(
+        node.relay_public_key,
+        node.validation_secret_key
+    )
+
+    # sockets + queues + threads
+    (node.incoming_socket,
+        node.incoming_port,
+        node.incoming_queue,
+        node.incoming_populate_thread,
+        node.incoming_process_thread
+    ) = setup_udp(config.get('incoming_port', 7373), node.use_ipv6)
+
+    (node.outgoing_socket,
+        node.outgoing_queue,
+        node.outgoing_thread
+    ) = setup_outgoing(node.use_ipv6)
+
+    # other workers & maps
+    node.object_request_queue = Queue()
+    node.peer_manager_thread  = threading.Thread(
+        target=node._relay_peer_manager,
+        daemon=True
+    )
+    node.peer_manager_thread.start()
+
+    node.peers, node.addresses = {}, {} # peers: Dict[X25519PublicKey,Peer], addresses: Dict[(str,int),X25519PublicKey]
+
+    # bootstrap pings
+    for addr in config.get('bootstrap', []):
+        node._send_ping(addr)

{astreum-0.2.36 → astreum-0.2.37}/src/astreum/_lispeum/__init__.py

@@ -2,7 +2,7 @@ from .expression import Expr
 from .environment import Env
 from .low_evaluation import low_eval
 from .meter import Meter
-from .parser import parse
+from .parser import parse, ParseError
 from .tokenizer import tokenize
 
 __all__ = [
@@ -11,6 +11,6 @@ __all__ = [
     "low_eval",
     "Meter",
     "parse",
-    "tokenize"
+    "tokenize",
+    "ParseError",
 ]
-

{astreum-0.2.36 → astreum-0.2.37}/src/astreum/_lispeum/environment.py

@@ -1,10 +1,13 @@
 from ast import Expr
 from typing import Dict, Optional
+import uuid
 
 
 class Env:
     def __init__(
         self,
-        data: Optional[Dict[str, Expr]] = None
+        data: Optional[Dict[str, Expr]] = None,
+        parent_id: Optional[uuid.UUID] = None,
     ):
-        self.data: Dict[bytes, Expr] = {} if data is None else data
+        self.data: Dict[bytes, Expr] = {} if data is None else data
+        self.parent_id = parent_id

{astreum-0.2.36 → astreum-0.2.37}/src/astreum/_lispeum/expression.py

@@ -10,21 +10,21 @@ class Expr:
             if not self.elements:
                 return "()"
             inner = " ".join(str(e) for e in self.elements)
-            return f"({inner})"
+            return f"({inner} list)"
         
     class Symbol:
         def __init__(self, value: str):
             self.value = value
 
         def __repr__(self):
-            return self.value
+            return f"({self.value} symbol)"
         
-    class Byte:
-        def __init__(self, value: int):
+    class Bytes:
+        def __init__(self, value: bytes):
             self.value = value
 
         def __repr__(self):
-            return self.value
+            return f"({self.value} bytes)"
         
     class Error:
         def __init__(self, topic: str, origin: Optional['Expr'] = None):
@@ -33,5 +33,5 @@ class Expr:
 
         def __repr__(self):
             if self.origin is None:
-                return f'({self.topic} err)'
-            return f'({self.origin} {self.topic} err)'
+                return f'({self.topic} error)'
+            return f'({self.origin} {self.topic} error)'

{astreum-0.2.36 → astreum-0.2.37}/src/astreum/_lispeum/high_evaluation.py

@@ -1,7 +1,9 @@
-from typing import List, Union
-import uuid
-
-from src.astreum._lispeum import Env, Expr, Meter
+from typing import List, Union
+import uuid
+
+from .environment import Env
+from .expression import Expr
+from .meter import Meter
 
 
 def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
@@ -125,9 +127,7 @@ def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
 
                 # Execute low-level code built from sk-body using the caller's meter
                 res = self.low_eval(code, meter=meter)
-                if isinstance(res, Expr.Error):
-                    return res
-                return Expr.ListExpr([Expr.Byte(b) for b in res])
+                return res
 
         # ---------- (... (body params fn))  HIGH-LEVEL CALL ----------
         if isinstance(tail, Expr.ListExpr):
@@ -174,4 +174,4 @@ def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
 
         # ---------- default: resolve each element and return list ----------
         resolved: List[Expr] = [self.high_eval(env_id, e, meter=meter) for e in expr.elements]
-        return Expr.ListExpr(resolved)
+        return Expr.ListExpr(resolved)

{astreum-0.2.36 → astreum-0.2.37}/src/astreum/_lispeum/low_evaluation.py

@@ -1,5 +1,6 @@
-from typing import Dict, List, Union
-from src.astreum._lispeum import Expr, Meter
+from typing import Dict, List, Union
+from .expression import Expr
+from .meter import Meter
 
 def tc_to_int(b: bytes) -> int:
     """bytes -> int using two's complement (width = len(b)*8)."""
@@ -34,18 +35,19 @@ def nand_bytes(a: bytes, b: bytes) -> bytes:
     resu = (~(au & bu)) & mask
     return resu.to_bytes(w, "big", signed=False)
 
-def low_eval(self, code: List[bytes], meter: Meter) -> Union[bytes, Expr.Error]:
+def low_eval(self, code: List[bytes], meter: Meter) -> Expr:
         
         heap: Dict[bytes, bytes] = {}
 
         stack: List[bytes] = []
         pc = 0
 
-        while True:
-            if pc >= len(code):
-                if len(stack) != 1:
-                    return Expr.Error("bad stack")
-                return stack.pop()
+        while True:
+            if pc >= len(code):
+                if len(stack) != 1:
+                    return Expr.Error("bad stack")
+                # wrap successful result as an Expr.Bytes
+                return Expr.Bytes(stack.pop())
 
             tok = code[pc]
             pc += 1

{astreum-0.2.36 → astreum-0.2.37}/src/astreum/_lispeum/parser.py

@@ -1,5 +1,5 @@
-from typing import List, Tuple
-from src.astreum._lispeum import Expr
+from typing import List, Tuple
+from src.astreum._lispeum import Expr
 
 class ParseError(Exception):
     pass
@@ -27,14 +27,30 @@ def _parse_one(tokens: List[str], pos: int = 0) -> Tuple[Expr, int]:
     if tok == ')':
         raise ParseError("unexpected ')'")
 
-    # try integer → Byte
-    try:
-        n = int(tok)
-        return Expr.Byte(n), pos + 1
-    except ValueError:
-        return Expr.Symbol(tok), pos + 1
+    # try integer → Bytes (variable-length two's complement)
+    try:
+        n = int(tok)
+        # encode as minimal-width signed two's complement, big-endian
+        def int_to_min_tc(v: int) -> bytes:
+            """Return the minimal-width signed two's complement big-endian
+            byte encoding of integer v. Width expands just enough so that
+            decoding with signed=True yields the same value and sign.
+            Example: 0 -> b"\x00", 127 -> b"\x7f", 128 -> b"\x00\x80".
+            """
+            if v == 0:
+                return b"\x00"
+            w = 1
+            while True:
+                try:
+                    return v.to_bytes(w, "big", signed=True)
+                except OverflowError:
+                    w += 1
+
+        return Expr.Bytes(int_to_min_tc(n)), pos + 1
+    except ValueError:
+        return Expr.Symbol(tok), pos + 1
 
 def parse(tokens: List[str]) -> Tuple[Expr, List[str]]:
     """Parse tokens into an Expr and return (expr, remaining_tokens)."""
     expr, next_pos = _parse_one(tokens, 0)
-    return expr, tokens[next_pos:]
+    return expr, tokens[next_pos:]

astreum-0.2.37/src/astreum/_node.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+from typing import Dict, Optional
+import uuid
+import threading
+
+from src.astreum._storage.atom import Atom
+from src.astreum._lispeum import Env, Expr, low_eval, parse, tokenize, ParseError
+
+def bytes_touched(*vals: bytes) -> int:
+    """For metering: how many bytes were manipulated (max of operands)."""
+    return max((len(v) for v in vals), default=1)
+
+class Node:
+    def __init__(self, config: dict):
+        # Storage Setup
+        self.in_memory_storage: Dict[bytes, Atom] = {}
+        self.in_memory_storage_lock = threading.RLock()
+        # Lispeum Setup
+        self.environments: Dict[uuid.UUID, Env] = {}
+        self.machine_environments_lock = threading.RLock()
+        self.low_eval = low_eval
+        # Communication and Validation Setup (import lazily to avoid heavy deps during parsing tests)
+        try:
+            from astreum._communication import communication_setup  # type: ignore
+            communication_setup(node=self, config=config)
+        except Exception:
+            pass
+        try:
+            from astreum._validation import validation_setup  # type: ignore
+            validation_setup(node=self)
+        except Exception:
+            pass
+
+    # ---- Env helpers ----
+    def env_get(self, env_id: uuid.UUID, key: bytes) -> Optional[Expr]:
+        cur = self.environments.get(env_id)
+        while cur is not None:
+            if key in cur.data:
+                return cur.data[key]
+            cur = self.environments.get(cur.parent_id) if cur.parent_id else None
+        return None
+
+    def env_set(self, env_id: uuid.UUID, key: bytes, value: Expr) -> bool:
+        with self.machine_environments_lock:
+            env = self.environments.get(env_id)
+            if env is None:
+                return False
+            env.data[key] = value
+            return True
+
+    # Storage
+    def _local_get(self, key: bytes) -> Optional[Atom]:
+        with self.in_memory_storage_lock:
+            return self.in_memory_storage.get(key)
+
+    def _local_set(self, key: bytes, value: Atom) -> None:
+        with self.in_memory_storage_lock:
+            self.in_memory_storage[key] = value

astreum-0.2.37/src/astreum/_storage/__init__.py

@@ -0,0 +1,5 @@
+from .atom import Atom
+
+__all__ = [
+    "Atom",
+]

astreum-0.2.36/src/astreum/_node.py → astreum-0.2.37/src/astreum/_storage/atom.py

@@ -1,14 +1,8 @@
-from __future__ import annotations
-from typing import Dict, List, Optional, Tuple, Union
-import uuid
-import threading
 
-from src.astreum._lispeum import Env, Expr, Meter, low_eval
 
-def bytes_touched(*vals: bytes) -> int:
-    """For metering: how many bytes were manipulated (max of operands)."""
-    return max((len(v) for v in vals), default=1)
+from typing import List, Optional, Tuple
 
+from .._lispeum.expression import Expr
 from blake3 import blake3
 
 ZERO32 = b"\x00"*32
@@ -48,8 +42,6 @@ class Atom:
         return object_id == blake3(data_hash + next_hash + u64_le(size)).digest()
 
     def to_bytes(self) -> bytes:
-        if len(self.next) != len(ZERO32):
-            raise ValueError("next must be 32 bytes")
         return self.next + self.data
 
     @staticmethod
@@ -60,29 +52,23 @@ class Atom:
         data = buf[len(ZERO32):]
         return Atom(data=data, next=next_hash, size=len(data))
 
-def u32_le(n: int) -> bytes:
-    return int(n).to_bytes(4, "little", signed=False)
-
 def expr_to_atoms(e: Expr) -> Tuple[bytes, List[Atom]]:
-    def sym(v: str) -> Tuple[bytes, List[Atom]]:
-        val = v.encode("utf-8")
-        val_atom = Atom.from_data(u32_le(len(val)) + val)
+    def symbol(value: str) -> Tuple[bytes, List[Atom]]:
+        val = value.encode("utf-8")
+        val_atom = Atom.from_data(data=val)
         typ_atom = Atom.from_data(b"symbol", val_atom.object_id())
         return typ_atom.object_id(), [val_atom, typ_atom]
 
-    def byt(v: int) -> Tuple[bytes, List[Atom]]:
-        val_atom = Atom.from_data(bytes([v & 0xFF]))
+    def bytes(data: bytes) -> Tuple[bytes, List[Atom]]:
+        val_atom = Atom.from_data(data=data)
         typ_atom = Atom.from_data(b"byte", val_atom.object_id())
         return typ_atom.object_id(), [val_atom, typ_atom]
 
     def err(topic: str, origin: Optional[Expr]) -> Tuple[bytes, List[Atom]]:
-        t = topic.encode("utf-8")
-        origin_hash, acc = (ZERO32, [])
-        if origin is not None:
-            origin_hash, acc = expr_to_atoms(origin)
-        val_atom = Atom.from_data(u32_le(len(t)) + t + origin_hash)
-        typ_atom = Atom.from_data(b"error", val_atom.object_id())
-        return typ_atom.object_id(), acc + [val_atom, typ_atom]
+        topic_bytes = topic.encode("utf-8")
+        topic_atom = Atom.from_data(data=topic_bytes)
+        typ_atom = Atom.from_data(data=b"error", next_hash=topic_atom.object_id())
+        return typ_atom.object_id(), [topic_atom, typ_atom]
 
     def lst(items: List[Expr]) -> Tuple[bytes, List[Atom]]:
         acc: List[Atom] = []
@@ -99,49 +85,16 @@ def expr_to_atoms(e: Expr) -> Tuple[bytes, List[Atom]]:
             elem_atoms.append(a)
         elem_atoms.reverse()
         head = next_hash
-        val_atom = Atom.from_data(u64_le(len(items)), head)
-        typ_atom = Atom.from_data(b"list", val_atom.object_id())
+        val_atom = Atom.from_data(data=u64_le(len(items)), next_hash=head)
+        typ_atom = Atom.from_data(data=b"list", next_hash=val_atom.object_id())
         return typ_atom.object_id(), acc + elem_atoms + [val_atom, typ_atom]
 
     if isinstance(e, Expr.Symbol):
-        return sym(e.value)
-    if isinstance(e, Expr.Byte):
-        return byt(e.value)
+        return symbol(e.value)
+    if isinstance(e, Expr.Bytes):
+        return bytes(e.value)
     if isinstance(e, Expr.Error):
         return err(e.topic, e.origin)
     if isinstance(e, Expr.ListExpr):
         return lst(e.elements)
-    raise TypeError("unknown Expr variant")
-
-class Node:
-    def __init__(self):
-        # Storage Setup
-        self.in_memory_storage: Dict[bytes, bytes] = {}
-        # Lispeum Setup
-        self.environments: Dict[uuid.UUID, Env] = {}
-        self.machine_environments_lock = threading.RLock()
-        self.low_eval = low_eval
-
-    # ---- Env helpers ----
-    def env_get(self, env_id: uuid.UUID, key: bytes) -> Optional[Expr]:
-        cur = self.environments.get(env_id)
-        while cur is not None:
-            if key in cur.data:
-                return cur.data[key]
-            cur = self.environments.get(cur.parent_id) if cur.parent_id else None
-        return None
-
-    def env_set(self, env_id: uuid.UUID, key: bytes, value: Expr) -> bool:
-        with self.machine_environments_lock:
-            env = self.environments.get(env_id)
-            if env is None:
-                return False
-            env.data[key] = value
-            return True
-
-    # ---- Storage (persistent) ----
-    def _local_get(self, key: bytes) -> Optional[bytes]:
-        return self.in_memory_storage.get(key)
-
-    def _local_set(self, key: bytes, value: bytes) -> None:
-        self.in_memory_storage[key] = value
+    raise TypeError("unknown Expr variant")

astreum-0.2.37/src/astreum/_validation/__init__.py

@@ -0,0 +1,12 @@
+from .block import Block
+from .chain import Chain
+from .fork import Fork
+from .setup import validation_setup
+
+
+__all__ = [
+    "Block",
+    "Chain",
+    "Fork",
+    "validation_setup",
+]