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

chia/farmer/farmer.py

@@ -11,7 +11,7 @@ from collections.abc import AsyncIterator
 from dataclasses import dataclass
 from math import floor
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 import aiohttp
 from chia_rs import AugSchemeMPL, ConsensusConstants, G1Element, G2Element, PrivateKey, ProofOfSpace
@@ -70,7 +70,7 @@ UPDATE_POOL_FARMER_INFO_INTERVAL: int = 300
 @dataclass(frozen=True)
 class GetPoolInfoResult:
     pool_info: dict[str, Any]
-    new_pool_url: Optional[str]
+    new_pool_url: str | None
 
 
 def strip_old_entries(pairs: list[tuple[float, Any]], before: float) -> list[tuple[float, Any]]:
@@ -89,7 +89,7 @@ def increment_pool_stats(
     name: str,
     current_time: float,
     count: int = 1,
-    value: Optional[Union[int, dict[str, Any]]] = None,
+    value: int | dict[str, Any] | None = None,
 ) -> None:
     if p2_singleton_puzzlehash not in pool_states:
         return
@@ -127,9 +127,9 @@ class Farmer:
         farmer_config: dict[str, Any],
         pool_config: dict[str, Any],
         consensus_constants: ConsensusConstants,
-        local_keychain: Optional[Keychain] = None,
+        local_keychain: Keychain | None = None,
     ):
-        self.keychain_proxy: Optional[KeychainProxy] = None
+        self.keychain_proxy: KeychainProxy | None = None
         self.local_keychain = local_keychain
         self._root_path = root_path
         self.config = farmer_config
@@ -155,18 +155,18 @@ class Farmer:
 
         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
+        self.cache_clear_task: asyncio.Task[None] | None = None
+        self.update_pool_state_task: asyncio.Task[None] | None = None
         self.constants = consensus_constants
         self._shut_down = False
         self.server: Any = None
-        self.state_changed_callback: Optional[StateChangedProtocol] = None
+        self.state_changed_callback: StateChangedProtocol | None = None
         self.log = log
         self.log.addFilter(TimedDuplicateFilter("No pool specific authentication_token_timeout.*", 60 * 10))
         self.log.addFilter(TimedDuplicateFilter("No pool specific difficulty has been set.*", 60 * 10))
 
         self.started = False
-        self.harvester_handshake_task: Optional[asyncio.Task[None]] = None
+        self.harvester_handshake_task: asyncio.Task[None] | None = None
 
         # From p2_singleton_puzzle_hash to pool state dict
         self.pool_state: dict[bytes32, dict[str, Any]] = {}
@@ -180,7 +180,7 @@ class Farmer:
         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: tuple[uint64, farmer_protocol.NewSignagePoint] | None = None
 
     @contextlib.asynccontextmanager
     async def manage(self) -> AsyncIterator[None]:
@@ -219,7 +219,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: NodeType | None) -> list[dict[str, Any]]:
         return default_get_connections(server=self.server, request_node_type=request_node_type)
 
     async def ensure_keychain_proxy(self) -> KeychainProxy:
@@ -312,7 +312,7 @@ class Farmer:
             self.harvester_handshake_task = None
 
         if peer.connection_type is NodeType.HARVESTER:
-            self.plot_sync_receivers[peer.peer_node_id] = Receiver(peer, self.plot_sync_callback)
+            self.plot_sync_receivers[peer.peer_node_id] = Receiver(peer, self.plot_sync_callback, self.constants)
             self.harvester_handshake_task = create_referenced_task(handshake_task())
 
     def set_server(self, server: ChiaServer) -> None:
@@ -339,14 +339,14 @@ class Farmer:
             del self.plot_sync_receivers[connection.peer_node_id]
             self.state_changed("harvester_removed", {"node_id": connection.peer_node_id})
 
-    async def plot_sync_callback(self, peer_id: bytes32, delta: Optional[Delta]) -> None:
+    async def plot_sync_callback(self, peer_id: bytes32, delta: Delta | None) -> None:
         log.debug(f"plot_sync_callback: peer_id {peer_id}, delta {delta}")
         receiver: Receiver = self.plot_sync_receivers[peer_id]
         harvester_updated: bool = delta is not None and not delta.empty()
         if receiver.initial_sync() or harvester_updated:
             self.state_changed("harvester_update", receiver.to_dict(True))
 
-    async def _pool_get_pool_info(self, pool_config: PoolWalletConfig) -> Optional[GetPoolInfoResult]:
+    async def _pool_get_pool_info(self, pool_config: PoolWalletConfig) -> GetPoolInfoResult | None:
         try:
             async with aiohttp.ClientSession(trust_env=True) as session:
                 url = f"{pool_config.pool_url}/pool_info"
@@ -354,7 +354,7 @@ class Farmer:
                     if resp.ok:
                         response: dict[str, Any] = json.loads(await resp.text())
                         self.log.info(f"GET /pool_info response: {response}")
-                        new_pool_url: Optional[str] = None
+                        new_pool_url: str | None = None
                         response_url_str = f"{resp.url}"
                         if (
                             response_url_str != url
@@ -379,7 +379,7 @@ class Farmer:
 
     async def _pool_get_farmer(
         self, pool_config: PoolWalletConfig, authentication_token_timeout: uint8, authentication_sk: PrivateKey
-    ) -> Optional[dict[str, Any]]:
+    ) -> dict[str, Any] | None:
         authentication_token = get_current_authentication_token(authentication_token_timeout)
         message: bytes32 = std_hash(
             AuthenticationPayload(
@@ -387,7 +387,7 @@ class Farmer:
             )
         )
         signature: G2Element = AugSchemeMPL.sign(authentication_sk, message)
-        get_farmer_params: dict[str, Union[str, int]] = {
+        get_farmer_params: dict[str, str | int] = {
             "launcher_id": pool_config.launcher_id.hex(),
             "authentication_token": authentication_token,
             "signature": bytes(signature).hex(),
@@ -426,8 +426,8 @@ class Farmer:
 
     async def _pool_post_farmer(
         self, pool_config: PoolWalletConfig, authentication_token_timeout: uint8, owner_sk: PrivateKey
-    ) -> Optional[dict[str, Any]]:
-        auth_sk: Optional[PrivateKey] = self.get_authentication_sk(pool_config)
+    ) -> dict[str, Any] | None:
+        auth_sk: PrivateKey | None = self.get_authentication_sk(pool_config)
         assert auth_sk is not None
         post_farmer_payload: PostFarmerPayload = PostFarmerPayload(
             pool_config.launcher_id,
@@ -475,7 +475,7 @@ class Farmer:
     async def _pool_put_farmer(
         self, pool_config: PoolWalletConfig, authentication_token_timeout: uint8, owner_sk: PrivateKey
     ) -> None:
-        auth_sk: Optional[PrivateKey] = self.get_authentication_sk(pool_config)
+        auth_sk: PrivateKey | None = self.get_authentication_sk(pool_config)
         assert auth_sk is not None
         put_farmer_payload: PutFarmerPayload = PutFarmerPayload(
             pool_config.launcher_id,
@@ -518,10 +518,10 @@ class Farmer:
                 pool_config.p2_singleton_puzzle_hash, f"Exception in PUT /farmer {pool_config.pool_url}, {e}"
             )
 
-    def get_authentication_sk(self, pool_config: PoolWalletConfig) -> Optional[PrivateKey]:
+    def get_authentication_sk(self, pool_config: PoolWalletConfig) -> PrivateKey | None:
         if pool_config.p2_singleton_puzzle_hash in self.authentication_keys:
             return self.authentication_keys[pool_config.p2_singleton_puzzle_hash]
-        auth_sk: Optional[PrivateKey] = find_authentication_sk(self.all_root_sks, pool_config.owner_public_key)
+        auth_sk: PrivateKey | None = find_authentication_sk(self.all_root_sks, pool_config.owner_public_key)
         if auth_sk is not None:
             self.authentication_keys[pool_config.p2_singleton_puzzle_hash] = auth_sk
         return auth_sk
@@ -534,7 +534,7 @@ class Farmer:
             p2_singleton_puzzle_hash = pool_config.p2_singleton_puzzle_hash
 
             try:
-                authentication_sk: Optional[PrivateKey] = self.get_authentication_sk(pool_config)
+                authentication_sk: PrivateKey | None = self.get_authentication_sk(pool_config)
 
                 if authentication_sk is None:
                     self.log.error(f"Could not find authentication sk for {p2_singleton_puzzle_hash}")
@@ -602,13 +602,13 @@ 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[GetFarmerResponse | None, PoolErrorCode | None]:
                         # 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
                         )
-                        farmer_response: Optional[GetFarmerResponse] = None
-                        error_code_response: Optional[PoolErrorCode] = None
+                        farmer_response: GetFarmerResponse | None = None
+                        error_code_response: PoolErrorCode | None = None
                         if response is not None:
                             if "error_code" not in response:
                                 farmer_response = GetFarmerResponse.from_json_dict(response)
@@ -701,7 +701,7 @@ class Farmer:
             "pool_target": self.pool_target_encoded,
         }
 
-    def set_reward_targets(self, farmer_target_encoded: Optional[str], pool_target_encoded: Optional[str]) -> None:
+    def set_reward_targets(self, farmer_target_encoded: str | None, pool_target_encoded: str | None) -> None:
         with lock_and_load_config(self._root_path, "config.yaml") as config:
             if farmer_target_encoded is not None:
                 self.farmer_target_encoded = farmer_target_encoded
@@ -733,13 +733,13 @@ class Farmer:
 
         self.log.warning(f"Launcher id: {launcher_id} not found")
 
-    async def generate_login_link(self, launcher_id: bytes32) -> Optional[str]:
+    async def generate_login_link(self, launcher_id: bytes32) -> str | None:
         for pool_state in self.pool_state.values():
             pool_config: PoolWalletConfig = pool_state["pool_config"]
             if pool_config.launcher_id != launcher_id:
                 continue
 
-            authentication_sk: Optional[PrivateKey] = self.get_authentication_sk(pool_config)
+            authentication_sk: PrivateKey | None = self.get_authentication_sk(pool_config)
             if authentication_sk is None:
                 self.log.error(f"Could not find authentication sk for {pool_config.p2_singleton_puzzle_hash}")
                 continue
@@ -781,14 +781,14 @@ class Farmer:
         return {"harvesters": harvesters}
 
     def get_receiver(self, node_id: bytes32) -> Receiver:
-        receiver: Optional[Receiver] = self.plot_sync_receivers.get(node_id)
+        receiver: Receiver | None = self.plot_sync_receivers.get(node_id)
         if receiver is None:
             raise KeyError(f"Receiver missing for {node_id}")
         return receiver
 
     def check_missing_signage_points(
         self, timestamp: uint64, new_signage_point: farmer_protocol.NewSignagePoint
-    ) -> Optional[tuple[uint64, uint32]]:
+    ) -> tuple[uint64, uint32] | None:
         if self.prev_signage_point is None:
             self.prev_signage_point = (timestamp, new_signage_point)
             return None

chia/farmer/farmer_api.py

@@ -3,10 +3,10 @@ from __future__ import annotations
 import json
 import logging
 import time
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar
 
 import aiohttp
-from chia_rs import AugSchemeMPL, G2Element, PlotSize, PoolTarget, PrivateKey, ProofOfSpace
+from chia_rs import AugSchemeMPL, G2Element, PlotParam, PoolTarget, PrivateKey, ProofOfSpace
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64
 from packaging.version import Version
@@ -51,9 +51,11 @@ from chia.types.blockchain_format.proof_of_space import (
 
 class FarmerAPI:
     if TYPE_CHECKING:
-        from chia.server.api_protocol import ApiProtocol
+        from chia.apis.farmer_stub import FarmerApiStub
 
-        _protocol_check: ClassVar[ApiProtocol] = cast("FarmerAPI", None)
+        # Verify this class implements the FarmerApiStub protocol
+        def _protocol_check(self: FarmerAPI) -> FarmerApiStub:
+            return self
 
     log: logging.Logger
     farmer: Farmer
@@ -104,6 +106,7 @@ class FarmerAPI:
                 new_proof_of_space.challenge_hash,
                 new_proof_of_space.sp_hash,
                 height=sp.peak_height,
+                prev_transaction_block_height=sp.last_tx_height,
             )
             if computed_quality_string is None:
                 plotid: bytes32 = get_plot_id(new_proof_of_space.proof)
@@ -115,11 +118,9 @@ class FarmerAPI:
             required_iters: uint64 = calculate_iterations_quality(
                 self.farmer.constants,
                 computed_quality_string,
-                new_proof_of_space.proof.size(),
+                new_proof_of_space.proof.param(),
                 sp.difficulty,
                 new_proof_of_space.sp_hash,
-                sp.sub_slot_iters,
-                sp.last_tx_height,
             )
 
             # If the iters are good enough to make a block, proceed with the block making flow
@@ -127,7 +128,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: list[SignatureRequestSourceData | None] | None = None
                 if (
                     new_proof_of_space.include_source_signature_data
                     or new_proof_of_space.farmer_reward_address_override is not None
@@ -224,11 +225,9 @@ class FarmerAPI:
                 required_iters = calculate_iterations_quality(
                     self.farmer.constants,
                     computed_quality_string,
-                    new_proof_of_space.proof.size(),
+                    new_proof_of_space.proof.param(),
                     pool_state_dict["current_difficulty"],
                     new_proof_of_space.sp_hash,
-                    sp.sub_slot_iters,
-                    sp.last_tx_height,
                 )
                 if required_iters >= calculate_sp_interval_iters(
                     self.farmer.constants, self.farmer.constants.POOL_SUB_SLOT_ITERS
@@ -280,7 +279,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: list[SignatureRequestSourceData | None] | None = None
 
                 if (  # pragma: no cover
                     new_proof_of_space.include_source_signature_data
@@ -313,7 +312,7 @@ class FarmerAPI:
 
                 assert len(response.message_signatures) == 1
 
-                plot_signature: Optional[G2Element] = None
+                plot_signature: G2Element | None = None
                 for sk in self.farmer.get_private_keys():
                     pk = sk.get_g1()
                     if pk == response.farmer_pk:
@@ -328,9 +327,7 @@ class FarmerAPI:
                         )
                         assert AugSchemeMPL.verify(agg_pk, m_to_sign, plot_signature)
 
-                authentication_sk: Optional[PrivateKey] = self.farmer.get_authentication_sk(
-                    pool_state_dict["pool_config"]
-                )
+                authentication_sk: PrivateKey | None = self.farmer.get_authentication_sk(pool_state_dict["pool_config"])
                 if authentication_sk is None:
                     self.farmer.log.error(f"No authentication sk for {p2_singleton_puzzle_hash}")
                     increment_pool_stats(
@@ -507,11 +504,17 @@ class FarmerAPI:
 
         # Process each partial proof chain through solver service to get full proofs
         for partial_proof in partial_proof_data.partial_proofs:
-            solver_info = SolverInfo(partial_proof=partial_proof)
+            solver_info = SolverInfo(
+                partial_proof=partial_proof,
+                plot_id=partial_proof_data.plot_id,
+                strength=partial_proof_data.strength,
+                size=partial_proof_data.plot_size,
+            )
 
+            key = bytes(partial_proof)
             try:
                 # store pending request data for matching with response
-                self.farmer.pending_solver_requests[partial_proof] = {
+                self.farmer.pending_solver_requests[key] = {
                     "proof_data": partial_proof_data,
                     "peer": peer,
                 }
@@ -519,15 +522,15 @@ class FarmerAPI:
                 # send solve request to all solver connections
                 msg = make_msg(ProtocolMessageTypes.solve, solver_info)
                 await self.farmer.server.send_to_all([msg], NodeType.SOLVER)
-                self.farmer.log.debug(f"Sent solve request for partial proof {partial_proof.hex()[:10]}...")
+                self.farmer.log.debug(f"Sent solve request for partial proof {partial_proof.proof_fragments[:5]}...")
 
             except Exception as e:
                 self.farmer.log.error(
-                    f"Failed to call solver service for partial proof {partial_proof.hex()[:10]}...: {e}"
+                    f"Failed to call solver service for partial proof {partial_proof.proof_fragments[:5]}...: {e}"
                 )
                 # clean up pending request
-                if partial_proof in self.farmer.pending_solver_requests:
-                    del self.farmer.pending_solver_requests[partial_proof]
+                if key in self.farmer.pending_solver_requests:
+                    del self.farmer.pending_solver_requests[key]
 
     @metadata.request()
     async def solution_response(self, response: SolverResponse, peer: WSChiaConnection) -> None:
@@ -539,14 +542,15 @@ class FarmerAPI:
 
         # find the matching pending request using partial_proof
 
-        if response.partial_proof not in self.farmer.pending_solver_requests:
+        key = bytes(response.partial_proof)
+        if key not in self.farmer.pending_solver_requests:
             self.farmer.log.warning(
-                f"Received solver response for unknown partial proof {response.partial_proof.hex()}"
+                f"Received solver response for unknown partial proof {response.partial_proof.proof_fragments[:5]}"
             )
             return
 
         # get the original request data
-        request_data = self.farmer.pending_solver_requests.pop(response.partial_proof)
+        request_data = self.farmer.pending_solver_requests.pop(key)
         proof_data = request_data["proof_data"]
         original_peer = request_data["peer"]
         partial_proof = response.partial_proof
@@ -554,7 +558,9 @@ class FarmerAPI:
         # create the proof of space with the solver's proof
         proof_bytes = response.proof
         if proof_bytes is None or len(proof_bytes) == 0:
-            self.farmer.log.warning(f"Received empty proof from solver for proof {partial_proof.hex()}...")
+            self.farmer.log.warning(
+                f"Received empty proof from solver for proof {partial_proof.proof_fragments[:5]}..."
+            )
             return
 
         sp_challenge_hash = proof_data.challenge_hash
@@ -651,7 +657,7 @@ class FarmerAPI:
                 new_signage_point.challenge_chain_sp,
                 pool_difficulties,
                 uint8(
-                    calculate_prefix_bits(self.farmer.constants, new_signage_point.peak_height, PlotSize.make_v1(32))
+                    calculate_prefix_bits(self.farmer.constants, new_signage_point.peak_height, PlotParam.make_v1(32))
                 ),
             )
 
@@ -692,7 +698,7 @@ class FarmerAPI:
         )
 
     @metadata.request()
-    async def request_signed_values(self, full_node_request: farmer_protocol.RequestSignedValues) -> Optional[Message]:
+    async def request_signed_values(self, full_node_request: farmer_protocol.RequestSignedValues) -> Message | None:
         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}")
             return None
@@ -701,7 +707,7 @@ class FarmerAPI:
             full_node_request.quality_string
         ]
 
-        message_data: Optional[list[Optional[SignatureRequestSourceData]]] = None
+        message_data: list[SignatureRequestSourceData | None] | None = None
 
         if full_node_request.foliage_block_data is not None:
             message_data = [
@@ -792,7 +798,7 @@ class FarmerAPI:
 
     def _process_respond_signatures(
         self, response: harvester_protocol.RespondSignatures
-    ) -> Optional[Union[DeclareProofOfSpace, SignedValues]]:
+    ) -> DeclareProofOfSpace | SignedValues | None:
         """
         Processing the responded signatures happens when receiving an unsolicited request for an SP or when receiving
         the signature response for a block from a harvester.
@@ -803,6 +809,7 @@ class FarmerAPI:
         is_sp_signatures: bool = False
         sps = self.farmer.sps[response.sp_hash]
         peak_height = sps[0].peak_height
+        last_tx_height = sps[0].last_tx_height
         signage_point_index = sps[0].signage_point_index
         found_sp_hash_debug = False
         for sp_candidate in sps:
@@ -821,7 +828,12 @@ class FarmerAPI:
         include_taproot: bool = pospace.pool_contract_puzzle_hash is not None
 
         computed_quality_string = verify_and_get_quality_string(
-            pospace, self.farmer.constants, response.challenge_hash, response.sp_hash, height=peak_height
+            pospace,
+            self.farmer.constants,
+            response.challenge_hash,
+            response.sp_hash,
+            height=peak_height,
+            prev_transaction_block_height=last_tx_height,
         )
         if computed_quality_string is None:
             self.farmer.log.warning(f"Have invalid PoSpace {pospace}")
@@ -867,9 +879,9 @@ class FarmerAPI:
                             )
                             return None
 
-                        pool_target: Optional[PoolTarget] = PoolTarget(self.farmer.pool_target, uint32(0))
+                        pool_target: PoolTarget | None = PoolTarget(self.farmer.pool_target, uint32(0))
                         assert pool_target is not None
-                        pool_target_signature: Optional[G2Element] = AugSchemeMPL.sign(
+                        pool_target_signature: G2Element | None = AugSchemeMPL.sign(
                             self.farmer.pool_sks_map[pool_pk], bytes(pool_target)
                         )
                     else:

chia/farmer/farmer_rpc_api.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import dataclasses
 import operator
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, cast
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
@@ -33,7 +34,7 @@ class PaginatedRequestData(Protocol):
 @dataclasses.dataclass(frozen=True)
 class FilterItem(Streamable):
     key: str
-    value: Optional[str]
+    value: str | None
 
 
 @streamable
@@ -108,7 +109,7 @@ class FarmerRpcApi:
             "/connect_to_solver": self.connect_to_solver,
         }
 
-    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]:
         payloads = []
 
         if change_data is None:
@@ -363,7 +364,7 @@ class FarmerRpcApi:
 
     async def get_pool_login_link(self, request: dict[str, Any]) -> EndpointResult:
         launcher_id: bytes32 = bytes32.from_hexstr(request["launcher_id"])
-        login_link: Optional[str] = await self.service.generate_login_link(launcher_id)
+        login_link: str | None = await self.service.generate_login_link(launcher_id)
         if login_link is None:
             raise ValueError(f"Failed to generate login link for {launcher_id.hex()}")
         return {"login_link": login_link}

chia/farmer/farmer_rpc_client.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Optional, cast
+from typing import Any, cast
 
 from chia_rs.sized_bytes import bytes32
 
@@ -18,7 +18,7 @@ class FarmerRpcClient(RpcClient):
     to the full node.
     """
 
-    async def get_signage_point(self, sp_hash: bytes32) -> Optional[dict[str, Any]]:
+    async def get_signage_point(self, sp_hash: bytes32) -> dict[str, Any] | None:
         try:
             return await self.fetch("get_signage_point", {"sp_hash": sp_hash.hex()})
         except ValueError:  # not synced
@@ -44,8 +44,8 @@ class FarmerRpcClient(RpcClient):
 
     async def set_reward_targets(
         self,
-        farmer_target: Optional[str] = None,
-        pool_target: Optional[str] = None,
+        farmer_target: str | None = None,
+        pool_target: str | None = None,
     ) -> dict[str, Any]:
         request = {}
         if farmer_target is not None:
@@ -79,10 +79,10 @@ class FarmerRpcClient(RpcClient):
     async def get_harvester_plots_duplicates(self, request: PlotPathRequestData) -> dict[str, Any]:
         return await self.fetch("get_harvester_plots_duplicates", recurse_jsonify(request))
 
-    async def get_pool_login_link(self, launcher_id: bytes32) -> Optional[str]:
+    async def get_pool_login_link(self, launcher_id: bytes32) -> str | None:
         try:
             result = await self.fetch("get_pool_login_link", {"launcher_id": launcher_id.hex()})
-            return cast(Optional[str], result["login_link"])
+            return cast(str | None, result["login_link"])
         except ValueError:  # not connected to pool.
             return None
 

chia/farmer/start_farmer.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 import os
 import pathlib
 import sys
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs import ConsensusConstants
 
-from chia.apis import ApiProtocolRegistry
+from chia.apis import StubMetadataRegistry
 from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
 from chia.farmer.farmer import Farmer
@@ -36,9 +36,9 @@ def create_farmer_service(
     config: dict[str, Any],
     config_pool: dict[str, Any],
     consensus_constants: ConsensusConstants,
-    keychain: Optional[Keychain] = None,
+    keychain: Keychain | None = None,
     connect_to_daemon: bool = True,
-    solver_peer: Optional[UnresolvedPeerInfo] = None,
+    solver_peer: UnresolvedPeerInfo | None = None,
 ) -> FarmerService:
     service_config = config[SERVICE_NAME]
 
@@ -52,7 +52,7 @@ def create_farmer_service(
     )
     peer_api = FarmerAPI(node)
 
-    rpc_info: Optional[RpcInfo[FarmerRpcApi]] = None
+    rpc_info: RpcInfo[FarmerRpcApi] | None = None
     if service_config.get("start_rpc_server", True):
         rpc_info = (FarmerRpcApi, service_config["rpc_port"])
 
@@ -73,7 +73,7 @@ def create_farmer_service(
         network_id=network_id,
         rpc_info=rpc_info,
         connect_to_daemon=connect_to_daemon,
-        class_for_type=ApiProtocolRegistry,
+        stub_metadata_for_type=StubMetadataRegistry,
     )