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

chia/consensus/blockchain.py

@@ -7,10 +7,11 @@ import logging
 import traceback
 from concurrent.futures import Executor, ThreadPoolExecutor
 from enum import Enum
-from typing import TYPE_CHECKING, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, ClassVar, cast
 
 from chia_rs import (
     BlockRecord,
+    CoinRecord,
     ConsensusConstants,
     EndOfSubSlotBundle,
     FullBlock,
@@ -33,12 +34,12 @@ 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.generator_tools import get_block_header
+from chia.consensus.get_block_challenge import pre_sp_tx_block_height
 from chia.consensus.get_block_generator import get_block_generator
 from chia.consensus.multiprocess_validation import PreValidationResult
 from chia.full_node.block_store import BlockStore
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.vdf import VDFInfo
-from chia.types.coin_record import CoinRecord
 from chia.types.generator_types import BlockGenerator
 from chia.types.unfinished_header_block import UnfinishedHeaderBlock
 from chia.types.validation_state import ValidationState
@@ -73,7 +74,7 @@ class StateChangeSummary:
     # list of coin-id, puzzle-hash pairs
     removals: list[tuple[bytes32, bytes32]]
     # new coin and hint
-    additions: list[tuple[Coin, Optional[bytes]]]
+    additions: list[tuple[Coin, bytes | None]]
     new_rewards: list[Coin]
 
 
@@ -93,7 +94,7 @@ class Blockchain:
     constants: ConsensusConstants
 
     # peak of the blockchain
-    _peak_height: Optional[uint32]
+    _peak_height: uint32 | None
     # All blocks in peak path are guaranteed to be included, can include orphan blocks
     __block_records: dict[bytes32, BlockRecord]
     # all hashes of blocks in block_record by height, used for garbage collection
@@ -185,7 +186,7 @@ class Blockchain:
         assert self.__height_map.contains_height(self._peak_height)
         assert not self.__height_map.contains_height(uint32(self._peak_height + 1))
 
-    def get_peak(self) -> Optional[BlockRecord]:
+    def get_peak(self) -> BlockRecord | None:
         """
         Return the peak of the blockchain
         """
@@ -193,7 +194,7 @@ class Blockchain:
             return None
         return self.height_to_block_record(self._peak_height)
 
-    def get_tx_peak(self) -> Optional[BlockRecord]:
+    def get_tx_peak(self) -> BlockRecord | None:
         """
         Return the most recent transaction block. i.e. closest to the peak of the blockchain
         Requires the blockchain to be initialized and there to be a peak set
@@ -213,17 +214,17 @@ class Blockchain:
 
         return tx_peak
 
-    async def get_full_peak(self) -> Optional[FullBlock]:
+    async def get_full_peak(self) -> FullBlock | None:
         if self._peak_height is None:
             return None
         """ Return list of FullBlocks that are peaks"""
-        peak_hash: Optional[bytes32] = self.height_to_hash(self._peak_height)
+        peak_hash: bytes32 | None = self.height_to_hash(self._peak_height)
         assert peak_hash is not None  # Since we must have the peak block
         block = await self.block_store.get_full_block(peak_hash)
         assert block is not None
         return block
 
-    async def get_full_block(self, header_hash: bytes32) -> Optional[FullBlock]:
+    async def get_full_block(self, header_hash: bytes32) -> FullBlock | None:
         return await self.block_store.get_full_block(header_hash)
 
     async def advance_fork_info(self, block: FullBlock, fork_info: ForkInfo) -> None:
@@ -258,7 +259,7 @@ class Blockchain:
         assert len(chain) == block.height - fork_info.peak_height - 1
 
         for height in range(fork_info.peak_height + 1, block.height):
-            fork_block: Optional[FullBlock] = await self.block_store.get_full_block(chain[uint32(height)])
+            fork_block: FullBlock | None = await self.block_store.get_full_block(chain[uint32(height)])
             assert fork_block is not None
             await self.run_single_block(fork_block, fork_info)
 
@@ -266,14 +267,21 @@ class Blockchain:
         assert fork_info.peak_height == block.height - 1
         assert block.height == 0 or fork_info.peak_hash == block.prev_header_hash
 
-        additions: list[tuple[Coin, Optional[bytes]]] = []
+        additions: list[tuple[Coin, bytes | None]] = []
         removals: list[tuple[bytes32, Coin]] = []
         if block.transactions_generator is not None:
-            block_generator: Optional[BlockGenerator] = await get_block_generator(self.lookup_block_generators, block)
+            block_generator: BlockGenerator | None = 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
-            flags = get_flags_for_height_and_constants(block.height, self.constants)
+            prev_tx_height = pre_sp_tx_block_height(
+                constants=self.constants,
+                blocks=self,
+                prev_b_hash=block.prev_header_hash,
+                sp_index=block.reward_chain_block.signage_point_index,
+                first_in_sub_slot=len(block.finished_sub_slots) > 0,
+            )
+            flags = get_flags_for_height_and_constants(prev_tx_height, self.constants)
             additions, removals = additions_and_removals(
                 bytes(block.transactions_generator),
                 block_generator.generator_refs,
@@ -289,9 +297,9 @@ class Blockchain:
         pre_validation_result: PreValidationResult,
         sub_slot_iters: uint64,
         fork_info: ForkInfo,
-        prev_ses_block: Optional[BlockRecord] = None,
-        block_record: Optional[BlockRecord] = None,
-    ) -> tuple[AddBlockResult, Optional[Err], Optional[StateChangeSummary]]:
+        prev_ses_block: BlockRecord | None = None,
+        block_record: BlockRecord | None = None,
+    ) -> tuple[AddBlockResult, Err | None, StateChangeSummary | None]:
         """
         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
@@ -325,7 +333,7 @@ class Blockchain:
         # first check if this block is disconnected from the currently known
         # blocks. We can only accept blocks that are connected to another block
         # we know of.
-        prev_block: Optional[BlockRecord] = None
+        prev_block: BlockRecord | None = None
         if not extending_main_chain and not genesis:
             prev_block = self.try_block_record(block.prev_header_hash)
             if prev_block is None:
@@ -480,7 +488,7 @@ class Blockchain:
         block_record: BlockRecord,
         genesis: bool,
         fork_info: ForkInfo,
-    ) -> tuple[list[BlockRecord], Optional[StateChangeSummary]]:
+    ) -> tuple[list[BlockRecord], StateChangeSummary | None]:
         """
         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.
@@ -620,14 +628,14 @@ class Blockchain:
 
     async def get_sp_and_ip_sub_slots(
         self, header_hash: bytes32
-    ) -> Optional[tuple[Optional[EndOfSubSlotBundle], Optional[EndOfSubSlotBundle]]]:
-        block: Optional[FullBlock] = await self.block_store.get_full_block(header_hash)
+    ) -> tuple[EndOfSubSlotBundle | None, EndOfSubSlotBundle | None] | None:
+        block: FullBlock | None = await self.block_store.get_full_block(header_hash)
         if block is None:
             return None
         curr_br: BlockRecord = self.block_record(block.header_hash)
         is_overflow = curr_br.overflow
 
-        curr: Optional[FullBlock] = block
+        curr: FullBlock | None = block
         assert curr is not None
         while True:
             if curr_br.first_in_sub_slot:
@@ -652,7 +660,7 @@ class Blockchain:
             # Have both sub-slots
             return curr.finished_sub_slots[-2], ip_sub_slot
 
-        prev_curr: Optional[FullBlock] = await self.block_store.get_full_block(curr.prev_header_hash)
+        prev_curr: FullBlock | None = await self.block_store.get_full_block(curr.prev_header_hash)
         if prev_curr is None:
             assert curr.height == 0
             prev_curr = curr
@@ -676,7 +684,7 @@ class Blockchain:
         if peak is None:
             return []
         recent_rc: list[tuple[bytes32, uint128]] = []
-        curr: Optional[BlockRecord] = peak
+        curr: BlockRecord | None = peak
         while curr is not None and len(recent_rc) < 2 * self.constants.MAX_SUB_SLOT_BLOCKS:
             if curr != peak:
                 recent_rc.append((curr.reward_infusion_new_challenge, curr.total_iters))
@@ -694,16 +702,26 @@ class Blockchain:
 
     async def validate_unfinished_block_header(
         self, block: UnfinishedBlock, skip_overflow_ss_validation: bool = True
-    ) -> tuple[Optional[uint64], Optional[Err]]:
+    ) -> tuple[uint64 | None, Err | None]:
         if len(block.transactions_generator_ref_list) > self.constants.MAX_GENERATOR_REF_LIST_SIZE:
             return None, Err.TOO_MANY_GENERATOR_REFS
 
-        if (
-            self.try_block_record(block.prev_header_hash) is None
-            and block.prev_header_hash != self.constants.GENESIS_CHALLENGE
-        ):
+        prev_b = self.try_block_record(block.prev_header_hash)
+        if prev_b is None and block.prev_header_hash != self.constants.GENESIS_CHALLENGE:
             return None, Err.INVALID_PREV_BLOCK_HASH
 
+        prev_tx_height = pre_sp_tx_block_height(
+            constants=self.constants,
+            blocks=self,
+            prev_b_hash=block.prev_header_hash,
+            sp_index=block.reward_chain_block.signage_point_index,
+            first_in_sub_slot=len(block.finished_sub_slots) > 0,
+        )
+
+        # With hard fork 2 we ban transactions_generator_ref_list.
+        if prev_tx_height >= self.constants.HARD_FORK2_HEIGHT and block.transactions_generator_ref_list != []:
+            return None, Err.TOO_MANY_GENERATOR_REFS
+
         if block.transactions_info is not None:
             if block.transactions_generator is not None:
                 if std_hash(bytes(block.transactions_generator)) != block.transactions_info.generator_root:
@@ -750,7 +768,7 @@ class Blockchain:
         return required_iters, None
 
     async def validate_unfinished_block(
-        self, block: UnfinishedBlock, npc_result: Optional[NPCResult], skip_overflow_ss_validation: bool = True
+        self, block: UnfinishedBlock, npc_result: NPCResult | None, skip_overflow_ss_validation: bool = True
     ) -> PreValidationResult:
         required_iters, error = await self.validate_unfinished_block_header(block, skip_overflow_ss_validation)
 
@@ -793,7 +811,7 @@ class Blockchain:
 
     def height_to_block_record(self, height: uint32) -> BlockRecord:
         # Precondition: height is in the blockchain
-        header_hash: Optional[bytes32] = self.height_to_hash(height)
+        header_hash: bytes32 | None = self.height_to_hash(height)
         if header_hash is None:
             raise ValueError(f"Height is not in blockchain: {height}")
         return self.block_record(header_hash)
@@ -804,7 +822,7 @@ class Blockchain:
     def get_ses(self, height: uint32) -> SubEpochSummary:
         return self.__height_map.get_ses(height)
 
-    def height_to_hash(self, height: uint32) -> Optional[bytes32]:
+    def height_to_hash(self, height: uint32) -> bytes32 | None:
         if not self.__height_map.contains_height(height):
             return None
         return self.__height_map.get_hash(height)
@@ -812,7 +830,7 @@ class Blockchain:
     def contains_height(self, height: uint32) -> bool:
         return self.__height_map.contains_height(height)
 
-    def get_peak_height(self) -> Optional[uint32]:
+    def get_peak_height(self) -> uint32 | None:
         return self._peak_height
 
     async def warmup(self, fork_point: uint32) -> None:
@@ -876,7 +894,7 @@ class Blockchain:
     ) -> dict[bytes32, HeaderBlock]:
         hashes = []
         for height in range(start, stop + 1):
-            header_hash: Optional[bytes32] = self.height_to_hash(uint32(height))
+            header_hash: bytes32 | None = self.height_to_hash(uint32(height))
             if header_hash is not None:
                 hashes.append(header_hash)
 
@@ -917,7 +935,7 @@ class Blockchain:
 
     async def get_header_block_by_height(
         self, height: int, header_hash: bytes32, tx_filter: bool = True
-    ) -> Optional[HeaderBlock]:
+    ) -> HeaderBlock | None:
         header_dict: dict[bytes32, HeaderBlock] = await self.get_header_blocks_in_range(height, height, tx_filter)
         if len(header_dict) == 0:
             return None
@@ -931,19 +949,19 @@ class Blockchain:
         """
         hashes: list[bytes32] = []
         for height in heights:
-            header_hash: Optional[bytes32] = self.height_to_hash(height)
+            header_hash: bytes32 | None = self.height_to_hash(height)
             if header_hash is None:
                 raise ValueError(f"Do not have block at height {height}")
             hashes.append(header_hash)
 
         return await self.block_store.get_block_records_by_hash(hashes)
 
-    def try_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
+    def try_block_record(self, header_hash: bytes32) -> BlockRecord | None:
         if header_hash in self.__block_records:
             return self.block_record(header_hash)
         return None
 
-    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.__block_records.get(header_hash)
         if ret is not None:
             return ret
@@ -993,8 +1011,8 @@ class Blockchain:
     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(
+    ) -> list[SubEpochChallengeSegment] | None:
+        segments: list[SubEpochChallengeSegment] | None = await self.block_store.get_sub_epoch_challenge_segments(
             ses_block_hash
         )
         if segments is None:
@@ -1040,7 +1058,7 @@ class Blockchain:
         peak_block = await self.get_block_record_from_db(header_hash)
         assert peak_block is not None
         if self.height_to_hash(peak_block.height) != header_hash:
-            peak: Optional[BlockRecord] = self.get_peak()
+            peak: BlockRecord | None = self.get_peak()
             assert peak is not None
             reorg_chain: dict[uint32, bytes32]
             # Then we look up blocks up to fork point one at a time, backtracking

chia/consensus/blockchain_interface.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional, Protocol
+from typing import Protocol
 
 from chia_rs import BlockRecord, HeaderBlock, SubEpochChallengeSegment, SubEpochSummary
 from chia_rs.sized_bytes import bytes32
@@ -8,11 +8,11 @@ from chia_rs.sized_ints import uint32
 
 
 class BlockRecordsProtocol(Protocol):
-    def try_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]: ...
+    def try_block_record(self, header_hash: bytes32) -> BlockRecord | None: ...
     def block_record(self, header_hash: bytes32) -> BlockRecord: ...
     def contains_height(self, height: uint32) -> bool: ...
     def contains_block(self, header_hash: bytes32, height: uint32) -> bool: ...
-    def height_to_hash(self, height: uint32) -> Optional[bytes32]: ...
+    def height_to_hash(self, height: uint32) -> bytes32 | None: ...
     def height_to_block_record(self, height: uint32) -> BlockRecord: ...
 
     # given a list of block header hashes, return the header hashes of their
@@ -25,13 +25,13 @@ class BlocksProtocol(BlockRecordsProtocol, Protocol):
     async def lookup_block_generators(
         self, header_hash: bytes32, generator_refs: set[uint32]
     ) -> dict[uint32, bytes]: ...
-    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: ...
     def add_block_record(self, block_record: BlockRecord) -> None: ...
 
 
 class BlockchainInterface(BlocksProtocol, Protocol):
-    def get_peak(self) -> Optional[BlockRecord]: ...
-    def get_peak_height(self) -> Optional[uint32]: ...
+    def get_peak(self) -> BlockRecord | None: ...
+    def get_peak_height(self) -> uint32 | None: ...
     def get_ses_heights(self) -> list[uint32]: ...
     def get_ses(self, height: uint32) -> SubEpochSummary: ...
     async def contains_block_from_db(self, header_hash: bytes32) -> bool: ...
@@ -50,4 +50,4 @@ class BlockchainInterface(BlocksProtocol, Protocol):
     async def get_sub_epoch_challenge_segments(
         self,
         sub_epoch_summary_hash: bytes32,
-    ) -> Optional[list[SubEpochChallengeSegment]]: ...
+    ) -> list[SubEpochChallengeSegment] | None: ...

chia/consensus/coin_store_protocol.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
 from collections.abc import Collection
-from typing import Optional, Protocol
+from typing import Protocol
 
-from chia_rs import CoinState
+from chia_rs import CoinRecord, CoinState
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
 from chia.types.blockchain_format.coin import Coin
-from chia.types.coin_record import CoinRecord
 from chia.types.mempool_item import UnspentLineageInfo
 
 
@@ -30,7 +29,7 @@ class CoinStoreProtocol(Protocol):
         Add a new block to the coin store
         """
 
-    async def get_coin_record(self, coin_id: bytes32) -> Optional[CoinRecord]:
+    async def get_coin_record(self, coin_id: bytes32) -> CoinRecord | None:
         """
         Returns the coin record for the specified coin id
         """
@@ -129,12 +128,12 @@ class CoinStoreProtocol(Protocol):
         include_hinted: bool = ...,
         min_amount: uint64 = ...,
         max_items: int = ...,
-    ) -> tuple[list[CoinState], Optional[uint32]]:
+    ) -> tuple[list[CoinState], uint32 | None]:
         """
         Returns the coin states, as well as the next block height (or `None` if finished).
         """
 
-    async def get_unspent_lineage_info_for_puzzle_hash(self, puzzle_hash: bytes32) -> Optional[UnspentLineageInfo]:
+    async def get_unspent_lineage_info_for_puzzle_hash(self, puzzle_hash: bytes32) -> UnspentLineageInfo | None:
         """
         Lookup the most recent unspent lineage that matches a puzzle hash
         """

chia/consensus/condition_tools.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from functools import lru_cache
-from typing import Callable, Union
 
 from chia_rs import G1Element, SpendBundleConditions, SpendConditions
 from chia_rs.sized_bytes import bytes32
@@ -74,7 +74,7 @@ def agg_sig_additional_data(agg_sig_data: bytes) -> dict[ConditionOpcode, bytes]
 def make_aggsig_final_message(
     opcode: ConditionOpcode,
     msg: bytes,
-    spend_conditions: Union[Coin, SpendConditions],
+    spend_conditions: Coin | SpendConditions,
     agg_sig_additional_data: dict[ConditionOpcode, bytes],
 ) -> bytes:
     if isinstance(spend_conditions, Coin):
@@ -181,7 +181,7 @@ def created_outputs_for_conditions_dict(
 
 
 def conditions_dict_for_solution(
-    puzzle_reveal: Union[Program, SerializedProgram], solution: Union[Program, SerializedProgram], max_cost: int
+    puzzle_reveal: Program | SerializedProgram, solution: Program | SerializedProgram, max_cost: int
 ) -> dict[ConditionOpcode, list[ConditionWithArgs]]:
     conditions_dict: dict[ConditionOpcode, list[ConditionWithArgs]] = {}
     for cvp in conditions_for_solution(puzzle_reveal, solution, max_cost):
@@ -190,7 +190,7 @@ def conditions_dict_for_solution(
 
 
 def conditions_for_solution(
-    puzzle_reveal: Union[Program, SerializedProgram], solution: Union[Program, SerializedProgram], max_cost: int
+    puzzle_reveal: Program | SerializedProgram, solution: Program | SerializedProgram, max_cost: int
 ) -> list[ConditionWithArgs]:
     # get the standard script for a puzzle hash and feed in the solution
     try:

chia/consensus/cost_calculator.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Optional
 
 from chia_rs import SpendBundleConditions
 from chia_rs.sized_ints import uint16
@@ -12,5 +11,5 @@ from chia.util.streamable import Streamable, streamable
 @streamable
 @dataclass(frozen=True)
 class NPCResult(Streamable):
-    error: Optional[uint16]
-    conds: Optional[SpendBundleConditions]
+    error: uint16 | None
+    conds: SpendBundleConditions | None

chia/consensus/default_constants.py

@@ -34,8 +34,7 @@ DEFAULT_CONSTANTS = ConsensusConstants(
     ),  # H(plot signature of the challenge) must start with these many zeroes. for v2 plots
     MIN_PLOT_SIZE_V1=uint8(32),  # 32 for mainnet
     MAX_PLOT_SIZE_V1=uint8(50),
-    MIN_PLOT_SIZE_V2=uint8(28),
-    MAX_PLOT_SIZE_V2=uint8(32),
+    PLOT_SIZE_V2=uint8(28),
     SUB_SLOT_TIME_TARGET=uint16(600),  # The target number of seconds per slot, mainnet 600
     NUM_SP_INTERVALS_EXTRA=uint8(3),  # The number of sp intervals to add to the signage point
     MAX_FUTURE_TIME2=uint32(2 * 60),  # The next block can have a timestamp of at most these many seconds in the future
@@ -76,27 +75,28 @@ DEFAULT_CONSTANTS = ConsensusConstants(
     # inclusive, so the max allowed range of 32 is a request for 33 blocks
     # (which is allowed)
     MAX_BLOCK_COUNT_PER_REQUESTS=uint32(32),
-    MAX_GENERATOR_SIZE=uint32(1000000),
     MAX_GENERATOR_REF_LIST_SIZE=uint32(512),  # Number of references allowed in the block generator ref list
     POOL_SUB_SLOT_ITERS=uint64(37600000000),  # iters limit * NUM_SPS
     # June 2024
     HARD_FORK_HEIGHT=uint32(5496000),
+    # TODO: todo_v2_plots finalize fork height
     HARD_FORK2_HEIGHT=uint32(0xFFFFFFFA),
     # starting at the hard fork 2 height, v1 plots will gradually be phased out,
-    # and stop working entirely after this many blocks
-    PLOT_V1_PHASE_OUT=uint32(1179648),
+    # and stop working entirely after (1 << this) many epochs
+    PLOT_V1_PHASE_OUT_EPOCH_BITS=uint8(8),
     # June 2027
     PLOT_FILTER_128_HEIGHT=uint32(10542000),
     # June 2030
     PLOT_FILTER_64_HEIGHT=uint32(15592000),
     # June 2033
     PLOT_FILTER_32_HEIGHT=uint32(20643000),
-    PLOT_STRENGTH_INITIAL=uint8(2),
-    PLOT_STRENGTH_4_HEIGHT=uint32(0xFFFFFFFB),
-    PLOT_STRENGTH_5_HEIGHT=uint32(0xFFFFFFFC),
-    PLOT_STRENGTH_6_HEIGHT=uint32(0xFFFFFFFD),
-    PLOT_STRENGTH_7_HEIGHT=uint32(0xFFFFFFFE),
-    PLOT_STRENGTH_8_HEIGHT=uint32(0xFFFFFFFF),
+    MIN_PLOT_STRENGTH=uint8(2),
+    MAX_PLOT_STRENGTH=uint8(32),
+    QUALITY_PROOF_SCAN_FILTER=uint8(5),
+    # TODO: todo_v2_plots finalize plot filter schedule
+    PLOT_FILTER_V2_FIRST_ADJUSTMENT_HEIGHT=uint32(0xFFFFFFFB),
+    PLOT_FILTER_V2_SECOND_ADJUSTMENT_HEIGHT=uint32(0xFFFFFFFC),
+    PLOT_FILTER_V2_THIRD_ADJUSTMENT_HEIGHT=uint32(0xFFFFFFFD),
 )
 
 
@@ -109,5 +109,8 @@ def update_testnet_overrides(network_id: str, overrides: dict[str, Any]) -> None
         overrides["MAX_PLOT_SIZE_V1"] = overrides["MAX_PLOT_SIZE"]
         overrides.pop("MAX_PLOT_SIZE")
     if network_id in {"testnet11", "testneta"}:
-        if "MIN_PLOT_SIZE_V2" not in overrides:
-            overrides["MIN_PLOT_SIZE_V2"] = 18
+        if "PLOT_SIZE_V2" not in overrides:
+            overrides["PLOT_SIZE_V2"] = 28
+    if network_id == "testneta":
+        if "HARD_FORK_HEIGHT" not in overrides:
+            overrides["HARD_FORK_HEIGHT"] = 3693395

chia/consensus/deficit.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from chia_rs import BlockRecord, ConsensusConstants
 from chia_rs.sized_ints import uint8, uint32
 
@@ -9,7 +7,7 @@ from chia_rs.sized_ints import uint8, uint32
 def calculate_deficit(
     constants: ConsensusConstants,
     height: uint32,
-    prev_b: Optional[BlockRecord],
+    prev_b: BlockRecord | None,
     overflow: bool,
     num_finished_sub_slots: int,
 ) -> uint8:

chia/consensus/difficulty_adjustment.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from chia_rs import BlockRecord, ConsensusConstants
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
@@ -137,10 +135,10 @@ def can_finish_sub_and_full_epoch(
     constants: ConsensusConstants,
     blocks: BlockRecordsProtocol,
     height: uint32,
-    prev_header_hash: Optional[bytes32],
+    prev_header_hash: bytes32 | None,
     deficit: uint8,
     block_at_height_included_ses: bool,
-    prev_ses_block: Optional[BlockRecord] = None,
+    prev_ses_block: BlockRecord | None = None,
 ) -> tuple[bool, bool]:
     """
     Returns a bool tuple
@@ -355,7 +353,7 @@ def _get_next_difficulty(
 def get_next_sub_slot_iters_and_difficulty(
     constants: ConsensusConstants,
     is_first_in_sub_slot: bool,
-    prev_b: Optional[BlockRecord],
+    prev_b: BlockRecord | None,
     blocks: BlockRecordsProtocol,
 ) -> tuple[uint64, uint64]:
     """

chia/consensus/find_fork_point.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Union
-
 from chia_rs import BlockRecord, ConsensusConstants, HeaderBlock
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
@@ -11,8 +9,8 @@ from chia.consensus.blockchain_interface import BlockRecordsProtocol
 
 async def find_fork_point_in_chain(
     blocks: BlockRecordsProtocol,
-    block_1: Union[BlockRecord, HeaderBlock],
-    block_2: Union[BlockRecord, HeaderBlock],
+    block_1: BlockRecord | HeaderBlock,
+    block_2: BlockRecord | HeaderBlock,
 ) -> int:
     """Tries to find height where new chain (block_2) diverged from block_1 (assuming prev blocks
     are all included in chain)

chia/consensus/full_block_to_block_record.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional, Union
-
 from chia_rs import BlockRecord, ChallengeBlockInfo, ConsensusConstants, FullBlock, HeaderBlock, SubEpochSummary
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
@@ -19,9 +17,9 @@ def block_to_block_record(
     constants: ConsensusConstants,
     blocks: BlockRecordsProtocol,
     required_iters: uint64,
-    block: Union[FullBlock, HeaderBlock],
+    block: FullBlock | HeaderBlock,
     sub_slot_iters: uint64,
-    prev_ses_block: Optional[BlockRecord] = None,
+    prev_ses_block: BlockRecord | None = None,
 ) -> BlockRecord:
     prev_b = blocks.try_block_record(block.prev_header_hash)
     if block.height > 0:
@@ -39,8 +37,8 @@ def block_to_block_record(
         len(block.finished_sub_slots),
     )
 
-    found_ses_hash: Optional[bytes32] = None
-    ses: Optional[SubEpochSummary] = None
+    found_ses_hash: bytes32 | None = None
+    ses: SubEpochSummary | None = None
     if len(block.finished_sub_slots) > 0:
         for sub_slot in block.finished_sub_slots:
             if sub_slot.challenge_chain.subepoch_summary_hash is not None:
@@ -61,7 +59,7 @@ def block_to_block_record(
             raise ValueError(Err.INVALID_SUB_EPOCH_SUMMARY)
 
     prev_transaction_block_height = uint32(0)
-    curr: Optional[BlockRecord] = blocks.try_block_record(block.prev_header_hash)
+    curr: BlockRecord | None = blocks.try_block_record(block.prev_header_hash)
     while curr is not None and not curr.is_transaction_block:
         curr = blocks.try_block_record(curr.prev_hash)
 
@@ -83,12 +81,12 @@ def block_to_block_record(
 def header_block_to_sub_block_record(
     constants: ConsensusConstants,
     required_iters: uint64,
-    block: Union[FullBlock, HeaderBlock],
+    block: FullBlock | HeaderBlock,
     sub_slot_iters: uint64,
     overflow: bool,
     deficit: uint8,
     prev_transaction_block_height: uint32,
-    ses: Optional[SubEpochSummary],
+    ses: SubEpochSummary | None,
 ) -> BlockRecord:
     reward_claims_incorporated = (
         block.transactions_info.reward_claims_incorporated if block.transactions_info is not None else None
@@ -102,18 +100,18 @@ def header_block_to_sub_block_record(
     )
 
     if block.reward_chain_block.infused_challenge_chain_ip_vdf is not None:
-        icc_output: Optional[ClassgroupElement] = block.reward_chain_block.infused_challenge_chain_ip_vdf.output
+        icc_output: ClassgroupElement | None = block.reward_chain_block.infused_challenge_chain_ip_vdf.output
     else:
         icc_output = None
 
     if len(block.finished_sub_slots) > 0:
-        finished_challenge_slot_hashes: Optional[list[bytes32]] = [
+        finished_challenge_slot_hashes: list[bytes32] | None = [
             sub_slot.challenge_chain.get_hash() for sub_slot in block.finished_sub_slots
         ]
-        finished_reward_slot_hashes: Optional[list[bytes32]] = [
+        finished_reward_slot_hashes: list[bytes32] | None = [
             sub_slot.reward_chain.get_hash() for sub_slot in block.finished_sub_slots
         ]
-        finished_infused_challenge_slot_hashes: Optional[list[bytes32]] = [
+        finished_infused_challenge_slot_hashes: list[bytes32] | None = [
             sub_slot.infused_challenge_chain.get_hash()
             for sub_slot in block.finished_sub_slots
             if sub_slot.infused_challenge_chain is not None