astreum 0.3.5__tar.gz → 0.3.14__tar.gz

{astreum-0.3.5/src/astreum.egg-info → astreum-0.3.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.3.5
+Version: 0.3.14
 Summary: Python library to interact with the Astreum blockchain and its virtual machine.
 Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
 Project-URL: Homepage, https://github.com/astreum/lib-py
@@ -113,11 +113,11 @@ node.env_set(env_id, "int.add", int_add_fn)
 
 # 5) Retrieve the function and call it with bytes 1 and 2
 bound = node.env_get(env_id, "int.add")
-call = Expr.ListExpr([Expr.Byte(1), Expr.Byte(2), bound])
+call = Expr.ListExpr([Expr.Bytes(b"\x01"), Expr.Bytes(b"\x02"), bound])
 res  = node.high_eval(env_id, call)
 
 # sk returns a list of bytes; for 1+2 expect a single byte with value 3
-print([b.value for b in res.elements])  # [3]
+print([int.from_bytes(b.value, 'big', signed=True) for b in res.elements])  # [3]
 ```
 
 ### Handling errors

{astreum-0.3.5 → astreum-0.3.14}/README.md

@@ -90,16 +90,16 @@ fn_body = Expr.ListExpr([
 params = Expr.ListExpr([Expr.Symbol("a"), Expr.Symbol("b")])
 int_add_fn = Expr.ListExpr([fn_body, params, Expr.Symbol("fn")])
 
-# 4) Store under the name "int.add"
-node.env_set(env_id, "int.add", int_add_fn)
-
-# 5) Retrieve the function and call it with bytes 1 and 2
-bound = node.env_get(env_id, "int.add")
-call = Expr.ListExpr([Expr.Byte(1), Expr.Byte(2), bound])
+# 4) Store under the name "int.add"
+node.env_set(env_id, "int.add", int_add_fn)
+
+# 5) Retrieve the function and call it with bytes 1 and 2
+bound = node.env_get(env_id, "int.add")
+call = Expr.ListExpr([Expr.Bytes(b"\x01"), Expr.Bytes(b"\x02"), bound])
 res  = node.high_eval(env_id, call)
 
 # sk returns a list of bytes; for 1+2 expect a single byte with value 3
-print([b.value for b in res.elements])  # [3]
+print([int.from_bytes(b.value, 'big', signed=True) for b in res.elements])  # [3]
 ```
 
 ### Handling errors

{astreum-0.3.5 → astreum-0.3.14}/pyproject.toml

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

{astreum-0.3.5 → astreum-0.3.14}/src/astreum/__init__.py

@@ -1,6 +1,6 @@
-
+
 from astreum.consensus import Account, Accounts, Block, Chain, Fork, Receipt, Transaction
-from astreum.machine import Env, Expr
+from astreum.machine import Env, Expr, parse, tokenize
 from astreum.node import Node
 
 
@@ -15,4 +15,6 @@ __all__: list[str] = [
     "Transaction",
     "Account",
     "Accounts",
+    "parse",
+    "tokenize",
 ]

astreum-0.3.14/src/astreum/communication/handlers/handshake.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Sequence
+
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PublicKey
+
+from ..models.peer import Peer
+from ..models.message import Message
+
+if TYPE_CHECKING:
+    from .... import Node
+
+
+def handle_handshake(node: "Node", addr: Sequence[object], message: Message) -> bool:
+    """Handle incoming handshake messages.
+
+    Returns True if the outer loop should `continue`, False otherwise.
+    """
+    sender_public_key_bytes = message.sender_bytes
+    try:
+        sender_key = X25519PublicKey.from_public_bytes(sender_public_key_bytes)
+    except Exception as exc:
+        node.logger.warning("Error extracting sender key bytes: %s", exc)
+        return True
+
+    try:
+        host = addr[0]
+        port = int.from_bytes(message.content[:2], "big", signed=False)
+    except Exception:
+        return True
+    peer_address = (host, port)
+
+    existing_peer = node.get_peer(sender_public_key_bytes)
+    if existing_peer is not None:
+        existing_peer.address = peer_address
+        return False
+
+    try:
+        peer = Peer(
+            node_secret_key=node.relay_secret_key,
+            peer_public_key=sender_key,
+            address=peer_address,
+        )
+    except Exception:
+        return True
+
+    node.add_peer(sender_public_key_bytes, peer)
+    node.peer_route.add_peer(sender_public_key_bytes, peer)
+
+    node.logger.info(
+        "Handshake accepted from %s:%s; peer added",
+        peer_address[0],
+        peer_address[1],
+    )
+    response = Message(
+        handshake=True,
+        sender=node.relay_public_key,
+        content=int(node.config["incoming_port"]).to_bytes(2, "big", signed=False),
+    )
+    node.outgoing_queue.put((response.to_bytes(), peer_address))
+    return True

{astreum-0.3.5 → astreum-0.3.14}/src/astreum/communication/handlers/object_request.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Tuple
 
 from .object_response import ObjectResponse, ObjectResponseType
 from ..models.message import Message, MessageTopic
+from ..util import xor_distance
 
 if TYPE_CHECKING:
     from .. import Node
@@ -27,7 +28,7 @@ class ObjectRequest:
         self.atom_id = atom_id
 
     def to_bytes(self):
-        return [self.type.value] + self.atom_id + self.data
+        return bytes([self.type.value]) + self.atom_id + self.data
 
     @classmethod
     def from_bytes(cls, data: bytes) -> "ObjectRequest":
@@ -48,8 +49,6 @@ class ObjectRequest:
 
 def encode_peer_contact_bytes(peer: "Peer") -> bytes:
     """Return a fixed-width peer contact payload (32-byte key + IPv4 + port)."""
-    if not peer.address:
-        raise ValueError("peer address is required for encoding peer info")
     host, port = peer.address
     key_bytes = peer.public_key_bytes
     try:
@@ -62,22 +61,25 @@ def encode_peer_contact_bytes(peer: "Peer") -> bytes:
     return key_bytes + ip_bytes + port_bytes
 
 
-def handle_object_request(node: "Node", addr: Tuple[str, int], message: Message) -> None:
-    node_logger = getattr(node, "logger", logging.getLogger(__name__))
+def handle_object_request(node: "Node", peer: "Peer", message: Message) -> None:
+    if message.content is None:
+        node.logger.warning("OBJECT_REQUEST from %s missing content", peer.address)
+        return
+
     try:
-        object_request = ObjectRequest.from_bytes(message.body)
+        object_request = ObjectRequest.from_bytes(message.content)
     except Exception as exc:
-        node_logger.warning("Error decoding OBJECT_REQUEST from %s: %s", addr, exc)
+        node.logger.warning("Error decoding OBJECT_REQUEST from %s: %s", peer.address, exc)
         return
 
     match object_request.type:
         case ObjectRequestType.OBJECT_GET:
             atom_id = object_request.atom_id
-            node_logger.debug("Handling OBJECT_GET for %s from %s", atom_id.hex(), addr)
+            node.logger.debug("Handling OBJECT_GET for %s from %s", atom_id.hex(), peer.address)
 
             local_atom = node.local_get(atom_id)
             if local_atom is not None:
-                node_logger.debug("Object %s found locally; returning to %s", atom_id.hex(), addr)
+                node.logger.debug("Object %s found locally; returning to %s", atom_id.hex(), peer.address)
                 resp = ObjectResponse(
                     type=ObjectResponseType.OBJECT_FOUND,
                     data=local_atom.to_bytes(),
@@ -88,13 +90,13 @@ def handle_object_request(node: "Node", addr: Tuple[str, int], message: Message)
                     body=resp.to_bytes(),
                     sender=node.relay_public_key,
                 )
-                node.outgoing_queue.put((obj_res_msg.to_bytes(), addr))
+                obj_res_msg.encrypt(peer.shared_key_bytes)
+                node.outgoing_queue.put((obj_res_msg.to_bytes(), peer.address))
                 return
 
-            storage_index = getattr(node, "storage_index", None) or {}
-            if atom_id in storage_index:
-                node_logger.debug("Known provider for %s; informing %s", atom_id.hex(), addr)
-                provider_bytes = storage_index[atom_id]
+            if atom_id in node.storage_index:
+                node.logger.debug("Known provider for %s; informing %s", atom_id.hex(), peer.address)
+                provider_bytes = node.storage_index[atom_id]
                 resp = ObjectResponse(
                     type=ObjectResponseType.OBJECT_PROVIDER,
                     data=provider_bytes,
@@ -105,12 +107,13 @@ def handle_object_request(node: "Node", addr: Tuple[str, int], message: Message)
                     body=resp.to_bytes(),
                     sender=node.relay_public_key,
                 )
-                node.outgoing_queue.put((obj_res_msg.to_bytes(), addr))
+                obj_res_msg.encrypt(peer.shared_key_bytes)
+                node.outgoing_queue.put((obj_res_msg.to_bytes(), peer.address))
                 return
 
             nearest_peer = node.peer_route.closest_peer_for_hash(atom_id)
             if nearest_peer:
-                node_logger.debug("Forwarding requester %s to nearest peer for %s", addr, atom_id.hex())
+                node.logger.debug("Forwarding requester %s to nearest peer for %s", peer.address, atom_id.hex())
                 peer_info = encode_peer_contact_bytes(nearest_peer)
                 resp = ObjectResponse(
                     type=ObjectResponseType.OBJECT_PROVIDER,
@@ -123,31 +126,51 @@ def handle_object_request(node: "Node", addr: Tuple[str, int], message: Message)
                     body=resp.to_bytes(),
                     sender=node.relay_public_key,
                 )
-                node.outgoing_queue.put((obj_res_msg.to_bytes(), addr))
+                obj_res_msg.encrypt(nearest_peer.shared_key_bytes)
+                node.outgoing_queue.put((obj_res_msg.to_bytes(), peer.address))
 
         case ObjectRequestType.OBJECT_PUT:
-            atom_hash = object_request.data[:32]
-            node_logger.debug("Handling OBJECT_PUT for %s from %s", atom_hash.hex(), addr)
+            node.logger.debug("Handling OBJECT_PUT for %s from %s", object_request.atom_id.hex(), peer.address)
 
-            nearest_peer = node.peer_route.closest_peer_for_hash(atom_hash)
-            nearest = (nearest_peer.public_key, nearest_peer) if nearest_peer else None
-            if nearest:
-                node_logger.debug("Forwarding OBJECT_PUT for %s to nearer peer %s", atom_hash.hex(), nearest[1].address)
+            nearest_peer = node.peer_route.closest_peer_for_hash(object_request.atom_id)
+            is_self_closest = False
+            if nearest_peer is None or nearest_peer.address is None:
+                is_self_closest = True
+            else:
+                try:
+                    self_distance = xor_distance(object_request.atom_id, node.relay_public_key_bytes)
+                    peer_distance = xor_distance(object_request.atom_id, nearest_peer.public_key_bytes)
+                except Exception as exc:
+                    node.logger.warning(
+                        "Failed distance comparison for OBJECT_PUT %s: %s",
+                        object_request.atom_id.hex(),
+                        exc,
+                    )
+                    is_self_closest = True
+                else:
+                    is_self_closest = self_distance <= peer_distance
+
+            if is_self_closest:
+                node.logger.debug("Storing provider info for %s locally", object_request.atom_id.hex())
+                node.storage_index[object_request.atom_id] = object_request.data
+            else:
+                node.logger.debug(
+                    "Forwarding OBJECT_PUT for %s to nearer peer %s",
+                    object_request.atom_id.hex(),
+                    nearest_peer.address,
+                )
                 fwd_req = ObjectRequest(
                     type=ObjectRequestType.OBJECT_PUT,
                     data=object_request.data,
+                    atom_id=object_request.atom_id,
                 )
                 obj_req_msg = Message(
                     topic=MessageTopic.OBJECT_REQUEST,
                     body=fwd_req.to_bytes(),
                     sender=node.relay_public_key,
                 )
-                node.outgoing_queue.put((obj_req_msg.to_bytes(), nearest[1].address))
-            else:
-                node_logger.debug("Storing provider info for %s locally", atom_hash.hex())
-                if not hasattr(node, "storage_index") or not isinstance(node.storage_index, dict):
-                    node.storage_index = {}
-                node.storage_index[atom_hash] = object_request.data[32:]
+                obj_req_msg.encrypt(nearest_peer.shared_key_bytes)
+                node.outgoing_queue.put((obj_req_msg.to_bytes(), nearest_peer.address))
 
         case _:
-            node_logger.warning("Unknown ObjectRequestType %s from %s", object_request.type, addr)
+            node.logger.warning("Unknown ObjectRequestType %s from %s", object_request.type, peer.address)

astreum-0.3.14/src/astreum/communication/handlers/object_response.py

@@ -0,0 +1,115 @@
+import socket
+from enum import IntEnum
+from typing import Tuple, TYPE_CHECKING
+
+from ..models.message import Message, MessageTopic
+from ...storage.models.atom import Atom
+
+if TYPE_CHECKING:
+    from .. import Node
+    from ..models.peer import Peer
+
+
+class ObjectResponseType(IntEnum):
+    OBJECT_FOUND = 0
+    OBJECT_PROVIDER = 1
+    OBJECT_NEAREST_PEER = 2
+
+
+class ObjectResponse:
+    type: ObjectResponseType
+    data: bytes
+    atom_id: bytes
+
+    def __init__(self, type: ObjectResponseType, data: bytes, atom_id: bytes = None):
+        self.type = type
+        self.data = data
+        self.atom_id = atom_id
+
+    def to_bytes(self):
+        return bytes([self.type.value]) + self.atom_id + self.data
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> "ObjectResponse":
+        # need at least 1 byte for type + 32 bytes for atom id
+        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}")
+
+        atom_id = data[1:33]
+        payload   = data[33:]
+        return cls(resp_type, payload, atom_id)
+
+
+def decode_object_provider(payload: bytes) -> Tuple[bytes, str, int]:
+    expected_len = 32 + 4 + 2
+    if len(payload) < expected_len:
+        raise ValueError("provider payload too short")
+
+    provider_public_key = payload[:32]
+    provider_ip_bytes = payload[32:36]
+    provider_port_bytes = payload[36:38]
+
+    provider_address = socket.inet_ntoa(provider_ip_bytes)
+    provider_port = int.from_bytes(provider_port_bytes, byteorder="big", signed=False)
+    return provider_public_key, provider_address, provider_port
+
+
+def handle_object_response(node: "Node", peer: "Peer", message: Message) -> None:
+    if message.content is None:
+        node.logger.warning("OBJECT_RESPONSE from %s missing content", peer.address)
+        return
+
+    try:
+        object_response = ObjectResponse.from_bytes(message.content)
+    except Exception as exc:
+        node.logger.warning("Error decoding OBJECT_RESPONSE from %s: %s", peer.address, exc)
+        return
+
+    if not node.has_atom_req(object_response.atom_id):
+        return
+
+    match object_response.type:
+        case ObjectResponseType.OBJECT_FOUND:
+            atom = Atom.from_bytes(object_response.data)
+            atom_id = atom.object_id()
+            if object_response.atom_id == atom_id:
+                node.pop_atom_req(atom_id)
+                node._hot_storage_set(atom_id, atom)
+            else:
+                node.logger.warning(
+                    "OBJECT_FOUND atom ID mismatch (expected=%s got=%s)",
+                    object_response.atom_id.hex(),
+                    atom_id.hex(),
+                )
+
+        case ObjectResponseType.OBJECT_PROVIDER:
+            try:
+                _, provider_address, provider_port = decode_object_provider(object_response.data)
+            except Exception as exc:
+                node.logger.warning("Invalid OBJECT_PROVIDER payload from %s: %s", peer.address, exc)
+                return
+
+            from .object_request import ObjectRequest, ObjectRequestType
+
+            obj_req = ObjectRequest(
+                type=ObjectRequestType.OBJECT_GET,
+                data=b"",
+                atom_id=object_response.atom_id,
+            )
+            obj_req_bytes = obj_req.to_bytes()
+            obj_req_msg = Message(
+                topic=MessageTopic.OBJECT_REQUEST,
+                body=obj_req_bytes,
+                sender=node.relay_public_key,
+            )
+            obj_req_msg.encrypt(peer.shared_key_bytes)
+            node.outgoing_queue.put((obj_req_msg.to_bytes(), (provider_address, provider_port)))
+
+        case ObjectResponseType.OBJECT_NEAREST_PEER:
+            node.logger.debug("Ignoring OBJECT_NEAREST_PEER response from %s", peer.address)

astreum-0.3.14/src/astreum/communication/handlers/ping.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING
+
+from ..models.ping import Ping
+from ..models.peer import Peer
+
+if TYPE_CHECKING:
+    from .... import Node
+
+
+def handle_ping(node: "Node", peer: Peer, payload: bytes) -> None:
+    """Update peer and validation state based on an incoming ping message."""
+    try:
+        ping = Ping.from_bytes(payload)
+    except Exception as exc:
+        node.logger.warning("Error decoding ping: %s", exc)
+        return
+
+    peer.timestamp = datetime.now(timezone.utc)
+    peer.latest_block = ping.latest_block
+
+    validation_route = node.validation_route
+    if validation_route is None:
+        return
+
+    try:
+        if ping.is_validator:
+            validation_route.add_peer(peer.public_key_bytes)
+        else:
+            validation_route.remove_peer(peer.public_key_bytes)
+    except Exception:
+        pass

{astreum-0.3.5 → astreum-0.3.14}/src/astreum/communication/handlers/route_request.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Sequence
-
 import socket
 
 from ..models.message import Message, MessageTopic
@@ -10,19 +8,17 @@ from ..util import xor_distance
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from .... import Node
+    from ..models.peer import Peer
 
 
-def handle_route_request(node: "Node", addr: Sequence[object], message: Message) -> None:
-    logger = node.logger
-
-    request_addr = (addr[0], int(addr[1])) if len(addr) >= 2 else addr
-    sender_public_key = node.addresses.get(request_addr)
+def handle_route_request(node: "Node", peer: "Peer", message: Message) -> None:
+    sender_public_key = getattr(peer, "public_key_bytes", None)
     if not sender_public_key:
-        logger.warning("Unknown sender for ROUTE_REQUEST from %s", addr)
+        node.logger.warning("Unknown sender for ROUTE_REQUEST from %s", peer.address)
         return
 
     if not message.content:
-        logger.warning("ROUTE_REQUEST missing route id from %s", addr)
+        node.logger.warning("ROUTE_REQUEST missing route id from %s", peer.address)
         return
     route_id = message.content[0]
     if route_id == 0:
@@ -30,38 +26,44 @@ def handle_route_request(node: "Node", addr: Sequence[object], message: Message)
     elif route_id == 1:
         route = node.validation_route
         if route is None:
-            logger.warning("Validation route not initialized for %s", addr)
+            node.logger.warning("Validation route not initialized for %s", peer.address)
             return
     else:
-        logger.warning("Unknown route id %s in ROUTE_REQUEST from %s", route_id, addr)
+        node.logger.warning("Unknown route id %s in ROUTE_REQUEST from %s", route_id, peer.address)
         return
 
     payload_parts = []
     for bucket in route.buckets.values():
         closest_key = None
         closest_distance = None
+
         for peer_key in bucket:
             try:
                 distance = xor_distance(sender_public_key, peer_key)
             except ValueError:
                 continue
+
             if closest_distance is None or distance < closest_distance:
                 closest_distance = distance
                 closest_key = peer_key
+
         if closest_key is None:
             continue
-        peer = node.peers.get(closest_key)
-        if not peer or not peer.address:
+
+        bucket_peer = node.get_peer(closest_key)
+        if bucket_peer is None or bucket_peer.address is None:
             continue
-        host, port = peer.address
+
+        host, port = bucket_peer.address
         try:
             address_bytes = socket.inet_pton(socket.AF_INET, host)
         except OSError:
             try:
                 address_bytes = socket.inet_pton(socket.AF_INET6, host)
             except OSError as exc:
-                logger.warning("Invalid peer address %s: %s", peer.address, exc)
+                node.logger.warning("Invalid peer address %s: %s", bucket_peer.address, exc)
                 continue
+
         port_bytes = int(port).to_bytes(2, "big", signed=False)
         payload_parts.append(address_bytes + port_bytes)
 
@@ -70,9 +72,5 @@ def handle_route_request(node: "Node", addr: Sequence[object], message: Message)
         content=b"".join(payload_parts),
         sender=node.relay_public_key,
     )
-    try:
-        request_host, request_port = addr[0], int(addr[1])
-    except Exception:
-        logger.warning("Invalid requester address %s", addr)
-        return
-    node.outgoing_queue.put((response.to_bytes(), (request_host, request_port)))
+    response.encrypt(peer.shared_key_bytes)
+    node.outgoing_queue.put((response.to_bytes(), peer.address))

{astreum-0.3.5 → astreum-0.3.14}/src/astreum/communication/handlers/route_response.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Sequence
-
 import socket
 
 from ..models.message import Message
@@ -9,21 +7,20 @@ from ..models.message import Message
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from .... import Node
+    from ..models.peer import Peer
 
 
-def handle_route_response(node: "Node", addr: Sequence[object], message: Message) -> None:
-    logger = node.logger
-
+def handle_route_response(node: "Node", peer: "Peer", message: Message) -> None:
     payload = message.content
     if not payload:
         return
     host_len = 16 if node.use_ipv6 else 4
     chunk_size = host_len + 2
     if len(payload) % chunk_size != 0:
-        logger.warning(
+        node.logger.warning(
             "ROUTE_RESPONSE payload size mismatch (%s bytes) from %s",
             len(payload),
-            addr,
+            peer.address,
         )
         return
 
@@ -35,9 +32,9 @@ def handle_route_response(node: "Node", addr: Sequence[object], message: Message
         try:
             host = socket.inet_ntop(family, host_bytes)
         except OSError as exc:
-            logger.warning(
+            node.logger.warning(
                 "Invalid host bytes in ROUTE_RESPONSE from %s: %s",
-                addr,
+                peer.address,
                 exc,
             )
             continue
@@ -45,8 +42,12 @@ def handle_route_response(node: "Node", addr: Sequence[object], message: Message
         decoded_addresses.append((host, port))
     if not decoded_addresses:
         return
-    logger.debug("Decoded %s addresses from ROUTE_RESPONSE", len(decoded_addresses))
+    node.logger.debug("Decoded %s addresses from ROUTE_RESPONSE", len(decoded_addresses))
 
-    handshake_message = Message(handshake=True, sender=node.relay_public_key)
+    handshake_message = Message(
+        handshake=True,
+        sender=node.relay_public_key,
+        content=int(node.config["incoming_port"]).to_bytes(2, "big", signed=False),
+    )
     for host, port in decoded_addresses:
         node.outgoing_queue.put((handshake_message.to_bytes(), (host, port)))