astreum 0.3.46__tar.gz → 0.3.50__tar.gz

{astreum-0.3.46/src/astreum.egg-info → astreum-0.3.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.3.46
+Version: 0.3.50
 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
@@ -33,6 +33,8 @@ When initializing an `astreum.Node`, pass a dictionary with any of the options b
 | `hot_storage_limit`         | int        | `1073741824`   | Maximum bytes kept in the hot cache before new atoms are skipped (1 GiB).                                                                                                         |
 | `cold_storage_limit`        | int        | `10737418240`  | Cold storage write threshold (10 GiB by default); set to `0` to skip the limit.                                                                                                   |
 | `cold_storage_path`         | string     | `None`         | Directory where persisted atoms live; Astreum creates it on startup and skips cold storage when unset.                                                                            |
+| `atom_fetch_interval`       | float      | `0.25`         | Poll interval (seconds) while waiting for missing atoms in `get_atom_list_from_storage`; `0` disables waiting.                                                                    |
+| `atom_fetch_retries`        | int        | `8`            | Number of poll attempts for missing atoms; max wait is roughly `interval * retries`, `0` disables waiting.                                                                        |
 | `logging_retention_days`    | int        | `90`           | Number of days to keep rotated log files (daily gzip).                                                                                                                           |
 | `chain_id`                  | int        | `0`            | Chain identifier used for validation (0 = test, 1 = main).                                                                                                                        |
 | `verbose`                   | bool       | `False`        | When **True**, also mirror JSON logs to stdout with a human-readable format.                                                                                                     |
@@ -50,13 +52,14 @@ When initializing an `astreum.Node`, pass a dictionary with any of the options b
 | `peer_timeout`           | int         | `900`                 | Evict peers that have not been seen within this many seconds (15 minutes).                               |
 | `peer_timeout_interval`  | int         | `10`                  | How often (seconds) the peer manager checks for stale peers.                                             |
 | `bootstrap_retry_interval` | int       | `30`                  | How often (seconds) to retry bootstrapping when the peer list is empty.                                  |
-| `storage_index_interval` | int         | `600`                 | How often (seconds) to re-advertise cold storage atoms to the closest known peer.                        |
-| `cold_storage_advertise_limit` | int   | `1000`                | Max cold storage atoms advertised per cycle using last-modified time; `-1` unlimited, `0` disable.       |
+| `storage_index_interval` | int         | `600`                 | How often (seconds) to re-advertise entries in `node.atom_advertisments` to the closest known peer.       |
 | `incoming_queue_size_limit` | int     | `67108864`            | Soft cap (bytes) for inbound queue usage tracked by `enqueue_incoming`; set to `0` to disable.           |
 | `incoming_queue_timeout` | float      | `1.0`                 | When > 0, `enqueue_incoming` waits up to this many seconds for space before dropping the payload.        |
 | `outgoing_queue_size_limit` | int     | `67108864`            | Soft cap (bytes) for `enqueue_outgoing`-tracked outgoing queue usage; set to `0` to disable.            |
 | `outgoing_queue_timeout` | float      | `1.0`                 | When > 0, `enqueue_outgoing` waits up to this many seconds for space before dropping the payload.        |
 
+Advertisements: `node.atom_advertisments` holds `(atom_id, payload_type, expires_at)` tuples. Use `node.add_atom_advertisement` or `node.add_atom_advertisements` to enqueue entries (`expires_at=None` keeps them indefinite). Validators automatically advertise block, transaction (main and detail lists), receipt, and account trie lists for 15 minutes by default.
+
 > **Note**
 > The peer‑to‑peer *route* used for object discovery is always enabled.
 > If `validation_secret_key` is provided the node automatically joins the validation route too.
@@ -72,7 +75,6 @@ config = {
     "hot_storage_limit": 1073741824,         # cap hot cache at 1 GiB
     "cold_storage_limit": 10737418240,       # cap cold storage at 10 GiB
     "cold_storage_path": "./data/node1",
-    "cold_storage_advertise_limit": 1000,   # -1 unlimited, 0 disable, >0 limit
     "incoming_port": 52780,
     "use_ipv6": False,
     "default_seed": None,

{astreum-0.3.46 → astreum-0.3.50}/README.md

@@ -12,12 +12,14 @@ When initializing an `astreum.Node`, pass a dictionary with any of the options b
 
 | Parameter                   | Type       | Default        | Description                                                                                                                                                                      |
 | --------------------------- | ---------- | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `hot_storage_limit`         | int        | `1073741824`   | Maximum bytes kept in the hot cache before new atoms are skipped (1 GiB).                                                                                                         |
-| `cold_storage_limit`        | int        | `10737418240`  | Cold storage write threshold (10 GiB by default); set to `0` to skip the limit.                                                                                                   |
-| `cold_storage_path`         | string     | `None`         | Directory where persisted atoms live; Astreum creates it on startup and skips cold storage when unset.                                                                            |
-| `logging_retention_days`    | int        | `90`           | Number of days to keep rotated log files (daily gzip).                                                                                                                           |
-| `chain_id`                  | int        | `0`            | Chain identifier used for validation (0 = test, 1 = main).                                                                                                                        |
-| `verbose`                   | bool       | `False`        | When **True**, also mirror JSON logs to stdout with a human-readable format.                                                                                                     |
+| `hot_storage_limit`         | int        | `1073741824`   | Maximum bytes kept in the hot cache before new atoms are skipped (1 GiB).                                                                                                         |
+| `cold_storage_limit`        | int        | `10737418240`  | Cold storage write threshold (10 GiB by default); set to `0` to skip the limit.                                                                                                   |
+| `cold_storage_path`         | string     | `None`         | Directory where persisted atoms live; Astreum creates it on startup and skips cold storage when unset.                                                                            |
+| `atom_fetch_interval`       | float      | `0.25`         | Poll interval (seconds) while waiting for missing atoms in `get_atom_list_from_storage`; `0` disables waiting.                                                                    |
+| `atom_fetch_retries`        | int        | `8`            | Number of poll attempts for missing atoms; max wait is roughly `interval * retries`, `0` disables waiting.                                                                        |
+| `logging_retention_days`    | int        | `90`           | Number of days to keep rotated log files (daily gzip).                                                                                                                           |
+| `chain_id`                  | int        | `0`            | Chain identifier used for validation (0 = test, 1 = main).                                                                                                                        |
+| `verbose`                   | bool       | `False`        | When **True**, also mirror JSON logs to stdout with a human-readable format.                                                                                                     |
 
 ### Communication
 
@@ -32,14 +34,15 @@ When initializing an `astreum.Node`, pass a dictionary with any of the options b
 | `peer_timeout`           | int         | `900`                 | Evict peers that have not been seen within this many seconds (15 minutes).                               |
 | `peer_timeout_interval`  | int         | `10`                  | How often (seconds) the peer manager checks for stale peers.                                             |
 | `bootstrap_retry_interval` | int       | `30`                  | How often (seconds) to retry bootstrapping when the peer list is empty.                                  |
-| `storage_index_interval` | int         | `600`                 | How often (seconds) to re-advertise cold storage atoms to the closest known peer.                        |
-| `cold_storage_advertise_limit` | int   | `1000`                | Max cold storage atoms advertised per cycle using last-modified time; `-1` unlimited, `0` disable.       |
+| `storage_index_interval` | int         | `600`                 | How often (seconds) to re-advertise entries in `node.atom_advertisments` to the closest known peer.       |
 | `incoming_queue_size_limit` | int     | `67108864`            | Soft cap (bytes) for inbound queue usage tracked by `enqueue_incoming`; set to `0` to disable.           |
 | `incoming_queue_timeout` | float      | `1.0`                 | When > 0, `enqueue_incoming` waits up to this many seconds for space before dropping the payload.        |
 | `outgoing_queue_size_limit` | int     | `67108864`            | Soft cap (bytes) for `enqueue_outgoing`-tracked outgoing queue usage; set to `0` to disable.            |
-| `outgoing_queue_timeout` | float      | `1.0`                 | When > 0, `enqueue_outgoing` waits up to this many seconds for space before dropping the payload.        |
-
-> **Note**
+| `outgoing_queue_timeout` | float      | `1.0`                 | When > 0, `enqueue_outgoing` waits up to this many seconds for space before dropping the payload.        |
+
+Advertisements: `node.atom_advertisments` holds `(atom_id, payload_type, expires_at)` tuples. Use `node.add_atom_advertisement` or `node.add_atom_advertisements` to enqueue entries (`expires_at=None` keeps them indefinite). Validators automatically advertise block, transaction (main and detail lists), receipt, and account trie lists for 15 minutes by default.
+
+> **Note**
 > The peer‑to‑peer *route* used for object discovery is always enabled.
 > If `validation_secret_key` is provided the node automatically joins the validation route too.
 
@@ -54,7 +57,6 @@ config = {
     "hot_storage_limit": 1073741824,         # cap hot cache at 1 GiB
     "cold_storage_limit": 10737418240,       # cap cold storage at 10 GiB
     "cold_storage_path": "./data/node1",
-    "cold_storage_advertise_limit": 1000,   # -1 unlimited, 0 disable, >0 limit
     "incoming_port": 52780,
     "use_ipv6": False,
     "default_seed": None,

{astreum-0.3.46 → astreum-0.3.50}/pyproject.toml

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

{astreum-0.3.46 → astreum-0.3.50}/src/astreum/communication/handlers/object_request.py

@@ -1,9 +1,16 @@
 import logging
 import socket
 from enum import IntEnum
-from typing import TYPE_CHECKING, Tuple
+from typing import Optional, TYPE_CHECKING, Tuple
 
-from .object_response import ObjectResponse, ObjectResponseType
+from .object_response import (
+    ObjectResponse,
+    ObjectResponseType,
+    OBJECT_FOUND_ATOM_PAYLOAD,
+    OBJECT_FOUND_LIST_PAYLOAD,
+    encode_object_found_atom_payload,
+    encode_object_found_list_payload,
+)
 from ..outgoing_queue import enqueue_outgoing
 from ..models.message import Message, MessageTopic
 from ..util import xor_distance
@@ -19,22 +26,36 @@ class ObjectRequestType(IntEnum):
     OBJECT_PUT = 1
 
 
-class ObjectRequest:
-    type: ObjectRequestType
-    data: bytes
-    atom_id: bytes
-
-    def __init__(self, type: ObjectRequestType, 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) -> "ObjectRequest":
-        # need at least 1 byte for type + 32 bytes for hash
+class ObjectRequest:
+    type: ObjectRequestType
+    data: bytes
+    atom_id: bytes
+    payload_type: Optional[int]
+
+    def __init__(
+        self,
+        type: ObjectRequestType,
+        data: bytes = b"",
+        atom_id: bytes = None,
+        payload_type: Optional[int] = None,
+    ):
+        self.type = type
+        self.data = data
+        self.atom_id = atom_id
+        self.payload_type = payload_type
+
+    def to_bytes(self):
+        if self.type == ObjectRequestType.OBJECT_PUT and self.payload_type is None:
+            raise ValueError("OBJECT_PUT requires payload_type")
+        if self.payload_type is not None:
+            payload = bytes([self.payload_type]) + self.data
+        else:
+            payload = self.data
+        return bytes([self.type.value]) + self.atom_id + payload
+
+    @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)")
 
@@ -44,9 +65,22 @@ class ObjectRequest:
         except ValueError:
             raise ValueError(f"Unknown ObjectRequestType: {type_val!r}")
 
-        atom_id_bytes = data[1:33]
-        payload    = data[33:]
-        return cls(req_type, payload, atom_id_bytes)
+        atom_id_bytes = data[1:33]
+        payload = data[33:]
+        if req_type == ObjectRequestType.OBJECT_GET:
+            if payload:
+                payload_type = payload[0]
+                payload = payload[1:]
+            else:
+                payload_type = None
+            return cls(req_type, payload, atom_id_bytes, payload_type=payload_type)
+        if req_type == ObjectRequestType.OBJECT_PUT:
+            if not payload:
+                raise ValueError("OBJECT_PUT missing payload type")
+            payload_type = payload[0]
+            payload = payload[1:]
+            return cls(req_type, payload, atom_id_bytes, payload_type=payload_type)
+        return cls(req_type, payload, atom_id_bytes)
 
 
 def encode_peer_contact_bytes(peer: "Peer") -> bytes:
@@ -75,31 +109,63 @@ def handle_object_request(node: "Node", peer: "Peer", message: Message) -> None:
         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(), 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(), peer.address)
-                resp = ObjectResponse(
-                    type=ObjectResponseType.OBJECT_FOUND,
-                    data=local_atom.to_bytes(),
-                    atom_id=atom_id
-                )
-                obj_res_msg  = Message(
-                    topic=MessageTopic.OBJECT_RESPONSE,
-                    body=resp.to_bytes(),
-                    sender=node.relay_public_key,
-                )
-                obj_res_msg.encrypt(peer.shared_key_bytes)
-                enqueue_outgoing(
-                    node,
-                    peer.address,
-                    message=obj_res_msg,
-                    difficulty=peer.difficulty,
+        case ObjectRequestType.OBJECT_GET:
+            atom_id = object_request.atom_id
+            node.logger.debug("Handling OBJECT_GET for %s from %s", atom_id.hex(), peer.address)
+            payload_type = object_request.payload_type
+            if payload_type is None:
+                payload_type = OBJECT_FOUND_ATOM_PAYLOAD
+
+            if payload_type == OBJECT_FOUND_ATOM_PAYLOAD:
+                local_atom = node.get_atom_from_local_storage(atom_id=atom_id)
+                if local_atom is not None:
+                    node.logger.debug("Object %s found locally; returning to %s", atom_id.hex(), peer.address)
+                    resp = ObjectResponse(
+                        type=ObjectResponseType.OBJECT_FOUND,
+                        data=encode_object_found_atom_payload(local_atom),
+                        atom_id=atom_id
+                    )
+                    obj_res_msg  = Message(
+                        topic=MessageTopic.OBJECT_RESPONSE,
+                        body=resp.to_bytes(),
+                        sender=node.relay_public_key,
+                    )
+                    obj_res_msg.encrypt(peer.shared_key_bytes)
+                    enqueue_outgoing(
+                        node,
+                        peer.address,
+                        message=obj_res_msg,
+                        difficulty=peer.difficulty,
+                    )
+                    return
+            elif payload_type == OBJECT_FOUND_LIST_PAYLOAD:
+                local_atoms = node.get_atom_list_from_local_storage(root_hash=atom_id)
+                if local_atoms is not None:
+                    node.logger.debug("Object list %s found locally; returning to %s", atom_id.hex(), peer.address)
+                    resp = ObjectResponse(
+                        type=ObjectResponseType.OBJECT_FOUND,
+                        data=encode_object_found_list_payload(local_atoms),
+                        atom_id=atom_id
+                    )
+                    obj_res_msg  = Message(
+                        topic=MessageTopic.OBJECT_RESPONSE,
+                        body=resp.to_bytes(),
+                        sender=node.relay_public_key,
+                    )
+                    obj_res_msg.encrypt(peer.shared_key_bytes)
+                    enqueue_outgoing(
+                        node,
+                        peer.address,
+                        message=obj_res_msg,
+                        difficulty=peer.difficulty,
+                    )
+                    return
+            else:
+                node.logger.warning(
+                    "Unknown OBJECT_GET payload type %s for %s",
+                    payload_type,
+                    atom_id.hex(),
                 )
-                return
 
             if atom_id in node.storage_index:
                 provider_id = node.storage_index[atom_id]
@@ -184,11 +250,12 @@ def handle_object_request(node: "Node", peer: "Peer", message: Message) -> None:
                     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,
-                )
+                fwd_req = ObjectRequest(
+                    type=ObjectRequestType.OBJECT_PUT,
+                    data=object_request.data,
+                    atom_id=object_request.atom_id,
+                    payload_type=object_request.payload_type,
+                )
                 obj_req_msg = Message(
                     topic=MessageTopic.OBJECT_REQUEST,
                     body=fwd_req.to_bytes(),

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

@@ -0,0 +1,223 @@
+import socket
+from enum import IntEnum
+from typing import List, Tuple, TYPE_CHECKING
+
+from ..outgoing_queue import enqueue_outgoing
+from ..models.message import Message, MessageTopic
+from ...storage.models.atom import Atom
+from ...storage.requests import get_atom_req_payload
+
+if TYPE_CHECKING:
+    from .. import Node
+    from ..models.peer import Peer
+
+
+class ObjectResponseType(IntEnum):
+    OBJECT_FOUND = 0
+    OBJECT_PROVIDER = 1
+    OBJECT_NEAREST_PEER = 2
+
+
+OBJECT_FOUND_ATOM_PAYLOAD = 1
+OBJECT_FOUND_LIST_PAYLOAD = 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 encode_object_found_atom_payload(atom: Atom) -> bytes:
+    return bytes([OBJECT_FOUND_ATOM_PAYLOAD]) + atom.to_bytes()
+
+
+def encode_object_found_list_payload(atoms: List[Atom]) -> bytes:
+    parts = [bytes([OBJECT_FOUND_LIST_PAYLOAD])]
+    for atom in atoms:
+        atom_bytes = atom.to_bytes()
+        parts.append(len(atom_bytes).to_bytes(4, "big", signed=False))
+        parts.append(atom_bytes)
+    return b"".join(parts)
+
+
+def decode_object_found_list_payload(payload: bytes) -> List[Atom]:
+    atoms: List[Atom] = []
+    offset = 0
+    while offset < len(payload):
+        if len(payload) - offset < 4:
+            raise ValueError("truncated atom length")
+        atom_len = int.from_bytes(payload[offset : offset + 4], "big", signed=False)
+        offset += 4
+        if atom_len <= 0:
+            raise ValueError("invalid atom length")
+        end = offset + atom_len
+        if end > len(payload):
+            raise ValueError("truncated atom payload")
+        atoms.append(Atom.from_bytes(payload[offset:end]))
+        offset = end
+    return atoms
+
+
+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:
+            payload = object_response.data
+            if not payload:
+                node.logger.warning(
+                    "OBJECT_FOUND payload for %s missing content",
+                    object_response.atom_id.hex(),
+                )
+                return
+
+            payload_type = payload[0]
+            body = payload[1:]
+
+            if payload_type == OBJECT_FOUND_ATOM_PAYLOAD:
+                try:
+                    atom = Atom.from_bytes(body)
+                except Exception as exc:
+                    node.logger.warning(
+                        "Invalid OBJECT_FOUND atom payload for %s: %s",
+                        object_response.atom_id.hex(),
+                        exc,
+                    )
+                    return
+
+                atom_id = atom.object_id()
+                if object_response.atom_id != atom_id:
+                    node.logger.warning(
+                        "OBJECT_FOUND atom ID mismatch (expected=%s got=%s)",
+                        object_response.atom_id.hex(),
+                        atom_id.hex(),
+                    )
+                    return
+
+                node.pop_atom_req(atom_id)
+                node._hot_storage_set(atom_id, atom)
+                return
+
+            if payload_type == OBJECT_FOUND_LIST_PAYLOAD:
+                try:
+                    atoms = decode_object_found_list_payload(body)
+                except Exception as exc:
+                    node.logger.warning(
+                        "Invalid OBJECT_FOUND list payload for %s: %s",
+                        object_response.atom_id.hex(),
+                        exc,
+                    )
+                    return
+
+                if not atoms:
+                    node.logger.warning(
+                        "OBJECT_FOUND list payload for %s contained no atoms",
+                        object_response.atom_id.hex(),
+                    )
+                    return
+
+                root_id = atoms[0].object_id()
+                if object_response.atom_id != root_id:
+                    node.logger.warning(
+                        "OBJECT_FOUND list root ID mismatch (expected=%s got=%s)",
+                        object_response.atom_id.hex(),
+                        root_id.hex(),
+                    )
+                    return
+
+                node.pop_atom_req(root_id)
+                for atom in atoms:
+                    node._hot_storage_set(atom.object_id(), atom)
+                return
+
+            node.logger.warning(
+                "Unknown OBJECT_FOUND payload type %s for %s",
+                payload_type,
+                object_response.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
+
+            payload_type = get_atom_req_payload(node, object_response.atom_id)
+            if payload_type is None:
+                payload_type = OBJECT_FOUND_ATOM_PAYLOAD
+
+            obj_req = ObjectRequest(
+                type=ObjectRequestType.OBJECT_GET,
+                data=b"",
+                atom_id=object_response.atom_id,
+                payload_type=payload_type,
+            )
+            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)
+            enqueue_outgoing(
+                node,
+                (provider_address, provider_port),
+                message=obj_req_msg,
+                difficulty=1,
+            )
+
+        case ObjectResponseType.OBJECT_NEAREST_PEER:
+            node.logger.debug("Ignoring OBJECT_NEAREST_PEER response from %s", peer.address)

{astreum-0.3.46 → astreum-0.3.50}/src/astreum/communication/handlers/ping.py

@@ -1,43 +1,57 @@
-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
-    peer.difficulty = ping.difficulty
-    if peer.is_default_seed and ping.latest_block:
-        if getattr(node, "latest_block_hash", None) != ping.latest_block:
-            node.latest_block_hash = ping.latest_block
-            node.latest_block = None
-            node.logger.info(
-                "Updated latest block hash from default seed %s",
-                peer.address[0] if peer.address else "unknown",
-            )
-
-    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
+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
+    peer.difficulty = ping.difficulty
+    if peer.is_default_seed and ping.latest_block:
+        if getattr(node, "latest_block_hash", None) != ping.latest_block:
+            node.latest_block_hash = ping.latest_block
+            node.latest_block = None
+            try:
+                from astreum.validation.models.block import Block
+
+                node.latest_block = Block.from_atom(node, ping.latest_block)
+                node.logger.info(
+                    "Loaded latest block %s after seed update",
+                    ping.latest_block.hex(),
+                )
+            except Exception as exc:
+                node.logger.warning(
+                    "Failed loading latest block %s after seed update: %s",
+                    ping.latest_block.hex(),
+                    exc,
+                )
+            node.logger.info(
+                "Updated latest block hash from default seed %s",
+                peer.address[0] if peer.address else "unknown",
+            )
+
+    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