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

chia/consensus/augmented_chain.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, ClassVar, cast
 
 from chia_rs import BlockRecord, FullBlock
 from chia_rs.sized_bytes import bytes32
@@ -34,7 +34,7 @@ class AugmentedBlockchain:
         self._extra_blocks = {}
         self._height_to_hash = {}
 
-    def _get_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
+    def _get_block_record(self, header_hash: bytes32) -> BlockRecord | None:
         eb = self._extra_blocks.get(header_hash)
         if eb is None:
             return None
@@ -64,7 +64,7 @@ class AugmentedBlockchain:
         # traverse the additional blocks (if any) and resolve heights into
         # generators
         to_remove = []
-        curr: Optional[tuple[FullBlock, BlockRecord]] = self._extra_blocks.get(header_hash)
+        curr: tuple[FullBlock, BlockRecord] | None = self._extra_blocks.get(header_hash)
         while curr is not None:
             b = curr[0]
             if b.height in generator_refs:
@@ -81,7 +81,7 @@ class AugmentedBlockchain:
             generators.update(await self._underlying.lookup_block_generators(header_hash, generator_refs))
         return generators
 
-    async def get_block_record_from_db(self, header_hash: bytes32) -> Optional[BlockRecord]:
+    async def get_block_record_from_db(self, header_hash: bytes32) -> BlockRecord | None:
         ret = self._get_block_record(header_hash)
         if ret is not None:
             return ret
@@ -97,7 +97,7 @@ class AugmentedBlockchain:
             del self._extra_blocks[hh]
 
     # BlockRecordsProtocol
-    def try_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
+    def try_block_record(self, header_hash: bytes32) -> BlockRecord | None:
         ret = self._get_block_record(header_hash)
         if ret is not None:
             return ret
@@ -118,7 +118,7 @@ class AugmentedBlockchain:
             return self._underlying.block_record(header_hash)
         return self._underlying.height_to_block_record(height)
 
-    def height_to_hash(self, height: uint32) -> Optional[bytes32]:
+    def height_to_hash(self, height: uint32) -> bytes32 | None:
         ret = self._height_to_hash.get(height)
         if ret is not None:
             return ret

chia/consensus/block_body_validation.py

@@ -2,16 +2,17 @@ from __future__ import annotations
 
 import collections
 import logging
-from collections.abc import Awaitable, Collection
+from collections.abc import Awaitable, Callable, Collection
 from dataclasses import dataclass, field
-from typing import Callable, Optional, Union
 
 from chia_rs import (
     BlockRecord,
+    CoinRecord,
     ConsensusConstants,
     FullBlock,
     SpendBundleConditions,
     UnfinishedBlock,
+    check_time_locks,
     compute_merkle_set_root,
     is_canonical_serialization,
 )
@@ -21,10 +22,8 @@ from chiabip158 import PyBIP158
 
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
-from chia.consensus.check_time_locks import check_time_locks
 from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
 from chia.types.blockchain_format.coin import Coin, hash_coin_ids
-from chia.types.coin_record import CoinRecord
 from chia.util.errors import Err
 from chia.util.hash import std_hash
 
@@ -47,7 +46,7 @@ class ForkAdd:
     coin: Coin
     confirmed_height: uint32
     timestamp: uint64
-    hint: Optional[bytes]
+    hint: bytes | None
     is_coinbase: bool
     # This means matching parent puzzle hash and amount
     same_as_parent: bool
@@ -109,7 +108,7 @@ class ForkInfo:
                 coin, block.height, timestamp, hint=None, is_coinbase=True, same_as_parent=False
             )
 
-    def include_spends(self, conds: Optional[SpendBundleConditions], block: FullBlock, header_hash: bytes32) -> None:
+    def include_spends(self, conds: SpendBundleConditions | None, block: FullBlock, header_hash: bytes32) -> None:
         self.update_fork_peak(block, header_hash)
         if conds is not None:
             assert block.foliage_transaction_block is not None
@@ -127,7 +126,7 @@ class ForkInfo:
 
     def include_block(
         self,
-        additions: list[tuple[Coin, Optional[bytes]]],
+        additions: list[tuple[Coin, bytes | None]],
         removals: list[tuple[bytes32, Coin]],
         block: FullBlock,
         header_hash: bytes32,
@@ -161,7 +160,7 @@ def validate_block_merkle_roots(
     block_removals_root: bytes32,
     tx_additions: list[tuple[Coin, bytes32]],
     tx_removals: list[bytes32],
-) -> Optional[Err]:
+) -> Err | None:
     # Create addition Merkle set
     puzzlehash_coins_map: dict[bytes32, list[bytes32]] = {}
 
@@ -192,13 +191,13 @@ async def validate_block_body(
     constants: ConsensusConstants,
     records: BlockRecordsProtocol,
     get_coin_records: Callable[[Collection[bytes32]], Awaitable[list[CoinRecord]]],
-    block: Union[FullBlock, UnfinishedBlock],
+    block: FullBlock | UnfinishedBlock,
     height: uint32,
-    conds: Optional[SpendBundleConditions],
+    conds: SpendBundleConditions | None,
     fork_info: ForkInfo,
     *,
     log_coins: bool = False,
-) -> Optional[Err]:
+) -> Err | None:
     """
     This assumes the header block has been completely validated.
     Validates the transactions and body of the block.
@@ -227,7 +226,7 @@ async def validate_block_body(
         ):
             return Err.NOT_BLOCK_BUT_HAS_DATA
 
-        prev_tb: Optional[BlockRecord] = records.block_record(block.prev_header_hash)
+        prev_tb: BlockRecord | None = records.block_record(block.prev_header_hash)
         assert prev_tb is not None
         while not prev_tb.is_transaction_block:
             prev_tb = records.block_record(prev_tb.prev_hash)
@@ -341,10 +340,14 @@ async def validate_block_body(
     #     the generator ref list for this block (or 'one' bytes [0x01] if no generator)
     # 8b. The generator ref list length must be less than or equal to MAX_GENERATOR_REF_LIST_SIZE entries
     # 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_generator_ref_list == []:
         if block.transactions_info.generator_refs_root != bytes([1] * 32):
             return Err.INVALID_TRANSACTIONS_GENERATOR_REFS_ROOT
     else:
+        # With hard fork 2 we ban transactions_generator_ref_list.
+        if prev_transaction_block_height >= constants.HARD_FORK2_HEIGHT:
+            return Err.TOO_MANY_GENERATOR_REFS
+
         # 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
@@ -558,14 +561,15 @@ async def validate_block_body(
     # 21. Verify conditions
     # verify absolute/relative height/time conditions
     if conds is not None:
-        error = check_time_locks(
+        error: int | None = check_time_locks(
             removal_coin_records,
             conds,
             prev_transaction_block_height,
             prev_transaction_block_timestamp,
         )
         if error is not None:
-            return error
+            # TODO: standardise errors across Rust and Python so cast is not necesary here
+            return Err(error)
 
     # 22. Verify aggregated signature is done in pre-validation
     if not block.transactions_info.aggregated_signature:

chia/consensus/block_creation.py

@@ -2,8 +2,7 @@ from __future__ import annotations
 
 import logging
 import random
-from collections.abc import Sequence
-from typing import Callable, Optional
+from collections.abc import Callable, Sequence
 
 import chia_rs
 from chia_rs import (
@@ -54,18 +53,18 @@ def compute_block_fee(additions: Sequence[Coin], removals: Sequence[Coin]) -> ui
 def create_foliage(
     constants: ConsensusConstants,
     reward_block_unfinished: RewardChainBlockUnfinished,
-    new_block_gen: Optional[NewBlockGenerator],
-    prev_block: Optional[BlockRecord],
+    new_block_gen: NewBlockGenerator | None,
+    prev_block: BlockRecord | None,
     blocks: BlockRecordsProtocol,
     total_iters_sp: uint128,
     timestamp: uint64,
     farmer_reward_puzzlehash: bytes32,
     pool_target: PoolTarget,
     get_plot_signature: Callable[[bytes32, G1Element], G2Element],
-    get_pool_signature: Callable[[PoolTarget, Optional[G1Element]], Optional[G2Element]],
+    get_pool_signature: Callable[[PoolTarget, G1Element | None], G2Element | None],
     seed: bytes,
     compute_fees: Callable[[Sequence[Coin], Sequence[Coin]], uint64],
-) -> tuple[Foliage, Optional[FoliageTransactionBlock], Optional[TransactionsInfo]]:
+) -> tuple[Foliage, FoliageTransactionBlock | None, TransactionsInfo | None]:
     """
     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
@@ -90,7 +89,7 @@ def create_foliage(
     if prev_block is not None:
         res = get_prev_transaction_block(prev_block, blocks, total_iters_sp)
         is_transaction_block: bool = res[0]
-        prev_transaction_block: Optional[BlockRecord] = res[1]
+        prev_transaction_block: BlockRecord | None = res[1]
     else:
         # Genesis is a transaction block
         prev_transaction_block = None
@@ -110,7 +109,7 @@ def create_foliage(
     tx_additions: list[Coin] = []
     tx_removals: list[bytes32] = []
 
-    pool_target_signature: Optional[G2Element] = get_pool_signature(
+    pool_target_signature: G2Element | None = get_pool_signature(
         pool_target, reward_block_unfinished.proof_of_space.pool_public_key
     )
 
@@ -134,7 +133,7 @@ def create_foliage(
 
     generator_block_heights_list: list[uint32] = []
 
-    foliage_transaction_block_hash: Optional[bytes32]
+    foliage_transaction_block_hash: bytes32 | None
 
     if is_transaction_block:
         cost: uint64
@@ -236,7 +235,7 @@ def create_foliage(
 
         filter_hash: bytes32 = std_hash(encoded)
 
-        transactions_info: Optional[TransactionsInfo] = TransactionsInfo(
+        transactions_info: TransactionsInfo | None = TransactionsInfo(
             generator_hash,
             generator_refs_hash,
             new_block_gen.signature if new_block_gen else G2Element(),
@@ -250,7 +249,7 @@ def create_foliage(
             prev_transaction_block_hash = prev_transaction_block.header_hash
 
         assert transactions_info is not None
-        foliage_transaction_block: Optional[FoliageTransactionBlock] = FoliageTransactionBlock(
+        foliage_transaction_block: FoliageTransactionBlock | None = FoliageTransactionBlock(
             prev_transaction_block_hash,
             timestamp,
             filter_hash,
@@ -261,7 +260,7 @@ def create_foliage(
         assert foliage_transaction_block is not None
 
         foliage_transaction_block_hash = foliage_transaction_block.get_hash()
-        foliage_transaction_block_signature: Optional[G2Element] = get_plot_signature(
+        foliage_transaction_block_signature: G2Element | None = get_plot_signature(
             foliage_transaction_block_hash, reward_block_unfinished.proof_of_space.plot_public_key
         )
         assert foliage_transaction_block_signature is not None
@@ -296,14 +295,14 @@ def create_unfinished_block(
     farmer_reward_puzzle_hash: bytes32,
     pool_target: PoolTarget,
     get_plot_signature: Callable[[bytes32, G1Element], G2Element],
-    get_pool_signature: Callable[[PoolTarget, Optional[G1Element]], Optional[G2Element]],
+    get_pool_signature: Callable[[PoolTarget, G1Element | None], G2Element | None],
     signage_point: SignagePoint,
     timestamp: uint64,
     blocks: BlockRecordsProtocol,
     seed: bytes = b"",
-    new_block_gen: Optional[NewBlockGenerator] = None,
-    prev_block: Optional[BlockRecord] = None,
-    finished_sub_slots_input: Optional[list[EndOfSubSlotBundle]] = None,
+    new_block_gen: NewBlockGenerator | None = None,
+    prev_block: BlockRecord | None = None,
+    finished_sub_slots_input: list[EndOfSubSlotBundle] | None = None,
     compute_fees: Callable[[Sequence[Coin], Sequence[Coin]], uint64] = compute_block_fee,
 ) -> UnfinishedBlock:
     """
@@ -346,6 +345,10 @@ def create_unfinished_block(
 
     cc_sp_hash: bytes32 = slot_cc_challenge
 
+    if proof_of_space.param().strength_v2 is not None:
+        # v2 plots don't support pool public key
+        assert proof_of_space.pool_public_key is None
+
     # Only enters this if statement if we are in testing mode (making VDF proofs here)
     if signage_point.cc_vdf is not None:
         assert signage_point.rc_vdf is not None
@@ -366,8 +369,8 @@ def create_unfinished_block(
             rc_sp_hash = curr.finished_reward_slot_hashes[-1]
         signage_point = SignagePoint(None, None, None, None)
 
-    cc_sp_signature: Optional[G2Element] = get_plot_signature(cc_sp_hash, proof_of_space.plot_public_key)
-    rc_sp_signature: Optional[G2Element] = get_plot_signature(rc_sp_hash, proof_of_space.plot_public_key)
+    cc_sp_signature: G2Element | None = get_plot_signature(cc_sp_hash, proof_of_space.plot_public_key)
+    rc_sp_signature: G2Element | None = get_plot_signature(rc_sp_hash, proof_of_space.plot_public_key)
     assert cc_sp_signature is not None
     assert rc_sp_signature is not None
     assert chia_rs.AugSchemeMPL.verify(proof_of_space.plot_public_key, cc_sp_hash, cc_sp_signature)
@@ -418,10 +421,10 @@ def unfinished_block_to_full_block(
     cc_ip_proof: VDFProof,
     rc_ip_vdf: VDFInfo,
     rc_ip_proof: VDFProof,
-    icc_ip_vdf: Optional[VDFInfo],
-    icc_ip_proof: Optional[VDFProof],
+    icc_ip_vdf: VDFInfo | None,
+    icc_ip_proof: VDFProof | None,
     finished_sub_slots: list[EndOfSubSlotBundle],
-    prev_block: Optional[BlockRecord],
+    prev_block: BlockRecord | None,
     blocks: BlockRecordsProtocol,
     total_iters_sp: uint128,
     difficulty: uint64,
@@ -482,6 +485,7 @@ def unfinished_block_to_full_block(
         unfinished_block.reward_chain_block.reward_chain_sp_signature,
         rc_ip_vdf,
         icc_ip_vdf,
+        None,
         is_transaction_block,
     )
     if prev_block is None:

chia/consensus/block_header_validation.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import logging
 import time
-from typing import Optional
 
 from chia_rs import (
     AugSchemeMPL,
@@ -20,7 +19,11 @@ from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
 from chia.consensus.deficit import calculate_deficit
 from chia.consensus.difficulty_adjustment import can_finish_sub_and_full_epoch
-from chia.consensus.get_block_challenge import final_eos_is_already_included, get_block_challenge, prev_tx_block
+from chia.consensus.get_block_challenge import (
+    final_eos_is_already_included,
+    get_block_challenge,
+    pre_sp_tx_block_height,
+)
 from chia.consensus.make_sub_epoch_summary import make_sub_epoch_summary
 from chia.consensus.pot_iterations import (
     calculate_ip_iters,
@@ -50,7 +53,7 @@ def validate_unfinished_header_block(
     skip_overflow_last_ss_validation: bool = False,
     skip_vdf_is_valid: bool = False,
     check_sub_epoch_summary: bool = True,
-) -> tuple[Optional[uint64], Optional[ValidationError]]:
+) -> tuple[uint64 | None, ValidationError | None]:
     """
     Validates an unfinished header block. This is a block without the infusion VDFs (unfinished)
     and without transactions and transaction info (header). Returns (required_iters, error).
@@ -114,7 +117,7 @@ def validate_unfinished_header_block(
             can_finish_epoch = False
 
     # 2. Check finished slots that have been crossed since prev_b
-    ses_hash: Optional[bytes32] = None
+    ses_hash: bytes32 | None = None
     if new_sub_slot and not skip_overflow_last_ss_validation:
         # Finished a slot(s) since previous block. The first sub-slot must have at least one block, and all
         # subsequent sub-slots must be empty
@@ -151,9 +154,9 @@ def validate_unfinished_header_block(
                     return None, ValidationError(Err.SHOULD_NOT_HAVE_ICC)
             else:
                 assert prev_b is not None
-                icc_iters_committed: Optional[uint64] = None
-                icc_iters_proof: Optional[uint64] = None
-                icc_challenge_hash: Optional[bytes32] = None
+                icc_iters_committed: uint64 | None = None
+                icc_iters_proof: uint64 | None = None
+                icc_challenge_hash: bytes32 | None = None
                 icc_vdf_input = None
                 if prev_b.deficit < constants.MIN_BLOCKS_PER_CHALLENGE_BLOCK:
                     # There should be no ICC chain if the last block's deficit is 16
@@ -502,8 +505,13 @@ def validate_unfinished_header_block(
         cc_sp_hash,
         height,
         expected_vs.difficulty,
-        expected_vs.ssi,
-        prev_tx_block(blocks, prev_b),
+        pre_sp_tx_block_height(
+            constants=constants,
+            blocks=blocks,
+            prev_b_hash=header_block.prev_header_hash,
+            sp_index=header_block.reward_chain_block.signage_point_index,
+            first_in_sub_slot=len(header_block.finished_sub_slots) > 0,
+        ),
     )
     if required_iters is None:
         return None, ValidationError(Err.INVALID_POSPACE)
@@ -756,10 +764,16 @@ def validate_unfinished_header_block(
             != constants.GENESIS_PRE_FARM_FARMER_PUZZLE_HASH
         ):
             return None, ValidationError(Err.INVALID_PREFARM)
-    # 20b. If pospace has a pool pk, heck pool target signature. Should not check this for genesis block.
+    # 20b. If pospace has a pool pk, check pool target signature. Should not check this for genesis block.
     elif header_block.reward_chain_block.proof_of_space.pool_public_key is not None:
         assert header_block.reward_chain_block.proof_of_space.pool_contract_puzzle_hash is None
         assert header_block.foliage.foliage_block_data.pool_signature is not None
+
+        # v2 plots require pool contract puzzle hash, not pool pk
+        # TODO: todo_v2_plots add test coverage of this check
+        if header_block.reward_chain_block.proof_of_space.param().strength_v2 is not None:
+            return None, ValidationError(Err.INVALID_POOL_TARGET)
+
         if not AugSchemeMPL.verify(
             header_block.reward_chain_block.proof_of_space.pool_public_key,
             bytes(header_block.foliage.foliage_block_data.pool_target),
@@ -834,7 +848,7 @@ def validate_finished_header_block(
     check_filter: bool,
     expected_vs: ValidationState,
     check_sub_epoch_summary: bool = True,
-) -> tuple[Optional[uint64], Optional[ValidationError]]:
+) -> tuple[uint64 | None, ValidationError | None]:
     """
     Fully validates the header of a block. A header block is the same  as a full block, but
     without transactions and transaction info. Returns (required_iters, error).
@@ -866,7 +880,7 @@ def validate_finished_header_block(
     assert required_iters is not None
 
     if header_block.height == 0:
-        prev_b: Optional[BlockRecord] = None
+        prev_b: BlockRecord | None = None
         genesis_block = True
     else:
         prev_b = blocks.block_record(header_block.prev_header_hash)
@@ -1009,7 +1023,7 @@ def validate_finished_header_block(
                 last_ss = header_block.finished_sub_slots[-1]
                 assert last_ss.infused_challenge_chain is not None
                 icc_vdf_challenge: bytes32 = last_ss.infused_challenge_chain.get_hash()
-                icc_vdf_input: Optional[ClassgroupElement] = ClassgroupElement.get_default_element()
+                icc_vdf_input: ClassgroupElement | None = ClassgroupElement.get_default_element()
             else:
                 assert prev_b is not None
                 if prev_b.is_challenge_block(constants):

chia/consensus/block_height_map.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional
 
 import aiofiles
 from chia_rs import SubEpochSummary
@@ -57,9 +56,7 @@ class BlockHeightMap(BlockHeightMapProtocol):
     __ses_filename: Path
 
     @classmethod
-    async def create(
-        cls, blockchain_dir: Path, db: DBWrapper2, selected_network: Optional[str] = None
-    ) -> BlockHeightMap:
+    async def create(cls, blockchain_dir: Path, db: DBWrapper2, selected_network: str | None = None) -> BlockHeightMap:
         if db.db_version != 2:
             raise RuntimeError(f"BlockHeightMap does not support database schema v{db.db_version}")
         self = BlockHeightMap()
@@ -138,7 +135,7 @@ class BlockHeightMap(BlockHeightMapProtocol):
 
         return self
 
-    def update_height(self, height: uint32, header_hash: bytes32, ses: Optional[SubEpochSummary]) -> None:
+    def update_height(self, height: uint32, header_hash: bytes32, ses: SubEpochSummary | None) -> None:
         # we're only updating the last hash. If we've reorged, we already rolled
         # back, making this the new peak
         assert height * 32 <= len(self.__height_to_hash)
@@ -196,7 +193,7 @@ class BlockHeightMap(BlockHeightMapProtocol):
             async with self.db.reader_no_transaction() as conn:
                 async with conn.execute(query, (window_end, height)) as cursor:
                     # maps block-hash -> (height, prev-hash, sub-epoch-summary)
-                    ordered: dict[bytes32, tuple[uint32, bytes32, Optional[bytes]]] = {}
+                    ordered: dict[bytes32, tuple[uint32, bytes32, bytes | None]] = {}
 
                     for r in await cursor.fetchall():
                         ordered[r[0]] = (r[2], r[1], r[3])

chia/consensus/block_height_map_protocol.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional, Protocol
+from typing import Protocol
 
 from chia_rs import SubEpochSummary
 from chia_rs.sized_bytes import bytes32
@@ -8,7 +8,7 @@ from chia_rs.sized_ints import uint32
 
 
 class BlockHeightMapProtocol(Protocol):
-    def update_height(self, height: uint32, header_hash: bytes32, ses: Optional[SubEpochSummary]) -> None: ...
+    def update_height(self, height: uint32, header_hash: bytes32, ses: SubEpochSummary | None) -> None: ...
 
     def get_hash(self, height: uint32) -> bytes32: ...
 

chia/consensus/block_record.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 from typing_extensions import Protocol
@@ -15,13 +13,13 @@ class BlockRecordProtocol(Protocol):
     def height(self) -> uint32: ...
 
     @property
-    def timestamp(self) -> Optional[uint64]: ...
+    def timestamp(self) -> uint64 | None: ...
 
     @property
     def prev_transaction_block_height(self) -> uint32: ...
 
     @property
-    def prev_transaction_block_hash(self) -> Optional[bytes32]: ...
+    def prev_transaction_block_hash(self) -> bytes32 | None: ...
 
     @property
     def is_transaction_block(self) -> bool: ...