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

astreum/communication/handlers/object_request.py

@@ -1,176 +1,206 @@
-import logging
-import socket
+import logging
+import socket
 from enum import IntEnum
 from typing import TYPE_CHECKING, Tuple
 
 from .object_response import ObjectResponse, ObjectResponseType
+from ..outgoing_queue import enqueue_outgoing
 from ..models.message import Message, MessageTopic
 from ..util import xor_distance
-
-if TYPE_CHECKING:
-    from .. import Node
-    from ..models.peer import Peer
-
-
-class ObjectRequestType(IntEnum):
-    OBJECT_GET = 0
-    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
-        if len(data) < 1 + 32:
-            raise ValueError(f"Too short for ObjectRequest ({len(data)} bytes)")
-
-        type_val = data[0]
-        try:
-            req_type = ObjectRequestType(type_val)
-        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)
-
-
-def encode_peer_contact_bytes(peer: "Peer") -> bytes:
-    """Return a fixed-width peer contact payload (32-byte key + IPv4 + port)."""
-    host, port = peer.address
-    key_bytes = peer.public_key_bytes
-    try:
-        ip_bytes = socket.inet_aton(host)
-    except OSError as exc:  # pragma: no cover - inet_aton raises for invalid hosts
-        raise ValueError(f"invalid IPv4 address: {host}") from exc
-    if not (0 <= port <= 0xFFFF):
-        raise ValueError(f"port out of range (0-65535): {port}")
-    port_bytes = int(port).to_bytes(2, "big", signed=False)
-    return key_bytes + ip_bytes + port_bytes
-
-
-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.content)
-    except Exception as 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(), 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
-                )
+from ...storage.providers import provider_id_for_payload, provider_payload_for_id
+
+if TYPE_CHECKING:
+    from .. import Node
+    from ..models.peer import Peer
+
+
+class ObjectRequestType(IntEnum):
+    OBJECT_GET = 0
+    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
+        if len(data) < 1 + 32:
+            raise ValueError(f"Too short for ObjectRequest ({len(data)} bytes)")
+
+        type_val = data[0]
+        try:
+            req_type = ObjectRequestType(type_val)
+        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)
+
+
+def encode_peer_contact_bytes(peer: "Peer") -> bytes:
+    """Return a fixed-width peer contact payload (32-byte key + IPv4 + port)."""
+    host, port = peer.address
+    key_bytes = peer.public_key_bytes
+    try:
+        ip_bytes = socket.inet_aton(host)
+    except OSError as exc:  # pragma: no cover - inet_aton raises for invalid hosts
+        raise ValueError(f"invalid IPv4 address: {host}") from exc
+    if not (0 <= port <= 0xFFFF):
+        raise ValueError(f"port out of range (0-65535): {port}")
+    port_bytes = int(port).to_bytes(2, "big", signed=False)
+    return key_bytes + ip_bytes + port_bytes
+
+
+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.content)
+    except Exception as 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(), 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)
-                node.outgoing_queue.put((obj_res_msg.to_bytes(), peer.address))
-                return
-
-            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,
-                    atom_id=atom_id
+                enqueue_outgoing(
+                    node,
+                    peer.address,
+                    message=obj_res_msg,
+                    difficulty=peer.difficulty,
                 )
-                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)
-                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", peer.address, atom_id.hex())
-                peer_info = encode_peer_contact_bytes(nearest_peer)
-                resp = ObjectResponse(
-                    type=ObjectResponseType.OBJECT_PROVIDER,
-                    # type=ObjectResponseType.OBJECT_NEAREST_PEER,
-                    data=peer_info,
-                    atom_id=atom_id
-                )
+
+            if atom_id in node.storage_index:
+                provider_id = node.storage_index[atom_id]
+                provider_bytes = provider_payload_for_id(node, provider_id)
+                if provider_bytes is not None:
+                    node.logger.debug("Known provider for %s; informing %s", atom_id.hex(), peer.address)
+                    resp = ObjectResponse(
+                        type=ObjectResponseType.OBJECT_PROVIDER,
+                        data=provider_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,
+                    )
+                    return
+                node.logger.warning(
+                    "Unknown provider id %s for %s",
+                    provider_id,
+                    atom_id.hex(),
+                )
+
+            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", peer.address, atom_id.hex())
+                peer_info = encode_peer_contact_bytes(nearest_peer)
+                resp = ObjectResponse(
+                    type=ObjectResponseType.OBJECT_PROVIDER,
+                    # type=ObjectResponseType.OBJECT_NEAREST_PEER,
+                    data=peer_info,
+                    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(nearest_peer.shared_key_bytes)
-                node.outgoing_queue.put((obj_res_msg.to_bytes(), peer.address))
-
-        case ObjectRequestType.OBJECT_PUT:
-            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(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,
+                enqueue_outgoing(
+                    node,
+                    peer.address,
+                    message=obj_res_msg,
+                    difficulty=peer.difficulty,
                 )
+
+        case ObjectRequestType.OBJECT_PUT:
+            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(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())
+                provider_id = provider_id_for_payload(node, object_request.data)
+                node.storage_index[object_request.atom_id] = provider_id
+            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,
                 )
                 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, peer.address)
+                enqueue_outgoing(
+                    node,
+                    nearest_peer.address,
+                    message=obj_req_msg,
+                    difficulty=nearest_peer.difficulty,
+                )
+
+        case _:
+            node.logger.warning("Unknown ObjectRequestType %s from %s", object_request.type, peer.address)

astreum/communication/handlers/object_response.py

@@ -2,6 +2,7 @@ import socket
 from enum import IntEnum
 from typing import Tuple, TYPE_CHECKING
 
+from ..outgoing_queue import enqueue_outgoing
 from ..models.message import Message, MessageTopic
 from ...storage.models.atom import Atom
 
@@ -109,7 +110,12 @@ def handle_object_response(node: "Node", peer: "Peer", message: Message) -> None
                 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)))
+            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/communication/handlers/ping.py

@@ -20,6 +20,15 @@ def handle_ping(node: "Node", peer: Peer, payload: bytes) -> None:
 
     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:

astreum/communication/handlers/route_request.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import socket
 
+from ..outgoing_queue import enqueue_outgoing
 from ..models.message import Message, MessageTopic
 from ..util import xor_distance
 
@@ -73,4 +74,9 @@ def handle_route_request(node: "Node", peer: "Peer", message: Message) -> None:
         sender=node.relay_public_key,
     )
     response.encrypt(peer.shared_key_bytes)
-    node.outgoing_queue.put((response.to_bytes(), peer.address))
+    enqueue_outgoing(
+        node,
+        peer.address,
+        message=response,
+        difficulty=peer.difficulty,
+    )

astreum/communication/handlers/route_response.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import socket
 
+from ..outgoing_queue import enqueue_outgoing
 from ..models.message import Message
 
 from typing import TYPE_CHECKING
@@ -50,4 +51,9 @@ def handle_route_response(node: "Node", peer: "Peer", message: Message) -> None:
         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)))
+        enqueue_outgoing(
+            node,
+            (host, port),
+            message=handshake_message,
+            difficulty=1,
+        )

astreum/communication/incoming_queue.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Tuple
+
+from blake3 import blake3
+
+from .difficulty import message_difficulty
+from .message_pow import NONCE_SIZE, _leading_zero_bits
+
+if TYPE_CHECKING:
+    from .. import Node
+
+
+INCOMING_QUEUE_ITEM_OVERHEAD_BYTES = 6
+
+
+def enqueue_incoming(
+    node: "Node",
+    address: Tuple[str, int],
+    payload: bytes,
+) -> bool:
+    """Enqueue an incoming UDP payload while tracking queued bytes.
+    Increments `node.incoming_queue_size` by `len(payload) + 6` and enforces
+    `node.incoming_queue_size_limit` (bytes) as a soft cap by dropping enqueues that
+    would exceed the limit. If `node.incoming_queue_timeout` is > 0, it waits up to
+    that many seconds (using `communication_stop_event.wait`) for space before dropping.
+    """
+    required_difficulty = message_difficulty(node)
+    if len(payload) <= NONCE_SIZE:
+        node.logger.warning(
+            "Incoming payload too short for difficulty check (len=%s, required=%s)",
+            len(payload),
+            required_difficulty,
+        )
+        return False
+
+    nonce_bytes = payload[:NONCE_SIZE]
+    message_bytes = payload[NONCE_SIZE:]
+    digest = blake3(message_bytes + nonce_bytes).digest()
+    zeros = _leading_zero_bits(digest)
+    if zeros < required_difficulty:
+        node.logger.warning(
+            "Incoming payload failed difficulty check (zeros=%s required=%s bytes=%s)",
+            zeros,
+            required_difficulty,
+            len(payload),
+        )
+        return False
+
+    accounted_size = len(payload) + INCOMING_QUEUE_ITEM_OVERHEAD_BYTES
+    timeout = float(node.incoming_queue_timeout or 0)
+
+    with node.incoming_queue_size_lock:
+        current_size = int(node.incoming_queue_size)
+        limit = int(node.incoming_queue_size_limit)
+        projected_size = current_size + accounted_size
+        if projected_size > limit:
+            if timeout <= 0:
+                node.logger.warning(
+                    "Incoming queue size limit reached (%s > %s); dropping inbound payload (bytes=%s)",
+                    projected_size,
+                    limit,
+                    len(payload),
+                )
+                return False
+            wait_for_space = True
+        else:
+            node.incoming_queue_size = projected_size
+            wait_for_space = False
+
+    if wait_for_space:
+        if node.communication_stop_event.wait(timeout):
+            return False
+        with node.incoming_queue_size_lock:
+            current_size = int(node.incoming_queue_size)
+            limit = int(node.incoming_queue_size_limit)
+            projected_size = current_size + accounted_size
+            if projected_size > limit:
+                node.logger.warning(
+                    "Incoming queue still full after waiting %ss (%s > %s); dropping inbound payload (bytes=%s)",
+                    timeout,
+                    projected_size,
+                    limit,
+                    len(payload),
+                )
+                return False
+            node.incoming_queue_size = projected_size
+
+    try:
+        node.incoming_queue.put((message_bytes, address, accounted_size))
+    except Exception:
+        with node.incoming_queue_size_lock:
+            node.incoming_queue_size = max(0, int(node.incoming_queue_size) - accounted_size)
+        raise
+
+    return True

astreum/communication/message_pow.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from blake3 import blake3
+
+NONCE_SIZE = 8
+MAX_MESSAGE_NONCE = (1 << (NONCE_SIZE * 8)) - 1
+
+
+def _leading_zero_bits(buf: bytes) -> int:
+    """Return the number of leading zero bits in the provided buffer."""
+    zeros = 0
+    for byte in buf:
+        if byte == 0:
+            zeros += 8
+            continue
+        zeros += 8 - int(byte).bit_length()
+        break
+    return zeros
+
+
+def calculate_message_nonce(message_bytes: bytes, difficulty: int) -> int:
+    """Find a nonce such that blake3(message_bytes + nonce_bytes) meets difficulty.
+
+    message_bytes should exclude any nonce prefix that will be added on the wire.
+    """
+    target = max(1, int(difficulty))
+    nonce = 0
+    message_bytes = bytes(message_bytes)
+    while True:
+        if nonce > MAX_MESSAGE_NONCE:
+            raise ValueError("nonce search exhausted")
+        nonce_bytes = int(nonce).to_bytes(NONCE_SIZE, "big", signed=False)
+        digest = blake3(message_bytes + nonce_bytes).digest()
+        if _leading_zero_bits(digest) >= target:
+            return nonce
+        nonce += 1

astreum/communication/models/peer.py

@@ -13,11 +13,15 @@ class Peer:
         peer_public_key: X25519PublicKey,
         latest_block: Optional[bytes] = None,
         address: Optional[Tuple[str, int]] = None,
+        is_default_seed: bool = False,
+        difficulty: int = 1,
     ):
         self.shared_key_bytes = node_secret_key.exchange(peer_public_key)
         self.timestamp = datetime.now(timezone.utc)
         self.latest_block = latest_block
+        self.difficulty = max(1, int(difficulty or 1))
         self.address = address
+        self.is_default_seed = bool(is_default_seed)
         self.public_key_bytes = peer_public_key.public_bytes(
             encoding=serialization.Encoding.Raw,
             format=serialization.PublicFormat.Raw,

astreum/communication/models/ping.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import Optional
 
 
 class PingFormatError(ValueError):
@@ -10,24 +11,44 @@ class PingFormatError(ValueError):
 @dataclass
 class Ping:
     is_validator: bool
-    latest_block: bytes
+    difficulty: int
+    latest_block: Optional[bytes]
 
-    PAYLOAD_SIZE = 33
+    PAYLOAD_SIZE = 34
+    ZERO_BLOCK = b"\x00" * 32
 
     def __post_init__(self) -> None:
-        lb = bytes(self.latest_block or b"")
+        self.difficulty = int(self.difficulty)
+        if self.difficulty < 1 or self.difficulty > 255:
+            raise ValueError("difficulty must be between 1 and 255")
+        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:
-        return (b"\x01" if self.is_validator else b"\x00") + self.latest_block
+        flag = b"\x01" if self.is_validator else b"\x00"
+        difficulty = bytes([self.difficulty])
+        latest_block = self.latest_block if self.latest_block is not None else self.ZERO_BLOCK
+        return flag + difficulty + latest_block
 
     @classmethod
     def from_bytes(cls, data: bytes) -> "Ping":
         if len(data) != cls.PAYLOAD_SIZE:
-            raise PingFormatError("ping payload must be exactly 33 bytes")
+            raise PingFormatError("ping payload must be 34 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:])
+        difficulty = data[1]
+        if difficulty < 1:
+            raise PingFormatError("ping difficulty must be >= 1")
+        latest_block = data[2:]
+        if latest_block == cls.ZERO_BLOCK:
+            latest_block = None
+        return cls(
+            is_validator=bool(flag),
+            difficulty=difficulty,
+            latest_block=latest_block,
+        )

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: