revert strength

Author: almogdepaz

chia/_tests/farmer_harvester/test_farmer_harvester.py

@@ -341,7 +341,6 @@ 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),
         pool_public_key=None,
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -371,7 +370,6 @@ 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),
         pool_public_key=None,
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -414,7 +412,6 @@ 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),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -448,7 +445,6 @@ 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),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -525,7 +521,6 @@ 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),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -587,7 +582,6 @@ 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),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),

chia/_tests/solver/test_solver_service.py

@@ -11,7 +11,6 @@
 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
 
 
 @pytest.mark.anyio
@@ -28,28 +27,3 @@ async def test_solver_api_methods(blockchain_constants: ConsensusConstants, tmp_
                 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_error_handling(
-    blockchain_constants: ConsensusConstants, self_hostname: str, tmp_path: Path
-) -> None:
-    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(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)
-                assert result is None  # api returns None on error

chia/_tests/util/network_protocol_data.py

@@ -158,7 +158,6 @@
     [b"partial-proof1", b"partial-proof2"],
     uint8(4),
     uint8(32),
-    uint64(100000),
     G1Element.from_bytes(
         bytes.fromhex(
             "a04c6b5ac7dfb935f6feecfdd72348ccf1d4be4fe7e26acf271ea3b7d308da61e0a308f7a62495328a81f5147b66634c"

chia/_tests/util/protocol_messages_bytes-v1.0

@@ -72,7 +72,6 @@
     "partial_proofs": ["0x7061727469616c2d70726f6f6631", "0x7061727469616c2d70726f6f6632"],
     "signage_point_index": 4,
     "plot_size": 32,
-    "difficulty": 100000,
     "pool_public_key": "0xa04c6b5ac7dfb935f6feecfdd72348ccf1d4be4fe7e26acf271ea3b7d308da61e0a308f7a62495328a81f5147b66634c",
     "pool_contract_puzzle_hash": "0x91240fbacdf93b44c0571caa74fd99f163d4c5d7deaedac87125528721493f7a",
     "plot_public_key": "0xa04c6b5ac7dfb935f6feecfdd72348ccf1d4be4fe7e26acf271ea3b7d308da61e0a308f7a62495328a81f5147b66634c",

chia/_tests/util/protocol_messages_json.py

@@ -31,32 +31,3 @@ def get_state_cmd(
     from chia.cmds.solver_funcs import get_state
 
     asyncio.run(get_state(ChiaCliContext.set_default(ctx), solver_rpc_port))
-
-
-@solver_cmd.command("solve", help="Solve a partial proof of space, turning it into a full proof")
-@click.option(
-    "-sp",
-    "--solver-rpc-port",
-    help="Set the port where the Solver is hosting the RPC interface. See the rpc_port under solver in config.yaml",
-    type=int,
-    default=None,
-    show_default=True,
-)
-@click.option(
-    "-p",
-    "--partial_proof",
-    help="partial proof string to solve (hex format)",
-    type=str,
-    required=True,
-)
-@click.pass_context
-def solve_cmd(
-    ctx: click.Context,
-    solver_rpc_port: Optional[int],
-    partial_proof: str,
-) -> 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))

chia/cmds/solver.py

@@ -19,17 +19,3 @@ async def get_state(
             print(json.dumps(response, indent=2))
     except Exception as e:
         print(f"Failed to get solver state: {e}")
-
-
-async def solve_partial_proof(
-    ctx: ChiaCliContext,
-    solver_rpc_port: Optional[int],
-    partial_proof: str,
-) -> 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)
-            print(json.dumps(response, indent=2))
-    except Exception as e:
-        print(f"Failed to solve partial proof: {e}")

chia/cmds/solver_funcs.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
@@ -139,37 +181,36 @@ def blocking_lookup_v2_partial_proofs(filename: Path, plot_info: PlotInfo) -> Op
                             break
 
                 # Filter qualities that pass the required_iters check (same as V1 flow)
-                good_qualities = []
+                good_partial_proofs = []
                 sp_interval_iters = calculate_sp_interval_iters(self.harvester.constants, sub_slot_iters)
 
                 for partial_proof in partial_proofs:
                     quality_str = quality_for_partial_proof(partial_proof, new_challenge.challenge_hash)
                     required_iters: uint64 = calculate_iterations_quality(
                         self.harvester.constants,
                         quality_str,
-                        plot_info.prover.get_size(),  # TODO: todo_v2_plots update for V2
+                        plot_info.prover.get_size(),
                         difficulty,
                         new_challenge.sp_hash,
                         sub_slot_iters,
                         new_challenge.last_tx_height,
                     )
 
                     if required_iters < sp_interval_iters:
-                        good_qualities.append(partial_proof)
+                        good_partial_proofs.append(partial_proof)
 
-                if len(good_qualities) == 0:
+                if len(good_partial_proofs) == 0:
                     return None
 
                 size = plot_info.prover.get_size().size_v2
                 assert size is not None
                 return PartialProofsData(
                     new_challenge.challenge_hash,
                     new_challenge.sp_hash,
-                    good_qualities[0].hex() + str(filename.resolve()),
-                    good_qualities,
+                    good_partial_proofs[0].hex() + str(filename.resolve()),
+                    good_partial_proofs,
                     new_challenge.signage_point_index,
                     size,
-                    difficulty,
                     plot_info.pool_public_key,
                     plot_info.pool_contract_puzzle_hash,
                     plot_info.plot_public_key,
@@ -354,30 +395,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,6 @@ 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
     pool_public_key: Optional[G1Element]
     pool_contract_puzzle_hash: Optional[bytes32]
     plot_public_key: G1Element

chia/protocols/harvester_protocol.py

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