chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.6.0rc2__py3-none-any.whl

chia/_tests/wallet/wallet_block_tools.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import time
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs import (
     BlockRecord,
@@ -58,12 +58,12 @@ class WalletBlockTools(BlockTools):
     def get_consecutive_blocks(
         self,
         num_blocks: int,
-        block_list_input: Optional[list[FullBlock]] = None,
+        block_list_input: list[FullBlock] | None = None,
         *,
-        farmer_reward_puzzle_hash: Optional[bytes32] = None,
-        pool_reward_puzzle_hash: Optional[bytes32] = None,
-        transaction_data: Optional[SpendBundle] = None,
-        genesis_timestamp: Optional[uint64] = None,
+        farmer_reward_puzzle_hash: bytes32 | None = None,
+        pool_reward_puzzle_hash: bytes32 | None = None,
+        transaction_data: SpendBundle | None = None,
+        genesis_timestamp: uint64 | None = None,
         **kwargs: Any,  # We're overriding so there's many arguments no longer used.
     ) -> list[FullBlock]:
         assert num_blocks > 0
@@ -86,7 +86,7 @@ class WalletBlockTools(BlockTools):
             height_to_hash, _, blocks = load_block_list(block_list_input, constants)
 
         if len(block_list_input) > 0:
-            latest_block: Optional[BlockRecord] = blocks[block_list_input[-1].header_hash]
+            latest_block: BlockRecord | None = blocks[block_list_input[-1].header_hash]
             assert latest_block is not None
             assert latest_block.timestamp is not None
             last_timestamp = latest_block.timestamp
@@ -97,7 +97,7 @@ class WalletBlockTools(BlockTools):
         for _ in range(num_blocks):
             additions = []
             removals = []
-            block_generator: Optional[BlockGenerator] = None
+            block_generator: BlockGenerator | None = None
             if transaction_data is not None and len(block_list_input) > 0:
                 additions = compute_additions_unchecked(transaction_data)
                 removals = transaction_data.removals()
@@ -161,7 +161,7 @@ def load_block_list(
 def finish_block(
     constants: ConsensusConstants,
     unfinished_block: UnfinishedBlock,
-    prev_block: Optional[BlockRecord],
+    prev_block: BlockRecord | None,
     blocks: dict[bytes32, BlockRecord],
 ) -> tuple[FullBlock, BlockRecord]:
     if prev_block is None:
@@ -187,6 +187,7 @@ def finish_block(
             G2Element(),
             DEFAULT_VDF_INFO,
             DEFAULT_VDF_INFO,
+            None,  # header_mmr_root
             prev_block is not None,
         ),
         DEFAULT_VDF_PROOF,
@@ -211,8 +212,8 @@ def get_full_block_and_block_record(
     last_timestamp: uint64,
     farmer_reward_puzzlehash: bytes32,
     pool_target: PoolTarget,
-    prev_block: Optional[BlockRecord],
-    block_generator: Optional[BlockGenerator],
+    prev_block: BlockRecord | None,
+    block_generator: BlockGenerator | None,
     additions: list[Coin],
     removals: list[Coin],
 ) -> tuple[FullBlock, BlockRecord, float]:

chia/_tests/weight_proof/config.py

@@ -1,3 +1,4 @@
 from __future__ import annotations
 
 checkout_blocks_and_plots = True
+job_timeout = 45

chia/_tests/weight_proof/test_weight_proof.py

@@ -47,7 +47,6 @@ async def load_blocks_dont_validate(
             cc_sp,
             block.height,
             difficulty,
-            sub_slot_iters,
             uint32(0),  # prev_tx_block(blocks, prev_b), todo need to get height of prev tx block somehow here
         )
         assert required_iters is not None
@@ -99,15 +98,17 @@ async def _test_map_summaries(
 
 
 class TestWeightProof:
+    # This test requires at least two sub epoch summaries in the block chain,
+    # for some test chains, 400 blocks is not enough
     @pytest.mark.anyio
     async def test_weight_proof_map_summaries_1(
-        self, default_400_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_1000_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         header_cache, height_to_hash, sub_blocks, summaries = await load_blocks_dont_validate(
-            default_400_blocks, blockchain_constants
+            default_1000_blocks, blockchain_constants
         )
         await _test_map_summaries(
-            default_400_blocks, header_cache, height_to_hash, sub_blocks, summaries, blockchain_constants
+            default_1000_blocks, header_cache, height_to_hash, sub_blocks, summaries, blockchain_constants
         )
 
     @pytest.mark.anyio

chia/apis/__init__.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from chia.apis.farmer_stub import FarmerApiStub
+from chia.apis.full_node_stub import FullNodeApiStub
+from chia.apis.harvester_stub import HarvesterApiStub
+from chia.apis.introducer_stub import IntroducerApiStub
+from chia.apis.solver_stub import SolverApiStub
+from chia.apis.stub_protocol_registry import StubMetadataRegistry
+from chia.apis.timelord_stub import TimelordApiStub
+from chia.apis.wallet_stub import WalletNodeApiStub
+
+__all__ = [
+    "FarmerApiStub",
+    "FullNodeApiStub",
+    "HarvesterApiStub",
+    "IntroducerApiStub",
+    "SolverApiStub",
+    "StubMetadataRegistry",
+    "TimelordApiStub",
+    "WalletNodeApiStub",
+]

chia/apis/farmer_stub.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import logging
+from typing import ClassVar
+
+from typing_extensions import Protocol
+
+from chia.protocols import farmer_protocol, harvester_protocol
+from chia.protocols.harvester_protocol import (
+    PlotSyncDone,
+    PlotSyncPathList,
+    PlotSyncPlotList,
+    PlotSyncStart,
+    RespondPlots,
+    RespondSignatures,
+)
+from chia.protocols.outbound_message import Message
+from chia.server.api_protocol import ApiMetadata, ApiProtocol
+from chia.server.ws_connection import WSChiaConnection
+
+
+class FarmerApiStub(ApiProtocol, Protocol):
+    """Non-functional API stub for FarmerAPI
+
+    This is a protocol definition only - methods are not implemented and should
+    never be called. Use the actual FarmerAPI implementation at runtime.
+    """
+
+    log: logging.Logger
+    # Create a concrete instance for decorators while keeping the ClassVar type hint for mypy
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
+
+    def ready(self) -> bool:
+        """Check if the farmer is ready."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def new_proof_of_space(
+        self, new_proof_of_space: harvester_protocol.NewProofOfSpace, peer: WSChiaConnection
+    ) -> None:
+        """Handle new proof of space from harvester."""
+        ...
+
+    @metadata.request()
+    async def respond_signatures(self, response: RespondSignatures) -> None:
+        """Handle signature response from harvester."""
+        ...
+
+    @metadata.request()
+    async def new_signage_point(self, new_signage_point: farmer_protocol.NewSignagePoint) -> None:
+        """Handle new signage point from full node."""
+        ...
+
+    @metadata.request()
+    async def request_signed_values(self, full_node_request: farmer_protocol.RequestSignedValues) -> Message | None:
+        """Handle request for signed values from full node."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def farming_info(self, request: farmer_protocol.FarmingInfo, peer: WSChiaConnection) -> None:
+        """Handle farming info from full node."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def respond_plots(self, _: RespondPlots, peer: WSChiaConnection) -> None:
+        """Handle respond plots from harvester."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def plot_sync_start(self, message: PlotSyncStart, peer: WSChiaConnection) -> None:
+        """Handle plot sync start."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def plot_sync_loaded(self, message: PlotSyncPlotList, peer: WSChiaConnection) -> None:
+        """Handle plot sync loaded."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def plot_sync_removed(self, message: PlotSyncPathList, peer: WSChiaConnection) -> None:
+        """Handle plot sync removed."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def plot_sync_invalid(self, message: PlotSyncPathList, peer: WSChiaConnection) -> None:
+        """Handle plot sync invalid."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def plot_sync_keys_missing(self, message: PlotSyncPathList, peer: WSChiaConnection) -> None:
+        """Handle plot sync keys missing."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def plot_sync_duplicates(self, message: PlotSyncPathList, peer: WSChiaConnection) -> None:
+        """Handle plot sync duplicates."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def plot_sync_done(self, message: PlotSyncDone, peer: WSChiaConnection) -> None:
+        """Handle plot sync done."""
+        ...

chia/apis/full_node_stub.py

@@ -0,0 +1,374 @@
+from __future__ import annotations
+
+import logging
+from typing import ClassVar
+
+from typing_extensions import Protocol
+
+from chia.protocols import (
+    farmer_protocol,
+    full_node_protocol,
+    introducer_protocol,
+    timelord_protocol,
+    wallet_protocol,
+)
+from chia.protocols.outbound_message import Message
+from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.server.api_protocol import ApiMetadata, ApiProtocol
+from chia.server.ws_connection import WSChiaConnection
+
+
+class FullNodeApiStub(ApiProtocol, Protocol):
+    """Non-functional API stub for FullNodeAPI
+
+    This is a protocol definition only - methods are not implemented and should
+    never be called. Use the actual FullNodeAPI implementation at runtime.
+    """
+
+    log: logging.Logger
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
+
+    def ready(self) -> bool:
+        """Check if the full node is ready."""
+        ...
+
+    # PEER PROTOCOL
+    @metadata.request(peer_required=True, reply_types=[ProtocolMessageTypes.respond_peers])
+    async def request_peers(self, _request: full_node_protocol.RequestPeers, peer: WSChiaConnection) -> Message | None:
+        """Handle peer request."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def respond_peers(self, request: full_node_protocol.RespondPeers, peer: WSChiaConnection) -> Message | None:
+        """Handle peers response."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def respond_peers_introducer(
+        self, request: introducer_protocol.RespondPeersIntroducer, peer: WSChiaConnection
+    ) -> Message | None:
+        """Handle peers response from introducer."""
+        ...
+
+    # FULL NODE PROTOCOL
+    @metadata.request(peer_required=True, execute_task=True)
+    async def new_peak(self, request: full_node_protocol.NewPeak, peer: WSChiaConnection) -> None:
+        """Handle new peak from peer."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def new_transaction(
+        self, transaction: full_node_protocol.NewTransaction, peer: WSChiaConnection
+    ) -> Message | None:
+        """Handle new transaction from peer."""
+        ...
+
+    @metadata.request(reply_types=[ProtocolMessageTypes.respond_transaction])
+    async def request_transaction(self, request: full_node_protocol.RequestTransaction) -> Message | None:
+        """Handle transaction request."""
+        ...
+
+    @metadata.request(peer_required=True, bytes_required=True)
+    async def respond_transaction(
+        self,
+        tx: full_node_protocol.RespondTransaction,
+        peer: WSChiaConnection,
+        tx_bytes: bytes = b"",
+        test: bool = False,
+    ) -> Message | None:
+        """Handle transaction response from peer."""
+        ...
+
+    @metadata.request(reply_types=[ProtocolMessageTypes.respond_proof_of_weight])
+    async def request_proof_of_weight(self, request: full_node_protocol.RequestProofOfWeight) -> Message | None:
+        """Handle proof of weight request."""
+        ...
+
+    @metadata.request()
+    async def respond_proof_of_weight(self, request: full_node_protocol.RespondProofOfWeight) -> Message | None:
+        """Handle proof of weight response."""
+        ...
+
+    @metadata.request(reply_types=[ProtocolMessageTypes.respond_block, ProtocolMessageTypes.reject_block])
+    async def request_block(self, request: full_node_protocol.RequestBlock) -> Message | None:
+        """Handle block request."""
+        ...
+
+    @metadata.request(reply_types=[ProtocolMessageTypes.respond_blocks, ProtocolMessageTypes.reject_blocks])
+    async def request_blocks(self, request: full_node_protocol.RequestBlocks) -> Message | None:
+        """Handle blocks request."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def reject_block(
+        self,
+        request: full_node_protocol.RejectBlock,
+        peer: WSChiaConnection,
+    ) -> None:
+        """Handle block rejection."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def reject_blocks(
+        self,
+        request: full_node_protocol.RejectBlocks,
+        peer: WSChiaConnection,
+    ) -> None:
+        """Handle blocks rejection."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def respond_blocks(
+        self,
+        request: full_node_protocol.RespondBlocks,
+        peer: WSChiaConnection,
+    ) -> None:
+        """Handle blocks response."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def respond_block(
+        self,
+        respond_block: full_node_protocol.RespondBlock,
+        peer: WSChiaConnection,
+    ) -> Message | None:
+        """Handle block response."""
+        ...
+
+    @metadata.request()
+    async def new_unfinished_block(self, new_unfinished_block: full_node_protocol.NewUnfinishedBlock) -> Message | None:
+        """Handle new unfinished block."""
+        ...
+
+    @metadata.request(reply_types=[ProtocolMessageTypes.respond_unfinished_block])
+    async def request_unfinished_block(
+        self, request_unfinished_block: full_node_protocol.RequestUnfinishedBlock
+    ) -> Message | None:
+        """Handle unfinished block request."""
+        ...
+
+    @metadata.request()
+    async def new_unfinished_block2(
+        self, new_unfinished_block: full_node_protocol.NewUnfinishedBlock2
+    ) -> Message | None:
+        """Handle new unfinished block v2."""
+        ...
+
+    @metadata.request(reply_types=[ProtocolMessageTypes.respond_unfinished_block])
+    async def request_unfinished_block2(
+        self, request_unfinished_block: full_node_protocol.RequestUnfinishedBlock2
+    ) -> Message | None:
+        """Handle unfinished block v2 request."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def respond_unfinished_block(
+        self,
+        respond_unfinished_block: full_node_protocol.RespondUnfinishedBlock,
+        peer: WSChiaConnection,
+    ) -> Message | None:
+        """Handle unfinished block response."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def new_signage_point_or_end_of_sub_slot(
+        self, new_sp: full_node_protocol.NewSignagePointOrEndOfSubSlot, peer: WSChiaConnection
+    ) -> Message | None:
+        """Handle new signage point or end of sub slot."""
+        ...
+
+    @metadata.request(
+        reply_types=[ProtocolMessageTypes.respond_signage_point, ProtocolMessageTypes.respond_end_of_sub_slot]
+    )
+    async def request_signage_point_or_end_of_sub_slot(
+        self, request: full_node_protocol.RequestSignagePointOrEndOfSubSlot
+    ) -> Message | None:
+        """Handle signage point or end of sub slot request."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def respond_signage_point(
+        self, request: full_node_protocol.RespondSignagePoint, peer: WSChiaConnection
+    ) -> Message | None:
+        """Handle signage point response."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def respond_end_of_sub_slot(
+        self, request: full_node_protocol.RespondEndOfSubSlot, peer: WSChiaConnection
+    ) -> Message | None:
+        """Handle end of sub slot response."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def request_mempool_transactions(
+        self,
+        request: full_node_protocol.RequestMempoolTransactions,
+        peer: WSChiaConnection,
+    ) -> Message | None:
+        """Handle mempool transactions request."""
+        ...
+
+    # FARMER PROTOCOL
+    @metadata.request(peer_required=True)
+    async def declare_proof_of_space(
+        self, request: farmer_protocol.DeclareProofOfSpace, peer: WSChiaConnection
+    ) -> Message | None:
+        """Handle proof of space declaration from farmer."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def signed_values(
+        self, farmer_request: farmer_protocol.SignedValues, peer: WSChiaConnection
+    ) -> Message | None:
+        """Handle signed values from farmer."""
+        ...
+
+    # TIMELORD PROTOCOL
+    @metadata.request(peer_required=True)
+    async def new_infusion_point_vdf(
+        self, request: timelord_protocol.NewInfusionPointVDF, peer: WSChiaConnection
+    ) -> Message | None:
+        """Handle new infusion point VDF from timelord."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def new_signage_point_vdf(
+        self, request: timelord_protocol.NewSignagePointVDF, peer: WSChiaConnection
+    ) -> None:
+        """Handle new signage point VDF from timelord."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def new_end_of_sub_slot_vdf(
+        self, request: timelord_protocol.NewEndOfSubSlotVDF, peer: WSChiaConnection
+    ) -> Message | None:
+        """Handle new end of sub slot VDF from timelord."""
+        ...
+
+    @metadata.request(bytes_required=True, execute_task=True)
+    async def respond_compact_proof_of_time(
+        self, request: timelord_protocol.RespondCompactProofOfTime, request_bytes: bytes = b""
+    ) -> None:
+        """Handle compact proof of time response from timelord."""
+
+    @metadata.request(peer_required=True, bytes_required=True, execute_task=True)
+    async def new_compact_vdf(
+        self, request: full_node_protocol.NewCompactVDF, peer: WSChiaConnection, request_bytes: bytes = b""
+    ) -> None:
+        """Handle new compact VDF."""
+        ...
+
+    @metadata.request(peer_required=True, reply_types=[ProtocolMessageTypes.respond_compact_vdf])
+    async def request_compact_vdf(self, request: full_node_protocol.RequestCompactVDF, peer: WSChiaConnection) -> None:
+        """Handle compact VDF request."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def respond_compact_vdf(self, request: full_node_protocol.RespondCompactVDF, peer: WSChiaConnection) -> None:
+        """Handle compact VDF response."""
+        ...
+
+    # WALLET PROTOCOL
+    @metadata.request()
+    async def request_block_header(self, request: wallet_protocol.RequestBlockHeader) -> Message | None:
+        """Handle block header request from wallet."""
+        ...
+
+    @metadata.request()
+    async def request_additions(self, request: wallet_protocol.RequestAdditions) -> Message | None:
+        """Handle additions request from wallet."""
+        ...
+
+    @metadata.request()
+    async def request_removals(self, request: wallet_protocol.RequestRemovals) -> Message | None:
+        """Handle removals request from wallet."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def send_transaction(
+        self, request: wallet_protocol.SendTransaction, peer: WSChiaConnection, *, test: bool = False
+    ) -> Message | None:
+        """Handle transaction send from wallet."""
+        ...
+
+    @metadata.request()
+    async def request_puzzle_solution(self, request: wallet_protocol.RequestPuzzleSolution) -> Message | None:
+        """Handle puzzle solution request from wallet."""
+        ...
+
+    @metadata.request()
+    async def request_block_headers(self, request: wallet_protocol.RequestBlockHeaders) -> Message | None:
+        """Handle block headers request from wallet."""
+        ...
+
+    @metadata.request()
+    async def request_header_blocks(self, request: wallet_protocol.RequestHeaderBlocks) -> Message | None:
+        """Handle header blocks request from wallet (deprecated)."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def register_for_ph_updates(
+        self, request: wallet_protocol.RegisterForPhUpdates, peer: WSChiaConnection
+    ) -> Message:
+        """Handle puzzle hash updates registration from wallet."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def register_for_coin_updates(
+        self, request: wallet_protocol.RegisterForCoinUpdates, peer: WSChiaConnection
+    ) -> Message:
+        """Handle coin updates registration from wallet."""
+        ...
+
+    @metadata.request()
+    async def request_children(self, request: wallet_protocol.RequestChildren) -> Message | None:
+        """Handle children request from wallet."""
+        ...
+
+    @metadata.request()
+    async def request_ses_hashes(self, request: wallet_protocol.RequestSESInfo) -> Message:
+        """Handle SES hashes request from wallet."""
+        ...
+
+    @metadata.request(reply_types=[ProtocolMessageTypes.respond_fee_estimates])
+    async def request_fee_estimates(self, request: wallet_protocol.RequestFeeEstimates) -> Message:
+        """Handle fee estimates request from wallet."""
+        ...
+
+    @metadata.request(
+        peer_required=True,
+        reply_types=[ProtocolMessageTypes.respond_remove_puzzle_subscriptions],
+    )
+    async def request_remove_puzzle_subscriptions(
+        self, request: wallet_protocol.RequestRemovePuzzleSubscriptions, peer: WSChiaConnection
+    ) -> Message:
+        """Handle remove puzzle subscriptions request from wallet."""
+        ...
+
+    @metadata.request(
+        peer_required=True,
+        reply_types=[ProtocolMessageTypes.respond_remove_coin_subscriptions],
+    )
+    async def request_remove_coin_subscriptions(
+        self, request: wallet_protocol.RequestRemoveCoinSubscriptions, peer: WSChiaConnection
+    ) -> Message:
+        """Handle remove coin subscriptions request from wallet."""
+        ...
+
+    @metadata.request(peer_required=True, reply_types=[ProtocolMessageTypes.respond_puzzle_state])
+    async def request_puzzle_state(
+        self, request: wallet_protocol.RequestPuzzleState, peer: WSChiaConnection
+    ) -> Message:
+        """Handle puzzle state request from wallet."""
+        ...
+
+    @metadata.request(peer_required=True, reply_types=[ProtocolMessageTypes.respond_coin_state])
+    async def request_coin_state(self, request: wallet_protocol.RequestCoinState, peer: WSChiaConnection) -> Message:
+        """Handle coin state request from wallet."""
+        ...
+
+    @metadata.request(reply_types=[ProtocolMessageTypes.respond_cost_info])
+    async def request_cost_info(self, _request: wallet_protocol.RequestCostInfo) -> Message | None:
+        """Handle cost info request from wallet."""
+        ...

chia/apis/harvester_stub.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import logging
+from typing import ClassVar
+
+from typing_extensions import Protocol
+
+from chia.protocols import harvester_protocol
+from chia.protocols.harvester_protocol import PlotSyncResponse
+from chia.protocols.outbound_message import Message
+from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.server.api_protocol import ApiMetadata, ApiProtocol
+from chia.server.ws_connection import WSChiaConnection
+
+
+class HarvesterApiStub(ApiProtocol, Protocol):
+    """Non-functional API stub for HarvesterAPI
+
+    This is a protocol definition only - methods are not implemented and should
+    never be called. Use the actual HarvesterAPI implementation at runtime.
+    """
+
+    log: logging.Logger
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
+
+    def ready(self) -> bool:
+        """Check if the harvester is ready."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def harvester_handshake(
+        self, harvester_handshake: harvester_protocol.HarvesterHandshake, peer: WSChiaConnection
+    ) -> None:
+        """Handshake between the harvester and farmer."""
+        ...
+
+    @metadata.request(peer_required=True)
+    async def new_signage_point_harvester(
+        self, new_challenge: harvester_protocol.NewSignagePointHarvester2, peer: WSChiaConnection
+    ) -> None:
+        """Handle new signage point from farmer."""
+        ...
+
+    @metadata.request(reply_types=[ProtocolMessageTypes.respond_signatures])
+    async def request_signatures(self, request: harvester_protocol.RequestSignatures) -> Message | None:
+        """Handle signature request from farmer."""
+        ...
+
+    @metadata.request()
+    async def request_plots(self, _: harvester_protocol.RequestPlots) -> Message:
+        """Handle request for plot information."""
+        ...
+
+    @metadata.request()
+    async def plot_sync_response(self, response: PlotSyncResponse) -> None:
+        """Handle plot sync response."""
+        ...