fix service tests, cleanup

Author: almogdepaz

chia/_tests/farmer_harvester/test_farmer_harvester.py

@@ -167,9 +167,6 @@ async def test_farmer_respond_signatures(
     # messages even though it didn't request them, to cover when the farmer doesn't know
     # about an sp_hash, so it fails at the sp record check.
 
-    def log_is_ready() -> bool:
-        return len(caplog.text) > 0
-
     _, _, harvester_service, _, _ = harvester_farmer_environment
     # We won't have an sp record for this one
     challenge_hash = bytes32(b"1" * 32)
@@ -184,11 +181,16 @@ def log_is_ready() -> bool:
         include_source_signature_data=False,
         farmer_reward_address_override=None,
     )
+
+    expected_error = f"Do not have challenge hash {challenge_hash}"
+
+    def expected_log_is_ready() -> bool:
+        return expected_error in caplog.text
+
     msg = make_msg(ProtocolMessageTypes.respond_signatures, response)
     await harvester_service._node.server.send_to_all([msg], NodeType.FARMER)
-    await time_out_assert(15, log_is_ready)
-    # We fail the sps record check
-    expected_error = f"Do not have challenge hash {challenge_hash}"
+    await time_out_assert(10, expected_log_is_ready)
+    # We should find the error message
     assert expected_error in caplog.text
 
 

chia/_tests/solver/test_solver_service.py

@@ -1,146 +1,56 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Optional
 from unittest.mock import patch
 
 import pytest
-from chia_rs import ConsensusConstants, FullBlock
-from chia_rs.sized_bytes import bytes32
+from chia_rs import ConsensusConstants
 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.outbound_message import Message
 from chia.protocols.solver_protocol import SolverInfo
 from chia.simulator.block_tools import create_block_tools_async
+from chia.simulator.keyring import TempKeyring
 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:
-    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_difficulty=uint64(1500), quality_chain=b"test_quality_chain_42")
-
-        # test normal solve operation (stub returns None)
-        result = solver.solve(test_info)
-        assert result is None
-
-        # test with mocked return value to verify full flow
-        expected_proof = b"test_proof_data_12345"
-        with patch.object(solver, "solve", return_value=expected_proof):
-            api_result = await solver_api.solve(test_info)
-            assert api_result is not None
-            # api returns protocol message for peer communication
-            from chia.protocols.outbound_message import Message
-
-            assert isinstance(api_result, Message)
-
-        # test error handling - solver not started
-        original_started = solver.started
-        solver.started = False
-        api_result = await solver_api.solve(test_info)
-        assert api_result is None
-        solver.started = original_started
+    with TempKeyring(populate=True) as keychain:
+        bt = await create_block_tools_async(constants=blockchain_constants, keychain=keychain)
+        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_info = SolverInfo(plot_difficulty=uint64(1500), quality_chain=b"test_quality_chain_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)
+                assert api_result is not None
+                assert isinstance(api_result, Message)
 
 
 @pytest.mark.anyio
-async def test_solver_with_real_blocks_and_signage_points(
-    blockchain_constants: ConsensusConstants,
-    default_400_blocks: list[FullBlock],
-    empty_blockchain: Blockchain,
-    self_hostname: str,
-    tmp_path: Path,
-) -> None:
-    blockchain = empty_blockchain
-    blocks = default_400_blocks[:3]
-    for block in blocks:
-        await _validate_and_add_block(empty_blockchain, block)
-    block = blocks[-1]  # always use the last block
-    overflow = is_overflow_block(blockchain_constants, block.reward_chain_block.signage_point_index)
-    challenge = get_block_challenge(blockchain_constants, block, blockchain, False, overflow, False)
-    assert block.reward_chain_block.pos_ss_cc_challenge_hash == challenge
-    if block.reward_chain_block.challenge_chain_sp_vdf is None:
-        challenge_chain_sp: bytes32 = challenge
-    else:
-        challenge_chain_sp = block.reward_chain_block.challenge_chain_sp_vdf.output.get_hash()
-    # extract real quality data from blocks using chia's proof of space verification
-    pos = block.reward_chain_block.proof_of_space
-    # calculate real quality string from proof of space data
-    quality_string: Optional[bytes32] = verify_and_get_quality_string(
-        block.reward_chain_block.proof_of_space,
-        blockchain_constants,
-        challenge,
-        challenge_chain_sp,
-        height=block.reward_chain_block.height,
-    )
-
-    assert quality_string is not None
-    quality_hex = quality_string.hex()
-
-    # test solver with real blockchain quality
-    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
-    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
-        )
-        solve_response = await solver_rpc_client.solve(quality_hex, int(k_size), 1000)
-        assert solve_response["success"] is True
-        assert "proof" in solve_response
-        # stub implementation returns None, real implementation would return actual proof
-        assert solve_response["proof"] is None
-
-
-@pytest.mark.anyio
-async def test_solver_error_handling_and_edge_cases(
+async def test_solver_error_handling(
     blockchain_constants: ConsensusConstants, self_hostname: str, tmp_path: Path
 ) -> None:
-    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
-        )
-
-        # test invalid quality string format
-        try:
-            await solver_rpc_client.solve("invalid_hex")
-            assert False, "should have raised exception for invalid hex"
-        except Exception:
-            pass  # expected
-
-        # test edge case parameters
-        valid_quality = "1234567890abcdef" * 4
-
-        # test with edge case plot sizes and difficulties
-        edge_cases = [
-            (18, 1),  # minimum plot size, minimum difficulty
-            (50, 999999),  # large plot size, high difficulty
-        ]
-
-        for plot_size, difficulty in edge_cases:
-            response = await solver_rpc_client.solve(valid_quality, plot_size, difficulty)
-            assert response["success"] is True
-            assert "proof" in response
-
-        # 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")
-
-        with patch.object(solver, "solve", side_effect=RuntimeError("test error")):
-            # solver api should handle exceptions gracefully
-            result = await solver_service._api.solve(test_info)
-            assert result is None  # api returns None on error
+    with TempKeyring(populate=True) as keychain:
+        bt = await create_block_tools_async(constants=blockchain_constants, keychain=keychain)
+        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
+            )
+            try:
+                await solver_rpc_client.solve("invalid_hex")
+                assert False, "should have raised exception for invalid hex"
+            except Exception:
+                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")
+            with patch.object(solver, "solve", side_effect=RuntimeError("test error")):
+                # solver api should handle exceptions gracefully
+                result = await solver_service._api.solve(test_info)
+                assert result is None  # api returns None on error

chia/farmer/farmer_api.py

@@ -75,7 +75,7 @@ async def new_proof_of_space(
         """
         if new_proof_of_space.sp_hash not in self.farmer.number_of_responses:
             self.farmer.number_of_responses[new_proof_of_space.sp_hash] = 0
-            self.farmer.cache_add_time[new_proof_of_space.sp_hash] = uint64(int(time.time()))
+            self.farmer.cache_add_time[new_proof_of_space.sp_hash] = uint64(time.time())
 
         max_pos_per_sp = 5
 
@@ -172,14 +172,14 @@ async def new_proof_of_space(
                         new_proof_of_space.proof,
                     )
                 )
-                self.farmer.cache_add_time[new_proof_of_space.sp_hash] = uint64(int(time.time()))
+                self.farmer.cache_add_time[new_proof_of_space.sp_hash] = uint64(time.time())
                 self.farmer.quality_str_to_identifiers[computed_quality_string] = (
                     new_proof_of_space.plot_identifier,
                     new_proof_of_space.challenge_hash,
                     new_proof_of_space.sp_hash,
                     peer.peer_node_id,
                 )
-                self.farmer.cache_add_time[computed_quality_string] = uint64(int(time.time()))
+                self.farmer.cache_add_time[computed_quality_string] = uint64(time.time())
 
                 await peer.send_message(make_msg(ProtocolMessageTypes.request_signatures, request))
 
@@ -488,15 +488,15 @@ async def v2_qualities(self, quality_data: V2Qualities, peer: WSChiaConnection)
         """
         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(int(time.time()))
+            self.farmer.cache_add_time[quality_data.sp_hash] = uint64(time.time())
 
         if quality_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}"
             )
             return None
 
-        self.farmer.cache_add_time[quality_data.sp_hash] = uint64(int(time.time()))
+        self.farmer.cache_add_time[quality_data.sp_hash] = uint64(time.time())
 
         self.farmer.log.info(
             f"Received V2 quality collection with {len(quality_data.quality_chains)} quality chains "
@@ -576,14 +576,6 @@ 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)
@@ -664,7 +656,7 @@ async def new_signage_point(self, new_signage_point: farmer_protocol.NewSignageP
 
                     pool_dict[key] = strip_old_entries(pairs=pool_dict[key], before=cutoff_24h)
 
-        now = uint64(int(time.time()))
+        now = uint64(time.time())
         self.farmer.cache_add_time[new_signage_point.challenge_chain_sp] = now
         missing_signage_points = self.farmer.check_missing_signage_points(now, new_signage_point)
         self.farmer.state_changed(

chia/harvester/harvester_api.py

@@ -363,7 +363,7 @@ async def lookup_challenge(
                 msg = make_msg(ProtocolMessageTypes.v2_qualities, v2_qualities)
                 await peer.send_message(msg)
 
-        now = uint64(int(time.time()))
+        now = uint64(time.time())
 
         farming_info = FarmingInfo(
             new_challenge.challenge_hash,
@@ -395,14 +395,6 @@ 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/solver/solver.py

@@ -69,7 +69,7 @@ async def manage(self) -> AsyncIterator[None]:
 
     def solve(self, info: SolverInfo) -> Optional[bytes]:
         self.log.debug(f"Solve request: quality={info.quality_chain.hex()}")
-        # todo implement actualy calling the solver
+        # TODO todo_v2_plots implement actualy calling the solver
         return None
 
     def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:

chia/solver/solver_rpc_client.py

@@ -20,6 +20,4 @@ async def get_state(self) -> dict[str, Any]:
     async def solve(self, quality_string: str, plot_size: int = 32, plot_difficulty: int = 1000) -> dict[str, Any]:
         """Solve a quality string with optional plot size and difficulty."""
         quality = bytes32.from_hexstr(quality_string)
-        return await self.fetch(
-            "solve", {"quality_string": quality.hex(), "plot_size": plot_size, "plot_difficulty": plot_difficulty}
-        )
+        return await self.fetch("solve", {"quality_chain": quality.hex(), "plot_difficulty": plot_difficulty})