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

chia/consensus/block_body_validation.py

@@ -2,25 +2,24 @@ from __future__ import annotations
 
 import collections
 import logging
+from collections.abc import Awaitable, Collection
 from dataclasses import dataclass, field
-from typing import Awaitable, Callable, Collection, Dict, List, Optional, Set, Tuple, Union
+from typing import Callable, Optional, Union
 
-from chia_rs import AugSchemeMPL, BLSCache, G1Element, SpendBundleConditions
+from chia_rs import SpendBundleConditions, compute_merkle_set_root
 from chiabip158 import PyBIP158
 
 from chia.consensus.block_record import BlockRecord
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
-from chia.consensus.block_root_validation import validate_block_merkle_roots
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
 from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
 from chia.consensus.constants import ConsensusConstants
 from chia.full_node.mempool_check_conditions import mempool_check_time_locks
-from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.coin import Coin, hash_coin_ids
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_record import CoinRecord
 from chia.types.full_block import FullBlock
 from chia.types.unfinished_block import UnfinishedBlock
-from chia.util.condition_tools import pkm_pairs
 from chia.util.errors import Err
 from chia.util.hash import std_hash
 from chia.util.ints import uint32, uint64
@@ -68,13 +67,13 @@ class ForkInfo:
     # the header hash of the peak block of this fork
     peak_hash: bytes32
     # The additions include coinbase additions
-    additions_since_fork: Dict[bytes32, ForkAdd] = field(default_factory=dict)
+    additions_since_fork: dict[bytes32, ForkAdd] = field(default_factory=dict)
     # coin-id, ForkRem
-    removals_since_fork: Dict[bytes32, ForkRem] = field(default_factory=dict)
+    removals_since_fork: dict[bytes32, ForkRem] = field(default_factory=dict)
     # the header hashes of the blocks, starting with the one-past fork_height
     # i.e. the header hash of fork_height + 1 is stored in block_hashes[0]
     # followed by fork_height + 2, and so on.
-    block_hashes: List[bytes32] = field(default_factory=list)
+    block_hashes: list[bytes32] = field(default_factory=list)
 
     def reset(self, fork_height: int, header_hash: bytes32) -> None:
         self.fork_height = fork_height
@@ -110,6 +109,36 @@ class ForkInfo:
             assert coin.name() not in self.additions_since_fork
             self.additions_since_fork[coin.name()] = ForkAdd(coin, block.height, timestamp, None, True)
 
+    def include_block(
+        self,
+        additions: list[tuple[Coin, Optional[bytes]]],
+        removals: list[Coin],
+        block: FullBlock,
+        header_hash: bytes32,
+    ) -> None:
+        height = block.height
+
+        assert self.peak_height == height - 1
+
+        assert len(self.block_hashes) == self.peak_height - self.fork_height
+        assert block.height == self.fork_height + 1 + len(self.block_hashes)
+        self.block_hashes.append(header_hash)
+
+        self.peak_height = int(block.height)
+        self.peak_hash = header_hash
+
+        if block.foliage_transaction_block is not None:
+            timestamp = block.foliage_transaction_block.timestamp
+            for spend in removals:
+                self.removals_since_fork[bytes32(spend.name())] = ForkRem(bytes32(spend.puzzle_hash), height)
+            for coin, hint in additions:
+                self.additions_since_fork[coin.name()] = ForkAdd(coin, height, timestamp, hint, False)
+        for coin in block.get_included_reward_coins():
+            assert block.foliage_transaction_block is not None
+            timestamp = block.foliage_transaction_block.timestamp
+            assert coin.name() not in self.additions_since_fork
+            self.additions_since_fork[coin.name()] = ForkAdd(coin, block.height, timestamp, None, True)
+
     def rollback(self, header_hash: bytes32, height: int) -> None:
         assert height <= self.peak_height
         self.peak_height = height
@@ -118,25 +147,54 @@ class ForkInfo:
         self.removals_since_fork = {k: v for k, v in self.removals_since_fork.items() if v.height <= height}
 
 
+def validate_block_merkle_roots(
+    block_additions_root: bytes32,
+    block_removals_root: bytes32,
+    tx_additions: list[tuple[Coin, bytes32]],
+    tx_removals: list[bytes32],
+) -> Optional[Err]:
+    # Create addition Merkle set
+    puzzlehash_coins_map: dict[bytes32, list[bytes32]] = {}
+
+    for coin, coin_name in tx_additions:
+        if coin.puzzle_hash in puzzlehash_coins_map:
+            puzzlehash_coins_map[coin.puzzle_hash].append(coin_name)
+        else:
+            puzzlehash_coins_map[coin.puzzle_hash] = [coin_name]
+
+    # Addition Merkle set contains puzzlehash and hash of all coins with that puzzlehash
+    additions_merkle_items: list[bytes32] = []
+    for puzzle, coin_ids in puzzlehash_coins_map.items():
+        additions_merkle_items.append(puzzle)
+        additions_merkle_items.append(hash_coin_ids(coin_ids))
+
+    additions_root = bytes32(compute_merkle_set_root(additions_merkle_items))
+    removals_root = bytes32(compute_merkle_set_root(tx_removals))
+
+    if block_additions_root != additions_root:
+        return Err.BAD_ADDITION_ROOT
+    if block_removals_root != removals_root:
+        return Err.BAD_REMOVAL_ROOT
+
+    return None
+
+
 async def validate_block_body(
     constants: ConsensusConstants,
     records: BlockRecordsProtocol,
-    get_coin_records: Callable[[Collection[bytes32]], Awaitable[List[CoinRecord]]],
+    get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]],
     block: Union[FullBlock, UnfinishedBlock],
     height: uint32,
     conds: Optional[SpendBundleConditions],
     fork_info: ForkInfo,
-    bls_cache: Optional[BLSCache],
     *,
-    validate_signature: bool = True,
-) -> Tuple[Optional[Err], Optional[SpendBundleConditions]]:
+    log_coins: bool = False,
+) -> Optional[Err]:
     """
     This assumes the header block has been completely validated.
     Validates the transactions and body of the block.
-    Returns None for the first value if everything validates correctly, or an
-        Err if something does not validate.
-    For the second value, returns a SpendBundleConditions only if validation
-        succeeded, and there are transactions. In other cases it returns None.
+    Returns None if everything validates correctly, or an Err if something does
+        not validate.
     conds is the result of running the generator with the previous generators
         refs. It must be set for transaction blocks and must be None for
         non-transaction blocks.
@@ -158,7 +216,7 @@ async def validate_block_body(
             or block.transactions_info is not None
             or block.transactions_generator is not None
         ):
-            return Err.NOT_BLOCK_BUT_HAS_DATA, None
+            return Err.NOT_BLOCK_BUT_HAS_DATA
 
         prev_tb: Optional[BlockRecord] = records.block_record(block.prev_header_hash)
         assert prev_tb is not None
@@ -167,28 +225,30 @@ async def validate_block_body(
             assert prev_tb is not None
         assert prev_tb.timestamp is not None
         if len(block.transactions_generator_ref_list) > 0:
-            return Err.NOT_BLOCK_BUT_HAS_DATA, None
+            return Err.NOT_BLOCK_BUT_HAS_DATA
 
         assert fork_info.peak_height == height - 1
 
-        return None, None  # This means the block is valid
+        assert conds is None
+        # This means the block is valid
+        return None
 
     # All checks below this point correspond to transaction blocks
     # 2. For blocks, foliage block, transactions info must not be empty
     if block.foliage_transaction_block is None or block.transactions_info is None:
-        return Err.IS_TRANSACTION_BLOCK_BUT_NO_DATA, None
+        return Err.IS_TRANSACTION_BLOCK_BUT_NO_DATA
     assert block.foliage_transaction_block is not None
 
     # keeps track of the reward coins that need to be incorporated
-    expected_reward_coins: Set[Coin] = set()
+    expected_reward_coins: set[Coin] = set()
 
     # 3. The transaction info hash in the Foliage block must match the transaction info
     if block.foliage_transaction_block.transactions_info_hash != std_hash(block.transactions_info):
-        return Err.INVALID_TRANSACTIONS_INFO_HASH, None
+        return Err.INVALID_TRANSACTIONS_INFO_HASH
 
     # 4. The foliage block hash in the foliage block must match the foliage block
     if block.foliage.foliage_transaction_block_hash != std_hash(block.foliage_transaction_block):
-        return Err.INVALID_FOLIAGE_BLOCK_HASH, None
+        return Err.INVALID_FOLIAGE_BLOCK_HASH
 
     # 5. The reward claims must be valid for the previous blocks, and current block fees
     # If height == 0, expected_reward_coins will be left empty
@@ -241,19 +301,19 @@ async def validate_block_body(
                 assert curr_b is not None
 
     if set(block.transactions_info.reward_claims_incorporated) != expected_reward_coins:
-        return Err.INVALID_REWARD_COINS, None
+        return Err.INVALID_REWARD_COINS
 
     if len(block.transactions_info.reward_claims_incorporated) != len(expected_reward_coins):
-        return Err.INVALID_REWARD_COINS, None
+        return Err.INVALID_REWARD_COINS
 
-    removals: List[bytes32] = []
+    removals: list[bytes32] = []
 
     # we store coins paired with their names in order to avoid computing the
     # coin name multiple times, we store it next to the coin while validating
     # the block
-    coinbase_additions: List[Tuple[Coin, bytes32]] = [(c, c.name()) for c in expected_reward_coins]
-    additions: List[Tuple[Coin, bytes32]] = []
-    removals_puzzle_dic: Dict[bytes32, bytes32] = {}
+    coinbase_additions: list[tuple[Coin, bytes32]] = [(c, c.name()) for c in expected_reward_coins]
+    additions: list[tuple[Coin, bytes32]] = []
+    removals_puzzle_dic: dict[bytes32, bytes32] = {}
     cost: uint64 = uint64(0)
 
     # In header validation we check that timestamp is not more than 5 minutes into the future
@@ -264,10 +324,10 @@ async def validate_block_body(
     #     the generator for this block (or zeroes if no generator)
     if block.transactions_generator is not None:
         if std_hash(bytes(block.transactions_generator)) != block.transactions_info.generator_root:
-            return Err.INVALID_TRANSACTIONS_GENERATOR_HASH, None
+            return Err.INVALID_TRANSACTIONS_GENERATOR_HASH
     else:
         if block.transactions_info.generator_root != bytes([0] * 32):
-            return Err.INVALID_TRANSACTIONS_GENERATOR_HASH, None
+            return Err.INVALID_TRANSACTIONS_GENERATOR_HASH
 
     # 8a. The generator_ref_list must be the hash of the serialized bytes of
     #     the generator ref list for this block (or 'one' bytes [0x01] if no generator)
@@ -275,20 +335,20 @@ async def validate_block_body(
     # 8c. The generator ref list must not point to a height >= this block's height
     if block.transactions_generator_ref_list in (None, []):
         if block.transactions_info.generator_refs_root != bytes([1] * 32):
-            return Err.INVALID_TRANSACTIONS_GENERATOR_REFS_ROOT, None
+            return Err.INVALID_TRANSACTIONS_GENERATOR_REFS_ROOT
     else:
         # If we have a generator reference list, we must have a generator
         if block.transactions_generator is None:
-            return Err.INVALID_TRANSACTIONS_GENERATOR_REFS_ROOT, None
+            return Err.INVALID_TRANSACTIONS_GENERATOR_REFS_ROOT
 
-        # The generator_refs_root must be the hash of the concatenation of the List[uint32]
+        # The generator_refs_root must be the hash of the concatenation of the list[uint32]
         generator_refs_hash = std_hash(b"".join([i.stream_to_bytes() for i in block.transactions_generator_ref_list]))
         if block.transactions_info.generator_refs_root != generator_refs_hash:
-            return Err.INVALID_TRANSACTIONS_GENERATOR_REFS_ROOT, None
+            return Err.INVALID_TRANSACTIONS_GENERATOR_REFS_ROOT
         if len(block.transactions_generator_ref_list) > constants.MAX_GENERATOR_REF_LIST_SIZE:
-            return Err.TOO_MANY_GENERATOR_REFS, None
+            return Err.TOO_MANY_GENERATOR_REFS
         if any([index >= height for index in block.transactions_generator_ref_list]):
-            return Err.FUTURE_GENERATOR_REFS, None
+            return Err.FUTURE_GENERATOR_REFS
 
     if block.transactions_generator is not None:
         # Get List of names removed, puzzles hashes for removed coins and conditions created
@@ -301,10 +361,11 @@ async def validate_block_body(
             f"percent full: {round(100 * (cost / constants.MAX_BLOCK_COST_CLVM), 2)}%"
         )
         if cost > constants.MAX_BLOCK_COST_CLVM:
-            return Err.BLOCK_COST_EXCEEDS_MAX, None
+            return Err.BLOCK_COST_EXCEEDS_MAX
 
         # 8. The CLVM program must not return any errors
         assert conds is not None
+        assert conds.validated_signature
 
         for spend in conds.spends:
             removals.append(bytes32(spend.coin_id))
@@ -317,19 +378,19 @@ async def validate_block_body(
 
     # 9. Check that the correct cost is in the transactions info
     if block.transactions_info.cost != cost:
-        return Err.INVALID_BLOCK_COST, None
+        return Err.INVALID_BLOCK_COST
 
-    additions_dic: Dict[bytes32, Coin] = {}
+    additions_dic: dict[bytes32, Coin] = {}
     # 10. Check additions for max coin amount
     # Be careful to check for 64 bit overflows in other languages. This is the max 64 bit unsigned integer
     # We will not even reach here because Coins do type checking (uint64)
     for coin, coin_name in additions + coinbase_additions:
         additions_dic[coin_name] = coin
         if coin.amount < 0:
-            return Err.COIN_AMOUNT_NEGATIVE, None
+            return Err.COIN_AMOUNT_NEGATIVE
 
         if coin.amount > constants.MAX_COIN_AMOUNT:
-            return Err.COIN_AMOUNT_EXCEEDS_MAXIMUM, None
+            return Err.COIN_AMOUNT_EXCEEDS_MAXIMUM
 
     # 11. Validate addition and removal roots
     root_error = validate_block_merkle_roots(
@@ -338,11 +399,11 @@ async def validate_block_body(
         additions + coinbase_additions,
         removals,
     )
-    if root_error:
-        return root_error, None
+    if root_error is not None:
+        return root_error
 
     # 12. The additions and removals must result in the correct filter
-    byte_array_tx: List[bytearray] = []
+    byte_array_tx: list[bytearray] = []
 
     for coin, _ in additions + coinbase_additions:
         byte_array_tx.append(bytearray(coin.puzzle_hash))
@@ -354,19 +415,19 @@ async def validate_block_body(
     filter_hash = std_hash(encoded_filter)
 
     if filter_hash != block.foliage_transaction_block.filter_hash:
-        return Err.INVALID_TRANSACTIONS_FILTER_HASH, None
+        return Err.INVALID_TRANSACTIONS_FILTER_HASH
 
     # 13. Check for duplicate outputs in additions
     addition_counter = collections.Counter(coin_name for _, coin_name in additions + coinbase_additions)
-    for k, v in addition_counter.items():
-        if v > 1:
-            return Err.DUPLICATE_OUTPUT, None
+    for count in addition_counter.values():
+        if count > 1:
+            return Err.DUPLICATE_OUTPUT
 
     # 14. Check for duplicate spends inside block
     removal_counter = collections.Counter(removals)
     for count in removal_counter.values():
         if count > 1:
-            return Err.DOUBLE_SPEND, None
+            return Err.DOUBLE_SPEND
 
     # 15. Check if removals exist and were not previously spent. (unspent_db + diff_store + this_block)
     # The fork point is the last block in common between the peak chain and the chain of `block`
@@ -374,10 +435,10 @@ async def validate_block_body(
     assert fork_info.fork_height < height
     assert fork_info.peak_height == height - 1
 
-    removal_coin_records: Dict[bytes32, CoinRecord] = {}
+    removal_coin_records: dict[bytes32, CoinRecord] = {}
     # the removed coins we need to look up from the DB
     # i.e. all non-ephemeral coins
-    removals_from_db: List[bytes32] = []
+    removals_from_db: list[bytes32] = []
     for rem in removals:
         if rem in additions_dic:
             # Ephemeral coin
@@ -396,40 +457,46 @@ async def validate_block_body(
             if rem in fork_info.removals_since_fork:
                 # This coin was spent in the fork
                 log.error(f"Err.DOUBLE_SPEND_IN_FORK {fork_info.removals_since_fork[rem]}")
-                return Err.DOUBLE_SPEND_IN_FORK, None
+                return Err.DOUBLE_SPEND_IN_FORK
             removals_from_db.append(rem)
 
     unspent_records = await get_coin_records(removals_from_db)
 
     # some coin spends we need to ensure exist in the fork branch. Both coins we
     # can't find in the DB, but also coins that were spent after the fork point
-    look_in_fork: List[bytes32] = []
+    look_in_fork: list[bytes32] = []
     for unspent in unspent_records:
         if unspent.confirmed_block_index <= fork_info.fork_height:
             # Spending something in the current chain, confirmed before fork
             # (We ignore all coins confirmed after fork)
             if unspent.spent == 1 and unspent.spent_block_index <= fork_info.fork_height:
                 # Check for coins spent in an ancestor block
-                return Err.DOUBLE_SPEND, None
+                return Err.DOUBLE_SPEND
             removal_coin_records[unspent.name] = unspent
         else:
             look_in_fork.append(unspent.name)
 
+    if log_coins and len(look_in_fork) > 0:
+        log.info("%d coins spent after fork", len(look_in_fork))
+
     if len(unspent_records) != len(removals_from_db):
         # some coins could not be found in the DB. We need to find out which
         # ones and look for them in additions_since_fork
-        found: Set[bytes32] = {u.name for u in unspent_records}
+        found: set[bytes32] = {u.name for u in unspent_records}
         for rem in removals_from_db:
             if rem in found:
                 continue
             look_in_fork.append(rem)
 
+    if log_coins and len(look_in_fork) > 0:
+        log.info("coins spent in fork: %s", ",".join([f"{name}"[0:6] for name in look_in_fork]))
+
     for rem in look_in_fork:
         # This coin is not in the current heaviest chain, so it must be in the fork
         if rem not in fork_info.additions_since_fork:
             # Check for spending a coin that does not exist in this fork
             log.error(f"Err.UNKNOWN_UNSPENT: COIN ID: {rem} fork_info: {fork_info}")
-            return Err.UNKNOWN_UNSPENT, None
+            return Err.UNKNOWN_UNSPENT
         addition: ForkAdd = fork_info.additions_since_fork[rem]
         new_coin_record: CoinRecord = CoinRecord(
             addition.coin,
@@ -450,7 +517,7 @@ async def validate_block_body(
 
     # 16. Check that the total coin amount for added is <= removed
     if removed < added:
-        return Err.MINTING_COIN, None
+        return Err.MINTING_COIN
 
     fees = removed - added
     assert fees >= 0
@@ -461,20 +528,20 @@ async def validate_block_body(
 
     # 17. Check that the assert fee sum <= fees, and that each reserved fee is non-negative
     if fees < assert_fee_sum:
-        return Err.RESERVE_FEE_CONDITION_FAILED, None
+        return Err.RESERVE_FEE_CONDITION_FAILED
 
     # 18. Check that the fee amount + farmer reward < maximum coin amount
     if fees + calculate_base_farmer_reward(height) > constants.MAX_COIN_AMOUNT:
-        return Err.COIN_AMOUNT_EXCEEDS_MAXIMUM, None
+        return Err.COIN_AMOUNT_EXCEEDS_MAXIMUM
 
     # 19. Check that the computed fees are equal to the fees in the block header
     if block.transactions_info.fees != fees:
-        return Err.INVALID_BLOCK_FEE_AMOUNT, None
+        return Err.INVALID_BLOCK_FEE_AMOUNT
 
     # 20. Verify that removed coin puzzle_hashes match with calculated puzzle_hashes
     for unspent in removal_coin_records.values():
         if unspent.coin.puzzle_hash != removals_puzzle_dic[unspent.name]:
-            return Err.WRONG_PUZZLE_HASH, None
+            return Err.WRONG_PUZZLE_HASH
 
     # 21. Verify conditions
     # verify absolute/relative height/time conditions
@@ -486,30 +553,10 @@ async def validate_block_body(
             prev_transaction_block_timestamp,
         )
         if error is not None:
-            return error, None
-
-    # create hash_key list for aggsig check
-    pairs_pks: List[G1Element] = []
-    pairs_msgs: List[bytes] = []
-    if conds is not None:
-        pairs_pks, pairs_msgs = pkm_pairs(conds, constants.AGG_SIG_ME_ADDITIONAL_DATA)
+            return error
 
-    # 22. Verify aggregated signature
-    # TODO: move this to pre_validate_blocks_multiprocessing so we can sync faster
+    # 22. Verify aggregated signature is done in pre-validation
     if not block.transactions_info.aggregated_signature:
-        return Err.BAD_AGGREGATE_SIGNATURE, None
-
-    # The pairing cache is not useful while syncing as each pairing is seen
-    # only once, so the extra effort of populating it is not justified.
-    # However, we force caching of pairings just for unfinished blocks
-    # as the cache is likely to be useful when validating the corresponding
-    # finished blocks later.
-    if validate_signature:
-        if bls_cache is None:
-            if not AugSchemeMPL.aggregate_verify(pairs_pks, pairs_msgs, block.transactions_info.aggregated_signature):
-                return Err.BAD_AGGREGATE_SIGNATURE, None
-        else:
-            if not bls_cache.aggregate_verify(pairs_pks, pairs_msgs, block.transactions_info.aggregated_signature):
-                return Err.BAD_AGGREGATE_SIGNATURE, None
+        return Err.BAD_AGGREGATE_SIGNATURE
 
-    return None, conds
+    return None

chia/consensus/block_creation.py

@@ -2,10 +2,20 @@ from __future__ import annotations
 
 import logging
 import random
-from typing import Callable, Dict, List, Optional, Sequence, Tuple
+from collections.abc import Sequence
+from typing import Callable, Optional
 
 import chia_rs
-from chia_rs import G1Element, G2Element, compute_merkle_set_root
+from chia_rs import (
+    DONT_VALIDATE_SIGNATURE,
+    MEMPOOL_MODE,
+    G1Element,
+    G2Element,
+    compute_merkle_set_root,
+    get_flags_for_height_and_constants,
+    run_block_generator,
+    run_block_generator2,
+)
 from chiabip158 import PyBIP158
 
 from chia.consensus.block_record import BlockRecord
@@ -13,8 +23,6 @@ from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
 from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
 from chia.consensus.constants import ConsensusConstants
-from chia.consensus.cost_calculator import NPCResult
-from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions
 from chia.full_node.signage_point import SignagePoint
 from chia.types.blockchain_format.coin import Coin, hash_coin_ids
 from chia.types.blockchain_format.foliage import Foliage, FoliageBlockData, FoliageTransactionBlock, TransactionsInfo
@@ -35,10 +43,23 @@ log = logging.getLogger(__name__)
 
 
 def compute_block_cost(generator: BlockGenerator, constants: ConsensusConstants, height: uint32) -> uint64:
-    result: NPCResult = get_name_puzzle_conditions(
-        generator, constants.MAX_BLOCK_COST_CLVM, mempool_mode=True, height=height, constants=constants
+    flags = get_flags_for_height_and_constants(height, constants) | MEMPOOL_MODE | DONT_VALIDATE_SIGNATURE
+
+    if height >= constants.HARD_FORK_HEIGHT:
+        run_block = run_block_generator2
+    else:
+        run_block = run_block_generator
+
+    _, conds = run_block(
+        bytes(generator.program),
+        generator.generator_refs,
+        constants.MAX_BLOCK_COST_CLVM,
+        flags,
+        G2Element(),
+        None,
+        constants,
     )
-    return uint64(0 if result.conds is None else result.conds.cost)
+    return uint64(0 if conds is None else conds.cost)
 
 
 def compute_block_fee(additions: Sequence[Coin], removals: Sequence[Coin]) -> uint64:
@@ -56,8 +77,8 @@ def create_foliage(
     reward_block_unfinished: RewardChainBlockUnfinished,
     block_generator: Optional[BlockGenerator],
     aggregate_sig: G2Element,
-    additions: List[Coin],
-    removals: List[Coin],
+    additions: list[Coin],
+    removals: list[Coin],
     prev_block: Optional[BlockRecord],
     blocks: BlockRecordsProtocol,
     total_iters_sp: uint128,
@@ -69,7 +90,7 @@ def create_foliage(
     seed: bytes,
     compute_cost: Callable[[BlockGenerator, ConsensusConstants, uint32], uint64],
     compute_fees: Callable[[Sequence[Coin], Sequence[Coin]], uint64],
-) -> Tuple[Foliage, Optional[FoliageTransactionBlock], Optional[TransactionsInfo]]:
+) -> tuple[Foliage, Optional[FoliageTransactionBlock], Optional[TransactionsInfo]]:
     """
     Creates a foliage for a given reward chain block. This may or may not be a tx block. In the case of a tx block,
     the return values are not None. This is called at the signage point, so some of this information may be
@@ -111,9 +132,9 @@ def create_foliage(
         height = uint32(prev_block.height + 1)
 
     # Create filter
-    byte_array_tx: List[bytearray] = []
-    tx_additions: List[Coin] = []
-    tx_removals: List[bytes32] = []
+    byte_array_tx: list[bytearray] = []
+    tx_additions: list[Coin] = []
+    tx_removals: list[bytes32] = []
 
     pool_target_signature: Optional[G2Element] = get_pool_signature(
         pool_target, reward_block_unfinished.proof_of_space.pool_public_key
@@ -202,10 +223,10 @@ def create_foliage(
         bip158: PyBIP158 = PyBIP158(byte_array_tx)
         encoded = bytes(bip158.GetEncoded())
 
-        additions_merkle_items: List[bytes32] = []
+        additions_merkle_items: list[bytes32] = []
 
         # Create addition Merkle set
-        puzzlehash_coin_map: Dict[bytes32, List[bytes32]] = {}
+        puzzlehash_coin_map: dict[bytes32, list[bytes32]] = {}
 
         for coin in tx_additions:
             if coin.puzzle_hash in puzzlehash_coin_map:
@@ -221,7 +242,7 @@ def create_foliage(
         additions_root = bytes32(compute_merkle_set_root(additions_merkle_items))
         removals_root = bytes32(compute_merkle_set_root(tx_removals))
 
-        generator_hash = bytes32([0] * 32)
+        generator_hash = bytes32.zeros
         if block_generator is not None:
             generator_hash = std_hash(block_generator.program)
 
@@ -295,10 +316,10 @@ def create_unfinished_block(
     seed: bytes = b"",
     block_generator: Optional[BlockGenerator] = None,
     aggregate_sig: G2Element = G2Element(),
-    additions: Optional[List[Coin]] = None,
-    removals: Optional[List[Coin]] = None,
+    additions: Optional[list[Coin]] = None,
+    removals: Optional[list[Coin]] = None,
     prev_block: Optional[BlockRecord] = None,
-    finished_sub_slots_input: Optional[List[EndOfSubSlotBundle]] = None,
+    finished_sub_slots_input: Optional[list[EndOfSubSlotBundle]] = None,
     compute_cost: Callable[[BlockGenerator, ConsensusConstants, uint32], uint64] = compute_block_cost,
     compute_fees: Callable[[Sequence[Coin], Sequence[Coin]], uint64] = compute_block_fee,
 ) -> UnfinishedBlock:
@@ -334,7 +355,7 @@ def create_unfinished_block(
 
     """
     if finished_sub_slots_input is None:
-        finished_sub_slots: List[EndOfSubSlotBundle] = []
+        finished_sub_slots: list[EndOfSubSlotBundle] = []
     else:
         finished_sub_slots = finished_sub_slots_input.copy()
     overflow: bool = sp_iters > ip_iters
@@ -428,7 +449,7 @@ def unfinished_block_to_full_block(
     rc_ip_proof: VDFProof,
     icc_ip_vdf: Optional[VDFInfo],
     icc_ip_proof: Optional[VDFProof],
-    finished_sub_slots: List[EndOfSubSlotBundle],
+    finished_sub_slots: list[EndOfSubSlotBundle],
     prev_block: Optional[BlockRecord],
     blocks: BlockRecordsProtocol,
     total_iters_sp: uint128,