change quality_string to quality_chain

Author: almogdepaz

chia/_tests/farmer_harvester/test_farmer_harvester.py

@@ -186,7 +186,7 @@ def log_is_ready() -> bool:
     )
     msg = make_msg(ProtocolMessageTypes.respond_signatures, response)
     await harvester_service._node.server.send_to_all([msg], NodeType.FARMER)
-    await time_out_assert(5, log_is_ready)
+    await time_out_assert(15, log_is_ready)
     # We fail the sps record check
     expected_error = f"Do not have challenge hash {challenge_hash}"
     assert expected_error in caplog.text
@@ -461,7 +461,7 @@ async def test_solution_response_handler(
     }
 
     # create solution response
-    solution_response = solver_protocol.SolverResponse(quality_string=quality, proof=b"test_proof_from_solver")
+    solution_response = solver_protocol.SolverResponse(quality_chain=quality, proof=b"test_proof_from_solver")
     solver_peer = Mock()
     solver_peer.peer_node_id = "solver_peer"
 
@@ -493,7 +493,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_string=bytes32(b"1" * 32), proof=b"test_proof")
+    solution_response = solver_protocol.SolverResponse(quality_chain=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)
@@ -543,7 +543,7 @@ async def test_solution_response_empty_proof(
     solver_peer = await get_solver_peer(farmer)
 
     # create solution response with empty proof
-    solution_response = solver_protocol.SolverResponse(quality_string=quality, proof=b"")
+    solution_response = solver_protocol.SolverResponse(quality_chain=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)

chia/_tests/solver/test_solver_service.py

@@ -7,27 +7,29 @@
 import pytest
 from chia_rs import ConsensusConstants, FullBlock
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint8, uint64
+from chia_rs.sized_ints import uint64
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
 from chia.consensus.blockchain import Blockchain
 from chia.consensus.get_block_challenge import get_block_challenge
 from chia.consensus.pot_iterations import is_overflow_block
 from chia.protocols.solver_protocol import SolverInfo
+from chia.simulator.block_tools import create_block_tools_async
 from chia.simulator.setup_services import setup_solver
 from chia.solver.solver_rpc_client import SolverRpcClient
 from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string
 
 
 @pytest.mark.anyio
 async def test_solver_api_methods(blockchain_constants: ConsensusConstants, tmp_path: Path) -> None:
-    async with setup_solver(tmp_path, blockchain_constants) as solver_service:
+    bt = await create_block_tools_async(constants=blockchain_constants)
+    async with setup_solver(tmp_path, bt, blockchain_constants) as solver_service:
         solver = solver_service._node
         solver_api = solver_service._api
         assert solver_api.ready() is True
 
         # test solve with real SolverInfo
-        test_info = SolverInfo(plot_size=uint8(32), plot_difficulty=uint64(1500), quality_string=bytes32([42] * 32))
+        test_info = SolverInfo(plot_difficulty=uint64(1500), quality_chain=b"test_quality_chain_42")
 
         # test normal solve operation (stub returns None)
         result = solver.solve(test_info)
@@ -89,7 +91,8 @@ async def test_solver_with_real_blocks_and_signage_points(
     plot_size = pos.size()
     k_size = plot_size.size_v1 if plot_size.size_v1 is not None else plot_size.size_v2
     assert k_size is not None
-    async with setup_solver(tmp_path, blockchain_constants) as solver_service:
+    bt = await create_block_tools_async(constants=blockchain_constants)
+    async with setup_solver(tmp_path, bt, blockchain_constants) as solver_service:
         assert solver_service.rpc_server is not None
         solver_rpc_client = await SolverRpcClient.create(
             self_hostname, solver_service.rpc_server.listen_port, solver_service.root_path, solver_service.config
@@ -105,7 +108,8 @@ async def test_solver_with_real_blocks_and_signage_points(
 async def test_solver_error_handling_and_edge_cases(
     blockchain_constants: ConsensusConstants, self_hostname: str, tmp_path: Path
 ) -> None:
-    async with setup_solver(tmp_path, blockchain_constants) as solver_service:
+    bt = await create_block_tools_async(constants=blockchain_constants)
+    async with setup_solver(tmp_path, bt, blockchain_constants) as solver_service:
         assert solver_service.rpc_server is not None
         solver_rpc_client = await SolverRpcClient.create(
             self_hostname, solver_service.rpc_server.listen_port, solver_service.root_path, solver_service.config
@@ -134,7 +138,7 @@ async def test_solver_error_handling_and_edge_cases(
 
         # test solver handles exception in solve method
         solver = solver_service._node
-        test_info = SolverInfo(plot_size=uint8(32), plot_difficulty=uint64(1000), quality_string=bytes32.zeros)
+        test_info = SolverInfo(plot_difficulty=uint64(1000), quality_chain=b"test_quality_chain_zeros")
 
         with patch.object(solver, "solve", side_effect=RuntimeError("test error")):
             # solver api should handle exceptions gracefully

chia/farmer/farmer.py

@@ -144,7 +144,7 @@ def __init__(
         self.quality_str_to_identifiers: dict[bytes32, tuple[str, bytes32, bytes32, bytes32]] = {}
 
         # Track pending solver requests, keyed by quality string hex
-        self.pending_solver_requests: dict[bytes32, dict[str, Any]] = {}
+        self.pending_solver_requests: dict[bytes, dict[str, Any]] = {}
 
         # number of responses to each signage point
         self.number_of_responses: dict[bytes32, int] = {}

chia/farmer/farmer_api.py

@@ -499,35 +499,34 @@ async def v2_qualities(self, quality_data: V2Qualities, peer: WSChiaConnection)
         self.farmer.cache_add_time[quality_data.sp_hash] = uint64(int(time.time()))
 
         self.farmer.log.info(
-            f"Received V2 quality collection with {len(quality_data.qualities)} qualities "
+            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}"
         )
 
-        # Process each quality through solver service to get full proofs
-        for quality in quality_data.qualities:
+        # Process each quality chain through solver service to get full proofs
+        for quality_chain in quality_data.quality_chains:
             solver_info = SolverInfo(
-                plot_size=quality_data.plot_size,
                 plot_difficulty=quality_data.difficulty,
-                quality_string=quality,
+                quality_chain=quality_chain,
             )
 
             try:
                 # store pending request data for matching with response
-                self.farmer.pending_solver_requests[quality] = {
+                self.farmer.pending_solver_requests[quality_chain] = {
                     "quality_data": quality_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.hex()[:10]}...")
+                self.farmer.log.debug(f"Sent solve request for quality {quality_chain.hex()[:10]}...")
 
             except Exception as e:
-                self.farmer.log.error(f"Failed to call solver service for quality {quality.hex()[:10]}...: {e}")
+                self.farmer.log.error(f"Failed to call solver service for quality {quality_chain.hex()[:10]}...: {e}")
                 # clean up pending request
-                if quality in self.farmer.pending_solver_requests:
-                    del self.farmer.pending_solver_requests[quality]
+                if quality_chain in self.farmer.pending_solver_requests:
+                    del self.farmer.pending_solver_requests[quality_chain]
 
     @metadata.request()
     async def solution_response(self, response: SolverResponse, peer: WSChiaConnection) -> None:
@@ -539,20 +538,20 @@ async def solution_response(self, response: SolverResponse, peer: WSChiaConnecti
 
         # find the matching pending request using quality_string
 
-        if response.quality_string not in self.farmer.pending_solver_requests:
-            self.farmer.log.warning(f"Received solver response for unknown quality {response.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()}")
             return
 
         # get the original request data
-        request_data = self.farmer.pending_solver_requests.pop(response.quality_string)
+        request_data = self.farmer.pending_solver_requests.pop(response.quality_chain)
         quality_data = request_data["quality_data"]
         original_peer = request_data["peer"]
-        quality = response.quality_string
+        quality = response.quality_chain
 
         # 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()[:10]}...")
+            self.farmer.log.warning(f"Received empty proof from solver for quality {quality.hex()}...")
             return
 
         sp_challenge_hash = quality_data.challenge_hash
@@ -577,6 +576,14 @@ async def solution_response(self, response: SolverResponse, peer: WSChiaConnecti
         # process the proof of space
         await self.new_proof_of_space(new_proof_of_space, original_peer)
 
+    def _derive_quality_string_from_chain(self, quality_chain: bytes) -> bytes32:
+        """Derive 32-byte quality string from quality chain (16 * k bits blob)."""
+        # TODO: todo_v2_plots implement actual quality string derivation algorithm
+        # For now, hash the quality chain to get a 32-byte result
+        from chia.util.hash import std_hash
+
+        return std_hash(quality_chain)
+
     @metadata.request()
     async def respond_signatures(self, response: harvester_protocol.RespondSignatures) -> None:
         request = self._process_respond_signatures(response)

chia/harvester/harvester_api.py

@@ -107,47 +107,29 @@ def blocking_lookup_v2_qualities(filename: Path, plot_info: PlotInfo) -> Optiona
                     new_challenge.sp_hash,
                 )
                 try:
-                    quality_strings = plot_info.prover.get_qualities_for_challenge(sp_challenge_hash)
+                    quality_chains = plot_info.prover.get_quality_chains_for_challenge(sp_challenge_hash)
                 except Exception as e:
-                    self.harvester.log.error(f"Exception fetching qualities for V2 plot {filename}. {e}")
+                    self.harvester.log.error(f"Exception fetching quality chains for V2 plot {filename}. {e}")
                     return None
 
-                if quality_strings is not None and len(quality_strings) > 0:
+                if quality_chains is not None and len(quality_chains) > 0:
                     # Get the appropriate difficulty for this plot
                     difficulty = new_challenge.difficulty
-                    sub_slot_iters = new_challenge.sub_slot_iters
                     if plot_info.pool_contract_puzzle_hash is not None:
                         # Check for pool-specific difficulty
                         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
                                 break
 
-                    # Filter qualities that pass the required_iters check (same as V1 flow)
-                    good_qualities = []
-                    sp_interval_iters = calculate_sp_interval_iters(self.harvester.constants, sub_slot_iters)
-
-                    for quality_str in quality_strings:
-                        required_iters: uint64 = calculate_iterations_quality(
-                            self.harvester.constants,
-                            quality_str,
-                            PlotSize.make_v1(plot_info.prover.get_size()),  # TODO: todo_v2_plots update for V2
-                            difficulty,
-                            new_challenge.sp_hash,
-                            sub_slot_iters,
-                            new_challenge.last_tx_height,
-                        )
-
-                        if required_iters < sp_interval_iters:
-                            good_qualities.append(quality_str)
+                    # Filter quality chains that pass the required_iters check
 
-                    if len(good_qualities) > 0:
+                    if len(quality_chains) > 0:
                         return V2Qualities(
                             new_challenge.challenge_hash,
                             new_challenge.sp_hash,
-                            good_qualities[0].hex() + str(filename.resolve()),
-                            good_qualities,
+                            quality_chains[0].hex() + str(filename.resolve()),
+                            quality_chains,
                             new_challenge.signage_point_index,
                             plot_info.prover.get_size(),
                             difficulty,
@@ -375,7 +357,7 @@ async def lookup_challenge(
                     f" to minimize risk of losing rewards."
                 )
             if v2_qualities is not None:
-                total_v2_qualities_found += len(v2_qualities.qualities)
+                total_v2_qualities_found += len(v2_qualities.quality_chains)
                 msg = make_msg(ProtocolMessageTypes.v2_qualities, v2_qualities)
                 await peer.send_message(msg)
 
@@ -411,6 +393,14 @@ async def lookup_challenge(
             },
         )
 
+    # def _derive_quality_string_from_chain(self, quality_chain: bytes) -> bytes32:
+    #     """Derive 32-byte quality string from quality chain (16 * k bits blob)."""
+    #     # TODO: todo_v2_plots implement actual quality string derivation algorithm
+    #     # For now, hash the quality chain to get a 32-byte result
+    #     from chia.util.hash import std_hash
+
+    #     return std_hash(quality_chain)
+
     @metadata.request(reply_types=[ProtocolMessageTypes.respond_signatures])
     async def request_signatures(self, request: harvester_protocol.RequestSignatures) -> Optional[Message]:
         """

chia/plotting/prover.py

@@ -27,6 +27,7 @@ def get_version(self) -> PlotVersion: ...
     def __bytes__(self) -> bytes: ...
     def get_id(self) -> bytes32: ...
     def get_qualities_for_challenge(self, challenge: bytes32) -> list[bytes32]: ...
+    def get_quality_chains_for_challenge(self, challenge: bytes) -> list[bytes]: ...
     def get_full_proof(self, challenge: bytes, index: int, parallel_read: bool = True) -> bytes: ...
 
     @classmethod
@@ -72,6 +73,10 @@ def get_qualities_for_challenge(self, challenge: bytes) -> list[bytes32]:
         # TODO: todo_v2_plots Implement plot quality lookup
         raise NotImplementedError("V2 plot format is not yet implemented")
 
+    def get_quality_chains_for_challenge(self, challenge: bytes) -> list[bytes]:
+        # TODO: todo_v2_plots Implement quality chain lookup (16 * k bits blobs)
+        raise NotImplementedError("V2 plot format is not yet implemented")
+
     def get_full_proof(self, challenge: bytes, index: int, parallel_read: bool = True) -> bytes:
         # TODO: todo_v2_plots Implement plot proof generation
         raise NotImplementedError("V2 plot format require solver to get full proof")
@@ -115,6 +120,9 @@ def get_id(self) -> bytes32:
     def get_qualities_for_challenge(self, challenge: bytes32) -> list[bytes32]:
         return [bytes32(quality) for quality in self._disk_prover.get_qualities_for_challenge(challenge)]
 
+    def get_quality_chains_for_challenge(self, challenge: bytes) -> list[bytes]:
+        raise NotImplementedError("V1 does not implement quality chains, only qualities")
+
     def get_full_proof(self, challenge: bytes, index: int, parallel_read: bool = True) -> bytes:
         return bytes(self._disk_prover.get_full_proof(challenge, index, parallel_read))
 

chia/protocols/harvester_protocol.py

@@ -69,7 +69,7 @@ class V2Qualities(Streamable):
     challenge_hash: bytes32
     sp_hash: bytes32
     plot_identifier: str
-    qualities: list[bytes32]
+    quality_chains: list[bytes]  # 16 * k bits blobs instead of 32-byte quality strings
     signage_point_index: uint8
     plot_size: uint8
     difficulty: uint64

chia/protocols/shared_protocol.py

@@ -17,6 +17,7 @@
     NodeType.INTRODUCER: "0.0.36",
     NodeType.WALLET: "0.0.38",
     NodeType.DATA_LAYER: "0.0.36",
+    NodeType.SOLVER: "0.0.37",
 }
 
 """
@@ -65,7 +66,7 @@ class Capability(IntEnum):
     NodeType.INTRODUCER: _capabilities,
     NodeType.WALLET: _capabilities,
     NodeType.DATA_LAYER: _capabilities,
-    NodeType.SOLVER: [],
+    NodeType.SOLVER: _capabilities,
 }
 
 

chia/protocols/solver_protocol.py

@@ -2,22 +2,20 @@
 
 from dataclasses import dataclass
 
-from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint8, uint64
+from chia_rs.sized_ints import uint64
 
 from chia.util.streamable import Streamable, streamable
 
 
 @streamable
 @dataclass(frozen=True)
 class SolverInfo(Streamable):
-    plot_size: uint8
     plot_difficulty: uint64
-    quality_string: bytes32
+    quality_chain: bytes  # 16 * k bits blob, k (plot size) can be derived from this
 
 
 @streamable
 @dataclass(frozen=True)
 class SolverResponse(Streamable):
-    quality_string: bytes32
+    quality_chain: bytes
     proof: bytes

chia/solver/solver.py

@@ -68,7 +68,7 @@ async def manage(self) -> AsyncIterator[None]:
             self.log.info("Solver service shutdown complete")
 
     def solve(self, info: SolverInfo) -> Optional[bytes]:
-        self.log.debug(f"Solve request: quality={info.quality_string.hex()}")
+        self.log.debug(f"Solve request: quality={info.quality_chain.hex()}")
         # todo implement actualy calling the solver
         return None