Skip to main content

Harvester Protocol

Harvester protocol source

The harvester protocol defines the messages sent between a farmer service and a harvester service. These tend to be on the same machine for small farmers, but for medium or large farmers they can be in multiple machines.


The handshake between farmer and harvester. A farmer sends this message to harvesters, to initialize them and tell them which pool public keys and farmer public keys are acceptable to use.

A farmer can be connected to multiple harvesters, but a harvester should only have one farmer connection. The harvester can start using plots which have these keys associated with them.

class HarvesterHandshake(Streamable):
farmer_public_keys: List[G1Element]
pool_public_keys: List[G1Element]


This message is a notification from the farmer to the harvester of a new challenge. The harvester first checks which plots pass the plot filter (see the Harvester Algorithm page), and for those that do, fetches the quality. This requires around 7-9 random reads (and thus disk seeks) for each quality. Each plot is expected to have one proof of space (and therefore one quality) on average, so for 50 plots, a harvester would have around 50 qualities. For those qualities that are sufficiently good to win a block or a pool partial, the whole proof is fetched (64 random reads in the plot), and then new_proof_of_space is sent to the farmer.

class NewSignagePointHarvester(Streamable):
challenge_hash: bytes32 # The challenge hash for the sub slot in which the signage point lies
difficulty: uint64 # The current blockchain difficulty
sub_slot_iters: uint64 # The current blockchain sub-slot iters
signage_point_index: uint8 # The signage point's index, from 0 to 63. 0 for an end of sub slot signage point
sp_hash: bytes32 # The hash of the signage point, this is == challenge_hash iff the index is 0
pool_difficulties: List[PoolDifficulty] # List of each pool the farmer is in, and what the difficulty is for that pool

class PoolDifficulty(Streamable):
difficulty: uint64 # The current difficulty that is set for plots belonging to this pool contract
sub_slot_iters: uint64 # The pool sub slot iters, which is static for each network (mainnet, testnet)
pool_contract_puzzle_hash: bytes32 # The pool contract puzzle hash which can be in many plots


A successful proof of space that is sent to the farmer. The challenge_hash, sp_hash, and signage_point_index correspond to the ones sent in new_signage_point_harvester. Many proofs can be submitted for each signage point.

The plot is a string chosen by the harvester to represent the winning plot (and proof index) in future communications between the farmer and harvester. This can be, for example, the filename of the plot with an additional byte for the index. This is relevant, because a certain plot can potentially have more than one proof for each signage point, and we want communications for each proof to be separate and not conflict (specifically to fetch signatures from the harvester).

class NewProofOfSpace(Streamable):
challenge_hash: bytes32
sp_hash: bytes32
plot_identifier: str
proof: ProofOfSpace # The actual proof of space which contains more data, shown below
signage_point_index: uint8

class ProofOfSpace(Streamable):
challenge: bytes32 # This is the challenge for the pospace, explained in the Signage and Infusion Points page
pool_public_key: Optional[G1Element] # Only one of these two should be present
pool_contract_puzzle_hash: Optional[bytes32] # Present only for pooled plots
plot_public_key: G1Element # Explained in the keys section
size: uint8 # k size, usually 32 but can vary
proof: bytes # proof bytes, 64 k bit values, total size 8k bytes


This is a request from the farmer to the harvester for a signature from the plot key, for a specific plot (using the plot identifier from new_proof_of_space). The farmer can request signatures from multiple messages.

class RequestSignatures(Streamable):
plot_identifier: str
challenge_hash: bytes32
sp_hash: bytes32
messages: List[bytes32]


This is a response to request_signatures. The local public key is the public key corresponding to the secret key in the plot. To see more about the keys for plots, look at the BLS Keys page.

class RespondSignatures(Streamable):
plot_identifier: str
challenge_hash: bytes32
sp_hash: bytes32
local_pk: G1Element # Key in the plot
farmer_pk: G1Element # Key controlled by farmer
message_signatures: List[Tuple[bytes32, G2Element]]


A request from the farmer to the harvester for the list of all plots being farmed by the harvester.

class RequestPlots(Streamable):


A response to request_plots request. This message is also sent whenever a new plot is loaded.

class RespondPlots(Streamable):
plots: List[Plot]
failed_to_open_filenames: List[str] # Filenames for files which cannot be opened
no_key_filenames: List[str] # Filenames for files which cannot be farmed by this farmer

class Plot(Streamable):
filename: str
size: uint8
plot_id: bytes32
pool_public_key: Optional[G1Element]
pool_contract_puzzle_hash: Optional[bytes32]
plot_public_key: G1Element
file_size: uint64
time_modified: uint64