chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.5.8rc1__py3-none-any.whl

chia/plotters/bladebit.py

@@ -7,7 +7,7 @@ import os
 import sys
 import traceback
 from pathlib import Path
-from typing import Any, Literal, Optional, Union
+from typing import Any, Literal
 
 from chia.plotters.plotters_util import get_venv_bin, reset_loop_policy_for_windows, run_command, run_plotter
 from chia.plotting.create_plots import resolve_plot_keys
@@ -23,9 +23,9 @@ def is_bladebit_supported() -> bool:
     return sys.platform.startswith("linux") or sys.platform in {"win32", "cygwin", "darwin"}
 
 
-def meets_memory_requirement(plotters_root_path: Path) -> tuple[bool, Optional[str]]:
+def meets_memory_requirement(plotters_root_path: Path) -> tuple[bool, str | None]:
     have_enough_memory: bool = False
-    warning_string: Optional[str] = None
+    warning_string: str | None = None
 
     bladebit_executable_path = get_bladebit_executable_path(plotters_root_path)
     if bladebit_executable_path.exists():
@@ -87,7 +87,7 @@ def get_bladebit_exec_path(with_cuda: bool = False) -> str:
     return "bladebit.exe" if sys.platform in {"win32", "cygwin"} else "bladebit"
 
 
-def get_bladebit_exec_venv_path(with_cuda: bool = False) -> Optional[Path]:
+def get_bladebit_exec_venv_path(with_cuda: bool = False) -> Path | None:
     venv_bin_path = get_venv_bin()
     if not venv_bin_path:
         return None
@@ -131,7 +131,7 @@ def get_bladebit_executable_path(plotters_root_path: Path) -> Path:
 
 def get_bladebit_version(
     plotters_root_path: Path,
-) -> Union[tuple[Literal[False], str], tuple[None, str], tuple[Literal[True], list[str]]]:
+) -> tuple[Literal[False], str] | tuple[None, str] | tuple[Literal[True], list[str]]:
     bladebit_executable_path = get_bladebit_executable_path(plotters_root_path)
     if not bladebit_executable_path.exists():
         # (found=False, "")
@@ -157,7 +157,7 @@ def get_bladebit_version(
         return None, str(e)
 
 
-def get_bladebit_install_info(plotters_root_path: Path) -> Optional[dict[str, Any]]:
+def get_bladebit_install_info(plotters_root_path: Path) -> dict[str, Any] | None:
     info: dict[str, Any] = {"display_name": "BladeBit Plotter"}
     installed: bool = False
     supported: bool = is_bladebit_supported()
@@ -165,7 +165,7 @@ def get_bladebit_install_info(plotters_root_path: Path) -> Optional[dict[str, An
 
     bladebit_executable_path = get_bladebit_executable_path(plotters_root_path)
     if bladebit_executable_path.exists():
-        version: Optional[str] = None
+        version: str | None = None
         found, response = get_bladebit_version(plotters_root_path)
         if found:
             version = ".".join(response)

chia/plotters/chiapos.py

@@ -10,7 +10,7 @@ import importlib.metadata
 import logging
 from argparse import Namespace
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from chia.plotting.create_plots import create_plots, resolve_plot_keys
 from chia.plotting.util import Params, add_plot_directory, validate_plot_size
@@ -18,7 +18,7 @@ from chia.plotting.util import Params, add_plot_directory, validate_plot_size
 log = logging.getLogger(__name__)
 
 
-def get_chiapos_install_info() -> Optional[dict[str, Any]]:
+def get_chiapos_install_info() -> dict[str, Any] | None:
     chiapos_version = importlib.metadata.version("chiapos")
     return {"display_name": "Chia Proof of Space", "version": chiapos_version, "installed": True}
 

chia/plotters/madmax.py

@@ -6,7 +6,7 @@ import os
 import sys
 import traceback
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from chia.plotters.plotters_util import get_venv_bin, reset_loop_policy_for_windows, run_command, run_plotter
 from chia.plotting.create_plots import resolve_plot_keys
@@ -32,7 +32,7 @@ def get_madmax_package_path() -> Path:
     return Path(os.path.dirname(sys.executable)).joinpath("madmax")
 
 
-def get_madmax_exec_venv_path(ksize: int = 32) -> Optional[Path]:
+def get_madmax_exec_venv_path(ksize: int = 32) -> Path | None:
     venv_bin_path = get_venv_bin()
     if not venv_bin_path:
         return None
@@ -100,14 +100,14 @@ def get_madmax_version(plotters_root_path: Path):
         return None, f"Failed to determine madmax version: {e} {tb}"
 
 
-def get_madmax_install_info(plotters_root_path: Path) -> Optional[dict[str, Any]]:
+def get_madmax_install_info(plotters_root_path: Path) -> dict[str, Any] | None:
     info: dict[str, Any] = {"display_name": "madMAx Plotter"}
     installed: bool = False
     supported: bool = is_madmax_supported()
 
     madmax_executable_path = get_madmax_executable_path_for_ksize(plotters_root_path)
     if madmax_executable_path.exists():
-        version: Optional[str] = None
+        version: str | None = None
         found, result_msg = get_madmax_version(plotters_root_path)
         if found:
             version = ".".join(result_msg)

chia/plotters/plotters.py

@@ -5,7 +5,7 @@ import binascii
 import os
 from enum import Enum
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from chia.plotters.bladebit import get_bladebit_install_info, plot_bladebit
 from chia.plotters.chiapos import get_chiapos_install_info, plot_chia
@@ -550,9 +550,9 @@ def call_plotters(root_path: Path, args):
 def get_available_plotters(root_path) -> dict[str, Any]:
     plotters_root_path: Path = get_plotters_root_path(root_path)
     plotters: dict[str, Any] = {}
-    chiapos: Optional[dict[str, Any]] = get_chiapos_install_info()
-    bladebit: Optional[dict[str, Any]] = get_bladebit_install_info(plotters_root_path)
-    madmax: Optional[dict[str, Any]] = get_madmax_install_info(plotters_root_path)
+    chiapos: dict[str, Any] | None = get_chiapos_install_info()
+    bladebit: dict[str, Any] | None = get_bladebit_install_info(plotters_root_path)
+    madmax: dict[str, Any] | None = get_madmax_install_info(plotters_root_path)
 
     if chiapos is not None:
         plotters["chiapos"] = chiapos

chia/plotters/plotters_util.py

@@ -10,7 +10,7 @@ import sys
 from collections.abc import Iterator
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, TextIO
+from typing import TextIO
 
 from chia.util.chia_version import chia_short_version
 from chia.util.config import lock_and_load_config
@@ -18,8 +18,8 @@ from chia.util.task_referencer import create_referenced_task
 
 
 @contextlib.contextmanager
-def get_optional_beta_plot_log_file(root_path: Path, plotter: str) -> Iterator[Optional[TextIO]]:
-    beta_log_path: Optional[Path] = None
+def get_optional_beta_plot_log_file(root_path: Path, plotter: str) -> Iterator[TextIO | None]:
+    beta_log_path: Path | None = None
     with lock_and_load_config(root_path, "config.yaml") as config:
         if config.get("beta", {}).get("enabled", False):
             file_name = f"{plotter}_{datetime.now().strftime('%m_%d_%Y__%H_%M_%S')}.log"

chia/plotting/cache.py

@@ -5,14 +5,15 @@ import time
 import traceback
 from collections.abc import ItemsView, KeysView, ValuesView
 from dataclasses import dataclass, field
+from functools import lru_cache
 from math import ceil
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from chia.plotting.prover import ProverProtocol
 
-from chia_rs import G1Element
+from chia_rs import G1Element, PrivateKey
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint64
 
@@ -27,13 +28,18 @@ log = logging.getLogger(__name__)
 CURRENT_VERSION: int = 2
 
 
+@lru_cache
+def cached_master_sk_to_local_sk(master: PrivateKey) -> PrivateKey:
+    return master_sk_to_local_sk(master)
+
+
 @streamable
 @dataclass(frozen=True)
 class DiskCacheEntry(Streamable):
     prover_data: bytes
     farmer_public_key: G1Element
-    pool_public_key: Optional[G1Element]
-    pool_contract_puzzle_hash: Optional[bytes32]
+    pool_public_key: G1Element | None
+    pool_contract_puzzle_hash: bytes32 | None
     plot_public_key: G1Element
     last_use: uint64
 
@@ -48,8 +54,8 @@ class CacheDataV1(Streamable):
 class CacheEntry:
     prover: ProverProtocol
     farmer_public_key: G1Element
-    pool_public_key: Optional[G1Element]
-    pool_contract_puzzle_hash: Optional[bytes32]
+    pool_public_key: G1Element | None
+    pool_contract_puzzle_hash: bytes32 | None
     plot_public_key: G1Element
     last_use: float
 
@@ -61,15 +67,15 @@ class CacheEntry:
             local_master_sk,
         ) = parse_plot_info(prover.get_memo())
 
-        pool_public_key: Optional[G1Element] = None
-        pool_contract_puzzle_hash: Optional[bytes32] = None
+        pool_public_key: G1Element | None = None
+        pool_contract_puzzle_hash: bytes32 | None = None
         if isinstance(pool_public_key_or_puzzle_hash, G1Element):
             pool_public_key = pool_public_key_or_puzzle_hash
         else:
             assert isinstance(pool_public_key_or_puzzle_hash, bytes32)
             pool_contract_puzzle_hash = pool_public_key_or_puzzle_hash
 
-        local_sk = master_sk_to_local_sk(local_master_sk)
+        local_sk = cached_master_sk_to_local_sk(local_master_sk)
 
         plot_public_key: G1Element = generate_plot_public_key(
             local_sk.get_g1(), farmer_public_key, pool_contract_puzzle_hash is not None
@@ -165,9 +171,9 @@ class Cache:
                     #       it's here to filter invalid cache entries coming from bladebit RAM plotting.
                     #       Related: - https://github.com/Chia-Network/chia-blockchain/issues/13084
                     #                - https://github.com/Chia-Network/chiapos/pull/337
-                    ps = new_entry.prover.get_size()
-                    if ps.size_v1 is not None:
-                        k = ps.size_v1
+                    param = new_entry.prover.get_param()
+                    if param.size_v1 is not None:
+                        k = param.size_v1
                         if k not in estimated_c2_sizes:
                             estimated_c2_sizes[k] = ceil(2**k / 100_000_000) * ceil(k / 8)
                         memo_size = len(new_entry.prover.get_memo())
@@ -190,7 +196,7 @@ class Cache:
                             )
                         else:
                             self._data[Path(path)] = new_entry
-                    elif ps.size_v2 is not None:
+                    elif param.strength_v2 is not None:
                         # TODO: todo_v2_plots validate prover size
                         self._data[Path(path)] = new_entry
 
@@ -212,7 +218,7 @@ class Cache:
     def items(self) -> ItemsView[Path, CacheEntry]:
         return self._data.items()
 
-    def get(self, path: Path) -> Optional[CacheEntry]:
+    def get(self, path: Path) -> CacheEntry | None:
         return self._data.get(path)
 
     def changed(self) -> bool:

chia/plotting/check_plots.py

@@ -7,16 +7,14 @@ from collections.abc import Sequence
 from pathlib import Path
 from threading import Lock
 from time import monotonic, sleep
-from typing import Optional, Union
 
-from chia_rs import G1Element
-from chia_rs.sized_bytes import bytes32
+from chia_rs import G1Element, solve_proof
 from chia_rs.sized_ints import uint8, uint32
 from chiapos import Verifier
 
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.plotting.manager import PlotManager
-from chia.plotting.prover import PlotVersion
+from chia.plotting.prover import QualityProtocol, V1Prover, V2Prover, V2Quality
 from chia.plotting.util import (
     PlotInfo,
     PlotRefreshEvents,
@@ -26,10 +24,6 @@ from chia.plotting.util import (
     get_plot_filenames,
     parse_plot_info,
 )
-from chia.types.blockchain_format.proof_of_space import (
-    quality_for_partial_proof,
-    solve_proof,
-)
 from chia.util.bech32m import encode_puzzle_hash
 from chia.util.config import load_config
 from chia.util.cpu import available_logical_cores
@@ -46,8 +40,8 @@ def plot_refresh_callback(event: PlotRefreshEvents, refresh_result: PlotRefreshR
 
 def check_plots(
     root_path: Path,
-    num: Optional[int],
-    challenge_start: Optional[int],
+    num: int | None,
+    challenge_start: int | None,
     grep_string: str,
     list_duplicates: bool,
     debug_show_memo: bool,
@@ -61,6 +55,7 @@ def check_plots(
         open_no_key_filenames=True,
         refresh_parameter=plot_refresh_parameter,
         refresh_callback=plot_refresh_callback,
+        constants=DEFAULT_CONSTANTS,
     )
 
     context_count = config["harvester"].get("parallel_decompressor_count", 5)
@@ -142,7 +137,7 @@ def check_plots(
         log.info("")
         log.info(f"Starting to test each plot with {num} challenges each\n")
     total_good_plots_v1: Counter[uint8] = Counter()
-    total_good_plots_v2: Counter[uint8] = Counter()
+    total_good_plots_v2: int = 0
     total_size = 0
     bad_plots_list: list[Path] = []
 
@@ -165,7 +160,7 @@ def check_plots(
             local_sk = master_sk_to_local_sk(local_master_sk)
 
             with lock:
-                log.info(f"Testing plot {plot_path} k={pr.get_size()}")
+                log.info(f"Testing plot {plot_path} k={pr.get_param()}")
                 if plot_info.pool_public_key is not None:
                     log.info(f"\t{'Pool public key:':<23} {plot_info.pool_public_key}")
                 if plot_info.pool_contract_puzzle_hash is not None:
@@ -176,18 +171,13 @@ def check_plots(
 
             total_proofs = 0
             caught_exception: bool = False
-            version = pr.get_version()
             for i in range(num_start, num_end):
                 challenge = std_hash(i.to_bytes(32, "big"))
-                # these are either qualities (v1) or partial proofs (v2)
-                proofs: Sequence[Union[bytes32, bytes]]
+                qualities: Sequence[QualityProtocol]
                 # Some plot errors cause get_qualities_for_challenge to throw a RuntimeError
                 try:
                     quality_start_time = round(monotonic() * 1000)
-                    if version == PlotVersion.V1:
-                        proofs = pr.get_qualities_for_challenge(challenge)
-                    else:
-                        proofs = pr.get_partial_proofs_for_challenge(challenge, DEFAULT_CONSTANTS.PLOT_STRENGTH_INITIAL)
+                    qualities = pr.get_qualities_for_challenge(challenge, DEFAULT_CONSTANTS.QUALITY_PROOF_SCAN_FILTER)
                     quality_spent_time = round(monotonic() * 1000) - quality_start_time
                     if quality_spent_time > 8000:
                         log.warning(
@@ -215,18 +205,22 @@ def check_plots(
                     caught_exception = True
                     break
 
-                for index, proof in enumerate(proofs):
+                for index, quality in enumerate(qualities):
                     # Other plot errors cause get_full_proof or validate_proof to throw an AssertionError
                     try:
                         proof_start_time = round(monotonic() * 1000)
-                        if version == PlotVersion.V1:
-                            quality_str = bytes32(proof)
+                        quality_str = quality.get_string()
+
+                        if isinstance(pr, V1Prover):
                             full_proof = pr.get_full_proof(challenge, index, parallel_read)
                             proof_spent_time = round(monotonic() * 1000) - proof_start_time
-                        else:
-                            quality_str = quality_for_partial_proof(proof, challenge)
+                        elif isinstance(pr, V2Prover):
+                            assert isinstance(quality, V2Quality)
+                            partial_proof = pr.get_partial_proof(quality)
                             proof_spent_time = round(monotonic() * 1000) - proof_start_time
-                            full_proof = solve_proof(proof)
+                            full_proof = solve_proof(
+                                partial_proof, pr.get_id(), pr.get_strength(), DEFAULT_CONSTANTS.PLOT_SIZE_V2
+                            )
 
                         if proof_spent_time > 15000:
                             log.warning(
@@ -236,7 +230,7 @@ def check_plots(
                         else:
                             log.info(f"\tFinding proof took: {proof_spent_time} ms. Filepath: {plot_path}")
 
-                        ver_quality_str = v.validate_proof(pr.get_id(), pr.get_size().size_v1, challenge, full_proof)
+                        ver_quality_str = v.validate_proof(pr.get_id(), pr.get_param().size_v1, challenge, full_proof)
                         if quality_str == ver_quality_str:
                             total_proofs += 1
                         else:
@@ -257,15 +251,13 @@ def check_plots(
                     f"\tProofs {total_proofs} / {challenges}, {round(total_proofs / float(challenges), 4)}. "
                     f"Filepath: {plot_path}"
                 )
-                version_and_size = pr.get_size()
-                if version_and_size.size_v1 is not None:
-                    k = version_and_size.size_v1
+                param = pr.get_param()
+                if param.size_v1 is not None:
+                    k = param.size_v1
                     total_good_plots_v1[k] += 1
                     total_size += plot_path.stat().st_size
                 else:
-                    assert version_and_size.size_v2 is not None
-                    k = version_and_size.size_v2
-                    total_good_plots_v2[k] += 1
+                    total_good_plots_v2 += 1
                     total_size += plot_path.stat().st_size
             else:
                 log.error(
@@ -288,12 +280,11 @@ def check_plots(
     log.info("")
     log.info("")
     log.info("Summary")
-    total_plots: int = sum(list(total_good_plots_v1.values()) + list(total_good_plots_v2.values()))
+    total_plots: int = sum(list(total_good_plots_v1.values())) + total_good_plots_v2
     log.info(f"Found {total_plots} valid plots, total size {total_size / (1024 * 1024 * 1024 * 1024):.5f} TiB")
     for k, count in sorted(dict(total_good_plots_v1).items()):
         log.info(f"{count} v1 plots of size {k}")
-    for k, count in sorted(dict(total_good_plots_v2).items()):
-        log.info(f"{count} v2 plots of size {k}")
+    log.info(f"{total_good_plots_v2} v2 plots")
     grand_total_bad = len(bad_plots_list) + len(plot_manager.failed_to_open_filenames)
     if grand_total_bad > 0:
         log.warning(f"{grand_total_bad} invalid plots found:")

chia/plotting/create_plots.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import logging
 from datetime import datetime
 from pathlib import Path
-from typing import Optional
 
 from chia_rs import AugSchemeMPL, G1Element, PrivateKey
 from chia_rs.sized_bytes import bytes32
@@ -27,15 +26,15 @@ class PlotKeys:
     def __init__(
         self,
         farmer_public_key: G1Element,
-        pool_public_key: Optional[G1Element],
-        pool_contract_address: Optional[str],
+        pool_public_key: G1Element | None,
+        pool_contract_address: str | None,
     ):
         self.farmer_public_key = farmer_public_key
         self.pool_public_key = pool_public_key
         self.pool_contract_address = pool_contract_address
 
     @property
-    def pool_contract_puzzle_hash(self) -> Optional[bytes32]:
+    def pool_contract_puzzle_hash(self) -> bytes32 | None:
         if self.pool_contract_address is not None:
             return decode_puzzle_hash(self.pool_contract_address)
         return None
@@ -44,10 +43,10 @@ class PlotKeys:
 class PlotKeysResolver:
     def __init__(
         self,
-        farmer_public_key: Optional[str],
-        alt_fingerprint: Optional[int],
-        pool_public_key: Optional[str],
-        pool_contract_address: Optional[str],
+        farmer_public_key: str | None,
+        alt_fingerprint: int | None,
+        pool_public_key: str | None,
+        pool_contract_address: str | None,
         root_path: Path,
         log: logging.Logger,
         connect_to_daemon: bool = False,
@@ -59,13 +58,13 @@ class PlotKeysResolver:
         self.root_path = root_path
         self.log = log
         self.connect_to_daemon = connect_to_daemon
-        self.resolved_keys: Optional[PlotKeys] = None
+        self.resolved_keys: PlotKeys | None = None
 
     async def resolve(self) -> PlotKeys:
         if self.resolved_keys is not None:
             return self.resolved_keys
 
-        keychain_proxy: Optional[KeychainProxy] = None
+        keychain_proxy: KeychainProxy | None = None
         try:
             if self.connect_to_daemon:
                 keychain_proxy = await connect_to_keychain_and_validate(self.root_path, self.log)
@@ -78,7 +77,7 @@ class PlotKeysResolver:
             else:
                 farmer_public_key = await self.get_farmer_public_key(keychain_proxy)
 
-            pool_public_key: Optional[G1Element] = None
+            pool_public_key: G1Element | None = None
             if self.pool_public_key is not None:
                 if self.pool_contract_address is not None:
                     raise RuntimeError("Choose one of pool_contract_address and pool_public_key")
@@ -93,8 +92,8 @@ class PlotKeysResolver:
                 await keychain_proxy.close()
         return self.resolved_keys
 
-    async def get_sk(self, keychain_proxy: Optional[KeychainProxy] = None) -> Optional[PrivateKey]:
-        sk: Optional[PrivateKey] = None
+    async def get_sk(self, keychain_proxy: KeychainProxy | None = None) -> PrivateKey | None:
+        sk: PrivateKey | None = None
         if keychain_proxy:
             try:
                 if self.alt_fingerprint is not None:
@@ -104,7 +103,7 @@ class PlotKeysResolver:
             except Exception as e:
                 log.error(f"Keychain proxy failed with error: {e}")
         else:
-            sk_ent: Optional[tuple[PrivateKey, bytes]] = None
+            sk_ent: tuple[PrivateKey, bytes] | None = None
             keychain: Keychain = Keychain()
             if self.alt_fingerprint is not None:
                 sk_ent = keychain.get_private_key_by_fingerprint(self.alt_fingerprint)
@@ -115,16 +114,16 @@ class PlotKeysResolver:
                 sk = sk_ent[0]
         return sk
 
-    async def get_farmer_public_key(self, keychain_proxy: Optional[KeychainProxy] = None) -> G1Element:
-        sk: Optional[PrivateKey] = await self.get_sk(keychain_proxy)
+    async def get_farmer_public_key(self, keychain_proxy: KeychainProxy | None = None) -> G1Element:
+        sk: PrivateKey | None = await self.get_sk(keychain_proxy)
         if sk is None:
             raise RuntimeError(
                 "No keys, please run 'chia keys add', 'chia keys generate' or provide a public key with -f"
             )
         return master_sk_to_farmer_sk(sk).get_g1()
 
-    async def get_pool_public_key(self, keychain_proxy: Optional[KeychainProxy] = None) -> G1Element:
-        sk: Optional[PrivateKey] = await self.get_sk(keychain_proxy)
+    async def get_pool_public_key(self, keychain_proxy: KeychainProxy | None = None) -> G1Element:
+        sk: PrivateKey | None = await self.get_sk(keychain_proxy)
         if sk is None:
             raise RuntimeError(
                 "No keys, please run 'chia keys add', 'chia keys generate' or provide a public key with -p"
@@ -133,10 +132,10 @@ class PlotKeysResolver:
 
 
 async def resolve_plot_keys(
-    farmer_public_key: Optional[str],
-    alt_fingerprint: Optional[int],
-    pool_public_key: Optional[str],
-    pool_contract_address: Optional[str],
+    farmer_public_key: str | None,
+    alt_fingerprint: int | None,
+    pool_public_key: str | None,
+    pool_contract_address: str | None,
     root_path: Path,
     log: logging.Logger,
     connect_to_daemon: bool = False,
@@ -150,7 +149,7 @@ async def create_plots(
     args: Params,
     keys: PlotKeys,
     use_datetime: bool = True,
-    test_private_keys: Optional[list[PrivateKey]] = None,
+    test_private_keys: list[PrivateKey] | None = None,
 ) -> tuple[dict[bytes32, Path], dict[bytes32, Path]]:
     if args.tmp2_dir is None:
         args.tmp2_dir = args.tmp_dir

chia/plotting/manager.py

@@ -4,11 +4,12 @@ import logging
 import threading
 import time
 import traceback
+from collections.abc import Callable
 from concurrent.futures.thread import ThreadPoolExecutor
 from pathlib import Path
-from typing import Any, Callable, Optional
+from typing import Any
 
-from chia_rs import G1Element
+from chia_rs import ConsensusConstants, G1Element
 from chiapos import decompressor_context_queue
 
 from chia.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR, _expected_plot_size
@@ -36,24 +37,26 @@ class PlotManager:
     farmer_public_keys: list[G1Element]
     pool_public_keys: list[G1Element]
     cache: Cache
-    match_str: Optional[str]
+    match_str: str | None
     open_no_key_filenames: bool
     last_refresh_time: float
     refresh_parameter: PlotsRefreshParameter
     log: Any
     _lock: threading.Lock
-    _refresh_thread: Optional[threading.Thread]
+    _refresh_thread: threading.Thread | None
     _refreshing_enabled: bool
     _refresh_callback: Callable
     _initial: bool
     max_compression_level_allowed: int
     context_count: int
+    constants: ConsensusConstants
 
     def __init__(
         self,
         root_path: Path,
         refresh_callback: Callable,
-        match_str: Optional[str] = None,
+        constants: ConsensusConstants,
+        match_str: str | None = None,
         open_no_key_filenames: bool = False,
         refresh_parameter: PlotsRefreshParameter = PlotsRefreshParameter(),
     ):
@@ -82,6 +85,7 @@ class PlotManager:
         self._initial = True
         self.max_compression_level_allowed = 0
         self.context_count = 0
+        self.constants = constants
 
     def __enter__(self):
         self._lock.acquire()
@@ -278,8 +282,8 @@ class PlotManager:
                     f"total_result.removed {len(total_result.removed)}, "
                     f"total_duration {total_result.duration:.2f} seconds"
                 )
-            except Exception as e:
-                log.error(f"_refresh_callback raised: {e} with the traceback: {traceback.format_exc()}")
+            except Exception:
+                log.exception("_refresh_callback raised")
                 self.reset()
 
     def refresh_batch(self, plot_paths: list[Path], plot_directories: set[Path]) -> PlotRefreshResult:
@@ -292,7 +296,7 @@ class PlotManager:
         if self.match_str is not None:
             log.info(f'Only loading plots that contain "{self.match_str}" in the file or directory name')
 
-        def process_file(file_path: Path) -> Optional[PlotInfo]:
+        def process_file(file_path: Path) -> PlotInfo | None:
             if not self._refreshing_enabled:
                 return None
             filename_str = str(file_path)
@@ -309,7 +313,7 @@ class PlotManager:
             if file_path in self.plots:
                 return self.plots[file_path]
 
-            entry: Optional[tuple[str, set[str]]] = self.plot_filename_paths.get(file_path.name)
+            entry: tuple[str, set[str]] | None = self.plot_filename_paths.get(file_path.name)
             if entry is not None:
                 _loaded_parent, duplicates = entry
                 if str(file_path.parent) in duplicates:
@@ -328,17 +332,20 @@ class PlotManager:
 
                     log.debug(f"process_file {file_path!s}")
 
-                    expected_size = _expected_plot_size(prover.get_size()) * UI_ACTUAL_SPACE_CONSTANT_FACTOR
+                    expected_size = (
+                        _expected_plot_size(prover.get_param(), self.constants) * UI_ACTUAL_SPACE_CONSTANT_FACTOR
+                    )
 
                     # TODO: consider checking if the file was just written to (which would mean that the file is still
                     # being copied). A segfault might happen in this edge case.
 
-                    k = prover.get_size()
+                    param = prover.get_param()
                     level = prover.get_compression_level()
                     if (
                         level == 0
                         and stat_info.st_size < 0.98 * expected_size
-                        and ((k.size_v1 is not None and k.size_v1 >= 30) or (k.size_v2 is not None and k.size_v2 >= 28))
+                        and param.size_v1 is not None
+                        and param.size_v1 >= 30
                     ):
                         log.warning(
                             f"Not farming plot {file_path}. "
@@ -388,7 +395,7 @@ class PlotManager:
                     self.no_key_filenames.remove(file_path)
 
                 with self.plot_filename_paths_lock:
-                    paths: Optional[tuple[str, set[str]]] = self.plot_filename_paths.get(file_path.name)
+                    paths: tuple[str, set[str]] | None = self.plot_filename_paths.get(file_path.name)
                     if paths is None:
                         paths = (str(Path(cache_entry.prover.get_filename()).parent), set())
                         self.plot_filename_paths[file_path.name] = paths
@@ -419,7 +426,7 @@ class PlotManager:
                 log.error(f"Failed to open file {file_path}. {e} {tb}")
                 self.failed_to_open_filenames[file_path] = int(time.time())
                 return None
-            log.debug(f"Found plot {file_path} of size {new_plot_info.prover.get_size()}, cache_hit: {cache_hit}")
+            log.debug(f"Found plot {file_path} of size {new_plot_info.prover.get_param()}, cache_hit: {cache_hit}")
 
             return new_plot_info