remove strangth from SolverInfo

Author: almogdepaz

chia/_tests/solver/test_solver_service.py

@@ -5,7 +5,6 @@
 
 import pytest
 from chia_rs import ConsensusConstants
-from chia_rs.sized_ints import uint64
 
 from chia.protocols.outbound_message import Message
 from chia.protocols.solver_protocol import SolverInfo
@@ -23,7 +22,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_strength=uint64(1500), partial_proof=b"test_partial_proof_42")
+            test_info = SolverInfo(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 +48,7 @@ async def test_solver_error_handling(
                 pass  # expected
             # test solver handles exception in solve method
             solver = solver_service._node
-            test_info = SolverInfo(plot_strength=uint64(1000), partial_proof=b"test_partial_proof_zeros")
+            test_info = SolverInfo(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/_tests/util/network_protocol_data.py

@@ -1106,6 +1106,6 @@
 )
 
 # SOLVER PROTOCOL
-solver_info = solver_protocol.SolverInfo(uint64(2), b"partial-proof")
+solver_info = solver_protocol.SolverInfo(partial_proof=b"partial-proof")
 
 solver_response = solver_protocol.SolverResponse(b"partial-proof", b"full-proof")

chia/_tests/util/protocol_messages_bytes-v1.0

@@ -2715,7 +2715,7 @@
 
 error_with_data_json: dict[str, Any] = {"code": 1, "message": "Unknown", "data": "0x65787472612064617461"}
 
-solver_info_json: dict[str, Any] = {"plot_strength": 2, "partial_proof": "0x7061727469616c2d70726f6f66"}
+solver_info_json: dict[str, Any] = {"partial_proof": "0x7061727469616c2d70726f6f66"}
 
 solver_response_json: dict[str, Any] = {
     "partial_proof": "0x7061727469616c2d70726f6f66",

chia/_tests/util/protocol_messages_json.py

@@ -31,7 +31,7 @@ async def solve_quality(
     """Solve a quality string via RPC."""
     try:
         async with get_any_service_client(SolverRpcClient, ctx.root_path, solver_rpc_port) as (client, _):
-            response = await client.solve(quality_hex, plot_size, difficulty)
+            response = await client.solve(quality_hex)
             print(json.dumps(response, indent=2))
     except Exception as e:
         print(f"Failed to solve quality: {e}")

chia/cmds/solver_funcs.py

@@ -505,10 +505,7 @@ async def partial_proofs(self, partial_proof_data: PartialProofsData, peer: WSCh
 
         # Process each quality chain through solver service to get full proofs
         for partial_proof in partial_proof_data.partial_proofs:
-            solver_info = SolverInfo(
-                plot_strength=partial_proof_data.difficulty,
-                partial_proof=partial_proof,
-            )
+            solver_info = SolverInfo(partial_proof=partial_proof)
 
             try:
                 # store pending request data for matching with response

chia/farmer/farmer_api.py

@@ -124,7 +124,7 @@ def blocking_lookup_v2_partial_proofs(filename: Path, plot_info: PlotInfo) -> Op
                 partial_proofs = plot_info.prover.get_partial_proofs_for_challenge(sp_challenge_hash)
 
                 # If no partial proofs are found, return None
-                if partial_proofs is None or len(partial_proofs) == 0:
+                if len(partial_proofs) == 0:
                     return None
 
                 # Get the appropriate difficulty for this plot

chia/harvester/harvester_api.py

@@ -2,15 +2,12 @@
 
 from dataclasses import dataclass
 
-from chia_rs.sized_ints import uint64
-
 from chia.util.streamable import Streamable, streamable
 
 
 @streamable
 @dataclass(frozen=True)
 class SolverInfo(Streamable):
-    plot_strength: uint64
     partial_proof: bytes  # 16 * k bits blob, k (plot size) can be derived from this
 
 

chia/protocols/solver_protocol.py

@@ -11,7 +11,6 @@
 from chia_rs import ConsensusConstants
 
 from chia.protocols.outbound_message import NodeType
-from chia.protocols.solver_protocol import SolverInfo
 from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
@@ -66,8 +65,8 @@ async def manage(self) -> AsyncIterator[None]:
             self.executor.shutdown(wait=True)
             self.log.info("Solver service shutdown complete")
 
-    def solve(self, info: SolverInfo) -> Optional[bytes]:
-        self.log.debug(f"Solve request: quality={info.partial_proof.hex()}")
+    def solve(self, partial_proof: bytes) -> Optional[bytes]:
+        self.log.debug(f"Solve request: quality={partial_proof.hex()}")
         # TODO todo_v2_plots implement actualy calling the solver
         return None
 

chia/solver/solver.py

@@ -33,27 +33,27 @@ async def solve(
         request: SolverInfo,
     ) -> Optional[Message]:
         """
-        Solve a V2 plot quality to get the full proof of space.
-        This is called by the farmer when it receives V2 qualities from harvester.
+        Solve a V2 plot partial proof to get the full proof of space.
+        This is called by the farmer when it receives V2 parital proofs from harvester.
         """
         if not self.solver.started:
             self.log.error("Solver is not started")
             return None
 
-        self.log.debug(f"Solving quality {request.partial_proof.hex()}with difficulty {request.plot_strength}")
+        self.log.debug(f"Solving partial {request.partial_proof.hex()}")
 
         try:
-            proof = self.solver.solve(request)
+            proof = self.solver.solve(request.partial_proof)
             if proof is None:
-                self.log.warning(f"Solver returned no proof for quality {request.partial_proof.hex()}")
+                self.log.warning(f"Solver returned no proof for parital {request.partial_proof.hex()}")
                 return None
 
-            self.log.debug(f"Successfully solved quality, returning {len(proof)} byte proof")
+            self.log.debug(f"Successfully solved partial proof, returning {len(proof)} byte proof")
             return make_msg(
                 ProtocolMessageTypes.solution_response,
                 SolverResponse(proof=proof, partial_proof=request.partial_proof),
             )
 
         except Exception as e:
-            self.log.error(f"Error solving quality {request.partial_proof.hex()}: {e}")
+            self.log.error(f"Error solving parital {request.partial_proof.hex()}: {e}")
             return None