chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.6.0rc2__py3-none-any.whl

chia/server/server.py

@@ -5,11 +5,11 @@ import logging
 import ssl
 import time
 import traceback
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from ipaddress import IPv4Network, IPv6Network, ip_network
 from pathlib import Path
-from typing import Any, Callable, Optional, Union, cast
+from typing import Any, cast
 
 from aiohttp import (
     ClientResponseError,
@@ -31,7 +31,7 @@ from chia.protocols.outbound_message import Message, NodeType
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.protocol_state_machine import message_requires_reply
 from chia.protocols.protocol_timing import INVALID_PROTOCOL_BAN_SECONDS
-from chia.server.api_protocol import ApiProtocol
+from chia.server.api_protocol import ApiMetadata, ApiProtocol
 from chia.server.introducer_peers import IntroducerPeers
 from chia.server.ssl_context import private_ssl_paths, public_ssl_paths
 from chia.server.ws_connection import ConnectionCallback, WSChiaConnection
@@ -52,33 +52,21 @@ def ssl_context_for_server(
     key_path: Path,
     *,
     check_permissions: bool = True,
-    log: Optional[logging.Logger] = None,
+    log: logging.Logger | None = None,
 ) -> ssl.SSLContext:
     if check_permissions:
         verify_ssl_certs_and_keys([ca_cert, cert_path], [ca_key, key_path], log)
 
     ssl_context = ssl._create_unverified_context(purpose=ssl.Purpose.CLIENT_AUTH, cafile=str(ca_cert))  # noqa: S323
     ssl_context.check_hostname = False
-    ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2
-    ssl_context.set_ciphers(
-        "ECDHE-ECDSA-AES256-GCM-SHA384:"
-        "ECDHE-RSA-AES256-GCM-SHA384:"
-        "ECDHE-ECDSA-CHACHA20-POLY1305:"
-        "ECDHE-RSA-CHACHA20-POLY1305:"
-        "ECDHE-ECDSA-AES128-GCM-SHA256:"
-        "ECDHE-RSA-AES128-GCM-SHA256:"
-        "ECDHE-ECDSA-AES256-SHA384:"
-        "ECDHE-RSA-AES256-SHA384:"
-        "ECDHE-ECDSA-AES128-SHA256:"
-        "ECDHE-RSA-AES128-SHA256"
-    )
+    ssl_context.minimum_version = ssl.TLSVersion.TLSv1_3
     ssl_context.load_cert_chain(certfile=str(cert_path), keyfile=str(key_path))
     ssl_context.verify_mode = ssl.CERT_REQUIRED
     return ssl_context
 
 
 def ssl_context_for_root(
-    ca_cert_file: str, *, check_permissions: bool = True, log: Optional[logging.Logger] = None
+    ca_cert_file: str, *, check_permissions: bool = True, log: logging.Logger | None = None
 ) -> ssl.SSLContext:
     if check_permissions:
         verify_ssl_certs_and_keys([Path(ca_cert_file)], [], log)
@@ -94,7 +82,7 @@ def ssl_context_for_client(
     key_path: Path,
     *,
     check_permissions: bool = True,
-    log: Optional[logging.Logger] = None,
+    log: logging.Logger | None = None,
 ) -> ssl.SSLContext:
     if check_permissions:
         verify_ssl_certs_and_keys([ca_cert, cert_path], [ca_key, key_path], log)
@@ -116,7 +104,7 @@ def calculate_node_id(cert_path: Path) -> bytes32:
 @final
 @dataclass
 class ChiaServer:
-    _port: Optional[int]
+    _port: int | None
     _local_type: NodeType
     _local_capabilities_for_handshake: list[tuple[uint16, str]]
     _ping_interval: int
@@ -131,23 +119,23 @@ class ChiaServer:
     ssl_context: ssl.SSLContext
     ssl_client_context: ssl.SSLContext
     node_id: bytes32
-    exempt_peer_networks: list[Union[IPv4Network, IPv6Network]]
-    class_for_type: dict[NodeType, type[ApiProtocol]]
+    exempt_peer_networks: list[IPv4Network | IPv6Network]
+    stub_metadata_for_type: dict[NodeType, ApiMetadata]
     all_connections: dict[bytes32, WSChiaConnection] = field(default_factory=dict)
-    on_connect: Optional[ConnectionCallback] = None
+    on_connect: ConnectionCallback | None = None
     shut_down_event: asyncio.Event = field(default_factory=asyncio.Event)
-    introducer_peers: Optional[IntroducerPeers] = None
-    gc_task: Optional[asyncio.Task[None]] = None
-    webserver: Optional[WebServer] = None
-    connection_close_task: Optional[asyncio.Task[None]] = None
-    received_message_callback: Optional[ConnectionCallback] = None
+    introducer_peers: IntroducerPeers | None = None
+    gc_task: asyncio.Task[None] | None = None
+    webserver: WebServer | None = None
+    connection_close_task: asyncio.Task[None] | None = None
+    received_message_callback: ConnectionCallback | None = None
     banned_peers: dict[str, float] = field(default_factory=dict)
     invalid_protocol_ban_seconds: int = INVALID_PROTOCOL_BAN_SECONDS
 
     @classmethod
     def create(
         cls,
-        port: Optional[int],
+        port: int | None,
         node: Any,
         api: ApiProtocol,
         local_type: NodeType,
@@ -160,7 +148,7 @@ class ChiaServer:
         config: dict[str, Any],
         private_ca_crt_key: tuple[Path, Path],
         chia_ca_crt_key: tuple[Path, Path],
-        class_for_type: dict[NodeType, type[ApiProtocol]],
+        stub_metadata_for_type: dict[NodeType, ApiMetadata],
         name: str = __name__,
     ) -> ChiaServer:
         log = logging.getLogger(name)
@@ -241,7 +229,7 @@ class ChiaServer:
             node_id=calculate_node_id(node_id_cert_path),
             exempt_peer_networks=[ip_network(net, strict=False) for net in config.get("exempt_peer_networks", [])],
             introducer_peers=IntroducerPeers() if local_type is NodeType.INTRODUCER else None,
-            class_for_type=class_for_type,
+            stub_metadata_for_type=stub_metadata_for_type,
         )
 
     def set_received_message_callback(self, callback: ConnectionCallback) -> None:
@@ -285,7 +273,7 @@ class ChiaServer:
     async def start(
         self,
         prefer_ipv6: bool,
-        on_connect: Optional[ConnectionCallback] = None,
+        on_connect: ConnectionCallback | None = None,
     ) -> None:
         if self.webserver is not None:
             raise RuntimeError("ChiaServer already started")
@@ -326,7 +314,7 @@ class ChiaServer:
         peer_id = bytes32(der_cert.fingerprint(hashes.SHA256()))
         if peer_id == self.node_id:
             return ws
-        connection: Optional[WSChiaConnection] = None
+        connection: WSChiaConnection | None = None
         try:
             connection = WSChiaConnection.create(
                 local_type=self._local_type,
@@ -341,7 +329,8 @@ class ChiaServer:
                 inbound_rate_limit_percent=self._inbound_rate_limit_percent,
                 outbound_rate_limit_percent=self._outbound_rate_limit_percent,
                 local_capabilities_for_handshake=self._local_capabilities_for_handshake,
-                class_for_type=self.class_for_type,
+                stub_metadata_for_type=self.stub_metadata_for_type,
+                exempt_peer_networks=self.exempt_peer_networks,
             )
             await connection.perform_handshake(self._network_id, self.get_port(), self._local_type)
             assert connection.connection_type is not None, "handshake failed to set connection type, still None"
@@ -384,7 +373,7 @@ class ChiaServer:
         return ws
 
     async def connection_added(
-        self, connection: WSChiaConnection, on_connect: Optional[ConnectionCallback] = None
+        self, connection: WSChiaConnection, on_connect: ConnectionCallback | None = None
     ) -> None:
         # If we already had a connection to this peer_id, close the old one. This is secure because peer_ids are based
         # on TLS public keys
@@ -416,7 +405,7 @@ class ChiaServer:
     async def start_client(
         self,
         target_node: PeerInfo,
-        on_connect: Optional[ConnectionCallback] = None,
+        on_connect: ConnectionCallback | None = None,
         is_feeler: bool = False,
     ) -> bool:
         """
@@ -432,7 +421,7 @@ class ChiaServer:
             return False
 
         session = None
-        connection: Optional[WSChiaConnection] = None
+        connection: WSChiaConnection | None = None
         try:
             # Crawler/DNS introducer usually uses a lower timeout than the default
             timeout_value = float(self.config.get("peer_connect_timeout", 30))
@@ -492,8 +481,9 @@ class ChiaServer:
                 inbound_rate_limit_percent=self._inbound_rate_limit_percent,
                 outbound_rate_limit_percent=self._outbound_rate_limit_percent,
                 local_capabilities_for_handshake=self._local_capabilities_for_handshake,
-                class_for_type=self.class_for_type,
+                stub_metadata_for_type=self.stub_metadata_for_type,
                 session=session,
+                exempt_peer_networks=self.exempt_peer_networks,
             )
             await connection.perform_handshake(self._network_id, server_port, self._local_type)
             await self.connection_added(connection, on_connect)
@@ -561,15 +551,14 @@ class ChiaServer:
                     f"Trying to ban trusted peer {connection.peer_info.host} for {ban_time}, but will not ban"
                 )
                 ban_time = 0
-        if ban_time > 0:
-            ban_until: float = time.time() + ban_time
-            self.log.warning(f"Banning {connection.peer_info.host} for {ban_time} seconds")
-            if connection.peer_info.host in self.banned_peers:
-                self.banned_peers[connection.peer_info.host] = max(
-                    ban_until, self.banned_peers[connection.peer_info.host]
+            elif is_in_network(connection.peer_info.host, self.exempt_peer_networks):
+                self.log.warning(
+                    f"Trying to ban exempt peer {connection.peer_info.host} for {ban_time}, but will not ban"
                 )
-            else:
-                self.banned_peers[connection.peer_info.host] = ban_until
+                ban_time = 0
+
+        if ban_time > 0:
+            self.ban_peer(connection.peer_info.host, ban_time)
 
         present_connection = self.all_connections.get(connection.peer_node_id)
         if present_connection is connection:
@@ -607,7 +596,7 @@ class ChiaServer:
         self,
         messages: list[Message],
         node_type: NodeType,
-        exclude: Optional[bytes32] = None,
+        exclude: bytes32 | None = None,
     ) -> None:
         await self.validate_broadcast_message_type(messages, node_type)
         for _, connection in self.all_connections.items():
@@ -620,7 +609,7 @@ class ChiaServer:
         messages: list[Message],
         node_type: NodeType,
         predicate: Callable[[WSChiaConnection], bool],
-        exclude: Optional[bytes32] = None,
+        exclude: bytes32 | None = None,
     ) -> None:
         await self.validate_broadcast_message_type(messages, node_type)
         for _, connection in self.all_connections.items():
@@ -635,8 +624,8 @@ class ChiaServer:
                 await connection.send_message(message)
 
     async def call_api_of_specific(
-        self, request_method: Callable[..., Awaitable[Optional[Message]]], message_data: Streamable, node_id: bytes32
-    ) -> Optional[Any]:
+        self, request_method: Callable[..., Awaitable[Message | None]], message_data: Streamable, node_id: bytes32
+    ) -> Any | None:
         if node_id in self.all_connections:
             connection = self.all_connections[node_id]
             return await connection.call_api(request_method, message_data)
@@ -644,7 +633,7 @@ class ChiaServer:
         return None
 
     def get_connections(
-        self, node_type: Optional[NodeType] = None, *, outbound: Optional[bool] = None
+        self, node_type: NodeType | None = None, *, outbound: bool | None = None
     ) -> list[WSChiaConnection]:
         result = []
         for _, connection in self.all_connections.items():
@@ -680,7 +669,7 @@ class ChiaServer:
             await self.webserver.await_closed()
             self.webserver = None
 
-    async def get_peer_info(self) -> Optional[PeerInfo]:
+    async def get_peer_info(self) -> PeerInfo | None:
         ip = None
 
         try:
@@ -749,3 +738,11 @@ class ChiaServer:
 
     def set_capabilities(self, capabilities: list[tuple[uint16, str]]) -> None:
         self._local_capabilities_for_handshake = capabilities
+
+    def ban_peer(self, host: str, ban_time: int) -> None:
+        ban_until: float = time.time() + ban_time
+        self.log.warning(f"Banning {host} for {ban_time} seconds")
+        if host in self.banned_peers:
+            self.banned_peers[host] = max(ban_until, self.banned_peers[host])
+        else:
+            self.banned_peers[host] = ban_until

chia/server/signal_handlers.py

@@ -8,7 +8,7 @@ import signal
 import sys
 from collections.abc import AsyncIterator
 from types import FrameType
-from typing import Optional, final
+from typing import final
 
 from typing_extensions import Protocol
 
@@ -19,7 +19,7 @@ class Handler(Protocol):
     def __call__(
         self,
         signal_: signal.Signals,
-        stack_frame: Optional[FrameType],
+        stack_frame: FrameType | None,
         loop: asyncio.AbstractEventLoop,
     ) -> None: ...
 
@@ -28,7 +28,7 @@ class AsyncHandler(Protocol):
     async def __call__(
         self,
         signal_: signal.Signals,
-        stack_frame: Optional[FrameType],
+        stack_frame: FrameType | None,
         loop: asyncio.AbstractEventLoop,
     ) -> None: ...
 
@@ -55,7 +55,7 @@ class SignalHandlers:
     def loop_safe_sync_signal_handler_for_async(
         self,
         signal_: signal.Signals,
-        stack_frame: Optional[FrameType],
+        stack_frame: FrameType | None,
         loop: asyncio.AbstractEventLoop,
         handler: AsyncHandler,
     ) -> None:
@@ -69,7 +69,7 @@ class SignalHandlers:
     def threadsafe_sync_signal_handler_for_async(
         self,
         signal_: signal.Signals,
-        stack_frame: Optional[FrameType],
+        stack_frame: FrameType | None,
         loop: asyncio.AbstractEventLoop,
         handler: AsyncHandler,
     ) -> None:
@@ -90,7 +90,7 @@ class SignalHandlers:
 
             def ensure_signal_object_not_int(
                 signal_: int,
-                stack_frame: Optional[FrameType],
+                stack_frame: FrameType | None,
                 *,
                 handler: Handler = handler,
                 loop: asyncio.AbstractEventLoop = loop,

chia/server/start_service.py

@@ -5,10 +5,10 @@ import contextlib
 import logging
 import os
 import signal
-from collections.abc import AsyncIterator, Awaitable, Coroutine
+from collections.abc import AsyncIterator, Awaitable, Callable, Coroutine
 from pathlib import Path
 from types import FrameType
-from typing import Any, Callable, Generic, Optional, TypeVar, cast
+from typing import Any, Generic, TypeVar, cast
 
 from chia_rs.sized_ints import uint16
 
@@ -16,7 +16,7 @@ from chia.daemon.server import service_launch_lock_path
 from chia.protocols.outbound_message import NodeType
 from chia.protocols.shared_protocol import default_capabilities
 from chia.rpc.rpc_server import RpcApiProtocol, RpcServer, RpcServiceProtocol, start_rpc_server
-from chia.server.api_protocol import ApiProtocol
+from chia.server.api_protocol import ApiMetadata, ApiProtocol
 from chia.server.chia_policy import set_chia_policy
 from chia.server.server import ChiaServer
 from chia.server.signal_handlers import SignalHandlers
@@ -33,7 +33,7 @@ from chia.util.task_referencer import create_referenced_task
 
 # this is used to detect whether we are running in the main process or not, in
 # signal handlers. We need to ignore signals in the sub processes.
-main_pid: Optional[int] = None
+main_pid: int | None = None
 
 T = TypeVar("T")
 _T_RpcServiceProtocol = TypeVar("_T_RpcServiceProtocol", bound=RpcServiceProtocol)
@@ -56,19 +56,19 @@ class Service(Generic[_T_RpcServiceProtocol, _T_ApiProtocol, _T_RpcApiProtocol])
         node: _T_RpcServiceProtocol,
         peer_api: _T_ApiProtocol,
         node_type: NodeType,
-        advertised_port: Optional[int],
+        advertised_port: int | None,
         service_name: str,
         network_id: str,
         *,
         config: dict[str, Any],
-        class_for_type: dict[NodeType, type[ApiProtocol]],
-        upnp_ports: Optional[list[int]] = None,
-        connect_peers: Optional[set[UnresolvedPeerInfo]] = None,
-        on_connect_callback: Optional[Callable[[WSChiaConnection], Awaitable[None]]] = None,
-        rpc_info: Optional[RpcInfo[_T_RpcApiProtocol]] = None,
+        stub_metadata_for_type: dict[NodeType, ApiMetadata],
+        upnp_ports: list[int] | None = None,
+        connect_peers: set[UnresolvedPeerInfo] | None = None,
+        on_connect_callback: Callable[[WSChiaConnection], Awaitable[None]] | None = None,
+        rpc_info: RpcInfo[_T_RpcApiProtocol] | None = None,
         connect_to_daemon: bool = True,
-        max_request_body_size: Optional[int] = None,
-        override_capabilities: Optional[list[tuple[uint16, str]]] = None,
+        max_request_body_size: int | None = None,
+        override_capabilities: list[tuple[uint16, str]] | None = None,
     ) -> None:
         if upnp_ports is None:
             upnp_ports = []
@@ -85,7 +85,7 @@ class Service(Generic[_T_RpcServiceProtocol, _T_ApiProtocol, _T_RpcApiProtocol])
         self._connect_to_daemon = connect_to_daemon
         self._node_type = node_type
         self._service_name = service_name
-        self.rpc_server: Optional[RpcServer[_T_RpcApiProtocol]] = None
+        self.rpc_server: RpcServer[_T_RpcApiProtocol] | None = None
         self._network_id: str = network_id
         self.max_request_body_size = max_request_body_size
         self.reconnect_retry_seconds: int = 3
@@ -123,7 +123,7 @@ class Service(Generic[_T_RpcServiceProtocol, _T_ApiProtocol, _T_RpcApiProtocol])
             self.service_config,
             (private_ca_crt, private_ca_key),
             (chia_ca_crt, chia_ca_key),
-            class_for_type=class_for_type,
+            stub_metadata_for_type=stub_metadata_for_type,
             name=f"{service_name}_server",
         )
         f = getattr(node, "set_server", None)
@@ -141,7 +141,7 @@ class Service(Generic[_T_RpcServiceProtocol, _T_ApiProtocol, _T_RpcApiProtocol])
         self._on_connect_callback = on_connect_callback
         self._advertised_port = advertised_port
         self._connect_peers = connect_peers
-        self._connect_peers_task: Optional[asyncio.Task[None]] = None
+        self._connect_peers_task: asyncio.Task[None] | None = None
         self.upnp: UPnP = UPnP()
         self.stop_requested = asyncio.Event()
 
@@ -287,7 +287,7 @@ class Service(Generic[_T_RpcServiceProtocol, _T_ApiProtocol, _T_RpcApiProtocol])
     def _accept_signal(
         self,
         signal_: signal.Signals,
-        stack_frame: Optional[FrameType],
+        stack_frame: FrameType | None,
         loop: asyncio.AbstractEventLoop,
     ) -> None:
         # we only handle signals in the main process. In the ProcessPoolExecutor
@@ -309,7 +309,7 @@ class Service(Generic[_T_RpcServiceProtocol, _T_ApiProtocol, _T_RpcApiProtocol])
         self.stop_requested.set()
 
 
-def async_run(coro: Coroutine[object, object, T], connection_limit: Optional[int] = None) -> T:
+def async_run(coro: Coroutine[object, object, T], connection_limit: int | None = None) -> T:
     with log_exceptions(log=log, message="fatal uncaught exception"):
         if connection_limit is not None:
             set_chia_policy(connection_limit)

chia/server/upnp.py

@@ -6,9 +6,7 @@ import threading
 from collections.abc import Iterator
 from dataclasses import dataclass, field
 from queue import Queue
-from typing import Optional, Union
-
-from typing_extensions import Literal
+from typing import Literal
 
 log = logging.getLogger(__name__)
 
@@ -23,11 +21,11 @@ except ImportError:
 
 @dataclass
 class UPnP:
-    _thread: Optional[threading.Thread] = None
-    _queue: Queue[Union[tuple[Literal["remap", "release"], int], tuple[Literal["shutdown"]]]] = field(
+    _thread: threading.Thread | None = None
+    _queue: Queue[tuple[Literal["remap", "release"], int] | tuple[Literal["shutdown"]]] = field(
         default_factory=Queue,
     )
-    _upnp: Optional[miniupnpc.UPnP] = None
+    _upnp: miniupnpc.UPnP | None = None
 
     @contextlib.contextmanager
     def manage(self, ports: list[int]) -> Iterator[None]: