update block tools to support v2 plots when generating chains, as well as using the solve_proof() stub in the solver

Author: arvidn

chia/simulator/block_tools.py

@@ -14,7 +14,7 @@
 from dataclasses import dataclass, replace
 from pathlib import Path
 from random import Random
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, Union
 
 import anyio
 from chia_puzzles_py.programs import CHIALISP_DESERIALISATION, ROM_BOOTSTRAP_GENERATOR
@@ -64,6 +64,7 @@
 from chia.full_node.bundle_tools import simple_solution_generator, simple_solution_generator_backrefs
 from chia.plotting.create_plots import PlotKeys, create_plots
 from chia.plotting.manager import PlotManager
+from chia.plotting.prover import PlotVersion
 from chia.plotting.util import (
     Params,
     PlotRefreshEvents,
@@ -91,10 +92,13 @@
 from chia.types.blockchain_format.proof_of_space import (
     calculate_pos_challenge,
     calculate_prefix_bits,
+    calculate_required_plot_strength,
     generate_plot_public_key,
     generate_taproot_sk,
     make_pos,
     passes_plot_filter,
+    quality_for_partial_proof,
+    solve_proof,
 )
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
@@ -1501,6 +1505,8 @@ def get_pospaces_for_challenge(
         rng = random.Random()
         rng.seed(seed)
 
+        required_plot_strength = calculate_required_plot_strength(constants, prev_transaction_b_height)
+
         for plot_info in self.plot_manager.plots.values():
             plot_id: bytes32 = plot_info.prover.get_id()
             if force_plot_id is not None and plot_id != force_plot_id:
@@ -1509,10 +1515,29 @@ def get_pospaces_for_challenge(
             if not passes_plot_filter(prefix_bits, plot_id, challenge_hash, signage_point):
                 continue
 
+            # v2 plots aren't valid until after the hard fork
+            if (
+                prev_transaction_b_height < constants.HARD_FORK2_HEIGHT
+                and plot_info.prover.get_version() == PlotVersion.V2
+            ):
+                continue
+
             new_challenge: bytes32 = calculate_pos_challenge(plot_id, challenge_hash, signage_point)
-            qualities = plot_info.prover.get_qualities_for_challenge(new_challenge)
 
-            for proof_index, quality_str in enumerate(qualities):
+            # these are either qualities (v1) or partial proofs (v2)
+            proofs: Sequence[Union[bytes32, bytes]]
+            v = plot_info.prover.get_version()
+            if v == PlotVersion.V1:
+                proofs = plot_info.prover.get_qualities_for_challenge(new_challenge)
+            else:
+                proofs = plot_info.prover.get_partial_proofs_for_challenge(new_challenge, required_plot_strength)
+
+            for proof_index, proof in enumerate(proofs):
+                if v == PlotVersion.V2:
+                    quality_str = quality_for_partial_proof(proof, new_challenge)
+                elif v == PlotVersion.V1:
+                    quality_str = bytes32(proof)
+
                 required_iters = calculate_iterations_quality(
                     constants,
                     quality_str,
@@ -1525,7 +1550,11 @@ def get_pospaces_for_challenge(
                 if required_iters >= calculate_sp_interval_iters(constants, sub_slot_iters):
                     continue
 
-                proof_xs: bytes = plot_info.prover.get_full_proof(new_challenge, proof_index)
+                proof_xs: bytes
+                if v == PlotVersion.V1:
+                    proof_xs = plot_info.prover.get_full_proof(new_challenge, proof_index)
+                else:
+                    proof_xs = solve_proof(proof)
 
                 # Look up local_sk from plot to save locked memory
                 (

chia/solver/solver.py

@@ -14,6 +14,7 @@
 from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
+from chia.types.blockchain_format.proof_of_space import solve_proof
 
 log = logging.getLogger(__name__)
 
@@ -67,7 +68,10 @@ async def manage(self) -> AsyncIterator[None]:
 
     def solve(self, partial_proof: bytes) -> Optional[bytes]:
         self.log.debug(f"Solve request: partial={partial_proof.hex()}")
-        # TODO todo_v2_plots implement actualy calling the solver
+        try:
+            return solve_proof(partial_proof)
+        except Exception:
+            self.log.exception("solve_proof()")
         return None
 
     def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]: