chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.6.0rc2__py3-none-any.whl

chia/_tests/timelord/test_new_peak.py

@@ -1,9 +1,7 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import pytest
-from chia_rs import BlockRecord, FullBlock, SubEpochSummary, UnfinishedBlock
+from chia_rs import BlockRecord, FullBlock, SubEpochSummary, UnfinishedBlock, is_overflow_block
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64, uint128
 
@@ -22,6 +20,13 @@ from chia.simulator.wallet_tools import WalletTool
 from chia.timelord.timelord_api import TimelordAPI
 
 
+def last_unfinished(tl: TimelordAPI, *, overflow: bool) -> timelord_protocol.NewUnfinishedBlockTimelord:
+    if overflow:
+        return tl.timelord.overflow_blocks[-1]
+    else:
+        return tl.timelord.unfinished_blocks[-1]
+
+
 class TestNewPeak:
     @pytest.mark.anyio
     async def test_timelord_new_peak_basic(
@@ -127,7 +132,8 @@ class TestNewPeak:
             )
             await timelord_api.new_unfinished_block_timelord(timelord_unf_block)
 
-            assert timelord_api.timelord.unfinished_blocks[-1].get_hash() == timelord_unf_block.get_hash()
+            overflow = is_overflow_block(bt.constants, timelord_unf_block.reward_chain_block.signage_point_index)
+            assert last_unfinished(timelord_api, overflow=overflow).get_hash() == timelord_unf_block.get_hash()
             new_peak = timelord_peak_from_block(b1, block_2)
             assert timelord_unf_block.reward_chain_block.total_iters <= new_peak.reward_chain_block.total_iters
             await timelord_api.new_peak_timelord(new_peak)
@@ -193,7 +199,9 @@ class TestNewPeak:
                     await get_rc_prev(b1, block_1),
                 )
                 await timelord_api.new_unfinished_block_timelord(timelord_unf_block)
-                assert timelord_api.timelord.unfinished_blocks[-1].get_hash() == timelord_unf_block.get_hash()
+
+                overflow = is_overflow_block(bt.constants, timelord_unf_block.reward_chain_block.signage_point_index)
+                assert last_unfinished(timelord_api, overflow=overflow).get_hash() == timelord_unf_block.get_hash()
                 new_peak = timelord_peak_from_block(b2, block_2)
 
                 # timelord knows unfinished block_1 that has lower iterations,
@@ -208,7 +216,8 @@ class TestNewPeak:
                     == peak.reward_chain_block.get_hash()
                 )
                 # check unfinished block_1 is still in cache
-                assert timelord_api.timelord.unfinished_blocks[-1].get_hash() == timelord_unf_block.get_hash()
+                overflow = is_overflow_block(bt.constants, timelord_unf_block.reward_chain_block.signage_point_index)
+                assert last_unfinished(timelord_api, overflow=overflow).get_hash() == timelord_unf_block.get_hash()
 
                 # full node gets block_1 unfinished
                 block_1_unf = UnfinishedBlock(
@@ -371,7 +380,8 @@ class TestNewPeak:
 
                 # add unfinished and make sure we cache it
                 await timelord_api.new_unfinished_block_timelord(timelord_unf_block)
-                assert timelord_api.timelord.unfinished_blocks[-1].get_hash() == timelord_unf_block.get_hash()
+                overflow = is_overflow_block(bt.constants, timelord_unf_block.reward_chain_block.signage_point_index)
+                assert last_unfinished(timelord_api, overflow=overflow).get_hash() == timelord_unf_block.get_hash()
                 new_peak = timelord_peak_from_block(b1, block_1)
                 assert timelord_unf_block.reward_chain_block.total_iters >= new_peak.reward_chain_block.total_iters
                 await timelord_api.new_peak_timelord(new_peak)
@@ -531,9 +541,10 @@ class TestNewPeak:
                 )
 
             await timelord_api.new_unfinished_block_timelord(timelord_unf_block)
-            assert timelord_api.timelord.unfinished_blocks[-1].get_hash() == timelord_unf_block.get_hash()
+            overflow = is_overflow_block(bt.constants, timelord_unf_block.reward_chain_block.signage_point_index)
+            assert last_unfinished(timelord_api, overflow=overflow).get_hash() == timelord_unf_block.get_hash()
             assert (
-                timelord_api.timelord.unfinished_blocks[-1].reward_chain_block.get_hash()
+                last_unfinished(timelord_api, overflow=overflow).reward_chain_block.get_hash()
                 == timelord_unf_block.reward_chain_block.get_hash()
             )
 
@@ -579,7 +590,7 @@ def get_recent_reward_challenges(blockchain: Blockchain) -> list[tuple[bytes32,
     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 * blockchain.constants.MAX_SUB_SLOT_BLOCKS:
         if curr != peak:
             recent_rc.append((curr.reward_infusion_new_challenge, curr.total_iters))
@@ -602,7 +613,7 @@ def timelord_peak_from_block(
 ) -> timelord_protocol.NewPeakTimelord:
     peak = blockchain.block_record(block.header_hash)
     _, difficulty = get_next_sub_slot_iters_and_difficulty(blockchain.constants, False, peak, blockchain)
-    ses: Optional[SubEpochSummary] = next_sub_epoch_summary(
+    ses: SubEpochSummary | None = next_sub_epoch_summary(
         blockchain.constants, blockchain, peak.required_iters, block, True
     )
 

chia/_tests/tools/test_run_block.py

@@ -34,8 +34,6 @@ constants = DEFAULT_CONSTANTS.replace(
     ),
     MEMPOOL_BLOCK_BUFFER=uint8(10),
     MIN_PLOT_SIZE_V1=uint8(18),
-    # TODO: todo_v2_plots decide on v2 test plot k-size
-    MIN_PLOT_SIZE_V2=uint8(18),
 )
 retire_bytes = (
     b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"

chia/_tests/tools/test_virtual_project.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import textwrap
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any
 
 import click
 import pytest

chia/_tests/util/benchmarks.py

@@ -94,6 +94,7 @@ def rand_full_block() -> FullBlock:
         rand_g2(),
         rand_vdf(),
         rand_vdf(),
+        None,
         True,
     )
 

chia/_tests/util/blockchain.py

@@ -5,10 +5,10 @@ import os
 import pickle  # noqa: S403  # TODO: use explicit serialization instead of pickle
 from collections.abc import AsyncIterator
 from pathlib import Path
-from typing import Optional
 
 from chia_rs import ConsensusConstants, FullBlock
 from chia_rs.sized_ints import uint64
+from filelock import FileLock
 
 from chia.consensus.block_height_map import BlockHeightMap
 from chia.consensus.blockchain import Blockchain
@@ -48,8 +48,8 @@ def persistent_blocks(
     normalized_to_identity_icc_eos: bool = False,
     normalized_to_identity_cc_sp: bool = False,
     normalized_to_identity_cc_ip: bool = False,
-    block_list_input: Optional[list[FullBlock]] = None,
-    time_per_block: Optional[float] = None,
+    block_list_input: list[FullBlock] | None = None,
+    time_per_block: float | None = None,
     dummy_block_references: bool = False,
     include_transactions: bool = False,
 ) -> list[FullBlock]:
@@ -59,6 +59,7 @@ def persistent_blocks(
         block_list_input = []
     block_path_dir = DEFAULT_ROOT_PATH.parent.joinpath("blocks")
     file_path = block_path_dir.joinpath(db_name)
+    lock_file_path = block_path_dir / (db_name + ".lockfile")
 
     ci = os.environ.get("CI")
     if ci is not None and not file_path.exists():
@@ -66,40 +67,41 @@ def persistent_blocks(
 
     block_path_dir.mkdir(parents=True, exist_ok=True)
 
-    if file_path.exists():
-        print(f"File found at: {file_path}")
-        try:
-            bytes_list = file_path.read_bytes()
-            # TODO: use explicit serialization instead of pickle
-            block_bytes_list: list[bytes] = pickle.loads(bytes_list)  # noqa: S301
-            blocks: list[FullBlock] = []
-            for block_bytes in block_bytes_list:
-                blocks.append(FullBlock.from_bytes_unchecked(block_bytes))
-            if len(blocks) == num_of_blocks + len(block_list_input):
-                print(f"\n loaded {file_path} with {len(blocks)} blocks")
+    with FileLock(lock_file_path):
+        if file_path.exists():
+            print(f"File found at: {file_path}")
+            try:
+                bytes_list = file_path.read_bytes()
+                # TODO: use explicit serialization instead of pickle
+                block_bytes_list: list[bytes] = pickle.loads(bytes_list)  # noqa: S301
+                blocks: list[FullBlock] = []
+                for block_bytes in block_bytes_list:
+                    blocks.append(FullBlock.from_bytes_unchecked(block_bytes))
+                if len(blocks) == num_of_blocks + len(block_list_input):
+                    print(f"\n loaded {file_path} with {len(blocks)} blocks")
 
-                return blocks
-        except EOFError:
-            print("\n error reading db file")
-    else:
-        print(f"File not found at: {file_path}")
+                    return blocks
+            except EOFError:
+                print("\n error reading db file")
+        else:
+            print(f"File not found at: {file_path}")
 
-    print("Creating a new test db")
-    return new_test_db(
-        file_path,
-        num_of_blocks,
-        seed,
-        empty_sub_slots,
-        bt,
-        block_list_input,
-        time_per_block,
-        normalized_to_identity_cc_eos=normalized_to_identity_cc_eos,
-        normalized_to_identity_icc_eos=normalized_to_identity_icc_eos,
-        normalized_to_identity_cc_sp=normalized_to_identity_cc_sp,
-        normalized_to_identity_cc_ip=normalized_to_identity_cc_ip,
-        dummy_block_references=dummy_block_references,
-        include_transactions=include_transactions,
-    )
+        print("Creating a new test db")
+        return new_test_db(
+            file_path,
+            num_of_blocks,
+            seed,
+            empty_sub_slots,
+            bt,
+            block_list_input,
+            time_per_block,
+            normalized_to_identity_cc_eos=normalized_to_identity_cc_eos,
+            normalized_to_identity_icc_eos=normalized_to_identity_icc_eos,
+            normalized_to_identity_cc_sp=normalized_to_identity_cc_sp,
+            normalized_to_identity_cc_ip=normalized_to_identity_cc_ip,
+            dummy_block_references=dummy_block_references,
+            include_transactions=include_transactions,
+        )
 
 
 def new_test_db(
@@ -109,7 +111,7 @@ def new_test_db(
     empty_sub_slots: int,
     bt: BlockTools,
     block_list_input: list[FullBlock],
-    time_per_block: Optional[float],
+    time_per_block: float | None,
     *,
     normalized_to_identity_cc_eos: bool = False,  # CC_EOS,
     normalized_to_identity_icc_eos: bool = False,  # ICC_EOS

chia/_tests/util/blockchain_mock.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, ClassVar, cast
 
 from chia_rs import BlockRecord, HeaderBlock, SubEpochChallengeSegment, SubEpochSegments, SubEpochSummary
 from chia_rs.sized_bytes import bytes32
@@ -20,9 +20,9 @@ class BlockchainMock:
     def __init__(
         self,
         blocks: dict[bytes32, BlockRecord],
-        headers: Optional[dict[bytes32, HeaderBlock]] = None,
-        height_to_hash: Optional[dict[uint32, bytes32]] = None,
-        sub_epoch_summaries: Optional[dict[uint32, SubEpochSummary]] = None,
+        headers: dict[bytes32, HeaderBlock] | None = None,
+        height_to_hash: dict[uint32, bytes32] | None = None,
+        sub_epoch_summaries: dict[uint32, SubEpochSummary] | None = None,
     ):
         if sub_epoch_summaries is None:
             sub_epoch_summaries = {}
@@ -37,10 +37,10 @@ class BlockchainMock:
         self._sub_epoch_segments: dict[bytes32, SubEpochSegments] = {}
         self.log = logging.getLogger(__name__)
 
-    def get_peak(self) -> Optional[BlockRecord]:
+    def get_peak(self) -> BlockRecord | None:
         return None
 
-    def get_peak_height(self) -> Optional[uint32]:
+    def get_peak_height(self) -> uint32 | None:
         return None
 
     def block_record(self, header_hash: bytes32) -> BlockRecord:
@@ -49,7 +49,7 @@ class BlockchainMock:
     def height_to_block_record(self, height: uint32, check_db: bool = False) -> BlockRecord:
         # Precondition: height is < peak height
 
-        header_hash: Optional[bytes32] = self.height_to_hash(height)
+        header_hash: bytes32 | None = self.height_to_hash(height)
         assert header_hash is not None
 
         return self.block_record(header_hash)
@@ -60,7 +60,7 @@ class BlockchainMock:
     def get_ses(self, height: uint32) -> SubEpochSummary:
         return self._sub_epoch_summaries[height]
 
-    def height_to_hash(self, height: uint32) -> Optional[bytes32]:
+    def height_to_hash(self, height: uint32) -> bytes32 | None:
         assert height in self._height_to_hash
         return self._height_to_hash[height]
 
@@ -88,10 +88,10 @@ class BlockchainMock:
             block_records.append(self.height_to_block_record(height))
         return block_records
 
-    def try_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
+    def try_block_record(self, header_hash: bytes32) -> BlockRecord | None:
         return self._block_records.get(header_hash)
 
-    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:
         return self._block_records[header_hash]
 
     async def prev_block_hash(self, header_hashes: list[bytes32]) -> list[bytes32]:
@@ -119,7 +119,7 @@ class BlockchainMock:
     async def get_sub_epoch_challenge_segments(
         self,
         sub_epoch_summary_hash: bytes32,
-    ) -> Optional[list[SubEpochChallengeSegment]]:
+    ) -> list[SubEpochChallengeSegment] | None:
         segments = self._sub_epoch_segments.get(sub_epoch_summary_hash)
         if segments is None:
             return None

chia/_tests/util/build_network_protocol_files.py

@@ -4,8 +4,9 @@ from __future__ import annotations
 import os
 import subprocess
 import sys
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any
 
 from chia_rs.sized_ints import uint32
 

chia/_tests/util/coin_store.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from chia_rs import CoinRecord
+
 from chia.consensus.coin_store_protocol import CoinStoreProtocol
-from chia.types.coin_record import CoinRecord
 from chia.util.db_wrapper import DBWrapper2
 
 

chia/_tests/util/config.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-job_timeout = 60
+job_timeout = 90

chia/_tests/util/db_connection.py

@@ -4,7 +4,6 @@ import tempfile
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import Optional
 
 import aiosqlite
 
@@ -14,8 +13,8 @@ from chia.util.db_wrapper import DBWrapper2, generate_in_memory_db_uri
 @asynccontextmanager
 async def DBConnection(
     db_version: int,
-    foreign_keys: Optional[bool] = None,
-    row_factory: Optional[type[aiosqlite.Row]] = None,
+    foreign_keys: bool | None = None,
+    row_factory: type[aiosqlite.Row] | None = None,
 ) -> AsyncIterator[DBWrapper2]:
     db_uri = generate_in_memory_db_uri()
     async with DBWrapper2.managed(

chia/_tests/util/full_sync.py

@@ -5,10 +5,10 @@ import logging
 import shutil
 import tempfile
 import time
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Callable, Optional, cast
+from typing import cast
 
 import aiosqlite
 import zstd
@@ -60,9 +60,7 @@ def enable_profiler(profile: bool, counter: int) -> Iterator[None]:
 
 
 class FakeServer:
-    async def send_to_all(
-        self, messages: list[Message], node_type: NodeType, exclude: Optional[bytes32] = None
-    ) -> None:
+    async def send_to_all(self, messages: list[Message], node_type: NodeType, exclude: bytes32 | None = None) -> None:
         pass
 
     async def send_to_all_if(
@@ -70,18 +68,18 @@ class FakeServer:
         messages: list[Message],
         node_type: NodeType,
         predicate: Callable[[WSChiaConnection], bool],
-        exclude: Optional[bytes32] = None,
+        exclude: bytes32 | None = None,
     ) -> None:
         pass
 
     def set_received_message_callback(self, callback: ConnectionCallback) -> None:
         pass
 
-    async def get_peer_info(self) -> Optional[PeerInfo]:
+    async def get_peer_info(self) -> PeerInfo | None:
         return None
 
     def get_connections(
-        self, node_type: Optional[NodeType] = None, *, outbound: Optional[bool] = False
+        self, node_type: NodeType | None = None, *, outbound: bool | None = False
     ) -> list[WSChiaConnection]:
         return []
 
@@ -91,7 +89,7 @@ class FakeServer:
     async def start_client(
         self,
         target_node: PeerInfo,
-        on_connect: Optional[ConnectionCallback] = None,
+        on_connect: ConnectionCallback | None = None,
         auth: bool = False,
         is_feeler: bool = False,
     ) -> bool:
@@ -105,7 +103,7 @@ class FakePeer:
     def __init__(self) -> None:
         self.peer_node_id = bytes([0] * 32)
 
-    async def get_peer_info(self) -> Optional[PeerInfo]:
+    async def get_peer_info(self) -> PeerInfo | None:
         return None
 
 
@@ -118,7 +116,7 @@ async def run_sync_test(
     keep_up: bool,
     db_sync: str,
     node_profiler: bool,
-    start_at_checkpoint: Optional[str],
+    start_at_checkpoint: str | None,
 ) -> None:
     logger = logging.getLogger()
     logger.setLevel(logging.WARNING)

chia/_tests/util/gen_ssl_certs.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Optional
 
 import click
 from pytest import MonkeyPatch
@@ -20,8 +19,8 @@ from chia.ssl.create_ssl import generate_ca_signed_cert, get_chia_ca_crt_key, ma
     required=True,
 )
 def gen_ssl(suffix: str = "") -> None:
-    captured_crt: Optional[bytes] = None
-    captured_key: Optional[bytes] = None
+    captured_crt: bytes | None = None
+    captured_key: bytes | None = None
     capture_cert_and_key = False
 
     def patched_write_ssl_cert_and_key(cert_path: Path, cert_data: bytes, key_path: Path, key_data: bytes) -> None:
@@ -39,8 +38,8 @@ def gen_ssl(suffix: str = "") -> None:
     patch = MonkeyPatch()
     patch.setattr("chia.ssl.create_ssl.write_ssl_cert_and_key", patched_write_ssl_cert_and_key)
 
-    private_ca_crt: Optional[bytes] = None
-    private_ca_key: Optional[bytes] = None
+    private_ca_crt: bytes | None = None
+    private_ca_key: bytes | None = None
     capture_cert_and_key = True
 
     make_ca_cert(Path("SSL_TEST_PRIVATE_CA_CRT"), Path("SSL_TEST_PRIVATE_CA_KEY"))

chia/_tests/util/get_name_puzzle_conditions.py

@@ -28,6 +28,8 @@ def get_name_puzzle_conditions(
     height: uint32,
     constants: ConsensusConstants,
 ) -> NPCResult:
+    # TODO: technically, this is supposed to be the previous transaction block
+    # height. But this is just for testing and it seems to be OK for now
     flags = get_flags_for_height_and_constants(height, constants) | DONT_VALIDATE_SIGNATURE
 
     if mempool_mode:

chia/_tests/util/misc.py

@@ -12,7 +12,7 @@ import pathlib
 import ssl
 import subprocess
 import sys
-from collections.abc import Awaitable, Collection, Iterator
+from collections.abc import Awaitable, Callable, Collection, Iterator
 from concurrent.futures import Future
 from dataclasses import dataclass, field
 from enum import Enum
@@ -20,7 +20,7 @@ from statistics import mean
 from textwrap import dedent
 from time import thread_time
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, Protocol, TextIO, TypeVar, Union, cast, final
+from typing import TYPE_CHECKING, Any, ClassVar, Protocol, TextIO, TypeVar, cast, final
 
 import aiohttp
 import pytest
@@ -88,7 +88,7 @@ class RuntimeResults:
     duration: float
     entry_file: str
     entry_line: int
-    overhead: Optional[float]
+    overhead: float | None
 
     def block(self, label: str = "") -> str:
         # The entry line is reported starting at the beginning of the line to trigger
@@ -112,13 +112,13 @@ class AssertRuntimeResults:
     duration: float
     entry_file: str
     entry_line: int
-    overhead: Optional[float]
+    overhead: float | None
     limit: float
     ratio: float
 
     @classmethod
     def from_runtime_results(
-        cls, results: RuntimeResults, limit: float, entry_file: str, entry_line: int, overhead: Optional[float]
+        cls, results: RuntimeResults, limit: float, entry_file: str, entry_line: int, overhead: float | None
     ) -> AssertRuntimeResults:
         return cls(
             start=results.start,
@@ -161,7 +161,7 @@ class AssertRuntimeResults:
 
 def measure_overhead(
     manager_maker: Callable[
-        [], contextlib.AbstractContextManager[Union[Future[RuntimeResults], Future[AssertRuntimeResults]]]
+        [], contextlib.AbstractContextManager[Future[RuntimeResults] | Future[AssertRuntimeResults]]
     ],
     cycles: int = 10,
 ) -> float:
@@ -183,7 +183,7 @@ def measure_runtime(
     label: str = "",
     clock: Callable[[], float] = thread_time,
     gc_mode: GcMode = GcMode.disable,
-    overhead: Optional[float] = None,
+    overhead: float | None = None,
     print_results: bool = True,
 ) -> Iterator[Future[RuntimeResults]]:
     entry_file, entry_line = caller_file_and_line(
@@ -289,12 +289,12 @@ class _AssertRuntime:
     clock: Callable[[], float] = thread_time
     gc_mode: GcMode = GcMode.disable
     print: bool = True
-    overhead: Optional[float] = None
-    entry_file: Optional[str] = None
-    entry_line: Optional[int] = None
-    _results: Optional[AssertRuntimeResults] = None
-    runtime_manager: Optional[contextlib.AbstractContextManager[Future[RuntimeResults]]] = None
-    runtime_results_callable: Optional[Future[RuntimeResults]] = None
+    overhead: float | None = None
+    entry_file: str | None = None
+    entry_line: int | None = None
+    _results: AssertRuntimeResults | None = None
+    runtime_manager: contextlib.AbstractContextManager[Future[RuntimeResults]] | None = None
+    runtime_results_callable: Future[RuntimeResults] | None = None
     enable_assertion: bool = True
 
     def __enter__(self) -> Future[AssertRuntimeResults]:
@@ -315,9 +315,9 @@ class _AssertRuntime:
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc: Optional[BaseException],
-        traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
     ) -> None:
         if (
             self.entry_file is None
@@ -366,8 +366,8 @@ class _AssertRuntime:
 @dataclasses.dataclass
 class BenchmarkRunner:
     enable_assertion: bool = True
-    test_id: Optional[TestId] = None
-    overhead: Optional[float] = None
+    test_id: TestId | None = None
+    overhead: float | None = None
 
     def assert_runtime(self, *args: Any, **kwargs: Any) -> _AssertRuntime:
         kwargs.setdefault("enable_assertion", self.enable_assertion)
@@ -398,7 +398,7 @@ def closing_chia_root_popen(chia_root: ChiaRoot, args: list[str]) -> Iterator[su
 
 
 # https://github.com/pytest-dev/pytest/blob/7.3.1/src/_pytest/mark/__init__.py#L45
-Marks = Union[pytest.MarkDecorator, Collection[Union[pytest.MarkDecorator, pytest.Mark]]]
+Marks = pytest.MarkDecorator | Collection[pytest.MarkDecorator | pytest.Mark]
 
 
 class DataCase(Protocol):
@@ -445,7 +445,7 @@ class CoinGenerator:
         self._seed += 1
         return uint64(self._seed)
 
-    def get(self, parent_coin_id: Optional[bytes32] = None, include_hint: bool = True) -> HintedCoin:
+    def get(self, parent_coin_id: bytes32 | None = None, include_hint: bool = True) -> HintedCoin:
         if parent_coin_id is None:
             parent_coin_id = self._get_hash()
         hint = None
@@ -516,7 +516,7 @@ class RecordingWebServer:
         hostname: str,
         port: uint16,
         max_request_body_size: int = 1024**2,  # Default `client_max_size` from web.Application
-        ssl_context: Optional[ssl.SSLContext] = None,
+        ssl_context: ssl.SSLContext | None = None,
         prefer_ipv6: bool = False,
     ) -> RecordingWebServer:
         web_server = await WebServer.create(
@@ -657,9 +657,9 @@ def is_attribute_local(o: object, name: str) -> bool:
 
 @contextlib.contextmanager
 def patch_request_handler(
-    api: Union[ApiProtocol, type[ApiProtocol]],
-    handler: Callable[..., Awaitable[Optional[Message]]],
-    request_type: Optional[ProtocolMessageTypes] = None,
+    api: ApiProtocol | type[ApiProtocol],
+    handler: Callable[..., Awaitable[Message | None]],
+    request_type: ProtocolMessageTypes | None = None,
 ) -> Iterator[None]:
     if request_type is None:
         request_type = ProtocolMessageTypes[handler.__name__]