prover protocol and v2Prover

Author: almogdepaz

chia/_tests/plot_sync/test_plot_sync.py

@@ -65,7 +65,7 @@ class ExpectedResult:
     def add_valid(self, list_plots: list[MockPlotInfo]) -> None:
         def create_mock_plot(info: MockPlotInfo) -> Plot:
             return Plot(
-                info.prover.get_filename(),
+                str(info.prover.get_filename()),
                 uint8(0),
                 bytes32.zeros,
                 None,
@@ -77,7 +77,7 @@ def create_mock_plot(info: MockPlotInfo) -> Plot:
             )
 
         self.valid_count += len(list_plots)
-        self.valid_delta.additions.update({x.prover.get_filename(): create_mock_plot(x) for x in list_plots})
+        self.valid_delta.additions.update({str(x.prover.get_filename()): create_mock_plot(x) for x in list_plots})
 
     def remove_valid(self, list_paths: list[Path]) -> None:
         self.valid_count -= len(list_paths)
@@ -193,7 +193,7 @@ async def plot_sync_callback(self, peer_id: bytes32, delta: Optional[Delta]) ->
             assert path in delta.valid.additions
             plot = harvester.plot_manager.plots.get(Path(path), None)
             assert plot is not None
-            assert plot.prover.get_filename() == delta.valid.additions[path].filename
+            assert plot.prover.get_filename_str() == delta.valid.additions[path].filename
             assert plot.prover.get_size() == delta.valid.additions[path].size
             assert plot.prover.get_id() == delta.valid.additions[path].plot_id
             assert plot.prover.get_compression_level() == delta.valid.additions[path].compression_level
@@ -254,7 +254,7 @@ async def run_sync_test(self) -> None:
             assert expected.duplicates_delta.empty()
             for path, plot_info in plot_manager.plots.items():
                 assert str(path) in receiver.plots()
-                assert plot_info.prover.get_filename() == receiver.plots()[str(path)].filename
+                assert plot_info.prover.get_filename_str() == receiver.plots()[str(path)].filename
                 assert plot_info.prover.get_size() == receiver.plots()[str(path)].size
                 assert plot_info.prover.get_id() == receiver.plots()[str(path)].plot_id
                 assert plot_info.prover.get_compression_level() == receiver.plots()[str(path)].compression_level

chia/_tests/plot_sync/test_sync_simulated.py

@@ -25,6 +25,7 @@
 from chia.plot_sync.sender import Sender
 from chia.plot_sync.util import Constants
 from chia.plotting.manager import PlotManager
+from chia.plotting.prover import V1Prover
 from chia.plotting.util import PlotInfo
 from chia.protocols.harvester_protocol import PlotSyncError, PlotSyncResponse
 from chia.protocols.outbound_message import make_msg
@@ -79,7 +80,7 @@ async def run(
         removed_paths: list[Path] = [p.prover.get_filename() for p in removed] if removed is not None else []
         invalid_dict: dict[Path, int] = {p.prover.get_filename(): 0 for p in self.invalid}
         keys_missing_set: set[Path] = {p.prover.get_filename() for p in self.keys_missing}
-        duplicates_set: set[str] = {p.prover.get_filename() for p in self.duplicates}
+        duplicates_set: set[str] = {p.prover.get_filename_str() for p in self.duplicates}
 
         # Inject invalid plots into `PlotManager` of the harvester so that the callback calls below can use them
         # to sync them to the farmer.
@@ -131,30 +132,30 @@ def validate_plot_sync(self) -> None:
         assert len(self.invalid) == len(self.plot_sync_receiver.invalid())
         assert len(self.keys_missing) == len(self.plot_sync_receiver.keys_missing())
         for _, plot_info in self.plots.items():
-            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.invalid()
-            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.keys_missing()
-            assert plot_info.prover.get_filename() in self.plot_sync_receiver.plots()
-            synced_plot = self.plot_sync_receiver.plots()[plot_info.prover.get_filename()]
-            assert plot_info.prover.get_filename() == synced_plot.filename
+            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.invalid()
+            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.keys_missing()
+            assert plot_info.prover.get_filename_str() in self.plot_sync_receiver.plots()
+            synced_plot = self.plot_sync_receiver.plots()[plot_info.prover.get_filename_str()]
+            assert plot_info.prover.get_filename_str() == synced_plot.filename
             assert plot_info.pool_public_key == synced_plot.pool_public_key
             assert plot_info.pool_contract_puzzle_hash == synced_plot.pool_contract_puzzle_hash
             assert plot_info.plot_public_key == synced_plot.plot_public_key
             assert plot_info.file_size == synced_plot.file_size
             assert uint64(int(plot_info.time_modified)) == synced_plot.time_modified
         for plot_info in self.invalid:
-            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.plots()
-            assert plot_info.prover.get_filename() in self.plot_sync_receiver.invalid()
-            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.keys_missing()
-            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.duplicates()
+            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.plots()
+            assert plot_info.prover.get_filename_str() in self.plot_sync_receiver.invalid()
+            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.keys_missing()
+            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.duplicates()
         for plot_info in self.keys_missing:
-            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.plots()
-            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.invalid()
-            assert plot_info.prover.get_filename() in self.plot_sync_receiver.keys_missing()
-            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.duplicates()
+            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.plots()
+            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.invalid()
+            assert plot_info.prover.get_filename_str() in self.plot_sync_receiver.keys_missing()
+            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.duplicates()
         for plot_info in self.duplicates:
-            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.invalid()
-            assert plot_info.prover.get_filename() not in self.plot_sync_receiver.keys_missing()
-            assert plot_info.prover.get_filename() in self.plot_sync_receiver.duplicates()
+            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.invalid()
+            assert plot_info.prover.get_filename_str() not in self.plot_sync_receiver.keys_missing()
+            assert plot_info.prover.get_filename_str() in self.plot_sync_receiver.duplicates()
 
 
 @dataclass
@@ -284,7 +285,7 @@ def get_compression_level(self) -> uint8:
 
     return [
         PlotInfo(
-            prover=DiskProver(f"{x}", bytes32.random(seeded_random), 25 + x % 26),
+            prover=V1Prover(DiskProver(f"{x}", bytes32.random(seeded_random), 25 + x % 26)),
             pool_public_key=None,
             pool_contract_puzzle_hash=None,
             plot_public_key=G1Element(),

chia/_tests/plotting/test_plot_manager.py

@@ -42,8 +42,8 @@
 class MockDiskProver:
     filename: str
 
-    def get_filename(self) -> str:
-        return self.filename
+    def get_filename(self) -> Path:
+        return Path(self.filename)
 
 
 @dataclass
@@ -614,7 +614,7 @@ def assert_cache(expected: list[MockPlotInfo]) -> None:
     # Write the modified cache entries to the file
     cache_path.write_bytes(bytes(VersionedBlob(uint16(CURRENT_VERSION), bytes(cache_data))))
     # And now test that plots in invalid_entries are not longer loaded
-    assert_cache([plot_info for plot_info in plot_infos if plot_info.prover.get_filename() not in invalid_entries])
+    assert_cache([plot_info for plot_info in plot_infos if str(plot_info.prover.get_filename()) not in invalid_entries])
 
 
 @pytest.mark.anyio

chia/plot_sync/sender.py

@@ -39,7 +39,7 @@ def _convert_plot_info_list(plot_infos: list[PlotInfo]) -> list[Plot]:
     for plot_info in plot_infos:
         converted.append(
             Plot(
-                filename=plot_info.prover.get_filename(),
+                filename=plot_info.prover.get_filename_str(),
                 size=plot_info.prover.get_size(),
                 plot_id=plot_info.prover.get_id(),
                 pool_public_key=plot_info.pool_public_key,

chia/plotting/cache.py

@@ -7,13 +7,16 @@
 from dataclasses import dataclass, field
 from math import ceil
 from pathlib import Path
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from chia.plotting.prover import ProverProtocol
 
 from chia_rs import G1Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint64
-from chiapos import DiskProver
 
+from chia.plotting.prover import get_prover_from_bytes
 from chia.plotting.util import parse_plot_info
 from chia.types.blockchain_format.proof_of_space import generate_plot_public_key
 from chia.util.streamable import Streamable, VersionedBlob, streamable
@@ -43,15 +46,16 @@ class CacheDataV1(Streamable):
 
 @dataclass
 class CacheEntry:
-    prover: DiskProver
+    prover: ProverProtocol
     farmer_public_key: G1Element
     pool_public_key: Optional[G1Element]
     pool_contract_puzzle_hash: Optional[bytes32]
     plot_public_key: G1Element
     last_use: float
 
     @classmethod
-    def from_disk_prover(cls, prover: DiskProver) -> CacheEntry:
+    def from_prover(cls, prover: ProverProtocol) -> CacheEntry:
+        """Create CacheEntry from any prover implementation"""
         (
             pool_public_key_or_puzzle_hash,
             farmer_public_key,
@@ -149,8 +153,9 @@ def load(self) -> None:
                     39: 44367,
                 }
                 for path, cache_entry in cache_data.entries:
+                    prover: ProverProtocol = get_prover_from_bytes(path, cache_entry.prover_data)
                     new_entry = CacheEntry(
-                        DiskProver.from_bytes(cache_entry.prover_data),
+                        prover,
                         cache_entry.farmer_public_key,
                         cache_entry.pool_public_key,
                         cache_entry.pool_contract_puzzle_hash,

chia/plotting/check_plots.py

@@ -9,7 +9,7 @@
 from typing import Optional
 
 from chia_rs import G1Element
-from chia_rs.sized_ints import uint32
+from chia_rs.sized_ints import uint8, uint32
 from chiapos import Verifier
 
 from chia.plotting.manager import PlotManager
@@ -133,7 +133,7 @@ def check_plots(
         log.info("")
         log.info("")
         log.info(f"Starting to test each plot with {num} challenges each\n")
-    total_good_plots: Counter[str] = Counter()
+    total_good_plots: Counter[uint8] = Counter()
     total_size = 0
     bad_plots_list: list[Path] = []
 

chia/plotting/manager.py

@@ -9,10 +9,11 @@
 from typing import Any, Callable, Optional
 
 from chia_rs import G1Element
-from chiapos import DiskProver, decompressor_context_queue
+from chiapos import decompressor_context_queue
 
 from chia.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR, _expected_plot_size
 from chia.plotting.cache import Cache, CacheEntry
+from chia.plotting.prover import get_prover_from_file
 from chia.plotting.util import (
     HarvestingMode,
     PlotInfo,
@@ -323,7 +324,7 @@ def process_file(file_path: Path) -> Optional[PlotInfo]:
                 cache_entry = self.cache.get(file_path)
                 cache_hit = cache_entry is not None
                 if not cache_hit:
-                    prover = DiskProver(str(file_path))
+                    prover = get_prover_from_file(str(file_path))
 
                     log.debug(f"process_file {file_path!s}")
 
@@ -343,7 +344,7 @@ def process_file(file_path: Path) -> Optional[PlotInfo]:
                             )
                             return None
 
-                    cache_entry = CacheEntry.from_disk_prover(prover)
+                    cache_entry = CacheEntry.from_prover(prover)
                     self.cache.update(file_path, cache_entry)
 
                 assert cache_entry is not None