astreum 0.3.9__py3-none-any.whl → 0.3.46__py3-none-any.whl

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.validation import Account, Accounts, Block, Fork, Receipt, Transaction
+from astreum.machine import Env, Expr, parse, tokenize
 from astreum.node import Node
 
 
@@ -9,10 +9,11 @@ __all__: list[str] = [
     "Env",
     "Expr",
     "Block",
-    "Chain",
     "Fork",
     "Receipt",
     "Transaction",
     "Account",
     "Accounts",
+    "parse",
+    "tokenize",
 ]

astreum/communication/__init__.py

@@ -1,11 +1,15 @@
-from .models.message import Message
-from .models.peer import Peer
-from .models.route import Route
-from .setup import communication_setup
-
-__all__ = [
-    "Message",
-    "Peer",
-    "Route",
-    "communication_setup",
-]
+from .models.message import Message
+from .models.peer import Peer
+from .models.route import Route
+from .incoming_queue import enqueue_incoming
+from .outgoing_queue import enqueue_outgoing
+from .setup import communication_setup
+
+__all__ = [
+    "Message",
+    "Peer",
+    "Route",
+    "enqueue_incoming",
+    "enqueue_outgoing",
+    "communication_setup",
+]

astreum/communication/difficulty.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .. import Node
+
+
+def message_difficulty(node: "Node") -> int:
+    """Compute current message difficulty based on incoming queue pressure."""
+    size = node.incoming_queue_size
+    limit = node.incoming_queue_size_limit
+
+    if limit <= 0:
+        return 1
+
+    pressure = size / limit
+    if pressure < 0.70:
+        value = 1
+    elif pressure < 0.75:
+        value = 3
+    elif pressure < 0.80:
+        value = 5
+    elif pressure < 0.85:
+        value = 8
+    elif pressure < 0.90:
+        value = 12
+    elif pressure < 0.93:
+        value = 16
+    elif pressure < 0.95:
+        value = 19
+    elif pressure < 0.97:
+        value = 22
+    elif pressure < 0.98:
+        value = 24
+    else:
+        value = 26
+
+    return max(1, min(255, value))

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/communication/handlers/handshake.py

@@ -1,89 +1,105 @@
-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)
-
-    old_key_bytes = node.addresses.get(peer_address)
-    node.addresses[peer_address] = sender_public_key_bytes
-
-    if old_key_bytes is None:
-        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
-
-    if old_key_bytes == sender_public_key_bytes:
-        peer = node.get_peer(sender_public_key_bytes)
-        if peer is not None:
-            peer.address = peer_address
-        return False
-
-    try:
-        node.peer_route.remove_peer(old_key_bytes)
-    except Exception:
-        pass
-    try:
-        peer = Peer(
-            node_secret_key=node.relay_secret_key,
-            peer_public_key=sender_key,
-            address=peer_address,
-        )
-    except Exception:
-        return True
-
-    node.replace_peer(old_key_bytes, sender_public_key_bytes, peer)
-    node.peer_route.add_peer(sender_public_key_bytes, peer)
-    node.logger.info(
-        "Peer at %s:%s replaced due to key change",
-        peer_address[0],
-        peer_address[1],
-    )
-    return False
+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 ..outgoing_queue import enqueue_outgoing
+from ..models.peer import Peer
+from ..models.message import Message, MessageTopic
+from ..models.ping import Ping
+from ..difficulty import message_difficulty
+
+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 _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)),
+                difficulty=message_difficulty(node),
+                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)
+            enqueue_outgoing(
+                node,
+                peer_address,
+                message=ping_msg,
+                difficulty=peer.difficulty,
+            )
+        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)
+    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)
+    default_seed_ips = getattr(node, "default_seed_ips", None)
+    is_default_seed = bool(default_seed_ips) and host in default_seed_ips
+
+    existing_peer = node.get_peer(sender_public_key_bytes)
+    if existing_peer is not None:
+        existing_peer.address = peer_address
+        existing_peer.is_default_seed = is_default_seed
+        _queue_handshake_ping(existing_peer, peer_address)
+        return False
+
+    try:
+        peer = Peer(
+            node_secret_key=node.relay_secret_key,
+            peer_public_key=sender_key,
+            address=peer_address,
+            is_default_seed=is_default_seed,
+        )
+    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),
+    )
+    enqueue_outgoing(
+        node,
+        peer_address,
+        message=response,
+        difficulty=peer.difficulty,
+    )
+    _queue_handshake_ping(peer, peer_address)
+    return True