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

chia/data_layer/data_layer.py

@@ -12,7 +12,7 @@ import time
 import traceback
 from collections.abc import AsyncIterator, Awaitable
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast, final
+from typing import TYPE_CHECKING, Any, ClassVar, cast, final
 
 import aiohttp
 from chia_rs.datalayer import ProofOfInclusion, ProofOfInclusionLayer
@@ -61,12 +61,15 @@ from chia.server.ws_connection import WSChiaConnection
 from chia.util.async_pool import Job, QueuedAsyncPool
 from chia.util.path import path_from_root
 from chia.util.task_referencer import create_referenced_task
+from chia.wallet.puzzle_drivers import Solver
 from chia.wallet.trade_record import TradeRecord
 from chia.wallet.trading.offer import Offer as TradingOffer
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.wallet_request_types import (
+    CancelOffer,
     CreateNewDL,
+    CreateOfferForIDs,
     DLDeleteMirror,
     DLGetMirrors,
     DLHistory,
@@ -77,8 +80,10 @@ from chia.wallet.wallet_request_types import (
     DLUpdateMultiple,
     DLUpdateMultipleUpdates,
     DLUpdateRoot,
+    GetOffer,
     LauncherRootPair,
     LogIn,
+    TakeOffer,
 )
 from chia.wallet.wallet_rpc_client import WalletRpcClient
 
@@ -129,14 +134,14 @@ class DataLayer:
     maximum_full_file_count: int
     server_files_location: Path
     unsubscribe_data_queue: list[UnsubscribeData]
-    _server: Optional[ChiaServer] = None
+    _server: ChiaServer | None = None
     none_bytes: bytes32 = bytes32.zeros
     initialized: bool = False
-    _data_store: Optional[DataStore] = None
-    state_changed_callback: Optional[StateChangedProtocol] = None
+    _data_store: DataStore | None = None
+    state_changed_callback: StateChangedProtocol | None = None
     _shut_down: bool = False
-    periodically_manage_data_task: Optional[asyncio.Task[None]] = None
-    _wallet_rpc: Optional[WalletRpcClient] = None
+    periodically_manage_data_task: asyncio.Task[None] | None = None
+    _wallet_rpc: WalletRpcClient | None = None
     subscription_lock: asyncio.Lock = dataclasses.field(default_factory=asyncio.Lock)
     subscription_update_concurrency: int = 5
     client_timeout: aiohttp.ClientTimeout = dataclasses.field(
@@ -179,7 +184,7 @@ class DataLayer:
         wallet_rpc_init: Awaitable[WalletRpcClient],
         downloaders: list[PluginRemote],
         uploaders: list[PluginRemote],  # dont add FilesystemUploader to this, it is the default uploader
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> DataLayer:
         if name == "":
             # TODO: If no code depends on "" counting as 'unspecified' then we do not
@@ -225,7 +230,7 @@ class DataLayer:
 
     @contextlib.asynccontextmanager
     async def manage(self) -> AsyncIterator[None]:
-        sql_log_path: Optional[Path] = None
+        sql_log_path: Path | None = None
         if self.config.get("log_sqlite_cmds", False):
             sql_log_path = path_from_root(self.root_path, "log/data_sql.log")
             self.log.info(f"logging SQL commands to {sql_log_path}")
@@ -264,7 +269,7 @@ class DataLayer:
     async def on_connect(self, connection: WSChiaConnection) -> None:
         pass
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
+    def get_connections(self, request_node_type: NodeType | None) -> list[dict[str, Any]]:
         return default_get_connections(server=self.server, request_node_type=request_node_type)
 
     def set_server(self, server: ChiaServer) -> None:
@@ -292,7 +297,7 @@ class DataLayer:
         changelist: list[dict[str, Any]],
         fee: uint64,
         submit_on_chain: bool = True,
-    ) -> Optional[TransactionRecord]:
+    ) -> TransactionRecord | None:
         status = Status.PENDING if submit_on_chain else Status.PENDING_BATCH
         await self.batch_insert(store_id=store_id, changelist=changelist, status=status)
 
@@ -302,7 +307,7 @@ class DataLayer:
             return None
 
     async def _get_publishable_root_hash(self, store_id: bytes32) -> bytes32:
-        pending_root: Optional[Root] = await self.data_store.get_pending_root(store_id=store_id)
+        pending_root: Root | None = await self.data_store.get_pending_root(store_id=store_id)
         if pending_root is None:
             raise Exception("Latest root is already confirmed.")
         if pending_root.status == Status.PENDING_BATCH:
@@ -348,7 +353,7 @@ class DataLayer:
     ) -> TransactionRecord:
         await self._update_confirmation_status(store_id=store_id)
 
-        pending_root: Optional[Root] = await self.data_store.get_pending_root(store_id=store_id)
+        pending_root: Root | None = await self.data_store.get_pending_root(store_id=store_id)
         if pending_root is None:
             raise Exception("Latest root is already confirmed.")
         if pending_root.status == Status.PENDING:
@@ -376,12 +381,12 @@ class DataLayer:
         store_id: bytes32,
         changelist: list[dict[str, Any]],
         status: Status = Status.PENDING,
-        enable_batch_autoinsert: Optional[bool] = None,
+        enable_batch_autoinsert: bool | None = None,
     ) -> bytes32:
         await self._update_confirmation_status(store_id=store_id)
 
         async with self.data_store.transaction():
-            pending_root: Optional[Root] = await self.data_store.get_pending_root(store_id=store_id)
+            pending_root: Root | None = await self.data_store.get_pending_root(store_id=store_id)
             if pending_root is not None and pending_root.status == Status.PENDING:
                 raise Exception("Already have a pending root waiting for confirmation.")
 
@@ -428,7 +433,7 @@ class DataLayer:
         self,
         store_id: bytes32,
         key: bytes,
-        root_hash: Union[bytes32, Unspecified] = unspecified,
+        root_hash: bytes32 | Unspecified = unspecified,
     ) -> bytes32:
         await self._update_confirmation_status(store_id=store_id)
 
@@ -436,9 +441,7 @@ class DataLayer:
             node = await self.data_store.get_node_by_key(store_id=store_id, key=key, root_hash=root_hash)
             return node.hash
 
-    async def get_value(
-        self, store_id: bytes32, key: bytes, root_hash: Union[bytes32, Unspecified] = unspecified
-    ) -> bytes:
+    async def get_value(self, store_id: bytes32, key: bytes, root_hash: bytes32 | Unspecified = unspecified) -> bytes:
         await self._update_confirmation_status(store_id=store_id)
 
         async with self.data_store.transaction():
@@ -449,7 +452,7 @@ class DataLayer:
     async def get_keys_values(
         self,
         store_id: bytes32,
-        root_hash: Union[bytes32, Unspecified],
+        root_hash: bytes32 | Unspecified,
     ) -> list[TerminalNode]:
         await self._update_confirmation_status(store_id=store_id)
 
@@ -461,9 +464,9 @@ class DataLayer:
     async def get_keys_values_paginated(
         self,
         store_id: bytes32,
-        root_hash: Union[bytes32, Unspecified],
+        root_hash: bytes32 | Unspecified,
         page: int,
-        max_page_size: Optional[int] = None,
+        max_page_size: int | None = None,
     ) -> KeysValuesPaginationData:
         await self._update_confirmation_status(store_id=store_id)
 
@@ -472,7 +475,7 @@ class DataLayer:
         res = await self.data_store.get_keys_values_paginated(store_id, page, max_page_size, root_hash)
         return res
 
-    async def get_keys(self, store_id: bytes32, root_hash: Union[bytes32, Unspecified]) -> list[bytes]:
+    async def get_keys(self, store_id: bytes32, root_hash: bytes32 | Unspecified) -> list[bytes]:
         await self._update_confirmation_status(store_id=store_id)
 
         res = await self.data_store.get_keys(store_id, root_hash)
@@ -481,9 +484,9 @@ class DataLayer:
     async def get_keys_paginated(
         self,
         store_id: bytes32,
-        root_hash: Union[bytes32, Unspecified],
+        root_hash: bytes32 | Unspecified,
         page: int,
-        max_page_size: Optional[int] = None,
+        max_page_size: int | None = None,
     ) -> KeysPaginationData:
         await self._update_confirmation_status(store_id=store_id)
 
@@ -500,13 +503,13 @@ class DataLayer:
             self.log.error("Failed to get ancestors")
         return res
 
-    async def get_root(self, store_id: bytes32) -> Optional[SingletonRecord]:
+    async def get_root(self, store_id: bytes32) -> SingletonRecord | None:
         latest = (await self.wallet_rpc.dl_latest_singleton(DLLatestSingleton(store_id, True))).singleton
         if latest is None:
             self.log.error(f"Failed to get root for {store_id.hex()}")
         return latest
 
-    async def get_local_root(self, store_id: bytes32) -> Optional[bytes32]:
+    async def get_local_root(self, store_id: bytes32) -> bytes32 | None:
         await self._update_confirmation_status(store_id=store_id)
 
         res = await self.data_store.get_tree_root(store_id=store_id)
@@ -520,7 +523,7 @@ class DataLayer:
         if records is None:
             self.log.error(f"Failed to get root history for {store_id.hex()}")
         root_history = []
-        prev: Optional[SingletonRecord] = None
+        prev: SingletonRecord | None = None
         for record in records:
             if prev is None or record.root != prev.root:
                 root_history.append(record)
@@ -688,7 +691,7 @@ class DataLayer:
                     )
                     self.log.info(f"Successfully written full tree filename {filename_full_tree}.")
 
-    async def get_downloader(self, store_id: bytes32, url: str) -> Optional[PluginRemote]:
+    async def get_downloader(self, store_id: bytes32, url: str) -> PluginRemote | None:
         request_json = {"store_id": store_id.hex(), "url": url}
         for d in self.downloaders:
             async with aiohttp.ClientSession() as session:
@@ -787,7 +790,7 @@ class DataLayer:
             publish_generation -= 1
             root = await self.data_store.get_tree_root(store_id=store_id, generation=publish_generation)
 
-    async def add_missing_files(self, store_id: bytes32, overwrite: bool, foldername: Optional[Path]) -> None:
+    async def add_missing_files(self, store_id: bytes32, overwrite: bool, foldername: Path | None) -> None:
         root = await self.data_store.get_tree_root(store_id=store_id)
         latest_generation = root.generation
         full_tree_first_publish_generation = max(0, latest_generation - self.maximum_full_file_count + 1)
@@ -937,7 +940,7 @@ class DataLayer:
         hash_1: bytes32,
         hash_2: bytes32,
         page: int,
-        max_page_size: Optional[int] = None,
+        max_page_size: int | None = None,
     ) -> KVDiffPaginationData:
         if max_page_size is None:
             max_page_size = 40 * 1024 * 1024
@@ -1148,34 +1151,38 @@ class DataLayer:
         async with self.data_store.transaction():
             our_store_proofs = await self.process_offered_stores(offer_stores=maker)
 
-            offer_dict: dict[Union[uint32, str], int] = {
-                **{offer_store.store_id.hex(): -1 for offer_store in maker},
-                **{offer_store.store_id.hex(): 1 for offer_store in taker},
+            offer_dict: dict[str, str] = {
+                **{offer_store.store_id.hex(): "-1" for offer_store in maker},
+                **{offer_store.store_id.hex(): "1" for offer_store in taker},
             }
 
-            solver: dict[str, Any] = {
-                "0x" + our_offer_store.store_id.hex(): {
-                    "new_root": "0x" + our_store_proofs[our_offer_store.store_id].proofs[0].root().hex(),
-                    "dependencies": [
-                        {
-                            "launcher_id": "0x" + their_offer_store.store_id.hex(),
-                            "values_to_prove": [
-                                "0x" + leaf_hash(key=entry.key, value=entry.value).hex()
-                                for entry in their_offer_store.inclusions
-                            ],
-                        }
-                        for their_offer_store in taker
-                    ],
+            solver = Solver(
+                {
+                    "0x" + our_offer_store.store_id.hex(): {
+                        "new_root": "0x" + our_store_proofs[our_offer_store.store_id].proofs[0].root().hex(),
+                        "dependencies": [
+                            {
+                                "launcher_id": "0x" + their_offer_store.store_id.hex(),
+                                "values_to_prove": [
+                                    "0x" + leaf_hash(key=entry.key, value=entry.value).hex()
+                                    for entry in their_offer_store.inclusions
+                                ],
+                            }
+                            for their_offer_store in taker
+                        ],
+                    }
+                    for our_offer_store in maker
                 }
-                for our_offer_store in maker
-            }
+            )
 
             res = await self.wallet_rpc.create_offer_for_ids(
-                offer_dict=offer_dict,
-                solver=solver,
-                driver_dict={},
-                fee=fee,
-                validate_only=False,
+                CreateOfferForIDs(
+                    offer=offer_dict,
+                    solver=solver,
+                    driver_dict={},
+                    fee=fee,
+                    validate_only=False,
+                ),
                 # TODO: probably shouldn't be default but due to peculiarities in the RPC, we're using a stop gap.
                 # This is not a change in behavior, the default was already implicit.
                 tx_config=DEFAULT_TX_CONFIG,
@@ -1235,22 +1242,26 @@ class DataLayer:
                         )
                     )
 
-            solver: dict[str, Any] = {
-                "proofs_of_inclusion": proofs_of_inclusion,
-                **{
-                    "0x" + our_offer_store.store_id.hex(): {
-                        "new_root": "0x" + root.hex(),
-                        "dependencies": [
-                            {
-                                "launcher_id": "0x" + their_offer_store.store_id.hex(),
-                                "values_to_prove": ["0x" + entry.node_hash.hex() for entry in their_offer_store.proofs],
-                            }
-                            for their_offer_store in maker
-                        ],
-                    }
-                    for our_offer_store in taker
-                },
-            }
+            solver = Solver(
+                {
+                    "proofs_of_inclusion": proofs_of_inclusion,
+                    **{
+                        "0x" + our_offer_store.store_id.hex(): {
+                            "new_root": "0x" + root.hex(),
+                            "dependencies": [
+                                {
+                                    "launcher_id": "0x" + their_offer_store.store_id.hex(),
+                                    "values_to_prove": [
+                                        "0x" + entry.node_hash.hex() for entry in their_offer_store.proofs
+                                    ],
+                                }
+                                for their_offer_store in maker
+                            ],
+                        }
+                        for our_offer_store in taker
+                    },
+                }
+            )
 
         # Excluding wallet from transaction since failures in the wallet may occur
         # after the transaction is submitted to the chain.  If we roll back data we
@@ -1258,9 +1269,7 @@ class DataLayer:
 
         trade_record = (
             await self.wallet_rpc.take_offer(
-                offer=offer,
-                solver=solver,
-                fee=fee,
+                TakeOffer(offer=offer.to_bech32(), solver=solver, fee=fee, push=True),
                 # TODO: probably shouldn't be default but due to peculiarities in the RPC, we're using a stop gap.
                 # This is not a change in behavior, the default was already implicit.
                 tx_config=DEFAULT_TX_CONFIG,
@@ -1273,15 +1282,15 @@ class DataLayer:
         store_ids: list[bytes32] = []
 
         if not secure:
-            trade_record = await self.wallet_rpc.get_offer(trade_id=trade_id, file_contents=True)
+            trade_record = (
+                await self.wallet_rpc.get_offer(GetOffer(trade_id=trade_id, file_contents=True))
+            ).trade_record
             trading_offer = TradingOffer.from_bytes(trade_record.offer)
             summary = await DataLayerWallet.get_offer_summary(offer=trading_offer)
-            store_ids = [bytes32.from_hexstr(offered["launcher_id"]) for offered in summary["offered"]]
+            store_ids = [offered.launcher_id for offered in summary.offered]
 
         await self.wallet_rpc.cancel_offer(
-            trade_id=trade_id,
-            secure=secure,
-            fee=fee,
+            CancelOffer(trade_id=trade_id, secure=secure, fee=fee, push=True),
             # TODO: probably shouldn't be default but due to peculiarities in the RPC, we're using a stop gap.
             # This is not a change in behavior, the default was already implicit.
             tx_config=DEFAULT_TX_CONFIG,

chia/data_layer/data_layer_rpc_api.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import dataclasses
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint64
@@ -137,7 +137,7 @@ class DataLayerRpcApi:
             "/verify_proof": self.verify_proof,
         }
 
-    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]]) -> list[WsRpcMessage]:
+    async def _state_changed(self, change: str, change_data: dict[str, Any] | None) -> list[WsRpcMessage]:
         return []
 
     async def wallet_log_in(self, request: dict[str, Any]) -> EndpointResult:
@@ -168,8 +168,8 @@ class DataLayerRpcApi:
         store_id = bytes32.from_hexstr(request["id"])
         key = hexstr_to_bytes(request["key"])
         # NOTE: being outside the rpc, this retains the none-means-unspecified semantics
-        root_hash: Optional[str] = request.get("root_hash")
-        resolved_root_hash: Union[bytes32, Unspecified]
+        root_hash: str | None = request.get("root_hash")
+        resolved_root_hash: bytes32 | Unspecified
         if root_hash is not None:
             resolved_root_hash = bytes32.from_hexstr(root_hash)
         else:
@@ -185,10 +185,10 @@ class DataLayerRpcApi:
     async def get_keys(self, request: dict[str, Any]) -> EndpointResult:
         store_id = bytes32.from_hexstr(request["id"])
         # NOTE: being outside the rpc, this retains the none-means-unspecified semantics
-        root_hash: Optional[str] = request.get("root_hash")
+        root_hash: str | None = request.get("root_hash")
         page = request.get("page", None)
         max_page_size = request.get("max_page_size", None)
-        resolved_root_hash: Union[bytes32, Unspecified]
+        resolved_root_hash: bytes32 | Unspecified
         if root_hash is not None:
             resolved_root_hash = bytes32.from_hexstr(root_hash)
         else:
@@ -222,10 +222,10 @@ class DataLayerRpcApi:
     async def get_keys_values(self, request: dict[str, Any]) -> EndpointResult:
         store_id = bytes32.from_hexstr(request["id"])
         # NOTE: being outside the rpc, this retains the none-means-unspecified semantics
-        root_hash: Optional[str] = request.get("root_hash")
+        root_hash: str | None = request.get("root_hash")
         page = request.get("page", None)
         max_page_size = request.get("max_page_size", None)
-        resolved_root_hash: Union[bytes32, Unspecified]
+        resolved_root_hash: bytes32 | Unspecified
         if root_hash is not None:
             resolved_root_hash = bytes32.from_hexstr(root_hash)
         else:
@@ -445,7 +445,7 @@ class DataLayerRpcApi:
             subscriptions: list[Subscription] = await self.service.get_subscriptions()
             ids_bytes = [subscription.store_id for subscription in subscriptions]
         overwrite = request.get("overwrite", False)
-        foldername: Optional[Path] = None
+        foldername: Path | None = None
         if "foldername" in request:
             foldername = Path(request["foldername"])
         for store_id in ids_bytes:

chia/data_layer/data_layer_rpc_client.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
@@ -11,7 +11,7 @@ from chia.rpc.rpc_client import RpcClient
 
 
 class DataLayerRpcClient(RpcClient):
-    async def create_data_store(self, fee: Optional[uint64], verbose: bool) -> dict[str, Any]:
+    async def create_data_store(self, fee: uint64 | None, verbose: bool) -> dict[str, Any]:
         response = await self.fetch("create_data_store", {"fee": fee, "verbose": verbose})
         return response
 
@@ -20,7 +20,7 @@ class DataLayerRpcClient(RpcClient):
         response = await self.fetch("wallet_log_in", request)
         return response
 
-    async def get_value(self, store_id: bytes32, key: bytes, root_hash: Optional[bytes32]) -> dict[str, Any]:
+    async def get_value(self, store_id: bytes32, key: bytes, root_hash: bytes32 | None) -> dict[str, Any]:
         request: dict[str, Any] = {"id": store_id.hex(), "key": key.hex()}
         if root_hash is not None:
             request["root_hash"] = root_hash.hex()
@@ -28,7 +28,7 @@ class DataLayerRpcClient(RpcClient):
         return response
 
     async def update_data_store(
-        self, store_id: bytes32, changelist: list[dict[str, str]], fee: Optional[uint64], submit_on_chain: bool = True
+        self, store_id: bytes32, changelist: list[dict[str, str]], fee: uint64 | None, submit_on_chain: bool = True
     ) -> dict[str, Any]:
         response = await self.fetch(
             "batch_update",
@@ -42,7 +42,7 @@ class DataLayerRpcClient(RpcClient):
         return response
 
     async def update_multiple_stores(
-        self, store_updates: list[dict[str, Any]], fee: Optional[uint64], submit_on_chain: bool = True
+        self, store_updates: list[dict[str, Any]], fee: uint64 | None, submit_on_chain: bool = True
     ) -> dict[str, Any]:
         response = await self.fetch(
             "multistore_batch_update",
@@ -54,16 +54,16 @@ class DataLayerRpcClient(RpcClient):
         )
         return response
 
-    async def submit_pending_root(self, store_id: bytes32, fee: Optional[uint64]) -> dict[str, Any]:
+    async def submit_pending_root(self, store_id: bytes32, fee: uint64 | None) -> dict[str, Any]:
         response = await self.fetch("submit_pending_root", {"id": store_id.hex(), "fee": fee})
         return response
 
-    async def submit_all_pending_roots(self, fee: Optional[uint64]) -> dict[str, Any]:
+    async def submit_all_pending_roots(self, fee: uint64 | None) -> dict[str, Any]:
         response = await self.fetch("submit_all_pending_roots", {"fee": fee})
         return response
 
     async def get_keys_values(
-        self, store_id: bytes32, root_hash: Optional[bytes32], page: Optional[int], max_page_size: Optional[int]
+        self, store_id: bytes32, root_hash: bytes32 | None, page: int | None, max_page_size: int | None
     ) -> dict[str, Any]:
         request: dict[str, Any] = {"id": store_id.hex()}
         if root_hash is not None:
@@ -76,7 +76,7 @@ class DataLayerRpcClient(RpcClient):
         return response
 
     async def get_keys(
-        self, store_id: bytes32, root_hash: Optional[bytes32], page: Optional[int], max_page_size: Optional[int]
+        self, store_id: bytes32, root_hash: bytes32 | None, page: int | None, max_page_size: int | None
     ) -> dict[str, Any]:
         request: dict[str, Any] = {"id": store_id.hex()}
         if root_hash is not None:
@@ -117,7 +117,7 @@ class DataLayerRpcClient(RpcClient):
         return response
 
     async def add_missing_files(
-        self, store_ids: Optional[list[bytes32]], overwrite: Optional[bool], foldername: Optional[Path]
+        self, store_ids: list[bytes32] | None, overwrite: bool | None, foldername: Path | None
     ) -> dict[str, Any]:
         request: dict[str, Any] = {}
         if store_ids is not None:
@@ -130,7 +130,7 @@ class DataLayerRpcClient(RpcClient):
         return response
 
     async def get_kv_diff(
-        self, store_id: bytes32, hash_1: bytes32, hash_2: bytes32, page: Optional[int], max_page_size: Optional[int]
+        self, store_id: bytes32, hash_1: bytes32, hash_2: bytes32, page: int | None, max_page_size: int | None
     ) -> dict[str, Any]:
         request: dict[str, Any] = {"id": store_id.hex(), "hash_1": hash_1.hex(), "hash_2": hash_2.hex()}
         if page is not None:
@@ -144,13 +144,11 @@ class DataLayerRpcClient(RpcClient):
         response = await self.fetch("get_root_history", {"id": store_id.hex()})
         return response
 
-    async def add_mirror(
-        self, store_id: bytes32, urls: list[str], amount: int, fee: Optional[uint64]
-    ) -> dict[str, Any]:
+    async def add_mirror(self, store_id: bytes32, urls: list[str], amount: int, fee: uint64 | None) -> dict[str, Any]:
         response = await self.fetch("add_mirror", {"id": store_id.hex(), "urls": urls, "amount": amount, "fee": fee})
         return response
 
-    async def delete_mirror(self, coin_id: bytes32, fee: Optional[uint64]) -> dict[str, Any]:
+    async def delete_mirror(self, coin_id: bytes32, fee: uint64 | None) -> dict[str, Any]:
         response = await self.fetch("delete_mirror", {"coin_id": coin_id.hex(), "fee": fee})
         return response
 

chia/data_layer/data_layer_server.py

@@ -7,7 +7,7 @@ import sys
 from dataclasses import dataclass, field
 from pathlib import Path
 from types import FrameType
-from typing import Any, Optional
+from typing import Any
 
 import click
 from aiohttp import web
@@ -38,7 +38,7 @@ class DataLayerServer:
     config: dict[str, Any]
     log: logging.Logger
     shutdown_event: asyncio.Event
-    webserver: Optional[WebServer] = None
+    webserver: WebServer | None = None
     upnp: UPnP = field(default_factory=UPnP)
 
     async def start(self, signal_handlers: SignalHandlers) -> None:
@@ -120,7 +120,7 @@ class DataLayerServer:
     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)