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

chia/_tests/blockchain/test_blockchain.py

@@ -9,7 +9,6 @@ import time
 from collections.abc import AsyncIterator, Awaitable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, replace
-from typing import Optional
 
 import pytest
 from chia_rs import (
@@ -39,6 +38,7 @@ from chia._tests.blockchain.blockchain_test_utils import (
     check_block_store_invariant,
 )
 from chia._tests.conftest import ConsensusMode
+from chia._tests.core.full_node.test_full_node import find_reward_coin
 from chia._tests.util.blockchain import create_blockchain
 from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia.consensus.augmented_chain import AugmentedBlockchain
@@ -152,7 +152,14 @@ class TestGenesisBlock:
         await _validate_and_add_block(empty_blockchain, genesis)
 
     @pytest.mark.anyio
-    async def test_genesis_validate_1(self, empty_blockchain: Blockchain, bt: BlockTools) -> None:
+    async def test_genesis_validate_1(
+        self, empty_blockchain: Blockchain, bt: BlockTools, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        # Monkey patch pre_sp_tx_block so we dont throw there
+        monkeypatch.setattr(
+            "chia.consensus.multiprocess_validation.pre_sp_tx_block_height",
+            lambda *args, **kwargs: uint32(0),
+        )
         genesis = bt.get_consecutive_blocks(1, force_overflow=False)[0]
         bad_prev = bytes([1] * 32)
         genesis = recursive_replace(genesis, "foliage.prev_block_hash", bad_prev)
@@ -160,124 +167,126 @@ class TestGenesisBlock:
 
 
 class TestBlockHeaderValidation:
-    @pytest.mark.limit_consensus_modes(reason="save time")
     @pytest.mark.anyio
     async def test_long_chain(self, empty_blockchain: Blockchain, default_1000_blocks: list[FullBlock]) -> None:
         blocks = default_1000_blocks
         fork_info = ForkInfo(blocks[0].height - 1, blocks[0].height - 1, blocks[0].prev_header_hash)
         for block in blocks:
             if (
-                len(block.finished_sub_slots) > 0
-                and block.finished_sub_slots[0].challenge_chain.subepoch_summary_hash is not None
+                len(block.finished_sub_slots) == 0
+                or block.finished_sub_slots[0].challenge_chain.subepoch_summary_hash is None
             ):
-                # Sub/Epoch. Try using a bad ssi and difficulty to test 2m and 2n
-                new_finished_ss = recursive_replace(
-                    block.finished_sub_slots[0],
-                    "challenge_chain.new_sub_slot_iters",
-                    uint64(10_000_000),
-                )
-                block_bad = recursive_replace(
-                    block, "finished_sub_slots", [new_finished_ss, *block.finished_sub_slots[1:]]
-                )
-                header_block_bad = get_block_header(block_bad)
-                # TODO: Inspect these block values as they are currently None
-                expected_difficulty = block.finished_sub_slots[0].challenge_chain.new_difficulty or uint64(0)
-                expected_sub_slot_iters = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters or uint64(0)
-                expected_vs = ValidationState(expected_sub_slot_iters, expected_difficulty, None)
-                _, error = validate_finished_header_block(
-                    empty_blockchain.constants, empty_blockchain, header_block_bad, False, expected_vs
-                )
-                assert error is not None
-                assert error.code == Err.INVALID_NEW_SUB_SLOT_ITERS
+                await _validate_and_add_block(empty_blockchain, block, fork_info=fork_info)
+                continue
 
-                # Also fails calling the outer methods, but potentially with a different error
-                await _validate_and_add_block(
-                    empty_blockchain, block_bad, expected_result=AddBlockResult.INVALID_BLOCK, fork_info=fork_info
-                )
+            # TODO: deduplicate the test code, perhaps by parameterizing the
+            # test
 
-                new_finished_ss_2 = recursive_replace(
-                    block.finished_sub_slots[0],
-                    "challenge_chain.new_difficulty",
-                    uint64(10_000_000),
-                )
-                block_bad_2 = recursive_replace(
-                    block, "finished_sub_slots", [new_finished_ss_2, *block.finished_sub_slots[1:]]
-                )
+            # Sub/Epoch. Try using a bad ssi and difficulty to test 2m and 2n
+            new_finished_ss = recursive_replace(
+                block.finished_sub_slots[0],
+                "challenge_chain.new_sub_slot_iters",
+                uint64(10_000_000),
+            )
+            block_bad = recursive_replace(block, "finished_sub_slots", [new_finished_ss, *block.finished_sub_slots[1:]])
+            header_block_bad = get_block_header(block_bad)
+            # TODO: Inspect these block values as they are currently None
+            expected_difficulty = block.finished_sub_slots[0].challenge_chain.new_difficulty or uint64(0)
+            expected_sub_slot_iters = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters or uint64(0)
+            expected_vs = ValidationState(expected_sub_slot_iters, expected_difficulty, None)
+            _, error = validate_finished_header_block(
+                empty_blockchain.constants, empty_blockchain, header_block_bad, False, expected_vs
+            )
+            assert error is not None
+            assert error.code == Err.INVALID_NEW_SUB_SLOT_ITERS
 
-                header_block_bad_2 = get_block_header(block_bad_2)
-                # TODO: Inspect these block values as they are currently None
-                expected_difficulty = block.finished_sub_slots[0].challenge_chain.new_difficulty or uint64(0)
-                expected_sub_slot_iters = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters or uint64(0)
-                expected_vs = ValidationState(expected_sub_slot_iters, expected_difficulty, None)
-                _, error = validate_finished_header_block(
-                    empty_blockchain.constants, empty_blockchain, header_block_bad_2, False, expected_vs
-                )
-                assert error is not None
-                assert error.code == Err.INVALID_NEW_DIFFICULTY
+            # Also fails calling the outer methods, but potentially with a different error
+            await _validate_and_add_block(
+                empty_blockchain, block_bad, expected_result=AddBlockResult.INVALID_BLOCK, fork_info=fork_info
+            )
 
-                # Also fails calling the outer methods, but potentially with a different error
-                await _validate_and_add_block(
-                    empty_blockchain, block_bad_2, expected_result=AddBlockResult.INVALID_BLOCK, fork_info=fork_info
-                )
+            new_finished_ss = recursive_replace(
+                block.finished_sub_slots[0],
+                "challenge_chain.new_difficulty",
+                uint64(10_000_000),
+            )
+            block_bad = recursive_replace(block, "finished_sub_slots", [new_finished_ss, *block.finished_sub_slots[1:]])
+
+            header_block_bad = get_block_header(block_bad)
+            # TODO: Inspect these block values as they are currently None
+            expected_difficulty = block.finished_sub_slots[0].challenge_chain.new_difficulty or uint64(0)
+            expected_sub_slot_iters = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters or uint64(0)
+            expected_vs = ValidationState(expected_sub_slot_iters, expected_difficulty, None)
+            _, error = validate_finished_header_block(
+                empty_blockchain.constants, empty_blockchain, header_block_bad, False, expected_vs
+            )
+            assert error is not None
+            assert error.code == Err.INVALID_NEW_DIFFICULTY
 
-                # 3c
-                new_finished_ss_3: EndOfSubSlotBundle = recursive_replace(
-                    block.finished_sub_slots[0],
-                    "challenge_chain.subepoch_summary_hash",
-                    bytes([0] * 32),
-                )
-                new_finished_ss_3 = recursive_replace(
-                    new_finished_ss_3,
-                    "reward_chain.challenge_chain_sub_slot_hash",
-                    new_finished_ss_3.challenge_chain.get_hash(),
-                )
-                log.warning(f"Number of slots: {len(block.finished_sub_slots)}")
-                block_bad_3 = recursive_replace(block, "finished_sub_slots", [new_finished_ss_3])
+            # Also fails calling the outer methods, but potentially with a different error
+            await _validate_and_add_block(
+                empty_blockchain, block_bad, expected_result=AddBlockResult.INVALID_BLOCK, fork_info=fork_info
+            )
 
-                header_block_bad_3 = get_block_header(block_bad_3)
-                # TODO: Inspect these block values as they are currently None
-                expected_difficulty = block.finished_sub_slots[0].challenge_chain.new_difficulty or uint64(0)
-                expected_sub_slot_iters = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters or uint64(0)
-                expected_vs = ValidationState(expected_sub_slot_iters, expected_difficulty, None)
-                _, error = validate_finished_header_block(
-                    empty_blockchain.constants, empty_blockchain, header_block_bad_3, False, expected_vs
-                )
-                assert error is not None
-                assert error.code == Err.INVALID_SUB_EPOCH_SUMMARY
+            # 3c
+            new_finished_ss = recursive_replace(
+                block.finished_sub_slots[0],
+                "challenge_chain.subepoch_summary_hash",
+                bytes([0] * 32),
+            )
+            new_finished_ss = recursive_replace(
+                new_finished_ss,
+                "reward_chain.challenge_chain_sub_slot_hash",
+                new_finished_ss.challenge_chain.get_hash(),
+            )
+            log.warning(f"Number of slots: {len(block.finished_sub_slots)}")
+            block_bad = recursive_replace(block, "finished_sub_slots", [new_finished_ss])
+
+            header_block_bad = get_block_header(block_bad)
+            # TODO: Inspect these block values as they are currently None
+            expected_difficulty = block.finished_sub_slots[0].challenge_chain.new_difficulty or uint64(0)
+            expected_sub_slot_iters = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters or uint64(0)
+            expected_vs = ValidationState(expected_sub_slot_iters, expected_difficulty, None)
+            _, error = validate_finished_header_block(
+                empty_blockchain.constants, empty_blockchain, header_block_bad, False, expected_vs
+            )
+            assert error is not None
+            assert error.code == Err.INVALID_SUB_EPOCH_SUMMARY
 
-                # Also fails calling the outer methods, but potentially with a different error
-                await _validate_and_add_block(
-                    empty_blockchain, block_bad_3, expected_result=AddBlockResult.INVALID_BLOCK, fork_info=fork_info
-                )
+            # Also fails calling the outer methods, but potentially with a different error
+            await _validate_and_add_block(
+                empty_blockchain, block_bad, expected_result=AddBlockResult.INVALID_BLOCK, fork_info=fork_info
+            )
 
-                # 3d
-                new_finished_ss_4 = recursive_replace(
-                    block.finished_sub_slots[0],
-                    "challenge_chain.subepoch_summary_hash",
-                    std_hash(b"123"),
-                )
-                new_finished_ss_4 = recursive_replace(
-                    new_finished_ss_4,
-                    "reward_chain.challenge_chain_sub_slot_hash",
-                    new_finished_ss_4.challenge_chain.get_hash(),
-                )
-                block_bad_4 = recursive_replace(block, "finished_sub_slots", [new_finished_ss_4])
+            # 3d
+            new_finished_ss = recursive_replace(
+                block.finished_sub_slots[0],
+                "challenge_chain.subepoch_summary_hash",
+                std_hash(b"123"),
+            )
+            new_finished_ss = recursive_replace(
+                new_finished_ss,
+                "reward_chain.challenge_chain_sub_slot_hash",
+                new_finished_ss.challenge_chain.get_hash(),
+            )
+            block_bad = recursive_replace(block, "finished_sub_slots", [new_finished_ss])
+
+            header_block_bad = get_block_header(block_bad)
+            # TODO: Inspect these block values as they are currently None
+            expected_difficulty = block.finished_sub_slots[0].challenge_chain.new_difficulty or uint64(0)
+            expected_sub_slot_iters = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters or uint64(0)
+            expected_vs = ValidationState(expected_sub_slot_iters, expected_difficulty, None)
+            _, error = validate_finished_header_block(
+                empty_blockchain.constants, empty_blockchain, header_block_bad, False, expected_vs
+            )
+            assert error is not None
+            assert error.code == Err.INVALID_SUB_EPOCH_SUMMARY
 
-                header_block_bad_4 = get_block_header(block_bad_4)
-                # TODO: Inspect these block values as they are currently None
-                expected_difficulty = block.finished_sub_slots[0].challenge_chain.new_difficulty or uint64(0)
-                expected_sub_slot_iters = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters or uint64(0)
-                expected_vs = ValidationState(expected_sub_slot_iters, expected_difficulty, None)
-                _, error = validate_finished_header_block(
-                    empty_blockchain.constants, empty_blockchain, header_block_bad_4, False, expected_vs
-                )
-                assert error is not None
-                assert error.code == Err.INVALID_SUB_EPOCH_SUMMARY
+            # Also fails calling the outer methods, but potentially with a different error
+            await _validate_and_add_block(
+                empty_blockchain, block_bad, expected_result=AddBlockResult.INVALID_BLOCK, fork_info=fork_info
+            )
 
-                # Also fails calling the outer methods, but potentially with a different error
-                await _validate_and_add_block(
-                    empty_blockchain, block_bad_4, expected_result=AddBlockResult.INVALID_BLOCK, fork_info=fork_info
-                )
             await _validate_and_add_block(empty_blockchain, block, fork_info=fork_info)
             log.info(
                 f"Added block {block.height} total iters {block.total_iters} new slot? {len(block.finished_sub_slots)}"
@@ -609,14 +618,16 @@ class TestBlockHeaderValidation:
     async def do_test_invalid_icc_sub_slot_vdf(
         self, keychain: Keychain, db_version: int, constants: ConsensusConstants
     ) -> None:
-        bt_high_iters = await create_block_tools_async(
-            constants=constants.replace(
-                SUB_SLOT_ITERS_STARTING=uint64(2**12),
-                DIFFICULTY_STARTING=uint64(2**14),
-            ),
-            keychain=keychain,
-        )
-        async with create_blockchain(bt_high_iters.constants, db_version) as (bc1, _):
+        async with (
+            create_block_tools_async(
+                constants=constants.replace(
+                    SUB_SLOT_ITERS_STARTING=uint64(2**12),
+                    DIFFICULTY_STARTING=uint64(2**14),
+                ),
+                keychain=keychain,
+            ) as bt_high_iters,
+            create_blockchain(bt_high_iters.constants, db_version) as (bc1, _),
+        ):
             blocks = bt_high_iters.get_consecutive_blocks(10)
             for block in blocks:
                 if (
@@ -1443,7 +1454,7 @@ class TestBlockHeaderValidation:
                 new_fsb_sig = bt.get_plot_signature(new_m, blocks[-1].reward_chain_block.proof_of_space.plot_public_key)
                 block_bad = recursive_replace(block_bad, "foliage.foliage_block_data_signature", new_fsb_sig)
                 await _validate_and_add_block(empty_blockchain, block_bad, expected_error=Err.INVALID_POOL_TARGET)
-                return None
+                return
             attempts += 1
 
     @pytest.mark.anyio
@@ -1887,7 +1898,6 @@ class TestBodyValidation:
             3,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
             genesis_timestamp=uint64(10_000),
             time_per_block=10,
         )
@@ -1897,9 +1907,8 @@ class TestBodyValidation:
 
         wt: WalletTool = bt.get_pool_wallet_tool()
 
-        tx1 = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0]
-        )
+        coin = find_reward_coin(blocks[-1], bt.pool_ph)
+        tx1 = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
         coin1: Coin = tx1.additions()[0]
 
         if opcode == ConditionOpcode.ASSERT_MY_AMOUNT:
@@ -2036,7 +2045,6 @@ class TestBodyValidation:
                 3,
                 guarantee_transaction_block=True,
                 farmer_reward_puzzle_hash=bt.pool_ph,
-                pool_reward_puzzle_hash=bt.pool_ph,
                 genesis_timestamp=uint64(10_000),
                 time_per_block=10,
             )
@@ -2047,7 +2055,7 @@ class TestBodyValidation:
 
             conditions = {opcode: [ConditionWithArgs(opcode, [int_to_bytes(lock_value)])]}
 
-            coin = blocks[-1].get_included_reward_coins()[0]
+            coin = find_reward_coin(blocks[-1], bt.pool_ph)
             tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin, condition_dic=conditions)
 
             blocks = bt.get_consecutive_blocks(
@@ -2107,7 +2115,6 @@ class TestBodyValidation:
             3,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
             genesis_timestamp=uint64(10_000),
             time_per_block=10,
         )
@@ -2117,9 +2124,8 @@ class TestBodyValidation:
 
         wt: WalletTool = bt.get_pool_wallet_tool()
 
-        tx1 = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0]
-        )
+        coin = find_reward_coin(blocks[-1], bt.pool_ph)
+        tx1 = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
         coin1: Coin = tx1.additions()[0]
         secret_key = wt.get_private_key_for_puzzle_hash(coin1.puzzle_hash)
         synthetic_secret_key = calculate_synthetic_secret_key(secret_key, DEFAULT_HIDDEN_PUZZLE_HASH)
@@ -2237,7 +2243,6 @@ class TestBodyValidation:
                 3,
                 guarantee_transaction_block=True,
                 farmer_reward_puzzle_hash=bt.pool_ph,
-                pool_reward_puzzle_hash=bt.pool_ph,
                 genesis_timestamp=uint64(10_000),
                 time_per_block=10,
             )
@@ -2251,9 +2256,8 @@ class TestBodyValidation:
                 opcode: [ConditionWithArgs(opcode, [int_to_bytes(lock_value)] + ([b"garbage"] if with_garbage else []))]
             }
 
-            tx1 = wt.generate_signed_transaction(
-                uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0]
-            )
+            coin = find_reward_coin(blocks[-1], bt.pool_ph)
+            tx1 = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
             coin1: Coin = tx1.additions()[0]
             tx2 = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin1, condition_dic=conditions)
             assert coin1 in tx2.removals()
@@ -2487,15 +2491,13 @@ class TestBodyValidation:
             block_list_input=blocks,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
         )
         await _validate_and_add_block(b, blocks[2])
         await _validate_and_add_block(b, blocks[3])
 
         wt: WalletTool = bt.get_pool_wallet_tool()
-        tx = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0]
-        )
+        coin = find_reward_coin(blocks[-1], bt.pool_ph)
+        tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
         blocks = bt.get_consecutive_blocks(
             1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=tx
         )
@@ -2525,7 +2527,6 @@ class TestBodyValidation:
             3,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
         )
         await _validate_and_add_block(b, blocks[0])
         await _validate_and_add_block(b, blocks[1])
@@ -2557,9 +2558,8 @@ class TestBodyValidation:
         # Hash should be correct when there is a ref list
         await _validate_and_add_block(b, blocks[-1])
         wt: WalletTool = bt.get_pool_wallet_tool()
-        tx = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0]
-        )
+        coin = find_reward_coin(blocks[-1], bt.pool_ph)
+        tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
         blocks = bt.get_consecutive_blocks(5, block_list_input=blocks, guarantee_transaction_block=False)
         for block in blocks[-5:]:
             await _validate_and_add_block(b, block)
@@ -2592,7 +2592,6 @@ class TestBodyValidation:
             3,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
         )
         await _validate_and_add_block(b, blocks[0])
         await _validate_and_add_block(b, blocks[1])
@@ -2605,9 +2604,8 @@ class TestBodyValidation:
             output = ConditionWithArgs(ConditionOpcode.CREATE_COIN, [bt.pool_ph, int_to_bytes(i)])
             condition_dict[ConditionOpcode.CREATE_COIN].append(output)
 
-        tx = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0], condition_dic=condition_dict
-        )
+        coin = find_reward_coin(blocks[-1], bt.pool_ph)
+        tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin, condition_dic=condition_dict)
 
         blocks = bt.get_consecutive_blocks(
             1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=tx
@@ -2663,7 +2661,6 @@ class TestBodyValidation:
             3,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
         )
         await _validate_and_add_block(b, blocks[0])
         await _validate_and_add_block(b, blocks[1])
@@ -2671,9 +2668,8 @@ class TestBodyValidation:
 
         wt: WalletTool = bt.get_pool_wallet_tool()
 
-        tx = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0]
-        )
+        coin = find_reward_coin(blocks[-1], bt.pool_ph)
+        tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
 
         blocks = bt.get_consecutive_blocks(
             1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=tx
@@ -2813,7 +2809,6 @@ class TestBodyValidation:
         #         3,
         #         guarantee_transaction_block=True,
         #         farmer_reward_puzzle_hash=bt.pool_ph,
-        #         pool_reward_puzzle_hash=bt.pool_ph,
         #     )
         #     assert (await b.add_block(blocks[0]))[0] == AddBlockResult.NEW_PEAK
         #     assert (await b.add_block(blocks[1]))[0] == AddBlockResult.NEW_PEAK
@@ -2825,10 +2820,11 @@ class TestBodyValidation:
         #     output = ConditionWithArgs(ConditionOpcode.CREATE_COIN, [bt_2.pool_ph, int_to_bytes(2 ** 64)])
         #     condition_dict[ConditionOpcode.CREATE_COIN].append(output)
 
+        #     coin = find_reward_coin(blocks[1], bt.pool_ph)
         #     tx = wt.generate_signed_transaction_multiple_coins(
         #         uint64(10),
         #         wt.get_new_puzzlehash(),
-        #         blocks[1].get_included_reward_coins(),
+        #         coin,
         #         condition_dic=condition_dict,
         #     )
         #     with pytest.raises(Exception):
@@ -2845,7 +2841,6 @@ class TestBodyValidation:
             3,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
         )
         await _validate_and_add_block(empty_blockchain, blocks[0])
         await _validate_and_add_block(empty_blockchain, blocks[1])
@@ -2853,9 +2848,8 @@ class TestBodyValidation:
 
         wt: WalletTool = bt.get_pool_wallet_tool()
 
-        tx = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0]
-        )
+        coin = find_reward_coin(blocks[-1], bt.pool_ph)
+        tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
 
         blocks = bt.get_consecutive_blocks(
             1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=tx
@@ -2896,7 +2890,6 @@ class TestBodyValidation:
             3,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
         )
         await _validate_and_add_block(b, blocks[0])
         await _validate_and_add_block(b, blocks[1])
@@ -2904,9 +2897,8 @@ class TestBodyValidation:
 
         wt: WalletTool = bt.get_pool_wallet_tool()
 
-        tx = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0]
-        )
+        coin = find_reward_coin(blocks[-1], bt.pool_ph)
+        tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
 
         blocks = bt.get_consecutive_blocks(
             1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=tx
@@ -2931,7 +2923,6 @@ class TestBodyValidation:
             3,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
         )
         await _validate_and_add_block(b, blocks[0])
         await _validate_and_add_block(b, blocks[1])
@@ -2944,9 +2935,8 @@ class TestBodyValidation:
             output = ConditionWithArgs(ConditionOpcode.CREATE_COIN, [bt.pool_ph, int_to_bytes(1)])
             condition_dict[ConditionOpcode.CREATE_COIN].append(output)
 
-        tx = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0], condition_dic=condition_dict
-        )
+        coin = find_reward_coin(blocks[-1], bt.pool_ph)
+        tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin, condition_dic=condition_dict)
 
         blocks = bt.get_consecutive_blocks(
             1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=tx
@@ -2961,7 +2951,6 @@ class TestBodyValidation:
             3,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
         )
         await _validate_and_add_block(b, blocks[0])
         await _validate_and_add_block(b, blocks[1])
@@ -2969,12 +2958,9 @@ class TestBodyValidation:
 
         wt: WalletTool = bt.get_pool_wallet_tool()
 
-        tx = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0]
-        )
-        tx_2 = wt.generate_signed_transaction(
-            uint64(11), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0]
-        )
+        coin = find_reward_coin(blocks[-1], bt.pool_ph)
+        tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
+        tx_2 = wt.generate_signed_transaction(uint64(11), wt.get_new_puzzlehash(), coin)
         agg = SpendBundle.aggregate([tx, tx_2])
 
         blocks = bt.get_consecutive_blocks(
@@ -2990,7 +2976,6 @@ class TestBodyValidation:
             3,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
         )
         await _validate_and_add_block(b, blocks[0])
         await _validate_and_add_block(b, blocks[1])
@@ -2998,9 +2983,8 @@ class TestBodyValidation:
 
         wt: WalletTool = bt.get_pool_wallet_tool()
 
-        tx = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0]
-        )
+        coin = find_reward_coin(blocks[-1], bt.pool_ph)
+        tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
 
         blocks = bt.get_consecutive_blocks(
             1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=tx
@@ -3024,7 +3008,6 @@ class TestBodyValidation:
             3,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
         )
         await _validate_and_add_block(b, blocks[0])
         await _validate_and_add_block(b, blocks[1])
@@ -3032,9 +3015,8 @@ class TestBodyValidation:
 
         wt: WalletTool = bt.get_pool_wallet_tool()
 
-        tx = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0]
-        )
+        coin = find_reward_coin(blocks[-1], bt.pool_ph)
+        tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
         blocks = bt.get_consecutive_blocks(
             1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=tx
         )
@@ -3132,7 +3114,6 @@ class TestBodyValidation:
             3,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
         )
         await _validate_and_add_block(b, blocks[0])
         await _validate_and_add_block(b, blocks[1])
@@ -3140,7 +3121,7 @@ class TestBodyValidation:
 
         wt: WalletTool = bt.get_pool_wallet_tool()
 
-        spend = blocks[-1].get_included_reward_coins()[0]
+        spend = find_reward_coin(blocks[-1], bt.pool_ph)
         print("spend=", spend)
         # this create coin will spend all of the coin, so the 10 mojos below
         # will be "minted".
@@ -3168,7 +3149,6 @@ class TestBodyValidation:
             3,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
         )
         await _validate_and_add_block(b, blocks[0])
         await _validate_and_add_block(b, blocks[1])
@@ -3176,9 +3156,8 @@ class TestBodyValidation:
 
         wt: WalletTool = bt.get_pool_wallet_tool()
 
-        tx = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0]
-        )
+        coin = find_reward_coin(blocks[-1], bt.pool_ph)
+        tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
 
         blocks = bt.get_consecutive_blocks(
             1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=tx
@@ -3210,7 +3189,6 @@ class TestBodyValidation:
             3,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=bt.pool_ph,
-            pool_reward_puzzle_hash=bt.pool_ph,
         )
         await _validate_and_add_block(b, blocks[0])
         await _validate_and_add_block(b, blocks[1])
@@ -3218,9 +3196,8 @@ class TestBodyValidation:
 
         wt: WalletTool = bt.get_pool_wallet_tool()
 
-        tx = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0]
-        )
+        coin = find_reward_coin(blocks[-1], bt.pool_ph)
+        tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
         blocks = bt.get_consecutive_blocks(
             1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=tx
         )
@@ -3257,7 +3234,7 @@ class TestBodyValidation:
         assert preval_result.error == Err.BAD_AGGREGATE_SIGNATURE.value
 
 
-def maybe_header_hash(block: Optional[BlockRecord]) -> Optional[bytes32]:
+def maybe_header_hash(block: BlockRecord | None) -> bytes32 | None:
     if block is None:
         return None
     return block.header_hash
@@ -3304,7 +3281,7 @@ class TestReorgs:
             reorg_point = 12
         blocks = bt.get_consecutive_blocks(reorg_point)
 
-        last_tx_block: Optional[bytes32] = None
+        last_tx_block: bytes32 | None = None
         for block in blocks:
             assert maybe_header_hash(b.get_tx_peak()) == last_tx_block
             await _validate_and_add_block(b, block)
@@ -3315,7 +3292,7 @@ class TestReorgs:
         assert peak.height == reorg_point - 1
         assert maybe_header_hash(b.get_tx_peak()) == last_tx_block
 
-        reorg_last_tx_block: Optional[bytes32] = None
+        reorg_last_tx_block: bytes32 | None = None
         fork_block = blocks[9]
         fork_info = ForkInfo(fork_block.height, fork_block.height, fork_block.header_hash)
         blocks_reorg_chain = bt.get_consecutive_blocks(7, blocks[:10], seed=b"2")
@@ -3613,16 +3590,14 @@ class TestReorgs:
         blocks = bt.get_consecutive_blocks(
             3,
             guarantee_transaction_block=True,
-            pool_reward_puzzle_hash=bt.pool_ph,
             farmer_reward_puzzle_hash=bt.pool_ph,
         )
         await _validate_and_add_block(b, blocks[0])
         await _validate_and_add_block(b, blocks[1])
         await _validate_and_add_block(b, blocks[2])
         wt: WalletTool = bt.get_pool_wallet_tool()
-        tx = wt.generate_signed_transaction(
-            uint64(10), wt.get_new_puzzlehash(), blocks[2].get_included_reward_coins()[0]
-        )
+        coin = find_reward_coin(blocks[2], bt.pool_ph)
+        tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
         blocks = bt.get_consecutive_blocks(
             1,
             block_list_input=blocks,
@@ -4076,7 +4051,7 @@ async def test_get_tx_peak(default_400_blocks: list[FullBlock], empty_blockchain
     assert bc.get_tx_peak() == last_tx_block_record
 
 
-def to_bytes(gen: Optional[SerializedProgram]) -> bytes:
+def to_bytes(gen: SerializedProgram | None) -> bytes:
     assert gen is not None
     return bytes(gen)
 
@@ -4209,7 +4184,7 @@ async def get_fork_info(blockchain: Blockchain, block: FullBlock, peak: BlockRec
     counter = 0
     start = time.monotonic()
     for height in range(fork_info.fork_height + 1, block.height):
-        fork_block: Optional[FullBlock] = await blockchain.block_store.get_full_block(fork_chain[uint32(height)])
+        fork_block: FullBlock | None = await blockchain.block_store.get_full_block(fork_chain[uint32(height)])
         assert fork_block is not None
         assert fork_block.height - 1 == fork_info.peak_height
         assert fork_block.height == 0 or fork_block.prev_header_hash == fork_info.peak_hash