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

chia/simulator/block_tools.py

@@ -10,11 +10,14 @@ import ssl
 import sys
 import tempfile
 import time
-from collections.abc import Sequence
+from collections.abc import AsyncIterator, Callable, Iterator, Sequence
+from contextlib import asynccontextmanager, contextmanager
 from dataclasses import dataclass, replace
+from functools import lru_cache
 from pathlib import Path
 from random import Random
-from typing import Any, Callable, Optional, Union
+from types import TracebackType
+from typing import Any
 
 import anyio
 from chia_puzzles_py.programs import CHIALISP_DESERIALISATION, ROM_BOOTSTRAP_GENERATOR
@@ -37,9 +40,12 @@ from chia_rs import (
     SubSlotProofs,
     UnfinishedBlock,
     solution_generator,
+    solve_proof,
 )
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64, uint128
+from filelock import FileLock
+from typing_extensions import Self
 
 from chia.consensus.block_creation import create_unfinished_block, unfinished_block_to_full_block
 from chia.consensus.block_record import BlockRecordProtocol
@@ -49,6 +55,7 @@ from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.consensus.deficit import calculate_deficit
 from chia.consensus.full_block_to_block_record import block_to_block_record
+from chia.consensus.get_block_challenge import pre_sp_tx_block_height
 from chia.consensus.make_sub_epoch_summary import next_sub_epoch_summary
 from chia.consensus.pot_iterations import (
     calculate_ip_iters,
@@ -62,9 +69,10 @@ from chia.consensus.signage_point import SignagePoint
 from chia.consensus.vdf_info_computation import get_signage_point_vdf_info
 from chia.daemon.keychain_proxy import KeychainProxy, connect_to_keychain_and_validate, wrap_local_keychain
 from chia.full_node.bundle_tools import simple_solution_generator, simple_solution_generator_backrefs
+from chia.plotting.cache import cached_master_sk_to_local_sk
 from chia.plotting.create_plots import PlotKeys, create_plots
 from chia.plotting.manager import PlotManager
-from chia.plotting.prover import PlotVersion
+from chia.plotting.prover import PlotVersion, QualityProtocol, V1Prover, V2Prover, V2Quality
 from chia.plotting.util import (
     Params,
     PlotRefreshEvents,
@@ -92,13 +100,12 @@ from chia.types.blockchain_format.program import DEFAULT_FLAGS, INFINITE_COST, P
 from chia.types.blockchain_format.proof_of_space import (
     calculate_pos_challenge,
     calculate_prefix_bits,
-    calculate_required_plot_strength,
     generate_plot_public_key,
     generate_taproot_sk,
+    is_v1_phased_out,
     make_pos,
+    num_phase_out_epochs,
     passes_plot_filter,
-    quality_for_partial_proof,
-    solve_proof,
 )
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
@@ -120,7 +127,6 @@ from chia.util.keychain import Keychain, bytes_to_mnemonic
 from chia.util.timing import adjusted_timeout, backoff_times
 from chia.wallet.derive_keys import (
     master_sk_to_farmer_sk,
-    master_sk_to_local_sk,
     master_sk_to_pool_sk,
     master_sk_to_wallet_sk,
 )
@@ -132,14 +138,13 @@ GENERATOR_MOD: SerializedProgram = SerializedProgram.from_bytes(ROM_BOOTSTRAP_GE
 
 test_constants = DEFAULT_CONSTANTS.replace(
     MIN_PLOT_SIZE_V1=uint8(18),
-    # TODO: todo_v2_plots decide on v2 test plot k-size
-    MIN_PLOT_SIZE_V2=uint8(18),
+    PLOT_SIZE_V2=uint8(18),
     MIN_BLOCKS_PER_CHALLENGE_BLOCK=uint8(12),
     DIFFICULTY_STARTING=uint64(2**10),
     DISCRIMINANT_SIZE_BITS=uint16(16),
     SUB_EPOCH_BLOCKS=uint32(170),
     WEIGHT_PROOF_THRESHOLD=uint8(2),
-    WEIGHT_PROOF_RECENT_BLOCKS=uint32(380),
+    WEIGHT_PROOF_RECENT_BLOCKS=uint32(500),
     DIFFICULTY_CONSTANT_FACTOR=uint128(33554432),
     NUM_SPS_SUB_SLOT=uint8(16),  # Must be a power of 2
     MAX_SUB_SLOT_BLOCKS=uint32(50),
@@ -154,9 +159,15 @@ test_constants = DEFAULT_CONSTANTS.replace(
     # Allows creating blockchains with timestamps up to 10 days in the future, for testing
     MAX_FUTURE_TIME2=uint32(3600 * 24 * 10),
     MEMPOOL_BLOCK_BUFFER=uint8(6),
+    PLOT_V1_PHASE_OUT_EPOCH_BITS=uint8(3),
 )
 
 
+@lru_cache
+def cached_master_sk_to_farmer_sk(master: PrivateKey) -> PrivateKey:
+    return master_sk_to_farmer_sk(master)
+
+
 def compute_additions_unchecked(sb: SpendBundle) -> list[Coin]:
     ret: list[Coin] = []
     for cs in sb.coin_spends:
@@ -246,9 +257,9 @@ class BlockTools:
     def __init__(
         self,
         constants: ConsensusConstants = test_constants,
-        root_path: Optional[Path] = None,
-        keychain: Optional[Keychain] = None,
-        config_overrides: Optional[dict[str, Any]] = None,
+        root_path: Path | None = None,
+        keychain: Keychain | None = None,
+        config_overrides: dict[str, Any] | None = None,
         automated_testing: bool = True,
         plot_dir: str = "test-plots",
         log: logging.Logger = logging.getLogger(__name__),
@@ -257,7 +268,7 @@ class BlockTools:
 
         self._tempdir = None
         if root_path is None:
-            self._tempdir = tempfile.TemporaryDirectory()
+            self._tempdir = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
             root_path = Path(self._tempdir.name)
 
         self.root_path = root_path
@@ -340,64 +351,90 @@ class BlockTools:
                 assert self.total_result.processed == update_result.processed
                 assert self.total_result.duration == update_result.duration
                 assert update_result.remaining == 0
+
+                expected_plots: set[str] = set()
+                found_plots: set[str] = set()
+                if len(self.plot_manager.plots) != len(self.expected_plots):  # pragma: no cover
+                    for pid, filename in self.expected_plots.items():
+                        expected_plots.add(filename.name)
+                    for filename, _ in self.plot_manager.plots.items():
+                        found_plots.add(filename.name)
+                    print(f"directory: {self.plot_dir}")
+                    print(f"expected: {len(expected_plots)}")
+                    for f in expected_plots:
+                        print(f)
+                    print(f"plot manager: {len(found_plots)}")
+                    for f in found_plots:
+                        print(f)
+                    diff = found_plots.difference(expected_plots)
+                    print(f"found unexpected: {len(diff)}")
+                    for f in diff:
+                        print(f)
+                    diff = expected_plots.difference(found_plots)
+                    print(f"not found: {len(diff)}")
+                    for f in diff:
+                        print(f)
                 assert len(self.plot_manager.plots) == len(self.expected_plots)
 
         self.plot_manager: PlotManager = PlotManager(
             self.root_path,
             refresh_parameter=PlotsRefreshParameter(batch_size=uint32(2)),
             refresh_callback=test_callback,
+            constants=self.constants,
             match_str=str(self.plot_dir.relative_to(DEFAULT_ROOT_PATH.parent)) if not automated_testing else None,
         )
 
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        if self._tempdir is not None:
+            self._tempdir.cleanup()
+
     def setup_new_gen(
         self,
-        tx_block_heights: list[uint32],
+        generator_block_heights: list[uint32],
         curr: BlockRecordProtocol,
-        wallet: Optional[WalletTool],
-        rng: Optional[random.Random],
+        wallet: WalletTool | None,
+        rng: random.Random | None,
         available_coins: list[Coin],
         *,
         prev_tx_height: uint32,
         dummy_block_references: bool,
         include_transactions: bool,
-        transaction_data: Optional[SpendBundle],
+        block_generator: NewBlockGenerator | None,
         block_refs: list[uint32],
-    ) -> Optional[NewBlockGenerator]:
+    ) -> NewBlockGenerator | None:
+        if prev_tx_height >= self.constants.HARD_FORK2_HEIGHT:
+            assert block_refs == [], "block references are not allowed after hard fork 2"
+            dummy_block_references = False
+
         # we don't know if the new block will be a transaction
         # block or not, so even though we prepare a block
         # generator, we can't update our state (like,
         # available_coins) until it's confirmed the block
         # generator made it into the block.
         dummy_refs: list[uint32]
-        if dummy_block_references and len(tx_block_heights) > 4:
+        if dummy_block_references and len(generator_block_heights) > 4:
             dummy_refs = [
-                tx_block_heights[1],
-                tx_block_heights[len(tx_block_heights) // 2],
-                tx_block_heights[-2],
+                generator_block_heights[1],
+                generator_block_heights[len(generator_block_heights) // 2],
+                generator_block_heights[-2],
             ]
         else:
             dummy_refs = []
 
-        if transaction_data is not None:
-            # this means the caller passed in transaction_data
+        if block_generator is not None:
+            # this means the caller passed in block_generator
             # to be included in the block.
-            additions = compute_additions_unchecked(transaction_data)
-            removals = transaction_data.removals()
-            if curr.height >= self.constants.HARD_FORK_HEIGHT:
-                program = simple_solution_generator_backrefs(transaction_data).program
-            else:
-                program = simple_solution_generator(transaction_data).program
-            block_refs = []
-            cost = compute_block_cost(program, self.constants, uint32(curr.height + 1), prev_tx_height)
-            return NewBlockGenerator(
-                program,
-                [],
-                block_refs,
-                transaction_data.aggregated_signature,
-                additions,
-                removals,
-                cost,
-            )
+            assert block_refs == [], "block references cannot be combined with block_generator"
+            assert not dummy_block_references, "(dummy) block references cannot be combined with block_generator"
+            return block_generator
 
         if include_transactions:
             # if the caller did not pass in specific
@@ -426,8 +463,8 @@ class BlockTools:
 
         return None
 
-    async def setup_keys(self, fingerprint: Optional[int] = None, reward_ph: Optional[bytes32] = None) -> None:
-        keychain_proxy: Optional[KeychainProxy]
+    async def setup_keys(self, fingerprint: int | None = None, reward_ph: bytes32 | None = None) -> None:
+        keychain_proxy: KeychainProxy | None
         try:
             if self.local_keychain:
                 keychain_proxy = wrap_local_keychain(self.local_keychain, log=self.log)
@@ -454,7 +491,7 @@ class BlockTools:
                 assert sk is not None
                 self.pool_master_sk = sk
 
-            self.farmer_pk = master_sk_to_farmer_sk(self.farmer_master_sk).get_g1()
+            self.farmer_pk = cached_master_sk_to_farmer_sk(self.farmer_master_sk).get_g1()
             self.pool_pk = master_sk_to_pool_sk(self.pool_master_sk).get_g1()
 
             if reward_ph is None:
@@ -473,7 +510,7 @@ class BlockTools:
                 self.all_sks = [self.farmer_master_sk]  # we only want to include plots under the same fingerprint
             self.pool_pubkeys: list[G1Element] = [master_sk_to_pool_sk(sk).get_g1() for sk in self.all_sks]
 
-            self.farmer_pubkeys: list[G1Element] = [master_sk_to_farmer_sk(sk).get_g1() for sk in self.all_sks]
+            self.farmer_pubkeys: list[G1Element] = [cached_master_sk_to_farmer_sk(sk).get_g1() for sk in self.all_sks]
             if len(self.pool_pubkeys) == 0 or len(self.farmer_pubkeys) == 0:
                 raise RuntimeError("Keys not generated. Run `chia keys generate`")
 
@@ -502,41 +539,48 @@ class BlockTools:
         num_non_keychain_plots: int = 3,
         plot_size: int = 20,
         bitfield: bool = True,
+        testrun_uid: str | None = None,
     ) -> bool:
-        self.add_plot_directory(self.plot_dir)
-        assert self.created_plots == 0
-        existing_plots: bool = True
-        # OG Plots
-        for i in range(num_og_plots):
-            plot = await self.new_plot(plot_size=plot_size, bitfield=bitfield)
-            if plot.new_plot:
-                existing_plots = False
-        # Pool Plots
-        for i in range(num_pool_plots):
-            plot = await self.new_plot(self.pool_ph, plot_size=plot_size, bitfield=bitfield)
-            if plot.new_plot:
-                existing_plots = False
-        # Some plots with keys that are not in the keychain
-        for i in range(num_non_keychain_plots):
-            plot = await self.new_plot(
-                path=self.plot_dir / "not_in_keychain",
-                plot_keys=PlotKeys(G1Element(), G1Element(), None),
-                exclude_plots=True,
-                plot_size=plot_size,
-                bitfield=bitfield,
-            )
-            if plot.new_plot:
-                existing_plots = False
-        await self.refresh_plots()
-        assert len(self.plot_manager.plots) == len(self.expected_plots)
-        return existing_plots
+        if testrun_uid is None:
+            lock_file_name = self.plot_dir / ".lockfile"
+        else:
+            lock_file_name = self.plot_dir / (testrun_uid + ".lockfile")
+
+        with FileLock(lock_file_name):
+            self.add_plot_directory(self.plot_dir)
+            assert self.created_plots == 0
+            existing_plots: bool = True
+            # OG Plots
+            for i in range(num_og_plots):
+                plot = await self.new_plot(plot_size=plot_size, bitfield=bitfield)
+                if plot.new_plot:
+                    existing_plots = False
+            # Pool Plots
+            for i in range(num_pool_plots):
+                plot = await self.new_plot(self.pool_ph, plot_size=plot_size, bitfield=bitfield)
+                if plot.new_plot:
+                    existing_plots = False
+            # Some plots with keys that are not in the keychain
+            for i in range(num_non_keychain_plots):
+                plot = await self.new_plot(
+                    path=self.plot_dir / "not_in_keychain",
+                    plot_keys=PlotKeys(G1Element(), G1Element(), None),
+                    exclude_plots=True,
+                    plot_size=plot_size,
+                    bitfield=bitfield,
+                )
+                if plot.new_plot:
+                    existing_plots = False
+            await self.refresh_plots()
+            assert len(self.plot_manager.plots) == len(self.expected_plots)
+            return existing_plots
 
     async def new_plot(
         self,
-        pool_contract_puzzle_hash: Optional[bytes32] = None,
-        path: Optional[Path] = None,
-        tmp_dir: Optional[Path] = None,
-        plot_keys: Optional[PlotKeys] = None,
+        pool_contract_puzzle_hash: bytes32 | None = None,
+        path: Path | None = None,
+        tmp_dir: Path | None = None,
+        plot_keys: PlotKeys | None = None,
         exclude_plots: bool = False,
         plot_size: int = 20,
         bitfield: bool = True,
@@ -565,8 +609,8 @@ class BlockTools:
         )
         try:
             if plot_keys is None:
-                pool_pk: Optional[G1Element] = None
-                pool_address: Optional[str] = None
+                pool_pk: G1Element | None = None
+                pool_address: str | None = None
                 if pool_contract_puzzle_hash is None:
                     pool_pk = self.pool_pk
                 else:
@@ -582,8 +626,8 @@ class BlockTools:
             )
             self.created_plots += 1
 
-            plot_id_new: Optional[bytes32] = None
-            path_new: Optional[Path] = None
+            plot_id_new: bytes32 | None = None
+            path_new: Path | None = None
             new_plot: bool = True
 
             if len(created):
@@ -645,7 +689,7 @@ class BlockTools:
         """
         Returns the plot signature of the header data.
         """
-        farmer_sk = master_sk_to_farmer_sk(self.all_sks[0])
+        farmer_sk = cached_master_sk_to_farmer_sk(self.all_sks[0])
         for plot_info in self.plot_manager.plots.values():
             if plot_pk == plot_info.plot_public_key:
                 # Look up local_sk from plot to save locked memory
@@ -659,7 +703,7 @@ class BlockTools:
                 else:
                     assert isinstance(pool_pk_or_ph, bytes32)
                     include_taproot = True
-                local_sk = master_sk_to_local_sk(local_master_sk)
+                local_sk = cached_master_sk_to_local_sk(local_master_sk)
                 agg_pk = generate_plot_public_key(local_sk.get_g1(), farmer_sk.get_g1(), include_taproot)
                 assert agg_pk == plot_pk
                 harv_share = AugSchemeMPL.sign(local_sk, m, agg_pk)
@@ -673,7 +717,7 @@ class BlockTools:
 
         raise ValueError(f"Do not have key {plot_pk}")
 
-    def get_pool_key_signature(self, pool_target: PoolTarget, pool_pk: Optional[G1Element]) -> Optional[G2Element]:
+    def get_pool_key_signature(self, pool_target: PoolTarget, pool_pk: G1Element | None) -> G2Element | None:
         # Returns the pool signature for the corresponding pk. If no pk is provided, returns None.
         if pool_pk is None:
             return None
@@ -693,13 +737,13 @@ class BlockTools:
     def get_consecutive_blocks(
         self,
         num_blocks: int,
-        block_list_input: Optional[list[FullBlock]] = None,
+        block_list_input: list[FullBlock] | None = None,
         *,
-        farmer_reward_puzzle_hash: Optional[bytes32] = None,
-        pool_reward_puzzle_hash: Optional[bytes32] = None,
-        transaction_data: Optional[SpendBundle] = None,
+        farmer_reward_puzzle_hash: bytes32 | None = None,
+        pool_reward_puzzle_hash: bytes32 | None = None,
+        transaction_data: SpendBundle | None = None,
         seed: bytes = b"",
-        time_per_block: Optional[float] = None,
+        time_per_block: float | None = None,
         force_overflow: bool = False,
         skip_slots: int = 0,  # Force at least this number of empty slots before the first SB
         guarantee_transaction_block: bool = False,  # Force that this block must be a tx block
@@ -710,8 +754,8 @@ class BlockTools:
         normalized_to_identity_cc_ip: bool = False,
         current_time: bool = False,
         block_refs: list[uint32] = [],
-        genesis_timestamp: Optional[uint64] = None,
-        force_plot_id: Optional[bytes32] = None,
+        genesis_timestamp: uint64 | None = None,
+        force_plot_id: bytes32 | None = None,
         dummy_block_references: bool = False,
         include_transactions: bool = False,
         skip_overflow: bool = False,
@@ -725,13 +769,17 @@ class BlockTools:
         else:
             block_list = []
 
-        tx_block_heights: list[uint32] = []
+        # these are heights of blocks that have transactions generators. Note
+        # that there may be transactions blocks without generators. These are
+        # used to generate dummy block references. Block references require
+        # generators, not just transaction blocks.
+        generator_block_heights: list[uint32] = []
         if dummy_block_references:
             # block references can only point to transaction blocks, so we need
             # to record which ones are
             for b in block_list:
                 if b.transactions_generator is not None:
-                    tx_block_heights.append(b.height)
+                    generator_block_heights.append(b.height)
 
         constants = self.constants
 
@@ -743,8 +791,8 @@ class BlockTools:
         # after the one they were created by, so we "stage" them here to move
         # them into available_coins at the next transaction block
         pending_rewards: list[Coin] = []
-        wallet: Optional[WalletTool] = None
-        rng: Optional[Random] = None
+        wallet: WalletTool | None = None
+        rng: Random | None = None
         if include_transactions:
             # when we generate transactions in the chain, the caller cannot also
             # have ownership of the rewards and control the transactions
@@ -789,6 +837,12 @@ class BlockTools:
         if num_blocks == 0:
             return block_list
 
+        if block_list[-1].height >= constants.HARD_FORK2_HEIGHT and pool_reward_puzzle_hash is not None:
+            raise ValueError(
+                "block height is past hard fork 2 activation. v2 plots don't "
+                "support pool puzzle hashes, only contract hashes"
+            )
+
         blocks: dict[bytes32, BlockRecord]
         if block_list[-1].header_hash == self._block_cache_header:
             height_to_hash = self._block_cache_height_to_hash
@@ -803,7 +857,7 @@ class BlockTools:
             curr = blocks[curr.prev_hash]
         assert curr.timestamp is not None
         last_timestamp = float(curr.timestamp)
-        prev_tx_height = curr.height
+        prev_tx_height = uint32(0)
 
         curr = latest_block
         blocks_added_this_sub_slot = 1
@@ -821,6 +875,26 @@ class BlockTools:
         # this variable is true whenever there is a pending sub-epoch or epoch that needs to be added in the next block.
         pending_ses: bool = False
 
+        block_generator: NewBlockGenerator | None = None
+        if transaction_data is not None:
+            additions = compute_additions_unchecked(transaction_data)
+            removals = transaction_data.removals()
+            if curr.height >= self.constants.HARD_FORK_HEIGHT:
+                program = simple_solution_generator_backrefs(transaction_data).program
+            else:
+                program = simple_solution_generator(transaction_data).program
+            block_refs = []
+            cost = compute_block_cost(program, self.constants, uint32(curr.height + 1), prev_tx_height)
+            block_generator = NewBlockGenerator(
+                program,
+                [],
+                block_refs,
+                transaction_data.aggregated_signature,
+                additions,
+                removals,
+                cost,
+            )
+
         # Start at the last block in block list
         # Get the challenge for that slot
         while True:
@@ -872,6 +946,14 @@ class BlockTools:
                         assert signage_point.cc_vdf is not None
                         cc_sp_output_hash = signage_point.cc_vdf.output.get_hash()
 
+                    prev_tx_height = pre_sp_tx_block_height(
+                        constants=constants,
+                        blocks=BlockCache(blocks),
+                        prev_b_hash=latest_block.header_hash,
+                        sp_index=uint8(signage_point_index),
+                        first_in_sub_slot=len(finished_sub_slots_at_ip) > 0,
+                    )
+
                     qualified_proofs: list[tuple[uint64, ProofOfSpace]] = self.get_pospaces_for_challenge(
                         constants,
                         slot_cc_challenge,
@@ -880,7 +962,7 @@ class BlockTools:
                         difficulty,
                         sub_slot_iters,
                         curr.height,
-                        tx_block_heights[-1] if len(tx_block_heights) > 0 else uint32(0),
+                        prev_tx_height,
                         force_plot_id=force_plot_id,
                     )
 
@@ -908,14 +990,14 @@ class BlockTools:
                             pool_target = PoolTarget(self.pool_ph, uint32(0))
 
                         new_gen = self.setup_new_gen(
-                            tx_block_heights,
+                            generator_block_heights,
                             curr,
                             wallet,
                             rng,
                             available_coins,
                             prev_tx_height=prev_tx_height,
                             dummy_block_references=dummy_block_references,
-                            transaction_data=transaction_data,
+                            block_generator=block_generator,
                             include_transactions=include_transactions,
                             block_refs=block_refs,
                         )
@@ -953,18 +1035,24 @@ class BlockTools:
                             overflow_rc_challenge=None,
                         )
                         if block_record.is_transaction_block:
-                            transaction_data = None
+                            block_generator = None
                             block_refs = []
                             keep_going_until_tx_block = False
                             assert full_block.foliage_transaction_block is not None
                         elif guarantee_transaction_block:
                             continue
-                        # print(f"{full_block.height:4}: difficulty {difficulty} "
-                        #     f"time: {new_timestamp - last_timestamp:0.2f} "
-                        #     f"additions: {len(new_gen.additions) if block_record.is_transaction_block else 0:2} "
-                        #     f"removals: {len(new_gen.removals) if block_record.is_transaction_block else 0:2} "
-                        #     f"refs: {len(full_block.transactions_generator_ref_list):3} "
-                        #     f"tx: {block_record.is_transaction_block}")
+                        self.log.info(
+                            f"Created Block {full_block.height:4} "
+                            f"prev-tx: {prev_tx_height:4} "
+                            f"diff: {difficulty} "
+                            f"time: {new_timestamp - last_timestamp:0.2f} "
+                            f"additions: {len(new_gen.additions) if new_gen else 0:2} "
+                            f"removals: {len(new_gen.removals) if new_gen else 0:2} "
+                            f"refs: {len(full_block.transactions_generator_ref_list):3} "
+                            f"iters: {block_record.total_iters} "
+                            f"[{'TransactionBlock ' if block_record.is_transaction_block else ''}"
+                            f"{'V1' if proof_of_space.param().size_v1 else 'V2'}]"
+                        )
                         last_timestamp = new_timestamp
                         block_list.append(full_block)
 
@@ -981,12 +1069,10 @@ class BlockTools:
                                     available_coins.extend(new_gen.additions)
 
                         if full_block.transactions_generator is not None:
-                            tx_block_heights.append(full_block.height)
-                            prev_tx_height = full_block.height
+                            generator_block_heights.append(full_block.height)
 
                         blocks_added_this_sub_slot += 1
                         blocks[full_block.header_hash] = block_record
-                        self.log.info(f"Created block {block_record.height} ov=False, iters {block_record.total_iters}")
                         num_blocks -= 1
 
                         height_to_hash[uint32(full_block.height)] = full_block.header_hash
@@ -1050,7 +1136,7 @@ class BlockTools:
                 )
             # generate sub_epoch_summary, and if the last block was the last block of the sub-epoch or epoch
             # include the hash in the next sub-slot
-            sub_epoch_summary: Optional[SubEpochSummary] = None
+            sub_epoch_summary: SubEpochSummary | None = None
             if not pending_ses:  # if we just created a sub-epoch summary, we can at least skip another sub-slot
                 sub_epoch_summary = next_sub_epoch_summary(
                     constants,
@@ -1061,10 +1147,10 @@ class BlockTools:
                 )
             if sub_epoch_summary is not None:  # the previous block is the last block of the sub-epoch or epoch
                 pending_ses = True
-                ses_hash: Optional[bytes32] = sub_epoch_summary.get_hash()
+                ses_hash: bytes32 | None = sub_epoch_summary.get_hash()
                 # if the last block is the last block of the epoch, we set the new sub-slot iters and difficulty
-                new_sub_slot_iters: Optional[uint64] = sub_epoch_summary.new_sub_slot_iters
-                new_difficulty: Optional[uint64] = sub_epoch_summary.new_difficulty
+                new_sub_slot_iters: uint64 | None = sub_epoch_summary.new_sub_slot_iters
+                new_difficulty: uint64 | None = sub_epoch_summary.new_difficulty
 
                 self.log.info(f"Sub epoch summary: {sub_epoch_summary} for block {latest_block.height + 1}")
             else:  # the previous block is not the last block of the sub-epoch or epoch
@@ -1100,7 +1186,7 @@ class BlockTools:
                         icc_eos_iters,
                         True,
                     )
-                icc_sub_slot: Optional[InfusedChallengeChainSubSlot] = InfusedChallengeChainSubSlot(icc_eos_vdf)
+                icc_sub_slot: InfusedChallengeChainSubSlot | None = InfusedChallengeChainSubSlot(icc_eos_vdf)
                 assert icc_sub_slot is not None
                 icc_sub_slot_hash = icc_sub_slot.get_hash() if latest_block.deficit == 0 else None
                 cc_sub_slot = ChallengeChainSubSlot(
@@ -1136,7 +1222,7 @@ class BlockTools:
             sub_slots_finished += 1
             self.log.info(
                 f"Sub slot finished. blocks included: {blocks_added_this_sub_slot} blocks_per_slot: "
-                f"{(len(block_list) - initial_block_list_len) / sub_slots_finished}"
+                f"{(len(block_list) - initial_block_list_len) / sub_slots_finished} "
                 f"Sub Epoch Summary Included: {sub_epoch_summary is not None} "
             )
             blocks_added_this_sub_slot = 0  # Sub slot ended, overflows are in next sub slot
@@ -1175,6 +1261,14 @@ class BlockTools:
                         cc_sp_output_hash = signage_point.cc_vdf.output.get_hash()
 
                     # If did not reach the target slots to skip, don't make any proofs for this sub-slot
+                    prev_tx_height = pre_sp_tx_block_height(
+                        constants=constants,
+                        blocks=BlockCache(blocks),
+                        prev_b_hash=latest_block.header_hash,
+                        sp_index=uint8(signage_point_index),
+                        first_in_sub_slot=len(finished_sub_slots_at_ip) > 0,
+                    )
+
                     qualified_proofs = self.get_pospaces_for_challenge(
                         constants,
                         slot_cc_challenge,
@@ -1183,7 +1277,7 @@ class BlockTools:
                         difficulty,
                         sub_slot_iters,
                         curr.height,
-                        tx_block_heights[-1] if len(tx_block_heights) > 0 else uint32(0),
+                        prev_tx_height,
                         force_plot_id=force_plot_id,
                     )
                     for required_iters, proof_of_space in sorted(qualified_proofs, key=lambda t: t[0]):
@@ -1202,14 +1296,14 @@ class BlockTools:
                             pool_target = PoolTarget(self.pool_ph, uint32(0))
 
                         new_gen = self.setup_new_gen(
-                            tx_block_heights,
+                            generator_block_heights,
                             curr,
                             wallet,
                             rng,
                             available_coins,
                             prev_tx_height=prev_tx_height,
                             dummy_block_references=dummy_block_references,
-                            transaction_data=transaction_data,
+                            block_generator=block_generator,
                             include_transactions=include_transactions,
                             block_refs=block_refs,
                         )
@@ -1247,18 +1341,25 @@ class BlockTools:
                             overflow_rc_challenge=overflow_rc_challenge,
                         )
                         if block_record.is_transaction_block:
-                            transaction_data = None
+                            block_generator = None
                             block_refs = []
                             keep_going_until_tx_block = False
                             assert full_block.foliage_transaction_block is not None
                         elif guarantee_transaction_block:
                             continue
-                        # print(f"{full_block.height:4}: difficulty {difficulty} "
-                        #     f"time: {new_timestamp - last_timestamp:0.2f} "
-                        #     f"additions: {len(new_gen.additions) if block_record.is_transaction_block else 0:2} "
-                        #     f"removals: {len(new_gen.removals) if block_record.is_transaction_block else 0:2} "
-                        #     f"refs: {len(full_block.transactions_generator_ref_list):3} "
-                        #     f"tx: {block_record.is_transaction_block}")
+                        self.log.info(
+                            f"Created Block {full_block.height:4} "
+                            f"prev-tx: {prev_tx_height:4} "
+                            f"diff: {difficulty} "
+                            f"time: {new_timestamp - last_timestamp:0.2f} "
+                            f"additions: {len(new_gen.additions) if new_gen else 0:2} "
+                            f"removals: {len(new_gen.removals) if new_gen else 0:2} "
+                            f"refs: {len(full_block.transactions_generator_ref_list):3} "
+                            f"iters: {block_record.total_iters} "
+                            f"[{'TransactionBlock ' if block_record.is_transaction_block else ''}"
+                            f"{'V1 ' if proof_of_space.param().size_v1 else 'V2 '}"
+                            "Overflow]"
+                        )
                         last_timestamp = new_timestamp
                         block_list.append(full_block)
 
@@ -1275,12 +1376,10 @@ class BlockTools:
                                     available_coins.extend(new_gen.additions)
 
                         if full_block.transactions_generator is not None:
-                            tx_block_heights.append(full_block.height)
-                            prev_tx_height = full_block.height
+                            generator_block_heights.append(full_block.height)
 
                         blocks_added_this_sub_slot += 1
                         blocks[full_block.header_hash] = block_record
-                        self.log.info(f"Created block {block_record.height} ov=True, iters {block_record.total_iters}")
                         num_blocks -= 1
 
                         height_to_hash[uint32(full_block.height)] = full_block.header_hash
@@ -1308,7 +1407,7 @@ class BlockTools:
         self,
         constants: ConsensusConstants,
         seed: bytes = b"",
-        timestamp: Optional[uint64] = None,
+        timestamp: uint64 | None = None,
         force_overflow: bool = False,
         skip_slots: int = 0,
     ) -> FullBlock:
@@ -1316,7 +1415,7 @@ class BlockTools:
             timestamp = uint64(time.time())
 
         finished_sub_slots: list[EndOfSubSlotBundle] = []
-        unfinished_block: Optional[UnfinishedBlock] = None
+        unfinished_block: UnfinishedBlock | None = None
         ip_iters: uint64 = uint64(0)
         sub_slot_total_iters: uint128 = uint128(0)
 
@@ -1498,63 +1597,71 @@ class BlockTools:
         difficulty: uint64,
         sub_slot_iters: uint64,
         height: uint32,
-        prev_transaction_b_height: uint32,
-        force_plot_id: Optional[bytes32] = None,
+        prev_tx_height: uint32,
+        force_plot_id: bytes32 | None = None,
     ) -> list[tuple[uint64, ProofOfSpace]]:
         found_proofs: list[tuple[uint64, ProofOfSpace]] = []
         rng = random.Random()
         rng.seed(seed)
 
-        required_plot_strength = calculate_required_plot_strength(constants, prev_transaction_b_height)
+        sp_interval_iters = calculate_sp_interval_iters(constants, sub_slot_iters)
+        phase_out_epochs = num_phase_out_epochs(constants)
 
         for plot_info in self.plot_manager.plots.values():
             plot_id: bytes32 = plot_info.prover.get_id()
             if force_plot_id is not None and plot_id != force_plot_id:
                 continue
-            prefix_bits = calculate_prefix_bits(constants, height, plot_info.prover.get_size())
+            prefix_bits = calculate_prefix_bits(constants, height, plot_info.prover.get_param())
             if not passes_plot_filter(prefix_bits, plot_id, challenge_hash, signage_point):
                 continue
 
-            # v2 plots aren't valid until after the hard fork
-            if (
-                prev_transaction_b_height < constants.HARD_FORK2_HEIGHT
-                and plot_info.prover.get_version() == PlotVersion.V2
-            ):
+            if plot_info.prover.get_version() == PlotVersion.V2:
+                # v2 plots aren't valid until after the hard fork
+                if prev_tx_height < constants.HARD_FORK2_HEIGHT:
+                    continue
+
+                if plot_info.prover.get_strength() < constants.MIN_PLOT_STRENGTH:
+                    self.log.warn(
+                        f"Plot strength ({plot_info.prover.get_strength()}) too low, "
+                        f"cannot be used for farming: {plot_info.prover.get_filename()}"
+                    )
+                    continue
+                if plot_info.prover.get_strength() > constants.MAX_PLOT_STRENGTH:
+                    self.log.warn(
+                        f"Plot strength ({plot_info.prover.get_strength()}) too high, "
+                        f"cannot be used for farming: {plot_info.prover.get_filename()}"
+                    )
+                    continue
+            elif prev_tx_height >= constants.HARD_FORK2_HEIGHT + phase_out_epochs * constants.EPOCH_BLOCKS:
                 continue
 
             new_challenge: bytes32 = calculate_pos_challenge(plot_id, challenge_hash, signage_point)
 
-            # these are either qualities (v1) or partial proofs (v2)
-            proofs: Sequence[Union[bytes32, bytes]]
-            v = plot_info.prover.get_version()
-            if v == PlotVersion.V1:
-                proofs = plot_info.prover.get_qualities_for_challenge(new_challenge)
-            else:
-                proofs = plot_info.prover.get_partial_proofs_for_challenge(new_challenge, required_plot_strength)
-
-            for proof_index, proof in enumerate(proofs):
-                if v == PlotVersion.V2:
-                    quality_str = quality_for_partial_proof(proof, new_challenge)
-                elif v == PlotVersion.V1:
-                    quality_str = bytes32(proof)
+            qualities: Sequence[QualityProtocol] = plot_info.prover.get_qualities_for_challenge(
+                new_challenge, constants.QUALITY_PROOF_SCAN_FILTER
+            )
 
+            for idx, quality in enumerate(qualities):
                 required_iters = calculate_iterations_quality(
                     constants,
-                    quality_str,
-                    plot_info.prover.get_size(),
+                    quality.get_string(),
+                    plot_info.prover.get_param(),
                     difficulty,
                     signage_point,
-                    sub_slot_iters,
-                    prev_transaction_b_height,
                 )
-                if required_iters >= calculate_sp_interval_iters(constants, sub_slot_iters):
+                if required_iters >= sp_interval_iters:
                     continue
 
-                proof_xs: bytes
-                if v == PlotVersion.V1:
-                    proof_xs = plot_info.prover.get_full_proof(new_challenge, proof_index)
-                else:
-                    proof_xs = solve_proof(proof)
+                proof = b""
+                if isinstance(plot_info.prover, V1Prover):
+                    proof = plot_info.prover.get_full_proof(new_challenge, idx)
+                    if is_v1_phased_out(proof, prev_tx_height, constants):
+                        continue
+                elif isinstance(plot_info.prover, V2Prover):
+                    assert isinstance(quality, V2Quality)
+                    partial_proof = plot_info.prover.get_partial_proof(quality)
+                    strength = plot_info.prover.get_strength()
+                    proof = solve_proof(partial_proof, plot_id, strength, constants.PLOT_SIZE_V2)
 
                 # Look up local_sk from plot to save locked memory
                 (
@@ -1562,7 +1669,7 @@ class BlockTools:
                     farmer_public_key,
                     local_master_sk,
                 ) = parse_plot_info(plot_info.prover.get_memo())
-                local_sk = master_sk_to_local_sk(local_master_sk)
+                local_sk = cached_master_sk_to_local_sk(local_master_sk)
 
                 if isinstance(pool_public_key_or_puzzle_hash, G1Element):
                     include_taproot = False
@@ -1575,8 +1682,8 @@ class BlockTools:
                     plot_info.pool_public_key,
                     plot_info.pool_contract_puzzle_hash,
                     plot_pk,
-                    plot_info.prover.get_size(),
-                    proof_xs,
+                    plot_info.prover.get_param(),
+                    proof,
                 )
                 found_proofs.append((required_iters, proof_of_space))
         random_sample = found_proofs
@@ -1590,7 +1697,7 @@ class BlockTools:
 def get_signage_point(
     constants: ConsensusConstants,
     blocks: BlockRecordsProtocol,
-    latest_block: Optional[BlockRecord],
+    latest_block: BlockRecord | None,
     sub_slot_start_total_iters: uint128,
     signage_point_index: uint8,
     finished_sub_slots: list[EndOfSubSlotBundle],
@@ -1741,7 +1848,7 @@ def get_challenges(
     constants: ConsensusConstants,
     blocks: dict[bytes32, BlockRecord],
     finished_sub_slots: list[EndOfSubSlotBundle],
-    prev_header_hash: Optional[bytes32],
+    prev_header_hash: bytes32 | None,
 ) -> tuple[bytes32, bytes32]:
     if len(finished_sub_slots) == 0:
         if prev_header_hash is None:
@@ -1789,7 +1896,6 @@ def load_block_list(
     sub_slot_iters = uint64(constants.SUB_SLOT_ITERS_STARTING)
     height_to_hash: dict[uint32, bytes32] = {}
     blocks: dict[bytes32, BlockRecord] = {}
-    prev_transaction_b_height = uint32(0)
     for full_block in block_list:
         if full_block.height != 0:
             if len(full_block.finished_sub_slots) > 0:
@@ -1806,7 +1912,13 @@ def load_block_list(
             sp_hash = full_block.reward_chain_block.challenge_chain_sp_vdf.output.get_hash()
 
         cache = BlockCache(blocks)
-
+        prev_transaction_b_height = pre_sp_tx_block_height(
+            constants=constants,
+            blocks=cache,
+            prev_b_hash=full_block.prev_header_hash,
+            sp_index=full_block.reward_chain_block.signage_point_index,
+            first_in_sub_slot=len(full_block.finished_sub_slots) > 0,
+        )
         required_iters = validate_pospace_and_get_required_iters(
             constants,
             full_block.reward_chain_block.proof_of_space,
@@ -1814,14 +1926,10 @@ def load_block_list(
             sp_hash,
             full_block.height,
             uint64(difficulty),
-            sub_slot_iters,
             prev_transaction_b_height,
         )
         assert required_iters is not None
 
-        if full_block.is_transaction_block():
-            prev_transaction_b_height = full_block.height
-
         blocks[full_block.header_hash] = block_to_block_record(
             constants,
             cache,
@@ -1841,7 +1949,7 @@ def get_icc(
     blocks: dict[bytes32, BlockRecord],
     sub_slot_start_total_iters: uint128,
     deficit: uint8,
-) -> tuple[Optional[VDFInfo], Optional[VDFProof]]:
+) -> tuple[VDFInfo | None, VDFProof | None]:
     if len(finished_sub_slots) == 0:
         prev_deficit = latest_block.deficit
     else:
@@ -1871,7 +1979,7 @@ def get_icc(
         curr = blocks[curr.prev_hash]
     icc_iters = uint64(vdf_end_total_iters - latest_block.total_iters)
     if latest_block.is_challenge_block(constants):
-        icc_input: Optional[ClassgroupElement] = ClassgroupElement.get_default_element()
+        icc_input: ClassgroupElement | None = ClassgroupElement.get_default_element()
     else:
         icc_input = latest_block.infused_challenge_vdf_output
     assert icc_input is not None
@@ -1902,20 +2010,20 @@ def get_full_block_and_block_record(
     pool_target: PoolTarget,
     last_timestamp: float,
     time_per_block: float,
-    new_gen: Optional[NewBlockGenerator],
+    new_gen: NewBlockGenerator | None,
     height_to_hash: dict[uint32, bytes32],
     difficulty: uint64,
     required_iters: uint64,
     sub_slot_iters: uint64,
     get_plot_signature: Callable[[bytes32, G1Element], G2Element],
-    get_pool_signature: Callable[[PoolTarget, Optional[G1Element]], Optional[G2Element]],
+    get_pool_signature: Callable[[PoolTarget, G1Element | None], G2Element | None],
     finished_sub_slots: list[EndOfSubSlotBundle],
     signage_point: SignagePoint,
     prev_block: BlockRecord,
     seed: bytes = b"",
     *,
-    overflow_cc_challenge: Optional[bytes32] = None,
-    overflow_rc_challenge: Optional[bytes32] = None,
+    overflow_cc_challenge: bytes32 | None = None,
+    overflow_rc_challenge: bytes32 | None = None,
     normalized_to_identity_cc_ip: bool = False,
     current_time: bool = False,
 ) -> tuple[FullBlock, BlockRecord, float]:
@@ -2075,43 +2183,47 @@ create_block_tools_count = 0
 # listen port it uses is to write it to the config file.
 
 
+@asynccontextmanager
 async def create_block_tools_async(
     constants: ConsensusConstants = test_constants,
-    root_path: Optional[Path] = None,
-    keychain: Optional[Keychain] = None,
-    config_overrides: Optional[dict[str, Any]] = None,
+    root_path: Path | None = None,
+    keychain: Keychain | None = None,
+    config_overrides: dict[str, Any] | None = None,
     num_og_plots: int = 15,
     num_pool_plots: int = 5,
     num_non_keychain_plots: int = 3,
-) -> BlockTools:
+    testrun_uid: str | None = None,
+) -> AsyncIterator[BlockTools]:
     global create_block_tools_async_count
     create_block_tools_async_count += 1
     print(f"  create_block_tools_async called {create_block_tools_async_count} times")
-    bt = BlockTools(constants, root_path, keychain, config_overrides=config_overrides)
-    await bt.setup_keys()
-    await bt.setup_plots(
-        num_og_plots=num_og_plots,
-        num_pool_plots=num_pool_plots,
-        num_non_keychain_plots=num_non_keychain_plots,
-    )
 
-    return bt
+    with BlockTools(constants, root_path, keychain, config_overrides=config_overrides) as bt:
+        await bt.setup_keys()
+        await bt.setup_plots(
+            num_og_plots=num_og_plots,
+            num_pool_plots=num_pool_plots,
+            num_non_keychain_plots=num_non_keychain_plots,
+            testrun_uid=testrun_uid,
+        )
 
+        yield bt
 
+
+@contextmanager
 def create_block_tools(
     constants: ConsensusConstants = test_constants,
-    root_path: Optional[Path] = None,
-    keychain: Optional[Keychain] = None,
-    config_overrides: Optional[dict[str, Any]] = None,
-) -> BlockTools:
+    root_path: Path | None = None,
+    keychain: Keychain | None = None,
+    config_overrides: dict[str, Any] | None = None,
+) -> Iterator[BlockTools]:
     global create_block_tools_count
     create_block_tools_count += 1
     print(f"  create_block_tools called {create_block_tools_count} times")
-    bt = BlockTools(constants, root_path, keychain, config_overrides=config_overrides)
-
-    asyncio.get_event_loop().run_until_complete(bt.setup_keys())
-    asyncio.get_event_loop().run_until_complete(bt.setup_plots())
-    return bt
+    with BlockTools(constants, root_path, keychain, config_overrides=config_overrides) as bt:
+        asyncio.get_event_loop().run_until_complete(bt.setup_keys())
+        asyncio.get_event_loop().run_until_complete(bt.setup_plots())
+        yield bt
 
 
 def make_unfinished_block(