chia-blockchain 2.5.4rc2__py3-none-any.whl → 2.5.5rc2__py3-none-any.whl

chia/simulator/block_tools.py

@@ -20,20 +20,31 @@ import anyio
 from chia_puzzles_py.programs import CHIALISP_DESERIALISATION, ROM_BOOTSTRAP_GENERATOR
 from chia_rs import (
     AugSchemeMPL,
+    BlockRecord,
+    ChallengeChainSubSlot,
     ConsensusConstants,
+    EndOfSubSlotBundle,
+    FullBlock,
     G1Element,
     G2Element,
+    InfusedChallengeChainSubSlot,
+    PlotSize,
     PoolTarget,
     PrivateKey,
+    ProofOfSpace,
+    RewardChainSubSlot,
+    SpendBundle,
+    SubEpochSummary,
+    SubSlotProofs,
+    UnfinishedBlock,
     solution_generator,
 )
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64, uint128
 
 from chia.consensus.block_creation import create_unfinished_block, unfinished_block_to_full_block
-from chia.consensus.block_record import BlockRecord
+from chia.consensus.block_record import BlockRecordProtocol
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
-from chia.consensus.coinbase import create_puzzlehash_for_pk
 from chia.consensus.condition_costs import ConditionCost
 from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
@@ -46,11 +57,12 @@ from chia.consensus.pot_iterations import (
     calculate_sp_interval_iters,
     calculate_sp_iters,
     is_overflow_block,
+    validate_pospace_and_get_required_iters,
 )
+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.full_node.signage_point import SignagePoint
 from chia.plotting.create_plots import PlotKeys, create_plots
 from chia.plotting.manager import PlotManager
 from chia.plotting.util import (
@@ -70,35 +82,24 @@ from chia.simulator.ssl_certs import (
     get_next_nodes_certs_and_keys,
     get_next_private_ca_cert_and_key,
 )
+from chia.simulator.vdf_prover import get_vdf_info_and_proof
 from chia.simulator.wallet_tools import WalletTool
 from chia.ssl.create_ssl import create_all_ssl
+from chia.ssl.ssl_check import fix_ssl
 from chia.types.blockchain_format.classgroup import ClassgroupElement
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.program import DEFAULT_FLAGS, INFINITE_COST, Program
+from chia.types.blockchain_format.program import DEFAULT_FLAGS, INFINITE_COST, Program, _run, run_with_cost
 from chia.types.blockchain_format.proof_of_space import (
-    ProofOfSpace,
     calculate_pos_challenge,
     calculate_prefix_bits,
     generate_plot_public_key,
     generate_taproot_sk,
     passes_plot_filter,
-    verify_and_get_quality_string,
 )
 from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.blockchain_format.slots import (
-    ChallengeChainSubSlot,
-    InfusedChallengeChainSubSlot,
-    RewardChainSubSlot,
-    SubSlotProofs,
-)
-from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
 from chia.types.condition_opcodes import ConditionOpcode
-from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
-from chia.types.full_block import FullBlock
-from chia.types.generator_types import BlockGenerator
-from chia.types.spend_bundle import SpendBundle
-from chia.types.unfinished_block import UnfinishedBlock
+from chia.types.generator_types import NewBlockGenerator
 from chia.util.bech32m import encode_puzzle_hash
 from chia.util.block_cache import BlockCache
 from chia.util.config import (
@@ -112,22 +113,23 @@ from chia.util.config import (
 from chia.util.default_root import DEFAULT_ROOT_PATH
 from chia.util.hash import std_hash
 from chia.util.keychain import Keychain, bytes_to_mnemonic
-from chia.util.ssl_check import fix_ssl
 from chia.util.timing import adjusted_timeout, backoff_times
-from chia.util.vdf_prover import get_vdf_info_and_proof
 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,
 )
+from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_pk
 
 DESERIALIZE_MOD = Program.from_bytes(CHIALISP_DESERIALISATION)
 
 GENERATOR_MOD: SerializedProgram = SerializedProgram.from_bytes(ROM_BOOTSTRAP_GENERATOR)
 
 test_constants = DEFAULT_CONSTANTS.replace(
-    MIN_PLOT_SIZE=uint8(18),
+    MIN_PLOT_SIZE_V1=uint8(18),
+    # TODO: todo_v2_plots decide on v2 test plot k-size
+    MIN_PLOT_SIZE_V2=uint8(18),
     MIN_BLOCKS_PER_CHALLENGE_BLOCK=uint8(12),
     DIFFICULTY_STARTING=uint64(2**10),
     DISCRIMINANT_SIZE_BITS=uint16(16),
@@ -135,7 +137,7 @@ test_constants = DEFAULT_CONSTANTS.replace(
     WEIGHT_PROOF_THRESHOLD=uint8(2),
     WEIGHT_PROOF_RECENT_BLOCKS=uint32(380),
     DIFFICULTY_CONSTANT_FACTOR=uint128(33554432),
-    NUM_SPS_SUB_SLOT=uint32(16),  # Must be a power of 2
+    NUM_SPS_SUB_SLOT=uint8(16),  # Must be a power of 2
     MAX_SUB_SLOT_BLOCKS=uint32(50),
     EPOCH_BLOCKS=uint32(340),
     # the block cache must contain at least 3 epochs in order for
@@ -144,7 +146,7 @@ test_constants = DEFAULT_CONSTANTS.replace(
     BLOCKS_CACHE_SIZE=uint32(340 * 3),  # Coordinate with the above values
     SUB_SLOT_TIME_TARGET=uint16(600),  # The target number of seconds per slot, mainnet 600
     SUB_SLOT_ITERS_STARTING=uint64(2**10),  # Must be a multiple of 64
-    NUMBER_ZERO_BITS_PLOT_FILTER=uint8(1),  # H(plot signature of the challenge) must start with these many zeroes
+    NUMBER_ZERO_BITS_PLOT_FILTER_V1=uint8(1),  # H(plot signature of the challenge) must start with these many zeroes
     # 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),
@@ -155,7 +157,7 @@ def compute_additions_unchecked(sb: SpendBundle) -> list[Coin]:
     ret: list[Coin] = []
     for cs in sb.coin_spends:
         parent_id = cs.coin.name()
-        _, r = cs.puzzle_reveal.run_with_cost(INFINITE_COST, cs.solution)
+        _, r = run_with_cost(cs.puzzle_reveal, INFINITE_COST, cs.solution)
         for cond in Program.to(r).as_iter():
             atoms = cond.as_iter()
             op = next(atoms).atom
@@ -167,6 +169,48 @@ def compute_additions_unchecked(sb: SpendBundle) -> list[Coin]:
     return ret
 
 
+def compute_block_cost(
+    generator: SerializedProgram, constants: ConsensusConstants, height: uint32, prev_tx_height: uint32
+) -> uint64:
+    # this function cannot *validate* the block or any of the transactions. We
+    # deliberately create invalid blocks as parts of the tests, and we still
+    # need to be able to compute the cost of it
+
+    condition_cost = 0
+    clvm_cost = 0
+
+    if height >= constants.HARD_FORK_HEIGHT:
+        blocks: list[bytes] = []
+        cost, result = _run(generator, INFINITE_COST, DEFAULT_FLAGS, [DESERIALIZE_MOD, blocks])
+        clvm_cost += cost
+
+        for spend in result.first().as_iter():
+            # each spend is a list of:
+            # (parent-coin-id puzzle amount solution)
+            puzzle = spend.at("rf")
+            solution = spend.at("rrrf")
+
+            cost, result = _run(puzzle, INFINITE_COST, DEFAULT_FLAGS, solution)
+            clvm_cost += cost
+            condition_cost += conditions_cost(
+                result, charge_for_conditions=prev_tx_height >= constants.HARD_FORK2_HEIGHT
+            )
+
+    else:
+        block_program_args = SerializedProgram.to([[]])
+        clvm_cost, result = _run(GENERATOR_MOD, INFINITE_COST, DEFAULT_FLAGS, [generator, block_program_args])
+
+        for res in result.first().as_iter():
+            # each condition item is:
+            # (parent-coin-id puzzle-hash amount conditions)
+            conditions = res.at("rrrf")
+            condition_cost += conditions_cost(conditions, charge_for_conditions=False)
+
+    size_cost = len(bytes(generator)) * constants.COST_PER_BYTE
+
+    return uint64(clvm_cost + size_cost + condition_cost)
+
+
 def make_spend_bundle(coins: list[Coin], wallet: WalletTool, rng: Random) -> tuple[SpendBundle, list[Coin]]:
     """
     makes a new spend bundle (block generator) spending some of the coins in the
@@ -181,9 +225,6 @@ def make_spend_bundle(coins: list[Coin], wallet: WalletTool, rng: Random) -> tup
         bundle = wallet.generate_signed_transaction(uint64(c.amount // 2), receiver, c)
         new_coins.extend(bundle.additions())
         spend_bundles.append(bundle)
-        coins.remove(c)
-
-    coins.extend(new_coins)
 
     return SpendBundle.aggregate(spend_bundles), new_coins
 
@@ -304,6 +345,83 @@ class BlockTools:
             match_str=str(self.plot_dir.relative_to(DEFAULT_ROOT_PATH.parent)) if not automated_testing else None,
         )
 
+    def setup_new_gen(
+        self,
+        tx_block_heights: list[uint32],
+        curr: BlockRecordProtocol,
+        wallet: Optional[WalletTool],
+        rng: Optional[random.Random],
+        available_coins: list[Coin],
+        *,
+        prev_tx_height: uint32,
+        dummy_block_references: bool,
+        include_transactions: bool,
+        transaction_data: Optional[SpendBundle],
+        block_refs: list[uint32],
+    ) -> Optional[NewBlockGenerator]:
+        # 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:
+            dummy_refs = [
+                tx_block_heights[1],
+                tx_block_heights[len(tx_block_heights) // 2],
+                tx_block_heights[-2],
+            ]
+        else:
+            dummy_refs = []
+
+        if transaction_data is not None:
+            # this means the caller passed in transaction_data
+            # 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,
+            )
+
+        if include_transactions:
+            # if the caller did not pass in specific
+            # transactions, this parameter means we just want
+            # some transactions
+            assert wallet is not None
+            assert rng is not None
+            bundle, additions = make_spend_bundle(available_coins, wallet, rng)
+            removals = bundle.removals()
+            program = simple_solution_generator(bundle).program
+            cost = compute_block_cost(program, self.constants, uint32(curr.height + 1), prev_tx_height)
+            return NewBlockGenerator(
+                program,
+                [],
+                block_refs + dummy_refs,
+                bundle.aggregated_signature,
+                additions,
+                removals,
+                cost,
+            )
+
+        if dummy_block_references:
+            program = SerializedProgram.from_bytes(solution_generator([]))
+            cost = compute_block_cost(program, self.constants, uint32(curr.height + 1), prev_tx_height)
+            return NewBlockGenerator(program, [], block_refs + dummy_refs, G2Element(), [], [], cost)
+
+        return None
+
     async def setup_keys(self, fingerprint: Optional[int] = None, reward_ph: Optional[bytes32] = None) -> None:
         keychain_proxy: Optional[KeychainProxy]
         try:
@@ -336,10 +454,10 @@ class BlockTools:
             self.pool_pk = master_sk_to_pool_sk(self.pool_master_sk).get_g1()
 
             if reward_ph is None:
-                self.farmer_ph: bytes32 = create_puzzlehash_for_pk(
+                self.farmer_ph: bytes32 = puzzle_hash_for_pk(
                     master_sk_to_wallet_sk(self.farmer_master_sk, uint32(0)).get_g1()
                 )
-                self.pool_ph: bytes32 = create_puzzlehash_for_pk(
+                self.pool_ph: bytes32 = puzzle_hash_for_pk(
                     master_sk_to_wallet_sk(self.pool_master_sk, uint32(0)).get_g1()
                 )
             else:
@@ -595,6 +713,8 @@ class BlockTools:
         skip_overflow: bool = False,
         min_signage_point: int = -1,
     ) -> list[FullBlock]:
+        # make a copy to not have different invocations affect each other
+        block_refs = block_refs[:]
         assert num_blocks > 0
         if block_list_input is not None:
             block_list = block_list_input.copy()
@@ -610,11 +730,14 @@ class BlockTools:
                     tx_block_heights.append(b.height)
 
         constants = self.constants
-        transaction_data_included = False
+
         if time_per_block is None:
             time_per_block = float(constants.SUB_SLOT_TIME_TARGET) / float(constants.SLOT_BLOCKS_TARGET)
 
         available_coins: list[Coin] = []
+        # award coins aren't available to spend until the transaction block
+        # 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
@@ -676,7 +799,7 @@ class BlockTools:
             curr = blocks[curr.prev_hash]
         assert curr.timestamp is not None
         last_timestamp = float(curr.timestamp)
-        start_height = curr.height
+        prev_tx_height = curr.height
 
         curr = latest_block
         blocks_added_this_sub_slot = 1
@@ -709,7 +832,7 @@ class BlockTools:
                 num_empty_slots_added += 1
             else:
                 # Loop over every signage point (Except for the last ones, which are used for overflows)
-                for signage_point_index in range(0, constants.NUM_SPS_SUB_SLOT - constants.NUM_SP_INTERVALS_EXTRA):
+                for signage_point_index in range(constants.NUM_SPS_SUB_SLOT - constants.NUM_SP_INTERVALS_EXTRA):
                     curr = latest_block
                     while curr.total_iters > sub_slot_start_total_iters + calculate_sp_iters(
                         constants, sub_slot_iters, uint8(signage_point_index)
@@ -753,6 +876,7 @@ class BlockTools:
                         difficulty,
                         sub_slot_iters,
                         curr.height,
+                        tx_block_heights[-1] if len(tx_block_heights) > 0 else uint32(0),
                         force_plot_id=force_plot_id,
                     )
 
@@ -766,20 +890,6 @@ class BlockTools:
                                     continue
 
                         assert latest_block.header_hash in blocks
-                        additions = None
-                        removals = None
-                        if transaction_data_included:
-                            transaction_data = None
-                            block_refs = []
-                        if transaction_data is not None:
-                            additions = compute_additions_unchecked(transaction_data)
-                            removals = transaction_data.removals()
-                        elif include_transactions:
-                            assert wallet is not None
-                            assert rng is not None
-                            transaction_data, additions = make_spend_bundle(available_coins, wallet, rng)
-                            removals = transaction_data.removals()
-                            transaction_data_included = False
 
                         assert last_timestamp is not None
                         if proof_of_space.pool_contract_puzzle_hash is not None:
@@ -794,32 +904,19 @@ class BlockTools:
                             else:
                                 pool_target = PoolTarget(self.pool_ph, uint32(0))
 
-                        block_generator: Optional[BlockGenerator]
-                        if transaction_data is not None:
-                            if start_height >= constants.HARD_FORK_HEIGHT:
-                                block_generator = simple_solution_generator_backrefs(transaction_data)
-                                block_refs = []
-                            else:
-                                block_generator = simple_solution_generator(transaction_data)
+                        new_gen = self.setup_new_gen(
+                            tx_block_heights,
+                            curr,
+                            wallet,
+                            rng,
+                            available_coins,
+                            prev_tx_height=prev_tx_height,
+                            dummy_block_references=dummy_block_references,
+                            transaction_data=transaction_data,
+                            include_transactions=include_transactions,
+                            block_refs=block_refs,
+                        )
 
-                            aggregate_signature = transaction_data.aggregated_signature
-                        else:
-                            block_generator = None
-                            aggregate_signature = G2Element()
-
-                        if dummy_block_references:
-                            if block_generator is None:
-                                program = SerializedProgram.from_bytes(solution_generator([]))
-                                block_generator = BlockGenerator(program, [])
-
-                            if len(tx_block_heights) > 4:
-                                block_refs.extend(
-                                    [
-                                        tx_block_heights[1],
-                                        tx_block_heights[len(tx_block_heights) // 2],
-                                        tx_block_heights[-2],
-                                    ]
-                                )
                         (
                             full_block,
                             block_record,
@@ -835,12 +932,8 @@ class BlockTools:
                             farmer_reward_puzzle_hash,
                             pool_target,
                             last_timestamp,
-                            start_height,
                             time_per_block,
-                            block_generator,
-                            aggregate_signature,
-                            additions,
-                            removals,
+                            new_gen,
                             height_to_hash,
                             difficulty,
                             required_iters,
@@ -853,10 +946,11 @@ class BlockTools:
                             seed,
                             normalized_to_identity_cc_ip=normalized_to_identity_cc_ip,
                             current_time=current_time,
-                            block_refs=block_refs,
+                            overflow_cc_challenge=None,
+                            overflow_rc_challenge=None,
                         )
                         if block_record.is_transaction_block:
-                            transaction_data_included = True
+                            transaction_data = None
                             block_refs = []
                             keep_going_until_tx_block = False
                             assert full_block.foliage_transaction_block is not None
@@ -864,34 +958,38 @@ class BlockTools:
                             continue
                         # print(f"{full_block.height:4}: difficulty {difficulty} "
                         #     f"time: {new_timestamp - last_timestamp:0.2f} "
-                        #     f"additions: {len(additions) if block_record.is_transaction_block else 0:2} "
-                        #     f"removals: {len(removals) if block_record.is_transaction_block else 0:2} "
+                        #     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}")
                         last_timestamp = new_timestamp
                         block_list.append(full_block)
 
                         if include_transactions:
+                            prev_tx_height = full_block.height
                             for coin in full_block.get_included_reward_coins():
                                 if coin.puzzle_hash == self.farmer_ph:
                                     pending_rewards.append(coin)
                             if full_block.is_transaction_block():
                                 available_coins.extend(pending_rewards)
                                 pending_rewards = []
+                                if new_gen is not None:
+                                    for rem in new_gen.removals:
+                                        available_coins.remove(rem)
+                                    available_coins.extend(new_gen.additions)
 
                         if full_block.transactions_generator is not None:
                             tx_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} ove=False, iters {block_record.total_iters}"
-                        )
+                        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
                         latest_block = blocks[full_block.header_hash]
                         finished_sub_slots_at_ip = []
-                        num_blocks -= 1
+
                         if num_blocks <= 0 and not keep_going_until_tx_block:
                             self._block_cache_header = block_list[-1].header_hash
                             self._block_cache_height_to_hash = height_to_hash
@@ -1032,19 +1130,6 @@ class BlockTools:
             latest_block_eos = latest_block
             overflow_cc_challenge = finished_sub_slots_at_ip[-1].challenge_chain.get_hash()
             overflow_rc_challenge = finished_sub_slots_at_ip[-1].reward_chain.get_hash()
-            additions = None
-            removals = None
-            if transaction_data_included:
-                transaction_data = None
-            if transaction_data is not None:
-                additions = compute_additions_unchecked(transaction_data)
-                removals = transaction_data.removals()
-            elif include_transactions:
-                assert wallet is not None
-                assert rng is not None
-                transaction_data, additions = make_spend_bundle(available_coins, wallet, rng)
-                removals = transaction_data.removals()
-                transaction_data_included = False
             sub_slots_finished += 1
             self.log.info(
                 f"Sub slot finished. blocks included: {blocks_added_this_sub_slot} blocks_per_slot: "
@@ -1095,6 +1180,7 @@ class BlockTools:
                         difficulty,
                         sub_slot_iters,
                         curr.height,
+                        tx_block_heights[-1] if len(tx_block_heights) > 0 else uint32(0),
                         force_plot_id=force_plot_id,
                     )
                     for required_iters, proof_of_space in sorted(qualified_proofs, key=lambda t: t[0]):
@@ -1112,30 +1198,19 @@ class BlockTools:
                                 pool_target = PoolTarget(pool_reward_puzzle_hash, uint32(0))
                             else:
                                 pool_target = PoolTarget(self.pool_ph, uint32(0))
-                        if transaction_data is not None:
-                            if start_height >= constants.HARD_FORK_HEIGHT:
-                                block_generator = simple_solution_generator_backrefs(transaction_data)
-                                block_refs = []
-                            else:
-                                block_generator = simple_solution_generator(transaction_data)
-                            aggregate_signature = transaction_data.aggregated_signature
-                        else:
-                            block_generator = None
-                            aggregate_signature = G2Element()
-
-                        if dummy_block_references:
-                            if block_generator is None:
-                                program = SerializedProgram.from_bytes(solution_generator([]))
-                                block_generator = BlockGenerator(program, [])
-
-                            if len(tx_block_heights) > 4:
-                                block_refs.extend(
-                                    [
-                                        tx_block_heights[1],
-                                        tx_block_heights[len(tx_block_heights) // 2],
-                                        tx_block_heights[-2],
-                                    ]
-                                )
+
+                        new_gen = self.setup_new_gen(
+                            tx_block_heights,
+                            curr,
+                            wallet,
+                            rng,
+                            available_coins,
+                            prev_tx_height=prev_tx_height,
+                            dummy_block_references=dummy_block_references,
+                            transaction_data=transaction_data,
+                            include_transactions=include_transactions,
+                            block_refs=block_refs,
+                        )
 
                         (
                             full_block,
@@ -1152,12 +1227,8 @@ class BlockTools:
                             farmer_reward_puzzle_hash,
                             pool_target,
                             last_timestamp,
-                            start_height,
                             time_per_block,
-                            block_generator,
-                            aggregate_signature,
-                            additions,
-                            removals,
+                            new_gen,
                             height_to_hash,
                             difficulty,
                             required_iters,
@@ -1168,15 +1239,13 @@ class BlockTools:
                             signage_point,
                             latest_block,
                             seed,
-                            overflow_cc_challenge=overflow_cc_challenge,
-                            overflow_rc_challenge=overflow_rc_challenge,
                             normalized_to_identity_cc_ip=normalized_to_identity_cc_ip,
                             current_time=current_time,
-                            block_refs=block_refs,
+                            overflow_cc_challenge=overflow_cc_challenge,
+                            overflow_rc_challenge=overflow_rc_challenge,
                         )
-
                         if block_record.is_transaction_block:
-                            transaction_data_included = True
+                            transaction_data = None
                             block_refs = []
                             keep_going_until_tx_block = False
                             assert full_block.foliage_transaction_block is not None
@@ -1184,30 +1253,34 @@ class BlockTools:
                             continue
                         # print(f"{full_block.height:4}: difficulty {difficulty} "
                         #     f"time: {new_timestamp - last_timestamp:0.2f} "
-                        #     f"additions: {len(additions) if block_record.is_transaction_block else 0:2} "
-                        #     f"removals: {len(removals) if block_record.is_transaction_block else 0:2} "
+                        #     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}")
                         last_timestamp = new_timestamp
-
                         block_list.append(full_block)
 
                         if include_transactions:
+                            prev_tx_height = full_block.height
                             for coin in full_block.get_included_reward_coins():
                                 if coin.puzzle_hash == self.farmer_ph:
                                     pending_rewards.append(coin)
                             if full_block.is_transaction_block():
                                 available_coins.extend(pending_rewards)
                                 pending_rewards = []
+                                if new_gen is not None:
+                                    for rem in new_gen.removals:
+                                        available_coins.remove(rem)
+                                    available_coins.extend(new_gen.additions)
 
                         if full_block.transactions_generator is not None:
                             tx_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
 
-                        blocks[full_block.header_hash] = block_record
                         height_to_hash[uint32(full_block.height)] = full_block.header_hash
                         latest_block = blocks[full_block.header_hash]
                         finished_sub_slots_at_ip = []
@@ -1248,7 +1321,7 @@ class BlockTools:
         # Keep trying until we get a good proof of space that also passes sp filter
         while True:
             cc_challenge, rc_challenge = get_challenges(constants, {}, finished_sub_slots, None)
-            for signage_point_index in range(0, constants.NUM_SPS_SUB_SLOT):
+            for signage_point_index in range(constants.NUM_SPS_SUB_SLOT):
                 signage_point: SignagePoint = get_signage_point(
                     constants,
                     BlockCache({}),
@@ -1274,6 +1347,7 @@ class BlockTools:
                     constants.DIFFICULTY_STARTING,
                     constants.SUB_SLOT_ITERS_STARTING,
                     uint32(0),
+                    uint32(0),
                 )
 
                 # Try each of the proofs of space
@@ -1313,7 +1387,6 @@ class BlockTools:
                         BlockCache({}),
                         seed=seed,
                         finished_sub_slots_input=finished_sub_slots,
-                        compute_cost=compute_cost_test,
                         compute_fees=compute_fee_test,
                     )
                     assert unfinished_block is not None
@@ -1423,6 +1496,7 @@ class BlockTools:
         difficulty: uint64,
         sub_slot_iters: uint64,
         height: uint32,
+        prev_transaction_b_height: uint32,
         force_plot_id: Optional[bytes32] = None,
     ) -> list[tuple[uint64, ProofOfSpace]]:
         found_proofs: list[tuple[uint64, ProofOfSpace]] = []
@@ -1432,18 +1506,22 @@ class BlockTools:
             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)
+            # TODO: todo_v2_plots support v2 plots in the plot manager
+            prefix_bits = calculate_prefix_bits(constants, height, PlotSize.make_v1(plot_info.prover.get_size()))
             if passes_plot_filter(prefix_bits, plot_id, challenge_hash, signage_point):
                 new_challenge: bytes32 = calculate_pos_challenge(plot_id, challenge_hash, signage_point)
                 qualities = plot_info.prover.get_qualities_for_challenge(new_challenge)
 
                 for proof_index, quality_str in enumerate(qualities):
                     required_iters = calculate_iterations_quality(
-                        constants.DIFFICULTY_CONSTANT_FACTOR,
+                        constants,
                         quality_str,
-                        plot_info.prover.get_size(),
+                        # TODO: todo_v2_plots support v2 plots in the plot manager
+                        PlotSize.make_v1(plot_info.prover.get_size()),
                         difficulty,
                         signage_point,
+                        sub_slot_iters,
+                        prev_transaction_b_height,
                     )
                     if required_iters < calculate_sp_interval_iters(constants, sub_slot_iters):
                         proof_xs: bytes = plot_info.prover.get_full_proof(new_challenge, proof_index)
@@ -1694,21 +1772,25 @@ def load_block_list(
             assert full_block.reward_chain_block.challenge_chain_sp_vdf is not None
             challenge = full_block.reward_chain_block.challenge_chain_sp_vdf.challenge
             sp_hash = full_block.reward_chain_block.challenge_chain_sp_vdf.output.get_hash()
-        quality_str = verify_and_get_quality_string(
-            full_block.reward_chain_block.proof_of_space, constants, challenge, sp_hash, height=full_block.height
-        )
-        assert quality_str is not None
-        required_iters: uint64 = calculate_iterations_quality(
-            constants.DIFFICULTY_CONSTANT_FACTOR,
-            quality_str,
-            full_block.reward_chain_block.proof_of_space.size,
-            uint64(difficulty),
+
+        cache = BlockCache(blocks)
+        prev_transaction_b_height = uint32(0)  # TODO: todo_v2_plots
+
+        required_iters = validate_pospace_and_get_required_iters(
+            constants,
+            full_block.reward_chain_block.proof_of_space,
+            challenge,
             sp_hash,
+            full_block.height,
+            uint64(difficulty),
+            sub_slot_iters,
+            prev_transaction_b_height,
         )
+        assert required_iters is not None
 
         blocks[full_block.header_hash] = block_to_block_record(
             constants,
-            BlockCache(blocks),
+            cache,
             required_iters,
             full_block,
             sub_slot_iters,
@@ -1785,12 +1867,8 @@ def get_full_block_and_block_record(
     farmer_reward_puzzle_hash: bytes32,
     pool_target: PoolTarget,
     last_timestamp: float,
-    start_height: uint32,
     time_per_block: float,
-    block_generator: Optional[BlockGenerator],
-    aggregate_signature: G2Element,
-    additions: Optional[list[Coin]],
-    removals: Optional[list[Coin]],
+    new_gen: Optional[NewBlockGenerator],
     height_to_hash: dict[uint32, bytes32],
     difficulty: uint64,
     required_iters: uint64,
@@ -1802,7 +1880,6 @@ def get_full_block_and_block_record(
     prev_block: BlockRecord,
     seed: bytes = b"",
     *,
-    block_refs: list[uint32] = [],
     overflow_cc_challenge: Optional[bytes32] = None,
     overflow_rc_challenge: Optional[bytes32] = None,
     normalized_to_identity_cc_ip: bool = False,
@@ -1837,13 +1914,9 @@ def get_full_block_and_block_record(
         uint64(timestamp),
         BlockCache(blocks),
         seed,
-        block_generator,
-        aggregate_signature,
-        additions,
-        removals,
+        new_gen,
         prev_block,
         finished_sub_slots,
-        compute_cost=compute_cost_test,
         compute_fees=compute_fee_test,
     )
 
@@ -1898,10 +1971,19 @@ def compute_cost_table() -> list[int]:
 CONDITION_COSTS = compute_cost_table()
 
 
-def conditions_cost(conds: Program) -> uint64:
+def conditions_cost(conds: Program, *, charge_for_conditions: bool) -> uint64:
+    free_conditions = 100
+
     condition_cost = 0
     for cond in conds.as_iter():
         condition = cond.first().as_atom()
+
+        # this is new in hard fork 2
+        if free_conditions > 0:
+            free_conditions -= 1
+        elif charge_for_conditions:
+            condition_cost += ConditionCost.GENERIC_CONDITION_COST.value
+
         if condition == ConditionOpcode.CREATE_COIN:
             condition_cost += ConditionCost.CREATE_COIN.value
         # after the 2.0 hard fork, two byte conditions (with no leading 0)
@@ -1940,44 +2022,6 @@ def compute_fee_test(additions: Sequence[Coin], removals: Sequence[Coin]) -> uin
     return uint64(ret)
 
 
-def compute_cost_test(generator: BlockGenerator, constants: ConsensusConstants, height: uint32) -> uint64:
-    # this function cannot *validate* the block or any of the transactions. We
-    # deliberately create invalid blocks as parts of the tests, and we still
-    # need to be able to compute the cost of it
-
-    condition_cost = 0
-    clvm_cost = 0
-
-    if height >= constants.HARD_FORK_HEIGHT:
-        blocks = generator.generator_refs
-        cost, result = generator.program._run(INFINITE_COST, DEFAULT_FLAGS, [DESERIALIZE_MOD, blocks])
-        clvm_cost += cost
-
-        for spend in result.first().as_iter():
-            # each spend is a list of:
-            # (parent-coin-id puzzle amount solution)
-            puzzle = spend.at("rf")
-            solution = spend.at("rrrf")
-
-            cost, result = puzzle._run(INFINITE_COST, DEFAULT_FLAGS, solution)
-            clvm_cost += cost
-            condition_cost += conditions_cost(result)
-
-    else:
-        block_program_args = SerializedProgram.to([generator.generator_refs])
-        clvm_cost, result = GENERATOR_MOD._run(INFINITE_COST, DEFAULT_FLAGS, [generator.program, block_program_args])
-
-        for res in result.first().as_iter():
-            # each condition item is:
-            # (parent-coin-id puzzle-hash amount conditions)
-            conditions = res.at("rrrf")
-            condition_cost += conditions_cost(conditions)
-
-    size_cost = len(bytes(generator.program)) * constants.COST_PER_BYTE
-
-    return uint64(clvm_cost + size_cost + condition_cost)
-
-
 @dataclass
 class BlockToolsNewPlotResult:
     plot_id: bytes32