chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/protocols/wallet_protocol.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import IntEnum
-from typing import List, Optional, Tuple
+from typing import Optional
 
 import chia_rs
 
@@ -100,7 +100,7 @@ class RejectHeaderRequest(Streamable):
 class RequestRemovals(Streamable):
     height: uint32
     header_hash: bytes32
-    coin_names: Optional[List[bytes32]]
+    coin_names: Optional[list[bytes32]]
 
 
 @streamable
@@ -108,8 +108,8 @@ class RequestRemovals(Streamable):
 class RespondRemovals(Streamable):
     height: uint32
     header_hash: bytes32
-    coins: List[Tuple[bytes32, Optional[Coin]]]
-    proofs: Optional[List[Tuple[bytes32, bytes]]]
+    coins: list[tuple[bytes32, Optional[Coin]]]
+    proofs: Optional[list[tuple[bytes32, bytes]]]
 
 
 @streamable
@@ -124,7 +124,7 @@ class RejectRemovalsRequest(Streamable):
 class RequestAdditions(Streamable):
     height: uint32
     header_hash: Optional[bytes32]
-    puzzle_hashes: Optional[List[bytes32]]
+    puzzle_hashes: Optional[list[bytes32]]
 
 
 @streamable
@@ -132,8 +132,8 @@ class RequestAdditions(Streamable):
 class RespondAdditions(Streamable):
     height: uint32
     header_hash: bytes32
-    coins: List[Tuple[bytes32, List[Coin]]]
-    proofs: Optional[List[Tuple[bytes32, bytes, Optional[bytes]]]]
+    coins: list[tuple[bytes32, list[Coin]]]
+    proofs: Optional[list[tuple[bytes32, bytes, Optional[bytes]]]]
 
 
 @streamable
@@ -148,7 +148,7 @@ class RejectAdditionsRequest(Streamable):
 class RespondBlockHeaders(Streamable):
     start_height: uint32
     end_height: uint32
-    header_blocks: List[HeaderBlock]
+    header_blocks: list[HeaderBlock]
 
 
 @streamable
@@ -185,7 +185,7 @@ class RejectHeaderBlocks(Streamable):
 class RespondHeaderBlocks(Streamable):
     start_height: uint32
     end_height: uint32
-    header_blocks: List[HeaderBlock]
+    header_blocks: list[HeaderBlock]
 
 
 # This class is implemented in Rust
@@ -200,7 +200,7 @@ class RespondHeaderBlocks(Streamable):
 @streamable
 @dataclass(frozen=True)
 class RegisterForPhUpdates(Streamable):
-    puzzle_hashes: List[bytes32]
+    puzzle_hashes: list[bytes32]
     min_height: uint32
 
 
@@ -208,24 +208,24 @@ class RegisterForPhUpdates(Streamable):
 # @streamable
 # @dataclass(frozen=True)
 # class RespondToPhUpdates(Streamable):
-#    puzzle_hashes: List[bytes32]
+#    puzzle_hashes: list[bytes32]
 #    min_height: uint32
-#    coin_states: List[CoinState]
+#    coin_states: list[CoinState]
 
 
 @streamable
 @dataclass(frozen=True)
 class RegisterForCoinUpdates(Streamable):
-    coin_ids: List[bytes32]
+    coin_ids: list[bytes32]
     min_height: uint32
 
 
 @streamable
 @dataclass(frozen=True)
 class RespondToCoinUpdates(Streamable):
-    coin_ids: List[bytes32]
+    coin_ids: list[bytes32]
     min_height: uint32
-    coin_states: List[CoinState]
+    coin_states: list[CoinState]
 
 
 @streamable
@@ -234,7 +234,7 @@ class CoinStateUpdate(Streamable):
     height: uint32
     fork_height: uint32
     peak_hash: bytes32
-    items: List[CoinState]
+    items: list[CoinState]
 
 
 @streamable
@@ -246,7 +246,7 @@ class RequestChildren(Streamable):
 @streamable
 @dataclass(frozen=True)
 class RespondChildren(Streamable):
-    coin_states: List[CoinState]
+    coin_states: list[CoinState]
 
 
 @streamable
@@ -259,18 +259,18 @@ class RequestSESInfo(Streamable):
 @streamable
 @dataclass(frozen=True)
 class RespondSESInfo(Streamable):
-    reward_chain_hash: List[bytes32]
-    heights: List[List[uint32]]
+    reward_chain_hash: list[bytes32]
+    heights: list[list[uint32]]
 
 
 @streamable
 @dataclass(frozen=True)
 class RequestFeeEstimates(Streamable):
     """
-    time_targets (List[uint64]): Epoch timestamps in seconds to estimate FeeRates for.
+    time_targets (list[uint64]): Epoch timestamps in seconds to estimate FeeRates for.
     """
 
-    time_targets: List[uint64]
+    time_targets: list[uint64]
 
 
 @streamable
@@ -282,25 +282,25 @@ class RespondFeeEstimates(Streamable):
 @streamable
 @dataclass(frozen=True)
 class RequestRemovePuzzleSubscriptions(Streamable):
-    puzzle_hashes: Optional[List[bytes32]]
+    puzzle_hashes: Optional[list[bytes32]]
 
 
 @streamable
 @dataclass(frozen=True)
 class RespondRemovePuzzleSubscriptions(Streamable):
-    puzzle_hashes: List[bytes32]
+    puzzle_hashes: list[bytes32]
 
 
 @streamable
 @dataclass(frozen=True)
 class RequestRemoveCoinSubscriptions(Streamable):
-    coin_ids: Optional[List[bytes32]]
+    coin_ids: Optional[list[bytes32]]
 
 
 @streamable
 @dataclass(frozen=True)
 class RespondRemoveCoinSubscriptions(Streamable):
-    coin_ids: List[bytes32]
+    coin_ids: list[bytes32]
 
 
 @streamable
@@ -315,7 +315,7 @@ class CoinStateFilters(Streamable):
 @streamable
 @dataclass(frozen=True)
 class RequestPuzzleState(Streamable):
-    puzzle_hashes: List[bytes32]
+    puzzle_hashes: list[bytes32]
     previous_height: Optional[uint32]
     header_hash: bytes32
     filters: CoinStateFilters
@@ -325,11 +325,11 @@ class RequestPuzzleState(Streamable):
 @streamable
 @dataclass(frozen=True)
 class RespondPuzzleState(Streamable):
-    puzzle_hashes: List[bytes32]
+    puzzle_hashes: list[bytes32]
     height: uint32
     header_hash: bytes32
     is_finished: bool
-    coin_states: List[CoinState]
+    coin_states: list[CoinState]
 
 
 @streamable
@@ -341,7 +341,7 @@ class RejectPuzzleState(Streamable):
 @streamable
 @dataclass(frozen=True)
 class RequestCoinState(Streamable):
-    coin_ids: List[bytes32]
+    coin_ids: list[bytes32]
     previous_height: Optional[uint32]
     header_hash: bytes32
     subscribe: bool
@@ -350,8 +350,8 @@ class RequestCoinState(Streamable):
 @streamable
 @dataclass(frozen=True)
 class RespondCoinState(Streamable):
-    coin_ids: List[bytes32]
-    coin_states: List[CoinState]
+    coin_ids: list[bytes32]
+    coin_states: list[CoinState]
 
 
 @streamable
@@ -375,13 +375,13 @@ class RemovedMempoolItem(Streamable):
 @streamable
 @dataclass(frozen=True)
 class MempoolItemsAdded(Streamable):
-    transaction_ids: List[bytes32]
+    transaction_ids: list[bytes32]
 
 
 @streamable
 @dataclass(frozen=True)
 class MempoolItemsRemoved(Streamable):
-    removed_items: List[RemovedMempoolItem]
+    removed_items: list[RemovedMempoolItem]
 
 
 @streamable

chia/rpc/crawler_rpc_api.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import ipaddress
-from typing import Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
 from chia.rpc.rpc_server import Endpoint, EndpointResult
 from chia.seeder.crawler import Crawler
@@ -9,28 +9,33 @@ from chia.util.ws_message import WsRpcMessage, create_payload_dict
 
 
 class CrawlerRpcApi:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcApiProtocol
+
+        _protocol_check: ClassVar[RpcApiProtocol] = cast("CrawlerRpcApi", None)
+
     def __init__(self, crawler: Crawler):
         self.service = crawler
         self.service_name = "chia_crawler"
 
-    def get_routes(self) -> Dict[str, Endpoint]:
+    def get_routes(self) -> dict[str, Endpoint]:
         return {
             "/get_peer_counts": self.get_peer_counts,
             "/get_ips_after_timestamp": self.get_ips_after_timestamp,
         }
 
-    async def _state_changed(self, change: str, change_data: Optional[Dict[str, Any]] = None) -> List[WsRpcMessage]:
+    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> list[WsRpcMessage]:
         payloads = []
 
         if change_data is None:
             change_data = await self.get_peer_counts({})
 
-        if change in ("crawl_batch_completed", "loaded_initial_peers"):
+        if change in {"crawl_batch_completed", "loaded_initial_peers"}:
             payloads.append(create_payload_dict(change, change_data, self.service_name, "metrics"))
 
         return payloads
 
-    async def get_peer_counts(self, _request: Dict[str, Any]) -> EndpointResult:
+    async def get_peer_counts(self, _request: dict[str, Any]) -> EndpointResult:
         ipv6_addresses_count = 0
         for host in self.service.best_timestamp_per_peer.keys():
             try:
@@ -54,7 +59,7 @@ class CrawlerRpcApi:
         }
         return data
 
-    async def get_ips_after_timestamp(self, _request: Dict[str, Any]) -> EndpointResult:
+    async def get_ips_after_timestamp(self, _request: dict[str, Any]) -> EndpointResult:
         after = _request.get("after", None)
         if after is None:
             raise ValueError("`after` is required and must be a unix timestamp")
@@ -62,7 +67,7 @@ class CrawlerRpcApi:
         offset = _request.get("offset", 0)
         limit = _request.get("limit", 10000)
 
-        matched_ips: List[str] = []
+        matched_ips: list[str] = []
         for ip, timestamp in self.service.best_timestamp_per_peer.items():
             if timestamp > after:
                 matched_ips.append(ip)

chia/rpc/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, Dict, List, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
 
 from chia.data_layer.data_layer_errors import OfferIntegrityError
 from chia.data_layer.data_layer_util import (
@@ -44,9 +44,9 @@ if TYPE_CHECKING:
     from chia.data_layer.data_layer import DataLayer
 
 
-def process_change(change: Dict[str, Any]) -> Dict[str, Any]:
+def process_change(change: dict[str, Any]) -> dict[str, Any]:
     # TODO: A full class would likely be nice for this so downstream doesn't
-    #       have to deal with maybe-present attributes or Dict[str, Any] hints.
+    #       have to deal with maybe-present attributes or dict[str, Any] hints.
     reference_node_hash = change.get("reference_node_hash")
     if reference_node_hash is not None:
         reference_node_hash = bytes32.from_hexstr(reference_node_hash)
@@ -68,20 +68,20 @@ def process_change(change: Dict[str, Any]) -> Dict[str, Any]:
     }
 
 
-def process_change_multistore(update: Dict[str, Any]) -> Dict[str, Any]:
+def process_change_multistore(update: dict[str, Any]) -> dict[str, Any]:
     store_id = update.get("store_id")
     if store_id is None:
         raise Exception("Each update must specify a store_id")
     changelist = update.get("changelist")
     if changelist is None:
         raise Exception("Each update must specify a changelist")
-    res: Dict[str, Any] = {}
+    res: dict[str, Any] = {}
     res["store_id"] = bytes32.from_hexstr(store_id)
     res["changelist"] = [process_change(change) for change in changelist]
     return res
 
 
-def get_fee(config: Dict[str, Any], request: Dict[str, Any]) -> uint64:
+def get_fee(config: dict[str, Any], request: dict[str, Any]) -> uint64:
     fee = request.get("fee")
     if fee is None:
         fee = 0  # DL no longer reads the fee from the config
@@ -89,12 +89,17 @@ def get_fee(config: Dict[str, Any], request: Dict[str, Any]) -> uint64:
 
 
 class DataLayerRpcApi:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcApiProtocol
+
+        _protocol_check: ClassVar[RpcApiProtocol] = cast("DataLayerRpcApi", None)
+
     # TODO: other RPC APIs do not accept a wallet and the service start does not expect to provide one
     def __init__(self, data_layer: DataLayer):  # , wallet: DataLayerWallet):
         self.service: DataLayer = data_layer
         self.service_name = "chia_data_layer"
 
-    def get_routes(self) -> Dict[str, Endpoint]:
+    def get_routes(self) -> dict[str, Endpoint]:
         return {
             "/wallet_log_in": self.wallet_log_in,
             "/create_data_store": self.create_data_store,
@@ -133,17 +138,17 @@ 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: Optional[dict[str, Any]]) -> list[WsRpcMessage]:
         return []
 
-    async def wallet_log_in(self, request: Dict[str, Any]) -> EndpointResult:
+    async def wallet_log_in(self, request: dict[str, Any]) -> EndpointResult:
         if self.service is None:
             raise Exception("Data layer not created")
         fingerprint = cast(int, request["fingerprint"])
         await self.service.wallet_log_in(fingerprint=fingerprint)
         return {}
 
-    async def create_data_store(self, request: Dict[str, Any]) -> EndpointResult:
+    async def create_data_store(self, request: dict[str, Any]) -> EndpointResult:
         if self.service is None:
             raise Exception("Data layer not created")
         fee = get_fee(self.service.config, request)
@@ -154,13 +159,13 @@ class DataLayerRpcApi:
         else:
             return {"id": value.hex()}
 
-    async def get_owned_stores(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_owned_stores(self, request: dict[str, Any]) -> EndpointResult:
         if self.service is None:
             raise Exception("Data layer not created")
         singleton_records = await self.service.get_owned_stores()
         return {"store_ids": [singleton.launcher_id.hex() for singleton in singleton_records]}
 
-    async def get_value(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_value(self, request: dict[str, Any]) -> EndpointResult:
         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
@@ -178,7 +183,7 @@ class DataLayerRpcApi:
             hex = value.hex()
         return {"value": hex}
 
-    async def get_keys(self, request: Dict[str, Any]) -> EndpointResult:
+    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")
@@ -199,7 +204,7 @@ class DataLayerRpcApi:
             keys = keys_paginated.keys
 
         # NOTE: here we do support zeros as the empty root
-        if keys == [] and resolved_root_hash is not unspecified and resolved_root_hash != bytes32([0] * 32):
+        if keys == [] and resolved_root_hash is not unspecified and resolved_root_hash != bytes32.zeros:
             raise Exception(f"Can't find keys for {resolved_root_hash}")
 
         response: EndpointResult = {"keys": [f"0x{key.hex()}" for key in keys]}
@@ -215,7 +220,7 @@ class DataLayerRpcApi:
 
         return response
 
-    async def get_keys_values(self, request: Dict[str, Any]) -> EndpointResult:
+    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")
@@ -239,7 +244,7 @@ class DataLayerRpcApi:
 
         json_nodes = [recurse_jsonify(dataclasses.asdict(node)) for node in keys_values]
         # NOTE: here we do support zeros as the empty root
-        if not json_nodes and resolved_root_hash is not unspecified and resolved_root_hash != bytes32([0] * 32):
+        if not json_nodes and resolved_root_hash is not unspecified and resolved_root_hash != bytes32.zeros:
             raise Exception(f"Can't find keys and values for {resolved_root_hash}")
 
         response: EndpointResult = {"keys_values": json_nodes}
@@ -255,7 +260,7 @@ class DataLayerRpcApi:
 
         return response
 
-    async def get_ancestors(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_ancestors(self, request: dict[str, Any]) -> EndpointResult:
         store_id = bytes32.from_hexstr(request["id"])
         node_hash = bytes32.from_hexstr(request["hash"])
         if self.service is None:
@@ -263,7 +268,7 @@ class DataLayerRpcApi:
         value = await self.service.get_ancestors(node_hash, store_id)
         return {"ancestors": value}
 
-    async def batch_update(self, request: Dict[str, Any]) -> EndpointResult:
+    async def batch_update(self, request: dict[str, Any]) -> EndpointResult:
         """
         id  - the id of the store we are operating on
         changelist - a list of changes to apply on store
@@ -285,7 +290,7 @@ class DataLayerRpcApi:
                 raise Exception("Transaction submitted on chain, but submit_on_chain set to False")
             return {}
 
-    async def multistore_batch_update(self, request: Dict[str, Any]) -> EndpointResult:
+    async def multistore_batch_update(self, request: dict[str, Any]) -> EndpointResult:
         fee = get_fee(self.service.config, request)
         store_updates = [process_change_multistore(update) for update in request["store_updates"]]
         submit_on_chain = request.get("submit_on_chain", True)
@@ -301,18 +306,18 @@ class DataLayerRpcApi:
                 raise Exception("Transaction submitted on chain, but submit_on_chain set to False")
             return {}
 
-    async def submit_pending_root(self, request: Dict[str, Any]) -> EndpointResult:
+    async def submit_pending_root(self, request: dict[str, Any]) -> EndpointResult:
         store_id = bytes32.from_hexstr(request["id"])
         fee = get_fee(self.service.config, request)
         transaction_record = await self.service.submit_pending_root(store_id, uint64(fee))
         return {"tx_id": transaction_record.name}
 
-    async def submit_all_pending_roots(self, request: Dict[str, Any]) -> EndpointResult:
+    async def submit_all_pending_roots(self, request: dict[str, Any]) -> EndpointResult:
         fee = get_fee(self.service.config, request)
         transaction_records = await self.service.submit_all_pending_roots(uint64(fee))
         return {"tx_id": [transaction_record.name for transaction_record in transaction_records]}
 
-    async def insert(self, request: Dict[str, Any]) -> EndpointResult:
+    async def insert(self, request: dict[str, Any]) -> EndpointResult:
         """
         rows_to_add a list of clvm objects as bytes to add to table
         rows_to_remove a list of row hashes to remove
@@ -329,7 +334,7 @@ class DataLayerRpcApi:
         assert transaction_record is not None
         return {"tx_id": transaction_record.name}
 
-    async def delete_key(self, request: Dict[str, Any]) -> EndpointResult:
+    async def delete_key(self, request: dict[str, Any]) -> EndpointResult:
         """
         rows_to_add a list of clvm objects as bytes to add to table
         rows_to_remove a list of row hashes to remove
@@ -345,7 +350,7 @@ class DataLayerRpcApi:
         assert transaction_record is not None
         return {"tx_id": transaction_record.name}
 
-    async def get_root(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_root(self, request: dict[str, Any]) -> EndpointResult:
         """get hash of latest tree root"""
         store_id = bytes32.from_hexstr(request["id"])
         # todo input checks
@@ -356,7 +361,7 @@ class DataLayerRpcApi:
             raise Exception(f"Failed to get root for {store_id.hex()}")
         return {"hash": rec.root, "confirmed": rec.confirmed, "timestamp": rec.timestamp}
 
-    async def get_local_root(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_local_root(self, request: dict[str, Any]) -> EndpointResult:
         """get hash of latest tree root saved in our local datastore"""
         store_id = bytes32.from_hexstr(request["id"])
         # todo input checks
@@ -365,7 +370,7 @@ class DataLayerRpcApi:
         res = await self.service.get_local_root(store_id)
         return {"hash": res}
 
-    async def get_roots(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_roots(self, request: dict[str, Any]) -> EndpointResult:
         """
         get state hashes for a list of roots
         """
@@ -381,7 +386,7 @@ class DataLayerRpcApi:
                 roots.append({"id": id_bytes, "hash": rec.root, "confirmed": rec.confirmed, "timestamp": rec.timestamp})
         return {"root_hashes": roots}
 
-    async def subscribe(self, request: Dict[str, Any]) -> EndpointResult:
+    async def subscribe(self, request: dict[str, Any]) -> EndpointResult:
         """
         subscribe to singleton
         """
@@ -396,7 +401,7 @@ class DataLayerRpcApi:
         await self.service.subscribe(store_id=store_id_bytes, urls=urls)
         return {}
 
-    async def unsubscribe(self, request: Dict[str, Any]) -> EndpointResult:
+    async def unsubscribe(self, request: dict[str, Any]) -> EndpointResult:
         """
         unsubscribe from singleton
         """
@@ -410,16 +415,16 @@ class DataLayerRpcApi:
         await self.service.unsubscribe(store_id_bytes, retain_data)
         return {}
 
-    async def subscriptions(self, request: Dict[str, Any]) -> EndpointResult:
+    async def subscriptions(self, request: dict[str, Any]) -> EndpointResult:
         """
         List current subscriptions
         """
         if self.service is None:
             raise Exception("Data layer not created")
-        subscriptions: List[Subscription] = await self.service.get_subscriptions()
+        subscriptions: list[Subscription] = await self.service.get_subscriptions()
         return {"store_ids": [sub.store_id.hex() for sub in subscriptions]}
 
-    async def remove_subscriptions(self, request: Dict[str, Any]) -> EndpointResult:
+    async def remove_subscriptions(self, request: dict[str, Any]) -> EndpointResult:
         if self.service is None:
             raise Exception("Data layer not created")
         store_id = request.get("id")
@@ -430,7 +435,7 @@ class DataLayerRpcApi:
         await self.service.remove_subscriptions(store_id=store_id_bytes, urls=urls)
         return {}
 
-    async def add_missing_files(self, request: Dict[str, Any]) -> EndpointResult:
+    async def add_missing_files(self, request: dict[str, Any]) -> EndpointResult:
         """
         complete the data server files.
         """
@@ -438,7 +443,7 @@ class DataLayerRpcApi:
             store_ids = request["ids"]
             ids_bytes = [bytes32.from_hexstr(id) for id in store_ids]
         else:
-            subscriptions: List[Subscription] = await self.service.get_subscriptions()
+            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
@@ -448,7 +453,7 @@ class DataLayerRpcApi:
             await self.service.add_missing_files(store_id, overwrite, foldername)
         return {}
 
-    async def get_root_history(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_root_history(self, request: dict[str, Any]) -> EndpointResult:
         """
         get history of state hashes for a store
         """
@@ -457,12 +462,12 @@ class DataLayerRpcApi:
         store_id = request["id"]
         id_bytes = bytes32.from_hexstr(store_id)
         records = await self.service.get_root_history(id_bytes)
-        res: List[Dict[str, Any]] = []
+        res: list[dict[str, Any]] = []
         for rec in records:
             res.insert(0, {"root_hash": rec.root, "confirmed": rec.confirmed, "timestamp": rec.timestamp})
         return {"root_history": res}
 
-    async def get_kv_diff(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_kv_diff(self, request: dict[str, Any]) -> EndpointResult:
         """
         get kv diff between two root hashes
         """
@@ -476,7 +481,7 @@ class DataLayerRpcApi:
         hash_2_bytes = bytes32.from_hexstr(hash_2)
         page = request.get("page", None)
         max_page_size = request.get("max_page_size", None)
-        res: List[Dict[str, Any]] = []
+        res: list[dict[str, Any]] = []
 
         if page is None:
             records_dict = await self.service.get_kv_diff(id_bytes, hash_1_bytes, hash_2_bytes)
@@ -501,7 +506,7 @@ class DataLayerRpcApi:
 
         return response
 
-    async def add_mirror(self, request: Dict[str, Any]) -> EndpointResult:
+    async def add_mirror(self, request: dict[str, Any]) -> EndpointResult:
         store_id = request["id"]
         id_bytes = bytes32.from_hexstr(store_id)
         urls = request["urls"]
@@ -510,17 +515,17 @@ class DataLayerRpcApi:
         await self.service.add_mirror(id_bytes, urls, amount, fee)
         return {}
 
-    async def delete_mirror(self, request: Dict[str, Any]) -> EndpointResult:
+    async def delete_mirror(self, request: dict[str, Any]) -> EndpointResult:
         coin_id = request["coin_id"]
         coin_id_bytes = bytes32.from_hexstr(coin_id)
         fee = get_fee(self.service.config, request)
         await self.service.delete_mirror(coin_id_bytes, fee)
         return {}
 
-    async def get_mirrors(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_mirrors(self, request: dict[str, Any]) -> EndpointResult:
         store_id = request["id"]
         id_bytes = bytes32.from_hexstr(store_id)
-        mirrors: List[Mirror] = await self.service.get_mirrors(id_bytes)
+        mirrors: list[Mirror] = await self.service.get_mirrors(id_bytes)
         return {"mirrors": [mirror.to_json_dict() for mirror in mirrors]}
 
     @marshal()  # type: ignore[arg-type]
@@ -566,7 +571,7 @@ class DataLayerRpcApi:
 
         return CancelOfferResponse(success=True)
 
-    async def get_sync_status(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_sync_status(self, request: dict[str, Any]) -> EndpointResult:
         store_id = request["id"]
         id_bytes = bytes32.from_hexstr(store_id)
         if self.service is None:
@@ -582,7 +587,7 @@ class DataLayerRpcApi:
             }
         }
 
-    async def check_plugins(self, request: Dict[str, Any]) -> EndpointResult:
+    async def check_plugins(self, request: dict[str, Any]) -> EndpointResult:
         if self.service is None:
             raise Exception("Data layer not created")
         plugin_status = await self.service.check_plugins()
@@ -601,7 +606,7 @@ class DataLayerRpcApi:
         if root is None:
             raise ValueError("no root")
 
-        all_proofs: List[HashOnlyProof] = []
+        all_proofs: list[HashOnlyProof] = []
         for key in request.keys:
             node = await self.service.data_store.get_node_by_key(store_id=request.store_id, key=key)
             pi = await self.service.data_store.get_proof_of_inclusion_by_hash(