chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7rc2__py3-none-any.whl

chia/_tests/conftest.py

@@ -50,19 +50,14 @@ from chia._tests.util.setup_nodes import (
 from chia._tests.util.spend_sim import CostLogger
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.farmer.farmer_rpc_client import FarmerRpcClient
+from chia.farmer.farmer_service import FarmerService
 from chia.full_node.full_node_api import FullNodeAPI
+from chia.full_node.full_node_service import FullNodeService
 from chia.harvester.harvester_rpc_client import HarvesterRpcClient
+from chia.harvester.harvester_service import HarvesterService
+from chia.seeder.crawler_service import CrawlerService
 from chia.seeder.dns_server import DNSServer
-from chia.server.aliases import (
-    CrawlerService,
-    FarmerService,
-    FullNodeService,
-    HarvesterService,
-    TimelordService,
-    WalletService,
-)
 from chia.server.server import ChiaServer
-from chia.server.start_service import Service
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.setup_services import (
     setup_crawler,
@@ -70,11 +65,14 @@ from chia.simulator.setup_services import (
     setup_full_node,
     setup_introducer,
     setup_seeder,
+    setup_solver,
     setup_timelord,
 )
 from chia.simulator.start_simulator import SimulatorFullNodeService
 from chia.simulator.wallet_tools import WalletTool
-from chia.types.peer_info import PeerInfo
+from chia.solver.solver_service import SolverService
+from chia.timelord.timelord_service import TimelordService
+from chia.types.peer_info import PeerInfo, UnresolvedPeerInfo
 from chia.util.config import create_default_chia_config, lock_and_load_config
 from chia.util.db_wrapper import generate_in_memory_db_uri
 from chia.util.keychain import Keychain
@@ -82,6 +80,7 @@ from chia.util.task_timing import main as task_instrumentation_main
 from chia.util.task_timing import start_task_instrumentation, stop_task_instrumentation
 from chia.wallet.wallet_node import WalletNode
 from chia.wallet.wallet_rpc_client import WalletRpcClient
+from chia.wallet.wallet_service import WalletService
 
 # TODO: review how this is now after other imports and before some stdlib imports...  :[
 # Set spawn after stdlib imports, but before other imports
@@ -93,7 +92,7 @@ from pathlib import Path
 from chia_rs.sized_ints import uint128
 
 from chia._tests.environments.wallet import WalletEnvironment, WalletState, WalletTestFramework
-from chia._tests.util.setup_nodes import setup_farmer_multi_harvester
+from chia._tests.util.setup_nodes import setup_farmer_solver_multi_harvester
 from chia.full_node.full_node_rpc_client import FullNodeRpcClient
 from chia.simulator.block_tools import BlockTools, create_block_tools_async, test_constants
 from chia.simulator.keyring import TempKeyring
@@ -233,8 +232,8 @@ def blockchain_constants(consensus_mode: ConsensusMode) -> ConsensusConstants:
 @pytest.fixture(scope="session", name="bt")
 async def block_tools_fixture(get_keychain, blockchain_constants, anyio_backend) -> BlockTools:
     # Note that this causes a lot of CPU and disk traffic - disk, DB, ports, process creation ...
-    _shared_block_tools = await create_block_tools_async(constants=blockchain_constants, keychain=get_keychain)
-    return _shared_block_tools
+    shared_block_tools = await create_block_tools_async(constants=blockchain_constants, keychain=get_keychain)
+    return shared_block_tools
 
 
 # if you have a system that has an unusual hostname for localhost and you want
@@ -790,7 +789,7 @@ async def three_nodes_two_wallets(blockchain_constants: ConsensusConstants):
 @pytest.fixture(scope="function")
 async def one_node(
     blockchain_constants: ConsensusConstants,
-) -> AsyncIterator[tuple[list[Service], list[FullNodeSimulator], BlockTools]]:
+) -> AsyncIterator[tuple[list[SimulatorFullNodeService], list[WalletService], BlockTools]]:
     async with setup_simulators_and_wallets_service(1, 0, blockchain_constants) as _:
         yield _
 
@@ -867,7 +866,7 @@ async def farmer_one_harvester_simulator_wallet(
     ]
 ]:
     async with setup_simulators_and_wallets_service(1, 1, blockchain_constants) as (nodes, wallets, bt):
-        async with setup_farmer_multi_harvester(bt, 1, tmp_path, bt.constants, start_services=True) as (
+        async with setup_farmer_solver_multi_harvester(bt, 1, tmp_path, bt.constants, start_services=True) as (
             harvester_services,
             farmer_service,
             _,
@@ -880,31 +879,54 @@ FarmerOneHarvester = tuple[list[HarvesterService], FarmerService, BlockTools]
 
 @pytest.fixture(scope="function")
 async def farmer_one_harvester(tmp_path: Path, get_b_tools: BlockTools) -> AsyncIterator[FarmerOneHarvester]:
-    async with setup_farmer_multi_harvester(get_b_tools, 1, tmp_path, get_b_tools.constants, start_services=True) as _:
+    async with setup_farmer_solver_multi_harvester(
+        get_b_tools, 1, tmp_path, get_b_tools.constants, start_services=True
+    ) as _:
         yield _
 
 
+FarmerOneHarvesterSolver = tuple[list[HarvesterService], FarmerService, SolverService, BlockTools]
+
+
+@pytest.fixture(scope="function")
+async def farmer_one_harvester_solver(
+    tmp_path: Path, get_b_tools: BlockTools
+) -> AsyncIterator[FarmerOneHarvesterSolver]:
+    async with setup_solver(tmp_path / "solver", get_b_tools, get_b_tools.constants) as solver_service:
+        solver_peer = UnresolvedPeerInfo(get_b_tools.config["self_hostname"], solver_service._server.get_port())
+        async with setup_farmer_solver_multi_harvester(
+            get_b_tools, 1, tmp_path, get_b_tools.constants, start_services=True, solver_peer=solver_peer
+        ) as (harvester_services, farmer_service, bt):
+            yield harvester_services, farmer_service, solver_service, bt
+
+
 @pytest.fixture(scope="function")
 async def farmer_one_harvester_not_started(
     tmp_path: Path, get_b_tools: BlockTools
-) -> AsyncIterator[tuple[list[Service], Service]]:
-    async with setup_farmer_multi_harvester(get_b_tools, 1, tmp_path, get_b_tools.constants, start_services=False) as _:
+) -> AsyncIterator[tuple[list[HarvesterService], FarmerService, BlockTools]]:
+    async with setup_farmer_solver_multi_harvester(
+        get_b_tools, 1, tmp_path, get_b_tools.constants, start_services=False
+    ) as _:
         yield _
 
 
 @pytest.fixture(scope="function")
 async def farmer_two_harvester_not_started(
     tmp_path: Path, get_b_tools: BlockTools
-) -> AsyncIterator[tuple[list[Service], Service]]:
-    async with setup_farmer_multi_harvester(get_b_tools, 2, tmp_path, get_b_tools.constants, start_services=False) as _:
+) -> AsyncIterator[tuple[list[HarvesterService], FarmerService, BlockTools]]:
+    async with setup_farmer_solver_multi_harvester(
+        get_b_tools, 2, tmp_path, get_b_tools.constants, start_services=False
+    ) as _:
         yield _
 
 
 @pytest.fixture(scope="function")
 async def farmer_three_harvester_not_started(
     tmp_path: Path, get_b_tools: BlockTools
-) -> AsyncIterator[tuple[list[Service], Service]]:
-    async with setup_farmer_multi_harvester(get_b_tools, 3, tmp_path, get_b_tools.constants, start_services=False) as _:
+) -> AsyncIterator[tuple[list[HarvesterService], FarmerService, BlockTools]]:
+    async with setup_farmer_solver_multi_harvester(
+        get_b_tools, 3, tmp_path, get_b_tools.constants, start_services=False
+    ) as _:
         yield _
 
 
@@ -1285,10 +1307,13 @@ async def farmer_harvester_2_simulators_zero_bits_plot_filter(
             )
             for index in range(len(bts))
         ]
-
-        [harvester_service], farmer_service, _ = await async_exit_stack.enter_async_context(
-            setup_farmer_multi_harvester(bt, 1, tmp_path, bt.constants, start_services=True)
-        )
+        async with setup_solver(tmp_path / "solver", bt, bt.constants) as solver_service:
+            solver_peer = UnresolvedPeerInfo(bt.config["self_hostname"], solver_service._server.get_port())
+            [harvester_service], farmer_service, _ = await async_exit_stack.enter_async_context(
+                setup_farmer_solver_multi_harvester(
+                    bt, 1, tmp_path, bt.constants, start_services=True, solver_peer=solver_peer
+                )
+            )
 
         yield farmer_service, harvester_service, simulators[0], simulators[1], bt
 

chia/_tests/core/cmds/test_wallet.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any
 
 import pytest
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
 from chia.cmds.wallet_funcs import print_offer_summary
+from chia.wallet.wallet_request_types import CATAssetIDToName, CATAssetIDToNameResponse
 
 TEST_DUCKSAUCE_ASSET_ID = "1000000000000000000000000000000000000000000000000000000000000001"
 TEST_CRUNCHBERRIES_ASSET_ID = "1000000000000000000000000000000000000000000000000000000000000002"
@@ -19,8 +20,8 @@ TEST_ASSET_ID_NAME_MAPPING: dict[bytes32, tuple[uint32, str]] = {
 }
 
 
-async def cat_name_resolver(asset_id: bytes32) -> Optional[tuple[Optional[uint32], str]]:
-    return TEST_ASSET_ID_NAME_MAPPING.get(asset_id)
+async def cat_name_resolver(request: CATAssetIDToName) -> CATAssetIDToNameResponse:
+    return CATAssetIDToNameResponse(*TEST_ASSET_ID_NAME_MAPPING.get(request.asset_id, (None, None)))
 
 
 @pytest.mark.anyio

chia/_tests/core/consensus/test_pot_iterations.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import pytest
 from chia_rs import PlotSize
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64, uint128
 from pytest import raises
@@ -7,7 +8,6 @@ from pytest import raises
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.consensus.pos_quality import _expected_plot_size
 from chia.consensus.pot_iterations import (
-    PHASE_OUT_PERIOD,
     calculate_ip_iters,
     calculate_iterations_quality,
     calculate_phase_out,
@@ -68,7 +68,7 @@ class TestPotIterations:
         ip_iters = calculate_ip_iters(test_constants, ssi, uint8(13), required_iters)
         assert ip_iters == sp_iters + test_constants.NUM_SP_INTERVALS_EXTRA * sp_interval_iters + required_iters
 
-        required_iters = uint64(int(ssi * 4 / 300))
+        required_iters = uint64(ssi * 4 / 300)
         ip_iters = calculate_ip_iters(test_constants, ssi, uint8(13), required_iters)
         assert ip_iters == sp_iters + test_constants.NUM_SP_INTERVALS_EXTRA * sp_interval_iters + required_iters
         assert sp_iters < ip_iters
@@ -84,65 +84,96 @@ class TestPotIterations:
         assert ip_iters == (sp_iters + test_constants.NUM_SP_INTERVALS_EXTRA * sp_interval_iters + required_iters) % ssi
         assert sp_iters > ip_iters
 
-    def test_win_percentage(self):
+    @pytest.mark.parametrize(
+        "height",
+        [
+            uint32(0),
+            test_constants.HARD_FORK2_HEIGHT - 1,
+            test_constants.HARD_FORK2_HEIGHT,
+            test_constants.HARD_FORK2_HEIGHT + test_constants.PLOT_V1_PHASE_OUT,
+            test_constants.HARD_FORK2_HEIGHT + test_constants.PLOT_V1_PHASE_OUT + 1,
+        ],
+    )
+    def test_win_percentage(self, height: uint32):
         """
         Tests that the percentage of blocks won is proportional to the space of each farmer,
         with the assumption that all farmers have access to the same VDF speed.
         """
         farmer_ks = {
-            uint8(32): 100,
-            uint8(33): 100,
-            uint8(34): 100,
-            uint8(35): 100,
-            uint8(36): 100,
+            PlotSize.make_v1(32): 100,
+            PlotSize.make_v1(33): 100,
+            PlotSize.make_v1(34): 100,
+            PlotSize.make_v1(35): 100,
+            PlotSize.make_v1(36): 100,
+            PlotSize.make_v2(28): 200,
+            PlotSize.make_v2(30): 200,
+            PlotSize.make_v2(32): 200,
         }
-        farmer_space = {k: _expected_plot_size(uint8(k)) * count for k, count in farmer_ks.items()}
-        total_space = sum(farmer_space.values())
-        percentage_space = {k: float(sp / total_space) for k, sp in farmer_space.items()}
+        farmer_space = {k: _expected_plot_size(k) * count for k, count in farmer_ks.items()}
         wins = {k: 0 for k in farmer_ks.keys()}
+
+        constants = test_constants.replace(DIFFICULTY_CONSTANT_FACTOR=uint128(2**25))
         total_slots = 50
         num_sps = 16
-        sp_interval_iters = uint64(100000000 // 32)
+        sub_slot_iters = uint64(100000000)
+        sp_interval_iters = calculate_sp_interval_iters(constants, sub_slot_iters)
         difficulty = uint64(500000000000)
-        constants = test_constants.replace(DIFFICULTY_CONSTANT_FACTOR=uint128(2**25))
         for slot_index in range(total_slots):
             total_wins_in_slot = 0
             for sp_index in range(num_sps):
                 sp_hash = std_hash(slot_index.to_bytes(4, "big") + sp_index.to_bytes(4, "big"))
                 for k, count in farmer_ks.items():
                     for farmer_index in range(count):
-                        quality = std_hash(slot_index.to_bytes(4, "big") + k.to_bytes(1, "big") + bytes(farmer_index))
-                        # TODO: todo_v2_plots
+                        plot_k_val = k.size_v1 if k.size_v2 is None else k.size_v2
+                        assert plot_k_val is not None
+                        quality = std_hash(
+                            slot_index.to_bytes(4, "big") + plot_k_val.to_bytes(1, "big") + bytes(farmer_index)
+                        )
                         required_iters = calculate_iterations_quality(
-                            constants, quality, PlotSize.make_v1(k), difficulty, sp_hash, uint64(100000000), uint32(0)
+                            constants, quality, k, difficulty, sp_hash, sub_slot_iters, height
                         )
                         if required_iters < sp_interval_iters:
                             wins[k] += 1
                             total_wins_in_slot += 1
 
+        if height < test_constants.HARD_FORK2_HEIGHT + test_constants.PLOT_V1_PHASE_OUT:
+            total_space = sum(farmer_space.values())
+            percentage_space = {k: float(sp / total_space) for k, sp in farmer_space.items()}
+        else:
+            # after the phase-out, v1 plots don't count
+            # all wins are by v2 plots
+            total_space = sum(0 if k.size_v2 is None else sp for k, sp in farmer_space.items())
+            percentage_space = {
+                k: 0.0 if k.size_v2 is None else float(sp / total_space) for k, sp in farmer_space.items()
+            }
+
         win_percentage = {k: wins[k] / sum(wins.values()) for k in farmer_ks.keys()}
         for k in farmer_ks.keys():
             # Win rate is proportional to percentage of space
             assert abs(win_percentage[k] - percentage_space[k]) < 0.01
 
-    def test_calculate_phase_out(self):
+    @pytest.mark.parametrize("sp_interval", [uint64(6250000000), uint64(1), uint64(2), uint64(10), uint64(10000000000)])
+    def test_calculate_phase_out(self, sp_interval: uint64):
         constants = test_constants
-        sub_slot_iters = uint64(100000000000)
-        sp_interval = calculate_sp_interval_iters(constants, sub_slot_iters)
+        sub_slot_iters = uint64(sp_interval * constants.NUM_SPS_SUB_SLOT)
         # Before or at HARD_FORK2_HEIGHT, should return 0
-        assert calculate_phase_out(constants, sub_slot_iters, constants.HARD_FORK2_HEIGHT - 1) == 0
+        assert calculate_phase_out(constants, sub_slot_iters, uint32(constants.HARD_FORK2_HEIGHT - 1)) == 0
         assert calculate_phase_out(constants, sub_slot_iters, constants.HARD_FORK2_HEIGHT) == 0
         # after HARD_FORK2_HEIGHT, should return value = delta/phase_out_period * sp_interval
         assert (
-            calculate_phase_out(constants, sub_slot_iters, constants.HARD_FORK2_HEIGHT + 1)
-            == sp_interval // PHASE_OUT_PERIOD
+            calculate_phase_out(constants, sub_slot_iters, uint32(constants.HARD_FORK2_HEIGHT + 1))
+            == sp_interval // constants.PLOT_V1_PHASE_OUT
         )
         assert (
-            calculate_phase_out(constants, sub_slot_iters, constants.HARD_FORK2_HEIGHT + PHASE_OUT_PERIOD // 2)
+            calculate_phase_out(
+                constants, sub_slot_iters, uint32(constants.HARD_FORK2_HEIGHT + constants.PLOT_V1_PHASE_OUT // 2)
+            )
             == sp_interval // 2
         )
         assert (
-            calculate_phase_out(constants, sub_slot_iters, constants.HARD_FORK2_HEIGHT + PHASE_OUT_PERIOD)
+            calculate_phase_out(
+                constants, sub_slot_iters, uint32(constants.HARD_FORK2_HEIGHT + constants.PLOT_V1_PHASE_OUT)
+            )
             == sp_interval
         )
 
@@ -150,3 +181,19 @@ class TestPotIterations:
         max_uint32_height = uint32(0xFFFFFFFF)
         result_max_height = calculate_phase_out(constants, sub_slot_iters, max_uint32_height)
         assert result_max_height == sp_interval  # Should cap at sp_interval
+
+
+def test_expected_plot_size_v1() -> None:
+    last_size = 2_400_000
+    for k in range(18, 50):
+        plot_size = _expected_plot_size(PlotSize.make_v1(k))
+        assert plot_size > last_size * 2
+        last_size = plot_size
+
+
+def test_expected_plot_size_v2() -> None:
+    last_size = 100_000
+    for k in range(16, 32, 2):
+        plot_size = _expected_plot_size(PlotSize.make_v2(k))
+        assert plot_size > last_size * 2
+        last_size = plot_size

chia/_tests/core/custom_types/test_proof_of_space.py

@@ -5,15 +5,17 @@ from dataclasses import dataclass
 from typing import Optional
 
 import pytest
-from chia_rs import G1Element, PlotSize, ProofOfSpace
+from chia_rs import G1Element, PlotSize
 from chia_rs.sized_bytes import bytes32, bytes48
 from chia_rs.sized_ints import uint8, uint32
 
 from chia._tests.util.misc import Marks, datacases
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.types.blockchain_format.proof_of_space import (
-    calculate_plot_difficulty,
     calculate_prefix_bits,
+    calculate_required_plot_strength,
+    check_plot_size,
+    make_pos,
     passes_plot_filter,
     verify_and_get_quality_string,
 )
@@ -23,7 +25,7 @@ from chia.types.blockchain_format.proof_of_space import (
 class ProofOfSpaceCase:
     id: str
     pos_challenge: bytes32
-    plot_size: uint8
+    plot_size: PlotSize
     plot_public_key: G1Element
     pool_public_key: Optional[G1Element] = None
     pool_contract_puzzle_hash: Optional[bytes32] = None
@@ -45,14 +47,14 @@ def b32(key: str) -> bytes32:
     ProofOfSpaceCase(
         id="Neither pool public key nor pool contract puzzle hash",
         pos_challenge=bytes32(b"1" * 32),
-        plot_size=uint8(0),
+        plot_size=PlotSize.make_v1(0),
         plot_public_key=G1Element(),
         expected_error="Expected pool public key or pool contract puzzle hash but got neither",
     ),
     ProofOfSpaceCase(
         id="Both pool public key and pool contract puzzle hash",
         pos_challenge=bytes32(b"1" * 32),
-        plot_size=uint8(0),
+        plot_size=PlotSize.make_v1(0),
         plot_public_key=G1Element(),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"1" * 32),
@@ -61,7 +63,7 @@ def b32(key: str) -> bytes32:
     ProofOfSpaceCase(
         id="Lower than minimum plot size",
         pos_challenge=bytes32(b"1" * 32),
-        plot_size=uint8(31),
+        plot_size=PlotSize.make_v1(31),
         plot_public_key=G1Element(),
         pool_public_key=G1Element(),
         expected_error="Plot size is lower than the minimum",
@@ -69,7 +71,7 @@ def b32(key: str) -> bytes32:
     ProofOfSpaceCase(
         id="Higher than maximum plot size",
         pos_challenge=bytes32(b"1" * 32),
-        plot_size=uint8(51),
+        plot_size=PlotSize.make_v1(51),
         plot_public_key=G1Element(),
         pool_public_key=G1Element(),
         expected_error="Plot size is higher than the maximum",
@@ -77,7 +79,7 @@ def b32(key: str) -> bytes32:
     ProofOfSpaceCase(
         id="Different challenge",
         pos_challenge=bytes32(b"1" * 32),
-        plot_size=uint8(42),
+        plot_size=PlotSize.make_v1(42),
         pool_public_key=G1Element(),
         plot_public_key=G1Element(),
         expected_error="Calculated pos challenge doesn't match the provided one",
@@ -85,7 +87,7 @@ def b32(key: str) -> bytes32:
     ProofOfSpaceCase(
         id="Not passing the plot filter with size 9",
         pos_challenge=b32("08b23cc2844dfb92d2eedaa705a1ce665d571ee753bd81cbb67b92caa6d34722"),
-        plot_size=uint8(42),
+        plot_size=PlotSize.make_v1(42),
         pool_public_key=g1(
             "b6449c2c68df97c19e884427e42ee7350982d4020571ead08732615ff39bd216bfd630b6460784982bec98b49fea79d0"
         ),
@@ -98,7 +100,7 @@ def b32(key: str) -> bytes32:
     ProofOfSpaceCase(
         id="Passing the plot filter with size 8",
         pos_challenge=b32("08b23cc2844dfb92d2eedaa705a1ce665d571ee753bd81cbb67b92caa6d34722"),
-        plot_size=uint8(42),
+        plot_size=PlotSize.make_v1(42),
         pool_public_key=g1(
             "b6449c2c68df97c19e884427e42ee7350982d4020571ead08732615ff39bd216bfd630b6460784982bec98b49fea79d0"
         ),
@@ -110,7 +112,7 @@ def b32(key: str) -> bytes32:
     ProofOfSpaceCase(
         id="v2 plot size 0",
         pos_challenge=bytes32(b"1" * 32),
-        plot_size=uint8(0x80),
+        plot_size=PlotSize.make_v2(0),
         plot_public_key=G1Element(),
         pool_public_key=G1Element(),
         expected_error="Plot size is lower than the minimum",
@@ -118,7 +120,7 @@ def b32(key: str) -> bytes32:
     ProofOfSpaceCase(
         id="v2 plot size 34",
         pos_challenge=bytes32(b"1" * 32),
-        plot_size=uint8(0x80 | 34),
+        plot_size=PlotSize.make_v2(34),
         plot_public_key=G1Element(),
         pool_public_key=G1Element(),
         expected_error="Plot size is higher than the maximum",
@@ -126,7 +128,7 @@ def b32(key: str) -> bytes32:
     ProofOfSpaceCase(
         id="Not passing the plot filter v2",
         pos_challenge=b32("3d29ea79d19b3f7e99ebf764ae53697cbe143603909873946af6ab1ece606861"),
-        plot_size=uint8(0x80 | 32),
+        plot_size=PlotSize.make_v2(32),
         pool_public_key=g1(
             "b6449c2c68df97c19e884427e42ee7350982d4020571ead08732615ff39bd216bfd630b6460784982bec98b49fea79d0"
         ),
@@ -137,7 +139,7 @@ def b32(key: str) -> bytes32:
     ),
 )
 def test_verify_and_get_quality_string(caplog: pytest.LogCaptureFixture, case: ProofOfSpaceCase) -> None:
-    pos = ProofOfSpace(
+    pos = make_pos(
         challenge=case.pos_challenge,
         pool_public_key=case.pool_public_key,
         pool_contract_puzzle_hash=case.pool_contract_puzzle_hash,
@@ -159,7 +161,7 @@ def test_verify_and_get_quality_string(caplog: pytest.LogCaptureFixture, case: P
 @datacases(
     ProofOfSpaceCase(
         id="v2 plot are not implemented",
-        plot_size=uint8(0x80 | 30),
+        plot_size=PlotSize.make_v2(30),
         pos_challenge=b32("47deb938e145d25d7b3b3c85ca9e3972b76c01aeeb78a02fe5d3b040d282317e"),
         plot_public_key=g1(
             "afa3aaf09c03885154be49216ee7fb2e4581b9c4a4d7e9cc402e27280bf0cfdbdf1b9ba674e301fd1d1450234b3b1868"
@@ -171,7 +173,7 @@ def test_verify_and_get_quality_string(caplog: pytest.LogCaptureFixture, case: P
     ),
 )
 def test_verify_and_get_quality_string_v2(caplog: pytest.LogCaptureFixture, case: ProofOfSpaceCase) -> None:
-    pos = ProofOfSpace(
+    pos = make_pos(
         challenge=case.pos_challenge,
         pool_public_key=case.pool_public_key,
         pool_contract_puzzle_hash=case.pool_contract_puzzle_hash,
@@ -199,26 +201,54 @@ def test_verify_and_get_quality_string_v2(caplog: pytest.LogCaptureFixture, case
 
 
 @pytest.mark.parametrize(
-    "height, difficulty",
+    "height, strength",
     [
         (0, 2),
         (DEFAULT_CONSTANTS.HARD_FORK_HEIGHT, 2),
         (DEFAULT_CONSTANTS.HARD_FORK2_HEIGHT, 2),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_4_HEIGHT - 1, 2),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_4_HEIGHT, 4),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_5_HEIGHT - 1, 4),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_5_HEIGHT, 5),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_6_HEIGHT - 1, 5),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_6_HEIGHT, 6),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_7_HEIGHT - 1, 6),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_7_HEIGHT, 7),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_8_HEIGHT - 1, 7),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_8_HEIGHT, 8),
-        (DEFAULT_CONSTANTS.PLOT_DIFFICULTY_8_HEIGHT + 1000000, 8),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_4_HEIGHT - 1, 2),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_4_HEIGHT, 4),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_5_HEIGHT - 1, 4),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_5_HEIGHT, 5),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_6_HEIGHT - 1, 5),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_6_HEIGHT, 6),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_7_HEIGHT - 1, 6),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_7_HEIGHT, 7),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_8_HEIGHT - 1, 7),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_8_HEIGHT, 8),
+        (DEFAULT_CONSTANTS.PLOT_STRENGTH_8_HEIGHT + 1000000, 8),
     ],
 )
-def test_calculate_plot_difficulty(height: uint32, difficulty: uint8) -> None:
-    assert calculate_plot_difficulty(DEFAULT_CONSTANTS, height) == difficulty
+def test_calculate_plot_strength(height: uint32, strength: uint8) -> None:
+    assert calculate_required_plot_strength(DEFAULT_CONSTANTS, height) == strength
+
+
+@pytest.mark.parametrize(
+    "size, valid",
+    [
+        (PlotSize.make_v1(31), False),  # too small
+        (PlotSize.make_v1(32), True),
+        (PlotSize.make_v1(33), True),
+        (PlotSize.make_v1(34), True),
+        (PlotSize.make_v1(35), True),
+        (PlotSize.make_v1(36), True),
+        (PlotSize.make_v1(37), True),
+        (PlotSize.make_v1(49), True),
+        (PlotSize.make_v1(50), True),
+        (PlotSize.make_v1(51), False),  # too large
+        (PlotSize.make_v2(26), False),  # too small
+        (PlotSize.make_v2(27), False),  # too small (and odd)
+        (PlotSize.make_v2(28), True),
+        (PlotSize.make_v2(29), False),  # odd
+        (PlotSize.make_v2(30), True),
+        (PlotSize.make_v2(31), False),  # odd
+        (PlotSize.make_v2(32), True),
+        (PlotSize.make_v2(33), False),  # too large (and odd)
+        (PlotSize.make_v2(34), False),  # too large
+    ],
+)
+def test_check_plot_size(size: PlotSize, valid: bool) -> None:
+    assert check_plot_size(DEFAULT_CONSTANTS, size) == valid
 
 
 class TestProofOfSpace:

chia/_tests/core/custom_types/test_spend_bundle.py

@@ -28,10 +28,7 @@ class TestStructStream(unittest.TestCase):
 
 
 def rand_hash(rng: random.Random) -> bytes32:
-    ret = bytearray(32)
-    for i in range(32):
-        ret[i] = rng.getrandbits(8)
-    return bytes32(ret)
+    return bytes32.random(r=rng)
 
 
 def create_spends(num: int) -> tuple[list[CoinSpend], list[Coin]]:

chia/_tests/core/data_layer/conftest.py

@@ -61,8 +61,13 @@ def store_id_fixture() -> bytes32:
 
 
 @pytest.fixture(name="raw_data_store", scope="function")
-async def raw_data_store_fixture(database_uri: str) -> AsyncIterable[DataStore]:
-    async with DataStore.managed(database=database_uri, uri=True) as store:
+async def raw_data_store_fixture(database_uri: str, tmp_path: pathlib.Path) -> AsyncIterable[DataStore]:
+    async with DataStore.managed(
+        database=database_uri,
+        uri=True,
+        merkle_blobs_path=tmp_path.joinpath("merkle-blobs"),
+        key_value_blobs_path=tmp_path.joinpath("key-value-blobs"),
+    ) as store:
         yield store