chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.6.0rc2__py3-none-any.whl

chia/_tests/core/cmds/test_beta.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 import zipfile
+from collections.abc import Callable
 from pathlib import Path
-from typing import Callable, Optional
 
 import pytest
 from click.testing import CliRunner, Result
@@ -26,7 +26,7 @@ def configure(root_path: Path, *args: str) -> Result:
     )
 
 
-def configure_interactive(root_path: Path, user_input: Optional[str] = None) -> Result:
+def configure_interactive(root_path: Path, user_input: str | None = None) -> Result:
     return CliRunner().invoke(
         cli,
         [
@@ -53,7 +53,7 @@ def enable(root_path: Path, *args: str) -> Result:
     )
 
 
-def enable_interactive(root_path: Path, user_input: Optional[str] = None) -> Result:
+def enable_interactive(root_path: Path, user_input: str | None = None) -> Result:
     return CliRunner().invoke(
         cli,
         [
@@ -66,7 +66,7 @@ def enable_interactive(root_path: Path, user_input: Optional[str] = None) -> Res
     )
 
 
-def prepare_submission(root_path: Path, user_input: Optional[str] = None) -> Result:
+def prepare_submission(root_path: Path, user_input: str | None = None) -> Result:
     return CliRunner().invoke(
         cli,
         [

chia/_tests/core/cmds/test_keys.py

@@ -4,7 +4,6 @@ import json
 import os
 import re
 from pathlib import Path
-from typing import Optional
 
 import pytest
 from click.testing import CliRunner, Result
@@ -54,7 +53,7 @@ def setup_keyringwrapper(tmp_path):
     KeyringWrapper.set_keys_root_path(DEFAULT_KEYS_ROOT_PATH)
 
 
-def assert_label(keychain: Keychain, label: Optional[str], index: int) -> None:
+def assert_label(keychain: Keychain, label: str | None, index: int) -> None:
     all_keys = keychain.get_keys()
     assert len(all_keys) > index
     assert all_keys[index].label == label
@@ -200,7 +199,7 @@ class TestKeysCommands:
         ],
     )
     def test_generate_and_add_label_parameter(
-        self, cmd_params: list[str], label: Optional[str], input_str: Optional[str], tmp_path, empty_keyring
+        self, cmd_params: list[str], label: str | None, input_str: str | None, tmp_path, empty_keyring
     ):
         keychain = empty_keyring
         keys_root_path = keychain.keyring_wrapper.keys_root_path

chia/_tests/core/cmds/test_wallet.py

@@ -26,7 +26,7 @@ async def cat_name_resolver(request: CATAssetIDToName) -> CATAssetIDToNameRespon
 
 @pytest.mark.anyio
 async def test_print_offer_summary_xch(capsys: Any) -> None:
-    summary_dict = {"xch": 1_000_000_000_000}
+    summary_dict = {"xch": str(1_000_000_000_000)}
 
     await print_offer_summary(cat_name_resolver, summary_dict)
 
@@ -38,7 +38,7 @@ async def test_print_offer_summary_xch(capsys: Any) -> None:
 @pytest.mark.anyio
 async def test_print_offer_summary_cat(capsys: Any) -> None:
     summary_dict = {
-        TEST_DUCKSAUCE_ASSET_ID: 1_000,
+        TEST_DUCKSAUCE_ASSET_ID: str(1_000),
     }
 
     await print_offer_summary(cat_name_resolver, summary_dict)
@@ -51,8 +51,8 @@ async def test_print_offer_summary_cat(capsys: Any) -> None:
 @pytest.mark.anyio
 async def test_print_offer_summary_multiple_cats(capsys: Any) -> None:
     summary_dict = {
-        TEST_DUCKSAUCE_ASSET_ID: 1_000,
-        TEST_CRUNCHBERRIES_ASSET_ID: 2_000,
+        TEST_DUCKSAUCE_ASSET_ID: str(1_000),
+        TEST_CRUNCHBERRIES_ASSET_ID: str(2_000),
     }
 
     await print_offer_summary(cat_name_resolver, summary_dict)
@@ -66,10 +66,10 @@ async def test_print_offer_summary_multiple_cats(capsys: Any) -> None:
 @pytest.mark.anyio
 async def test_print_offer_summary_xch_and_cats(capsys: Any) -> None:
     summary_dict = {
-        "xch": 2_500_000_000_000,
-        TEST_DUCKSAUCE_ASSET_ID: 1_111,
-        TEST_CRUNCHBERRIES_ASSET_ID: 2_222,
-        TEST_UNICORNTEARS_ASSET_ID: 3_333,
+        "xch": str(2_500_000_000_000),
+        TEST_DUCKSAUCE_ASSET_ID: str(1_111),
+        TEST_CRUNCHBERRIES_ASSET_ID: str(2_222),
+        TEST_UNICORNTEARS_ASSET_ID: str(3_333),
     }
 
     await print_offer_summary(cat_name_resolver, summary_dict)
@@ -85,10 +85,10 @@ async def test_print_offer_summary_xch_and_cats(capsys: Any) -> None:
 @pytest.mark.anyio
 async def test_print_offer_summary_xch_and_cats_with_zero_values(capsys: Any) -> None:
     summary_dict = {
-        "xch": 0,
-        TEST_DUCKSAUCE_ASSET_ID: 0,
-        TEST_CRUNCHBERRIES_ASSET_ID: 0,
-        TEST_UNICORNTEARS_ASSET_ID: 0,
+        "xch": str(0),
+        TEST_DUCKSAUCE_ASSET_ID: str(0),
+        TEST_CRUNCHBERRIES_ASSET_ID: str(0),
+        TEST_UNICORNTEARS_ASSET_ID: str(0),
     }
 
     await print_offer_summary(cat_name_resolver, summary_dict)
@@ -104,8 +104,8 @@ async def test_print_offer_summary_xch_and_cats_with_zero_values(capsys: Any) ->
 @pytest.mark.anyio
 async def test_print_offer_summary_cat_with_fee_and_change(capsys: Any) -> None:
     summary_dict = {
-        TEST_DUCKSAUCE_ASSET_ID: 1_000,
-        "unknown": 3_456,
+        TEST_DUCKSAUCE_ASSET_ID: str(1_000),
+        "unknown": str(3_456),
     }
 
     await print_offer_summary(cat_name_resolver, summary_dict, has_fee=True)
@@ -118,7 +118,7 @@ async def test_print_offer_summary_cat_with_fee_and_change(capsys: Any) -> None:
 
 @pytest.mark.anyio
 async def test_print_offer_summary_xch_with_one_mojo(capsys: Any) -> None:
-    summary_dict = {"xch": 1}
+    summary_dict = {"xch": str(1)}
 
     await print_offer_summary(cat_name_resolver, summary_dict)
 

chia/_tests/core/consensus/test_pot_iterations.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-import pytest
-from chia_rs import PlotSize
+from chia_rs import PlotParam
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64, uint128
 from pytest import raises
 
@@ -10,7 +9,6 @@ from chia.consensus.pos_quality import _expected_plot_size
 from chia.consensus.pot_iterations import (
     calculate_ip_iters,
     calculate_iterations_quality,
-    calculate_phase_out,
     calculate_sp_interval_iters,
     calculate_sp_iters,
     is_overflow_block,
@@ -84,32 +82,22 @@ class TestPotIterations:
         assert ip_iters == (sp_iters + test_constants.NUM_SP_INTERVALS_EXTRA * sp_interval_iters + required_iters) % ssi
         assert sp_iters > ip_iters
 
-    @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):
+    def test_win_percentage(self):
         """
         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 = {
-            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,
+            PlotParam.make_v1(32): 100,
+            PlotParam.make_v1(33): 100,
+            PlotParam.make_v1(34): 100,
+            PlotParam.make_v1(35): 100,
+            PlotParam.make_v1(36): 100,
+            PlotParam.make_v2(2): 200,
+            PlotParam.make_v2(3): 200,
+            PlotParam.make_v2(4): 200,
         }
-        farmer_space = {k: _expected_plot_size(k) * count for k, count in farmer_ks.items()}
+        farmer_space = {k: _expected_plot_size(k, test_constants) * 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))
@@ -124,76 +112,34 @@ class TestPotIterations:
                 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):
-                        plot_k_val = k.size_v1 if k.size_v2 is None else k.size_v2
+                        plot_k_val = k.size_v1 if k.size_v1 is not None else constants.PLOT_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, k, difficulty, sp_hash, sub_slot_iters, height
-                        )
+                        required_iters = calculate_iterations_quality(constants, quality, k, difficulty, sp_hash)
                         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()
-            }
+        total_space = sum(farmer_space.values())
+        percentage_space = {k: 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
 
-    @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(sp_interval * constants.NUM_SPS_SUB_SLOT)
-        # Before or at HARD_FORK2_HEIGHT, should return 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, uint32(constants.HARD_FORK2_HEIGHT + 1))
-            == sp_interval // constants.PLOT_V1_PHASE_OUT
-        )
-        assert (
-            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, uint32(constants.HARD_FORK2_HEIGHT + constants.PLOT_V1_PHASE_OUT)
-            )
-            == sp_interval
-        )
-
-        # Test with maximum uint32 height to ensure no overflow
-        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))
+        plot_size = _expected_plot_size(PlotParam.make_v1(k), test_constants)
         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
+    for strength in [2, 3, 4, 5, 6, 7]:
+        plot_size = _expected_plot_size(PlotParam.make_v2(strength), test_constants)
+        assert plot_size == 988_513_566

chia/_tests/core/custom_types/test_proof_of_space.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
+import logging
 import random
 from dataclasses import dataclass
-from typing import Optional
 
 import pytest
-from chia_rs import G1Element, PlotSize
+from chia_rs import G1Element, PlotParam
 from chia_rs.sized_bytes import bytes32, bytes48
 from chia_rs.sized_ints import uint8, uint32
 
@@ -13,9 +13,10 @@ 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_prefix_bits,
-    calculate_required_plot_strength,
-    check_plot_size,
+    check_plot_param,
+    is_v1_phased_out,
     make_pos,
+    num_phase_out_epochs,
     passes_plot_filter,
     verify_and_get_quality_string,
 )
@@ -25,12 +26,12 @@ from chia.types.blockchain_format.proof_of_space import (
 class ProofOfSpaceCase:
     id: str
     pos_challenge: bytes32
-    plot_size: PlotSize
+    plot_size: PlotParam
     plot_public_key: G1Element
-    pool_public_key: Optional[G1Element] = None
-    pool_contract_puzzle_hash: Optional[bytes32] = None
-    height: uint32 = uint32(0)
-    expected_error: Optional[str] = None
+    pool_public_key: G1Element | None = None
+    pool_contract_puzzle_hash: bytes32 | None = None
+    height: uint32 = DEFAULT_CONSTANTS.HARD_FORK2_HEIGHT
+    expected_error: str | None = None
     marks: Marks = ()
 
 
@@ -47,14 +48,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=PlotSize.make_v1(0),
+        plot_size=PlotParam.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=PlotSize.make_v1(0),
+        plot_size=PlotParam.make_v1(0),
         plot_public_key=G1Element(),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"1" * 32),
@@ -63,23 +64,23 @@ def b32(key: str) -> bytes32:
     ProofOfSpaceCase(
         id="Lower than minimum plot size",
         pos_challenge=bytes32(b"1" * 32),
-        plot_size=PlotSize.make_v1(31),
+        plot_size=PlotParam.make_v1(31),
         plot_public_key=G1Element(),
         pool_public_key=G1Element(),
-        expected_error="Plot size is lower than the minimum",
+        expected_error="Plot size (31) is lower than the minimum (32)",
     ),
     ProofOfSpaceCase(
         id="Higher than maximum plot size",
         pos_challenge=bytes32(b"1" * 32),
-        plot_size=PlotSize.make_v1(51),
+        plot_size=PlotParam.make_v1(51),
         plot_public_key=G1Element(),
         pool_public_key=G1Element(),
-        expected_error="Plot size is higher than the maximum",
+        expected_error="Plot size (51) is higher than the maximum (50)",
     ),
     ProofOfSpaceCase(
         id="Different challenge",
         pos_challenge=bytes32(b"1" * 32),
-        plot_size=PlotSize.make_v1(42),
+        plot_size=PlotParam.make_v1(42),
         pool_public_key=G1Element(),
         plot_public_key=G1Element(),
         expected_error="Calculated pos challenge doesn't match the provided one",
@@ -87,7 +88,7 @@ def b32(key: str) -> bytes32:
     ProofOfSpaceCase(
         id="Not passing the plot filter with size 9",
         pos_challenge=b32("08b23cc2844dfb92d2eedaa705a1ce665d571ee753bd81cbb67b92caa6d34722"),
-        plot_size=PlotSize.make_v1(42),
+        plot_size=PlotParam.make_v1(42),
         pool_public_key=g1(
             "b6449c2c68df97c19e884427e42ee7350982d4020571ead08732615ff39bd216bfd630b6460784982bec98b49fea79d0"
         ),
@@ -100,7 +101,7 @@ def b32(key: str) -> bytes32:
     ProofOfSpaceCase(
         id="Passing the plot filter with size 8",
         pos_challenge=b32("08b23cc2844dfb92d2eedaa705a1ce665d571ee753bd81cbb67b92caa6d34722"),
-        plot_size=PlotSize.make_v1(42),
+        plot_size=PlotParam.make_v1(42),
         pool_public_key=g1(
             "b6449c2c68df97c19e884427e42ee7350982d4020571ead08732615ff39bd216bfd630b6460784982bec98b49fea79d0"
         ),
@@ -110,35 +111,51 @@ def b32(key: str) -> bytes32:
         height=uint32(5496000),
     ),
     ProofOfSpaceCase(
-        id="v2 plot size 0",
+        id="v2 plot strength 0",
         pos_challenge=bytes32(b"1" * 32),
-        plot_size=PlotSize.make_v2(0),
+        plot_size=PlotParam.make_v2(0),
+        pool_contract_puzzle_hash=bytes32(b"1" * 32),
         plot_public_key=G1Element(),
-        pool_public_key=G1Element(),
-        expected_error="Plot size is lower than the minimum",
+        expected_error="Plot strength (0) is lower than the minimum (2)",
     ),
     ProofOfSpaceCase(
-        id="v2 plot size 34",
+        id="v2 plot strength 33",
         pos_challenge=bytes32(b"1" * 32),
-        plot_size=PlotSize.make_v2(34),
+        plot_size=PlotParam.make_v2(33),
+        pool_contract_puzzle_hash=bytes32(b"1" * 32),
         plot_public_key=G1Element(),
-        pool_public_key=G1Element(),
-        expected_error="Plot size is higher than the maximum",
+        expected_error="Plot strength (33) is too high (max is 32)",
     ),
     ProofOfSpaceCase(
         id="Not passing the plot filter v2",
-        pos_challenge=b32("3d29ea79d19b3f7e99ebf764ae53697cbe143603909873946af6ab1ece606861"),
-        plot_size=PlotSize.make_v2(32),
-        pool_public_key=g1(
-            "b6449c2c68df97c19e884427e42ee7350982d4020571ead08732615ff39bd216bfd630b6460784982bec98b49fea79d0"
-        ),
+        pos_challenge=b32("4cfaacbd2782db64d07cf490ca938534adb07dfbd2f92b0e479e2e5b196178db"),
+        plot_size=PlotParam.make_v2(32),
+        pool_contract_puzzle_hash=bytes32(b"1" * 32),
         plot_public_key=g1(
             "879526b4e7b616cfd64984d8ad140d0798b048392a6f11e2faf09054ef467ea44dc0dab5e5edb2afdfa850c5c8b629cc"
         ),
         expected_error="Did not pass the plot filter",
     ),
+    ProofOfSpaceCase(
+        id="v2 not activated",
+        pos_challenge=bytes32(b"1" * 32),
+        plot_size=PlotParam.make_v2(2),
+        pool_contract_puzzle_hash=bytes32(b"1" * 32),
+        plot_public_key=G1Element(),
+        height=uint32(DEFAULT_CONSTANTS.HARD_FORK2_HEIGHT - 1),
+        expected_error="v2 proof support has not yet activated",
+    ),
+    ProofOfSpaceCase(
+        id="v2 plot with pool pk",
+        pos_challenge=bytes32(b"1" * 32),
+        plot_size=PlotParam.make_v2(2),
+        plot_public_key=G1Element(),
+        pool_public_key=G1Element(),
+        expected_error="v2 plots require pool_contract_puzzle_hash, pool public key is not supported",
+    ),
 )
 def test_verify_and_get_quality_string(caplog: pytest.LogCaptureFixture, case: ProofOfSpaceCase) -> None:
+    caplog.set_level(logging.INFO)
     pos = make_pos(
         challenge=case.pos_challenge,
         pool_public_key=case.pool_public_key,
@@ -153,6 +170,7 @@ def test_verify_and_get_quality_string(caplog: pytest.LogCaptureFixture, case: P
         original_challenge_hash=b32("0x73490e166d0b88347c37d921660b216c27316aae9a3450933d3ff3b854e5831a"),
         signage_point=b32("0x7b3e23dbd438f9aceefa9827e2c5538898189987f49b06eceb7a43067e77b531"),
         height=case.height,
+        prev_transaction_block_height=case.height,
     )
     assert quality_string is None
     assert len(caplog.text) == 0 if case.expected_error is None else case.expected_error in caplog.text
@@ -160,17 +178,16 @@ def test_verify_and_get_quality_string(caplog: pytest.LogCaptureFixture, case: P
 
 @datacases(
     ProofOfSpaceCase(
-        id="v2 plot are not implemented",
-        plot_size=PlotSize.make_v2(30),
-        pos_challenge=b32("47deb938e145d25d7b3b3c85ca9e3972b76c01aeeb78a02fe5d3b040d282317e"),
+        id="not passing the plot filter v2",
+        plot_size=PlotParam.make_v2(2),
+        pos_challenge=b32("aefba5c94bc9bbfe2c538b7faaaf03384ac5a6170e40b024657df6b0a27c34a7"),
         plot_public_key=g1(
             "afa3aaf09c03885154be49216ee7fb2e4581b9c4a4d7e9cc402e27280bf0cfdbdf1b9ba674e301fd1d1450234b3b1868"
         ),
-        pool_public_key=g1(
-            "b6449c2c68df97c19e884427e42ee7350982d4020571ead08732615ff39bd216bfd630b6460784982bec98b49fea79d0"
-        ),
-        expected_error="NotImplementedError",
+        pool_contract_puzzle_hash=bytes32(b"1" * 32),
+        expected_error="Did not pass the plot filter",
     ),
+    # TODO: todo_v2_plots add test case that passes the plot filter
 )
 def test_verify_and_get_quality_string_v2(caplog: pytest.LogCaptureFixture, case: ProofOfSpaceCase) -> None:
     pos = make_pos(
@@ -181,16 +198,17 @@ def test_verify_and_get_quality_string_v2(caplog: pytest.LogCaptureFixture, case
         version_and_size=case.plot_size,
         proof=b"1",
     )
-    size = pos.size()
-    assert size.size_v2 is not None
-    assert size.size_v1 is None
+    plot_param = pos.param()
+    assert plot_param.strength_v2 is not None
+    assert plot_param.size_v1 is None
     try:
         quality_string = verify_and_get_quality_string(
             pos=pos,
             constants=DEFAULT_CONSTANTS,
             original_challenge_hash=b32("0x73490e166d0b88347c37d921660b216c27316aae9a3450933d3ff3b854e5831a"),
-            signage_point=b32("0x7b3e23dbd438f9aceefa9827e2c5538898189987f49b06eceb7a43067e77b531"),
+            signage_point=b32("0xf7c1bd874da5e709d4713d60c8a70639eb1167b367a9c3787c65c1e582e2e662"),
             height=case.height,
+            prev_transaction_block_height=case.height,
         )
     except NotImplementedError as e:
         assert case.expected_error is not None
@@ -201,54 +219,27 @@ def test_verify_and_get_quality_string_v2(caplog: pytest.LogCaptureFixture, case
 
 
 @pytest.mark.parametrize(
-    "height, strength",
+    "plot_param, valid",
     [
-        (0, 2),
-        (DEFAULT_CONSTANTS.HARD_FORK_HEIGHT, 2),
-        (DEFAULT_CONSTANTS.HARD_FORK2_HEIGHT, 2),
-        (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),
+        (PlotParam.make_v1(31), False),  # too small
+        (PlotParam.make_v1(32), True),
+        (PlotParam.make_v1(33), True),
+        (PlotParam.make_v1(34), True),
+        (PlotParam.make_v1(35), True),
+        (PlotParam.make_v1(36), True),
+        (PlotParam.make_v1(37), True),
+        (PlotParam.make_v1(49), True),
+        (PlotParam.make_v1(50), True),
+        (PlotParam.make_v1(51), False),  # too large
+        (PlotParam.make_v2(1), False),  # too small
+        (PlotParam.make_v2(2), True),
+        (PlotParam.make_v2(3), True),
+        (PlotParam.make_v2(32), True),
+        (PlotParam.make_v2(33), False),  # strength too high
     ],
 )
-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
+def test_check_plot_param(plot_param: PlotParam, valid: bool) -> None:
+    assert check_plot_param(DEFAULT_CONSTANTS, plot_param) == valid
 
 
 class TestProofOfSpace:
@@ -272,12 +263,9 @@ class TestProofOfSpace:
 
 
 @pytest.mark.parametrize("height,expected", [(0, 3), (5496000, 2), (10542000, 1), (15592000, 0), (20643000, 0)])
-@pytest.mark.parametrize("plot_size", [PlotSize.make_v1(32), PlotSize.make_v2(28)])
-def test_calculate_prefix_bits_clamp_zero(height: uint32, expected: int, plot_size: PlotSize) -> None:
+def test_calculate_prefix_bits_clamp_zero_v1(height: uint32, expected: int) -> None:
     constants = DEFAULT_CONSTANTS.replace(NUMBER_ZERO_BITS_PLOT_FILTER_V1=uint8(3))
-    if plot_size.size_v2 is not None:
-        expected = constants.NUMBER_ZERO_BITS_PLOT_FILTER_V2
-    assert calculate_prefix_bits(constants, height, plot_size) == expected
+    assert calculate_prefix_bits(constants, height, PlotParam.make_v1(32)) == expected
 
 
 @pytest.mark.parametrize(
@@ -294,9 +282,47 @@ def test_calculate_prefix_bits_clamp_zero(height: uint32, expected: int, plot_si
         (20643000, 5),
     ],
 )
-@pytest.mark.parametrize("plot_size", [PlotSize.make_v1(32), PlotSize.make_v2(28)])
-def test_calculate_prefix_bits_default(height: uint32, expected: int, plot_size: PlotSize) -> None:
-    constants = DEFAULT_CONSTANTS
-    if plot_size.size_v2 is not None:
-        expected = DEFAULT_CONSTANTS.NUMBER_ZERO_BITS_PLOT_FILTER_V2
-    assert calculate_prefix_bits(constants, height, plot_size) == expected
+def test_calculate_prefix_bits_v1(height: uint32, expected: int) -> None:
+    assert calculate_prefix_bits(DEFAULT_CONSTANTS, height, PlotParam.make_v1(32)) == expected
+
+
+@pytest.mark.parametrize(
+    argnames=["height", "expected"],
+    argvalues=[
+        (0, 5),
+        (0xFFFFFFFA, 5),
+        (0xFFFFFFFB, 4),
+        (0xFFFFFFFC, 3),
+        (0xFFFFFFFD, 2),
+        (0xFFFFFFFF, 2),
+    ],
+)
+def test_calculate_prefix_bits_v2(height: uint32, expected: int) -> None:
+    assert calculate_prefix_bits(DEFAULT_CONSTANTS, height, PlotParam.make_v2(28)) == expected
+
+
+def test_v1_phase_out() -> None:
+    constants = DEFAULT_CONSTANTS.replace(HARD_FORK2_HEIGHT=uint32(500000))
+    rng = random.Random()
+
+    phase_out_epochs = num_phase_out_epochs(constants)
+    print(f"phase-out epochs: {phase_out_epochs}")
+
+    for epoch in range(-5, phase_out_epochs + 5):
+        prev_tx_height = uint32(constants.HARD_FORK2_HEIGHT + epoch * constants.EPOCH_BLOCKS)
+        num_phased_out = 0
+        rng.seed(1337)
+        for i in range(1000):
+            proof = rng.randbytes(32)
+            if is_v1_phased_out(proof, prev_tx_height, constants):
+                num_phased_out += 1
+
+        expect = min(1.0, max(0.0, epoch / phase_out_epochs))
+
+        print(
+            f"height: {prev_tx_height} "
+            f"epoch: {epoch} "
+            f"phased-out: {num_phased_out / 10:0.2f}% "
+            f"expect: {expect * 100.0:0.2f}%"
+        )
+        assert abs((num_phased_out / 1000) - expect) < 0.05