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

chia/harvester/harvester_api.py

@@ -5,7 +5,7 @@ import logging
 import time
 from collections.abc import Awaitable, Sequence
 from pathlib import Path
-from typing import TYPE_CHECKING, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, ClassVar
 
 from chia_rs import AugSchemeMPL, G1Element, G2Element, ProofOfSpace
 from chia_rs.sized_bytes import bytes32
@@ -16,7 +16,7 @@ from chia.consensus.pot_iterations import (
     calculate_sp_interval_iters,
 )
 from chia.harvester.harvester import Harvester
-from chia.plotting.prover import PlotVersion
+from chia.plotting.prover import PlotVersion, V1Prover, V2Prover, V2Quality
 from chia.plotting.util import PlotInfo, parse_plot_info
 from chia.protocols import harvester_protocol
 from chia.protocols.farmer_protocol import FarmingInfo
@@ -28,20 +28,22 @@ from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.proof_of_space import (
     calculate_pos_challenge,
     calculate_prefix_bits,
-    calculate_required_plot_strength,
     generate_plot_public_key,
+    is_v1_phased_out,
     make_pos,
     passes_plot_filter,
-    quality_for_partial_proof,
+    v1_cut_off_height,
 )
 from chia.wallet.derive_keys import master_sk_to_local_sk
 
 
 class HarvesterAPI:
     if TYPE_CHECKING:
-        from chia.server.api_protocol import ApiProtocol
+        from chia.apis.harvester_stub import HarvesterApiStub
 
-        _protocol_check: ClassVar[ApiProtocol] = cast("HarvesterAPI", None)
+        # Verify this class implements the HarvesterApiStub protocol
+        def _protocol_check(self: HarvesterAPI) -> HarvesterApiStub:
+            return self
 
     log: logging.Logger
     harvester: Harvester
@@ -58,7 +60,7 @@ class HarvesterAPI:
         filter_prefix_bits = calculate_prefix_bits(
             self.harvester.constants,
             challenge.peak_height,
-            plot_info.prover.get_size(),
+            plot_info.prover.get_param(),
         )
         return passes_plot_filter(
             filter_prefix_bits,
@@ -89,7 +91,7 @@ class HarvesterAPI:
         return proofs_found
 
     async def _handle_v2_responses(
-        self, v2_awaitables: Sequence[Awaitable[Optional[PartialProofsData]]], start_time: float, peer: WSChiaConnection
+        self, v2_awaitables: Sequence[Awaitable[PartialProofsData | None]], start_time: float, peer: WSChiaConnection
     ) -> int:
         partial_proofs_found = 0
         for quality_awaitable in asyncio.as_completed(v2_awaitables):
@@ -153,13 +155,9 @@ class HarvesterAPI:
         start = time.monotonic()
         assert len(new_challenge.challenge_hash) == 32
 
-        required_plot_strength = calculate_required_plot_strength(
-            self.harvester.constants, new_challenge.last_tx_height
-        )
-
         loop = asyncio.get_running_loop()
 
-        def blocking_lookup_v2_partial_proofs(filename: Path, plot_info: PlotInfo) -> Optional[PartialProofsData]:
+        def blocking_lookup_v2_partial_proofs(filename: Path, plot_info: PlotInfo) -> PartialProofsData | None:
             # Uses the V2 Prover object to lookup qualities only. No full proofs generated.
             try:
                 plot_id = plot_info.prover.get_id()
@@ -168,12 +166,12 @@ class HarvesterAPI:
                     new_challenge.challenge_hash,
                     new_challenge.sp_hash,
                 )
-                partial_proofs = plot_info.prover.get_partial_proofs_for_challenge(
-                    sp_challenge_hash, required_plot_strength
+                qualities = plot_info.prover.get_qualities_for_challenge(
+                    sp_challenge_hash, self.harvester.constants.QUALITY_PROOF_SCAN_FILTER
                 )
 
                 # If no partial proofs are found, return None
-                if len(partial_proofs) == 0:
+                if len(qualities) == 0:
                     return None
 
                 # Get the appropriate difficulty for this plot
@@ -191,33 +189,36 @@ class HarvesterAPI:
                 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)
+                for quality in qualities:
                     required_iters: uint64 = calculate_iterations_quality(
                         self.harvester.constants,
-                        quality_str,
-                        plot_info.prover.get_size(),
+                        quality.get_string(),
+                        plot_info.prover.get_param(),
                         difficulty,
                         new_challenge.sp_hash,
-                        sub_slot_iters,
-                        new_challenge.last_tx_height,
                     )
 
-                    if required_iters < sp_interval_iters:
-                        good_partial_proofs.append(partial_proof)
+                    if required_iters >= sp_interval_iters:
+                        continue
+
+                    assert isinstance(plot_info.prover, V2Prover)
+                    assert isinstance(quality, V2Quality)
+
+                    partial_proof = plot_info.prover.get_partial_proof(quality)
+                    good_partial_proofs.append(partial_proof)
 
                 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_partial_proofs[0].hex() + str(filename.resolve()),
+                    str(filename.resolve()),
                     good_partial_proofs,
                     new_challenge.signage_point_index,
-                    size,
+                    self.harvester.constants.PLOT_SIZE_V2,
+                    plot_info.prover.get_strength(),
+                    plot_id,
                     plot_info.pool_public_key,
                     plot_info.pool_contract_puzzle_hash,
                     plot_info.plot_public_key,
@@ -238,7 +239,9 @@ class HarvesterAPI:
                     new_challenge.sp_hash,
                 )
                 try:
-                    quality_strings = plot_info.prover.get_qualities_for_challenge(sp_challenge_hash)
+                    qualities = plot_info.prover.get_qualities_for_challenge(
+                        sp_challenge_hash, self.harvester.constants.QUALITY_PROOF_SCAN_FILTER
+                    )
                 except RuntimeError as e:
                     if str(e) == "Timeout waiting for context queue.":
                         self.harvester.log.warning(
@@ -264,7 +267,7 @@ class HarvesterAPI:
                     return []
 
                 responses: list[tuple[bytes32, ProofOfSpace]] = []
-                if quality_strings is not None:
+                if len(qualities) > 0:
                     difficulty = new_challenge.difficulty
                     sub_slot_iters = new_challenge.sub_slot_iters
                     if plot_info.pool_contract_puzzle_hash is not None:
@@ -277,24 +280,34 @@ class HarvesterAPI:
                                 sub_slot_iters = pool_difficulty.sub_slot_iters
 
                     # Found proofs of space (on average 1 is expected per plot)
-                    for index, quality_str in enumerate(quality_strings):
+                    for index, quality in enumerate(qualities):
                         required_iters: uint64 = calculate_iterations_quality(
                             self.harvester.constants,
-                            quality_str,
-                            plot_info.prover.get_size(),
+                            quality.get_string(),
+                            plot_info.prover.get_param(),
                             difficulty,
                             new_challenge.sp_hash,
-                            sub_slot_iters,
-                            new_challenge.last_tx_height,
                         )
                         sp_interval_iters = calculate_sp_interval_iters(self.harvester.constants, sub_slot_iters)
                         if required_iters < sp_interval_iters:
                             # Found a very good proof of space! will fetch the whole proof from disk,
                             # then send to farmer
                             try:
+                                assert isinstance(plot_info.prover, V1Prover)
                                 proof_xs = plot_info.prover.get_full_proof(
                                     sp_challenge_hash, index, self.harvester.parallel_read
                                 )
+
+                                if is_v1_phased_out(proof_xs, new_challenge.last_tx_height, self.harvester.constants):
+                                    self.harvester.log.info(
+                                        f"Proof dropped due to hard fork phase-out of v1 plots: {filename}"
+                                    )
+                                    self.harvester.log.info(
+                                        f"File: {filename} Plot ID: {plot_id.hex()}, challenge: {sp_challenge_hash}, "
+                                        f"plot_info: {plot_info}"
+                                    )
+                                    continue
+
                             except RuntimeError as e:
                                 if str(e) == "GRResult_NoProof received":
                                     self.harvester.log.info(
@@ -327,6 +340,7 @@ class HarvesterAPI:
                                 )
                                 continue
 
+                            quality_str = bytes32(quality.get_string())
                             responses.append(
                                 (
                                     quality_str,
@@ -335,7 +349,7 @@ class HarvesterAPI:
                                         plot_info.pool_public_key,
                                         plot_info.pool_contract_puzzle_hash,
                                         plot_info.plot_public_key,
-                                        plot_info.prover.get_size(),
+                                        plot_info.prover.get_param(),
                                         proof_xs,
                                     ),
                                 )
@@ -383,6 +397,11 @@ class HarvesterAPI:
                 if not self._plot_passes_filter(try_plot_info, new_challenge):
                     continue
                 if try_plot_info.prover.get_version() == PlotVersion.V2:
+                    # before hard fork activation, we can't farm v2 plots
+                    constants = self.harvester.constants
+                    if new_challenge.last_tx_height < constants.HARD_FORK2_HEIGHT:
+                        continue
+
                     v2_awaitables.append(
                         loop.run_in_executor(
                             self.harvester.executor,
@@ -393,12 +412,15 @@ class HarvesterAPI:
                     )
                     passed += 1
                 else:
+                    # after the phase-out, ignore v1 plots
+                    if new_challenge.last_tx_height >= v1_cut_off_height(self.harvester.constants):
+                        continue
+
                     passed += 1
                     awaitables.append(lookup_challenge(try_plot_filename, try_plot_info))
             self.harvester.log.debug(f"new_signage_point_harvester {passed} plots passed the plot filter")
 
         # Concurrently executes all lookups on disk, to take advantage of multiple disk parallelism
-        time_taken = time.monotonic() - start
         total_proofs_found = 0
         total_v2_partial_proofs_found = 0
 
@@ -419,6 +441,7 @@ class HarvesterAPI:
                 else:
                     total_v2_partial_proofs_found = results[0]
 
+        time_taken = time.monotonic() - start
         now = uint64(time.time())
 
         farming_info = FarmingInfo(
@@ -452,7 +475,7 @@ class HarvesterAPI:
         )
 
     @metadata.request(reply_types=[ProtocolMessageTypes.respond_signatures])
-    async def request_signatures(self, request: harvester_protocol.RequestSignatures) -> Optional[Message]:
+    async def request_signatures(self, request: harvester_protocol.RequestSignatures) -> Message | None:
         """
         The farmer requests a signature on the header hash, for one of the proofs that we found.
         A signature is created on the header hash using the harvester private key. This can also

chia/harvester/harvester_rpc_api.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from chia_rs.sized_ints import uint32
 
@@ -31,7 +31,7 @@ class HarvesterRpcApi:
             "/update_harvester_config": self.update_harvester_config,
         }
 
-    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> list[WsRpcMessage]:
+    async def _state_changed(self, change: str, change_data: dict[str, Any] | None = None) -> list[WsRpcMessage]:
         if change_data is None:
             change_data = {}
 
@@ -102,14 +102,14 @@ class HarvesterRpcApi:
         }
 
     async def update_harvester_config(self, request: dict[str, Any]) -> EndpointResult:
-        use_gpu_harvesting: Optional[bool] = None
-        gpu_index: Optional[int] = None
-        enforce_gpu_index: Optional[bool] = None
-        disable_cpu_affinity: Optional[bool] = None
-        parallel_decompressor_count: Optional[int] = None
-        decompressor_thread_count: Optional[int] = None
-        recursive_plot_scan: Optional[bool] = None
-        refresh_parameter_interval_seconds: Optional[uint32] = None
+        use_gpu_harvesting: bool | None = None
+        gpu_index: int | None = None
+        enforce_gpu_index: bool | None = None
+        disable_cpu_affinity: bool | None = None
+        parallel_decompressor_count: int | None = None
+        decompressor_thread_count: int | None = None
+        recursive_plot_scan: bool | None = None
+        refresh_parameter_interval_seconds: uint32 | None = None
         if "use_gpu_harvesting" in request:
             use_gpu_harvesting = bool(request["use_gpu_harvesting"])
         if "gpu_index" in request:

chia/harvester/start_harvester.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 import os
 import pathlib
 import sys
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs import ConsensusConstants
 
-from chia.apis import ApiProtocolRegistry
+from chia.apis import StubMetadataRegistry
 from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
 from chia.harvester.harvester import Harvester
@@ -48,7 +48,7 @@ def create_harvester_service(
     peer_api = HarvesterAPI(node)
     network_id = service_config["selected_network"]
 
-    rpc_info: Optional[RpcInfo[HarvesterRpcApi]] = None
+    rpc_info: RpcInfo[HarvesterRpcApi] | None = None
     if service_config.get("start_rpc_server", True):
         rpc_info = (HarvesterRpcApi, service_config["rpc_port"])
 
@@ -64,7 +64,7 @@ def create_harvester_service(
         network_id=network_id,
         rpc_info=rpc_info,
         connect_to_daemon=connect_to_daemon,
-        class_for_type=ApiProtocolRegistry,
+        stub_metadata_for_type=StubMetadataRegistry,
     )
 
 

chia/introducer/introducer.py

@@ -6,7 +6,7 @@ import logging
 import random
 import time
 from collections.abc import AsyncIterator
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 import dns.asyncresolver
 from chia_rs.sized_ints import uint16, uint64
@@ -42,7 +42,7 @@ class Introducer:
         self.dns_servers = dns_servers
         self.resolver = dns.asyncresolver.Resolver()
         self._shut_down = False
-        self._server: Optional[ChiaServer] = None
+        self._server: ChiaServer | None = None
         self.log = logging.getLogger(__name__)
 
     @contextlib.asynccontextmanager
@@ -62,7 +62,7 @@ class Introducer:
         # TODO: fill this out?
         pass
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
+    def get_connections(self, request_node_type: NodeType | None) -> list[dict[str, Any]]:
         return default_get_connections(server=self.server, request_node_type=request_node_type)
 
     def set_server(self, server: ChiaServer):

chia/introducer/introducer_api.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, ClassVar
 
 from chia_rs.sized_ints import uint64
 
@@ -17,9 +17,11 @@ from chia.types.peer_info import TimestampedPeerInfo
 
 class IntroducerAPI:
     if TYPE_CHECKING:
-        from chia.server.api_protocol import ApiProtocol
+        from chia.apis.introducer_stub import IntroducerApiStub
 
-        _protocol_check: ClassVar[ApiProtocol] = cast("IntroducerAPI", None)
+        # Verify this class implements the IntroducerApiStub protocol
+        def _protocol_check(self: IntroducerAPI) -> IntroducerApiStub:
+            return self
 
     log: logging.Logger
     introducer: Introducer
@@ -40,7 +42,7 @@ class IntroducerAPI:
         self,
         request: RequestPeersIntroducer,
         peer: WSChiaConnection,
-    ) -> Optional[Message]:
+    ) -> Message | None:
         max_peers = self.introducer.max_peers_to_send
         if self.introducer.server is None or self.introducer.server.introducer_peers is None:
             return None

chia/introducer/start_introducer.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 import os
 import pathlib
 import sys
-from typing import Any, Optional
+from typing import Any
 
-from chia.apis import ApiProtocolRegistry
+from chia.apis import StubMetadataRegistry
 from chia.introducer.introducer import Introducer
 from chia.introducer.introducer_api import IntroducerAPI
 from chia.introducer.introducer_service import IntroducerService
@@ -26,7 +26,7 @@ SERVICE_NAME = "introducer"
 def create_introducer_service(
     root_path: pathlib.Path,
     config: dict[str, Any],
-    advertised_port: Optional[int] = None,
+    advertised_port: int | None = None,
     connect_to_daemon: bool = True,
 ) -> IntroducerService:
     service_config = config[SERVICE_NAME]
@@ -60,7 +60,7 @@ def create_introducer_service(
         service_name=SERVICE_NAME,
         network_id=network_id,
         connect_to_daemon=connect_to_daemon,
-        class_for_type=ApiProtocolRegistry,
+        stub_metadata_for_type=StubMetadataRegistry,
     )
 
 

chia/legacy/keyring.py

@@ -6,7 +6,8 @@ helper it's required to install the `legacy_keyring` extra dependency which can
 from __future__ import annotations
 
 import sys
-from typing import Callable, Union, cast
+from collections.abc import Callable
+from typing import TypeAlias, cast
 
 import click
 from chia_rs import G1Element
@@ -21,11 +22,10 @@ except ImportError:
         sys.exit("Use `install.sh -l` to install the legacy_keyring dependency.")
     CryptFileKeyring = None
 
-
 from chia.util.errors import KeychainUserNotFound
 from chia.util.keychain import MAX_KEYS, KeyData, KeyDataSecrets, get_private_key_user
 
-LegacyKeyring = Union[MacKeyring, WinKeyring, CryptFileKeyring]
+LegacyKeyring: TypeAlias = MacKeyring | WinKeyring | CryptFileKeyring
 
 
 CURRENT_KEY_VERSION = "1.8"

chia/plot_sync/delta.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Union
 
 from chia.protocols.harvester_protocol import Plot
 
 
 @dataclass
 class DeltaType:
-    additions: Union[dict[str, Plot], list[str]]
+    additions: dict[str, Plot] | list[str]
     removals: list[str]
 
     def __str__(self) -> str:

chia/plot_sync/receiver.py

@@ -2,11 +2,11 @@ from __future__ import annotations
 
 import logging
 import time
-from collections.abc import Awaitable, Collection, Sequence
+from collections.abc import Awaitable, Callable, Collection, Sequence
 from dataclasses import dataclass, field
-from typing import Any, Callable, Optional, Union
+from typing import Any
 
-from chia_rs import PlotSize
+from chia_rs import ConsensusConstants
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import int16, uint32, uint64
 from typing_extensions import Protocol
@@ -40,7 +40,7 @@ from chia.server.ws_connection import WSChiaConnection
 log = logging.getLogger(__name__)
 
 
-def get_list_or_len(list_in: Sequence[object], length: bool) -> Union[int, Sequence[object]]:
+def get_list_or_len(list_in: Sequence[object], length: bool) -> int | Sequence[object]:
     return len(list_in) if length else list_in
 
 
@@ -52,7 +52,7 @@ class Sync:
     plots_processed: uint32 = uint32(0)
     plots_total: uint32 = uint32(0)
     delta: Delta = field(default_factory=Delta)
-    time_done: Optional[float] = None
+    time_done: float | None = None
 
     def in_progress(self) -> bool:
         return self.sync_id != 0
@@ -76,7 +76,7 @@ class Sync:
 
 
 class ReceiverUpdateCallback(Protocol):
-    def __call__(self, peer_id: bytes32, delta: Optional[Delta]) -> Awaitable[None]:
+    def __call__(self, peer_id: bytes32, delta: Delta | None) -> Awaitable[None]:
         pass
 
 
@@ -91,12 +91,14 @@ class Receiver:
     _total_plot_size: int
     _total_effective_plot_size: int
     _update_callback: ReceiverUpdateCallback
-    _harvesting_mode: Optional[HarvestingMode]
+    _harvesting_mode: HarvestingMode | None
+    _constants: ConsensusConstants
 
     def __init__(
         self,
         connection: WSChiaConnection,
         update_callback: ReceiverUpdateCallback,
+        constants: ConsensusConstants,
     ) -> None:
         self._connection = connection
         self._current_sync = Sync()
@@ -109,12 +111,13 @@ class Receiver:
         self._total_effective_plot_size = 0
         self._update_callback = update_callback
         self._harvesting_mode = None
+        self._constants = constants
 
-    async def trigger_callback(self, update: Optional[Delta] = None) -> None:
+    async def trigger_callback(self, update: Delta | None = None) -> None:
         try:
             await self._update_callback(self._connection.peer_node_id, update)
-        except Exception as e:
-            log.error(f"_update_callback: node_id {self.connection().peer_node_id}, raised {e}")
+        except Exception:
+            log.exception(f"_update_callback: node_id {self.connection().peer_node_id}")
 
     def reset(self) -> None:
         log.info(f"reset: node_id {self.connection().peer_node_id}, current_sync: {self._current_sync}")
@@ -158,7 +161,7 @@ class Receiver:
     def total_effective_plot_size(self) -> int:
         return self._total_effective_plot_size
 
-    def harvesting_mode(self) -> Optional[HarvestingMode]:
+    def harvesting_mode(self) -> HarvestingMode | None:
         return self._harvesting_mode
 
     async def _process(
@@ -168,7 +171,7 @@ class Receiver:
             f"_process: node_id {self.connection().peer_node_id}, message_type: {message_type}, message: {message}"
         )
 
-        async def send_response(plot_sync_error: Optional[PlotSyncError] = None) -> None:
+        async def send_response(plot_sync_error: PlotSyncError | None = None) -> None:
             if self._connection is not None:
                 await self._connection.send_message(
                     make_msg(
@@ -181,13 +184,13 @@ class Receiver:
             await method(message)
             await send_response()
         except InvalidIdentifierError as e:
-            log.warning(f"_process: node_id {self.connection().peer_node_id}, InvalidIdentifierError {e}")
+            log.exception(f"_process: node_id {self.connection().peer_node_id}")
             await send_response(PlotSyncError(int16(e.error_code), f"{e}", e.expected_identifier))
         except PlotSyncException as e:
-            log.warning(f"_process: node_id {self.connection().peer_node_id}, Error {e}")
+            log.exception(f"_process: node_id {self.connection().peer_node_id}")
             await send_response(PlotSyncError(int16(e.error_code), f"{e}", None))
         except Exception as e:
-            log.warning(f"_process: node_id {self.connection().peer_node_id}, Exception {e}")
+            log.exception(f"_process: node_id {self.connection().peer_node_id}")
             await send_response(PlotSyncError(int16(ErrorCodes.unknown), f"{e}", None))
 
     def _validate_identifier(self, identifier: PlotSyncIdentifier, start: bool = False) -> None:
@@ -349,10 +352,10 @@ class Receiver:
         self._keys_missing = self._current_sync.delta.keys_missing.additions.copy()
         self._duplicates = self._current_sync.delta.duplicates.additions.copy()
         self._total_plot_size = sum(plot.file_size for plot in self._plots.values())
+
         self._total_effective_plot_size = int(
-            # TODO: todo_v2_plots support v2 plots
             sum(
-                UI_ACTUAL_SPACE_CONSTANT_FACTOR * int(_expected_plot_size(PlotSize.make_v1(plot.size)))
+                UI_ACTUAL_SPACE_CONSTANT_FACTOR * _expected_plot_size(plot.param(), self._constants)
                 for plot in self._plots.values()
             )
         )

chia/plot_sync/sender.py

@@ -7,9 +7,9 @@ import traceback
 from collections.abc import Iterable
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Generic, Optional, TypeVar
+from typing import Any, Generic, TypeVar
 
-from chia_rs.sized_ints import int16, uint32, uint64
+from chia_rs.sized_ints import int16, uint8, uint32, uint64
 from typing_extensions import Protocol
 
 from chia.plot_sync.exceptions import AlreadyStartedError, InvalidConnectionTypeError
@@ -37,13 +37,18 @@ log = logging.getLogger(__name__)
 def _convert_plot_info_list(plot_infos: list[PlotInfo]) -> list[Plot]:
     converted: list[Plot] = []
     for plot_info in plot_infos:
-        # TODO: todo_v2_plots support v2 plots
-        k = plot_info.prover.get_size().size_v1
-        assert k is not None
+        param = plot_info.prover.get_param()
+        k: uint8
+        if param.size_v1 is not None:
+            k = param.size_v1
+        else:
+            assert param.strength_v2 is not None
+            k = uint8(0x80 | param.strength_v2)
+
         converted.append(
             Plot(
                 filename=plot_info.prover.get_filename(),
-                size=k,
+                size=uint8(k),
                 plot_id=plot_info.prover.get_id(),
                 pool_public_key=plot_info.pool_public_key,
                 pool_contract_puzzle_hash=plot_info.pool_contract_puzzle_hash,
@@ -84,7 +89,7 @@ class MessageGenerator(Generic[T]):
 class ExpectedResponse:
     message_type: ProtocolMessageTypes
     identifier: PlotSyncIdentifier
-    message: Optional[PlotSyncResponse] = None
+    message: PlotSyncResponse | None = None
 
     def __str__(self) -> str:
         return (
@@ -95,14 +100,14 @@ class ExpectedResponse:
 
 class Sender:
     _plot_manager: PlotManager
-    _connection: Optional[WSChiaConnection]
+    _connection: WSChiaConnection | None
     _sync_id: uint64
     _next_message_id: uint64
     _messages: list[MessageGenerator[PayloadType]]
     _last_sync_id: uint64
     _stop_requested = False
-    _task: Optional[asyncio.Task[None]]
-    _response: Optional[ExpectedResponse]
+    _task: asyncio.Task[None] | None
+    _response: ExpectedResponse | None
     _harvesting_mode: HarvestingMode
 
     def __init__(self, plot_manager: PlotManager, harvesting_mode: HarvestingMode) -> None: