chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.5.8rc1__py3-none-any.whl

chia/daemon/keychain_proxy.py

@@ -5,7 +5,7 @@ import logging
 import ssl
 import traceback
 from pathlib import Path
-from typing import Any, Literal, Optional, Union, overload
+from typing import Any, Literal, overload
 
 from aiohttp import ClientConnectorError, ClientSession
 from chia_rs import AugSchemeMPL, G1Element, PrivateKey
@@ -47,10 +47,10 @@ class KeychainProxy(DaemonProxy):
         self,
         log: logging.Logger,
         uri: str = "",
-        ssl_context: Optional[ssl.SSLContext] = None,
-        local_keychain: Optional[Keychain] = None,
-        user: Optional[str] = None,
-        service: Optional[str] = None,
+        ssl_context: ssl.SSLContext | None = None,
+        local_keychain: Keychain | None = None,
+        user: str | None = None,
+        service: str | None = None,
         heartbeat: int = 300,
     ):
         super().__init__(uri, ssl_context, heartbeat=heartbeat)
@@ -62,7 +62,7 @@ class KeychainProxy(DaemonProxy):
         self.keychain_user = user
         self.keychain_service = service
         # these are used to track and close the keychain connection
-        self.keychain_connection_task: Optional[asyncio.Task[None]] = None
+        self.keychain_connection_task: asyncio.Task[None] | None = None
         self.shut_down: bool = False
         self.connection_established: asyncio.Event = asyncio.Event()
 
@@ -175,26 +175,24 @@ class KeychainProxy(DaemonProxy):
     async def add_key(self, mnemonic_or_pk: str) -> PrivateKey: ...
 
     @overload
-    async def add_key(self, mnemonic_or_pk: str, label: Optional[str]) -> PrivateKey: ...
+    async def add_key(self, mnemonic_or_pk: str, label: str | None) -> PrivateKey: ...
 
     @overload
-    async def add_key(self, mnemonic_or_pk: str, label: Optional[str], private: Literal[True]) -> PrivateKey: ...
+    async def add_key(self, mnemonic_or_pk: str, label: str | None, private: Literal[True]) -> PrivateKey: ...
 
     @overload
-    async def add_key(self, mnemonic_or_pk: str, label: Optional[str], private: Literal[False]) -> G1Element: ...
+    async def add_key(self, mnemonic_or_pk: str, label: str | None, private: Literal[False]) -> G1Element: ...
 
     @overload
-    async def add_key(
-        self, mnemonic_or_pk: str, label: Optional[str], private: bool
-    ) -> Union[PrivateKey, G1Element]: ...
+    async def add_key(self, mnemonic_or_pk: str, label: str | None, private: bool) -> PrivateKey | G1Element: ...
 
     async def add_key(
-        self, mnemonic_or_pk: str, label: Optional[str] = None, private: bool = True
-    ) -> Union[PrivateKey, G1Element]:
+        self, mnemonic_or_pk: str, label: str | None = None, private: bool = True
+    ) -> PrivateKey | G1Element:
         """
         Forwards to Keychain.add_key()
         """
-        key: Union[PrivateKey, G1Element]
+        key: PrivateKey | G1Element
         if self.use_local_keychain():
             key = self.keychain.add_key(mnemonic_or_pk, label, private)
         else:
@@ -290,11 +288,11 @@ class KeychainProxy(DaemonProxy):
 
         return keys
 
-    async def get_first_private_key(self) -> Optional[PrivateKey]:
+    async def get_first_private_key(self) -> PrivateKey | None:
         """
         Forwards to Keychain.get_first_private_key()
         """
-        key: Optional[PrivateKey] = None
+        key: PrivateKey | None = None
         if self.use_local_keychain():
             sk_ent = self.keychain.get_first_private_key()
             if sk_ent:
@@ -329,30 +327,26 @@ class KeychainProxy(DaemonProxy):
         return key
 
     @overload
-    async def get_key_for_fingerprint(self, fingerprint: Optional[int]) -> Optional[PrivateKey]: ...
+    async def get_key_for_fingerprint(self, fingerprint: int | None) -> PrivateKey | None: ...
 
     @overload
-    async def get_key_for_fingerprint(
-        self, fingerprint: Optional[int], private: Literal[True]
-    ) -> Optional[PrivateKey]: ...
+    async def get_key_for_fingerprint(self, fingerprint: int | None, private: Literal[True]) -> PrivateKey | None: ...
 
     @overload
-    async def get_key_for_fingerprint(
-        self, fingerprint: Optional[int], private: Literal[False]
-    ) -> Optional[G1Element]: ...
+    async def get_key_for_fingerprint(self, fingerprint: int | None, private: Literal[False]) -> G1Element | None: ...
 
     @overload
     async def get_key_for_fingerprint(
-        self, fingerprint: Optional[int], private: bool
-    ) -> Optional[Union[PrivateKey, G1Element]]: ...
+        self, fingerprint: int | None, private: bool
+    ) -> PrivateKey | G1Element | None: ...
 
     async def get_key_for_fingerprint(
-        self, fingerprint: Optional[int], private: bool = True
-    ) -> Optional[Union[PrivateKey, G1Element]]:
+        self, fingerprint: int | None, private: bool = True
+    ) -> PrivateKey | G1Element | None:
         """
         Locates and returns a private key matching the provided fingerprint
         """
-        key: Optional[Union[PrivateKey, G1Element]] = None
+        key: PrivateKey | G1Element | None = None
         if self.use_local_keychain():
             keys = self.keychain.get_keys(include_secrets=private)
             if len(keys) == 0:
@@ -404,11 +398,11 @@ class KeychainProxy(DaemonProxy):
 
         return key
 
-    async def get_key(self, fingerprint: int, include_secrets: bool = False) -> Optional[KeyData]:
+    async def get_key(self, fingerprint: int, include_secrets: bool = False) -> KeyData | None:
         """
         Locates and returns KeyData matching the provided fingerprint
         """
-        key_data: Optional[KeyData] = None
+        key_data: KeyData | None = None
         if self.use_local_keychain():
             key_data = self.keychain.get_key(fingerprint, include_secrets)
         else:
@@ -449,10 +443,10 @@ async def connect_to_keychain(
     self_hostname: str,
     daemon_port: int,
     daemon_heartbeat: int,
-    ssl_context: Optional[ssl.SSLContext],
+    ssl_context: ssl.SSLContext | None,
     log: logging.Logger,
-    user: Optional[str] = None,
-    service: Optional[str] = None,
+    user: str | None = None,
+    service: str | None = None,
 ) -> KeychainProxy:
     """
     Connect to the local daemon.
@@ -475,9 +469,9 @@ async def connect_to_keychain(
 async def connect_to_keychain_and_validate(
     root_path: Path,
     log: logging.Logger,
-    user: Optional[str] = None,
-    service: Optional[str] = None,
-) -> Optional[KeychainProxy]:
+    user: str | None = None,
+    service: str | None = None,
+) -> KeychainProxy | None:
     """
     Connect to the local daemon and do a ping to ensure that something is really
     there and running.

chia/daemon/server.py

@@ -18,7 +18,7 @@ from contextlib import asynccontextmanager
 from enum import Enum
 from pathlib import Path
 from types import FrameType
-from typing import Any, Optional, TextIO
+from typing import Any, TextIO
 
 from chia_rs import G1Element
 from chia_rs.sized_ints import uint32
@@ -141,7 +141,7 @@ class Command(Protocol):
     async def __call__(self, websocket: WebSocketResponse, request: dict[str, Any]) -> dict[str, Any]: ...
 
 
-def _get_keys_by_fingerprints(fingerprints: Optional[list[uint32]]) -> tuple[list[KeyData], set[uint32]]:
+def _get_keys_by_fingerprints(fingerprints: list[uint32] | None) -> tuple[list[KeyData], set[uint32]]:
     all_keys = Keychain().get_keys(include_secrets=True)
     missing_fingerprints = set()
 
@@ -189,41 +189,40 @@ class WebSocketServer:
         self.services: dict[str, list[subprocess.Popen]] = dict()
         self.plots_queue: list[dict] = []
         self.connections: dict[str, set[WebSocketResponse]] = dict()  # service name : {WebSocketResponse}
-        self.ping_job: Optional[asyncio.Task] = None
+        self.ping_job: asyncio.Task | None = None
         self.net_config = load_config(root_path, "config.yaml")
         self.self_hostname = self.net_config["self_hostname"]
         self.daemon_port = self.net_config["daemon_port"]
         self.daemon_max_message_size = self.net_config.get("daemon_max_message_size", 50 * 1000 * 1000)
         self.heartbeat = self.net_config.get("daemon_heartbeat", 300)
-        self.webserver: Optional[WebServer] = None
+        self.webserver: WebServer | None = None
         self.ssl_context = ssl_context_for_server(ca_crt_path, ca_key_path, crt_path, key_path, log=self.log)
         self.keychain_server = KeychainServer()
         self.run_check_keys_on_unlock = run_check_keys_on_unlock
         self.shutdown_event = asyncio.Event()
         self.state_changed_msg_queue: asyncio.Queue[StatusMessage] = asyncio.Queue()
-        self.state_changed_task: Optional[asyncio.Task] = None
+        self.state_changed_task: asyncio.Task | None = None
 
     @asynccontextmanager
     async def run(self) -> AsyncIterator[None]:
         self.log.info(f"Starting Daemon Server ({self.self_hostname}:{self.daemon_port})")
 
-        # Note: the minimum_version has been already set to TLSv1_2
+        # Note: the minimum_version has been already set to TLSv1_3
         # in ssl_context_for_server()
-        # Daemon is internal connections, so override to TLSv1_3 only unless specified in the config
-        if ssl.HAS_TLSv1_3 and not self.net_config.get("daemon_allow_tls_1_2", False):
-            try:
-                self.ssl_context.minimum_version = ssl.TLSVersion.TLSv1_3
-            except ValueError:
-                # in case the attempt above confused the config, set it again (likely not needed but doesn't hurt)
-                self.ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2
-
-        if self.ssl_context.minimum_version is not ssl.TLSVersion.TLSv1_3:
-            self.log.warning(
-                (
-                    "Deprecation Warning: Your version of SSL (%s) does not support TLS1.3. "
-                    "A future version of Chia will require TLS1.3."
-                ),
-                ssl.OPENSSL_VERSION,
+        # Daemon is internal connections, so override to TLSv1_2 only if specified in the config
+        if self.net_config.get("daemon_allow_tls_1_2", False):
+            self.ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2
+            self.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"
             )
 
         self.state_changed_task = create_referenced_task(self._process_state_changed_queue())
@@ -249,7 +248,7 @@ class WebSocketServer:
     async def _accept_signal(
         self,
         signal_: signal.Signals,
-        stack_frame: Optional[FrameType],
+        stack_frame: FrameType | None,
         loop: asyncio.AbstractEventLoop,
     ) -> None:
         self.log.info("Received signal %s (%s), shutting down.", signal_.name, signal_.value)
@@ -408,7 +407,7 @@ class WebSocketServer:
 
     async def handle_message(
         self, websocket: WebSocketResponse, message: WsRpcMessage
-    ) -> Optional[tuple[str, set[WebSocketResponse]]]:
+    ) -> tuple[str, set[WebSocketResponse]] | None:
         """
         This function gets called when new message is received via websocket.
         """
@@ -519,8 +518,8 @@ class WebSocketServer:
 
     async def unlock_keyring(self, websocket: WebSocketResponse, request: dict[str, Any]) -> dict[str, Any]:
         success: bool = False
-        error: Optional[str] = None
-        key: Optional[str] = request.get("key", None)
+        error: str | None = None
+        key: str | None = request.get("key", None)
         if type(key) is not str:
             return {"success": False, "error": "missing key"}
 
@@ -555,8 +554,8 @@ class WebSocketServer:
         request: dict[str, Any],
     ) -> dict[str, Any]:
         success: bool = False
-        error: Optional[str] = None
-        key: Optional[str] = request.get("key", None)
+        error: str | None = None
+        key: str | None = request.get("key", None)
         if type(key) is not str:
             return {"success": False, "error": "missing key"}
 
@@ -572,10 +571,10 @@ class WebSocketServer:
 
     async def set_keyring_passphrase(self, websocket: WebSocketResponse, request: dict[str, Any]) -> dict[str, Any]:
         success: bool = False
-        error: Optional[str] = None
-        current_passphrase: Optional[str] = None
-        new_passphrase: Optional[str] = None
-        passphrase_hint: Optional[str] = request.get("passphrase_hint", None)
+        error: str | None = None
+        current_passphrase: str | None = None
+        new_passphrase: str | None = None
+        passphrase_hint: str | None = request.get("passphrase_hint", None)
         save_passphrase: bool = request.get("save_passphrase", False)
 
         if using_default_passphrase():
@@ -616,8 +615,8 @@ class WebSocketServer:
 
     async def remove_keyring_passphrase(self, websocket: WebSocketResponse, request: dict[str, Any]) -> dict[str, Any]:
         success: bool = False
-        error: Optional[str] = None
-        current_passphrase: Optional[str] = None
+        error: str | None = None
+        current_passphrase: str | None = None
 
         if not Keychain.has_master_passphrase():
             return {"success": False, "error": "passphrase not set"}

chia/daemon/windows_signal.py

@@ -8,11 +8,12 @@ from __future__ import annotations
 import os
 import signal
 import sys
+from collections.abc import Callable
 from types import FrameType
-from typing import Any, Callable, Optional, Union
+from typing import Any
 
 # https://github.com/python/typeshed/blob/fbddd2c4e2b746f1880399ed0cb31a44d6ede6ff/stdlib/signal.pyi
-_HANDLER = Union[Callable[[int, Optional[FrameType]], Any], int, signal.Handlers, None]
+_HANDLER = Callable[[int, FrameType | None], Any] | int | signal.Handlers | None
 
 if sys.platform != "win32" and sys.platform != "cygwin":
     kill = os.kill
@@ -39,7 +40,7 @@ else:
             event = threading.Event()
             callable_handler = handler
 
-            def handler_set_event(signum: int, frame: Optional[FrameType]) -> Any:
+            def handler_set_event(signum: int, frame: FrameType | None) -> Any:
                 event.set()
                 return callable_handler(signum, frame)