astreum 0.3.14__tar.gz → 0.3.25__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.3.14
+Version: 0.3.25
 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,18 +33,23 @@ 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.                                                                            |
-| `logging_retention`         | int        | `90`           | Number of days to keep rotated log files (daily gzip).                                                                                                                           |
+| `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.                                                                                                     |
 
-### Networking
+### Communication
 
 | Parameter                | Type        | Default               | Description                                                                                             |
 | ------------------------ | ----------- | --------------------- | ------------------------------------------------------------------------------------------------------- |
 | `relay_secret_key`       | hex string  | Auto-generated        | X25519 private key used for the relay route; a new keypair is created when this field is omitted.        |
 | `validation_secret_key`  | hex string  | `None`                | Optional Ed25519 key that lets the node join the validation route; leave blank to opt out of validation. |
 | `use_ipv6`               | bool        | `False`               | Bind the incoming/outgoing sockets on IPv6 (the OS still listens on IPv4 if a peer speaks both).         |
-| `incoming_port`          | int         | `7373`                | UDP port the relay binds to; pass `0` or omit to let the OS pick an ephemeral port.                       |
-| `bootstrap`              | list\[str\] | `[]`                  | Addresses to ping with a handshake before joining; each must look like `host:port` or `[ipv6]:port`.     |
+| `incoming_port`          | int         | `52780`                | UDP port the relay binds to; pass `0` or omit to let the OS pick an ephemeral port.                       |
+| `default_seeds`          | list\[str\] | `["bootstrap.astreum.org:52780"]` | Default addresses to ping before joining; pass `[]` to disable the built-in default.          |
+| `additional_seeds`       | list\[str\] | `[]`                  | Extra addresses appended to `default_seeds`; each must look like `host:port` or `[ipv6]:port`.           |
+| `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.                                  |
 
 > **Note**
 > The peer‑to‑peer *route* used for object discovery is always enabled.
@@ -61,10 +66,10 @@ 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",
-    "incoming_port": 7373,
+    "incoming_port": 52780,
     "use_ipv6": False,
-    "bootstrap": [
-        "bootstrap.astreum.org:7373",
+    "default_seeds": [],
+    "additional_seeds": [
         "127.0.0.1:7374"
     ]
 }
@@ -145,7 +150,7 @@ except ParseError as e:
 Every `Node` instance wires up structured logging automatically:
 
 - Logs land in per-instance files named `node.log` under `%LOCALAPPDATA%\Astreum\lib-py\logs/<instance_id>` on Windows and `$XDG_STATE_HOME` (or `~/.local/state`)/`Astreum/lib-py/logs/<instance_id>` on other platforms. The `<instance_id>` is the first 16 hex characters of a BLAKE3 hash of the caller's file path, so running the node from different entry points keeps their logs isolated.
-- Files rotate at midnight UTC with gzip compression (`node-YYYY-MM-DD.log.gz`) and retain 90 days by default. Override via `config["logging_retention"]`.
+- Files rotate at midnight UTC with gzip compression (`node-YYYY-MM-DD.log.gz`) and retain 90 days by default. Override via `config["logging_retention_days"]`.
 - Each event is a single JSON line containing timestamp, level, logger, message, process/thread info, module/function, and the derived `instance_id`.
 - Set `config["verbose"] = True` to mirror logs to stdout in a human-friendly format like `[2025-04-13-42-59] [info] Starting Astreum Node`.
 - The very first entry emitted is the banner `Starting Astreum Node`, signalling that the logging pipeline is live before other subsystems spin up.
@@ -156,5 +161,26 @@ Every `Node` instance wires up structured logging automatically:
 python3 -m venv venv
 source venv/bin/activate
 pip install -e .
+```
+
+for all tests
+```
 python3 -m unittest discover -s tests
 ```
+
+for individual tests
+```
+python3 -m unittest tests.node.test_atom_get
+python3 -m unittest tests.node.test_current_validator
+python3 -m unittest tests.node.test_node_connection
+python3 -m unittest tests.node.test_node_init
+python3 -m unittest tests.node.test_node_validation
+python3 -m unittest tests.node.tokenize
+python3 -m unittest tests.node.parse
+python3 -m unittest tests.node.function
+python3 -m unittest tests.node.stack
+python3 -m unittest tests.models.test_merkle
+python3 -m unittest tests.models.test_patricia
+python3 -m unittest tests.block.atom
+python3 -m unittest tests.block.nonce
+```

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

@@ -15,18 +15,23 @@ 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.                                                                            |
-| `logging_retention`         | int        | `90`           | Number of days to keep rotated log files (daily gzip).                                                                                                                           |
+| `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.                                                                                                     |
 
-### Networking
+### Communication
 
 | Parameter                | Type        | Default               | Description                                                                                             |
 | ------------------------ | ----------- | --------------------- | ------------------------------------------------------------------------------------------------------- |
-| `relay_secret_key`       | hex string  | Auto-generated        | X25519 private key used for the relay route; a new keypair is created when this field is omitted.        |
-| `validation_secret_key`  | hex string  | `None`                | Optional Ed25519 key that lets the node join the validation route; leave blank to opt out of validation. |
-| `use_ipv6`               | bool        | `False`               | Bind the incoming/outgoing sockets on IPv6 (the OS still listens on IPv4 if a peer speaks both).         |
-| `incoming_port`          | int         | `7373`                | UDP port the relay binds to; pass `0` or omit to let the OS pick an ephemeral port.                       |
-| `bootstrap`              | list\[str\] | `[]`                  | Addresses to ping with a handshake before joining; each must look like `host:port` or `[ipv6]:port`.     |
+| `relay_secret_key`       | hex string  | Auto-generated        | X25519 private key used for the relay route; a new keypair is created when this field is omitted.        |
+| `validation_secret_key`  | hex string  | `None`                | Optional Ed25519 key that lets the node join the validation route; leave blank to opt out of validation. |
+| `use_ipv6`               | bool        | `False`               | Bind the incoming/outgoing sockets on IPv6 (the OS still listens on IPv4 if a peer speaks both).         |
+| `incoming_port`          | int         | `52780`                | UDP port the relay binds to; pass `0` or omit to let the OS pick an ephemeral port.                       |
+| `default_seeds`          | list\[str\] | `["bootstrap.astreum.org:52780"]` | Default addresses to ping before joining; pass `[]` to disable the built-in default.          |
+| `additional_seeds`       | list\[str\] | `[]`                  | Extra addresses appended to `default_seeds`; each must look like `host:port` or `[ipv6]:port`.           |
+| `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.                                  |
 
 > **Note**
 > The peer‑to‑peer *route* used for object discovery is always enabled.
@@ -42,14 +47,14 @@ config = {
     "validation_secret_key": "12…34",        # optional – validator
     "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",
-    "incoming_port": 7373,
-    "use_ipv6": False,
-    "bootstrap": [
-        "bootstrap.astreum.org:7373",
-        "127.0.0.1:7374"
-    ]
-}
+    "cold_storage_path": "./data/node1",
+    "incoming_port": 52780,
+    "use_ipv6": False,
+    "default_seeds": [],
+    "additional_seeds": [
+        "127.0.0.1:7374"
+    ]
+}
 
 node = Node(config)
 # … your code …
@@ -127,7 +132,7 @@ except ParseError as e:
 Every `Node` instance wires up structured logging automatically:
 
 - Logs land in per-instance files named `node.log` under `%LOCALAPPDATA%\Astreum\lib-py\logs/<instance_id>` on Windows and `$XDG_STATE_HOME` (or `~/.local/state`)/`Astreum/lib-py/logs/<instance_id>` on other platforms. The `<instance_id>` is the first 16 hex characters of a BLAKE3 hash of the caller's file path, so running the node from different entry points keeps their logs isolated.
-- Files rotate at midnight UTC with gzip compression (`node-YYYY-MM-DD.log.gz`) and retain 90 days by default. Override via `config["logging_retention"]`.
+- Files rotate at midnight UTC with gzip compression (`node-YYYY-MM-DD.log.gz`) and retain 90 days by default. Override via `config["logging_retention_days"]`.
 - Each event is a single JSON line containing timestamp, level, logger, message, process/thread info, module/function, and the derived `instance_id`.
 - Set `config["verbose"] = True` to mirror logs to stdout in a human-friendly format like `[2025-04-13-42-59] [info] Starting Astreum Node`.
 - The very first entry emitted is the banner `Starting Astreum Node`, signalling that the logging pipeline is live before other subsystems spin up.
@@ -138,5 +143,26 @@ Every `Node` instance wires up structured logging automatically:
 python3 -m venv venv
 source venv/bin/activate
 pip install -e .
+```
+
+for all tests
+```
 python3 -m unittest discover -s tests
 ```
+
+for individual tests
+```
+python3 -m unittest tests.node.test_atom_get
+python3 -m unittest tests.node.test_current_validator
+python3 -m unittest tests.node.test_node_connection
+python3 -m unittest tests.node.test_node_init
+python3 -m unittest tests.node.test_node_validation
+python3 -m unittest tests.node.tokenize
+python3 -m unittest tests.node.parse
+python3 -m unittest tests.node.function
+python3 -m unittest tests.node.stack
+python3 -m unittest tests.models.test_merkle
+python3 -m unittest tests.models.test_patricia
+python3 -m unittest tests.block.atom
+python3 -m unittest tests.block.nonce
+```

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

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

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

@@ -1,5 +1,5 @@
 
-from astreum.consensus import Account, Accounts, Block, Chain, Fork, Receipt, Transaction
+from astreum.validation import Account, Accounts, Block, Chain, Fork, Receipt, Transaction
 from astreum.machine import Env, Expr, parse, tokenize
 from astreum.node import Node
 

astreum-0.3.25/src/astreum/communication/disconnect.py

@@ -0,0 +1,57 @@
+"""Helpers related to disconnecting communication components."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from astreum.node import Node
+
+
+_SOCKET_ATTRS: tuple[str, ...] = ("incoming_socket", "outgoing_socket")
+_THREAD_ATTRS: tuple[str, ...] = (
+    "incoming_populate_thread",
+    "incoming_process_thread",
+    "outgoing_thread",
+    "peer_manager_thread",
+    "latest_block_discovery_thread",
+    "verify_thread",
+    "consensus_validation_thread",
+)
+
+
+def _set_event(node: "Node", attr_name: str) -> None:
+    event = getattr(node, attr_name, None)
+    if event is not None:
+        event.set()
+
+
+def _close_socket(node: "Node", attr_name: str) -> None:
+    sock = getattr(node, attr_name, None)
+    if sock is None:
+        return
+    try:
+        sock.close()
+    except Exception as exc:  # pragma: no cover - defensive logging path
+        node.logger.warning("Error closing %s: %s", attr_name, exc)
+
+
+def disconnect_node(node: "Node") -> None:
+    """Gracefully stop worker threads and close communication sockets."""
+    node.logger.info("Disconnecting Astreum Node")
+
+    _set_event(node, "communication_stop_event")
+    _set_event(node, "_validation_stop_event")
+    _set_event(node, "_verify_stop_event")
+
+    for sock_name in _SOCKET_ATTRS:
+        _close_socket(node, sock_name)
+
+    for thread_name in _THREAD_ATTRS:
+        thread = getattr(node, thread_name, None)
+        if thread is None or not thread.is_alive():
+            continue
+        thread.join(timeout=1.0)
+
+    node.is_connected = False
+    node.logger.info("Node disconnected")

{astreum-0.3.14 → astreum-0.3.25}/src/astreum/communication/handlers/handshake.py

@@ -5,18 +5,42 @@ 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
+from ..models.peer import Peer
+from ..models.message import Message, MessageTopic
+from ..models.ping import Ping
 
 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.
-    """
+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.
+    """
+    def _queue_handshake_ping(peer: Peer, peer_address: tuple[str, int]) -> None:
+        latest_block = getattr(node, "latest_block_hash", None)
+        if not isinstance(latest_block, (bytes, bytearray)) or len(latest_block) != 32:
+            latest_block = None
+        try:
+            ping_payload = Ping(
+                is_validator=bool(getattr(node, "validation_public_key", None)),
+                latest_block=latest_block,
+            ).to_bytes()
+            ping_msg = Message(
+                topic=MessageTopic.PING,
+                content=ping_payload,
+                sender=node.relay_public_key,
+            )
+            ping_msg.encrypt(peer.shared_key_bytes)
+            node.outgoing_queue.put((ping_msg.to_bytes(), peer_address))
+        except Exception as exc:
+            node.logger.debug(
+                "Failed sending handshake ping to %s:%s: %s",
+                peer_address[0],
+                peer_address[1],
+                exc,
+            )
     sender_public_key_bytes = message.sender_bytes
     try:
         sender_key = X25519PublicKey.from_public_bytes(sender_public_key_bytes)
@@ -31,10 +55,11 @@ def handle_handshake(node: "Node", addr: Sequence[object], message: Message) ->
         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
+    existing_peer = node.get_peer(sender_public_key_bytes)
+    if existing_peer is not None:
+        existing_peer.address = peer_address
+        _queue_handshake_ping(existing_peer, peer_address)
+        return False
 
     try:
         peer = Peer(
@@ -48,15 +73,16 @@ def handle_handshake(node: "Node", addr: Sequence[object], message: Message) ->
     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.logger.info(
+        "Handshake accepted from %s:%s; peer added",
+        peer_address[0],
+        peer_address[1],
     )
-    node.outgoing_queue.put((response.to_bytes(), peer_address))
-    return True
+    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))
+    _queue_handshake_ping(peer, peer_address)
+    return True

astreum-0.3.25/src/astreum/communication/models/ping.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+class PingFormatError(ValueError):
+    """Raised when ping payload bytes are invalid."""
+
+
+@dataclass
+class Ping:
+    is_validator: bool
+    latest_block: Optional[bytes]
+
+    MIN_PAYLOAD_SIZE = 1
+    FULL_PAYLOAD_SIZE = 33
+
+    def __post_init__(self) -> None:
+        if self.latest_block is None:
+            return
+        lb = bytes(self.latest_block)
+        if len(lb) != 32:
+            raise ValueError("latest_block must be exactly 32 bytes")
+        self.latest_block = lb
+
+    def to_bytes(self) -> bytes:
+        flag = b"\x01" if self.is_validator else b"\x00"
+        if self.latest_block is None:
+            return flag
+        return flag + self.latest_block
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> "Ping":
+        if len(data) == cls.MIN_PAYLOAD_SIZE:
+            flag = data[0]
+            if flag not in (0, 1):
+                raise PingFormatError("ping validator flag must be 0 or 1")
+            return cls(is_validator=bool(flag), latest_block=None)
+        if len(data) != cls.FULL_PAYLOAD_SIZE:
+            raise PingFormatError("ping payload must be 1 or 33 bytes")
+        flag = data[0]
+        if flag not in (0, 1):
+            raise PingFormatError("ping validator flag must be 0 or 1")
+        return cls(is_validator=bool(flag), latest_block=data[1:])

{astreum-0.3.14 → astreum-0.3.25}/src/astreum/communication/models/route.py

@@ -42,6 +42,8 @@ class Route:
 
     def add_peer(self, peer_public_key: PeerKey, peer: Optional[Peer] = None):
         peer_public_key_bytes = self._normalize_peer_key(peer_public_key)
+        if peer_public_key_bytes == self.relay_public_key_bytes:
+            return
         bucket_idx = self._matching_leading_bits(self.relay_public_key_bytes, peer_public_key_bytes)
         if len(self.buckets[bucket_idx]) < self.bucket_size:
             bucket = self.buckets[bucket_idx]
@@ -52,6 +54,8 @@ class Route:
 
     def remove_peer(self, peer_public_key: PeerKey):
         peer_public_key_bytes = self._normalize_peer_key(peer_public_key)
+        if peer_public_key_bytes == self.relay_public_key_bytes:
+            return
         bucket_idx = self._matching_leading_bits(self.relay_public_key_bytes, peer_public_key_bytes)
         bucket = self.buckets.get(bucket_idx)
         if not bucket:

astreum-0.3.14/src/astreum/communication/start.py → astreum-0.3.25/src/astreum/communication/node.py

@@ -1,19 +1,18 @@
-def connect_to_network_and_verify(self):
+
+def connect_node(self):
     """Initialize communication and consensus components, then load latest block state."""
+    if self.is_connected:
+        self.logger.debug("Node already connected; skipping communication setup")
+        return
+
     self.logger.info("Starting communication and consensus setup")
     try:
         from astreum.communication import communication_setup  # type: ignore
         communication_setup(node=self, config=self.config)
         self.logger.info("Communication setup completed")
-    except Exception:
-        self.logger.exception("Communication setup failed")
-
-    try:
-        from astreum.consensus import consensus_setup  # type: ignore
-        consensus_setup(node=self, config=self.config)
-        self.logger.info("Consensus setup completed")
-    except Exception:
-        self.logger.exception("Consensus setup failed")
+    except Exception as exc:
+        self.logger.exception("Communication setup failed: %s", exc)
+        return exc
 
     # Load latest_block_hash from config
     self.latest_block_hash = getattr(self, "latest_block_hash", None)
@@ -30,7 +29,7 @@ def connect_to_network_and_verify(self):
 
     if self.latest_block_hash and self.latest_block is None:
         try:
-            from astreum.consensus.models.block import Block
+            from astreum.validation.models.block import Block
             self.latest_block = Block.from_atom(self, self.latest_block_hash)
             self.logger.info("Loaded latest block %s from storage", self.latest_block_hash.hex())
         except Exception as exc:

{astreum-0.3.14 → astreum-0.3.25}/src/astreum/communication/processors/incoming.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import socket
+from queue import Empty
 from typing import TYPE_CHECKING
 
 from ..handlers.handshake import handle_handshake
@@ -18,13 +20,19 @@ if TYPE_CHECKING:
 
 def process_incoming_messages(node: "Node") -> None:
     """Process incoming messages (placeholder)."""
-    while True:
+    stop = getattr(node, "communication_stop_event", None)
+    while stop is None or not stop.is_set():
         try:
-            data, addr = node.incoming_queue.get()
-        except Exception as exc:
+            data, addr = node.incoming_queue.get(timeout=0.5)
+        except Empty:
+            continue
+        except Exception:
             node.logger.exception("Error taking from incoming queue")
             continue
 
+        if stop is not None and stop.is_set():
+            break
+
         try:
             message = Message.from_bytes(data)
         except Exception as exc:
@@ -87,12 +95,23 @@ def process_incoming_messages(node: "Node") -> None:
             case _:
                 continue
 
+    node.logger.info("Incoming message processor stopped")
+
 
 def populate_incoming_messages(node: "Node") -> None:
     """Receive UDP packets and feed the incoming queue."""
-    while True:
+    stop = getattr(node, "communication_stop_event", None)
+    while stop is None or not stop.is_set():
         try:
             data, addr = node.incoming_socket.recvfrom(4096)
             node.incoming_queue.put((data, addr))
+        except socket.timeout:
+            continue
+        except OSError:
+            if stop is not None and stop.is_set():
+                break
+            node.logger.warning("Error populating incoming queue: socket closed")
         except Exception as exc:
             node.logger.warning("Error populating incoming queue: %s", exc)
+
+    node.logger.info("Incoming message populator stopped")

{astreum-0.3.14 → astreum-0.3.25}/src/astreum/communication/processors/outgoing.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from queue import Empty
 from typing import TYPE_CHECKING, Tuple
 
 if TYPE_CHECKING:
@@ -7,14 +8,22 @@ if TYPE_CHECKING:
 
 def process_outgoing_messages(node: "Node") -> None:
     """Send queued outbound packets."""
-    while True:
+    stop = getattr(node, "communication_stop_event", None)
+    while stop is None or not stop.is_set():
         try:
-            payload, addr = node.outgoing_queue.get()
+            payload, addr = node.outgoing_queue.get(timeout=0.5)
+        except Empty:
+            continue
         except Exception:
             node.logger.exception("Error taking from outgoing queue")
             continue
 
+        if stop is not None and stop.is_set():
+            break
+
         try:
             node.outgoing_socket.sendto(payload, addr)
         except Exception as exc:
             node.logger.warning("Error sending message to %s: %s", addr, exc)
+
+    node.logger.info("Outgoing message processor stopped")

astreum-0.3.25/src/astreum/communication/processors/peer.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import time
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING, Any
+
+from ..models.message import Message
+from ..util import address_str_to_host_and_port
+
+if TYPE_CHECKING:
+    from .. import Node
+
+
+def _queue_bootstrap_handshakes(node: "Node") -> int:
+    outgoing_queue = getattr(node, "outgoing_queue", None)
+    relay_public_key = getattr(node, "relay_public_key", None)
+    if outgoing_queue is None or relay_public_key is None:
+        return 0
+
+    default_seeds = node.config.get("default_seeds", [])
+    additional_seeds = node.config.get("additional_seeds", [])
+    bootstrap_peers = list(default_seeds) + list(additional_seeds)
+    if not bootstrap_peers:
+        return 0
+
+    try:
+        incoming_port = int(node.config.get("incoming_port", 0))
+        content = incoming_port.to_bytes(2, "big", signed=False)
+    except (TypeError, ValueError, OverflowError):
+        return 0
+
+    handshake_message = Message(
+        handshake=True,
+        sender=relay_public_key,
+        content=content,
+    )
+    handshake_bytes = handshake_message.to_bytes()
+    sent = 0
+    for addr in bootstrap_peers:
+        try:
+            host, port = address_str_to_host_and_port(addr)
+        except Exception as exc:
+            node.logger.warning("Invalid bootstrap address %s: %s", addr, exc)
+            continue
+        outgoing_queue.put((handshake_bytes, (host, port)))
+        node.logger.info("Retrying bootstrap handshake to %s:%s", host, port)
+        sent += 1
+    return sent
+
+
+def manage_peer(node: "Node") -> None:
+    """Continuously evict peers whose timestamps exceed the configured timeout."""
+    node.logger.info(
+        "Peer manager started (timeout=%3ds, interval=%3ds)",
+        node.config["peer_timeout"],
+        node.config["peer_timeout_interval"],
+    )
+    stop = getattr(node, "communication_stop_event", None)
+    while stop is None or not stop.is_set():
+        timeout_seconds = node.config["peer_timeout"]
+        interval_seconds = node.config["peer_timeout_interval"]
+        try:
+            peers = getattr(node, "peers", None)
+            peer_route = getattr(node, "peer_route", None)
+            if not isinstance(peers, dict) or peer_route is None:
+                time.sleep(interval_seconds)
+                continue
+
+            cutoff = datetime.now(timezone.utc) - timedelta(seconds=timeout_seconds)
+            stale_keys = []
+            with node.peers_lock:
+                for peer_key, peer in list(peers.items()):
+                    if peer.timestamp < cutoff:
+                        stale_keys.append(peer_key)
+
+            removed_count = 0
+            for peer_key in stale_keys:
+                removed = node.remove_peer(peer_key)
+                if removed is None:
+                    continue
+                removed_count += 1
+                try:
+                    peer_route.remove_peer(peer_key)
+                except Exception:
+                    node.logger.debug(
+                        "Unable to remove peer %s from route",
+                        peer_key.hex(),
+                    )
+                node.logger.debug(
+                    "Evicted stale peer %s last seen at %s",
+                    peer_key.hex(),
+                    getattr(removed, "timestamp", None),
+                )
+
+            if removed_count:
+                node.logger.info("Peer manager removed %s stale peer(s)", removed_count)
+
+            try:
+                with node.peers_lock:
+                    peer_count = len(peers)
+            except Exception:
+                peer_count = len(getattr(node, "peers", {}) or {})
+            if peer_count == 0:
+                bootstrap_interval = node.config.get("bootstrap_retry_interval", 0)
+                now = time.time()
+                last_attempt = getattr(node, "_bootstrap_last_attempt", 0.0)
+                if bootstrap_interval and (now - last_attempt) >= bootstrap_interval:
+                    sent = _queue_bootstrap_handshakes(node)
+                    if sent:
+                        node._bootstrap_last_attempt = now
+        except Exception:
+            node.logger.exception("Peer manager iteration failed")
+
+        if stop is not None and stop.wait(interval_seconds):
+            break
+
+    node.logger.info("Peer manager stopped")