rename to partial proof

Author: almogdepaz

chia/_tests/farmer_harvester/test_farmer_harvester.py

@@ -326,19 +326,19 @@ async def test_harvester_has_no_server(
 
 
 @pytest.mark.anyio
-async def test_v2_quality_chains_new_sp_hash(
+async def test_v2_partial_proofs_new_sp_hash(
     farmer_one_harvester_solver: tuple[list[HarvesterService], FarmerService, SolverService, BlockTools],
 ) -> None:
     _, farmer_service, _solver_service, _bt = farmer_one_harvester_solver
     farmer_api = farmer_service._api
     farmer = farmer_api.farmer
 
     sp_hash = bytes32(b"1" * 32)
-    v2_quality_chains = harvester_protocol.V2QualityChains(
+    partial_proofs = harvester_protocol.PartialProofsData(
         challenge_hash=bytes32(b"2" * 32),
         sp_hash=sp_hash,
         plot_identifier="test_plot_id",
-        quality_chains=[b"test_quality_chain_1"],
+        partial_proofs=[b"test_partial_proof_1"],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
         difficulty=uint64(1000),
@@ -348,27 +348,27 @@ async def test_v2_quality_chains_new_sp_hash(
     )
 
     harvester_peer = await get_harvester_peer(farmer)
-    await farmer_api.v2_quality_chains(v2_quality_chains, harvester_peer)
+    await farmer_api.partial_proofs(partial_proofs, harvester_peer)
 
     assert sp_hash in farmer.number_of_responses
     assert farmer.number_of_responses[sp_hash] == 0
     assert sp_hash in farmer.cache_add_time
 
 
 @pytest.mark.anyio
-async def test_v2_quality_chains_missing_sp_hash(
+async def test_v2_partial_proofs_missing_sp_hash(
     caplog: pytest.LogCaptureFixture,
     farmer_one_harvester_solver: tuple[list[HarvesterService], FarmerService, SolverService, BlockTools],
 ) -> None:
     _, farmer_service, _, _ = farmer_one_harvester_solver
     farmer_api = farmer_service._api
 
     sp_hash = bytes32(b"1" * 32)
-    v2_quality_chains = harvester_protocol.V2QualityChains(
+    partial_proofs = harvester_protocol.PartialProofsData(
         challenge_hash=bytes32(b"2" * 32),
         sp_hash=sp_hash,
         plot_identifier="test_plot_id",
-        quality_chains=[b"test_quality_chain_1"],
+        partial_proofs=[b"test_partial_proof_1"],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
         difficulty=uint64(1000),
@@ -378,13 +378,13 @@ async def test_v2_quality_chains_missing_sp_hash(
     )
 
     harvester_peer = await get_harvester_peer(farmer_api.farmer)
-    await farmer_api.v2_quality_chains(v2_quality_chains, harvester_peer)
+    await farmer_api.partial_proofs(partial_proofs, harvester_peer)
 
-    assert f"Received V2 quality collection for a signage point that we do not have {sp_hash}" in caplog.text
+    assert f"Received partial proofs for a signage point that we do not have {sp_hash}" in caplog.text
 
 
 @pytest.mark.anyio
-async def test_v2_quality_chains_with_existing_sp(
+async def test_v2_partial_proofs_with_existing_sp(
     farmer_one_harvester_solver: tuple[list[HarvesterService], FarmerService, SolverService, BlockTools],
 ) -> None:
     _, farmer_service, _, _ = farmer_one_harvester_solver
@@ -407,11 +407,11 @@ async def test_v2_quality_chains_with_existing_sp(
 
     farmer.sps[sp_hash] = [sp]
 
-    v2_quality_chains = harvester_protocol.V2QualityChains(
+    partial_proofs = harvester_protocol.PartialProofsData(
         challenge_hash=challenge_hash,
         sp_hash=sp_hash,
         plot_identifier="test_plot_id",
-        quality_chains=[b"test_quality_chain_1", b"test_quality_chain_2"],
+        partial_proofs=[b"test_partial_proof_1", b"test_partial_proof_2"],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
         difficulty=uint64(1000),
@@ -421,7 +421,7 @@ async def test_v2_quality_chains_with_existing_sp(
     )
 
     harvester_peer = await get_harvester_peer(farmer)
-    await farmer_api.v2_quality_chains(v2_quality_chains, harvester_peer)
+    await farmer_api.partial_proofs(partial_proofs, harvester_peer)
 
     # should store 2 pending requests (one per quality)
     assert len(farmer.pending_solver_requests) == 2
@@ -441,11 +441,11 @@ async def test_solution_response_handler(
     sp_hash = bytes32(b"1" * 32)
     challenge_hash = bytes32(b"2" * 32)
 
-    v2_quality_chains = harvester_protocol.V2QualityChains(
+    partial_proofs = harvester_protocol.PartialProofsData(
         challenge_hash=challenge_hash,
         sp_hash=sp_hash,
         plot_identifier="test_plot_id",
-        quality_chains=[b"test_quality_chain_for_quality"],
+        partial_proofs=[b"test_partial_proof_for_quality"],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
         difficulty=uint64(1000),
@@ -458,12 +458,12 @@ async def test_solution_response_handler(
 
     # manually add pending request
     farmer.pending_solver_requests[quality] = {
-        "quality_data": v2_quality_chains,
+        "proof_data": partial_proofs,
         "peer": harvester_peer,
     }
 
     # create solution response
-    solution_response = solver_protocol.SolverResponse(quality_chain=quality, proof=b"test_proof_from_solver")
+    solution_response = solver_protocol.SolverResponse(partial_proof=quality, proof=b"test_proof_from_solver")
     solver_peer = Mock()
     solver_peer.peer_node_id = "solver_peer"
 
@@ -495,7 +495,7 @@ async def test_solution_response_unknown_quality(
     solver_peer = await get_solver_peer(farmer)
 
     # create solution response with unknown quality
-    solution_response = solver_protocol.SolverResponse(quality_chain=bytes(b"1" * 32), proof=b"test_proof")
+    solution_response = solver_protocol.SolverResponse(partial_proof=bytes(b"1" * 32), proof=b"test_proof")
 
     with unittest.mock.patch.object(farmer_api, "new_proof_of_space", new_callable=AsyncMock) as mock_new_proof:
         await farmer_api.solution_response(solution_response, solver_peer)
@@ -509,7 +509,6 @@ async def test_solution_response_unknown_quality(
 async def test_solution_response_empty_proof(
     farmer_one_harvester_solver: tuple[list[HarvesterService], FarmerService, SolverService, BlockTools],
 ) -> None:
-    """Test solution_response with empty proof."""
     _, farmer_service, _solver_service, _ = farmer_one_harvester_solver
     farmer_api = farmer_service._api
     farmer = farmer_api.farmer
@@ -519,11 +518,11 @@ async def test_solution_response_empty_proof(
     sp_hash = bytes32(b"1" * 32)
     challenge_hash = bytes32(b"2" * 32)
 
-    v2_quality_chains = harvester_protocol.V2QualityChains(
+    partial_proofs = harvester_protocol.PartialProofsData(
         challenge_hash=challenge_hash,
         sp_hash=sp_hash,
         plot_identifier="test_plot_id",
-        quality_chains=[b"test_quality_chain_for_quality"],
+        partial_proofs=[b"test_partial_proof_for_quality"],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
         difficulty=uint64(1000),
@@ -537,15 +536,15 @@ async def test_solution_response_empty_proof(
 
     # manually add pending request
     farmer.pending_solver_requests[quality] = {
-        "quality_data": v2_quality_chains,
+        "proof_data": partial_proofs,
         "peer": harvester_peer,
     }
 
     # get real solver peer connection
     solver_peer = await get_solver_peer(farmer)
 
     # create solution response with empty proof
-    solution_response = solver_protocol.SolverResponse(quality_chain=quality, proof=b"")
+    solution_response = solver_protocol.SolverResponse(partial_proof=quality, proof=b"")
 
     with unittest.mock.patch.object(farmer_api, "new_proof_of_space", new_callable=AsyncMock) as mock_new_proof:
         await farmer_api.solution_response(solution_response, solver_peer)
@@ -558,10 +557,9 @@ async def test_solution_response_empty_proof(
 
 
 @pytest.mark.anyio
-async def test_v2_quality_chains_solver_exception(
+async def test_v2_partial_proofs_solver_exception(
     farmer_one_harvester_solver: tuple[list[HarvesterService], FarmerService, SolverService, BlockTools],
 ) -> None:
-    """Test v2_quality_chains with solver service exception."""
     _, farmer_service, _solver_service, _ = farmer_one_harvester_solver
     farmer_api = farmer_service._api
     farmer = farmer_api.farmer
@@ -582,11 +580,11 @@ async def test_v2_quality_chains_solver_exception(
 
     farmer.sps[sp_hash] = [sp]
 
-    v2_quality_chains = harvester_protocol.V2QualityChains(
+    partial_proofs = harvester_protocol.PartialProofsData(
         challenge_hash=challenge_hash,
         sp_hash=sp_hash,
         plot_identifier="test_plot_id",
-        quality_chains=[b"test_quality_chain_1"],
+        partial_proofs=[b"test_partial_proof_1"],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
         difficulty=uint64(1000),
@@ -599,7 +597,7 @@ async def test_v2_quality_chains_solver_exception(
 
     # Mock send_to_all to raise an exception
     with unittest.mock.patch.object(farmer.server, "send_to_all", side_effect=Exception("Solver connection failed")):
-        await farmer_api.v2_quality_chains(v2_quality_chains, harvester_peer)
+        await farmer_api.partial_proofs(partial_proofs, harvester_peer)
 
         # verify pending request was cleaned up after exception
         quality = bytes32(b"3" * 32)

chia/_tests/solver/test_solver_service.py

@@ -23,7 +23,7 @@ async def test_solver_api_methods(blockchain_constants: ConsensusConstants, tmp_
             solver = solver_service._node
             solver_api = solver_service._api
             assert solver_api.ready() is True
-            test_info = SolverInfo(plot_difficulty=uint64(1500), quality_chain=b"test_quality_chain_42")
+            test_info = SolverInfo(plot_difficulty=uint64(1500), partial_proof=b"test_partial_proof_42")
             expected_proof = b"test_proof_data_12345"
             with patch.object(solver, "solve", return_value=expected_proof):
                 api_result = await solver_api.solve(test_info)
@@ -49,7 +49,7 @@ async def test_solver_error_handling(
                 pass  # expected
             # test solver handles exception in solve method
             solver = solver_service._node
-            test_info = SolverInfo(plot_difficulty=uint64(1000), quality_chain=b"test_quality_chain_zeros")
+            test_info = SolverInfo(plot_difficulty=uint64(1000), partial_proof=b"test_partial_proof_zeros")
             with patch.object(solver, "solve", side_effect=RuntimeError("test error")):
                 # solver api should handle exceptions gracefully
                 result = await solver_service._api.solve(test_info)

chia/consensus/pos_quality.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from chia_rs import PlotSize
+from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
 # The actual space in bytes of a plot, is _expected_plot_size(k) * UI_ACTUAL_SPACE_CONSTANT_FACTO
@@ -15,6 +16,11 @@
 }
 
 
+def quality_for_partial_proof(partial_proof: bytes, challenge: bytes32) -> bytes32:
+    # TODO todo_v2_plots real implementaion
+    return challenge
+
+
 def _expected_plot_size(size: PlotSize) -> uint64:
     """
     Given the plot size parameter k (which is between 32 and 59), computes the

chia/farmer/farmer_api.py

@@ -17,14 +17,14 @@
 from chia.protocols import farmer_protocol, harvester_protocol
 from chia.protocols.farmer_protocol import DeclareProofOfSpace, SignedValues
 from chia.protocols.harvester_protocol import (
+    PartialProofsData,
     PlotSyncDone,
     PlotSyncPathList,
     PlotSyncPlotList,
     PlotSyncStart,
     PoolDifficulty,
     SignatureRequestSourceData,
     SigningDataKind,
-    V2QualityChains,
 )
 from chia.protocols.outbound_message import Message, NodeType, make_msg
 from chia.protocols.pool_protocol import (
@@ -481,52 +481,52 @@ async def new_proof_of_space(
                 return
 
     @metadata.request(peer_required=True)
-    async def v2_quality_chains(self, quality_data: V2QualityChains, peer: WSChiaConnection) -> None:
+    async def partial_proofs(self, partial_proof_data: PartialProofsData, peer: WSChiaConnection) -> None:
         """
-        This is a response from the harvester for V2 plots, containing only quality chains (partial proof bytes).
+        This is a response from the harvester for V2 plots, containing only partial proof data.
         We send these to the solver service and wait for a response with the full proof.
         """
-        if quality_data.sp_hash not in self.farmer.number_of_responses:
-            self.farmer.number_of_responses[quality_data.sp_hash] = 0
-            self.farmer.cache_add_time[quality_data.sp_hash] = uint64(time.time())
+        if partial_proof_data.sp_hash not in self.farmer.number_of_responses:
+            self.farmer.number_of_responses[partial_proof_data.sp_hash] = 0
+            self.farmer.cache_add_time[partial_proof_data.sp_hash] = uint64(time.time())
 
-        if quality_data.sp_hash not in self.farmer.sps:
+        if partial_proof_data.sp_hash not in self.farmer.sps:
             self.farmer.log.warning(
-                f"Received V2 quality collection for a signage point that we do not have {quality_data.sp_hash}"
+                f"Received partial proofs for a signage point that we do not have {partial_proof_data.sp_hash}"
             )
             return None
 
-        self.farmer.cache_add_time[quality_data.sp_hash] = uint64(time.time())
+        self.farmer.cache_add_time[partial_proof_data.sp_hash] = uint64(time.time())
 
         self.farmer.log.info(
-            f"Received V2 quality collection with {len(quality_data.quality_chains)} quality chains "
-            f"for plot {quality_data.plot_identifier[:10]}... from {peer.peer_node_id}"
+            f"Received V2 partial proof collection with {len(partial_proof_data.partial_proofs)} partail proofs "
+            f"for plot {partial_proof_data.plot_identifier[:10]}... from {peer.peer_node_id}"
         )
 
         # Process each quality chain through solver service to get full proofs
-        for quality_chain in quality_data.quality_chains:
+        for partial_proof in partial_proof_data.partial_proofs:
             solver_info = SolverInfo(
-                plot_difficulty=quality_data.difficulty,
-                quality_chain=quality_chain,
+                plot_difficulty=partial_proof_data.difficulty,
+                partial_proof=partial_proof,
             )
 
             try:
                 # store pending request data for matching with response
-                self.farmer.pending_solver_requests[quality_chain] = {
-                    "quality_data": quality_data,
+                self.farmer.pending_solver_requests[partial_proof] = {
+                    "proof_data": partial_proof_data,
                     "peer": peer,
                 }
 
                 # 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 quality {quality_chain.hex()[:10]}...")
+                self.farmer.log.debug(f"Sent solve request for quality {partial_proof.hex()[:10]}...")
 
             except Exception as e:
-                self.farmer.log.error(f"Failed to call solver service for quality {quality_chain.hex()[:10]}...: {e}")
+                self.farmer.log.error(f"Failed to call solver service for quality {partial_proof.hex()[:10]}...: {e}")
                 # clean up pending request
-                if quality_chain in self.farmer.pending_solver_requests:
-                    del self.farmer.pending_solver_requests[quality_chain]
+                if partial_proof in self.farmer.pending_solver_requests:
+                    del self.farmer.pending_solver_requests[partial_proof]
 
     @metadata.request()
     async def solution_response(self, response: SolverResponse, peer: WSChiaConnection) -> None:
@@ -538,36 +538,36 @@ async def solution_response(self, response: SolverResponse, peer: WSChiaConnecti
 
         # find the matching pending request using quality_string
 
-        if response.quality_chain not in self.farmer.pending_solver_requests:
-            self.farmer.log.warning(f"Received solver response for unknown quality {response.quality_chain.hex()}")
+        if response.partial_proof not in self.farmer.pending_solver_requests:
+            self.farmer.log.warning(f"Received solver response for unknown quality {response.partial_proof.hex()}")
             return
 
         # get the original request data
-        request_data = self.farmer.pending_solver_requests.pop(response.quality_chain)
-        quality_data = request_data["quality_data"]
+        request_data = self.farmer.pending_solver_requests.pop(response.partial_proof)
+        proof_data = request_data["proof_data"]
         original_peer = request_data["peer"]
-        quality = response.quality_chain
+        quality = response.partial_proof
 
         # 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 quality {quality.hex()}...")
+            self.farmer.log.warning(f"Received empty proof from solver for proof {quality.hex()}...")
             return
 
-        sp_challenge_hash = quality_data.challenge_hash
+        sp_challenge_hash = proof_data.challenge_hash
         new_proof_of_space = harvester_protocol.NewProofOfSpace(
-            quality_data.challenge_hash,
-            quality_data.sp_hash,
-            quality_data.plot_identifier,
+            proof_data.challenge_hash,
+            proof_data.sp_hash,
+            proof_data.plot_identifier,
             ProofOfSpace(
                 sp_challenge_hash,
-                quality_data.pool_public_key,
-                quality_data.pool_contract_puzzle_hash,
-                quality_data.plot_public_key,
-                quality_data.plot_size,
+                proof_data.pool_public_key,
+                proof_data.pool_contract_puzzle_hash,
+                proof_data.plot_public_key,
+                proof_data.plot_size,
                 proof_bytes,
             ),
-            quality_data.signage_point_index,
+            proof_data.signage_point_index,
             include_source_signature_data=False,
             farmer_reward_address_override=None,
             fee_info=None,