chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/harvester/harvester.py

@@ -0,0 +1,272 @@
+from __future__ import annotations
+
+import asyncio
+import concurrent
+import contextlib
+import dataclasses
+import logging
+from collections.abc import AsyncIterator
+from concurrent.futures.thread import ThreadPoolExecutor
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+
+from typing_extensions import Literal
+
+from chia.consensus.constants import ConsensusConstants
+from chia.plot_sync.sender import Sender
+from chia.plotting.manager import PlotManager
+from chia.plotting.util import (
+    DEFAULT_DECOMPRESSOR_THREAD_COUNT,
+    DEFAULT_DECOMPRESSOR_TIMEOUT,
+    DEFAULT_DISABLE_CPU_AFFINITY,
+    DEFAULT_ENFORCE_GPU_INDEX,
+    DEFAULT_GPU_INDEX,
+    DEFAULT_MAX_COMPRESSION_LEVEL_ALLOWED,
+    DEFAULT_PARALLEL_DECOMPRESSOR_COUNT,
+    DEFAULT_USE_GPU_HARVESTING,
+    HarvestingMode,
+    PlotRefreshEvents,
+    PlotRefreshResult,
+    PlotsRefreshParameter,
+    add_plot_directory,
+    get_harvester_config,
+    get_plot_directories,
+    remove_plot,
+    remove_plot_directory,
+    update_harvester_config,
+)
+from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
+from chia.server.outbound_message import NodeType
+from chia.server.server import ChiaServer
+from chia.server.ws_connection import WSChiaConnection
+from chia.util.cpu import available_logical_cores
+from chia.util.ints import uint32
+
+log = logging.getLogger(__name__)
+
+
+class Harvester:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcServiceProtocol
+
+        _protocol_check: ClassVar[RpcServiceProtocol] = cast("Harvester", None)
+
+    plot_manager: PlotManager
+    plot_sync_sender: Sender
+    root_path: Path
+    _shut_down: bool
+    executor: ThreadPoolExecutor
+    state_changed_callback: Optional[StateChangedProtocol] = None
+    constants: ConsensusConstants
+    _refresh_lock: asyncio.Lock
+    event_loop: asyncio.events.AbstractEventLoop
+    _server: Optional[ChiaServer]
+    _mode: HarvestingMode
+
+    @property
+    def server(self) -> ChiaServer:
+        # This is a stop gap until the class usage is refactored such the values of
+        # integral attributes are known at creation of the instance.
+        if self._server is None:
+            raise RuntimeError("server not assigned")
+
+        return self._server
+
+    def __init__(self, root_path: Path, config: dict[str, Any], constants: ConsensusConstants):
+        self.log = log
+        self.root_path = root_path
+        # TODO, remove checks below later after some versions / time
+        refresh_parameter: PlotsRefreshParameter = PlotsRefreshParameter()
+        if "plot_loading_frequency_seconds" in config:
+            self.log.info(
+                "`harvester.plot_loading_frequency_seconds` is deprecated. Consider replacing it with the new section "
+                "`harvester.plots_refresh_parameter`. See `initial-config.yaml`."
+            )
+            refresh_parameter = dataclasses.replace(
+                refresh_parameter, interval_seconds=config["plot_loading_frequency_seconds"]
+            )
+        if "plots_refresh_parameter" in config:
+            refresh_parameter = PlotsRefreshParameter.from_json_dict(config["plots_refresh_parameter"])
+
+        self.log.info(f"Using plots_refresh_parameter: {refresh_parameter}")
+
+        self.plot_manager = PlotManager(
+            root_path, refresh_parameter=refresh_parameter, refresh_callback=self._plot_refresh_callback
+        )
+        self._shut_down = False
+        self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=config["num_threads"])
+        self._server = None
+        self.constants = constants
+        self.state_changed_callback: Optional[StateChangedProtocol] = None
+        self.parallel_read: bool = config.get("parallel_read", True)
+
+        context_count = config.get("parallel_decompressor_count", DEFAULT_PARALLEL_DECOMPRESSOR_COUNT)
+        thread_count = config.get("decompressor_thread_count", DEFAULT_DECOMPRESSOR_THREAD_COUNT)
+        cpu_count = available_logical_cores()
+        if thread_count == 0:
+            thread_count = cpu_count // 2
+        disable_cpu_affinity = config.get("disable_cpu_affinity", DEFAULT_DISABLE_CPU_AFFINITY)
+        max_compression_level_allowed = config.get(
+            "max_compression_level_allowed", DEFAULT_MAX_COMPRESSION_LEVEL_ALLOWED
+        )
+        use_gpu_harvesting = config.get("use_gpu_harvesting", DEFAULT_USE_GPU_HARVESTING)
+        gpu_index = config.get("gpu_index", DEFAULT_GPU_INDEX)
+        enforce_gpu_index = config.get("enforce_gpu_index", DEFAULT_ENFORCE_GPU_INDEX)
+        decompressor_timeout = config.get("decompressor_timeout", DEFAULT_DECOMPRESSOR_TIMEOUT)
+
+        try:
+            self._mode = self.plot_manager.configure_decompressor(
+                context_count,
+                thread_count,
+                disable_cpu_affinity,
+                max_compression_level_allowed,
+                use_gpu_harvesting,
+                gpu_index,
+                enforce_gpu_index,
+                decompressor_timeout,
+            )
+        except Exception as e:
+            self.log.error(f"{type(e)} {e} while configuring decompressor.")
+            raise
+
+        self.plot_sync_sender = Sender(self.plot_manager, self._mode)
+
+    @contextlib.asynccontextmanager
+    async def manage(self) -> AsyncIterator[None]:
+        self._refresh_lock = asyncio.Lock()
+        self.event_loop = asyncio.get_running_loop()
+        try:
+            yield
+        finally:
+            self._shut_down = True
+            self.executor.shutdown(wait=True)
+            self.plot_manager.stop_refreshing()
+            self.plot_manager.reset()
+            self.plot_sync_sender.stop()
+
+            await self.plot_sync_sender.await_closed()
+
+    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 on_connect(self, connection: WSChiaConnection) -> None:
+        self.state_changed("add_connection")
+
+    def _set_state_changed_callback(self, callback: StateChangedProtocol) -> None:
+        self.state_changed_callback = callback
+
+    def state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> None:
+        if self.state_changed_callback is not None:
+            self.state_changed_callback(change, change_data)
+
+    def _plot_refresh_callback(self, event: PlotRefreshEvents, update_result: PlotRefreshResult) -> None:
+        log_function = self.log.debug if event == PlotRefreshEvents.batch_processed else self.log.info
+        log_function(
+            f"_plot_refresh_callback: event {event.name}, loaded {len(update_result.loaded)}, "
+            f"removed {len(update_result.removed)}, processed {update_result.processed}, "
+            f"remaining {update_result.remaining}, "
+            f"duration: {update_result.duration:.2f} seconds, "
+            f"total plots: {len(self.plot_manager.plots)}"
+        )
+        if event == PlotRefreshEvents.started:
+            self.plot_sync_sender.sync_start(update_result.remaining, self.plot_manager.initial_refresh())
+        if event == PlotRefreshEvents.batch_processed:
+            self.plot_sync_sender.process_batch(update_result.loaded, update_result.remaining)
+        if event == PlotRefreshEvents.done:
+            self.plot_sync_sender.sync_done(update_result.removed, update_result.duration)
+
+    async def on_disconnect(self, connection: WSChiaConnection) -> None:
+        self.log.info(f"peer disconnected {connection.get_peer_logging()}")
+        self.state_changed("close_connection")
+        self.plot_sync_sender.stop()
+        asyncio.run_coroutine_threadsafe(self.plot_sync_sender.await_closed(), asyncio.get_running_loop())
+        self.plot_manager.stop_refreshing()
+
+    def get_plots(self) -> tuple[list[dict[str, Any]], list[str], list[str]]:
+        self.log.debug(f"get_plots prover items: {self.plot_manager.plot_count()}")
+        response_plots: list[dict[str, Any]] = []
+        with self.plot_manager:
+            for path, plot_info in self.plot_manager.plots.items():
+                prover = plot_info.prover
+                response_plots.append(
+                    {
+                        "filename": str(path),
+                        "size": prover.get_size(),
+                        "plot_id": prover.get_id(),
+                        "pool_public_key": plot_info.pool_public_key,
+                        "pool_contract_puzzle_hash": plot_info.pool_contract_puzzle_hash,
+                        "plot_public_key": plot_info.plot_public_key,
+                        "file_size": plot_info.file_size,
+                        "time_modified": int(plot_info.time_modified),
+                        "compression_level": prover.get_compression_level(),
+                    }
+                )
+            self.log.debug(
+                f"get_plots response: plots: {len(response_plots)}, "
+                f"failed_to_open_filenames: {len(self.plot_manager.failed_to_open_filenames)}, "
+                f"no_key_filenames: {len(self.plot_manager.no_key_filenames)}"
+            )
+            return (
+                response_plots,
+                [str(s) for s, _ in self.plot_manager.failed_to_open_filenames.items()],
+                [str(s) for s in self.plot_manager.no_key_filenames],
+            )
+
+    def delete_plot(self, str_path: str) -> Literal[True]:
+        remove_plot(Path(str_path))
+        self.plot_manager.trigger_refresh()
+        self.state_changed("plots")
+        return True
+
+    async def add_plot_directory(self, str_path: str) -> bool:
+        add_plot_directory(self.root_path, str_path)
+        self.plot_manager.trigger_refresh()
+        return True
+
+    async def get_plot_directories(self) -> list[str]:
+        return get_plot_directories(self.root_path)
+
+    async def remove_plot_directory(self, str_path: str) -> bool:
+        remove_plot_directory(self.root_path, str_path)
+        self.plot_manager.trigger_refresh()
+        return True
+
+    async def get_harvester_config(self) -> dict[str, Any]:
+        return get_harvester_config(self.root_path)
+
+    async def update_harvester_config(
+        self,
+        *,
+        use_gpu_harvesting: Optional[bool] = None,
+        gpu_index: Optional[int] = None,
+        enforce_gpu_index: Optional[bool] = None,
+        disable_cpu_affinity: Optional[bool] = None,
+        parallel_decompressor_count: Optional[int] = None,
+        decompressor_thread_count: Optional[int] = None,
+        recursive_plot_scan: Optional[bool] = None,
+        refresh_parameter_interval_seconds: Optional[uint32] = None,
+    ) -> bool:
+        refresh_parameter: Optional[PlotsRefreshParameter] = None
+        if refresh_parameter_interval_seconds is not None:
+            refresh_parameter = PlotsRefreshParameter(
+                interval_seconds=refresh_parameter_interval_seconds,
+                retry_invalid_seconds=self.plot_manager.refresh_parameter.retry_invalid_seconds,
+                batch_size=self.plot_manager.refresh_parameter.batch_size,
+                batch_sleep_milliseconds=self.plot_manager.refresh_parameter.batch_sleep_milliseconds,
+            )
+
+        update_harvester_config(
+            self.root_path,
+            use_gpu_harvesting=use_gpu_harvesting,
+            gpu_index=gpu_index,
+            enforce_gpu_index=enforce_gpu_index,
+            disable_cpu_affinity=disable_cpu_affinity,
+            parallel_decompressor_count=parallel_decompressor_count,
+            decompressor_thread_count=decompressor_thread_count,
+            recursive_plot_scan=recursive_plot_scan,
+            refresh_parameter=refresh_parameter,
+        )
+        return True
+
+    def set_server(self, server: ChiaServer) -> None:
+        self._server = server

chia/harvester/harvester_api.py

@@ -0,0 +1,380 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
+
+from chia_rs import AugSchemeMPL, G1Element, G2Element
+
+from chia.consensus.pot_iterations import calculate_iterations_quality, calculate_sp_interval_iters
+from chia.harvester.harvester import Harvester
+from chia.plotting.util import PlotInfo, parse_plot_info
+from chia.protocols import harvester_protocol
+from chia.protocols.farmer_protocol import FarmingInfo
+from chia.protocols.harvester_protocol import Plot, PlotSyncResponse
+from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.server.api_protocol import ApiMetadata
+from chia.server.outbound_message import Message, make_msg
+from chia.server.ws_connection import WSChiaConnection
+from chia.types.blockchain_format.proof_of_space import (
+    ProofOfSpace,
+    calculate_pos_challenge,
+    generate_plot_public_key,
+    passes_plot_filter,
+)
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint8, uint32, uint64
+from chia.wallet.derive_keys import master_sk_to_local_sk
+
+
+class HarvesterAPI:
+    if TYPE_CHECKING:
+        from chia.server.api_protocol import ApiProtocol
+
+        _protocol_check: ClassVar[ApiProtocol] = cast("HarvesterAPI", None)
+
+    log: logging.Logger
+    harvester: Harvester
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
+
+    def __init__(self, harvester: Harvester):
+        self.log = logging.getLogger(__name__)
+        self.harvester = harvester
+
+    def ready(self) -> bool:
+        return True
+
+    @metadata.request(peer_required=True)
+    async def harvester_handshake(
+        self, harvester_handshake: harvester_protocol.HarvesterHandshake, peer: WSChiaConnection
+    ) -> None:
+        """
+        Handshake between the harvester and farmer. The harvester receives the pool public keys,
+        as well as the farmer pks, which must be put into the plots, before the plotting process begins.
+        We cannot use any plots which have different keys in them.
+        """
+        self.harvester.plot_manager.set_public_keys(
+            harvester_handshake.farmer_public_keys, harvester_handshake.pool_public_keys
+        )
+        self.harvester.plot_sync_sender.set_connection(peer)
+        await self.harvester.plot_sync_sender.start()
+        self.harvester.plot_manager.start_refreshing()
+
+    @metadata.request(peer_required=True)
+    async def new_signage_point_harvester(
+        self, new_challenge: harvester_protocol.NewSignagePointHarvester, peer: WSChiaConnection
+    ) -> None:
+        """
+        The harvester receives a new signage point from the farmer, this happens at the start of each slot.
+        The harvester does a few things:
+        1. The harvester applies the plot filter for each of the plots, to select the proportion which are eligible
+        for this signage point and challenge.
+        2. The harvester gets the qualities for each plot. This is approximately 7 reads per plot which qualifies.
+        Note that each plot may have 0, 1, 2, etc qualities for that challenge: but on average it will have 1.
+        3. Checks the required_iters for each quality and the given signage point, to see which are eligible for
+        inclusion (required_iters < sp_interval_iters).
+        4. Looks up the full proof of space in the plot for each quality, approximately 64 reads per quality
+        5. Returns the proof of space to the farmer
+        """
+        if not self.harvester.plot_manager.public_keys_available():
+            # This means that we have not received the handshake yet
+            self.harvester.log.debug("new_signage_point_harvester received with no keys available")
+            return None
+
+        self.harvester.log.debug(
+            f"new_signage_point_harvester lookup: challenge_hash: {new_challenge.challenge_hash}, "
+            f"sp_hash: {new_challenge.sp_hash}, signage_point_index: {new_challenge.signage_point_index}"
+        )
+
+        start = time.time()
+        assert len(new_challenge.challenge_hash) == 32
+
+        loop = asyncio.get_running_loop()
+
+        def blocking_lookup(filename: Path, plot_info: PlotInfo) -> list[tuple[bytes32, ProofOfSpace]]:
+            # Uses the DiskProver object to lookup qualities. This is a blocking call,
+            # so it should be run in a thread pool.
+            try:
+                plot_id = plot_info.prover.get_id()
+                sp_challenge_hash = calculate_pos_challenge(
+                    plot_id,
+                    new_challenge.challenge_hash,
+                    new_challenge.sp_hash,
+                )
+                try:
+                    quality_strings = plot_info.prover.get_qualities_for_challenge(sp_challenge_hash)
+                except RuntimeError as e:
+                    if str(e) == "Timeout waiting for context queue.":
+                        self.harvester.log.warning(
+                            f"No decompressor available. Cancelling qualities retrieving for {filename}"
+                        )
+                        self.harvester.log.warning(
+                            f"File: {filename} Plot ID: {plot_id.hex()}, challenge: {sp_challenge_hash}, "
+                            f"plot_info: {plot_info}"
+                        )
+                    else:
+                        self.harvester.log.error(f"Exception fetching qualities for {filename}. {e}")
+                        self.harvester.log.error(
+                            f"File: {filename} Plot ID: {plot_id.hex()}, challenge: {sp_challenge_hash}, "
+                            f"plot_info: {plot_info}"
+                        )
+                    return []
+                except Exception as e:
+                    self.harvester.log.error(f"Error using prover object {e}")
+                    self.harvester.log.error(
+                        f"File: {filename} Plot ID: {plot_id.hex()}, "
+                        f"challenge: {sp_challenge_hash}, plot_info: {plot_info}"
+                    )
+                    return []
+
+                responses: list[tuple[bytes32, ProofOfSpace]] = []
+                if quality_strings is not None:
+                    difficulty = new_challenge.difficulty
+                    sub_slot_iters = new_challenge.sub_slot_iters
+                    if plot_info.pool_contract_puzzle_hash is not None:
+                        # If we are pooling, override the difficulty and sub slot iters with the pool threshold info.
+                        # This will mean more proofs actually get found, but they are only submitted to the pool,
+                        # not the blockchain
+                        for pool_difficulty in new_challenge.pool_difficulties:
+                            if pool_difficulty.pool_contract_puzzle_hash == plot_info.pool_contract_puzzle_hash:
+                                difficulty = pool_difficulty.difficulty
+                                sub_slot_iters = pool_difficulty.sub_slot_iters
+
+                    # Found proofs of space (on average 1 is expected per plot)
+                    for index, quality_str in enumerate(quality_strings):
+                        required_iters: uint64 = calculate_iterations_quality(
+                            self.harvester.constants.DIFFICULTY_CONSTANT_FACTOR,
+                            quality_str,
+                            plot_info.prover.get_size(),
+                            difficulty,
+                            new_challenge.sp_hash,
+                        )
+                        sp_interval_iters = calculate_sp_interval_iters(self.harvester.constants, sub_slot_iters)
+                        if required_iters < sp_interval_iters:
+                            # Found a very good proof of space! will fetch the whole proof from disk,
+                            # then send to farmer
+                            try:
+                                proof_xs = plot_info.prover.get_full_proof(
+                                    sp_challenge_hash, index, self.harvester.parallel_read
+                                )
+                            except RuntimeError as e:
+                                if str(e) == "GRResult_NoProof received":
+                                    self.harvester.log.info(
+                                        f"Proof dropped due to line point compression for {filename}"
+                                    )
+                                    self.harvester.log.info(
+                                        f"File: {filename} Plot ID: {plot_id.hex()}, challenge: {sp_challenge_hash}, "
+                                        f"plot_info: {plot_info}"
+                                    )
+                                elif str(e) == "Timeout waiting for context queue.":
+                                    self.harvester.log.warning(
+                                        f"No decompressor available. Cancelling full proof retrieving for {filename}"
+                                    )
+                                    self.harvester.log.warning(
+                                        f"File: {filename} Plot ID: {plot_id.hex()}, challenge: {sp_challenge_hash}, "
+                                        f"plot_info: {plot_info}"
+                                    )
+                                else:
+                                    self.harvester.log.error(f"Exception fetching full proof for {filename}. {e}")
+                                    self.harvester.log.error(
+                                        f"File: {filename} Plot ID: {plot_id.hex()}, challenge: {sp_challenge_hash}, "
+                                        f"plot_info: {plot_info}"
+                                    )
+                                continue
+                            except Exception as e:
+                                self.harvester.log.error(f"Exception fetching full proof for {filename}. {e}")
+                                self.harvester.log.error(
+                                    f"File: {filename} Plot ID: {plot_id.hex()}, challenge: {sp_challenge_hash}, "
+                                    f"plot_info: {plot_info}"
+                                )
+                                continue
+
+                            responses.append(
+                                (
+                                    quality_str,
+                                    ProofOfSpace(
+                                        sp_challenge_hash,
+                                        plot_info.pool_public_key,
+                                        plot_info.pool_contract_puzzle_hash,
+                                        plot_info.plot_public_key,
+                                        uint8(plot_info.prover.get_size()),
+                                        proof_xs,
+                                    ),
+                                )
+                            )
+                return responses
+            except Exception as e:
+                self.harvester.log.error(f"Unknown error: {e}")
+                return []
+
+        async def lookup_challenge(
+            filename: Path, plot_info: PlotInfo
+        ) -> tuple[Path, list[harvester_protocol.NewProofOfSpace]]:
+            # Executes a DiskProverLookup in a thread pool, and returns responses
+            all_responses: list[harvester_protocol.NewProofOfSpace] = []
+            if self.harvester._shut_down:
+                return filename, []
+            proofs_of_space_and_q: list[tuple[bytes32, ProofOfSpace]] = await loop.run_in_executor(
+                self.harvester.executor, blocking_lookup, filename, plot_info
+            )
+            for quality_str, proof_of_space in proofs_of_space_and_q:
+                all_responses.append(
+                    harvester_protocol.NewProofOfSpace(
+                        new_challenge.challenge_hash,
+                        new_challenge.sp_hash,
+                        quality_str.hex() + str(filename.resolve()),
+                        proof_of_space,
+                        new_challenge.signage_point_index,
+                        include_source_signature_data=False,
+                        farmer_reward_address_override=None,
+                        fee_info=None,
+                    )
+                )
+            return filename, all_responses
+
+        awaitables = []
+        passed = 0
+        total = 0
+        with self.harvester.plot_manager:
+            self.harvester.log.debug("new_signage_point_harvester lock acquired")
+            for try_plot_filename, try_plot_info in self.harvester.plot_manager.plots.items():
+                # Passes the plot filter (does not check sp filter yet though, since we have not reached sp)
+                # This is being executed at the beginning of the slot
+                total += 1
+                if passes_plot_filter(
+                    new_challenge.filter_prefix_bits,
+                    try_plot_info.prover.get_id(),
+                    new_challenge.challenge_hash,
+                    new_challenge.sp_hash,
+                ):
+                    passed += 1
+                    awaitables.append(lookup_challenge(try_plot_filename, try_plot_info))
+            self.harvester.log.debug(f"new_signage_point_harvester {passed} plots passed the plot filter")
+
+        # Concurrently executes all lookups on disk, to take advantage of multiple disk parallelism
+        time_taken = time.time() - start
+        total_proofs_found = 0
+        for filename_sublist_awaitable in asyncio.as_completed(awaitables):
+            filename, sublist = await filename_sublist_awaitable
+            time_taken = time.time() - start
+            if time_taken > 8:
+                self.harvester.log.warning(
+                    f"Looking up qualities on {filename} took: {time_taken}. This should be below 8 seconds"
+                    f" to minimize risk of losing rewards."
+                )
+            else:
+                pass
+                # self.harvester.log.info(f"Looking up qualities on {filename} took: {time_taken}")
+            for response in sublist:
+                total_proofs_found += 1
+                msg = make_msg(ProtocolMessageTypes.new_proof_of_space, response)
+                await peer.send_message(msg)
+
+        now = uint64(int(time.time()))
+
+        farming_info = FarmingInfo(
+            new_challenge.challenge_hash,
+            new_challenge.sp_hash,
+            now,
+            uint32(passed),
+            uint32(total_proofs_found),
+            uint32(total),
+            uint64(time_taken * 1_000_000),  # microseconds
+        )
+        pass_msg = make_msg(ProtocolMessageTypes.farming_info, farming_info)
+        await peer.send_message(pass_msg)
+
+        self.harvester.log.info(
+            f"{len(awaitables)} plots were eligible for farming {new_challenge.challenge_hash.hex()[:10]}..."
+            f" Found {total_proofs_found} proofs. Time: {time_taken:.5f} s. "
+            f"Total {self.harvester.plot_manager.plot_count()} plots"
+        )
+        self.harvester.state_changed(
+            "farming_info",
+            {
+                "challenge_hash": new_challenge.challenge_hash.hex(),
+                "total_plots": self.harvester.plot_manager.plot_count(),
+                "found_proofs": total_proofs_found,
+                "eligible_plots": len(awaitables),
+                "time": time_taken,
+            },
+        )
+
+    @metadata.request(reply_types=[ProtocolMessageTypes.respond_signatures])
+    async def request_signatures(self, request: harvester_protocol.RequestSignatures) -> Optional[Message]:
+        """
+        The farmer requests a signature on the header hash, for one of the proofs that we found.
+        A signature is created on the header hash using the harvester private key. This can also
+        be used for pooling.
+        """
+        plot_filename = Path(request.plot_identifier[64:]).resolve()
+        with self.harvester.plot_manager:
+            try:
+                plot_info = self.harvester.plot_manager.plots[plot_filename]
+            except KeyError:
+                self.harvester.log.warning(f"KeyError plot {plot_filename} does not exist.")
+                return None
+
+            # Look up local_sk from plot to save locked memory
+            (
+                pool_public_key_or_puzzle_hash,
+                farmer_public_key,
+                local_master_sk,
+            ) = parse_plot_info(plot_info.prover.get_memo())
+            local_sk = master_sk_to_local_sk(local_master_sk)
+
+        if isinstance(pool_public_key_or_puzzle_hash, G1Element):
+            include_taproot = False
+        else:
+            assert isinstance(pool_public_key_or_puzzle_hash, bytes32)
+            include_taproot = True
+
+        agg_pk = generate_plot_public_key(local_sk.get_g1(), farmer_public_key, include_taproot)
+
+        # This is only a partial signature. When combined with the farmer's half, it will
+        # form a complete PrependSignature.
+        message_signatures: list[tuple[bytes32, G2Element]] = []
+        for message in request.messages:
+            signature: G2Element = AugSchemeMPL.sign(local_sk, message, agg_pk)
+            message_signatures.append((message, signature))
+
+        response: harvester_protocol.RespondSignatures = harvester_protocol.RespondSignatures(
+            request.plot_identifier,
+            request.challenge_hash,
+            request.sp_hash,
+            local_sk.get_g1(),
+            farmer_public_key,
+            message_signatures,
+            False,
+            None,
+        )
+
+        return make_msg(ProtocolMessageTypes.respond_signatures, response)
+
+    @metadata.request()
+    async def request_plots(self, _: harvester_protocol.RequestPlots) -> Message:
+        plots_response = []
+        plots, failed_to_open_filenames, no_key_filenames = self.harvester.get_plots()
+        for plot in plots:
+            plots_response.append(
+                Plot(
+                    plot["filename"],
+                    plot["size"],
+                    plot["plot_id"],
+                    plot["pool_public_key"],
+                    plot["pool_contract_puzzle_hash"],
+                    plot["plot_public_key"],
+                    plot["file_size"],
+                    plot["time_modified"],
+                    plot["compression_level"],
+                )
+            )
+
+        response = harvester_protocol.RespondPlots(plots_response, failed_to_open_filenames, no_key_filenames)
+        return make_msg(ProtocolMessageTypes.respond_plots, response)
+
+    @metadata.request()
+    async def plot_sync_response(self, response: PlotSyncResponse) -> None:
+        self.harvester.plot_sync_sender.set_response(response)