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

chia/_tests/farmer_harvester/test_third_party_harvesters.py

@@ -7,7 +7,7 @@ import dataclasses
 import json
 import logging
 from os.path import dirname
-from typing import Optional, Union, cast
+from typing import cast
 
 import pytest
 from chia_rs import (
@@ -52,7 +52,7 @@ from chia.types.validation_state import ValidationState
 from chia.util.bech32m import decode_puzzle_hash
 from chia.util.hash import std_hash
 
-SPType = Union[timelord_protocol.NewEndOfSubSlotVDF, timelord_protocol.NewSignagePointVDF]
+SPType = timelord_protocol.NewEndOfSubSlotVDF | timelord_protocol.NewSignagePointVDF
 SPList = list[SPType]
 
 
@@ -61,8 +61,8 @@ async def test_harvester_receive_source_signing_data(
     farmer_harvester_2_simulators_zero_bits_plot_filter: tuple[
         FarmerService,
         HarvesterService,
-        Union[FullNodeService, SimulatorFullNodeService],
-        Union[FullNodeService, SimulatorFullNodeService],
+        FullNodeService | SimulatorFullNodeService,
+        FullNodeService | SimulatorFullNodeService,
         BlockTools,
     ],
 ) -> None:
@@ -121,12 +121,12 @@ async def test_harvester_receive_source_signing_data(
 
     async def intercept_harvester_request_signatures(
         self: HarvesterAPI, request: harvester_protocol.RequestSignatures
-    ) -> Optional[Message]:
+    ) -> Message | None:
         nonlocal harvester
         nonlocal farmer_reward_address
 
         validate_harvester_request_signatures(request)
-        result_msg: Optional[Message] = await HarvesterAPI.request_signatures(
+        result_msg: Message | None = await HarvesterAPI.request_signatures(
             cast(HarvesterAPI, harvester.server.api), request
         )
         assert result_msg is not None
@@ -158,15 +158,14 @@ async def test_harvester_receive_source_signing_data(
             assert hash
             assert src
 
-            data: Optional[
-                Union[
-                    FoliageBlockData,
-                    FoliageTransactionBlock,
-                    ClassgroupElement,
-                    ChallengeChainSubSlot,
-                    RewardChainSubSlot,
-                ]
-            ] = None
+            data: (
+                FoliageBlockData
+                | FoliageTransactionBlock
+                | ClassgroupElement
+                | ChallengeChainSubSlot
+                | RewardChainSubSlot
+                | None
+            ) = None
             if src.kind == uint8(SigningDataKind.FOLIAGE_BLOCK_DATA):
                 data = FoliageBlockData.from_bytes(src.data)
                 assert (
@@ -227,7 +226,7 @@ async def test_harvester_receive_source_signing_data(
 
     async def intercept_farmer_request_signed_values(
         self: FarmerAPI, request: farmer_protocol.RequestSignedValues
-    ) -> Optional[Message]:
+    ) -> Message | None:
         nonlocal farmer
         nonlocal farmer_reward_address
         nonlocal full_node_2
@@ -284,8 +283,8 @@ async def test_harvester_fee_convention(
     farmer_harvester_2_simulators_zero_bits_plot_filter: tuple[
         FarmerService,
         HarvesterService,
-        Union[FullNodeService, SimulatorFullNodeService],
-        Union[FullNodeService, SimulatorFullNodeService],
+        FullNodeService | SimulatorFullNodeService,
+        FullNodeService | SimulatorFullNodeService,
         BlockTools,
     ],
     caplog: pytest.LogCaptureFixture,
@@ -314,8 +313,8 @@ async def test_harvester_fee_invalid_convention(
     farmer_harvester_2_simulators_zero_bits_plot_filter: tuple[
         FarmerService,
         HarvesterService,
-        Union[FullNodeService, SimulatorFullNodeService],
-        Union[FullNodeService, SimulatorFullNodeService],
+        FullNodeService | SimulatorFullNodeService,
+        FullNodeService | SimulatorFullNodeService,
         BlockTools,
     ],
     caplog: pytest.LogCaptureFixture,
@@ -437,7 +436,7 @@ def node_type_connected(server: ChiaServer, node_type: NodeType) -> bool:
 
 def decode_sp(
     is_sub_slot: bool, sp64: str
-) -> Union[timelord_protocol.NewEndOfSubSlotVDF, timelord_protocol.NewSignagePointVDF]:
+) -> timelord_protocol.NewEndOfSubSlotVDF | timelord_protocol.NewSignagePointVDF:
     sp_bytes = base64.b64decode(sp64)
     if is_sub_slot:
         return timelord_protocol.NewEndOfSubSlotVDF.from_bytes(sp_bytes)
@@ -496,7 +495,7 @@ async def inject_signage_points(signage_points: SPList, full_node_1: FullNode, f
     api2 = cast(FullNodeAPI, full_node_2.server.api)
 
     for i, sp in enumerate(signage_points):
-        req: Union[full_node_protocol.RespondEndOfSubSlot, full_node_protocol.RespondSignagePoint]
+        req: full_node_protocol.RespondEndOfSubSlot | full_node_protocol.RespondSignagePoint
 
         if isinstance(sp, timelord_protocol.NewEndOfSubSlotVDF):
             full_node_1.log.info(f"Injecting SP for end of sub-slot @ {i}")

chia/_tests/fee_estimation/test_fee_estimation_integration.py

@@ -214,28 +214,28 @@ def test_current_block_height_new_block_then_new_height() -> None:
 
 @pytest.mark.anyio
 async def test_mm_new_peak_changes_fee_estimator_block_height() -> None:
-    mempool_manager = await instantiate_mempool_manager(zero_calls_get_coin_records)
-    block2 = create_test_block_record(height=uint32(2))
-    await mempool_manager.new_peak(block2, None)
-    assert mempool_manager.mempool.fee_estimator.block_height == uint32(2)  # type: ignore[attr-defined]
+    async with instantiate_mempool_manager(zero_calls_get_coin_records) as mempool_manager:
+        block2 = create_test_block_record(height=uint32(2))
+        await mempool_manager.new_peak(block2, None)
+        assert mempool_manager.mempool.fee_estimator.block_height == uint32(2)  # type: ignore[attr-defined]
 
 
 @pytest.mark.anyio
 async def test_mm_calls_new_block_height() -> None:
-    mempool_manager = await instantiate_mempool_manager(zero_calls_get_coin_records)
-    new_block_height_called = False
-
-    def test_new_block_height_called(self: FeeEstimatorInterface, height: uint32) -> None:
-        nonlocal new_block_height_called
-        new_block_height_called = True
-
-    # Replace new_block_height with test function
-    mempool_manager.fee_estimator.new_block_height = types.MethodType(  # type: ignore[method-assign]
-        test_new_block_height_called, mempool_manager.fee_estimator
-    )
-    block2 = create_test_block_record(height=uint32(2))
-    await mempool_manager.new_peak(block2, None)
-    assert new_block_height_called
+    async with instantiate_mempool_manager(zero_calls_get_coin_records) as mempool_manager:
+        new_block_height_called = False
+
+        def test_new_block_height_called(self: FeeEstimatorInterface, height: uint32) -> None:
+            nonlocal new_block_height_called
+            new_block_height_called = True
+
+        # Replace new_block_height with test function
+        mempool_manager.fee_estimator.new_block_height = types.MethodType(  # type: ignore[method-assign]
+            test_new_block_height_called, mempool_manager.fee_estimator
+        )
+        block2 = create_test_block_record(height=uint32(2))
+        await mempool_manager.new_peak(block2, None)
+        assert new_block_height_called
 
 
 def test_add_tx_called() -> None:

chia/_tests/fee_estimation/test_fee_estimation_rpc.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import re
+from collections.abc import AsyncGenerator
 from typing import Any
 
 import pytest
@@ -23,28 +24,29 @@ from chia.wallet.wallet_service import WalletService
 @pytest.fixture(scope="function")
 async def setup_node_and_rpc(
     two_wallet_nodes_services: tuple[list[SimulatorFullNodeService], list[WalletService], BlockTools],
-) -> tuple[FullNodeRpcClient, FullNodeRpcApi]:
+) -> AsyncGenerator[tuple[FullNodeRpcClient, FullNodeRpcApi], None]:
     full_nodes, wallets, bt = two_wallet_nodes_services
     wallet = wallets[0]._node.wallet_state_manager.main_wallet
     full_node_apis = [full_node_service._api for full_node_service in full_nodes]
     full_node_api: FullNodeSimulator = full_node_apis[0]
     full_node_service_1 = full_nodes[0]
     assert full_node_service_1.rpc_server is not None
-    client = await FullNodeRpcClient.create(
+
+    async with FullNodeRpcClient.create_as_context(
         bt.config["self_hostname"],
         full_node_service_1.rpc_server.listen_port,
         full_node_service_1.root_path,
         full_node_service_1.config,
-    )
-    full_node_rpc_api = FullNodeRpcApi(full_node_api.full_node)
+    ) as client:
+        full_node_rpc_api = FullNodeRpcApi(full_node_api.full_node)
 
-    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
+        async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+            ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
 
-    for i in range(4):
-        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+        for i in range(4):
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
 
-    return client, full_node_rpc_api
+        yield client, full_node_rpc_api
 
 
 @pytest.fixture(scope="function")

chia/_tests/harvester/test_harvester_api.py

@@ -15,6 +15,7 @@ from chia._tests.conftest import HarvesterFarmerEnvironment
 from chia._tests.plotting.util import get_test_plots
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.harvester.harvester_api import HarvesterAPI
+from chia.plotting.prover import V1Prover, V2Prover
 from chia.plotting.util import PlotInfo
 from chia.protocols import harvester_protocol
 from chia.protocols.harvester_protocol import PoolDifficulty
@@ -85,10 +86,16 @@ def create_test_setup(
 
 @contextmanager
 def mock_successful_proof(plot_info: PlotInfo) -> Iterator[None]:
-    with patch.object(plot_info.prover, "get_full_proof") as mock_get_proof:
-        mock_proof = MagicMock(spec=ProofOfSpace)
-        mock_get_proof.return_value = mock_proof, None
-        yield
+    if isinstance(plot_info.prover, V1Prover):
+        with patch.object(plot_info.prover, "get_full_proof") as mock_get_proof:
+            mock_proof = MagicMock(spec=ProofOfSpace)
+            mock_get_proof.return_value = mock_proof, None
+            yield
+    elif isinstance(plot_info.prover, V2Prover):
+        with patch.object(plot_info.prover, "get_partial_proof") as mock_get_proof:
+            mock_proof = MagicMock(spec=ProofOfSpace)
+            mock_get_proof.return_value = [uint64(1)] * 64, None
+            yield
 
 
 def assert_farming_info_sent(mock_peer: MagicMock) -> None:

chia/_tests/plot_sync/test_plot_sync.py

@@ -3,14 +3,14 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import functools
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Callable
 from dataclasses import dataclass, field, replace
 from pathlib import Path
 from shutil import copy
-from typing import Any, Callable, Optional
+from typing import Any
 
 import pytest
-from chia_rs import G1Element
+from chia_rs import G1Element, PlotParam
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 
@@ -109,6 +109,10 @@ class ExpectedResult:
         self.duplicates_delta.removals += [str(x) for x in list_paths]
 
 
+def equal_param(a: PlotParam, b: PlotParam) -> bool:
+    return a.size_v1 == b.size_v1 and a.strength_v2 == b.strength_v2
+
+
 @dataclass
 class Environment:
     root_path: Path
@@ -127,7 +131,7 @@ class Environment:
     split_farmer_service_manager: SplitAsyncManager[FarmerService]
     split_harvester_managers: list[SplitAsyncManager[Harvester]]
 
-    def get_harvester(self, peer_id: bytes32) -> Optional[Harvester]:
+    def get_harvester(self, peer_id: bytes32) -> Harvester | None:
         for harvester in self.harvesters:
             assert harvester.server is not None
             if harvester.server.node_id == peer_id:
@@ -183,10 +187,10 @@ class Environment:
         self.remove_directory(harvester_index, self.dir_invalid, State.invalid)
         self.remove_directory(harvester_index, self.dir_duplicates, State.duplicates)
 
-    async def plot_sync_callback(self, peer_id: bytes32, delta: Optional[Delta]) -> None:
+    async def plot_sync_callback(self, peer_id: bytes32, delta: Delta | None) -> None:
         if delta is None:
             return
-        harvester: Optional[Harvester] = self.get_harvester(peer_id)
+        harvester: Harvester | None = self.get_harvester(peer_id)
         assert harvester is not None
         expected = self.expected[self.harvesters.index(harvester)]
         assert len(expected.valid_delta.additions) == len(delta.valid.additions)
@@ -195,8 +199,7 @@ class Environment:
             plot = harvester.plot_manager.plots.get(Path(path), None)
             assert plot is not None
             assert plot.prover.get_filename() == delta.valid.additions[path].filename
-            # TODO: todo_v2_plots support v2 plots
-            assert plot.prover.get_size().size_v1 == delta.valid.additions[path].size
+            assert equal_param(plot.prover.get_param(), delta.valid.additions[path].param())
             assert plot.prover.get_id() == delta.valid.additions[path].plot_id
             assert plot.prover.get_compression_level() == delta.valid.additions[path].compression_level
             assert plot.pool_public_key == delta.valid.additions[path].pool_public_key
@@ -257,8 +260,7 @@ class Environment:
             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
-                # TODO: todo_v2_plots support v2 plots
-                assert plot_info.prover.get_size().size_v1 == receiver.plots()[str(path)].size
+                assert equal_param(plot_info.prover.get_param(), receiver.plots()[str(path)].param())
                 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
                 assert plot_info.pool_public_key == receiver.plots()[str(path)].pool_public_key
@@ -431,7 +433,7 @@ async def test_sync_keys_missing(environment: Environment) -> None:
     # Run again two times to make sure we still get the same results in repeated refresh intervals
     await env.run_sync_test()
     await env.run_sync_test()
-    # Drop all but 2 plots with missing keys and test sync inbetween
+    # Drop all but 2 plots with missing keys and test sync in between
     assert len(env.dir_keys_missing) > 2
     for _ in range(len(env.dir_keys_missing) - 2):
         drop_plot = env.dir_keys_missing.path_list()[0]

chia/_tests/plot_sync/test_receiver.py

@@ -4,14 +4,16 @@ import dataclasses
 import logging
 import random
 import time
-from typing import Any, Callable, Union
+from collections.abc import Callable
+from typing import Any
 
 import pytest
-from chia_rs import G1Element, PlotSize
+from chia_rs import G1Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 
 from chia._tests.plot_sync.util import get_dummy_connection
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR, _expected_plot_size
 from chia.plot_sync.delta import Delta
 from chia.plot_sync.receiver import Receiver, Sync, get_list_or_len
@@ -89,7 +91,7 @@ def assert_error_response(plot_sync: Receiver, error_code: ErrorCodes) -> None:
     assert response.error.code == error_code.value
 
 
-def pre_function_validate(receiver: Receiver, data: Union[list[Plot], list[str]], expected_state: State) -> None:
+def pre_function_validate(receiver: Receiver, data: list[Plot] | list[str], expected_state: State) -> None:
     if expected_state == State.loaded:
         for plot_info in data:
             assert type(plot_info) is Plot
@@ -108,7 +110,7 @@ def pre_function_validate(receiver: Receiver, data: Union[list[Plot], list[str]]
             assert path not in receiver.duplicates()
 
 
-def post_function_validate(receiver: Receiver, data: Union[list[Plot], list[str]], expected_state: State) -> None:
+def post_function_validate(receiver: Receiver, data: list[Plot] | list[str], expected_state: State) -> None:
     if expected_state == State.loaded:
         for plot_info in data:
             assert type(plot_info) is Plot
@@ -163,7 +165,7 @@ async def run_sync_step(receiver: Receiver, sync_step: SyncStepData) -> None:
 
 def plot_sync_setup(seeded_random: random.Random) -> tuple[Receiver, list[SyncStepData]]:
     harvester_connection = get_dummy_connection(NodeType.HARVESTER, bytes32.random(seeded_random))
-    receiver = Receiver(harvester_connection, dummy_callback)  # type:ignore[arg-type]
+    receiver = Receiver(harvester_connection, dummy_callback, DEFAULT_CONSTANTS)  # type:ignore[arg-type]
 
     # Create example plot data
     path_list = [str(x) for x in range(40)]
@@ -188,7 +190,7 @@ def plot_sync_setup(seeded_random: random.Random) -> tuple[Receiver, list[SyncSt
     # TODO: todo_v2_plots support v2 plots
     receiver._total_effective_plot_size = int(
         sum(
-            UI_ACTUAL_SPACE_CONSTANT_FACTOR * int(_expected_plot_size(PlotSize.make_v1(plot.size)))
+            UI_ACTUAL_SPACE_CONSTANT_FACTOR * int(_expected_plot_size(plot.param(), DEFAULT_CONSTANTS))
             for plot in receiver.plots().values()
         )
     )
@@ -221,6 +223,7 @@ def test_default_values(seeded_random: random.Random) -> None:
                 bytes32.random(seeded_random),
             ),  # type:ignore[arg-type]
             dummy_callback,  # type:ignore[arg-type]
+            DEFAULT_CONSTANTS,
         )
     )
 
@@ -270,9 +273,8 @@ async def test_to_dict(counts_only: bool, seeded_random: random.Random) -> None:
     assert get_list_or_len(plot_sync_dict_1["duplicates"], not counts_only) == 0
     assert plot_sync_dict_1["total_plot_size"] == sum(plot.file_size for plot in receiver.plots().values())
     assert plot_sync_dict_1["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 * int(_expected_plot_size(plot.param(), DEFAULT_CONSTANTS))
             for plot in receiver.plots().values()
         )
     )
@@ -320,10 +322,9 @@ async def test_to_dict(counts_only: bool, seeded_random: random.Random) -> None:
     assert get_list_or_len(sync_steps[State.duplicates].args[0], counts_only) == plot_sync_dict_3["duplicates"]
 
     assert plot_sync_dict_3["total_plot_size"] == sum(plot.file_size for plot in receiver.plots().values())
-    # TODO: todo_v2_plots support v2 plots
     assert plot_sync_dict_3["total_effective_plot_size"] == int(
         sum(
-            UI_ACTUAL_SPACE_CONSTANT_FACTOR * int(_expected_plot_size(PlotSize.make_v1(plot.size)))
+            UI_ACTUAL_SPACE_CONSTANT_FACTOR * int(_expected_plot_size(plot.param(), DEFAULT_CONSTANTS))
             for plot in receiver.plots().values()
         )
     )

chia/_tests/plot_sync/test_sync_simulated.py

@@ -10,7 +10,7 @@ from collections.abc import AsyncIterator
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import pytest
 from chia_rs import G1Element
@@ -102,7 +102,7 @@ class TestData:
         batch_size = self.harvester.plot_manager.refresh_parameter.batch_size
 
         # Used to capture the sync id in `run_internal`
-        sync_id: Optional[uint64] = None
+        sync_id: uint64 | None = None
 
         def run_internal() -> None:
             nonlocal sync_id

chia/_tests/plot_sync/util.py

@@ -4,7 +4,6 @@ import contextlib
 import time
 from collections.abc import AsyncIterator
 from dataclasses import dataclass
-from typing import Optional
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint64
@@ -25,7 +24,7 @@ class WSChiaConnectionDummy:
     connection_type: NodeType
     peer_node_id: bytes32
     peer_info: PeerInfo = PeerInfo("127.0.0.1", uint16(0))
-    last_sent_message: Optional[Message] = None
+    last_sent_message: Message | None = None
 
     async def send_message(self, message: Message) -> None:
         self.last_sent_message = message

chia/_tests/plotting/test_plot_manager.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 import logging
 import sys
 import time
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from dataclasses import dataclass, replace
 from os import unlink
 from pathlib import Path
 from shutil import copy, move
-from typing import Callable, Optional, cast
+from typing import cast
 
 import pytest
 from chia_rs import G1Element
@@ -18,6 +18,7 @@ from chiapos import DiskProver
 from chia._tests.plotting.util import get_test_plots
 from chia._tests.util.misc import boolean_datacases
 from chia._tests.util.time_out_assert import time_out_assert
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.plotting.cache import CURRENT_VERSION, CacheDataV1
 from chia.plotting.manager import Cache, PlotManager
 from chia.plotting.prover import V1Prover
@@ -90,7 +91,7 @@ class PlotRefreshTester:
     expected_result_matched: bool
 
     def __init__(self, root_path: Path):
-        self.plot_manager = PlotManager(root_path, self.refresh_callback)
+        self.plot_manager = PlotManager(root_path, self.refresh_callback, DEFAULT_CONSTANTS)
         # Set a very high refresh interval here to avoid unintentional refresh cycles
         self.plot_manager.refresh_parameter = replace(
             self.plot_manager.refresh_parameter, interval_seconds=uint32(10000)
@@ -508,8 +509,8 @@ async def test_plot_info_caching(environment, bt):
         assert plot_manager.plots[path].prover.get_filename() == plot_info.prover.get_filename()
         assert plot_manager.plots[path].prover.get_id() == plot_info.prover.get_id()
         assert plot_manager.plots[path].prover.get_memo() == plot_info.prover.get_memo()
-        assert plot_manager.plots[path].prover.get_size().size_v1 == plot_info.prover.get_size().size_v1
-        assert plot_manager.plots[path].prover.get_size().size_v2 == plot_info.prover.get_size().size_v2
+        assert plot_manager.plots[path].prover.get_param().size_v1 == plot_info.prover.get_param().size_v1
+        assert plot_manager.plots[path].prover.get_param().strength_v2 == plot_info.prover.get_param().strength_v2
         assert plot_manager.plots[path].prover.get_compression_level() == plot_info.prover.get_compression_level()
         assert plot_manager.plots[path].pool_public_key == plot_info.pool_public_key
         assert plot_manager.plots[path].pool_contract_puzzle_hash == plot_info.pool_contract_puzzle_hash
@@ -663,7 +664,7 @@ async def test_cache_lifetime(environment: Environment) -> None:
 )
 @pytest.mark.anyio
 async def test_callback_event_raises(environment, event_to_raise: PlotRefreshEvents):
-    last_event_fired: Optional[PlotRefreshEvents] = None
+    last_event_fired: PlotRefreshEvents | None = None
 
     def raising_callback(event: PlotRefreshEvents, _: PlotRefreshResult):
         nonlocal last_event_fired

chia/_tests/plotting/test_prover.py

@@ -12,44 +12,57 @@ from chia.plotting.prover import PlotVersion, V1Prover, V2Prover, get_prover_fro
 
 
 class TestProver:
+    def test_get_prover_from_file_with_plot1_still_works(self) -> None:
+        with tempfile.NamedTemporaryFile(suffix=".plot", delete=False) as f:
+            temp_path = f.name
+        try:
+            with pytest.raises(Exception) as exc_info:
+                get_prover_from_file(temp_path)
+            assert not isinstance(exc_info.value, NotImplementedError)
+        finally:
+            Path(temp_path).unlink()
+
+    def test_unsupported_file_extension_raises_value_error(self) -> None:
+        with pytest.raises(ValueError, match="Unsupported plot file"):
+            get_prover_from_file("/nonexistent/path/test.txt")
+
+
+# TODO: todo_v2_plots enable these tests once we have test plots we can load
+@pytest.mark.skip("we don't have v2 test plots yet")
+class TestV2Prover:
     def test_v2_prover_init_with_nonexistent_file(self) -> None:
-        prover = V2Prover("/nonexistent/path/test.plot2")
+        prover = V2Prover.from_filename("/nonexistent/path/test.plot2")
         assert prover.get_version() == PlotVersion.V2
         assert prover.get_filename() == "/nonexistent/path/test.plot2"
 
-    def test_v2_prover_get_size_raises_error(self) -> None:
-        prover = V2Prover("/nonexistent/path/test.plot2")
+    def test_v2_prover_get_param_raises_error(self) -> None:
+        prover = V2Prover.from_filename("/nonexistent/path/test.plot2")
         with pytest.raises(NotImplementedError, match="V2 plot format is not yet implemented"):
-            prover.get_size()
+            prover.get_param()
 
     def test_v2_prover_get_memo_raises_error(self) -> None:
-        prover = V2Prover("/nonexistent/path/test.plot2")
+        prover = V2Prover.from_filename("/nonexistent/path/test.plot2")
         with pytest.raises(NotImplementedError, match="V2 plot format is not yet implemented"):
             prover.get_memo()
 
     def test_v2_prover_get_compression_level(self) -> None:
-        prover = V2Prover("/nonexistent/path/test.plot2")
+        prover = V2Prover.from_filename("/nonexistent/path/test.plot2")
         assert prover.get_compression_level() == uint8(0)
 
     def test_v2_prover_get_id_raises_error(self) -> None:
-        prover = V2Prover("/nonexistent/path/test.plot2")
+        prover = V2Prover.from_filename("/nonexistent/path/test.plot2")
         with pytest.raises(NotImplementedError, match="V2 plot format is not yet implemented"):
             prover.get_id()
 
     def test_v2_prover_get_qualities_for_challenge_raises_error(self) -> None:
-        prover = V2Prover("/nonexistent/path/test.plot2")
+        prover = V2Prover.from_filename("/nonexistent/path/test.plot2")
         with pytest.raises(
             AssertionError, match="V2 plot format does not support qualities directly, use partial proofs"
         ):
-            prover.get_qualities_for_challenge(bytes32(b"1" * 32))
-
-    def test_v2_prover_get_full_proof_raises_error(self) -> None:
-        prover = V2Prover("/nonexistent/path/test.plot2")
-        with pytest.raises(AssertionError, match="V2 plot format require solver to get full proof"):
-            prover.get_full_proof(bytes32(b"1" * 32), 0)
+            prover.get_qualities_for_challenge(bytes32(b"1" * 32), uint8(5))
 
     def test_v2_prover_bytes_raises_error(self) -> None:
-        prover = V2Prover("/nonexistent/path/test.plot2")
+        prover = V2Prover.from_filename("/nonexistent/path/test.plot2")
         with pytest.raises(NotImplementedError, match="V2 plot format is not yet implemented"):
             bytes(prover)
 
@@ -61,21 +74,7 @@ class TestProver:
         prover = get_prover_from_file("/nonexistent/path/test.plot2")
         assert prover.get_version() == PlotVersion.V2
         with pytest.raises(NotImplementedError, match="V2 plot format is not yet implemented"):
-            prover.get_size()
-
-    def test_get_prover_from_file_with_plot1_still_works(self) -> None:
-        with tempfile.NamedTemporaryFile(suffix=".plot", delete=False) as f:
-            temp_path = f.name
-        try:
-            with pytest.raises(Exception) as exc_info:
-                get_prover_from_file(temp_path)
-            assert not isinstance(exc_info.value, NotImplementedError)
-        finally:
-            Path(temp_path).unlink()
-
-    def test_unsupported_file_extension_raises_value_error(self) -> None:
-        with pytest.raises(ValueError, match="Unsupported plot file"):
-            get_prover_from_file("/nonexistent/path/test.txt")
+            prover.get_param()
 
 
 class TestV1Prover:
@@ -87,13 +86,6 @@ class TestV1Prover:
 
 
 class TestGetProverFromBytes:
-    def test_get_prover_from_bytes_v2_plot(self) -> None:
-        with patch("chia.plotting.prover.V2Prover.from_bytes") as mock_v2_from_bytes:
-            mock_prover = MagicMock()
-            mock_v2_from_bytes.return_value = mock_prover
-            result = get_prover_from_bytes("test.plot2", b"test_data")
-            assert result == mock_prover
-
     def test_get_prover_from_bytes_v1_plot(self) -> None:
         with patch("chia.plotting.prover.DiskProver") as mock_disk_prover_class:
             mock_disk_prover = MagicMock()
@@ -102,5 +94,5 @@ class TestGetProverFromBytes:
             assert isinstance(result, V1Prover)
 
     def test_get_prover_from_bytes_unsupported_extension(self) -> None:
-        with pytest.raises(ValueError, match="Unsupported plot file"):
+        with pytest.raises((RuntimeError, ValueError)):
             get_prover_from_bytes("test.txt", b"test_data")

chia/_tests/pools/test_pool_cmdline.py

@@ -4,7 +4,7 @@ import json
 import re
 from dataclasses import dataclass
 from io import StringIO
-from typing import Optional, cast
+from typing import cast
 
 import click
 import pytest
@@ -59,8 +59,8 @@ pytestmark = [pytest.mark.limit_consensus_modes(reason="irrelevant")]
 class StateUrlCase:
     id: str
     state: str
-    pool_url: Optional[str]
-    expected_error: Optional[str] = None
+    pool_url: str | None
+    expected_error: str | None = None
     marks: Marks = ()
 
 
@@ -992,9 +992,7 @@ async def test_plotnft_cli_misc(mocker: MockerFixture, consensus_mode: Consensus
         )
 
     # Test fall-through raise in create
-    mocker.patch.object(
-        test_rpc_client, "create_new_pool_wallet", create=True, side_effect=ValueError("Injected error")
-    )
+    mocker.patch.object(test_rpc_client, "create_new_wallet", create=True, side_effect=ValueError("Injected error"))
     with pytest.raises(CliRpcConnectionError, match="Error creating plot NFT: Injected error"):
         await create(
             wallet_info=WalletClientInfo(client=cast(WalletRpcClient, test_rpc_client), fingerprint=0, config=dict()),