chia-blockchain 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

chia/data_layer/s3_plugin_service.py

@@ -11,10 +11,10 @@ import sys
 import tempfile
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, overload
+from typing import Any, Optional, overload
 from urllib.parse import urlparse
 
-import boto3 as boto3
+import boto3
 import yaml
 from aiohttp import web
 from botocore.exceptions import ClientError
@@ -31,17 +31,17 @@ plugin_version = "0.1.0"
 class StoreConfig:
     id: bytes32
     bucket: Optional[str]
-    urls: Set[str]
+    urls: set[str]
 
     @classmethod
-    def unmarshal(cls, d: Dict[str, Any]) -> StoreConfig:
+    def unmarshal(cls, d: dict[str, Any]) -> StoreConfig:
         upload_bucket = d.get("upload_bucket", None)
         if upload_bucket and len(upload_bucket) == 0:
             upload_bucket = None
 
         return StoreConfig(bytes32.from_hexstr(d["store_id"]), upload_bucket, d.get("download_urls", set()))
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {"store_id": self.id.hex(), "upload_bucket": self.bucket, "download_urls": self.urls}
 
 
@@ -52,7 +52,7 @@ class S3Plugin:
     aws_access_key_id: str
     aws_secret_access_key: str
     server_files_path: Path
-    stores: List[StoreConfig]
+    stores: list[StoreConfig]
     instance_name: str
 
     def __init__(
@@ -61,7 +61,7 @@ class S3Plugin:
         aws_access_key_id: str,
         aws_secret_access_key: str,
         server_files_path: Path,
-        stores: List[StoreConfig],
+        stores: list[StoreConfig],
         instance_name: str,
     ):
         self.boto_resource = boto3.resource(
@@ -373,7 +373,7 @@ class S3Plugin:
                 shutil.move(str(tmp_path), str(path))
 
 
-def read_store_ids_from_config(config: Dict[str, Any]) -> List[StoreConfig]:
+def read_store_ids_from_config(config: dict[str, Any]) -> list[StoreConfig]:
     stores = []
     for store in config.get("stores", []):
         try:
@@ -389,7 +389,7 @@ def read_store_ids_from_config(config: Dict[str, Any]) -> List[StoreConfig]:
     return stores
 
 
-def make_app(config: Dict[str, Any], instance_name: str) -> web.Application:
+def make_app(config: dict[str, Any], instance_name: str) -> web.Application:
     try:
         region = config["aws_credentials"]["region"]
         aws_access_key_id = config["aws_credentials"]["access_key_id"]

chia/data_layer/util/benchmark.py

@@ -23,7 +23,6 @@ async def generate_datastore(num_nodes: int, slow_mode: bool) -> None:
             os.remove(db_path)
 
         async with DataStore.managed(database=db_path) as data_store:
-
             store_id = bytes32(b"0" * 32)
             await data_store.create_tree(store_id)
 

chia/data_layer/util/plugin.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import logging
 from pathlib import Path
-from typing import List
 
 import yaml
 
@@ -10,7 +9,7 @@ from chia.data_layer.data_layer_util import PluginRemote
 from chia.util.log_exceptions import log_exceptions
 
 
-async def load_plugin_configurations(root_path: Path, config_type: str, log: logging.Logger) -> List[PluginRemote]:
+async def load_plugin_configurations(root_path: Path, config_type: str, log: logging.Logger) -> list[PluginRemote]:
     """
     Loads plugin configurations from the specified directory and validates that the contents
     are in the expected JSON format (an array of PluginRemote objects). It gracefully handles errors
@@ -21,7 +20,7 @@ async def load_plugin_configurations(root_path: Path, config_type: str, log: log
         config_type (str): The type of plugins to load ('downloaders' or 'uploaders').
 
     Returns:
-        List[PluginRemote]: A list of valid PluginRemote instances for the specified plugin type.
+        list[PluginRemote]: A list of valid PluginRemote instances for the specified plugin type.
     """
     config_path = root_path / "plugins" / config_type
     config_path.mkdir(parents=True, exist_ok=True)  # Ensure the config directory exists

chia/farmer/farmer.py

@@ -7,10 +7,11 @@ import logging
 import sys
 import time
 import traceback
+from collections.abc import AsyncIterator
 from dataclasses import dataclass
 from math import floor
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, AsyncIterator, ClassVar, Dict, List, Optional, Set, Tuple, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
 
 import aiohttp
 from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
@@ -49,6 +50,7 @@ from chia.util.ints import uint8, uint16, uint32, uint64
 from chia.util.keychain import Keychain
 from chia.util.logging import TimedDuplicateFilter
 from chia.util.profiler import profile_task
+from chia.util.task_referencer import create_referenced_task
 from chia.wallet.derive_keys import (
     find_authentication_sk,
     find_owner_sk,
@@ -69,11 +71,11 @@ UPDATE_POOL_FARMER_INFO_INTERVAL: int = 300
 
 @dataclass(frozen=True)
 class GetPoolInfoResult:
-    pool_info: Dict[str, Any]
+    pool_info: dict[str, Any]
     new_pool_url: Optional[str]
 
 
-def strip_old_entries(pairs: List[Tuple[float, Any]], before: float) -> List[Tuple[float, Any]]:
+def strip_old_entries(pairs: list[tuple[float, Any]], before: float) -> list[tuple[float, Any]]:
     for index, [timestamp, points] in enumerate(pairs):
         if timestamp >= before:
             if index == 0:
@@ -84,12 +86,12 @@ def strip_old_entries(pairs: List[Tuple[float, Any]], before: float) -> List[Tup
 
 
 def increment_pool_stats(
-    pool_states: Dict[bytes32, Any],
+    pool_states: dict[bytes32, Any],
     p2_singleton_puzzlehash: bytes32,
     name: str,
     current_time: float,
     count: int = 1,
-    value: Optional[Union[int, Dict[str, Any]]] = None,
+    value: Optional[Union[int, dict[str, Any]]] = None,
 ) -> None:
     if p2_singleton_puzzlehash not in pool_states:
         return
@@ -124,8 +126,8 @@ class Farmer:
     def __init__(
         self,
         root_path: Path,
-        farmer_config: Dict[str, Any],
-        pool_config: Dict[str, Any],
+        farmer_config: dict[str, Any],
+        pool_config: dict[str, Any],
         consensus_constants: ConsensusConstants,
         local_keychain: Optional[Keychain] = None,
     ):
@@ -135,22 +137,22 @@ class Farmer:
         self.config = farmer_config
         self.pool_config = pool_config
         # Keep track of all sps, keyed on challenge chain signage point hash
-        self.sps: Dict[bytes32, List[farmer_protocol.NewSignagePoint]] = {}
+        self.sps: dict[bytes32, list[farmer_protocol.NewSignagePoint]] = {}
 
         # Keep track of harvester plot identifier (str), target sp index, and PoSpace for each challenge
-        self.proofs_of_space: Dict[bytes32, List[Tuple[str, ProofOfSpace]]] = {}
+        self.proofs_of_space: dict[bytes32, list[tuple[str, ProofOfSpace]]] = {}
 
         # Quality string to plot identifier and challenge_hash, for use with harvester.RequestSignatures
-        self.quality_str_to_identifiers: Dict[bytes32, Tuple[str, bytes32, bytes32, bytes32]] = {}
+        self.quality_str_to_identifiers: dict[bytes32, tuple[str, bytes32, bytes32, bytes32]] = {}
 
         # number of responses to each signage point
-        self.number_of_responses: Dict[bytes32, int] = {}
+        self.number_of_responses: dict[bytes32, int] = {}
 
         # A dictionary of keys to time added. These keys refer to keys in the above 4 dictionaries. This is used
         # to periodically clear the memory
-        self.cache_add_time: Dict[bytes32, uint64] = {}
+        self.cache_add_time: dict[bytes32, uint64] = {}
 
-        self.plot_sync_receivers: Dict[bytes32, Receiver] = {}
+        self.plot_sync_receivers: dict[bytes32, Receiver] = {}
 
         self.cache_clear_task: Optional[asyncio.Task[None]] = None
         self.update_pool_state_task: Optional[asyncio.Task[None]] = None
@@ -166,18 +168,18 @@ class Farmer:
         self.harvester_handshake_task: Optional[asyncio.Task[None]] = None
 
         # From p2_singleton_puzzle_hash to pool state dict
-        self.pool_state: Dict[bytes32, Dict[str, Any]] = {}
+        self.pool_state: dict[bytes32, dict[str, Any]] = {}
 
         # From p2_singleton to auth PrivateKey
-        self.authentication_keys: Dict[bytes32, PrivateKey] = {}
+        self.authentication_keys: dict[bytes32, PrivateKey] = {}
 
         # Last time we updated pool_state based on the config file
         self.last_config_access_time: float = 0
 
-        self.all_root_sks: List[PrivateKey] = []
+        self.all_root_sks: list[PrivateKey] = []
 
         # Use to find missing signage points. (new_signage_point, time)
-        self.prev_signage_point: Optional[Tuple[uint64, farmer_protocol.NewSignagePoint]] = None
+        self.prev_signage_point: Optional[tuple[uint64, farmer_protocol.NewSignagePoint]] = None
 
     @contextlib.asynccontextmanager
     async def manage(self) -> AsyncIterator[None]:
@@ -186,8 +188,8 @@ class Farmer:
             # succeeds or until we need to shut down.
             while not self._shut_down:
                 if await self.setup_keys():
-                    self.update_pool_state_task = asyncio.create_task(self._periodically_update_pool_state_task())
-                    self.cache_clear_task = asyncio.create_task(self._periodically_clear_cache_and_refresh_task())
+                    self.update_pool_state_task = create_referenced_task(self._periodically_update_pool_state_task())
+                    self.cache_clear_task = create_referenced_task(self._periodically_clear_cache_and_refresh_task())
                     log.debug("start_task: initialized")
                     self.started = True
                     return
@@ -197,9 +199,9 @@ class Farmer:
             if sys.getprofile() is not None:
                 self.log.warning("not enabling profiler, getprofile() is already set")
             else:
-                asyncio.create_task(profile_task(self._root_path, "farmer", self.log))
+                create_referenced_task(profile_task(self._root_path, "farmer", self.log), known_unreferenced=True)
 
-        asyncio.create_task(start_task())
+        create_referenced_task(start_task(), known_unreferenced=True)
         try:
             yield
         finally:
@@ -216,7 +218,7 @@ class Farmer:
                 await asyncio.sleep(0.5)  # https://docs.aiohttp.org/en/stable/client_advanced.html#graceful-shutdown
             self.started = False
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> List[Dict[str, Any]]:
+    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
         return default_get_connections(server=self.server, request_node_type=request_node_type)
 
     async def ensure_keychain_proxy(self) -> KeychainProxy:
@@ -229,7 +231,7 @@ class Farmer:
                     raise KeychainProxyConnectionFailure()
         return self.keychain_proxy
 
-    async def get_all_private_keys(self) -> List[Tuple[PrivateKey, bytes]]:
+    async def get_all_private_keys(self) -> list[tuple[PrivateKey, bytes]]:
         keychain_proxy = await self.ensure_keychain_proxy()
         return await keychain_proxy.get_all_private_keys()
 
@@ -285,7 +287,8 @@ class Farmer:
         async def handshake_task() -> None:
             # Wait until the task in `Farmer._start` is done so that we have keys available for the handshake. Bail out
             # early if we need to shut down or if the harvester is not longer connected.
-            while not self.started and not self._shut_down and peer in self.server.get_connections():
+            # TODO: switch to event driven code
+            while not self.started and not self._shut_down and peer in self.server.get_connections():  # noqa: ASYNC110
                 await asyncio.sleep(1)
 
             if self._shut_down:
@@ -309,12 +312,12 @@ class Farmer:
 
         if peer.connection_type is NodeType.HARVESTER:
             self.plot_sync_receivers[peer.peer_node_id] = Receiver(peer, self.plot_sync_callback)
-            self.harvester_handshake_task = asyncio.create_task(handshake_task())
+            self.harvester_handshake_task = create_referenced_task(handshake_task())
 
     def set_server(self, server: ChiaServer) -> None:
         self.server = server
 
-    def state_changed(self, change: str, data: Dict[str, Any]) -> None:
+    def state_changed(self, change: str, data: dict[str, Any]) -> None:
         if self.state_changed_callback is not None:
             self.state_changed_callback(change, data)
 
@@ -348,7 +351,7 @@ class Farmer:
                 url = f"{pool_config.pool_url}/pool_info"
                 async with session.get(url, ssl=ssl_context_for_root(get_mozilla_ca_crt(), log=self.log)) as resp:
                     if resp.ok:
-                        response: Dict[str, Any] = json.loads(await resp.text())
+                        response: dict[str, Any] = json.loads(await resp.text())
                         self.log.info(f"GET /pool_info response: {response}")
                         new_pool_url: Optional[str] = None
                         response_url_str = f"{resp.url}"
@@ -375,7 +378,7 @@ class Farmer:
 
     async def _pool_get_farmer(
         self, pool_config: PoolWalletConfig, authentication_token_timeout: uint8, authentication_sk: PrivateKey
-    ) -> Optional[Dict[str, Any]]:
+    ) -> Optional[dict[str, Any]]:
         authentication_token = get_current_authentication_token(authentication_token_timeout)
         message: bytes32 = std_hash(
             AuthenticationPayload(
@@ -396,7 +399,7 @@ class Farmer:
                     ssl=ssl_context_for_root(get_mozilla_ca_crt(), log=self.log),
                 ) as resp:
                     if resp.ok:
-                        response: Dict[str, Any] = json.loads(await resp.text())
+                        response: dict[str, Any] = json.loads(await resp.text())
                         log_level = logging.INFO
                         if "error_code" in response:
                             log_level = logging.WARNING
@@ -422,7 +425,7 @@ class Farmer:
 
     async def _pool_post_farmer(
         self, pool_config: PoolWalletConfig, authentication_token_timeout: uint8, owner_sk: PrivateKey
-    ) -> Optional[Dict[str, Any]]:
+    ) -> Optional[dict[str, Any]]:
         auth_sk: Optional[PrivateKey] = self.get_authentication_sk(pool_config)
         assert auth_sk is not None
         post_farmer_payload: PostFarmerPayload = PostFarmerPayload(
@@ -444,7 +447,7 @@ class Farmer:
                     ssl=ssl_context_for_root(get_mozilla_ca_crt(), log=self.log),
                 ) as resp:
                     if resp.ok:
-                        response: Dict[str, Any] = json.loads(await resp.text())
+                        response: dict[str, Any] = json.loads(await resp.text())
                         log_level = logging.INFO
                         if "error_code" in response:
                             log_level = logging.WARNING
@@ -492,7 +495,7 @@ class Farmer:
                     ssl=ssl_context_for_root(get_mozilla_ca_crt(), log=self.log),
                 ) as resp:
                     if resp.ok:
-                        response: Dict[str, Any] = json.loads(await resp.text())
+                        response: dict[str, Any] = json.loads(await resp.text())
                         log_level = logging.INFO
                         if "error_code" in response:
                             log_level = logging.WARNING
@@ -525,7 +528,7 @@ class Farmer:
     async def update_pool_state(self) -> None:
         config = load_config(self._root_path, "config.yaml")
 
-        pool_config_list: List[PoolWalletConfig] = load_pool_config(self._root_path)
+        pool_config_list: list[PoolWalletConfig] = load_pool_config(self._root_path)
         for pool_config in pool_config_list:
             p2_singleton_puzzle_hash = pool_config.p2_singleton_puzzle_hash
 
@@ -598,7 +601,7 @@ class Farmer:
                     pool_state["next_farmer_update"] = time.time() + UPDATE_POOL_FARMER_INFO_INTERVAL
                     authentication_token_timeout = pool_state["authentication_token_timeout"]
 
-                    async def update_pool_farmer_info() -> Tuple[Optional[GetFarmerResponse], Optional[PoolErrorCode]]:
+                    async def update_pool_farmer_info() -> tuple[Optional[GetFarmerResponse], Optional[PoolErrorCode]]:
                         # Run a GET /farmer to see if the farmer is already known by the pool
                         response = await self._pool_get_farmer(
                             pool_config, authentication_token_timeout, authentication_sk
@@ -662,19 +665,19 @@ class Farmer:
                 tb = traceback.format_exc()
                 self.log.error(f"Exception in update_pool_state for {pool_config.pool_url}, {e} {tb}")
 
-    def get_public_keys(self) -> List[G1Element]:
+    def get_public_keys(self) -> list[G1Element]:
         return [child_sk.get_g1() for child_sk in self._private_keys]
 
-    def get_private_keys(self) -> List[PrivateKey]:
+    def get_private_keys(self) -> list[PrivateKey]:
         return self._private_keys
 
-    async def get_reward_targets(self, search_for_private_key: bool, max_ph_to_search: int = 500) -> Dict[str, Any]:
+    async def get_reward_targets(self, search_for_private_key: bool, max_ph_to_search: int = 500) -> dict[str, Any]:
         if search_for_private_key:
             all_sks = await self.get_all_private_keys()
             have_farmer_sk, have_pool_sk = False, False
-            search_addresses: List[bytes32] = [self.farmer_target, self.pool_target]
+            search_addresses: list[bytes32] = [self.farmer_target, self.pool_target]
             for sk, _ in all_sks:
-                found_addresses: Set[bytes32] = match_address_to_sk(sk, search_addresses, max_ph_to_search)
+                found_addresses: set[bytes32] = match_address_to_sk(sk, search_addresses, max_ph_to_search)
 
                 if not have_farmer_sk and self.farmer_target in found_addresses:
                     search_addresses.remove(self.farmer_target)
@@ -763,8 +766,8 @@ class Farmer:
 
         return None
 
-    async def get_harvesters(self, counts_only: bool = False) -> Dict[str, Any]:
-        harvesters: List[Dict[str, Any]] = []
+    async def get_harvesters(self, counts_only: bool = False) -> dict[str, Any]:
+        harvesters: list[dict[str, Any]] = []
         for connection in self.server.get_connections(NodeType.HARVESTER):
             self.log.debug(f"get_harvesters host: {connection.peer_info.host}, node_id: {connection.peer_node_id}")
             receiver = self.plot_sync_receivers.get(connection.peer_node_id)
@@ -785,7 +788,7 @@ class Farmer:
 
     def check_missing_signage_points(
         self, timestamp: uint64, new_signage_point: farmer_protocol.NewSignagePoint
-    ) -> Optional[Tuple[uint64, uint32]]:
+    ) -> Optional[tuple[uint64, uint32]]:
         if self.prev_signage_point is None:
             self.prev_signage_point = (timestamp, new_signage_point)
             return None
@@ -836,7 +839,7 @@ class Farmer:
             try:
                 if time_slept > self.constants.SUB_SLOT_TIME_TARGET:
                     now = time.time()
-                    removed_keys: List[bytes32] = []
+                    removed_keys: list[bytes32] = []
                     for key, add_time in self.cache_add_time.items():
                         if now - float(add_time) > self.constants.SUB_SLOT_TIME_TARGET * 3:
                             self.sps.pop(key, None)

chia/farmer/farmer_api.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 import logging
 import time
-from typing import Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
 
 import aiohttp
 from chia_rs import AugSchemeMPL, G2Element, PrivateKey
@@ -30,6 +30,7 @@ from chia.protocols.pool_protocol import (
     get_current_authentication_token,
 )
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.server.api_protocol import ApiMetadata
 from chia.server.outbound_message import Message, NodeType, make_msg
 from chia.server.server import ssl_context_for_root
 from chia.server.ws_connection import WSChiaConnection
@@ -43,13 +44,18 @@ from chia.types.blockchain_format.proof_of_space import (
     verify_and_get_quality_string,
 )
 from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.util.api_decorators import api_request
 from chia.util.ints import uint8, uint16, uint32, uint64
 
 
 class FarmerAPI:
+    if TYPE_CHECKING:
+        from chia.server.api_protocol import ApiProtocol
+
+        _protocol_check: ClassVar[ApiProtocol] = cast("FarmerAPI", None)
+
     log: logging.Logger
     farmer: Farmer
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
 
     def __init__(self, farmer: Farmer) -> None:
         self.log = logging.getLogger(__name__)
@@ -58,7 +64,7 @@ class FarmerAPI:
     def ready(self) -> bool:
         return self.farmer.started
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def new_proof_of_space(
         self, new_proof_of_space: harvester_protocol.NewProofOfSpace, peer: WSChiaConnection
     ) -> None:
@@ -117,7 +123,7 @@ class FarmerAPI:
                 if new_proof_of_space.farmer_reward_address_override is not None:
                     self.farmer.notify_farmer_reward_taken_by_harvester_as_fee(sp, new_proof_of_space)
 
-                sp_src_data: Optional[List[Optional[SignatureRequestSourceData]]] = None
+                sp_src_data: Optional[list[Optional[SignatureRequestSourceData]]] = None
                 if (
                     new_proof_of_space.include_source_signature_data
                     or new_proof_of_space.farmer_reward_address_override is not None
@@ -182,7 +188,7 @@ class FarmerAPI:
                 if p2_singleton_puzzle_hash not in self.farmer.pool_state:
                     self.farmer.log.info(f"Did not find pool info for {p2_singleton_puzzle_hash}")
                     return
-                pool_state_dict: Dict[str, Any] = self.farmer.pool_state[p2_singleton_puzzle_hash]
+                pool_state_dict: dict[str, Any] = self.farmer.pool_state[p2_singleton_puzzle_hash]
                 pool_url = pool_state_dict["pool_config"].pool_url
                 if pool_url == "":
                     # `pool_url == ""` means solo plotNFT farming
@@ -268,7 +274,7 @@ class FarmerAPI:
 
                 # The plot key is 2/2 so we need the harvester's half of the signature
                 m_to_sign = payload.get_hash()
-                m_src_data: Optional[List[Optional[SignatureRequestSourceData]]] = None
+                m_src_data: Optional[list[Optional[SignatureRequestSourceData]]] = None
 
                 if (  # pragma: no cover
                     new_proof_of_space.include_source_signature_data
@@ -374,7 +380,7 @@ class FarmerAPI:
                                 )
                                 return
 
-                            pool_response: Dict[str, Any] = json.loads(await resp.text())
+                            pool_response: dict[str, Any] = json.loads(await resp.text())
                             self.farmer.log.info(f"Pool response: {pool_response}")
                             if "error_code" in pool_response:
                                 self.farmer.log.error(
@@ -471,7 +477,7 @@ class FarmerAPI:
 
                 return
 
-    @api_request()
+    @metadata.request()
     async def respond_signatures(self, response: harvester_protocol.RespondSignatures) -> None:
         request = self._process_respond_signatures(response)
         if request is None:
@@ -489,7 +495,7 @@ class FarmerAPI:
     FARMER PROTOCOL (FARMER <-> FULL NODE)
     """
 
-    @api_request()
+    @metadata.request()
     async def new_signage_point(self, new_signage_point: farmer_protocol.NewSignagePoint) -> None:
         if new_signage_point.challenge_chain_sp not in self.farmer.sps:
             self.farmer.sps[new_signage_point.challenge_chain_sp] = []
@@ -501,7 +507,7 @@ class FarmerAPI:
         self.farmer.sps[new_signage_point.challenge_chain_sp].append(new_signage_point)
 
         try:
-            pool_difficulties: List[PoolDifficulty] = []
+            pool_difficulties: list[PoolDifficulty] = []
             for p2_singleton_puzzle_hash, pool_dict in self.farmer.pool_state.items():
                 if pool_dict["pool_config"].pool_url == "":
                     # Self pooling
@@ -558,7 +564,7 @@ class FarmerAPI:
             {"sp_hash": new_signage_point.challenge_chain_sp, "missing_signage_points": missing_signage_points},
         )
 
-    @api_request()
+    @metadata.request()
     async def request_signed_values(self, full_node_request: farmer_protocol.RequestSignedValues) -> Optional[Message]:
         if full_node_request.quality_string not in self.farmer.quality_str_to_identifiers:
             self.farmer.log.error(f"Do not have quality string {full_node_request.quality_string}")
@@ -568,7 +574,7 @@ class FarmerAPI:
             full_node_request.quality_string
         ]
 
-        message_data: Optional[List[Optional[SignatureRequestSourceData]]] = None
+        message_data: Optional[list[Optional[SignatureRequestSourceData]]] = None
 
         if full_node_request.foliage_block_data is not None:
             message_data = [
@@ -607,7 +613,7 @@ class FarmerAPI:
 
         return make_msg(ProtocolMessageTypes.signed_values, signed_values)
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def farming_info(self, request: farmer_protocol.FarmingInfo, peer: WSChiaConnection) -> None:
         self.farmer.state_changed(
             "new_farming_info",
@@ -625,35 +631,35 @@ class FarmerAPI:
             },
         )
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def respond_plots(self, _: harvester_protocol.RespondPlots, peer: WSChiaConnection) -> None:
         self.farmer.log.warning(f"Respond plots came too late from: {peer.get_peer_logging()}")
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def plot_sync_start(self, message: PlotSyncStart, peer: WSChiaConnection) -> None:
         await self.farmer.plot_sync_receivers[peer.peer_node_id].sync_started(message)
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def plot_sync_loaded(self, message: PlotSyncPlotList, peer: WSChiaConnection) -> None:
         await self.farmer.plot_sync_receivers[peer.peer_node_id].process_loaded(message)
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def plot_sync_removed(self, message: PlotSyncPathList, peer: WSChiaConnection) -> None:
         await self.farmer.plot_sync_receivers[peer.peer_node_id].process_removed(message)
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def plot_sync_invalid(self, message: PlotSyncPathList, peer: WSChiaConnection) -> None:
         await self.farmer.plot_sync_receivers[peer.peer_node_id].process_invalid(message)
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def plot_sync_keys_missing(self, message: PlotSyncPathList, peer: WSChiaConnection) -> None:
         await self.farmer.plot_sync_receivers[peer.peer_node_id].process_keys_missing(message)
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def plot_sync_duplicates(self, message: PlotSyncPathList, peer: WSChiaConnection) -> None:
         await self.farmer.plot_sync_receivers[peer.peer_node_id].process_duplicates(message)
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def plot_sync_done(self, message: PlotSyncDone, peer: WSChiaConnection) -> None:
         await self.farmer.plot_sync_receivers[peer.peer_node_id].sync_done(message)
 

chia/full_node/block_height_map.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import Optional
 
 import aiofiles
 
@@ -20,7 +20,7 @@ log = logging.getLogger(__name__)
 @streamable
 @dataclass(frozen=True)
 class SesCache(Streamable):
-    content: List[Tuple[uint32, bytes]]
+    content: list[tuple[uint32, bytes]]
 
 
 class BlockHeightMap:
@@ -38,7 +38,7 @@ class BlockHeightMap:
     # All sub-epoch summaries that have been included in the blockchain from the beginning until and including the peak
     # (height_included, SubEpochSummary). Note: ONLY for the blocks in the path to the peak
     # The value is a serialized SubEpochSummary object
-    __sub_epoch_summaries: Dict[uint32, bytes]
+    __sub_epoch_summaries: dict[uint32, bytes]
 
     # count how many blocks have been added since the cache was last written to
     # disk
@@ -124,7 +124,7 @@ class BlockHeightMap:
 
         log.info(
             f"Loaded sub-epoch-summaries: {len(self.__sub_epoch_summaries)} "
-            f"height-to-hash: {len(self.__height_to_hash)//32}"
+            f"height-to-hash: {len(self.__height_to_hash) // 32}"
         )
 
         # prepopulate the height -> hash mapping
@@ -194,7 +194,7 @@ class BlockHeightMap:
             async with self.db.reader_no_transaction() as conn:
                 async with conn.execute(query, (window_end, height)) as cursor:
                     # maps block-hash -> (height, prev-hash, sub-epoch-summary)
-                    ordered: Dict[bytes32, Tuple[uint32, bytes32, Optional[bytes]]] = {}
+                    ordered: dict[bytes32, tuple[uint32, bytes32, Optional[bytes]]] = {}
 
                     for r in await cursor.fetchall():
                         ordered[r[0]] = (r[2], r[1], r[3])
@@ -267,5 +267,5 @@ class BlockHeightMap:
     def get_ses(self, height: uint32) -> SubEpochSummary:
         return SubEpochSummary.from_bytes(self.__sub_epoch_summaries[height])
 
-    def get_ses_heights(self) -> List[uint32]:
+    def get_ses_heights(self) -> list[uint32]:
         return sorted(self.__sub_epoch_summaries.keys())