chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/_tests/blockchain/test_blockchain.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 import random
 import time
+from collections.abc import AsyncIterator, Awaitable
 from contextlib import asynccontextmanager
 from dataclasses import replace
-from typing import AsyncIterator, Dict, List, Optional
+from typing import Optional
 
 import pytest
 from chia_rs import AugSchemeMPL, G2Element, MerkleSet
@@ -20,6 +22,7 @@ from chia._tests.blockchain.blockchain_test_utils import (
 )
 from chia._tests.conftest import ConsensusMode
 from chia._tests.util.blockchain import create_blockchain
+from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.block_header_validation import validate_finished_header_block
 from chia.consensus.block_record import BlockRecord
@@ -27,11 +30,11 @@ from chia.consensus.block_rewards import calculate_base_farmer_reward
 from chia.consensus.blockchain import AddBlockResult, Blockchain
 from chia.consensus.coinbase import create_farmer_coin
 from chia.consensus.constants import ConsensusConstants
+from chia.consensus.find_fork_point import lookup_fork_chain
 from chia.consensus.full_block_to_block_record import block_to_block_record
 from chia.consensus.get_block_generator import get_block_generator
-from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_blocks_multiprocessing
+from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_block
 from chia.consensus.pot_iterations import is_overflow_block
-from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions
 from chia.simulator.block_tools import BlockTools, create_block_tools_async
 from chia.simulator.keyring import TempKeyring
 from chia.simulator.wallet_tools import WalletTool
@@ -49,7 +52,8 @@ 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.util.cpu import available_logical_cores
+from chia.types.validation_state import ValidationState
+from chia.util.augmented_chain import AugmentedBlockchain
 from chia.util.errors import Err
 from chia.util.generator_tools import get_block_header
 from chia.util.hash import std_hash
@@ -72,14 +76,14 @@ async def make_empty_blockchain(constants: ConsensusConstants) -> AsyncIterator[
     Provides a list of 10 valid blocks, as well as a blockchain with 9 blocks added to it.
     """
 
-    async with create_blockchain(constants, 2) as (bc, db_wrapper):
+    async with create_blockchain(constants, 2) as (bc, _):
         yield bc
 
 
 class TestGenesisBlock:
     @pytest.mark.anyio
     async def test_block_tools_proofs_400(
-        self, default_400_blocks: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_400_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         vdf, proof = get_vdf_info_and_proof(
             blockchain_constants,
@@ -92,7 +96,7 @@ class TestGenesisBlock:
 
     @pytest.mark.anyio
     async def test_block_tools_proofs_1000(
-        self, default_1000_blocks: List[FullBlock], blockchain_constants: ConsensusConstants
+        self, default_1000_blocks: list[FullBlock], blockchain_constants: ConsensusConstants
     ) -> None:
         vdf, proof = get_vdf_info_and_proof(
             blockchain_constants,
@@ -149,8 +153,9 @@ 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:
+    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
@@ -165,23 +170,21 @@ class TestBlockHeaderValidation:
                 block_bad = recursive_replace(
                     block, "finished_sub_slots", [new_finished_ss] + block.finished_sub_slots[1:]
                 )
-                header_block_bad = get_block_header(block_bad, [], [])
+                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_difficulty,
-                    expected_sub_slot_iters,
+                    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
 
                 # 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)
+                await _validate_and_add_block(
+                    empty_blockchain, block_bad, expected_result=AddBlockResult.INVALID_BLOCK, fork_info=fork_info
+                )
 
                 new_finished_ss_2 = recursive_replace(
                     block.finished_sub_slots[0],
@@ -192,24 +195,20 @@ class TestBlockHeaderValidation:
                     block, "finished_sub_slots", [new_finished_ss_2] + block.finished_sub_slots[1:]
                 )
 
-                header_block_bad_2 = get_block_header(block_bad_2, [], [])
+                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_difficulty,
-                    expected_sub_slot_iters,
+                    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_2, expected_result=AddBlockResult.INVALID_BLOCK
+                    empty_blockchain, block_bad_2, expected_result=AddBlockResult.INVALID_BLOCK, fork_info=fork_info
                 )
 
                 # 3c
@@ -226,24 +225,20 @@ class TestBlockHeaderValidation:
                 log.warning(f"Number of slots: {len(block.finished_sub_slots)}")
                 block_bad_3 = recursive_replace(block, "finished_sub_slots", [new_finished_ss_3])
 
-                header_block_bad_3 = get_block_header(block_bad_3, [], [])
+                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_difficulty,
-                    expected_sub_slot_iters,
+                    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
 
                 # 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
+                    empty_blockchain, block_bad_3, expected_result=AddBlockResult.INVALID_BLOCK, fork_info=fork_info
                 )
 
                 # 3d
@@ -259,26 +254,22 @@ class TestBlockHeaderValidation:
                 )
                 block_bad_4 = recursive_replace(block, "finished_sub_slots", [new_finished_ss_4])
 
-                header_block_bad_4 = get_block_header(block_bad_4, [], [])
+                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_difficulty,
-                    expected_sub_slot_iters,
+                    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_4, expected_result=AddBlockResult.INVALID_BLOCK
+                    empty_blockchain, block_bad_4, expected_result=AddBlockResult.INVALID_BLOCK, fork_info=fork_info
                 )
-            await _validate_and_add_block(empty_blockchain, block)
+            await _validate_and_add_block(empty_blockchain, block, fork_info=fork_info)
             log.info(
                 f"Added block {block.height} total iters {block.total_iters} "
                 f"new slot? {len(block.finished_sub_slots)}"
@@ -370,7 +361,7 @@ class TestBlockHeaderValidation:
     async def test_one_sb_per_slot(self, empty_blockchain: Blockchain, bt: BlockTools) -> None:
         blockchain = empty_blockchain
         num_blocks = 20
-        blocks: List[FullBlock] = []
+        blocks: list[FullBlock] = []
         for _ in range(num_blocks):
             blocks = bt.get_consecutive_blocks(1, block_list_input=blocks, skip_slots=1)
             await _validate_and_add_block(empty_blockchain, blocks[-1])
@@ -382,7 +373,7 @@ class TestBlockHeaderValidation:
     async def test_all_overflow(self, empty_blockchain: Blockchain, bt: BlockTools) -> None:
         blockchain = empty_blockchain
         num_rounds = 5
-        blocks: List[FullBlock] = []
+        blocks: list[FullBlock] = []
         num_blocks = 0
         for i in range(1, num_rounds):
             num_blocks += i
@@ -399,7 +390,7 @@ class TestBlockHeaderValidation:
     ) -> None:
         blockchain = empty_blockchain
 
-        blocks: List[FullBlock] = []
+        blocks: list[FullBlock] = []
         while True:
             # This creates an overflow block, then a normal block, and then an overflow in the next sub-slot
             # blocks = bt.get_consecutive_blocks(1, block_list_input=blocks, force_overflow=True)
@@ -447,7 +438,7 @@ class TestBlockHeaderValidation:
     async def test_one_sb_per_two_slots(self, empty_blockchain: Blockchain, bt: BlockTools) -> None:
         blockchain = empty_blockchain
         num_blocks = 20
-        blocks: List[FullBlock] = []
+        blocks: list[FullBlock] = []
         for _ in range(num_blocks):  # Same thing, but 2 sub-slots per block
             blocks = bt.get_consecutive_blocks(1, block_list_input=blocks, skip_slots=2)
             await _validate_and_add_block(blockchain, blocks[-1])
@@ -459,7 +450,7 @@ class TestBlockHeaderValidation:
     async def test_one_sb_per_five_slots(self, empty_blockchain: Blockchain, bt: BlockTools) -> None:
         blockchain = empty_blockchain
         num_blocks = 10
-        blocks: List[FullBlock] = []
+        blocks: list[FullBlock] = []
         for _ in range(num_blocks):  # Same thing, but 5 sub-slots per block
             blocks = bt.get_consecutive_blocks(1, block_list_input=blocks, skip_slots=5)
             await _validate_and_add_block(blockchain, blocks[-1])
@@ -480,7 +471,7 @@ class TestBlockHeaderValidation:
     async def test_one_sb_per_two_slots_force_overflow(self, empty_blockchain: Blockchain, bt: BlockTools) -> None:
         blockchain = empty_blockchain
         num_blocks = 10
-        blocks: List[FullBlock] = []
+        blocks: list[FullBlock] = []
         for _ in range(num_blocks):
             blocks = bt.get_consecutive_blocks(1, block_list_input=blocks, skip_slots=2, force_overflow=True)
             await _validate_and_add_block(blockchain, blocks[-1])
@@ -519,14 +510,12 @@ class TestBlockHeaderValidation:
             blocks[0], "finished_sub_slots", [new_finished_ss] + blocks[0].finished_sub_slots[1:]
         )
 
-        header_block_bad = get_block_header(block_0_bad, [], [])
+        header_block_bad = get_block_header(block_0_bad)
+        expected_vs = ValidationState(
+            empty_blockchain.constants.SUB_SLOT_ITERS_STARTING, empty_blockchain.constants.DIFFICULTY_STARTING, None
+        )
         _, error = validate_finished_header_block(
-            empty_blockchain.constants,
-            empty_blockchain,
-            header_block_bad,
-            False,
-            empty_blockchain.constants.DIFFICULTY_STARTING,
-            empty_blockchain.constants.SUB_SLOT_ITERS_STARTING,
+            empty_blockchain.constants, empty_blockchain, header_block_bad, False, expected_vs
         )
 
         assert error is not None
@@ -550,17 +539,13 @@ class TestBlockHeaderValidation:
         )
 
         await _validate_and_add_block(empty_blockchain, blocks[0])
-        header_block_bad = get_block_header(block_1_bad, [], [])
+        header_block_bad = get_block_header(block_1_bad)
         # TODO: Inspect these block values as they are currently None
         expected_difficulty = blocks[1].finished_sub_slots[0].challenge_chain.new_difficulty or uint64(0)
         expected_sub_slot_iters = blocks[1].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_difficulty,
-            expected_sub_slot_iters,
+            empty_blockchain.constants, empty_blockchain, header_block_bad, False, expected_vs
         )
         assert error is not None
         assert error.code == Err.INVALID_PREV_CHALLENGE_SLOT_HASH
@@ -581,17 +566,13 @@ class TestBlockHeaderValidation:
         )
         await _validate_and_add_block(empty_blockchain, blocks[0])
 
-        header_block_bad = get_block_header(block_1_bad, [], [])
+        header_block_bad = get_block_header(block_1_bad)
         # TODO: Inspect these block values as they are currently None
         expected_difficulty = blocks[1].finished_sub_slots[0].challenge_chain.new_difficulty or uint64(0)
         expected_sub_slot_iters = blocks[1].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_difficulty,
-            expected_sub_slot_iters,
+            empty_blockchain.constants, empty_blockchain, header_block_bad, False, expected_vs
         )
         assert error is not None
         assert error.code == Err.INVALID_PREV_CHALLENGE_SLOT_HASH
@@ -606,7 +587,7 @@ class TestBlockHeaderValidation:
             "infused_challenge_chain",
             InfusedChallengeChainSubSlot(
                 VDFInfo(
-                    bytes32([0] * 32),
+                    bytes32.zeros,
                     uint64(1200),
                     ClassgroupElement.get_default_element(),
                 )
@@ -627,7 +608,7 @@ class TestBlockHeaderValidation:
             ),
             keychain=keychain,
         )
-        async with create_blockchain(bt_high_iters.constants, db_version) as (bc1, db_wrapper):
+        async with create_blockchain(bt_high_iters.constants, db_version) as (bc1, _):
             blocks = bt_high_iters.get_consecutive_blocks(10)
             for block in blocks:
                 if (
@@ -677,7 +658,7 @@ class TestBlockHeaderValidation:
                             block.finished_sub_slots[
                                 -1
                             ].infused_challenge_chain.infused_challenge_chain_end_of_slot_vdf.replace(
-                                challenge=bytes32([0] * 32)
+                                challenge=bytes32.zeros
                             )
                         ),
                     )
@@ -740,17 +721,13 @@ class TestBlockHeaderValidation:
                     block, "finished_sub_slots", block.finished_sub_slots[:-1] + [new_finished_ss]
                 )
 
-                header_block_bad = get_block_header(block_bad, [], [])
+                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_difficulty,
-                    expected_sub_slot_iters,
+                    empty_blockchain.constants, empty_blockchain, header_block_bad, False, expected_vs
                 )
                 assert error is not None
                 assert error.code == Err.INVALID_ICC_HASH_CC
@@ -815,14 +792,12 @@ class TestBlockHeaderValidation:
             blocks[-1], "finished_sub_slots", blocks[-1].finished_sub_slots[:-1] + [new_finished_ss]
         )
 
-        header_block_bad = get_block_header(block_bad, [], [])
+        header_block_bad = get_block_header(block_bad)
+        expected_vs = ValidationState(
+            empty_blockchain.constants.SUB_SLOT_ITERS_STARTING, empty_blockchain.constants.DIFFICULTY_STARTING, None
+        )
         _, error = validate_finished_header_block(
-            empty_blockchain.constants,
-            empty_blockchain,
-            header_block_bad,
-            False,
-            empty_blockchain.constants.DIFFICULTY_STARTING,
-            empty_blockchain.constants.SUB_SLOT_ITERS_STARTING,
+            empty_blockchain.constants, empty_blockchain, header_block_bad, False, expected_vs
         )
         assert error is not None
         assert error.code == Err.INVALID_SUB_EPOCH_SUMMARY_HASH
@@ -830,7 +805,7 @@ class TestBlockHeaderValidation:
 
     @pytest.mark.anyio
     async def test_empty_sub_slots_epoch(
-        self, empty_blockchain: Blockchain, default_400_blocks: List[FullBlock], bt: BlockTools
+        self, empty_blockchain: Blockchain, default_400_blocks: list[FullBlock], bt: BlockTools
     ) -> None:
         # 2m
         # Tests adding an empty sub slot after the sub-epoch / epoch.
@@ -871,7 +846,7 @@ class TestBlockHeaderValidation:
     @pytest.mark.anyio
     async def test_invalid_cc_sub_slot_vdf(self, empty_blockchain: Blockchain, bt: BlockTools) -> None:
         # 2q
-        blocks: List[FullBlock] = []
+        blocks: list[FullBlock] = []
         found_overflow_slot: bool = False
 
         while not found_overflow_slot:
@@ -969,7 +944,7 @@ class TestBlockHeaderValidation:
     @pytest.mark.anyio
     async def test_invalid_rc_sub_slot_vdf(self, empty_blockchain: Blockchain, bt: BlockTools) -> None:
         # 2p
-        blocks: List[FullBlock] = []
+        blocks: list[FullBlock] = []
         found_block: bool = False
 
         while not found_block:
@@ -1099,7 +1074,7 @@ class TestBlockHeaderValidation:
             recursive_replace(
                 block.finished_sub_slots[0].challenge_chain,
                 "subepoch_summary_hash",
-                bytes32([0] * 32),
+                bytes32.zeros,
             ),
         )
 
@@ -1134,7 +1109,7 @@ class TestBlockHeaderValidation:
                     recursive_replace(
                         blocks[-1].finished_sub_slots[0].challenge_chain,
                         "subepoch_summary_hash",
-                        bytes32([0] * 32),
+                        bytes32.zeros,
                     ),
                 )
 
@@ -1222,7 +1197,7 @@ class TestBlockHeaderValidation:
     @pytest.mark.anyio
     async def test_sp_0_no_sp(self, empty_blockchain: Blockchain, bt: BlockTools) -> None:
         # 7
-        blocks: List[FullBlock] = []
+        blocks: list[FullBlock] = []
         case_1, case_2 = False, False
         while not case_1 or not case_2:
             blocks = bt.get_consecutive_blocks(1, block_list_input=blocks)
@@ -1819,67 +1794,63 @@ class TestPreValidation:
         block_bad = recursive_replace(
             blocks[-1], "reward_chain_block.total_iters", blocks[-1].reward_chain_block.total_iters + 1
         )
-        res = await pre_validate_blocks_multiprocessing(
-            empty_blockchain.constants,
-            empty_blockchain,
-            [blocks[0], block_bad],
-            empty_blockchain.pool,
-            {},
-            sub_slot_iters=ssi,
-            difficulty=difficulty,
-            prev_ses_block=None,
-            validate_signatures=True,
-        )
+        futures = []
+        vs = ValidationState(ssi, difficulty, None)
+        chain = AugmentedBlockchain(empty_blockchain)
+        for block in [blocks[0], block_bad]:
+            futures.append(
+                await pre_validate_block(
+                    empty_blockchain.constants,
+                    chain,
+                    block,
+                    empty_blockchain.pool,
+                    None,
+                    vs,
+                )
+            )
+        res: list[PreValidationResult] = list(await asyncio.gather(*futures))
         assert res[0].error is None
         assert res[1].error is not None
 
     @pytest.mark.anyio
     async def test_pre_validation(
-        self, empty_blockchain: Blockchain, default_1000_blocks: List[FullBlock], bt: BlockTools
+        self, empty_blockchain: Blockchain, default_1000_blocks: list[FullBlock], bt: BlockTools
     ) -> None:
         blocks = default_1000_blocks[:100]
         start = time.time()
-        n_at_a_time = min(available_logical_cores(), 32)
-        times_pv = []
-        times_rb = []
         ssi = empty_blockchain.constants.SUB_SLOT_ITERS_STARTING
         difficulty = empty_blockchain.constants.DIFFICULTY_STARTING
-        for i in range(0, len(blocks), n_at_a_time):
-            end_i = min(i + n_at_a_time, len(blocks))
-            blocks_to_validate = blocks[i:end_i]
-            start_pv = time.time()
-            res = await pre_validate_blocks_multiprocessing(
-                empty_blockchain.constants,
-                empty_blockchain,
-                blocks_to_validate,
-                empty_blockchain.pool,
-                {},
-                sub_slot_iters=ssi,
-                difficulty=difficulty,
-                prev_ses_block=None,
-                validate_signatures=True,
-            )
-            end_pv = time.time()
-            times_pv.append(end_pv - start_pv)
-            assert res is not None
-            for n in range(end_i - i):
-                assert res[n] is not None
-                assert res[n].error is None
-                block = blocks_to_validate[n]
-                start_rb = time.time()
-                result, err, _ = await empty_blockchain.add_block(block, res[n], None, ssi)
-                end_rb = time.time()
-                times_rb.append(end_rb - start_rb)
-                assert err is None
-                assert result == AddBlockResult.NEW_PEAK
-                log.info(
-                    f"Added block {block.height} total iters {block.total_iters} "
-                    f"new slot? {len(block.finished_sub_slots)}, time {end_rb - start_rb}"
+        blockchain = AugmentedBlockchain(empty_blockchain)
+        vs = ValidationState(ssi, difficulty, None)
+        futures: list[Awaitable[PreValidationResult]] = []
+        start = time.monotonic()
+        for block in blocks:
+            futures.append(
+                await pre_validate_block(
+                    bt.constants,
+                    blockchain,
+                    block,
+                    empty_blockchain.pool,
+                    None,
+                    vs,
                 )
-        end = time.time()
+            )
+
+        results = await asyncio.gather(*futures)
+        end = time.monotonic()
+        validation_time = start - end
+        db_start = end
+
+        fork_info = ForkInfo(-1, -1, bt.constants.GENESIS_CHALLENGE)
+        for block, res in zip(blocks, results):
+            assert res.error is None
+            result, err, _ = await empty_blockchain.add_block(block, res, ssi, fork_info=fork_info)
+            assert err is None
+            assert result == AddBlockResult.NEW_PEAK
+        end = time.monotonic()
         log.info(f"Total time: {end - start} seconds")
-        log.info(f"Average pv: {sum(times_pv)/(len(blocks)/n_at_a_time)}")
-        log.info(f"Average rb: {sum(times_rb)/(len(blocks))}")
+        log.info(f"Average validation: {validation_time / len(blocks)}")
+        log.info(f"Average database: {(end - db_start) / (len(blocks))}")
 
 
 class TestBodyValidation:
@@ -1939,7 +1910,7 @@ class TestBodyValidation:
         else:
             assert False
 
-        conditions: Dict[ConditionOpcode, List[ConditionWithArgs]] = {
+        conditions: dict[ConditionOpcode, list[ConditionWithArgs]] = {
             opcode: [ConditionWithArgs(opcode, args + ([b"garbage"] if with_garbage else []))]
         }
 
@@ -1956,20 +1927,20 @@ class TestBodyValidation:
         )
         ssi = b.constants.SUB_SLOT_ITERS_STARTING
         diff = b.constants.DIFFICULTY_STARTING
-        pre_validation_results: List[PreValidationResult] = await pre_validate_blocks_multiprocessing(
+        block = blocks[-1]
+        future = await pre_validate_block(
             b.constants,
-            b,
-            [blocks[-1]],
+            AugmentedBlockchain(b),
+            block,
             b.pool,
-            {},
-            sub_slot_iters=ssi,
-            difficulty=diff,
-            prev_ses_block=None,
-            validate_signatures=False,
+            None,
+            ValidationState(ssi, diff, None),
         )
+        pre_validation_result: PreValidationResult = await future
         # Ignore errors from pre-validation, we are testing block_body_validation
-        repl_preval_results = replace(pre_validation_results[0], error=None, required_iters=uint64(1))
-        code, err, state_change = await b.add_block(blocks[-1], repl_preval_results, None, sub_slot_iters=ssi)
+        repl_preval_results = replace(pre_validation_result, error=None, required_iters=uint64(1))
+        fork_info = ForkInfo(block.height - 1, block.height - 1, block.prev_header_hash)
+        code, err, state_change = await b.add_block(block, repl_preval_results, sub_slot_iters=ssi, fork_info=fork_info)
         assert code == AddBlockResult.NEW_PEAK
         assert err is None
         assert state_change is not None
@@ -2080,19 +2051,20 @@ class TestBodyValidation:
             )
             ssi = b.constants.SUB_SLOT_ITERS_STARTING
             diff = b.constants.DIFFICULTY_STARTING
-            pre_validation_results: List[PreValidationResult] = await pre_validate_blocks_multiprocessing(
+            block = blocks[-1]
+            future = await pre_validate_block(
                 b.constants,
-                b,
-                [blocks[-1]],
+                AugmentedBlockchain(b),
+                block,
                 b.pool,
-                {},
-                sub_slot_iters=ssi,
-                difficulty=diff,
-                prev_ses_block=None,
-                validate_signatures=True,
+                None,
+                ValidationState(ssi, diff, None),
             )
-            assert pre_validation_results is not None
-            assert (await b.add_block(blocks[-1], pre_validation_results[0], None, sub_slot_iters=ssi))[0] == expected
+            pre_validation_result: PreValidationResult = await future
+            fork_info = ForkInfo(block.height - 1, block.height - 1, block.prev_header_hash)
+            assert (await b.add_block(block, pre_validation_result, sub_slot_iters=ssi, fork_info=fork_info))[
+                0
+            ] == expected
 
             if expected == AddBlockResult.NEW_PEAK:
                 # ensure coin was in fact spent
@@ -2161,20 +2133,22 @@ class TestBodyValidation:
         )
         ssi = b.constants.SUB_SLOT_ITERS_STARTING
         diff = b.constants.DIFFICULTY_STARTING
-        pre_validation_results: List[PreValidationResult] = await pre_validate_blocks_multiprocessing(
+        block = blocks[-1]
+        future = await pre_validate_block(
             b.constants,
-            b,
-            [blocks[-1]],
+            AugmentedBlockchain(b),
+            block,
             b.pool,
-            {},
-            sub_slot_iters=ssi,
-            difficulty=diff,
-            prev_ses_block=None,
-            validate_signatures=False,
+            None,
+            ValidationState(ssi, diff, None),
         )
+        pre_validation_result: PreValidationResult = await future
         # Ignore errors from pre-validation, we are testing block_body_validation
-        repl_preval_results = replace(pre_validation_results[0], error=None, required_iters=uint64(1))
-        res, error, state_change = await b.add_block(blocks[-1], repl_preval_results, None, sub_slot_iters=ssi)
+        repl_preval_results = replace(pre_validation_result, error=None, required_iters=uint64(1))
+        fork_info = ForkInfo(block.height - 1, block.height - 1, block.prev_header_hash)
+        res, error, state_change = await b.add_block(
+            block, repl_preval_results, sub_slot_iters=ssi, fork_info=fork_info
+        )
         assert res == AddBlockResult.NEW_PEAK
         assert error is None
         assert state_change is not None and state_change.fork_height == uint32(2)
@@ -2287,19 +2261,20 @@ class TestBodyValidation:
             )
             ssi = b.constants.SUB_SLOT_ITERS_STARTING
             diff = b.constants.DIFFICULTY_STARTING
-            pre_validation_results: List[PreValidationResult] = await pre_validate_blocks_multiprocessing(
+            block = blocks[-1]
+            future = await pre_validate_block(
                 b.constants,
-                b,
-                [blocks[-1]],
+                AugmentedBlockchain(b),
+                block,
                 b.pool,
-                {},
-                sub_slot_iters=ssi,
-                difficulty=diff,
-                prev_ses_block=None,
-                validate_signatures=True,
+                None,
+                ValidationState(ssi, diff, None),
             )
-            assert pre_validation_results is not None
-            assert (await b.add_block(blocks[-1], pre_validation_results[0], None, sub_slot_iters=ssi))[0] == expected
+            pre_validation_result: PreValidationResult = await future
+            fork_info = ForkInfo(block.height - 1, block.height - 1, block.prev_header_hash)
+            assert (await b.add_block(block, pre_validation_result, sub_slot_iters=ssi, fork_info=fork_info))[
+                0
+            ] == expected
 
             if expected == AddBlockResult.NEW_PEAK:
                 # ensure coin1 was in fact spent
@@ -2432,8 +2407,9 @@ class TestBodyValidation:
 
         # Too many
         h = std_hash(b"")
-        too_many_reward_claims = block.transactions_info.reward_claims_incorporated + [
-            Coin(h, h, too_few_reward_claims[0].amount)
+        too_many_reward_claims = [
+            *block.transactions_info.reward_claims_incorporated,
+            Coin(h, h, too_few_reward_claims[0].amount),
         ]
         block_2 = recursive_replace(block, "transactions_info.reward_claims_incorporated", too_many_reward_claims)
         assert block_2.transactions_info is not None
@@ -2452,8 +2428,9 @@ class TestBodyValidation:
         await _validate_and_add_block(b, block_2, expected_error=Err.INVALID_REWARD_COINS, skip_prevalidation=True)
 
         # Duplicates
-        duplicate_reward_claims = block.transactions_info.reward_claims_incorporated + [
-            block.transactions_info.reward_claims_incorporated[-1]
+        duplicate_reward_claims = [
+            *block.transactions_info.reward_claims_incorporated,
+            block.transactions_info.reward_claims_incorporated[-1],
         ]
         block_2 = recursive_replace(block, "transactions_info.reward_claims_incorporated", duplicate_reward_claims)
         assert block_2.transactions_info is not None
@@ -2615,7 +2592,7 @@ class TestBodyValidation:
 
         wt: WalletTool = bt.get_pool_wallet_tool()
 
-        condition_dict: Dict[ConditionOpcode, List[ConditionWithArgs]] = {ConditionOpcode.CREATE_COIN: []}
+        condition_dict: dict[ConditionOpcode, list[ConditionWithArgs]] = {ConditionOpcode.CREATE_COIN: []}
         for i in range(7_000):
             output = ConditionWithArgs(ConditionOpcode.CREATE_COIN, [bt.pool_ph, int_to_bytes(i)])
             condition_dict[ConditionOpcode.CREATE_COIN].append(output)
@@ -2629,6 +2606,7 @@ class TestBodyValidation:
         )
 
         assert blocks[-1].transactions_generator is not None
+        assert blocks[-1].transactions_info is not None
         block_generator = BlockGenerator(blocks[-1].transactions_generator, [])
         npc_result = get_name_puzzle_conditions(
             block_generator,
@@ -2637,30 +2615,30 @@ class TestBodyValidation:
             height=softfork_height,
             constants=bt.constants,
         )
+        assert npc_result.conds is not None
         ssi = b.constants.SUB_SLOT_ITERS_STARTING
         diff = b.constants.DIFFICULTY_STARTING
+        block = blocks[-1]
+        fork_info = ForkInfo(block.height - 1, block.height - 1, block.prev_header_hash)
         err = (
             await b.add_block(
                 blocks[-1],
-                PreValidationResult(None, uint64(1), npc_result.conds, True, uint32(0)),
-                None,
+                PreValidationResult(None, uint64(1), npc_result.conds.replace(validated_signature=True), uint32(0)),
                 sub_slot_iters=ssi,
+                fork_info=fork_info,
             )
         )[1]
-        assert err in [Err.BLOCK_COST_EXCEEDS_MAX]
-        results: List[PreValidationResult] = await pre_validate_blocks_multiprocessing(
+        assert err == Err.BLOCK_COST_EXCEEDS_MAX
+        future = await pre_validate_block(
             b.constants,
-            b,
-            [blocks[-1]],
+            AugmentedBlockchain(b),
+            blocks[-1],
             b.pool,
-            {},
-            sub_slot_iters=ssi,
-            difficulty=diff,
-            prev_ses_block=None,
-            validate_signatures=False,
+            None,
+            ValidationState(ssi, diff, None),
         )
-        assert results is not None
-        assert Err(results[0].error) == Err.BLOCK_COST_EXCEEDS_MAX
+        result: PreValidationResult = await future
+        assert Err(result.error) == Err.BLOCK_COST_EXCEEDS_MAX
 
     @pytest.mark.anyio
     async def test_clvm_must_not_fail(self, empty_blockchain: Blockchain, bt: BlockTools) -> None:
@@ -2718,9 +2696,14 @@ class TestBodyValidation:
             height=softfork_height,
             constants=bt.constants,
         )
+        assert npc_result.conds is not None
         ssi = b.constants.SUB_SLOT_ITERS_STARTING
+        fork_info = ForkInfo(block_2.height - 1, block_2.height - 1, block_2.prev_header_hash)
         _, err, _ = await b.add_block(
-            block_2, PreValidationResult(None, uint64(1), npc_result.conds, False, uint32(0)), None, sub_slot_iters=ssi
+            block_2,
+            PreValidationResult(None, uint64(1), npc_result.conds.replace(validated_signature=True), uint32(0)),
+            sub_slot_iters=ssi,
+            fork_info=fork_info,
         )
         assert err == Err.INVALID_BLOCK_COST
 
@@ -2748,8 +2731,13 @@ class TestBodyValidation:
             height=softfork_height,
             constants=bt.constants,
         )
+        assert npc_result.conds is not None
+        fork_info = ForkInfo(block_2.height - 1, block_2.height - 1, block_2.prev_header_hash)
         _, err, _ = await b.add_block(
-            block_2, PreValidationResult(None, uint64(1), npc_result.conds, False, uint32(0)), None, sub_slot_iters=ssi
+            block_2,
+            PreValidationResult(None, uint64(1), npc_result.conds.replace(validated_signature=True), uint32(0)),
+            sub_slot_iters=ssi,
+            fork_info=fork_info,
         )
         assert err == Err.INVALID_BLOCK_COST
 
@@ -2776,11 +2764,19 @@ class TestBodyValidation:
             else b.constants.MAX_BLOCK_COST_CLVM * 1000
         )
         npc_result = get_name_puzzle_conditions(
-            block_generator, max_cost, mempool_mode=False, height=softfork_height, constants=bt.constants
+            block_generator,
+            max_cost,
+            mempool_mode=False,
+            height=softfork_height,
+            constants=bt.constants,
         )
-
-        result, err, _ = await b.add_block(
-            block_2, PreValidationResult(None, uint64(1), npc_result.conds, False, uint32(0)), None, sub_slot_iters=ssi
+        assert npc_result.conds is not None
+        fork_info = ForkInfo(block_2.height - 1, block_2.height - 1, block_2.prev_header_hash)
+        _result, err, _ = await b.add_block(
+            block_2,
+            PreValidationResult(None, uint64(1), npc_result.conds.replace(validated_signature=True), uint32(0)),
+            sub_slot_iters=ssi,
+            fork_info=fork_info,
         )
         assert err == Err.INVALID_BLOCK_COST
 
@@ -2817,7 +2813,7 @@ class TestBodyValidation:
 
         #     wt: WalletTool = bt_2.get_pool_wallet_tool()
 
-        #     condition_dict: Dict[ConditionOpcode, List[ConditionWithArgs]] = {ConditionOpcode.CREATE_COIN: []}
+        #     condition_dict: dict[ConditionOpcode, list[ConditionWithArgs]] = {ConditionOpcode.CREATE_COIN: []}
         #     output = ConditionWithArgs(ConditionOpcode.CREATE_COIN, [bt_2.pool_ph, int_to_bytes(2 ** 64)])
         #     condition_dict[ConditionOpcode.CREATE_COIN].append(output)
 
@@ -2935,7 +2931,7 @@ class TestBodyValidation:
 
         wt: WalletTool = bt.get_pool_wallet_tool()
 
-        condition_dict: Dict[ConditionOpcode, List[ConditionWithArgs]] = {ConditionOpcode.CREATE_COIN: []}
+        condition_dict: dict[ConditionOpcode, list[ConditionWithArgs]] = {ConditionOpcode.CREATE_COIN: []}
         for _ in range(2):
             output = ConditionWithArgs(ConditionOpcode.CREATE_COIN, [bt.pool_ph, int_to_bytes(1)])
             condition_dict[ConditionOpcode.CREATE_COIN].append(output)
@@ -3048,27 +3044,40 @@ class TestBodyValidation:
             await _validate_and_add_block(b, block)
 
         blocks_reorg = bt.get_consecutive_blocks(2, block_list_input=blocks[:-7], guarantee_transaction_block=True)
-        await _validate_and_add_block(b, blocks_reorg[-2], expected_result=AddBlockResult.ADDED_AS_ORPHAN)
-        await _validate_and_add_block(b, blocks_reorg[-1], expected_result=AddBlockResult.ADDED_AS_ORPHAN)
+        fork_info = ForkInfo(blocks[-8].height, blocks[-8].height, blocks[-8].header_hash)
+        await _validate_and_add_block(
+            b, blocks_reorg[-2], expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info
+        )
+        await _validate_and_add_block(
+            b, blocks_reorg[-1], expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info
+        )
 
         # Coin does not exist in reorg
         blocks_reorg = bt.get_consecutive_blocks(
             1, block_list_input=blocks_reorg, guarantee_transaction_block=True, transaction_data=tx_2
         )
-
-        await _validate_and_add_block(b, blocks_reorg[-1], expected_error=Err.UNKNOWN_UNSPENT)
+        peak = b.get_peak()
+        assert peak is not None
+        await _validate_and_add_block(b, blocks_reorg[-1], expected_error=Err.UNKNOWN_UNSPENT, fork_info=fork_info)
 
         # Finally add the block to the fork (spending both in same bundle, this is ephemeral)
         agg = SpendBundle.aggregate([tx, tx_2])
         blocks_reorg = bt.get_consecutive_blocks(
             1, block_list_input=blocks_reorg[:-1], guarantee_transaction_block=True, transaction_data=agg
         )
-        await _validate_and_add_block(b, blocks_reorg[-1], expected_result=AddBlockResult.ADDED_AS_ORPHAN)
+
+        peak = b.get_peak()
+        assert peak is not None
+        await _validate_and_add_block(
+            b, blocks_reorg[-1], expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info
+        )
 
         blocks_reorg = bt.get_consecutive_blocks(
             1, block_list_input=blocks_reorg, guarantee_transaction_block=True, transaction_data=tx_2
         )
-        await _validate_and_add_block(b, blocks_reorg[-1], expected_error=Err.DOUBLE_SPEND_IN_FORK)
+        peak = b.get_peak()
+        assert peak is not None
+        await _validate_and_add_block(b, blocks_reorg[-1], expected_error=Err.DOUBLE_SPEND_IN_FORK, fork_info=fork_info)
 
         rewards_ph = wt.get_new_puzzlehash()
         blocks_reorg = bt.get_consecutive_blocks(
@@ -3077,9 +3086,12 @@ class TestBodyValidation:
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=rewards_ph,
         )
+
+        peak = b.get_peak()
+        assert peak is not None
         for block in blocks_reorg[-10:]:
             await _validate_and_add_block_multi_result(
-                b, block, expected_result=[AddBlockResult.ADDED_AS_ORPHAN, AddBlockResult.NEW_PEAK]
+                b, block, expected_result=[AddBlockResult.ADDED_AS_ORPHAN, AddBlockResult.NEW_PEAK], fork_info=fork_info
             )
 
         # ephemeral coin is spent
@@ -3221,25 +3233,20 @@ class TestBodyValidation:
 
         # Bad signature fails during add_block
         await _validate_and_add_block(b, last_block, expected_error=Err.BAD_AGGREGATE_SIGNATURE)
-        # Also test the same case but when using BLSCache
-        await _validate_and_add_block(b, last_block, expected_error=Err.BAD_AGGREGATE_SIGNATURE, use_bls_cache=True)
 
         # Bad signature also fails in prevalidation
         ssi = b.constants.SUB_SLOT_ITERS_STARTING
         diff = b.constants.DIFFICULTY_STARTING
-        preval_results = await pre_validate_blocks_multiprocessing(
+        future = await pre_validate_block(
             b.constants,
-            b,
-            [last_block],
+            AugmentedBlockchain(b),
+            last_block,
             b.pool,
-            {},
-            sub_slot_iters=ssi,
-            difficulty=diff,
-            prev_ses_block=None,
-            validate_signatures=True,
+            None,
+            ValidationState(ssi, diff, None),
         )
-        assert preval_results is not None
-        assert preval_results[0].error == Err.BAD_AGGREGATE_SIGNATURE.value
+        preval_result: PreValidationResult = await future
+        assert preval_result.error == Err.BAD_AGGREGATE_SIGNATURE.value
 
 
 def maybe_header_hash(block: Optional[BlockRecord]) -> Optional[bytes32]:
@@ -3261,13 +3268,18 @@ class TestReorgs:
         assert peak.height == 14
 
         blocks_reorg_chain = bt.get_consecutive_blocks(7, blocks[:10], seed=b"2")
+        fork_info = ForkInfo(-1, -1, bt.constants.GENESIS_CHALLENGE)
         for reorg_block in blocks_reorg_chain:
             if reorg_block.height < 10:
-                await _validate_and_add_block(b, reorg_block, expected_result=AddBlockResult.ALREADY_HAVE_BLOCK)
+                await _validate_and_add_block(
+                    b, reorg_block, expected_result=AddBlockResult.ALREADY_HAVE_BLOCK, fork_info=fork_info
+                )
             elif reorg_block.height < 15:
-                await _validate_and_add_block(b, reorg_block, expected_result=AddBlockResult.ADDED_AS_ORPHAN)
+                await _validate_and_add_block(
+                    b, reorg_block, expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info
+                )
             elif reorg_block.height >= 15:
-                await _validate_and_add_block(b, reorg_block)
+                await _validate_and_add_block(b, reorg_block, fork_info=fork_info)
         peak = b.get_peak()
         assert peak is not None
         assert peak.height == 16
@@ -3296,16 +3308,19 @@ class TestReorgs:
         assert maybe_header_hash(b.get_tx_peak()) == last_tx_block
 
         reorg_last_tx_block: Optional[bytes32] = 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")
         assert blocks_reorg_chain[reorg_point].is_transaction_block() is False
         for reorg_block in blocks_reorg_chain:
             if reorg_block.height < 10:
                 await _validate_and_add_block(b, reorg_block, expected_result=AddBlockResult.ALREADY_HAVE_BLOCK)
             elif reorg_block.height < reorg_point:
-                await _validate_and_add_block(b, reorg_block, expected_result=AddBlockResult.ADDED_AS_ORPHAN)
+                await _validate_and_add_block(
+                    b, reorg_block, expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info
+                )
             elif reorg_block.height >= reorg_point:
-                await _validate_and_add_block(b, reorg_block)
+                await _validate_and_add_block(b, reorg_block, fork_info=fork_info)
 
             if reorg_block.is_transaction_block():
                 reorg_last_tx_block = reorg_block.header_hash
@@ -3324,9 +3339,9 @@ class TestReorgs:
         self,
         light_blocks: bool,
         empty_blockchain: Blockchain,
-        default_10000_blocks: List[FullBlock],
-        test_long_reorg_blocks: List[FullBlock],
-        test_long_reorg_blocks_light: List[FullBlock],
+        default_10000_blocks: list[FullBlock],
+        test_long_reorg_blocks: list[FullBlock],
+        test_long_reorg_blocks_light: list[FullBlock],
     ) -> None:
         if light_blocks:
             reorg_blocks = test_long_reorg_blocks_light[:1650]
@@ -3345,17 +3360,21 @@ class TestReorgs:
         print(f"pre-validating {len(blocks)} blocks")
         ssi = b.constants.SUB_SLOT_ITERS_STARTING
         diff = b.constants.DIFFICULTY_STARTING
-        pre_validation_results: List[PreValidationResult] = await pre_validate_blocks_multiprocessing(
-            b.constants,
-            b,
-            blocks,
-            b.pool,
-            {},
-            sub_slot_iters=ssi,
-            difficulty=diff,
-            prev_ses_block=None,
-            validate_signatures=False,
-        )
+        chain = AugmentedBlockchain(b)
+        vs = ValidationState(ssi, diff, None)
+        futures = []
+        for block in blocks:
+            futures.append(
+                await pre_validate_block(
+                    b.constants,
+                    chain,
+                    block,
+                    b.pool,
+                    None,
+                    vs,
+                )
+            )
+        pre_validation_results: list[PreValidationResult] = list(await asyncio.gather(*futures))
         for i, block in enumerate(blocks):
             if block.height != 0 and len(block.finished_sub_slots) > 0:
                 if block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters is not None:
@@ -3363,7 +3382,12 @@ class TestReorgs:
             assert pre_validation_results[i].error is None
             if (block.height % 100) == 0:
                 print(f"main chain: {block.height:4} weight: {block.weight}")
-            (result, err, _) = await b.add_block(block, pre_validation_results[i], None, sub_slot_iters=ssi)
+
+            fork_info: ForkInfo = ForkInfo(block.height - 1, block.height - 1, block.prev_header_hash)
+            assert fork_info is not None
+            (result, err, _) = await b.add_block(
+                block, pre_validation_results[i], sub_slot_iters=ssi, fork_info=fork_info
+            )
             await check_block_store_invariant(b)
             assert err is None
             assert result == AddBlockResult.NEW_PEAK
@@ -3388,7 +3412,7 @@ class TestReorgs:
         b.clean_block_records()
 
         first_peak = b.get_peak()
-        fork_info: Optional[ForkInfo] = None
+        fork_info2 = None
         for reorg_block in reorg_blocks:
             if (reorg_block.height % 100) == 0:
                 peak = b.get_peak()
@@ -3402,14 +3426,14 @@ class TestReorgs:
             if reorg_block.height < num_blocks_chain_2_start:
                 await _validate_and_add_block(b, reorg_block, expected_result=AddBlockResult.ALREADY_HAVE_BLOCK)
             elif reorg_block.weight <= chain_1_weight:
-                if fork_info is None:
-                    fork_info = ForkInfo(reorg_block.height - 1, reorg_block.height - 1, reorg_block.prev_header_hash)
+                if fork_info2 is None:
+                    fork_info2 = ForkInfo(reorg_block.height - 1, reorg_block.height - 1, reorg_block.prev_header_hash)
                 await _validate_and_add_block(
-                    b, reorg_block, expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info
+                    b, reorg_block, expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info2
                 )
             elif reorg_block.weight > chain_1_weight:
                 await _validate_and_add_block(
-                    b, reorg_block, expected_result=AddBlockResult.NEW_PEAK, fork_info=fork_info
+                    b, reorg_block, expected_result=AddBlockResult.NEW_PEAK, fork_info=fork_info2
                 )
 
         # if these asserts fires, there was no reorg
@@ -3448,7 +3472,7 @@ class TestReorgs:
 
         # start the fork point a few blocks back, to test that the blockchain
         # can catch up
-        fork_block = default_10000_blocks[num_blocks_chain_2_start - 200]
+        fork_block = default_10000_blocks[num_blocks_chain_2_start - 101]
         fork_info = ForkInfo(fork_block.height, fork_block.height, fork_block.header_hash)
         await b.warmup(fork_block.height)
         for block in blocks:
@@ -3476,7 +3500,7 @@ class TestReorgs:
 
     @pytest.mark.anyio
     async def test_long_compact_blockchain(
-        self, empty_blockchain: Blockchain, default_2000_blocks_compact: List[FullBlock]
+        self, empty_blockchain: Blockchain, default_2000_blocks_compact: list[FullBlock]
     ) -> None:
         b = empty_blockchain
         for block in default_2000_blocks_compact:
@@ -3499,22 +3523,34 @@ class TestReorgs:
 
         # Reorg to alternate chain that is 1 height longer
         blocks_reorg_chain = bt.get_consecutive_blocks(16, [], seed=b"2")
+        fork_info = ForkInfo(-1, -1, bt.constants.GENESIS_CHALLENGE)
         for reorg_block in blocks_reorg_chain:
             if reorg_block.height < 15:
                 await _validate_and_add_block_multi_result(
                     b,
                     reorg_block,
                     expected_result=[AddBlockResult.ADDED_AS_ORPHAN, AddBlockResult.ALREADY_HAVE_BLOCK],
+                    fork_info=fork_info,
                 )
             elif reorg_block.height >= 15:
-                await _validate_and_add_block(b, reorg_block)
+                await _validate_and_add_block(b, reorg_block, fork_info=fork_info)
 
         # Back to original chain
         blocks_reorg_chain_2 = bt.get_consecutive_blocks(3, blocks, seed=b"3")
 
-        await _validate_and_add_block(b, blocks_reorg_chain_2[-3], expected_result=AddBlockResult.ADDED_AS_ORPHAN)
-        await _validate_and_add_block(b, blocks_reorg_chain_2[-2])
-        await _validate_and_add_block(b, blocks_reorg_chain_2[-1])
+        # we start from the beginning to make sure fork_info is built correctly
+        fork_info = ForkInfo(-1, -1, bt.constants.GENESIS_CHALLENGE)
+        for reorg_block in blocks_reorg_chain_2:
+            if reorg_block.height < 15:
+                await _validate_and_add_block(
+                    b, reorg_block, expected_result=AddBlockResult.ALREADY_HAVE_BLOCK, fork_info=fork_info
+                )
+            elif reorg_block.height < 16:
+                await _validate_and_add_block(
+                    b, reorg_block, expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info
+                )
+            else:
+                await _validate_and_add_block(b, reorg_block, fork_info=fork_info)
 
         peak = b.get_peak()
         assert peak is not None
@@ -3562,9 +3598,10 @@ class TestReorgs:
         )
         for block in blocks:
             await _validate_and_add_block(b, block)
-
-        for block in blocks_fork:
-            await _validate_and_add_block_no_error(b, block)
+        fork_block = blocks[11]
+        fork_info = ForkInfo(fork_block.height, fork_block.height, fork_block.header_hash)
+        for block in blocks_fork[12:]:
+            await _validate_and_add_block_no_error(b, block, fork_info=fork_info)
 
     @pytest.mark.anyio
     async def test_get_header_blocks_in_range_tx_filter(self, empty_blockchain: Blockchain, bt: BlockTools) -> None:
@@ -3600,7 +3637,7 @@ class TestReorgs:
         assert blocks_with_filter[header_hash].header_hash == blocks_without_filter[header_hash].header_hash
 
     @pytest.mark.anyio
-    async def test_get_blocks_at(self, empty_blockchain: Blockchain, default_1000_blocks: List[FullBlock]) -> None:
+    async def test_get_blocks_at(self, empty_blockchain: Blockchain, default_1000_blocks: list[FullBlock]) -> None:
         b = empty_blockchain
         heights = []
         for block in default_1000_blocks[:200]:
@@ -3678,8 +3715,8 @@ async def test_reorg_new_ref(empty_blockchain: Blockchain, bt: BlockTools) -> No
     )
     blocks_reorg_chain = bt.get_consecutive_blocks(4, blocks_reorg_chain, seed=b"2")
 
+    fork_info = ForkInfo(-1, -1, b.constants.GENESIS_CHALLENGE)
     for i, block in enumerate(blocks_reorg_chain):
-        fork_info: Optional[ForkInfo] = None
         if i < 10:
             expected = AddBlockResult.ALREADY_HAVE_BLOCK
         elif i < 19:
@@ -3693,8 +3730,6 @@ async def test_reorg_new_ref(empty_blockchain: Blockchain, bt: BlockTools) -> No
             expected = AddBlockResult.NEW_PEAK
         else:
             expected = AddBlockResult.NEW_PEAK
-            if fork_info is None:
-                fork_info = ForkInfo(blocks[1].height, blocks[1].height, blocks[1].header_hash)
         await _validate_and_add_block(b, block, expected_result=expected, fork_info=fork_info)
     peak = b.get_peak()
     assert peak is not None
@@ -3746,7 +3781,7 @@ async def test_reorg_stale_fork_height(empty_blockchain: Blockchain, bt: BlockTo
         await _validate_and_add_block(b, block, expected_result=AddBlockResult.NEW_PEAK)
 
     # fake the fork_info to make every new block look like a reorg
-    fork_info = ForkInfo(blocks[1].height, blocks[1].height, blocks[1].header_hash)
+    fork_info = ForkInfo(blocks[4].height, blocks[4].height, blocks[4].header_hash)
     for block in blocks[5:]:
         await _validate_and_add_block(b, block, expected_result=AddBlockResult.NEW_PEAK, fork_info=fork_info)
     peak = b.get_peak()
@@ -3796,8 +3831,10 @@ async def test_chain_failed_rollback(empty_blockchain: Blockchain, bt: BlockTool
         guarantee_transaction_block=True,
     )
 
+    fork_block = blocks_reorg_chain[9]
+    fork_info = ForkInfo(fork_block.height, fork_block.height, fork_block.header_hash)
     for block in blocks_reorg_chain[10:-1]:
-        await _validate_and_add_block(b, block, expected_result=AddBlockResult.ADDED_AS_ORPHAN)
+        await _validate_and_add_block(b, block, expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info)
 
     # Incorrectly set the height as spent in DB to trigger an error
     print(f"{await b.coin_store.get_coin_record(spend_bundle.coin_spends[0].coin.name())}")
@@ -3806,8 +3843,10 @@ async def test_chain_failed_rollback(empty_blockchain: Blockchain, bt: BlockTool
     await b.coin_store.rollback_to_block(2)
     print(f"{await b.coin_store.get_coin_record(spend_bundle.coin_spends[0].coin.name())}")
 
+    fork_block = blocks_reorg_chain[10 - 1]
+    # fork_info = ForkInfo(fork_block.height, fork_block.height, fork_block.header_hash)
     with pytest.raises(ValueError, match="Invalid operation to set spent"):
-        await _validate_and_add_block(b, blocks_reorg_chain[-1])
+        await _validate_and_add_block(b, blocks_reorg_chain[-1], fork_info=fork_info)
 
     peak = b.get_peak()
     assert peak is not None
@@ -3906,31 +3945,37 @@ async def test_reorg_flip_flop(empty_blockchain: Blockchain, bt: BlockTools) ->
             block1, block2 = b1, b2
         counter += 1
 
-        preval: List[PreValidationResult] = await pre_validate_blocks_multiprocessing(
-            b.constants,
-            b,
-            [block1],
-            b.pool,
-            {},
-            sub_slot_iters=ssi,
-            difficulty=diff,
-            prev_ses_block=None,
-            validate_signatures=False,
+        preval = await (
+            await pre_validate_block(
+                b.constants,
+                AugmentedBlockchain(b),
+                block1,
+                b.pool,
+                None,
+                ValidationState(ssi, diff, None),
+            )
         )
-        _, err, _ = await b.add_block(block1, preval[0], None, sub_slot_iters=ssi)
+        peak = b.get_peak()
+        if peak is None:
+            fork_info = ForkInfo(-1, -1, bt.constants.GENESIS_CHALLENGE)
+        else:
+            fork_info = await get_fork_info(b, block1, peak)
+        _, err, _ = await b.add_block(block1, preval, sub_slot_iters=ssi, fork_info=fork_info)
         assert err is None
-        preval = await pre_validate_blocks_multiprocessing(
-            b.constants,
-            b,
-            [block2],
-            b.pool,
-            {},
-            sub_slot_iters=ssi,
-            difficulty=diff,
-            prev_ses_block=None,
-            validate_signatures=False,
+        preval = await (
+            await pre_validate_block(
+                b.constants,
+                AugmentedBlockchain(b),
+                block2,
+                b.pool,
+                None,
+                ValidationState(ssi, diff, None),
+            )
         )
-        _, err, _ = await b.add_block(block2, preval[0], None, sub_slot_iters=ssi)
+        peak = b.get_peak()
+        assert peak is not None
+        fork_info = await get_fork_info(b, block2, peak)
+        _, err, _ = await b.add_block(block2, preval, sub_slot_iters=ssi, fork_info=fork_info)
         assert err is None
 
     peak = b.get_peak()
@@ -3949,27 +3994,33 @@ async def test_reorg_flip_flop(empty_blockchain: Blockchain, bt: BlockTools) ->
         await _validate_and_add_block(b, block)
 
 
-async def test_get_tx_peak(default_400_blocks: List[FullBlock], empty_blockchain: Blockchain) -> None:
+async def test_get_tx_peak(default_400_blocks: list[FullBlock], empty_blockchain: Blockchain) -> None:
     bc = empty_blockchain
     test_blocks = default_400_blocks[:100]
     ssi = bc.constants.SUB_SLOT_ITERS_STARTING
     diff = bc.constants.DIFFICULTY_STARTING
-    res = await pre_validate_blocks_multiprocessing(
-        bc.constants,
-        bc,
-        test_blocks,
-        bc.pool,
-        {},
-        sub_slot_iters=ssi,
-        difficulty=diff,
-        prev_ses_block=None,
-        validate_signatures=False,
-    )
+    futures: list[Awaitable[PreValidationResult]] = []
+    chain = AugmentedBlockchain(bc)
+    vs = ValidationState(ssi, diff, None)
+    for block in test_blocks:
+        futures.append(
+            await pre_validate_block(
+                bc.constants,
+                chain,
+                block,
+                bc.pool,
+                None,
+                vs,
+            )
+        )
+
+    res: list[PreValidationResult] = list(await asyncio.gather(*futures))
 
     last_tx_block_record = None
     for b, prevalidation_res in zip(test_blocks, res):
         assert bc.get_tx_peak() == last_tx_block_record
-        _, err, _ = await bc.add_block(b, prevalidation_res, None, sub_slot_iters=ssi)
+        fork_info = ForkInfo(b.height - 1, b.height - 1, b.prev_header_hash)
+        _, err, _ = await bc.add_block(b, prevalidation_res, sub_slot_iters=ssi, fork_info=fork_info)
         assert err is None
 
         if b.is_transaction_block():
@@ -3995,8 +4046,8 @@ def to_bytes(gen: Optional[SerializedProgram]) -> bytes:
 @pytest.mark.limit_consensus_modes(reason="block heights for generators differ between test chains in different modes")
 @pytest.mark.parametrize("clear_cache", [True, False])
 async def test_lookup_block_generators(
-    default_10000_blocks: List[FullBlock],
-    test_long_reorg_blocks_light: List[FullBlock],
+    default_10000_blocks: list[FullBlock],
+    test_long_reorg_blocks_light: list[FullBlock],
     bt: BlockTools,
     empty_blockchain: Blockchain,
     clear_cache: bool,
@@ -4020,11 +4071,13 @@ async def test_lookup_block_generators(
     # 507, 516, 527, 535, 539, 543, 547
 
     # start with adding some blocks to test lookups from the mainchain
+    fork_info = ForkInfo(-1, -1, bt.constants.GENESIS_CHALLENGE)
     for block in blocks_2[:550]:
-        await _validate_and_add_block(b, block, expected_result=AddBlockResult.NEW_PEAK)
+        await _validate_and_add_block(b, block, expected_result=AddBlockResult.NEW_PEAK, fork_info=fork_info)
 
+    fork_info = ForkInfo(blocks_1[500].height - 1, blocks_1[500].height - 1, blocks_1[500].prev_header_hash)
     for block in blocks_1[500:550]:
-        await _validate_and_add_block(b, block, expected_result=AddBlockResult.ADDED_AS_ORPHAN)
+        await _validate_and_add_block(b, block, expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info)
 
     # now we have a blockchain with two forks, the peak is at blocks_2[550] and
     # the leight weight peak is at blocks_1[550]
@@ -4098,3 +4151,52 @@ async def test_lookup_block_generators(
         b.clean_block_records()
     with pytest.raises(AssertionError):
         await b.lookup_block_generators(blocks_1[600].prev_header_hash, {uint32(3)})
+
+
+async def get_fork_info(blockchain: Blockchain, block: FullBlock, peak: BlockRecord) -> ForkInfo:
+    fork_chain, fork_hash = await lookup_fork_chain(
+        blockchain,
+        (peak.height, peak.header_hash),
+        (block.height - 1, block.prev_header_hash),
+        blockchain.constants,
+    )
+    # now we know how long the fork is, and can compute the fork
+    # height.
+    fork_height = block.height - len(fork_chain) - 1
+    fork_info = ForkInfo(fork_height, fork_height, fork_hash)
+
+    # now run all the blocks of the fork to compute the additions
+    # and removals. They are recorded in the fork_info object
+    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)])
+        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
+        await blockchain.run_single_block(fork_block, fork_info)
+        counter += 1
+    end = time.monotonic()
+    log.info(
+        f"executed {counter} block generators in {end - start:2f} s. "
+        f"{len(fork_info.additions_since_fork)} additions, "
+        f"{len(fork_info.removals_since_fork)} removals"
+    )
+
+    return fork_info
+
+
+@pytest.mark.anyio
+async def test_get_header_blocks_in_range_tx_filter_non_tx_block(empty_blockchain: Blockchain, bt: BlockTools) -> None:
+    """
+    Covers the case of calling `get_header_blocks_in_range`, requesting
+    transactions filter, on a non transaction block.
+    """
+    b = empty_blockchain
+    blocks = bt.get_consecutive_blocks(2)
+    for block in blocks:
+        await _validate_and_add_block(b, block)
+    non_tx_block = next(block for block in blocks if not block.is_transaction_block())
+    blocks_with_filter = await b.get_header_blocks_in_range(0, 42, tx_filter=True)
+    empty_tx_filter = b"\x00"
+    assert blocks_with_filter[non_tx_block.header_hash].transactions_filter == empty_tx_filter