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

chia/types/blockchain_format/proof_of_space.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional, cast
+from typing import cast
 
 from bitstring import BitArray
-from chia_rs import AugSchemeMPL, ConsensusConstants, G1Element, PlotSize, PrivateKey, ProofOfSpace
+from chia_rs import AugSchemeMPL, ConsensusConstants, G1Element, PlotParam, PrivateKey, ProofOfSpace, validate_proof_v2
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32
 from chiapos import Verifier
@@ -13,44 +13,23 @@ from chia.util.hash import std_hash
 
 log = logging.getLogger(__name__)
 
-# These are temporary stubs for chiapos2, that we build against until it's ready to be integrated.
-
-
-# returns quality string for v2 plot, or None if invalid
-def validate_proof_v2(
-    plot_id: bytes32, size: uint8, required_plot_strength: uint8, challenge: bytes32, proof: bytes
-) -> Optional[bytes32]:
-    # TODO: todo_v2_plots call into new chiapos library
-    raise NotImplementedError
-
-
-# this is compute intensive, solving a partial proof returning a full proof
-def solve_proof(partial_proof: bytes) -> bytes:
-    # TODO: todo_v2_plots call into new chiapos library
-    raise NotImplementedError
-
-
-# given a partial proof, computes the quality. This is used to compute required iters.
-def quality_for_partial_proof(partial_proof: bytes, challenge: bytes32) -> bytes32:
-    # TODO: todo_v2_plots call into new chiapos library
-    return std_hash(partial_proof + challenge)
-
 
 def make_pos(
     challenge: bytes32,
-    pool_public_key: Optional[G1Element],
-    pool_contract_puzzle_hash: Optional[bytes32],
+    pool_public_key: G1Element | None,
+    pool_contract_puzzle_hash: bytes32 | None,
     plot_public_key: G1Element,
-    version_and_size: PlotSize,
+    version_and_size: PlotParam,
     proof: bytes,
 ) -> ProofOfSpace:
     k: int
     if version_and_size.size_v1 is not None:
         k = version_and_size.size_v1
     else:
-        assert version_and_size.size_v2 is not None
-        k = version_and_size.size_v2
+        assert version_and_size.strength_v2 is not None
+        k = version_and_size.strength_v2
         assert k is not None
+        assert k <= 0x3F
         k |= 0x80
 
     return ProofOfSpace(
@@ -64,6 +43,11 @@ def make_pos(
 
 
 def get_plot_id(pos: ProofOfSpace) -> bytes32:
+    plot_param = pos.param()
+    if plot_param.strength_v2 is not None:
+        assert pos.pool_contract_puzzle_hash is not None
+        return calculate_plot_id_v2(pos.pool_contract_puzzle_hash, pos.plot_public_key, uint8(plot_param.strength_v2))
+
     assert pos.pool_public_key is None or pos.pool_contract_puzzle_hash is None
     if pos.pool_public_key is None:
         assert pos.pool_contract_puzzle_hash is not None
@@ -71,32 +55,74 @@ def get_plot_id(pos: ProofOfSpace) -> bytes32:
     return calculate_plot_id_pk(pos.pool_public_key, pos.plot_public_key)
 
 
-def check_plot_size(constants: ConsensusConstants, ps: PlotSize) -> bool:
+def check_plot_param(constants: ConsensusConstants, ps: PlotParam) -> bool:
     size_v1 = ps.size_v1
-    if size_v1 is not None:
-        assert ps.size_v2 is None
-        if size_v1 < constants.MIN_PLOT_SIZE_V1:
-            log.error("Plot size is lower than the minimum")
+    strength_v2 = ps.strength_v2
+    if strength_v2 is not None:
+        if strength_v2 < constants.MIN_PLOT_STRENGTH:
+            log.error(f"Plot strength ({strength_v2}) is lower than the minimum ({constants.MIN_PLOT_STRENGTH})")
             return False
-        if size_v1 > constants.MAX_PLOT_SIZE_V1:
-            log.error("Plot size is higher than the maximum")
+        if strength_v2 > constants.MAX_PLOT_STRENGTH:
+            log.error(f"Plot strength ({strength_v2}) is too high (max is {constants.MAX_PLOT_STRENGTH})")
             return False
         return True
 
-    size_v2 = ps.size_v2
-    assert size_v2 is not None
-    if size_v2 < constants.MIN_PLOT_SIZE_V2:
-        log.error("Plot size is lower than the minimum")
-        return False
-    if size_v2 > constants.MAX_PLOT_SIZE_V2:
-        log.error("Plot size is higher than the maximum")
+    assert size_v1 is not None
+    if size_v1 < constants.MIN_PLOT_SIZE_V1:
+        log.error(f"Plot size ({size_v1}) is lower than the minimum ({constants.MIN_PLOT_SIZE_V1})")
         return False
-    if (size_v2 & 1) == 1:
-        log.error("Plot size is odd")
+    if size_v1 > constants.MAX_PLOT_SIZE_V1:
+        log.error(f"Plot size ({size_v1}) is higher than the maximum ({constants.MAX_PLOT_SIZE_V1})")
         return False
     return True
 
 
+def num_phase_out_epochs(constants: ConsensusConstants) -> int:
+    """
+    The number of phase-out epochs is always a power-of-two minus 1. i.e. it
+    will also be a mask for the hash of the proof we're checking for phase-out.
+    Since the hash of the proof are random bits, the simplest check is just to
+    mask and compare the resulting value against the phase-out count down.
+    """
+    return (1 << constants.PLOT_V1_PHASE_OUT_EPOCH_BITS) - 1
+
+
+def v1_cut_off_height(constants: ConsensusConstants) -> int:
+    """
+    returns the height where v1 proofs-of-space are no longer valid. Blocks
+    whose previous transaction block is equal to or higher than this may not have a
+    v1 proof.
+    """
+    return constants.HARD_FORK2_HEIGHT + num_phase_out_epochs(constants) * constants.EPOCH_BLOCKS
+
+
+def is_v1_phased_out(
+    proof: bytes,
+    prev_transaction_block_height: uint32,  # this is the height of the last tx block before the current block SP
+    constants: ConsensusConstants,
+) -> bool:
+    if prev_transaction_block_height < constants.HARD_FORK2_HEIGHT:
+        return False
+
+    # This is a v1 plot and the phase-out period has started
+    # The probability of having been phased out is proportional on the
+    # number of epochs since hard fork activation
+    phase_out_epoch_mask = num_phase_out_epochs(constants)
+
+    # we just look at one byte so the mask can't be bigger than that
+    assert phase_out_epoch_mask < 256
+
+    # this counter is counting down to zero
+    epoch_counter = (v1_cut_off_height(constants) - prev_transaction_block_height) // constants.EPOCH_BLOCKS
+
+    # if we're past the phase-out, v1 plots are unconditionally invalid
+    if epoch_counter < 0:
+        return True
+
+    proof_value = std_hash(proof + b"chia proof-of-space v1 phase-out")[0] & phase_out_epoch_mask
+    return proof_value >= epoch_counter
+
+
 def verify_and_get_quality_string(
     pos: ProofOfSpace,
     constants: ConsensusConstants,
@@ -104,8 +130,25 @@ def verify_and_get_quality_string(
     signage_point: bytes32,
     *,
     height: uint32,
-) -> Optional[bytes32]:
+    prev_transaction_block_height: uint32,  # this is the height of the last tx block before the current block SP
+    height_agnostic: bool = False,
+) -> bytes32 | None:
+    plot_param = pos.param()
+
+    if not height_agnostic:
+        if plot_param.size_v1 is not None and is_v1_phased_out(pos.proof, prev_transaction_block_height, constants):
+            log.info("v1 proof has been phased-out and is no longer valid")
+            return None
+
+        if plot_param.strength_v2 is not None and prev_transaction_block_height < constants.HARD_FORK2_HEIGHT:
+            log.info("v2 proof support has not yet activated")
+            return None
+
     # Exactly one of (pool_public_key, pool_contract_puzzle_hash) must not be None
+    # Except v2 plots, they only support pool contract puzzle hash
+    if plot_param.strength_v2 is not None and pos.pool_contract_puzzle_hash is None:
+        log.error("v2 plots require pool_contract_puzzle_hash, pool public key is not supported")
+        return None
     if (pos.pool_public_key is None) and (pos.pool_contract_puzzle_hash is None):
         log.error("Expected pool public key or pool contract puzzle hash but got neither")
         return None
@@ -113,37 +156,42 @@ def verify_and_get_quality_string(
         log.error("Expected pool public key or pool contract puzzle hash but got both")
         return None
 
-    plot_size = pos.size()
-    if not check_plot_size(constants, plot_size):
+    if not check_plot_param(constants, plot_param):
         return None
 
     plot_id: bytes32 = get_plot_id(pos)
     new_challenge: bytes32 = calculate_pos_challenge(plot_id, original_challenge_hash, signage_point)
 
     if new_challenge != pos.challenge:
-        log.error("Calculated pos challenge doesn't match the provided one")
+        log.error(f"Calculated pos challenge doesn't match the provided one {new_challenge}")
         return None
 
     # we use different plot filter prefix sizes depending on v1 or v2 plots
-    prefix_bits = calculate_prefix_bits(constants, height, plot_size)
+    prefix_bits = calculate_prefix_bits(constants, height, plot_param)
     if not passes_plot_filter(prefix_bits, plot_id, original_challenge_hash, signage_point):
-        log.error("Did not pass the plot filter")
+        log.error(f"Did not pass the plot filter. prefix bits: {prefix_bits} {'V1' if plot_param.size_v1 else 'V2'}")
         return None
 
-    if plot_size.size_v1 is not None:
+    if plot_param.size_v1 is not None:
         # === V1 plots ===
-        assert plot_size.size_v2 is None
+        assert plot_param.strength_v2 is None
 
-        quality_str = Verifier().validate_proof(plot_id, plot_size.size_v1, pos.challenge, bytes(pos.proof))
+        quality_str = Verifier().validate_proof(plot_id, plot_param.size_v1, pos.challenge, bytes(pos.proof))
         if not quality_str:
             return None
         return bytes32(quality_str)
     else:
         # === V2 plots ===
-        assert plot_size.size_v2 is not None
+        assert plot_param.strength_v2 is not None
 
-        required_plot_strength = calculate_required_plot_strength(constants, height)
-        return validate_proof_v2(plot_id, plot_size.size_v2, required_plot_strength, pos.challenge, bytes(pos.proof))
+        return validate_proof_v2(
+            plot_id,
+            constants.PLOT_SIZE_V2,
+            pos.challenge,
+            plot_param.strength_v2,
+            constants.QUALITY_PROOF_SCAN_FILTER,
+            pos.proof,
+        )
 
 
 def passes_plot_filter(
@@ -163,10 +211,16 @@ def passes_plot_filter(
     return cast(bool, plot_filter[:prefix_bits].uint == 0)
 
 
-def calculate_prefix_bits(constants: ConsensusConstants, height: uint32, plot_size: PlotSize) -> int:
-    # v2 plots have a constant plot filter size
-    if plot_size.size_v2 is not None:
-        return constants.NUMBER_ZERO_BITS_PLOT_FILTER_V2
+def calculate_prefix_bits(constants: ConsensusConstants, height: uint32, plot_param: PlotParam) -> int:
+    if plot_param.strength_v2 is not None:
+        prefix_bits = int(constants.NUMBER_ZERO_BITS_PLOT_FILTER_V2)
+        if height >= constants.PLOT_FILTER_V2_THIRD_ADJUSTMENT_HEIGHT:
+            prefix_bits -= 3
+        elif height >= constants.PLOT_FILTER_V2_SECOND_ADJUSTMENT_HEIGHT:
+            prefix_bits -= 2
+        elif height >= constants.PLOT_FILTER_V2_FIRST_ADJUSTMENT_HEIGHT:
+            prefix_bits -= 1
+        return max(0, prefix_bits)
 
     prefix_bits = int(constants.NUMBER_ZERO_BITS_PLOT_FILTER_V1)
     if height >= constants.PLOT_FILTER_32_HEIGHT:
@@ -181,21 +235,6 @@ def calculate_prefix_bits(constants: ConsensusConstants, height: uint32, plot_si
     return max(0, prefix_bits)
 
 
-def calculate_required_plot_strength(constants: ConsensusConstants, height: uint32) -> uint8:
-    if height < constants.PLOT_STRENGTH_4_HEIGHT:
-        return constants.PLOT_STRENGTH_INITIAL
-    if height < constants.PLOT_STRENGTH_5_HEIGHT:
-        return uint8(4)
-    if height < constants.PLOT_STRENGTH_6_HEIGHT:
-        return uint8(5)
-    if height < constants.PLOT_STRENGTH_7_HEIGHT:
-        return uint8(6)
-    if height < constants.PLOT_STRENGTH_8_HEIGHT:
-        return uint8(7)
-    else:
-        return uint8(8)
-
-
 def calculate_plot_filter_input(plot_id: bytes32, challenge_hash: bytes32, signage_point: bytes32) -> bytes32:
     return std_hash(plot_id + challenge_hash + signage_point)
 
@@ -204,6 +243,14 @@ def calculate_pos_challenge(plot_id: bytes32, challenge_hash: bytes32, signage_p
     return std_hash(calculate_plot_filter_input(plot_id, challenge_hash, signage_point))
 
 
+def calculate_plot_id_v2(
+    pool_contract_puzzle_hash: bytes32,
+    plot_public_key: G1Element,
+    strength: uint8,
+) -> bytes32:
+    return std_hash(bytes(pool_contract_puzzle_hash) + bytes(plot_public_key) + bytes(strength))
+
+
 def calculate_plot_id_pk(
     pool_public_key: G1Element,
     plot_public_key: G1Element,

chia/types/blockchain_format/tree_hash.py

@@ -8,7 +8,7 @@ have to worry about blowing out the python stack.
 
 from __future__ import annotations
 
-from typing import Callable, Optional, Union
+from collections.abc import Callable
 
 from chia_rs.sized_bytes import bytes32
 from clvm.CLVMObject import CLVMStorage
@@ -16,13 +16,13 @@ from clvm.SExp import SExp
 
 from chia.util.hash import std_hash
 
-ValueType = Union[bytes, CLVMStorage]
+ValueType = bytes | CLVMStorage
 ValueStackType = list[ValueType]
 Op = Callable[[ValueStackType, "OpStackType", set[bytes32]], None]
 OpStackType = list[Op]
 
 
-def sha256_treehash(sexp: CLVMStorage, precalculated: Optional[set[bytes32]] = None) -> bytes32:
+def sha256_treehash(sexp: CLVMStorage, precalculated: set[bytes32] | None = None) -> bytes32:
     """
     Hash values in `precalculated` are presumed to have been hashed already.
     """

chia/types/blockchain_format/vdf.py

@@ -4,7 +4,6 @@ import logging
 import traceback
 from enum import IntEnum
 from functools import lru_cache
-from typing import Optional
 
 from chia_rs import ConsensusConstants, VDFInfo, VDFProof
 from chia_rs.sized_bytes import bytes32, bytes100
@@ -51,7 +50,7 @@ def validate_vdf(
     constants: ConsensusConstants,
     input_el: ClassgroupElement,
     info: VDFInfo,
-    target_vdf_info: Optional[VDFInfo] = None,
+    target_vdf_info: VDFInfo | None = None,
 ) -> bool:
     """
     If target_vdf_info is passed in, it is compared with info.

chia/types/coin_spend.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Union
+from typing import Any
 
 from chia_rs import CoinSpend
 
@@ -14,8 +14,8 @@ from chia.types.condition_with_args import ConditionWithArgs
 
 def make_spend(
     coin: Coin,
-    puzzle_reveal: Union[Program, SerializedProgram],
-    solution: Union[Program, SerializedProgram],
+    puzzle_reveal: Program | SerializedProgram,
+    solution: Program | SerializedProgram,
 ) -> CoinSpend:
     pr: SerializedProgram
     sol: SerializedProgram

chia/types/mempool_item.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs import CoinSpend, G2Element, SpendBundle, SpendBundleConditions
 from chia_rs.sized_bytes import bytes32
@@ -31,7 +31,7 @@ class BundleCoinSpend:
     # current unspent lineage belonging to this singleton, that we would rebase
     # this spend on top of if we were to make a block now
     # When finding MempoolItems by coin ID, we use Coin ID from it if it's set
-    latest_singleton_lineage: Optional[UnspentLineageInfo]
+    latest_singleton_lineage: UnspentLineageInfo | None
 
     @property
     def supports_fast_forward(self) -> bool:
@@ -47,12 +47,12 @@ class MempoolItem:
     height_added_to_mempool: uint32
 
     # If present, this SpendBundle is not valid at or before this height
-    assert_height: Optional[uint32] = None
+    assert_height: uint32 | None = None
 
     # If present, this SpendBundle is not valid once the block height reaches
     # the specified height
-    assert_before_height: Optional[uint32] = None
-    assert_before_seconds: Optional[uint64] = None
+    assert_before_height: uint32 | None = None
+    assert_before_seconds: uint64 | None = None
 
     # Map of coin ID to coin spend data between the bundle and its
     # SpendBundleConditions

chia/types/mempool_submission_status.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Optional, Union
 
 from chia_rs.sized_ints import uint8
 
@@ -20,9 +19,9 @@ class MempoolSubmissionStatus(Streamable):
 
     peer_id: str
     inclusion_status: uint8  # MempoolInclusionStatus
-    error_msg: Optional[str]
+    error_msg: str | None
 
-    def to_json_dict_convenience(self) -> dict[str, Union[str, MempoolInclusionStatus, None]]:
+    def to_json_dict_convenience(self) -> dict[str, str | MempoolInclusionStatus | None]:
         formatted = self.to_json_dict()
         formatted["inclusion_status"] = MempoolInclusionStatus(self.inclusion_status).name
         return formatted

chia/types/peer_info.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import ipaddress
 from dataclasses import dataclass
-from typing import Union
 
 from chia_rs.sized_ints import uint16, uint64
 
@@ -23,7 +22,7 @@ class PeerInfo:
     _port: uint16
 
     # TODO, Drop this as soon as all call PeerInfo calls pass in an IPAddress
-    def __init__(self, host: Union[IPAddress, str], port: int):
+    def __init__(self, host: IPAddress | str, port: int):
         self._ip = host if isinstance(host, IPAddress) else IPAddress.create(host)
         self._port = uint16(port)
 

chia/types/unfinished_header_block.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Optional
 
 from chia_rs import EndOfSubSlotBundle, Foliage, FoliageTransactionBlock, RewardChainBlockUnfinished
 from chia_rs.sized_bytes import bytes32
@@ -17,10 +16,10 @@ class UnfinishedHeaderBlock(Streamable):
     # Same as a FullBlock but without TransactionInfo and Generator, used by light clients
     finished_sub_slots: list[EndOfSubSlotBundle]  # If first sb
     reward_chain_block: RewardChainBlockUnfinished  # Reward chain trunk data
-    challenge_chain_sp_proof: Optional[VDFProof]  # If not first sp in sub-slot
-    reward_chain_sp_proof: Optional[VDFProof]  # If not first sp in sub-slot
+    challenge_chain_sp_proof: VDFProof | None  # If not first sp in sub-slot
+    reward_chain_sp_proof: VDFProof | None  # If not first sp in sub-slot
     foliage: Foliage  # Reward chain foliage data
-    foliage_transaction_block: Optional[FoliageTransactionBlock]  # Reward chain foliage data (tx block)
+    foliage_transaction_block: FoliageTransactionBlock | None  # Reward chain foliage data (tx block)
     transactions_filter: bytes  # Filter for block transactions
 
     @property

chia/types/validation_state.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Optional
 
 from chia_rs import BlockRecord
 from chia_rs.sized_ints import uint64
@@ -11,4 +10,4 @@ from chia_rs.sized_ints import uint64
 class ValidationState:
     ssi: uint64
     difficulty: uint64
-    prev_ses_block: Optional[BlockRecord] = None
+    prev_ses_block: BlockRecord | None = None

chia/util/action_scope.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import contextlib
-from collections.abc import AsyncIterator, Awaitable
+from collections.abc import AsyncIterator, Awaitable, Callable
 from dataclasses import dataclass, field
-from typing import Callable, Generic, Optional, Protocol, TypeVar
+from typing import Generic, Protocol, TypeVar
 
 import aiosqlite
 from typing_extensions import Self
@@ -31,7 +31,7 @@ class ResourceManager(Protocol):
 @dataclass
 class SQLiteResourceManager:
     _db: DBWrapper2
-    _active_writer: Optional[aiosqlite.Connection] = field(init=False, default=None)
+    _active_writer: aiosqlite.Connection | None = field(init=False, default=None)
 
     def get_active_writer(self) -> aiosqlite.Connection:
         if self._active_writer is None:
@@ -102,8 +102,8 @@ class ActionScope(Generic[_T_SideEffects, _T_Config]):
     _resource_manager: ResourceManager
     _side_effects_format: type[_T_SideEffects]
     _config: _T_Config  # An object not intended to be mutated during the lifetime of the scope
-    _callback: Optional[Callable[[StateInterface[_T_SideEffects]], Awaitable[None]]] = None
-    _final_side_effects: Optional[_T_SideEffects] = field(init=False, default=None)
+    _callback: Callable[[StateInterface[_T_SideEffects]], Awaitable[None]] | None = None
+    _final_side_effects: _T_SideEffects | None = field(init=False, default=None)
 
     @property
     def side_effects(self) -> _T_SideEffects:
@@ -155,13 +155,13 @@ class ActionScope(Generic[_T_SideEffects, _T_Config]):
 class StateInterface(Generic[_T_SideEffects]):
     side_effects: _T_SideEffects
     _callbacks_allowed: bool
-    _callback: Optional[Callable[[StateInterface[_T_SideEffects]], Awaitable[None]]] = None
+    _callback: Callable[[StateInterface[_T_SideEffects]], Awaitable[None]] | None = None
 
     @property
-    def callback(self) -> Optional[Callable[[StateInterface[_T_SideEffects]], Awaitable[None]]]:
+    def callback(self) -> Callable[[StateInterface[_T_SideEffects]], Awaitable[None]] | None:
         return self._callback
 
-    def set_callback(self, new_callback: Optional[Callable[[StateInterface[_T_SideEffects]], Awaitable[None]]]) -> None:
+    def set_callback(self, new_callback: Callable[[StateInterface[_T_SideEffects]], Awaitable[None]] | None) -> None:
         if not self._callbacks_allowed:
             raise RuntimeError("Callback cannot be edited from inside itself")
 

chia/util/async_pool.py

@@ -7,7 +7,7 @@ import itertools
 import logging
 import traceback
 from collections.abc import AsyncIterator, Iterator
-from typing import Generic, Optional, Protocol, TypeVar, final
+from typing import Generic, Protocol, TypeVar, final
 
 import anyio
 
@@ -49,8 +49,8 @@ class Job(Generic[T]):
     input: T
     started: asyncio.Event = dataclasses.field(default_factory=asyncio.Event)
     done: asyncio.Event = dataclasses.field(default_factory=asyncio.Event)
-    exception: Optional[BaseException] = None
-    task: Optional[asyncio.Task[object]] = None
+    exception: BaseException | None = None
+    task: asyncio.Task[object] | None = None
     cancelled: bool = False
 
 
@@ -59,7 +59,7 @@ class Job(Generic[T]):
 class QueuedAsyncPool(Generic[J, R]):
     name: str
     job_queue: JobQueueProtocol[Job[J]]
-    result_queue: Optional[ResultQueueProtocol[R]]
+    result_queue: ResultQueueProtocol[R] | None
     worker_async_callable: QueuedWorkerCallable[J, R]
 
     @classmethod
@@ -70,7 +70,7 @@ class QueuedAsyncPool(Generic[J, R]):
         job_queue: JobQueueProtocol[Job[J]],
         worker_async_callable: QueuedWorkerCallable[J, R],
         target_worker_count: int,
-        result_queue: Optional[ResultQueueProtocol[R]] = None,
+        result_queue: ResultQueueProtocol[R] | None = None,
         log: logging.Logger = logging.getLogger(__name__),
     ) -> AsyncIterator[QueuedAsyncPool[J, R]]:
         self = cls(

chia/util/bech32m.py

@@ -23,7 +23,6 @@
 from __future__ import annotations
 
 from collections.abc import Iterable
-from typing import Optional
 
 from chia_rs.sized_bytes import bytes32
 
@@ -71,7 +70,7 @@ def bech32_encode(hrp: str, data: list[int]) -> str:
     return hrp + "1" + "".join([CHARSET[d] for d in combined])
 
 
-def bech32_decode(bech: str, max_length: int = 90) -> tuple[Optional[str], Optional[list[int]]]:
+def bech32_decode(bech: str, max_length: int = 90) -> tuple[str | None, list[int] | None]:
     """Validate a Bech32 string, and determine HRP and data."""
     bech = bech.strip()
     if (any(ord(x) < 33 or ord(x) > 126 for x in bech)) or (bech.lower() != bech and bech.upper() != bech):

chia/util/beta_metrics.py

@@ -6,7 +6,7 @@ import platform
 import socket
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import psutil
 
@@ -76,7 +76,7 @@ def log_network_metrics() -> None:
 @dataclass
 class BetaMetricsLogger:
     root_path: Path
-    task: Optional[asyncio.Task[None]] = None
+    task: asyncio.Task[None] | None = None
     stop_task: bool = False
 
     def start_logging(self) -> None:

chia/util/block_cache.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
 from chia_rs.sized_bytes import bytes32
@@ -34,11 +34,11 @@ class BlockCache:
 
     def height_to_block_record(self, height: uint32) -> 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)
 
-    def height_to_hash(self, height: uint32) -> Optional[bytes32]:
+    def height_to_hash(self, height: uint32) -> bytes32 | None:
         if height not in self._height_to_hash:
             return None
         return self._height_to_hash[height]
@@ -52,7 +52,7 @@ class BlockCache:
     def contains_height(self, height: uint32) -> bool:
         return height in self._height_to_hash
 
-    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 prev_block_hash(self, header_hashes: list[bytes32]) -> list[bytes32]:

chia/util/chia_logging.py

@@ -4,7 +4,7 @@ import logging
 import os
 from logging.handlers import SysLogHandler
 from pathlib import Path
-from typing import Any, Optional, cast
+from typing import Any, cast
 
 import colorlog
 from concurrent_log_handler import ConcurrentRotatingFileHandler
@@ -46,7 +46,7 @@ def initialize_logging(
     service_name: str,
     logging_config: dict[str, Any],
     root_path: Path,
-    beta_root_path: Optional[Path] = None,
+    beta_root_path: Path | None = None,
 ) -> None:
     log_backcompat = logging_config.get("log_backcompat", False)
     log_level = logging_config.get("log_level", default_log_level)

chia/util/chia_version.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from re import search
-from typing import Union
 
 from packaging.version import InvalidVersion, Version
 
@@ -26,7 +25,7 @@ def _chia_short_version_from_str(version: str) -> str:
     return version
 
 
-def chia_short_version(version: Union[str, Version] = __version__) -> str:
+def chia_short_version(version: str | Version = __version__) -> str:
     if isinstance(version, Version):
         return _chia_short_version_from_version(version)