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

chia/rpc/full_node_rpc_api.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
 from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain import Blockchain, BlockchainMutexPriority
@@ -33,7 +33,7 @@ from chia.util.math import make_monotonically_decreasing
 from chia.util.ws_message import WsRpcMessage, create_payload_dict
 
 
-def coin_record_dict_backwards_compat(coin_record: Dict[str, Any]) -> Dict[str, bool]:
+def coin_record_dict_backwards_compat(coin_record: dict[str, Any]) -> dict[str, bool]:
     coin_record["spent"] = coin_record["spent_block_index"] > 0
     return coin_record
 
@@ -82,12 +82,17 @@ async def get_average_block_time(
 
 
 class FullNodeRpcApi:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcApiProtocol
+
+        _protocol_check: ClassVar[RpcApiProtocol] = cast("FullNodeRpcApi", None)
+
     def __init__(self, service: FullNode) -> None:
         self.service = service
         self.service_name = "chia_full_node"
-        self.cached_blockchain_state: Optional[Dict[str, Any]] = None
+        self.cached_blockchain_state: Optional[dict[str, Any]] = None
 
-    def get_routes(self) -> Dict[str, Endpoint]:
+    def get_routes(self) -> dict[str, Endpoint]:
         return {
             # Blockchain
             "/get_blockchain_state": self.get_blockchain_state,
@@ -122,12 +127,12 @@ class FullNodeRpcApi:
             "/get_fee_estimate": self.get_fee_estimate,
         }
 
-    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]:
         if change_data is None:
             change_data = {}
 
         payloads = []
-        if change == "new_peak" or change == "sync_mode":
+        if change in {"new_peak", "sync_mode"}:
             data = await self.get_blockchain_state({})
             assert data is not None
             payloads.append(
@@ -147,7 +152,7 @@ class FullNodeRpcApi:
                 )
             )
 
-        if change in ("block", "signage_point"):
+        if change in {"block", "signage_point"}:
             payloads.append(create_payload_dict(change, change_data, self.service_name, "metrics"))
 
         if change == "unfinished_block":
@@ -155,7 +160,7 @@ class FullNodeRpcApi:
 
         return payloads
 
-    async def get_blockchain_state(self, _: Dict[str, Any]) -> EndpointResult:
+    async def get_blockchain_state(self, _: dict[str, Any]) -> EndpointResult:
         """
         Returns a summary of the node's view of the blockchain.
         """
@@ -278,7 +283,7 @@ class FullNodeRpcApi:
         self.cached_blockchain_state = dict(response["blockchain_state"])
         return response
 
-    async def get_recent_signage_point_or_eos(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_recent_signage_point_or_eos(self, request: dict[str, Any]) -> EndpointResult:
         if "sp_hash" not in request:
             challenge_hash: bytes32 = bytes32.from_hexstr(request["challenge_hash"])
             # This is the case of getting an end of slot
@@ -369,7 +374,7 @@ class FullNodeRpcApi:
 
         return {"signage_point": sp, "time_received": time_received, "reverted": True}
 
-    async def get_block(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_block(self, request: dict[str, Any]) -> EndpointResult:
         if "header_hash" not in request:
             raise ValueError("No header_hash in request")
         header_hash = bytes32.from_hexstr(request["header_hash"])
@@ -380,7 +385,7 @@ class FullNodeRpcApi:
 
         return {"block": block}
 
-    async def get_blocks(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_blocks(self, request: dict[str, Any]) -> EndpointResult:
         if "start" not in request:
             raise ValueError("No start in request")
         if "end" not in request:
@@ -397,7 +402,7 @@ class FullNodeRpcApi:
         block_range = []
         for a in range(start, end):
             block_range.append(uint32(a))
-        blocks: List[FullBlock] = await self.service.block_store.get_full_blocks_at(block_range)
+        blocks: list[FullBlock] = await self.service.block_store.get_full_blocks_at(block_range)
         json_blocks = []
         for block in blocks:
             hh: bytes32 = block.header_hash
@@ -410,7 +415,7 @@ class FullNodeRpcApi:
             json_blocks.append(json)
         return {"blocks": json_blocks}
 
-    async def get_block_count_metrics(self, _: Dict[str, Any]) -> EndpointResult:
+    async def get_block_count_metrics(self, _: dict[str, Any]) -> EndpointResult:
         compact_blocks = 0
         uncompact_blocks = 0
         with log_exceptions(self.service.log, consume=True):
@@ -430,7 +435,7 @@ class FullNodeRpcApi:
             }
         }
 
-    async def get_block_records(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_block_records(self, request: dict[str, Any]) -> EndpointResult:
         if "start" not in request:
             raise ValueError("No start in request")
         if "end" not in request:
@@ -460,7 +465,7 @@ class FullNodeRpcApi:
             records.append(record)
         return {"block_records": records}
 
-    async def get_block_spends(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_block_spends(self, request: dict[str, Any]) -> EndpointResult:
         if "header_hash" not in request:
             raise ValueError("No header_hash in request")
         header_hash = bytes32.from_hexstr(request["header_hash"])
@@ -468,7 +473,7 @@ class FullNodeRpcApi:
         if full_block is None:
             raise ValueError(f"Block {header_hash.hex()} not found")
 
-        spends: List[CoinSpend] = []
+        spends: list[CoinSpend] = []
         block_generator = await get_block_generator(self.service.blockchain.lookup_block_generators, full_block)
         if block_generator is None:  # if block is not a transaction block.
             return {"block_spends": spends}
@@ -477,7 +482,7 @@ class FullNodeRpcApi:
 
         return {"block_spends": spends}
 
-    async def get_block_spends_with_conditions(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_block_spends_with_conditions(self, request: dict[str, Any]) -> EndpointResult:
         if "header_hash" not in request:
             raise ValueError("No header_hash in request")
         header_hash = bytes32.from_hexstr(request["header_hash"])
@@ -506,7 +511,7 @@ class FullNodeRpcApi:
             ]
         }
 
-    async def get_block_record_by_height(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_block_record_by_height(self, request: dict[str, Any]) -> EndpointResult:
         if "height" not in request:
             raise ValueError("No height in request")
         height = request["height"]
@@ -525,7 +530,7 @@ class FullNodeRpcApi:
             raise ValueError(f"Block {header_hash} does not exist")
         return {"block_record": record}
 
-    async def get_block_record(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_block_record(self, request: dict[str, Any]) -> EndpointResult:
         if "header_hash" not in request:
             raise ValueError("header_hash not in request")
         header_hash_str = request["header_hash"]
@@ -539,12 +544,12 @@ class FullNodeRpcApi:
 
         return {"block_record": record}
 
-    async def get_unfinished_block_headers(self, _request: Dict[str, Any]) -> EndpointResult:
+    async def get_unfinished_block_headers(self, _request: dict[str, Any]) -> EndpointResult:
         peak: Optional[BlockRecord] = self.service.blockchain.get_peak()
         if peak is None:
             return {"headers": []}
 
-        response_headers: List[UnfinishedHeaderBlock] = []
+        response_headers: list[UnfinishedHeaderBlock] = []
         for block in self.service.full_node_store.get_unfinished_blocks(peak.height):
             unfinished_header_block = UnfinishedHeaderBlock(
                 block.finished_sub_slots,
@@ -558,7 +563,7 @@ class FullNodeRpcApi:
             response_headers.append(unfinished_header_block)
         return {"headers": response_headers}
 
-    async def get_network_space(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_network_space(self, request: dict[str, Any]) -> EndpointResult:
         """
         Retrieves an estimate of total space validating the chain
         between two block header hashes.
@@ -599,13 +604,13 @@ class FullNodeRpcApi:
         )
         return {"space": uint128(int(network_space_bytes_estimate))}
 
-    async def get_coin_records_by_puzzle_hash(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_coin_records_by_puzzle_hash(self, request: dict[str, Any]) -> EndpointResult:
         """
         Retrieves the coins for a given puzzlehash, by default returns unspent coins.
         """
         if "puzzle_hash" not in request:
             raise ValueError("Puzzle hash not in request")
-        kwargs: Dict[str, Any] = {"include_spent_coins": False, "puzzle_hash": hexstr_to_bytes(request["puzzle_hash"])}
+        kwargs: dict[str, Any] = {"include_spent_coins": False, "puzzle_hash": hexstr_to_bytes(request["puzzle_hash"])}
         if "start_height" in request:
             kwargs["start_height"] = uint32(request["start_height"])
         if "end_height" in request:
@@ -618,13 +623,13 @@ class FullNodeRpcApi:
 
         return {"coin_records": [coin_record_dict_backwards_compat(cr.to_json_dict()) for cr in coin_records]}
 
-    async def get_coin_records_by_puzzle_hashes(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_coin_records_by_puzzle_hashes(self, request: dict[str, Any]) -> EndpointResult:
         """
         Retrieves the coins for a given puzzlehash, by default returns unspent coins.
         """
         if "puzzle_hashes" not in request:
             raise ValueError("Puzzle hashes not in request")
-        kwargs: Dict[str, Any] = {
+        kwargs: dict[str, Any] = {
             "include_spent_coins": False,
             "puzzle_hashes": [hexstr_to_bytes(ph) for ph in request["puzzle_hashes"]],
         }
@@ -640,7 +645,7 @@ class FullNodeRpcApi:
 
         return {"coin_records": [coin_record_dict_backwards_compat(cr.to_json_dict()) for cr in coin_records]}
 
-    async def get_coin_record_by_name(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_coin_record_by_name(self, request: dict[str, Any]) -> EndpointResult:
         """
         Retrieves a coin record by its name.
         """
@@ -654,13 +659,13 @@ class FullNodeRpcApi:
 
         return {"coin_record": coin_record_dict_backwards_compat(coin_record.to_json_dict())}
 
-    async def get_coin_records_by_names(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_coin_records_by_names(self, request: dict[str, Any]) -> EndpointResult:
         """
         Retrieves the coins for given coin IDs, by default returns unspent coins.
         """
         if "names" not in request:
             raise ValueError("Names not in request")
-        kwargs: Dict[str, Any] = {
+        kwargs: dict[str, Any] = {
             "include_spent_coins": False,
             "names": [hexstr_to_bytes(name) for name in request["names"]],
         }
@@ -676,13 +681,13 @@ class FullNodeRpcApi:
 
         return {"coin_records": [coin_record_dict_backwards_compat(cr.to_json_dict()) for cr in coin_records]}
 
-    async def get_coin_records_by_parent_ids(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_coin_records_by_parent_ids(self, request: dict[str, Any]) -> EndpointResult:
         """
         Retrieves the coins for given parent coin IDs, by default returns unspent coins.
         """
         if "parent_ids" not in request:
             raise ValueError("Parent IDs not in request")
-        kwargs: Dict[str, Any] = {
+        kwargs: dict[str, Any] = {
             "include_spent_coins": False,
             "parent_ids": [hexstr_to_bytes(ph) for ph in request["parent_ids"]],
         }
@@ -698,7 +703,7 @@ class FullNodeRpcApi:
 
         return {"coin_records": [coin_record_dict_backwards_compat(cr.to_json_dict()) for cr in coin_records]}
 
-    async def get_coin_records_by_hint(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_coin_records_by_hint(self, request: dict[str, Any]) -> EndpointResult:
         """
         Retrieves coins by hint, by default returns unspent coins.
         """
@@ -708,9 +713,9 @@ class FullNodeRpcApi:
         if self.service.hint_store is None:
             return {"coin_records": []}
 
-        names: List[bytes32] = await self.service.hint_store.get_coin_ids(bytes32.from_hexstr(request["hint"]))
+        names: list[bytes32] = await self.service.hint_store.get_coin_ids(bytes32.from_hexstr(request["hint"]))
 
-        kwargs: Dict[str, Any] = {
+        kwargs: dict[str, Any] = {
             "include_spent_coins": False,
             "names": names,
         }
@@ -727,7 +732,7 @@ class FullNodeRpcApi:
 
         return {"coin_records": [coin_record_dict_backwards_compat(cr.to_json_dict()) for cr in coin_records]}
 
-    async def push_tx(self, request: Dict[str, Any]) -> EndpointResult:
+    async def push_tx(self, request: dict[str, Any]) -> EndpointResult:
         if "spend_bundle" not in request:
             raise ValueError("Spend bundle not in request")
 
@@ -752,7 +757,7 @@ class FullNodeRpcApi:
             "status": status.name,
         }
 
-    async def get_puzzle_and_solution(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_puzzle_and_solution(self, request: dict[str, Any]) -> EndpointResult:
         coin_name: bytes32 = bytes32.from_hexstr(request["coin_id"])
         height = request["height"]
         coin_record = await self.service.coin_store.get_coin_record(coin_name)
@@ -776,7 +781,7 @@ class FullNodeRpcApi:
         )
         return {"coin_solution": CoinSpend(coin_record.coin, spend_info.puzzle, spend_info.solution)}
 
-    async def get_additions_and_removals(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_additions_and_removals(self, request: dict[str, Any]) -> EndpointResult:
         if "header_hash" not in request:
             raise ValueError("No header_hash in request")
         header_hash = bytes32.from_hexstr(request["header_hash"])
@@ -788,28 +793,28 @@ class FullNodeRpcApi:
         async with self.service.blockchain.priority_mutex.acquire(priority=BlockchainMutexPriority.low):
             if self.service.blockchain.height_to_hash(block.height) != header_hash:
                 raise ValueError(f"Block at {header_hash.hex()} is no longer in the blockchain (it's in a fork)")
-            additions: List[CoinRecord] = await self.service.coin_store.get_coins_added_at_height(block.height)
-            removals: List[CoinRecord] = await self.service.coin_store.get_coins_removed_at_height(block.height)
+            additions: list[CoinRecord] = await self.service.coin_store.get_coins_added_at_height(block.height)
+            removals: list[CoinRecord] = await self.service.coin_store.get_coins_removed_at_height(block.height)
 
         return {
             "additions": [coin_record_dict_backwards_compat(cr.to_json_dict()) for cr in additions],
             "removals": [coin_record_dict_backwards_compat(cr.to_json_dict()) for cr in removals],
         }
 
-    async def get_aggsig_additional_data(self, _: Dict[str, Any]) -> EndpointResult:
+    async def get_aggsig_additional_data(self, _: dict[str, Any]) -> EndpointResult:
         return {"additional_data": self.service.constants.AGG_SIG_ME_ADDITIONAL_DATA.hex()}
 
-    async def get_all_mempool_tx_ids(self, _: Dict[str, Any]) -> EndpointResult:
+    async def get_all_mempool_tx_ids(self, _: dict[str, Any]) -> EndpointResult:
         ids = list(self.service.mempool_manager.mempool.all_item_ids())
         return {"tx_ids": ids}
 
-    async def get_all_mempool_items(self, _: Dict[str, Any]) -> EndpointResult:
+    async def get_all_mempool_items(self, _: dict[str, Any]) -> EndpointResult:
         spends = {}
         for item in self.service.mempool_manager.mempool.all_items():
             spends[item.name.hex()] = item.to_json_dict()
         return {"mempool_items": spends}
 
-    async def get_mempool_item_by_tx_id(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_mempool_item_by_tx_id(self, request: dict[str, Any]) -> EndpointResult:
         if "tx_id" not in request:
             raise ValueError("No tx_id in request")
         include_pending: bool = request.get("include_pending", False)
@@ -821,7 +826,7 @@ class FullNodeRpcApi:
 
         return {"mempool_item": item.to_json_dict()}
 
-    async def get_mempool_items_by_coin_name(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_mempool_items_by_coin_name(self, request: dict[str, Any]) -> EndpointResult:
         if "coin_name" not in request:
             raise ValueError("No coin_name in request")
 
@@ -849,7 +854,7 @@ class FullNodeRpcApi:
         }
         return uint64(tx_cost_estimates[name])
 
-    async def _validate_fee_estimate_cost(self, request: Dict[str, Any]) -> uint64:
+    async def _validate_fee_estimate_cost(self, request: dict[str, Any]) -> uint64:
         c = 0
         ns = ["spend_bundle", "cost", "spend_type"]
         for n in ns:
@@ -869,17 +874,17 @@ class FullNodeRpcApi:
             cost *= request.get("spend_count", 1)
         return uint64(cost)
 
-    def _validate_target_times(self, request: Dict[str, Any]) -> None:
+    def _validate_target_times(self, request: dict[str, Any]) -> None:
         if "target_times" not in request:
             raise ValueError("Request must contain 'target_times' array")
         if any(t < 0 for t in request["target_times"]):
             raise ValueError("'target_times' array members must be non-negative")
 
-    async def get_fee_estimate(self, request: Dict[str, Any]) -> Dict[str, Any]:
+    async def get_fee_estimate(self, request: dict[str, Any]) -> dict[str, Any]:
         self._validate_target_times(request)
         spend_cost = await self._validate_fee_estimate_cost(request)
 
-        target_times: List[int] = request["target_times"]
+        target_times: list[int] = request["target_times"]
         estimator: FeeEstimatorInterface = self.service.mempool_manager.mempool.fee_estimator
         target_times.sort()
         estimates = [

chia/rpc/full_node_rpc_client.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional, Tuple, cast
+from typing import Any, Optional, cast
 
 from chia.consensus.block_record import BlockRecord
 from chia.full_node.signage_point import SignagePoint
@@ -15,7 +15,7 @@ from chia.types.unfinished_header_block import UnfinishedHeaderBlock
 from chia.util.ints import uint32
 
 
-def coin_record_dict_backwards_compat(coin_record: Dict[str, Any]) -> Dict[str, Any]:
+def coin_record_dict_backwards_compat(coin_record: dict[str, Any]) -> dict[str, Any]:
     del coin_record["spent"]
     return coin_record
 
@@ -29,11 +29,11 @@ class FullNodeRpcClient(RpcClient):
     to the full node.
     """
 
-    async def get_blockchain_state(self) -> Dict[str, Any]:
+    async def get_blockchain_state(self) -> dict[str, Any]:
         response = await self.fetch("get_blockchain_state", {})
         if response["blockchain_state"]["peak"] is not None:
             response["blockchain_state"]["peak"] = BlockRecord.from_json_dict(response["blockchain_state"]["peak"])
-        return cast(Dict[str, Any], response["blockchain_state"])
+        return cast(dict[str, Any], response["blockchain_state"])
 
     async def get_block(self, header_hash: bytes32) -> Optional[FullBlock]:
         try:
@@ -42,7 +42,7 @@ class FullNodeRpcClient(RpcClient):
             return None
         return FullBlock.from_json_dict(response["block"])
 
-    async def get_blocks(self, start: int, end: int, exclude_reorged: bool = False) -> List[FullBlock]:
+    async def get_blocks(self, start: int, end: int, exclude_reorged: bool = False) -> list[FullBlock]:
         response = await self.fetch(
             "get_blocks", {"start": start, "end": end, "exclude_header_hash": True, "exclude_reorged": exclude_reorged}
         )
@@ -64,11 +64,11 @@ class FullNodeRpcClient(RpcClient):
             return None
         return BlockRecord.from_json_dict(response["block_record"])
 
-    async def get_unfinished_block_headers(self) -> List[UnfinishedHeaderBlock]:
+    async def get_unfinished_block_headers(self) -> list[UnfinishedHeaderBlock]:
         response = await self.fetch("get_unfinished_block_headers", {})
         return [UnfinishedHeaderBlock.from_json_dict(r) for r in response["headers"]]
 
-    async def get_all_block(self, start: uint32, end: uint32) -> List[FullBlock]:
+    async def get_all_block(self, start: uint32, end: uint32) -> list[FullBlock]:
         response = await self.fetch("get_blocks", {"start": start, "end": end, "exclude_header_hash": True})
         return [FullBlock.from_json_dict(r) for r in response["blocks"]]
 
@@ -93,11 +93,11 @@ class FullNodeRpcClient(RpcClient):
 
     async def get_coin_records_by_names(
         self,
-        names: List[bytes32],
+        names: list[bytes32],
         include_spent_coins: bool = True,
         start_height: Optional[int] = None,
         end_height: Optional[int] = None,
-    ) -> List[CoinRecord]:
+    ) -> list[CoinRecord]:
         names_hex = [name.hex() for name in names]
         d = {"names": names_hex, "include_spent_coins": include_spent_coins}
         if start_height is not None:
@@ -114,7 +114,7 @@ class FullNodeRpcClient(RpcClient):
         include_spent_coins: bool = True,
         start_height: Optional[int] = None,
         end_height: Optional[int] = None,
-    ) -> List[CoinRecord]:
+    ) -> list[CoinRecord]:
         d = {"puzzle_hash": puzzle_hash.hex(), "include_spent_coins": include_spent_coins}
         if start_height is not None:
             d["start_height"] = start_height
@@ -126,11 +126,11 @@ class FullNodeRpcClient(RpcClient):
 
     async def get_coin_records_by_puzzle_hashes(
         self,
-        puzzle_hashes: List[bytes32],
+        puzzle_hashes: list[bytes32],
         include_spent_coins: bool = True,
         start_height: Optional[int] = None,
         end_height: Optional[int] = None,
-    ) -> List[CoinRecord]:
+    ) -> list[CoinRecord]:
         puzzle_hashes_hex = [ph.hex() for ph in puzzle_hashes]
         d = {"puzzle_hashes": puzzle_hashes_hex, "include_spent_coins": include_spent_coins}
         if start_height is not None:
@@ -143,11 +143,11 @@ class FullNodeRpcClient(RpcClient):
 
     async def get_coin_records_by_parent_ids(
         self,
-        parent_ids: List[bytes32],
+        parent_ids: list[bytes32],
         include_spent_coins: bool = True,
         start_height: Optional[int] = None,
         end_height: Optional[int] = None,
-    ) -> List[CoinRecord]:
+    ) -> list[CoinRecord]:
         parent_ids_hex = [pid.hex() for pid in parent_ids]
         d = {"parent_ids": parent_ids_hex, "include_spent_coins": include_spent_coins}
         if start_height is not None:
@@ -168,7 +168,7 @@ class FullNodeRpcClient(RpcClient):
         include_spent_coins: bool = True,
         start_height: Optional[int] = None,
         end_height: Optional[int] = None,
-    ) -> List[CoinRecord]:
+    ) -> list[CoinRecord]:
         d = {"hint": hint.hex(), "include_spent_coins": include_spent_coins}
         if start_height is not None:
             d["start_height"] = start_height
@@ -178,7 +178,7 @@ class FullNodeRpcClient(RpcClient):
         response = await self.fetch("get_coin_records_by_hint", d)
         return [CoinRecord.from_json_dict(coin_record_dict_backwards_compat(coin)) for coin in response["coin_records"]]
 
-    async def get_additions_and_removals(self, header_hash: bytes32) -> Tuple[List[CoinRecord], List[CoinRecord]]:
+    async def get_additions_and_removals(self, header_hash: bytes32) -> tuple[list[CoinRecord], list[CoinRecord]]:
         try:
             response = await self.fetch("get_additions_and_removals", {"header_hash": header_hash.hex()})
         except Exception:
@@ -191,7 +191,7 @@ class FullNodeRpcClient(RpcClient):
             additions.append(CoinRecord.from_json_dict(coin_record_dict_backwards_compat(coin_record)))
         return additions, removals
 
-    async def get_block_records(self, start: int, end: int) -> List[Dict[str, Any]]:
+    async def get_block_records(self, start: int, end: int) -> list[dict[str, Any]]:
         try:
             response = await self.fetch("get_block_records", {"start": start, "end": end})
             if response["block_records"] is None:
@@ -199,9 +199,9 @@ class FullNodeRpcClient(RpcClient):
         except Exception:
             return []
         # TODO: return block records
-        return cast(List[Dict[str, Any]], response["block_records"])
+        return cast(list[dict[str, Any]], response["block_records"])
 
-    async def get_block_spends(self, header_hash: bytes32) -> Optional[List[CoinSpend]]:
+    async def get_block_spends(self, header_hash: bytes32) -> Optional[list[CoinSpend]]:
         try:
             response = await self.fetch("get_block_spends", {"header_hash": header_hash.hex()})
             block_spends = []
@@ -211,10 +211,10 @@ class FullNodeRpcClient(RpcClient):
         except Exception:
             return None
 
-    async def get_block_spends_with_conditions(self, header_hash: bytes32) -> Optional[List[CoinSpendWithConditions]]:
+    async def get_block_spends_with_conditions(self, header_hash: bytes32) -> Optional[list[CoinSpendWithConditions]]:
         try:
             response = await self.fetch("get_block_spends_with_conditions", {"header_hash": header_hash.hex()})
-            block_spends: List[CoinSpendWithConditions] = []
+            block_spends: list[CoinSpendWithConditions] = []
             for block_spend in response["block_spends_with_conditions"]:
                 block_spends.append(CoinSpendWithConditions.from_json_dict(block_spend))
             return block_spends
@@ -222,7 +222,7 @@ class FullNodeRpcClient(RpcClient):
         except Exception:
             return None
 
-    async def push_tx(self, spend_bundle: SpendBundle) -> Dict[str, Any]:
+    async def push_tx(self, spend_bundle: SpendBundle) -> dict[str, Any]:
         return await self.fetch("push_tx", {"spend_bundle": spend_bundle.to_json_dict()})
 
     async def get_puzzle_and_solution(self, coin_id: bytes32, height: uint32) -> Optional[CoinSpend]:
@@ -232,13 +232,13 @@ class FullNodeRpcClient(RpcClient):
         except Exception:
             return None
 
-    async def get_all_mempool_tx_ids(self) -> List[bytes32]:
+    async def get_all_mempool_tx_ids(self) -> list[bytes32]:
         response = await self.fetch("get_all_mempool_tx_ids", {})
         return [bytes32.from_hexstr(tx_id_hex) for tx_id_hex in response["tx_ids"]]
 
-    async def get_all_mempool_items(self) -> Dict[bytes32, Dict[str, Any]]:
+    async def get_all_mempool_items(self) -> dict[bytes32, dict[str, Any]]:
         response = await self.fetch("get_all_mempool_items", {})
-        converted: Dict[bytes32, Dict[str, Any]] = {}
+        converted: dict[bytes32, dict[str, Any]] = {}
         for tx_id_hex, item in response["mempool_items"].items():
             converted[bytes32.from_hexstr(tx_id_hex)] = item
         return converted
@@ -247,16 +247,16 @@ class FullNodeRpcClient(RpcClient):
         self,
         tx_id: bytes32,
         include_pending: bool = False,
-    ) -> Optional[Dict[str, Any]]:
+    ) -> Optional[dict[str, Any]]:
         try:
             response = await self.fetch(
                 "get_mempool_item_by_tx_id", {"tx_id": tx_id.hex(), "include_pending": include_pending}
             )
-            return cast(Dict[str, Any], response["mempool_item"])
+            return cast(dict[str, Any], response["mempool_item"])
         except Exception:
             return None
 
-    async def get_mempool_items_by_coin_name(self, coin_name: bytes32) -> Dict[str, Any]:
+    async def get_mempool_items_by_coin_name(self, coin_name: bytes32) -> dict[str, Any]:
         response = await self.fetch("get_mempool_items_by_coin_name", {"coin_name": coin_name.hex()})
         return response
 
@@ -285,8 +285,8 @@ class FullNodeRpcClient(RpcClient):
 
     async def get_fee_estimate(
         self,
-        target_times: Optional[List[int]],
+        target_times: Optional[list[int]],
         cost: Optional[int],
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         response = await self.fetch("get_fee_estimate", {"cost": cost, "target_times": target_times})
         return response