harvester_new_sp concurrent, add strength back

Author: almogdepaz

chia/_tests/farmer_harvester/test_farmer_harvester.py

@@ -341,7 +341,7 @@ async def test_v2_partial_proofs_new_sp_hash(
         partial_proofs=[b"test_partial_proof_1"],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
-        difficulty=uint64(1000),
+        plot_strength=uint64(1000),
         pool_public_key=None,
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -371,7 +371,7 @@ async def test_v2_partial_proofs_missing_sp_hash(
         partial_proofs=[b"test_partial_proof_1"],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
-        difficulty=uint64(1000),
+        plot_strength=uint64(1000),
         pool_public_key=None,
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -414,7 +414,7 @@ async def test_v2_partial_proofs_with_existing_sp(
         partial_proofs=[b"test_partial_proof_1", b"test_partial_proof_2"],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
-        difficulty=uint64(1000),
+        plot_strength=uint64(1000),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -448,7 +448,7 @@ async def test_solution_response_handler(
         partial_proofs=[b"test_partial_proof_for_quality"],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
-        difficulty=uint64(1000),
+        plot_strength=uint64(1000),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -525,7 +525,7 @@ async def test_solution_response_empty_proof(
         partial_proofs=[b"test_partial_proof_for_quality"],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
-        difficulty=uint64(1000),
+        plot_strength=uint64(1000),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -587,7 +587,7 @@ async def test_v2_partial_proofs_solver_exception(
         partial_proofs=[b"test_partial_proof_1"],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
-        difficulty=uint64(1000),
+        plot_strength=uint64(1000),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),

chia/_tests/solver/test_solver_service.py

@@ -5,6 +5,7 @@
 
 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
@@ -22,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(partial_proof=b"test_partial_proof_42")
+            test_info = SolverInfo(partial_proof=b"test_partial_proof_42", plot_strength=uint64(1500))
             expected_proof = b"test_proof_data_12345"
             with patch.object(solver, "solve", return_value=expected_proof):
                 api_result = await solver_api.solve(test_info)
@@ -42,13 +43,13 @@ async def test_solver_error_handling(
                 self_hostname, solver_service.rpc_server.listen_port, solver_service.root_path, solver_service.config
             )
             try:
-                await solver_rpc_client.solve("invalid_hex")
+                await solver_rpc_client.solve("invalid_hex", uint64(1000))
                 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(partial_proof=b"test_partial_proof_zeros")
+            test_info = SolverInfo(partial_proof=b"test_partial_proof_zeros", plot_strength=uint64(1000))
             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(partial_proof=b"partial-proof")
+solver_info = solver_protocol.SolverInfo(partial_proof=b"partial-proof", plot_strength=uint64(2))
 
 solver_response = solver_protocol.SolverResponse(b"partial-proof", b"full-proof")

chia/_tests/util/protocol_messages_bytes-v1.0

@@ -72,7 +72,7 @@
     "partial_proofs": ["0x7061727469616c2d70726f6f6631", "0x7061727469616c2d70726f6f6632"],
     "signage_point_index": 4,
     "plot_size": 32,
-    "difficulty": 100000,
+    "plot_strength": 100000,
     "pool_public_key": "0xa04c6b5ac7dfb935f6feecfdd72348ccf1d4be4fe7e26acf271ea3b7d308da61e0a308f7a62495328a81f5147b66634c",
     "pool_contract_puzzle_hash": "0x91240fbacdf93b44c0571caa74fd99f163d4c5d7deaedac87125528721493f7a",
     "plot_public_key": "0xa04c6b5ac7dfb935f6feecfdd72348ccf1d4be4fe7e26acf271ea3b7d308da61e0a308f7a62495328a81f5147b66634c",
@@ -2715,7 +2715,7 @@
 
 error_with_data_json: dict[str, Any] = {"code": 1, "message": "Unknown", "data": "0x65787472612064617461"}
 
-solver_info_json: dict[str, Any] = {"partial_proof": "0x7061727469616c2d70726f6f66"}
+solver_info_json: dict[str, Any] = {"partial_proof": "0x7061727469616c2d70726f6f66", "plot_strength": 2}
 
 solver_response_json: dict[str, Any] = {
     "partial_proof": "0x7061727469616c2d70726f6f66",

chia/_tests/util/protocol_messages_json.py

@@ -49,14 +49,23 @@ def get_state_cmd(
     type=str,
     required=True,
 )
+@click.option(
+    "-s",
+    "--plot_strength",
+    help="Plot plot_strength (default: 1000)",
+    type=int,
+    default=1000,
+    show_default=True,
+)
 @click.pass_context
 def solve_cmd(
     ctx: click.Context,
     solver_rpc_port: Optional[int],
     partial_proof: str,
+    plot_strength: int,
 ) -> None:
     import asyncio
 
     from chia.cmds.solver_funcs import solve_partial_proof
 
-    asyncio.run(solve_partial_proof(ChiaCliContext.set_default(ctx), solver_rpc_port, partial_proof))
+    asyncio.run(solve_partial_proof(ChiaCliContext.set_default(ctx), solver_rpc_port, partial_proof, plot_strength))

chia/cmds/solver.py

@@ -3,6 +3,8 @@
 import json
 from typing import Optional
 
+from chia_rs.sized_ints import uint64
+
 from chia.cmds.cmd_classes import ChiaCliContext
 from chia.cmds.cmds_util import get_any_service_client
 from chia.solver.solver_rpc_client import SolverRpcClient
@@ -25,11 +27,12 @@ async def solve_partial_proof(
     ctx: ChiaCliContext,
     solver_rpc_port: Optional[int],
     partial_proof: str,
+    plot_strength: int,
 ) -> None:
     """Solve a partial proof via RPC."""
     try:
         async with get_any_service_client(SolverRpcClient, ctx.root_path, solver_rpc_port) as (client, _):
-            response = await client.solve(partial_proof)
+            response = await client.solve(partial_proof, plot_strength=uint64(plot_strength))
             print(json.dumps(response, indent=2))
     except Exception as e:
         print(f"Failed to solve partial proof: {e}")

chia/cmds/solver_funcs.py

@@ -505,7 +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(partial_proof=partial_proof)
+            solver_info = SolverInfo(partial_proof=partial_proof, plot_strength=partial_proof_data.plot_strength)
 
             try:
                 # store pending request data for matching with response

chia/farmer/farmer_api.py

@@ -3,6 +3,7 @@
 import asyncio
 import logging
 import time
+from collections.abc import Awaitable, Sequence
 from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
@@ -65,6 +66,47 @@ def _plot_passes_filter(self, plot_info: PlotInfo, challenge: harvester_protocol
             challenge.sp_hash,
         )
 
+    async def _handle_v1_responses(
+        self,
+        awaitables: Sequence[Awaitable[tuple[Path, list[harvester_protocol.NewProofOfSpace]]]],
+        start_time: float,
+        peer: WSChiaConnection,
+    ) -> int:
+        proofs_found = 0
+        for filename_sublist_awaitable in asyncio.as_completed(awaitables):
+            filename, sublist = await filename_sublist_awaitable
+            time_taken = time.monotonic() - start_time
+            if time_taken > 8:
+                self.harvester.log.warning(
+                    f"Looking up qualities on {filename} took: {time_taken}. This should be below 8 seconds"
+                    f" to minimize risk of losing rewards."
+                )
+            for response in sublist:
+                proofs_found += 1
+                msg = make_msg(ProtocolMessageTypes.new_proof_of_space, response)
+                await peer.send_message(msg)
+        return proofs_found
+
+    async def _handle_v2_responses(
+        self, v2_awaitables: Sequence[Awaitable[Optional[PartialProofsData]]], start_time: float, peer: WSChiaConnection
+    ) -> int:
+        partial_proofs_found = 0
+        for quality_awaitable in asyncio.as_completed(v2_awaitables):
+            partial_proofs_data = await quality_awaitable
+            if partial_proofs_data is None:
+                continue
+            time_taken = time.monotonic() - start_time
+            if time_taken > 8:
+                self.harvester.log.warning(
+                    f"Looking up partial proofs on {partial_proofs_data.plot_identifier}"
+                    f"took: {time_taken}. This should be below 8 seconds"
+                    f"to minimize risk of losing rewards."
+                )
+            partial_proofs_found += len(partial_proofs_data.partial_proofs)
+            msg = make_msg(ProtocolMessageTypes.partial_proofs, partial_proofs_data)
+            await peer.send_message(msg)
+        return partial_proofs_found
+
     @metadata.request(peer_required=True)
     async def harvester_handshake(
         self, harvester_handshake: harvester_protocol.HarvesterHandshake, peer: WSChiaConnection
@@ -354,30 +396,22 @@ async def lookup_challenge(
         total_proofs_found = 0
         total_v2_partial_proofs_found = 0
 
-        # Process V1 plot responses (existing flow)
-        for filename_sublist_awaitable in asyncio.as_completed(awaitables):
-            filename, sublist = await filename_sublist_awaitable
-            time_taken = time.monotonic() - start
-            if time_taken > 8:
-                self.harvester.log.warning(
-                    f"Looking up qualities on {filename} took: {time_taken}. This should be below 8 seconds"
-                    f" to minimize risk of losing rewards."
-                )
-            else:
-                pass
-                # self.harvester.log.info(f"Looking up qualities on {filename} took: {time_taken}")
-            for response in sublist:
-                total_proofs_found += 1
-                msg = make_msg(ProtocolMessageTypes.new_proof_of_space, response)
-                await peer.send_message(msg)
-
-        # Process V2 plot quality collections (new flow)
-        for quality_awaitable in asyncio.as_completed(v2_awaitables):
-            partial_proofs_data = await quality_awaitable
-            if partial_proofs_data is not None:
-                total_v2_partial_proofs_found += len(partial_proofs_data.partial_proofs)
-                msg = make_msg(ProtocolMessageTypes.partial_proofs, partial_proofs_data)
-                await peer.send_message(msg)
+        # run both concurrently
+        tasks = []
+        if awaitables:
+            tasks.append(self._handle_v1_responses(awaitables, start, peer))
+        if v2_awaitables:
+            tasks.append(self._handle_v2_responses(v2_awaitables, start, peer))
+
+        if tasks:
+            results = await asyncio.gather(*tasks)
+            if len(results) == 2:
+                total_proofs_found, total_v2_partial_proofs_found = results
+            elif len(results) == 1:
+                if awaitables:
+                    total_proofs_found = results[0]
+                else:
+                    total_v2_partial_proofs_found = results[0]
 
         now = uint64(time.time())
 

chia/harvester/harvester_api.py

@@ -72,7 +72,7 @@ class PartialProofsData(Streamable):
     partial_proofs: list[bytes]  # 16 * k bits blobs instead of 32-byte quality strings
     signage_point_index: uint8
     plot_size: uint8
-    difficulty: uint64
+    plot_strength: uint64
     pool_public_key: Optional[G1Element]
     pool_contract_puzzle_hash: Optional[bytes32]
     plot_public_key: G1Element