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

chia/consensus/generator_tools.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from collections.abc import Collection
-from typing import Optional
 
 from chia_rs import FullBlock, HeaderBlock, SpendBundleConditions
 from chia_rs.sized_bytes import bytes32
@@ -12,7 +11,7 @@ from chia.types.blockchain_format.coin import Coin
 
 
 def get_block_header(
-    block: FullBlock, removals_and_additions: Optional[tuple[Collection[bytes32], Collection[Coin]]] = None
+    block: FullBlock, removals_and_additions: tuple[Collection[bytes32], Collection[Coin]] | None = None
 ) -> HeaderBlock:
     """
     Returns a HeaderBlock from a FullBlock.
@@ -51,7 +50,7 @@ def get_block_header(
     )
 
 
-def tx_removals_and_additions(results: Optional[SpendBundleConditions]) -> tuple[list[bytes32], list[Coin]]:
+def tx_removals_and_additions(results: SpendBundleConditions | None) -> tuple[list[bytes32], list[Coin]]:
     """
     Doesn't return farmer and pool reward.
     """

chia/consensus/get_block_challenge.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional, Union
 
 from chia_rs import BlockRecord, ConsensusConstants, FullBlock, HeaderBlock, UnfinishedBlock
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint32, uint64
+from chia_rs.sized_ints import uint8, uint32, uint64
 
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
 from chia.types.unfinished_header_block import UnfinishedHeaderBlock
@@ -14,7 +13,7 @@ log = logging.getLogger(__name__)
 
 
 def final_eos_is_already_included(
-    header_block: Union[UnfinishedHeaderBlock, UnfinishedBlock, HeaderBlock, FullBlock],
+    header_block: UnfinishedHeaderBlock | UnfinishedBlock | HeaderBlock | FullBlock,
     blocks: BlockRecordsProtocol,
     sub_slot_iters: uint64,
 ) -> bool:
@@ -52,7 +51,7 @@ def final_eos_is_already_included(
 
 def get_block_challenge(
     constants: ConsensusConstants,
-    header_block: Union[UnfinishedHeaderBlock, UnfinishedBlock, HeaderBlock, FullBlock],
+    header_block: UnfinishedHeaderBlock | UnfinishedBlock | HeaderBlock | FullBlock,
     blocks: BlockRecordsProtocol,
     genesis_block: bool,
     overflow: bool,
@@ -102,28 +101,45 @@ def get_block_challenge(
     return challenge
 
 
-def prev_tx_block(
+# Returns the previous transaction block up to the blocks signage point
+# we use this for block validation since when the block is farmed we do not know the latest transaction block
+# since a new one might be infused by the time the block is infused
+def pre_sp_tx_block(
+    constants: ConsensusConstants,
+    blocks: BlockRecordsProtocol,
+    *,
+    prev_b_hash: bytes32,
+    sp_index: uint8,
+    first_in_sub_slot: bool,
+) -> BlockRecord | None:
+    if prev_b_hash == constants.GENESIS_CHALLENGE:
+        return None
+    curr = blocks.block_record(prev_b_hash)
+    before_slot = first_in_sub_slot
+    while curr.height > 0:
+        if curr.is_transaction_block and (before_slot or curr.signage_point_index < sp_index):
+            break
+        if curr.first_in_sub_slot:
+            before_slot = True
+        curr = blocks.block_record(curr.prev_hash)
+    return curr
+
+
+def pre_sp_tx_block_height(
+    constants: ConsensusConstants,
     blocks: BlockRecordsProtocol,
-    prev_b: Optional[Union[BlockRecord, FullBlock, HeaderBlock]],
+    *,
+    prev_b_hash: bytes32,
+    sp_index: uint8,
+    first_in_sub_slot: bool,
 ) -> uint32:
-    # todo add check to make sure we dont return tx block from same sp as block we are validating
-    if prev_b is None:
+    latest_tx_block = pre_sp_tx_block(
+        constants=constants,
+        blocks=blocks,
+        prev_b_hash=prev_b_hash,
+        sp_index=sp_index,
+        first_in_sub_slot=first_in_sub_slot,
+    )
+    if latest_tx_block is None:
         return uint32(0)
-    if isinstance(prev_b, BlockRecord):
-        if prev_b.prev_transaction_block_hash is not None:
-            return prev_b.height
-        else:
-            curr = prev_b
-    elif isinstance(prev_b, FullBlock):
-        if prev_b.foliage_transaction_block is not None:
-            return prev_b.height
-        else:
-            curr = blocks.block_record(prev_b.header_hash)
-    elif isinstance(prev_b, HeaderBlock):
-        if prev_b.foliage_transaction_block is not None:
-            return prev_b.height
-        else:
-            curr = blocks.block_record(prev_b.header_hash)
-    while curr.is_transaction_block is False and curr.height > 0:
-        curr = blocks.block_record(curr.prev_hash)
-    return curr.height
+    return latest_tx_block.height

chia/consensus/get_block_generator.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-from collections.abc import Awaitable
-from typing import Callable, Optional
+from collections.abc import Awaitable, Callable
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
@@ -13,7 +12,7 @@ from chia.types.generator_types import BlockGenerator
 async def get_block_generator(
     lookup_block_generators: Callable[[bytes32, set[uint32]], Awaitable[dict[uint32, bytes]]],
     block: BlockInfo,
-) -> Optional[BlockGenerator]:
+) -> BlockGenerator | None:
     ref_list = block.transactions_generator_ref_list
     if block.transactions_generator is None:
         assert len(ref_list) == 0

chia/consensus/make_sub_epoch_summary.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional, Union
 
 from chia_rs import BlockRecord, ConsensusConstants, FullBlock, SubEpochSummary, UnfinishedBlock
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
@@ -25,9 +24,9 @@ def make_sub_epoch_summary(
     blocks: BlockRecordsProtocol,
     blocks_included_height: uint32,
     prev_prev_block: BlockRecord,
-    new_difficulty: Optional[uint64],
-    new_sub_slot_iters: Optional[uint64],
-    prev_ses_block: Optional[BlockRecord] = None,
+    new_difficulty: uint64 | None,
+    new_sub_slot_iters: uint64 | None,
+    prev_ses_block: BlockRecord | None = None,
 ) -> SubEpochSummary:
     """
     Creates a sub-epoch-summary object, assuming that the first block in the new sub-epoch is at height
@@ -53,6 +52,7 @@ def make_sub_epoch_summary(
             uint8(0),
             None,
             None,
+            None,
         )
     if prev_ses_block is None:
         curr: BlockRecord = prev_prev_block
@@ -70,6 +70,7 @@ def make_sub_epoch_summary(
         uint8(prev_ses_block.height % constants.SUB_EPOCH_BLOCKS),
         new_difficulty,
         new_sub_slot_iters,
+        None,  # challenge_merkle_root
     )
 
 
@@ -77,9 +78,9 @@ def next_sub_epoch_summary(
     constants: ConsensusConstants,
     blocks: BlockRecordsProtocol,
     required_iters: uint64,
-    block: Union[UnfinishedBlock, FullBlock],
+    block: UnfinishedBlock | FullBlock,
     can_finish_soon: bool = False,
-) -> Optional[SubEpochSummary]:
+) -> SubEpochSummary | None:
     """
     Returns the sub-epoch summary that can be included in the block after block. If it should include one. Block
     must be eligible to be the last block in the epoch. If not, returns None. Assumes that there is a new slot
@@ -97,7 +98,7 @@ def next_sub_epoch_summary(
         object: the new sub-epoch summary
     """
     signage_point_index = block.reward_chain_block.signage_point_index
-    prev_b: Optional[BlockRecord] = blocks.try_block_record(block.prev_header_hash)
+    prev_b: BlockRecord | None = blocks.try_block_record(block.prev_header_hash)
     if prev_b is None or prev_b.height == 0:
         return None
 

chia/consensus/multiprocess_validation.py

@@ -8,7 +8,6 @@ import traceback
 from collections.abc import Awaitable, Collection
 from concurrent.futures import Executor
 from dataclasses import dataclass
-from typing import Optional
 
 from chia_rs import (
     BlockRecord,
@@ -28,7 +27,7 @@ from chia.consensus.block_header_validation import validate_finished_header_bloc
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
 from chia.consensus.full_block_to_block_record import block_to_block_record
 from chia.consensus.generator_tools import get_block_header, tx_removals_and_additions
-from chia.consensus.get_block_challenge import get_block_challenge, prev_tx_block
+from chia.consensus.get_block_challenge import get_block_challenge, pre_sp_tx_block_height
 from chia.consensus.get_block_generator import get_block_generator
 from chia.consensus.pot_iterations import (
     is_overflow_block,
@@ -46,9 +45,9 @@ log = logging.getLogger(__name__)
 @streamable
 @dataclass(frozen=True)
 class PreValidationResult(Streamable):
-    error: Optional[uint16]
-    required_iters: Optional[uint64]  # Iff error is None
-    conds: Optional[SpendBundleConditions]  # Iff error is None and block is a transaction block
+    error: uint16 | None
+    required_iters: uint64 | None  # Iff error is None
+    conds: SpendBundleConditions | None  # Iff error is None and block is a transaction block
     timing: uint32  # the time (in milliseconds) it took to pre-validate the block
 
     @property
@@ -60,11 +59,11 @@ class PreValidationResult(Streamable):
 
 # this layer of abstraction is here to let wallet tests monkeypatch it
 def _run_block(
-    block: FullBlock, prev_generators: list[bytes], constants: ConsensusConstants
-) -> tuple[Optional[int], Optional[SpendBundleConditions]]:
+    block: FullBlock, prev_generators: list[bytes], prev_tx_height: uint32, constants: ConsensusConstants
+) -> tuple[int | None, SpendBundleConditions | None]:
     assert block.transactions_generator is not None
     assert block.transactions_info is not None
-    flags = get_flags_for_height_and_constants(block.height, constants)
+    flags = get_flags_for_height_and_constants(prev_tx_height, constants)
     if block.height >= constants.HARD_FORK_HEIGHT:
         run_block = run_block_generator2
     else:
@@ -84,8 +83,8 @@ def _pre_validate_block(
     constants: ConsensusConstants,
     blockchain: BlockRecordsProtocol,
     block: FullBlock,
-    prev_generators: Optional[list[bytes]],
-    conds: Optional[SpendBundleConditions],
+    prev_generators: list[bytes] | None,
+    conds: SpendBundleConditions | None,
     expected_vs: ValidationState,
 ) -> PreValidationResult:
     """
@@ -101,7 +100,7 @@ def _pre_validate_block(
 
     try:
         validation_start = time.monotonic()
-        removals_and_additions: Optional[tuple[Collection[bytes32], Collection[Coin]]] = None
+        removals_and_additions: tuple[Collection[bytes32], Collection[Coin]] | None = None
         if conds is not None:
             assert conds.validated_signature is True
             assert block.transactions_generator is not None
@@ -116,7 +115,14 @@ def _pre_validate_block(
                     uint16(Err.BLOCK_COST_EXCEEDS_MAX.value), None, None, uint32(validation_time * 1000)
                 )
 
-            err, conds = _run_block(block, prev_generators, constants)
+            prev_tx_height = pre_sp_tx_block_height(
+                constants=constants,
+                blocks=blockchain,
+                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,
+            )
+            err, conds = _run_block(block, prev_generators, prev_tx_height, constants)
 
             assert (err is None) != (conds is None)
             if err is not None:
@@ -137,7 +143,7 @@ def _pre_validate_block(
             True,  # check_filter
             expected_vs,
         )
-        error_int: Optional[uint16] = None
+        error_int: uint16 | None = None
         if error is not None:
             error_int = uint16(error.code.value)
 
@@ -160,10 +166,10 @@ async def pre_validate_block(
     blockchain: AugmentedBlockchain,
     block: FullBlock,
     pool: Executor,
-    conds: Optional[SpendBundleConditions],
+    conds: SpendBundleConditions | None,
     vs: ValidationState,
     *,
-    wp_summaries: Optional[list[SubEpochSummary]] = None,
+    wp_summaries: list[SubEpochSummary] | None = None,
 ) -> Awaitable[PreValidationResult]:
     """
     This method must be called under the blockchain lock
@@ -189,7 +195,7 @@ async def pre_validate_block(
         wp_summaries:
         validate_signatures:
     """
-    prev_b: Optional[BlockRecord] = None
+    prev_b: BlockRecord | None = None
 
     async def return_error(error_code: Err) -> PreValidationResult:
         return PreValidationResult(uint16(error_code.value), None, None, uint32(0))
@@ -220,8 +226,13 @@ async def pre_validate_block(
         cc_sp_hash,
         block.height,
         vs.difficulty,
-        vs.ssi,
-        prev_tx_block(blockchain, prev_b),
+        pre_sp_tx_block_height(
+            constants=constants,
+            blocks=blockchain,
+            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,
+        ),
     )
     if required_iters is None:
         return return_error(Err.INVALID_POSPACE)
@@ -248,10 +259,10 @@ async def pre_validate_block(
     blockchain.add_extra_block(block, block_rec)  # Temporarily add block to chain
     prev_b = block_rec
 
-    previous_generators: Optional[list[bytes]] = None
+    previous_generators: list[bytes] | None = None
 
     try:
-        block_generator: Optional[BlockGenerator] = await get_block_generator(blockchain.lookup_block_generators, block)
+        block_generator: BlockGenerator | None = await get_block_generator(blockchain.lookup_block_generators, block)
         if block_generator is not None:
             previous_generators = block_generator.generator_refs
     except ValueError:

chia/consensus/pos_quality.py

@@ -1,28 +1,14 @@
 from __future__ import annotations
 
-from chia_rs import PlotSize
+from chia_rs import ConsensusConstants, PlotParam
 from chia_rs.sized_ints import uint64
 
 # The actual space in bytes of a plot, is _expected_plot_size(k) * UI_ACTUAL_SPACE_CONSTANT_FACTO
 # This is not used in consensus, only for display purposes
 UI_ACTUAL_SPACE_CONSTANT_FACTOR = 0.78
 
-# TODO: todo_v2_plots these values prelimenary. When the plotter is complete,
-# replace this table with a closed form formula
-v2_plot_sizes: dict[int, uint64] = {
-    16: uint64(222_863),
-    18: uint64(1_048_737),
-    20: uint64(4_824_084),
-    22: uint64(21_812_958),
-    24: uint64(97_318_160),
-    26: uint64(429_539_960),
-    28: uint64(1_879_213_114),
-    30: uint64(8_161_097_549),
-    32: uint64(35_221_370_574),
-}
 
-
-def _expected_plot_size(size: PlotSize) -> uint64:
+def _expected_plot_size(size: PlotParam, constants: ConsensusConstants) -> uint64:
     """
     Given the plot size parameter k (which is between 32 and 59), computes the
     expected size of the plot in bytes (times a constant factor). This is based on efficient encoding
@@ -36,10 +22,7 @@ def _expected_plot_size(size: PlotSize) -> uint64:
         k = size.size_v1
         return uint64(((2 * k) + 1) * (2 ** (k - 1)))
     else:
-        assert size.size_v2 is not None
-        k = size.size_v2
-        if k in v2_plot_sizes:
-            return v2_plot_sizes[k]
-        else:
-            # TODO: todo_v2_plots support test plots with lower k-values
-            return uint64(0)
+        k = constants.PLOT_SIZE_V2
+        # TODO: todo_v2_plots this formula may change slightly before the
+        # final version of the plotter. Revisit this when the plotter is complete
+        return uint64((2**k) * (k + 1.46) / 8)

chia/consensus/pot_iterations.py

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional
-
-from chia_rs import ConsensusConstants, PlotSize, ProofOfSpace
+from chia_rs import ConsensusConstants, PlotParam, ProofOfSpace
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 
@@ -28,25 +26,6 @@ def calculate_sp_iters(constants: ConsensusConstants, sub_slot_iters: uint64, si
     return uint64(calculate_sp_interval_iters(constants, sub_slot_iters) * signage_point_index)
 
 
-def calculate_phase_out(
-    constants: ConsensusConstants,
-    sub_slot_iters: uint64,
-    prev_transaction_block_height: uint32,
-) -> uint64:
-    if prev_transaction_block_height <= constants.HARD_FORK2_HEIGHT:
-        return uint64(0)
-    elif uint32(prev_transaction_block_height - constants.HARD_FORK2_HEIGHT) >= constants.PLOT_V1_PHASE_OUT:
-        return uint64(calculate_sp_interval_iters(constants, sub_slot_iters))
-
-    return uint64(
-        (
-            uint32(prev_transaction_block_height - constants.HARD_FORK2_HEIGHT)
-            * calculate_sp_interval_iters(constants, sub_slot_iters)
-        )
-        // constants.PLOT_V1_PHASE_OUT
-    )
-
-
 def calculate_ip_iters(
     constants: ConsensusConstants,
     sub_slot_iters: uint64,
@@ -75,11 +54,17 @@ def validate_pospace_and_get_required_iters(
     cc_sp_hash: bytes32,
     height: uint32,
     difficulty: uint64,
-    sub_slot_iters: uint64,
     prev_transaction_block_height: uint32,  # this is the height of the last tx block before the current block SP
-) -> Optional[uint64]:
-    q_str: Optional[bytes32] = verify_and_get_quality_string(
-        proof_of_space, constants, challenge, cc_sp_hash, height=height
+    height_agnostic: bool = False,
+) -> uint64 | None:
+    q_str: bytes32 | None = verify_and_get_quality_string(
+        proof_of_space,
+        constants,
+        challenge,
+        cc_sp_hash,
+        height=height,
+        prev_transaction_block_height=prev_transaction_block_height,
+        height_agnostic=height_agnostic,
     )
     if q_str is None:
         return None
@@ -87,41 +72,29 @@ def validate_pospace_and_get_required_iters(
     return calculate_iterations_quality(
         constants,
         q_str,
-        proof_of_space.size(),
+        proof_of_space.param(),
         difficulty,
         cc_sp_hash,
-        sub_slot_iters,
-        prev_transaction_block_height,
     )
 
 
 def calculate_iterations_quality(
     constants: ConsensusConstants,
     quality_string: bytes32,
-    size: PlotSize,
+    size: PlotParam,
     difficulty: uint64,
     cc_sp_output_hash: bytes32,
-    ssi: uint64,
-    prev_transaction_block_height: uint32,  # this is the height of the last tx block before the current block SP
 ) -> uint64:
     """
     Calculates the number of iterations from the quality. This is derives as the difficulty times the constant factor
     times a random number between 0 and 1 (based on quality string), divided by plot size.
     """
-    if size.size_v1 is not None:
-        assert size.size_v2 is None
-        phase_out = calculate_phase_out(constants, ssi, prev_transaction_block_height)
-    else:
-        phase_out = uint64(0)
 
     sp_quality_string: bytes32 = std_hash(quality_string + cc_sp_output_hash)
     iters = uint64(
-        (
-            int(difficulty)
-            * int(constants.DIFFICULTY_CONSTANT_FACTOR)
-            * int.from_bytes(sp_quality_string, "big", signed=False)
-            // (int(pow(2, 256)) * int(_expected_plot_size(size)))
-        )
-        + phase_out
+        int(difficulty)
+        * int(constants.DIFFICULTY_CONSTANT_FACTOR)
+        * int.from_bytes(sp_quality_string, "big", signed=False)
+        // (int(pow(2, 256)) * int(_expected_plot_size(size, constants)))
     )
     return max(iters, uint64(1))

chia/consensus/signage_point.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Optional
 
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
 from chia.util.streamable import Streamable, streamable
@@ -10,7 +9,7 @@ from chia.util.streamable import Streamable, streamable
 @streamable
 @dataclass(frozen=True)
 class SignagePoint(Streamable):
-    cc_vdf: Optional[VDFInfo]
-    cc_proof: Optional[VDFProof]
-    rc_vdf: Optional[VDFInfo]
-    rc_proof: Optional[VDFProof]
+    cc_vdf: VDFInfo | None
+    cc_proof: VDFProof | None
+    rc_vdf: VDFInfo | None
+    rc_proof: VDFProof | None

chia/consensus/vdf_info_computation.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from chia_rs import BlockRecord, ConsensusConstants, EndOfSubSlotBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64, uint128
@@ -14,7 +12,7 @@ def get_signage_point_vdf_info(
     constants: ConsensusConstants,
     finished_sub_slots: list[EndOfSubSlotBundle],
     overflow: bool,
-    prev_b: Optional[BlockRecord],
+    prev_b: BlockRecord | None,
     blocks: BlockRecordsProtocol,
     sp_total_iters: uint128,
     sp_iters: uint64,
@@ -90,7 +88,7 @@ def get_signage_point_vdf_info(
             )
         else:
             found_sub_slots = []
-        sp_pre_sb: Optional[BlockRecord] = None
+        sp_pre_sb: BlockRecord | None = None
         while len(found_sub_slots) < 2 and curr.height > 0:
             if sp_pre_sb is None and curr.total_iters < sp_total_iters:
                 sp_pre_sb = curr

chia/daemon/client.py

@@ -6,7 +6,7 @@ import ssl
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import aiohttp
 from chia_rs.sized_ints import uint32
@@ -20,7 +20,7 @@ class DaemonProxy:
     def __init__(
         self,
         uri: str,
-        ssl_context: Optional[ssl.SSLContext],
+        ssl_context: ssl.SSLContext | None,
         heartbeat: int,
         max_message_size: int = 50 * 1000 * 1000,
     ):
@@ -29,8 +29,8 @@ class DaemonProxy:
         self.response_dict: dict[str, WsRpcMessage] = {}
         self.ssl_context = ssl_context
         self.heartbeat = heartbeat
-        self.client_session: Optional[aiohttp.ClientSession] = None
-        self.websocket: Optional[aiohttp.ClientWebSocketResponse] = None
+        self.client_session: aiohttp.ClientSession | None = None
+        self.websocket: aiohttp.ClientWebSocketResponse | None = None
         self.max_message_size = max_message_size
 
     def format_request(self, command: str, data: dict[str, Any]) -> WsRpcMessage:
@@ -164,7 +164,7 @@ class DaemonProxy:
         request = self.format_request("exit", {})
         return await self._get(request)
 
-    async def get_keys_for_plotting(self, fingerprints: Optional[list[uint32]] = None) -> WsRpcMessage:
+    async def get_keys_for_plotting(self, fingerprints: list[uint32] | None = None) -> WsRpcMessage:
         data = {"fingerprints": fingerprints} if fingerprints else {}
         request = self.format_request("get_keys_for_plotting", data)
         response = await self._get(request)
@@ -196,7 +196,7 @@ async def connect_to_daemon(
 
 async def connect_to_daemon_and_validate(
     root_path: Path, config: dict[str, Any], quiet: bool = False, wait_for_start: bool = False
-) -> Optional[DaemonProxy]:
+) -> DaemonProxy | None:
     """
     Connect to the local daemon and do a ping to ensure that something is really
     there and running.
@@ -233,7 +233,7 @@ async def connect_to_daemon_and_validate(
 @asynccontextmanager
 async def acquire_connection_to_daemon(
     root_path: Path, config: dict[str, Any], quiet: bool = False
-) -> AsyncIterator[Optional[DaemonProxy]]:
+) -> AsyncIterator[DaemonProxy | None]:
     """
     Asynchronous context manager which attempts to create a connection to the daemon.
     The connection object (DaemonProxy) is yielded to the caller. After the caller's
@@ -241,7 +241,7 @@ async def acquire_connection_to_daemon(
     closed.
     """
 
-    daemon: Optional[DaemonProxy] = None
+    daemon: DaemonProxy | None = None
     try:
         daemon = await connect_to_daemon_and_validate(root_path, config, quiet=quiet)
         yield daemon  # <----