uint8 strength, remove solve cmd

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),
-        plot_strength=uint64(1000),
+        plot_strength=uint8(10),
         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),
-        plot_strength=uint64(1000),
+        plot_strength=uint8(10),
         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),
-        plot_strength=uint64(1000),
+        plot_strength=uint8(10),
         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),
-        plot_strength=uint64(1000),
+        plot_strength=uint8(10),
         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),
-        plot_strength=uint64(1000),
+        plot_strength=uint8(10),
         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),
-        plot_strength=uint64(1000),
+        plot_strength=uint8(10),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),

chia/_tests/solver/test_solver_service.py

@@ -5,14 +5,13 @@
 
 import pytest
 from chia_rs import ConsensusConstants
-from chia_rs.sized_ints import uint64
+from chia_rs.sized_ints import uint8
 
 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
 
 
 @pytest.mark.anyio
@@ -23,34 +22,9 @@ 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", plot_strength=uint64(1500))
+            test_info = SolverInfo(partial_proof=b"test_partial_proof_42", plot_strength=uint8(10))
             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_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", 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", 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)
-                assert result is None  # api returns None on error

chia/_tests/util/network_protocol_data.py

@@ -158,7 +158,7 @@
     [b"partial-proof1", b"partial-proof2"],
     uint8(4),
     uint8(32),
-    uint64(100000),
+    uint8(8),
     G1Element.from_bytes(
         bytes.fromhex(
             "a04c6b5ac7dfb935f6feecfdd72348ccf1d4be4fe7e26acf271ea3b7d308da61e0a308f7a62495328a81f5147b66634c"
@@ -1106,6 +1106,6 @@
 )
 
 # SOLVER PROTOCOL
-solver_info = solver_protocol.SolverInfo(partial_proof=b"partial-proof", plot_strength=uint64(2))
+solver_info = solver_protocol.SolverInfo(partial_proof=b"partial-proof", plot_strength=uint8(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,
-    "plot_strength": 100000,
+    "plot_strength": 8,
     "pool_public_key": "0xa04c6b5ac7dfb935f6feecfdd72348ccf1d4be4fe7e26acf271ea3b7d308da61e0a308f7a62495328a81f5147b66634c",
     "pool_contract_puzzle_hash": "0x91240fbacdf93b44c0571caa74fd99f163d4c5d7deaedac87125528721493f7a",
     "plot_public_key": "0xa04c6b5ac7dfb935f6feecfdd72348ccf1d4be4fe7e26acf271ea3b7d308da61e0a308f7a62495328a81f5147b66634c",

chia/_tests/util/protocol_messages_json.py

@@ -31,41 +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.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, plot_strength))

chia/cmds/solver.py

@@ -3,8 +3,6 @@
 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
@@ -21,18 +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,
-    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, 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

@@ -9,7 +9,7 @@
 
 from chia_rs import AugSchemeMPL, G1Element, G2Element, ProofOfSpace
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint32, uint64
+from chia_rs.sized_ints import uint8, uint32, uint64
 
 from chia.consensus.pos_quality import quality_for_partial_proof
 from chia.consensus.pot_iterations import (
@@ -181,37 +181,37 @@ 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,
+                    uint8(0),  # TODO todo_v2_plots Plot strength currently stubbed to 0
                     plot_info.pool_public_key,
                     plot_info.pool_contract_puzzle_hash,
                     plot_info.plot_public_key,

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
-    plot_strength: uint64
+    plot_strength: uint8
     pool_public_key: Optional[G1Element]
     pool_contract_puzzle_hash: Optional[bytes32]
     plot_public_key: G1Element

chia/protocols/harvester_protocol.py

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