chia-blockchain 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

chia/consensus/blockchain.py

@@ -4,16 +4,13 @@ import asyncio
 import dataclasses
 import enum
 import logging
-import time
 import traceback
-from concurrent.futures import Executor
-from concurrent.futures.process import ProcessPoolExecutor
+from concurrent.futures import Executor, ThreadPoolExecutor
 from enum import Enum
-from multiprocessing.context import BaseContext
 from pathlib import Path
-from typing import TYPE_CHECKING, ClassVar, Dict, List, Optional, Set, Tuple, cast
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
-from chia_rs import BLSCache
+from chia_rs import additions_and_removals, get_flags_for_height_and_constants
 
 from chia.consensus.block_body_validation import ForkInfo, validate_block_body
 from chia.consensus.block_header_validation import validate_unfinished_header_block
@@ -24,11 +21,10 @@ from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_dif
 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, _run_generator
+from chia.consensus.multiprocess_validation import PreValidationResult
 from chia.full_node.block_height_map import BlockHeightMap
 from chia.full_node.block_store import BlockStore
 from chia.full_node.coin_store import CoinStore
-from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
@@ -40,15 +36,15 @@ from chia.types.generator_types import BlockGenerator
 from chia.types.header_block import HeaderBlock
 from chia.types.unfinished_block import UnfinishedBlock
 from chia.types.unfinished_header_block import UnfinishedHeaderBlock
+from chia.types.validation_state import ValidationState
 from chia.types.weight_proof import SubEpochChallengeSegment
 from chia.util.cpu import available_logical_cores
-from chia.util.errors import ConsensusError, Err
+from chia.util.errors import Err
 from chia.util.generator_tools import get_block_header
 from chia.util.hash import std_hash
 from chia.util.inline_executor import InlineExecutor
 from chia.util.ints import uint16, uint32, uint64, uint128
 from chia.util.priority_mutex import PriorityMutex
-from chia.util.setproctitle import getproctitle, setproctitle
 
 log = logging.getLogger(__name__)
 
@@ -71,12 +67,12 @@ class AddBlockResult(Enum):
 class StateChangeSummary:
     peak: BlockRecord
     fork_height: uint32
-    rolled_back_records: List[CoinRecord]
+    rolled_back_records: list[CoinRecord]
     # list of coin-id, puzzle-hash pairs
-    removals: List[Tuple[bytes32, bytes32]]
+    removals: list[tuple[bytes32, bytes32]]
     # new coin and hint
-    additions: List[Tuple[Coin, Optional[bytes]]]
-    new_rewards: List[Coin]
+    additions: list[tuple[Coin, Optional[bytes]]]
+    new_rewards: list[Coin]
 
 
 class BlockchainMutexPriority(enum.IntEnum):
@@ -97,9 +93,9 @@ class Blockchain:
     # peak of the blockchain
     _peak_height: Optional[uint32]
     # All blocks in peak path are guaranteed to be included, can include orphan blocks
-    __block_records: Dict[bytes32, BlockRecord]
+    __block_records: dict[bytes32, BlockRecord]
     # all hashes of blocks in block_record by height, used for garbage collection
-    __heights_in_cache: Dict[uint32, Set[bytes32]]
+    __heights_in_cache: dict[uint32, set[bytes32]]
     # maps block height (of the current heaviest chain) to block hash and sub
     # epoch summaries
     __height_map: BlockHeightMap
@@ -110,7 +106,7 @@ class Blockchain:
     # Used to verify blocks in parallel
     pool: Executor
     # Set holding seen compact proofs, in order to avoid duplicates.
-    _seen_compact_proofs: Set[Tuple[VDFInfo, uint32]]
+    _seen_compact_proofs: set[tuple[VDFInfo, uint32]]
 
     # Whether blockchain is shut down or not
     _shut_down: bool
@@ -119,6 +115,8 @@ class Blockchain:
     priority_mutex: PriorityMutex[BlockchainMutexPriority]
     compact_proof_lock: asyncio.Lock
 
+    _log_coins: bool
+
     @staticmethod
     async def create(
         coin_store: CoinStore,
@@ -126,9 +124,9 @@ class Blockchain:
         consensus_constants: ConsensusConstants,
         blockchain_dir: Path,
         reserved_cores: int,
-        multiprocessing_context: Optional[BaseContext] = None,
         *,
         single_threaded: bool = False,
+        log_coins: bool = False,
     ) -> Blockchain:
         """
         Initializes a blockchain with the BlockRecords from disk, assuming they have all been
@@ -136,6 +134,7 @@ class Blockchain:
         in the consensus constants config.
         """
         self = Blockchain()
+        self._log_coins = log_coins
         # Blocks are validated under high priority, and transactions under low priority. This guarantees blocks will
         # be validated first.
         self.priority_mutex = PriorityMutex.create(priority_type=BlockchainMutexPriority)
@@ -145,11 +144,8 @@ class Blockchain:
         else:
             cpu_count = available_logical_cores()
             num_workers = max(cpu_count - reserved_cores, 1)
-            self.pool = ProcessPoolExecutor(
+            self.pool = ThreadPoolExecutor(
                 max_workers=num_workers,
-                mp_context=multiprocessing_context,
-                initializer=setproctitle,
-                initargs=(f"{getproctitle()}_block_validation_worker",),
             )
             log.info(f"Started {num_workers} processes for block validation")
 
@@ -267,32 +263,32 @@ class Blockchain:
         assert fork_info.peak_height == block.height - 1
         assert block.height == 0 or fork_info.peak_hash == block.prev_header_hash
 
-        npc: Optional[NPCResult] = None
+        additions: list[tuple[Coin, Optional[bytes]]] = []
+        removals: list[Coin] = []
         if block.transactions_generator is not None:
             block_generator: Optional[BlockGenerator] = await get_block_generator(self.lookup_block_generators, block)
             assert block_generator is not None
             assert block.transactions_info is not None
             assert block.foliage_transaction_block is not None
-            npc = get_name_puzzle_conditions(
-                block_generator,
-                block.transactions_info.cost,
-                mempool_mode=False,
-                height=block.height,
-                constants=self.constants,
+            flags = get_flags_for_height_and_constants(block.height, self.constants)
+            additions, removals = additions_and_removals(
+                bytes(block.transactions_generator),
+                block_generator.generator_refs,
+                flags,
+                self.constants,
             )
-            assert npc.error is None
 
-        fork_info.include_spends(None if npc is None else npc.conds, block, block.header_hash)
+        fork_info.include_block(additions, removals, block, block.header_hash)
 
     async def add_block(
         self,
         block: FullBlock,
         pre_validation_result: PreValidationResult,
-        bls_cache: Optional[BLSCache],
         sub_slot_iters: uint64,
-        fork_info: Optional[ForkInfo] = None,
+        fork_info: ForkInfo,
         prev_ses_block: Optional[BlockRecord] = None,
-    ) -> Tuple[AddBlockResult, Optional[Err], Optional[StateChangeSummary]]:
+        block_record: Optional[BlockRecord] = None,
+    ) -> tuple[AddBlockResult, Optional[Err], Optional[StateChangeSummary]]:
         """
         This method must be called under the blockchain lock
         Adds a new block into the blockchain, if it's valid and connected to the current
@@ -303,9 +299,6 @@ class Blockchain:
         Args:
             block: The FullBlock to be validated.
             pre_validation_result: A result of successful pre validation
-            bls_cache: An optional cache of pairings that are likely to be part
-               of the aggregate signature. If this is set, the cache will always
-               be used (which may be slower if there are no cache hits).
             fork_info: Information about the fork chain this block is part of,
                to make validation more efficient. This is an in-out parameter.
 
@@ -345,78 +338,38 @@ class Blockchain:
 
         header_hash: bytes32 = block.header_hash
 
-        # maybe fork_info should be mandatory to pass in, but we have a lot of
-        # tests that make sure the Blockchain object can handle any blocks,
-        # including orphaned ones, without any fork context
-        if fork_info is None:
-            block_rec = await self.get_block_record_from_db(header_hash)
-            if block_rec is not None:
-                self.add_block_record(block_rec)
-                # this means we have already seen and validated this block.
-                return AddBlockResult.ALREADY_HAVE_BLOCK, None, None
-            elif extending_main_chain:
-                # this is the common and efficient case where we extend the main
-                # chain. The fork_info can be empty
-                prev_height = block.height - 1
-                fork_info = ForkInfo(prev_height, prev_height, block.prev_header_hash)
+        # passing in correct fork_info is critical for performing reorgs
+        # correctly, so we perform some validation of it here
+        assert block.height - 1 == fork_info.peak_height
+        assert len(fork_info.block_hashes) == fork_info.peak_height - fork_info.fork_height
+        if fork_info.peak_height == fork_info.fork_height:
+            # if fork_info is saying we're not on a fork, the previous block better
+            # be part of the main chain
+            assert block.prev_header_hash == fork_info.peak_hash
+            if fork_info.fork_height == -1:
+                assert fork_info.peak_hash == self.constants.GENESIS_CHALLENGE
             else:
-                assert peak is not None
-                # the block is extending a fork, and we don't have any fork_info
-                # for it. This can potentially be quite expensive and we should
-                # try to avoid getting here
-
-                # first, collect all the block hashes of the forked chain
-                # the block we're trying to add doesn't exist in the chain yet,
-                # so we need to start traversing from its prev_header_hash
-                fork_chain, fork_hash = await lookup_fork_chain(
-                    self,
-                    (peak.height, peak.header_hash),
-                    (block.height - 1, block.prev_header_hash),
-                    self.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)
-
-                log.warning(
-                    f"slow path in block validation. Building coin set for fork ({fork_height}, {block.height})"
-                )
-
-                # 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 self.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 self.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"
-                )
-
+                assert self.height_to_hash(uint32(fork_info.fork_height)) == block.prev_header_hash
         else:
-            if extending_main_chain:
-                fork_info.reset(block.height - 1, block.prev_header_hash)
-
-            block_rec = await self.get_block_record_from_db(header_hash)
-            if block_rec is not None:
-                # We have already validated the block, but if it's not part of the
-                # main chain, we still need to re-run it to update the additions and
-                # removals in fork_info.
-                await self.advance_fork_info(block, fork_info)
-                fork_info.include_spends(pre_validation_result.conds, block, header_hash)
-                self.add_block_record(block_rec)
-                return AddBlockResult.ALREADY_HAVE_BLOCK, None, None
-
-            if fork_info.peak_hash != block.prev_header_hash:
-                await self.advance_fork_info(block, fork_info)
+            assert fork_info.peak_hash == block.prev_header_hash
+
+        if extending_main_chain:
+            fork_info.reset(block.height - 1, block.prev_header_hash)
+
+        # we dont consider block_record passed in here since it might be from
+        # a current sync process and not yet fully validated and commited to the DB
+        block_rec_from_db = await self.get_block_record_from_db(header_hash)
+        if block_rec_from_db is not None:
+            # We have already validated the block, but if it's not part of the
+            # main chain, we still need to re-run it to update the additions and
+            # removals in fork_info.
+            await self.advance_fork_info(block, fork_info)
+            fork_info.include_spends(pre_validation_result.conds, block, header_hash)
+            self.add_block_record(block_rec_from_db)
+            return AddBlockResult.ALREADY_HAVE_BLOCK, None, None
+
+        if fork_info.peak_hash != block.prev_header_hash:
+            await self.advance_fork_info(block, fork_info)
 
         # if these prerequisites of the fork_info aren't met, the fork_info
         # object is invalid for this block. If the caller would have passed in
@@ -424,7 +377,8 @@ class Blockchain:
         assert fork_info.peak_height == block.height - 1
         assert block.height == 0 or fork_info.peak_hash == block.prev_header_hash
 
-        error_code, _ = await validate_block_body(
+        assert block.transactions_generator is None or pre_validation_result.validated_signature
+        error_code = await validate_block_body(
             self.constants,
             self,
             self.coin_store.get_coin_records,
@@ -432,9 +386,7 @@ class Blockchain:
             block.height,
             pre_validation_result.conds,
             fork_info,
-            bls_cache,
-            # If we did not already validate the signature, validate it now
-            validate_signature=not pre_validation_result.validated_signature,
+            log_coins=self._log_coins,
         )
         if error_code is not None:
             return AddBlockResult.INVALID_BLOCK, error_code, None
@@ -449,18 +401,20 @@ class Blockchain:
         if not genesis and prev_block is not None:
             self.add_block_record(prev_block)
 
-        block_record = block_to_block_record(
-            self.constants,
-            self,
-            required_iters,
-            block,
-            sub_slot_iters=sub_slot_iters,
-            prev_ses_block=prev_ses_block,
-        )
+        if block_record is None:
+            block_record = block_to_block_record(
+                self.constants,
+                self,
+                required_iters,
+                block,
+                sub_slot_iters=sub_slot_iters,
+                prev_ses_block=prev_ses_block,
+            )
 
         # in case we fail and need to restore the blockchain state, remember the
         # peak height
         previous_peak_height = self._peak_height
+        prev_fork_peak = (fork_info.peak_height, fork_info.peak_hash)
 
         try:
             # Always add the block to the database
@@ -497,7 +451,8 @@ class Blockchain:
                 self.remove_block_record(header_hash)
             except KeyError:
                 pass
-            fork_info.rollback(header_hash, -1 if previous_peak_height is None else previous_peak_height)
+            # restore fork_info to the state before adding the block
+            fork_info.rollback(prev_fork_peak[1], prev_fork_peak[0])
             self.block_store.rollback_cache_block(header_hash)
             self._peak_height = previous_peak_height
             log.error(
@@ -522,7 +477,7 @@ class Blockchain:
         block_record: BlockRecord,
         genesis: bool,
         fork_info: ForkInfo,
-    ) -> Tuple[List[BlockRecord], Optional[StateChangeSummary]]:
+    ) -> tuple[list[BlockRecord], Optional[StateChangeSummary]]:
         """
         When a new block is added, this is called, to check if the new block is the new peak of the chain.
         This also handles reorgs by reverting blocks which are not in the heaviest chain.
@@ -531,7 +486,7 @@ class Blockchain:
         """
 
         peak = self.get_peak()
-        rolled_back_state: Dict[bytes32, CoinRecord] = {}
+        rolled_back_state: dict[bytes32, CoinRecord] = {}
 
         if genesis and peak is not None:
             return [], None
@@ -543,16 +498,49 @@ class Blockchain:
             if block_record.weight == peak.weight and peak.total_iters <= block_record.total_iters:
                 # this is an equal weight block but our peak has lower iterations, so we dont change the coin set
                 return [], None
+            if block_record.weight == peak.weight:
+                log.info(
+                    f"block has equal weight as our peak ({peak.weight}), but fewer "
+                    f"total iterations {block_record.total_iters} "
+                    f"peak: {peak.total_iters} "
+                    f"peak-hash: {peak.header_hash}"
+                )
 
             if block_record.prev_hash != peak.header_hash:
                 for coin_record in await self.coin_store.rollback_to_block(fork_info.fork_height):
                     rolled_back_state[coin_record.name] = coin_record
+                if self._log_coins and len(rolled_back_state) > 0:
+                    log.info(f"rolled back {len(rolled_back_state)} coins, to fork height {fork_info.fork_height}")
+                    log.info(
+                        "removed: %s",
+                        ",".join(
+                            [
+                                name.hex()[0:6]
+                                for name, state in rolled_back_state.items()
+                                if state.confirmed_block_index == 0
+                            ]
+                        ),
+                    )
+                    log.info(
+                        "unspent: %s",
+                        ",".join(
+                            [
+                                name.hex()[0:6]
+                                for name, state in rolled_back_state.items()
+                                if state.confirmed_block_index != 0
+                            ]
+                        ),
+                    )
 
         # Collects all blocks from fork point to new peak
-        records_to_add: List[BlockRecord] = []
+        records_to_add: list[BlockRecord] = []
 
         if genesis:
             records_to_add = [block_record]
+        elif fork_info.block_hashes == [block_record.header_hash]:
+            # in the common case, we just add a block on top of the chain. Check
+            # for that here to avoid an unnecessary database lookup.
+            records_to_add = [block_record]
         else:
             records_to_add = await self.block_store.get_block_records_by_hash(fork_info.block_hashes)
 
@@ -589,6 +577,15 @@ class Blockchain:
                 tx_additions,
                 tx_removals,
             )
+            if self._log_coins and (len(tx_removals) > 0 or len(tx_additions) > 0):
+                log.info(
+                    f"adding new block to coin_store "
+                    f"(hh: {fetched_block_record.header_hash} "
+                    f"height: {fetched_block_record.height}), {len(tx_removals)} spends"
+                )
+                log.info("rewards: %s", ",".join([add.name().hex()[0:6] for add in included_reward_coins]))
+                log.info("additions: %s", ",".join([add.name().hex()[0:6] for add in tx_additions]))
+                log.info("removals: %s", ",".join([f"{rem}"[0:6] for rem in tx_removals]))
 
         # we made it to the end successfully
         # Rollback sub_epoch_summaries
@@ -628,7 +625,7 @@ class Blockchain:
 
     async def get_sp_and_ip_sub_slots(
         self, header_hash: bytes32
-    ) -> Optional[Tuple[Optional[EndOfSubSlotBundle], Optional[EndOfSubSlotBundle]]]:
+    ) -> Optional[tuple[Optional[EndOfSubSlotBundle], Optional[EndOfSubSlotBundle]]]:
         block: Optional[FullBlock] = await self.block_store.get_full_block(header_hash)
         if block is None:
             return None
@@ -679,11 +676,11 @@ class Blockchain:
             return None, ip_sub_slot
         return prev_curr.finished_sub_slots[-1], ip_sub_slot
 
-    def get_recent_reward_challenges(self) -> List[Tuple[bytes32, uint128]]:
+    def get_recent_reward_challenges(self) -> list[tuple[bytes32, uint128]]:
         peak = self.get_peak()
         if peak is None:
             return []
-        recent_rc: List[Tuple[bytes32, uint128]] = []
+        recent_rc: list[tuple[bytes32, uint128]] = []
         curr: Optional[BlockRecord] = peak
         while curr is not None and len(recent_rc) < 2 * self.constants.MAX_SUB_SLOT_BLOCKS:
             if curr != peak:
@@ -702,7 +699,7 @@ class Blockchain:
 
     async def validate_unfinished_block_header(
         self, block: UnfinishedBlock, skip_overflow_ss_validation: bool = True
-    ) -> Tuple[Optional[uint64], Optional[Err]]:
+    ) -> tuple[Optional[uint64], Optional[Err]]:
         if len(block.transactions_generator_ref_list) > self.constants.MAX_GENERATOR_REF_LIST_SIZE:
             return None, Err.TOO_MANY_GENERATOR_REFS
 
@@ -745,13 +742,13 @@ class Blockchain:
         sub_slot_iters, difficulty = get_next_sub_slot_iters_and_difficulty(
             self.constants, len(unfinished_header_block.finished_sub_slots) > 0, prev_b, self
         )
+        expected_vs = ValidationState(sub_slot_iters, difficulty, None)
         required_iters, error = validate_unfinished_header_block(
             self.constants,
             self,
             unfinished_header_block,
             False,
-            difficulty,
-            sub_slot_iters,
+            expected_vs,
             skip_overflow_ss_validation,
         )
         if error is not None:
@@ -764,7 +761,7 @@ class Blockchain:
         required_iters, error = await self.validate_unfinished_block_header(block, skip_overflow_ss_validation)
 
         if error is not None:
-            return PreValidationResult(uint16(error.value), None, None, False, uint32(0))
+            return PreValidationResult(uint16(error.value), None, None, uint32(0))
 
         prev_height = (
             -1
@@ -774,39 +771,22 @@ class Blockchain:
 
         fork_info = ForkInfo(prev_height, prev_height, block.prev_header_hash)
 
-        error_code, cost_result = await validate_block_body(
+        conds = None if npc_result is None else npc_result.conds
+        error_code = await validate_block_body(
             self.constants,
             self,
             self.coin_store.get_coin_records,
             block,
             uint32(prev_height + 1),
-            None if npc_result is None else npc_result.conds,
+            conds,
             fork_info,
-            None,
-            validate_signature=False,  # Signature was already validated before calling this method, no need to validate
+            log_coins=self._log_coins,
         )
 
         if error_code is not None:
-            return PreValidationResult(uint16(error_code.value), None, None, False, uint32(0))
+            return PreValidationResult(uint16(error_code.value), None, None, uint32(0))
 
-        return PreValidationResult(None, required_iters, cost_result, False, uint32(0))
-
-    async def run_generator(self, unfinished_block: bytes, generator: BlockGenerator, height: uint32) -> NPCResult:
-        task = asyncio.get_running_loop().run_in_executor(
-            self.pool,
-            _run_generator,
-            self.constants,
-            unfinished_block,
-            bytes(generator),
-            height,
-        )
-        npc_result_bytes = await task
-        if npc_result_bytes is None:
-            raise ConsensusError(Err.UNKNOWN)
-        ret: NPCResult = NPCResult.from_bytes(npc_result_bytes)
-        if ret.error is not None:
-            raise ConsensusError(Err(ret.error))
-        return ret
+        return PreValidationResult(None, required_iters, conds, uint32(0))
 
     def contains_block(self, header_hash: bytes32) -> bool:
         """
@@ -825,7 +805,7 @@ class Blockchain:
             raise ValueError(f"Height is not in blockchain: {height}")
         return self.block_record(header_hash)
 
-    def get_ses_heights(self) -> List[uint32]:
+    def get_ses_heights(self) -> list[uint32]:
         return self.__height_map.get_ses_heights()
 
     def get_ses(self, height: uint32) -> SubEpochSummary:
@@ -877,7 +857,7 @@ class Blockchain:
 
             if height == 0:
                 break
-            height = height - 1
+            height -= 1
             blocks_to_remove = self.__heights_in_cache.get(uint32(height), None)
 
     def clean_block_records(self) -> None:
@@ -895,41 +875,49 @@ class Blockchain:
             return None
         self.clean_block_record(self._peak_height - self.constants.BLOCKS_CACHE_SIZE)
 
-    async def get_block_records_in_range(self, start: int, stop: int) -> Dict[bytes32, BlockRecord]:
+    async def get_block_records_in_range(self, start: int, stop: int) -> dict[bytes32, BlockRecord]:
         return await self.block_store.get_block_records_in_range(start, stop)
 
     async def get_header_blocks_in_range(
         self, start: int, stop: int, tx_filter: bool = True
-    ) -> Dict[bytes32, HeaderBlock]:
+    ) -> dict[bytes32, HeaderBlock]:
         hashes = []
         for height in range(start, stop + 1):
             header_hash: Optional[bytes32] = self.height_to_hash(uint32(height))
             if header_hash is not None:
                 hashes.append(header_hash)
 
-        blocks: List[FullBlock] = []
+        blocks: list[FullBlock] = []
         for hash in hashes.copy():
             block = self.block_store.block_cache.get(hash)
             if block is not None:
                 blocks.append(block)
                 hashes.remove(hash)
-        blocks_on_disk: List[FullBlock] = await self.block_store.get_blocks_by_hash(hashes)
+        blocks_on_disk: list[FullBlock] = await self.block_store.get_blocks_by_hash(hashes)
         blocks.extend(blocks_on_disk)
-        header_blocks: Dict[bytes32, HeaderBlock] = {}
+        header_blocks: dict[bytes32, HeaderBlock] = {}
 
         for block in blocks:
             if self.height_to_hash(block.height) != block.header_hash:
                 raise ValueError(f"Block at {block.header_hash} is no longer in the blockchain (it's in a fork)")
             if tx_filter is False:
-                header = get_block_header(block, [], [])
-            else:
-                tx_additions: List[CoinRecord] = [
-                    c for c in (await self.coin_store.get_coins_added_at_height(block.height)) if not c.coinbase
-                ]
-                removed: List[CoinRecord] = await self.coin_store.get_coins_removed_at_height(block.height)
-                header = get_block_header(
-                    block, [record.coin for record in tx_additions], [record.coin.name() for record in removed]
+                header = get_block_header(block)
+            elif block.transactions_generator is not None:
+                added_coins_records, removed_coins_records = await asyncio.gather(
+                    self.coin_store.get_coins_added_at_height(block.height),
+                    self.coin_store.get_coins_removed_at_height(block.height),
                 )
+                tx_additions = [cr.coin for cr in added_coins_records if not cr.coinbase]
+                removed = [cr.coin.name() for cr in removed_coins_records]
+                header = get_block_header(block, (removed, tx_additions))
+            elif block.is_transaction_block():
+                # This is a transaction block with just reward coins.
+                # We're sending empty additions and removals to signal that we
+                # want the transactions filter to be computed.
+                header = get_block_header(block, ([], []))
+            else:
+                # Non transaction block.
+                header = get_block_header(block)
             header_blocks[header.header_hash] = header
 
         return header_blocks
@@ -937,19 +925,19 @@ class Blockchain:
     async def get_header_block_by_height(
         self, height: int, header_hash: bytes32, tx_filter: bool = True
     ) -> Optional[HeaderBlock]:
-        header_dict: Dict[bytes32, HeaderBlock] = await self.get_header_blocks_in_range(height, height, tx_filter)
+        header_dict: dict[bytes32, HeaderBlock] = await self.get_header_blocks_in_range(height, height, tx_filter)
         if len(header_dict) == 0:
             return None
         if header_hash not in header_dict:
             return None
         return header_dict[header_hash]
 
-    async def get_block_records_at(self, heights: List[uint32], batch_size: int = 900) -> List[BlockRecord]:
+    async def get_block_records_at(self, heights: list[uint32], batch_size: int = 900) -> list[BlockRecord]:
         """
         gets block records by height (only blocks that are part of the chain)
         """
-        records: List[BlockRecord] = []
-        hashes: List[bytes32] = []
+        records: list[BlockRecord] = []
+        hashes: list[bytes32] = []
         assert batch_size < self.block_store.db_wrapper.host_parameter_limit
         for height in heights:
             header_hash: Optional[bytes32] = self.height_to_hash(height)
@@ -977,7 +965,7 @@ class Blockchain:
             return ret
         return await self.block_store.get_block_record(header_hash)
 
-    async def prev_block_hash(self, header_hashes: List[bytes32]) -> List[bytes32]:
+    async def prev_block_hash(self, header_hashes: list[bytes32]) -> list[bytes32]:
         """
         Given a list of block header hashes, returns the previous header hashes
         for each block, in the order they were passed in.
@@ -1014,15 +1002,15 @@ class Blockchain:
         self.__heights_in_cache[block_record.height].add(block_record.header_hash)
 
     async def persist_sub_epoch_challenge_segments(
-        self, ses_block_hash: bytes32, segments: List[SubEpochChallengeSegment]
+        self, ses_block_hash: bytes32, segments: list[SubEpochChallengeSegment]
     ) -> None:
         await self.block_store.persist_sub_epoch_challenge_segments(ses_block_hash, segments)
 
     async def get_sub_epoch_challenge_segments(
         self,
         ses_block_hash: bytes32,
-    ) -> Optional[List[SubEpochChallengeSegment]]:
-        segments: Optional[List[SubEpochChallengeSegment]] = await self.block_store.get_sub_epoch_challenge_segments(
+    ) -> Optional[list[SubEpochChallengeSegment]]:
+        segments: Optional[list[SubEpochChallengeSegment]] = await self.block_store.get_sub_epoch_challenge_segments(
             ses_block_hash
         )
         if segments is None:
@@ -1040,9 +1028,8 @@ class Blockchain:
         self._seen_compact_proofs.add(pot_tuple)
         return False
 
-    async def lookup_block_generators(self, header_hash: bytes32, generator_refs: Set[uint32]) -> Dict[uint32, bytes]:
-
-        generators: Dict[uint32, bytes] = {}
+    async def lookup_block_generators(self, header_hash: bytes32, generator_refs: set[uint32]) -> dict[uint32, bytes]:
+        generators: dict[uint32, bytes] = {}
 
         # if this is empty, we shouldn't have called this function to begin with
         assert len(generator_refs)
@@ -1071,7 +1058,7 @@ class Blockchain:
         if self.height_to_hash(peak_block.height) != header_hash:
             peak: Optional[BlockRecord] = self.get_peak()
             assert peak is not None
-            reorg_chain: Dict[uint32, bytes32]
+            reorg_chain: dict[uint32, bytes32]
             # Then we look up blocks up to fork point one at a time, backtracking
             reorg_chain, _ = await lookup_fork_chain(
                 self,