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

chia/_tests/util/spend_sim.py

@@ -7,11 +7,12 @@ from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import anyio
 from chia_rs import (
     DONT_VALIDATE_SIGNATURE,
+    CoinRecord,
     CoinSpend,
     ConsensusConstants,
     G2Element,
@@ -34,7 +35,6 @@ from chia.full_node.mempool import Mempool
 from chia.full_node.mempool_manager import MempoolManager
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import INFINITE_COST
-from chia.types.coin_record import CoinRecord
 from chia.types.generator_types import BlockGenerator
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.types.mempool_item import MempoolItem
@@ -58,7 +58,7 @@ and is designed so that you could test with it and then swap in a real rpc clien
 
 @asynccontextmanager
 async def sim_and_client(
-    db_path: Optional[Path] = None, defaults: ConsensusConstants = DEFAULT_CONSTANTS, pass_prefarm: bool = True
+    db_path: Path | None = None, defaults: ConsensusConstants = DEFAULT_CONSTANTS, pass_prefarm: bool = True
 ) -> AsyncIterator[tuple[SpendSim, SimClient]]:
     async with SpendSim.managed(db_path, defaults) as sim:
         client: SimClient = SimClient(sim)
@@ -103,7 +103,7 @@ class CostLogger:
 @streamable
 @dataclass(frozen=True)
 class SimFullBlock(Streamable):
-    transactions_generator: Optional[BlockGenerator]
+    transactions_generator: BlockGenerator | None
     height: uint32  # Note that height is not on a regular FullBlock
 
 
@@ -155,7 +155,7 @@ class SpendSim:
     @classmethod
     @contextlib.asynccontextmanager
     async def managed(
-        cls, db_path: Optional[Path] = None, defaults: ConsensusConstants = DEFAULT_CONSTANTS
+        cls, db_path: Path | None = None, defaults: ConsensusConstants = DEFAULT_CONSTANTS
     ) -> AsyncIterator[Self]:
         self = cls()
         if db_path is None:
@@ -166,44 +166,44 @@ class SpendSim:
         async with DBWrapper2.managed(database=uri, uri=True, reader_count=1, db_version=2) as self.db_wrapper:
             self.coin_store = await CoinStore.create(self.db_wrapper)
             self.hint_store = await HintStore.create(self.db_wrapper)
-            self.mempool_manager = MempoolManager(
-                self.coin_store.get_coin_records, self.coin_store.get_unspent_lineage_info_for_puzzle_hash, defaults
-            )
             self.defaults = defaults
 
-            # Load the next data if there is any
-            async with self.db_wrapper.writer_maybe_transaction() as conn:
-                await conn.execute("CREATE TABLE IF NOT EXISTS block_data(data blob PRIMARY KEY)")
-                cursor = await conn.execute("SELECT * from block_data")
-                row = await cursor.fetchone()
-                await cursor.close()
-                if row is not None:
-                    store_data = SimStore.from_bytes(row[0])
-                    self.timestamp = store_data.timestamp
-                    self.block_height = store_data.block_height
-                    self.block_records = store_data.block_records
-                    self.blocks = store_data.blocks
-                    self.mempool_manager.peak = self.block_records[-1]
-                else:
-                    self.timestamp = uint64(1)
-                    self.block_height = uint32(0)
-                    self.block_records = []
-                    self.blocks = []
-
-            try:
-                yield self
-            finally:
-                with anyio.CancelScope(shield=True):
-                    async with self.db_wrapper.writer_maybe_transaction() as conn:
-                        c = await conn.execute("DELETE FROM block_data")
-                        await c.close()
-                        c = await conn.execute(
-                            "INSERT INTO block_data VALUES(?)",
-                            (bytes(SimStore(self.timestamp, self.block_height, self.block_records, self.blocks)),),
-                        )
-                        await c.close()
-
-    async def new_peak(self, spent_coins_ids: Optional[list[bytes32]]) -> None:
+            async with MempoolManager.managed(
+                self.coin_store.get_coin_records, self.coin_store.get_unspent_lineage_info_for_puzzle_hash, defaults
+            ) as self.mempool_manager:
+                # Load the next data if there is any
+                async with self.db_wrapper.writer_maybe_transaction() as conn:
+                    await conn.execute("CREATE TABLE IF NOT EXISTS block_data(data blob PRIMARY KEY)")
+                    cursor = await conn.execute("SELECT * from block_data")
+                    row = await cursor.fetchone()
+                    await cursor.close()
+                    if row is not None:
+                        store_data = SimStore.from_bytes(row[0])
+                        self.timestamp = store_data.timestamp
+                        self.block_height = store_data.block_height
+                        self.block_records = store_data.block_records
+                        self.blocks = store_data.blocks
+                        self.mempool_manager.peak = self.block_records[-1]
+                    else:
+                        self.timestamp = uint64(1)
+                        self.block_height = uint32(0)
+                        self.block_records = []
+                        self.blocks = []
+
+                try:
+                    yield self
+                finally:
+                    with anyio.CancelScope(shield=True):
+                        async with self.db_wrapper.writer_maybe_transaction() as conn:
+                            c = await conn.execute("DELETE FROM block_data")
+                            await c.close()
+                            c = await conn.execute(
+                                "INSERT INTO block_data VALUES(?)",
+                                (bytes(SimStore(self.timestamp, self.block_height, self.block_records, self.blocks)),),
+                            )
+                            await c.close()
+
+    async def new_peak(self, spent_coins_ids: list[bytes32] | None) -> None:
         await self.mempool_manager.new_peak(self.block_records[-1], spent_coins_ids)
 
     def new_coin_record(self, coin: Coin, coinbase: bool = False) -> CoinRecord:
@@ -229,7 +229,7 @@ class SpendSim:
             coins.add(coin)
         return list(coins)
 
-    async def generate_transaction_generator(self, bundle: Optional[SpendBundle]) -> Optional[BlockGenerator]:
+    async def generate_transaction_generator(self, bundle: SpendBundle | None) -> BlockGenerator | None:
         if bundle is None:
             return None
         return simple_solution_generator(bundle)
@@ -257,7 +257,7 @@ class SpendSim:
             ),
         ]
         # Coin store gets updated
-        generator_bundle: Optional[SpendBundle] = None
+        generator_bundle: SpendBundle | None = None
         tx_additions = []
         tx_removals = []
         spent_coins_ids = None
@@ -295,7 +295,7 @@ class SpendSim:
             tx_removals=spent_coins_ids if spent_coins_ids is not None else [],
         )
         # SimBlockRecord is created
-        generator: Optional[BlockGenerator] = await self.generate_transaction_generator(generator_bundle)
+        generator: BlockGenerator | None = await self.generate_transaction_generator(generator_bundle)
         self.block_records.append(SimBlockRecord.create(included_reward_coins, next_block_height, self.timestamp))
         self.blocks.append(SimFullBlock(generator, next_block_height))
 
@@ -336,7 +336,7 @@ class SimClient:
     def __init__(self, service: SpendSim) -> None:
         self.service = service
 
-    async def push_tx(self, spend_bundle: SpendBundle) -> tuple[MempoolInclusionStatus, Optional[Err]]:
+    async def push_tx(self, spend_bundle: SpendBundle) -> tuple[MempoolInclusionStatus, Err | None]:
         try:
             spend_bundle_id = spend_bundle.name()
             sbc = await self.service.mempool_manager.pre_validate_spendbundle(spend_bundle, spend_bundle_id)
@@ -348,14 +348,14 @@ class SimClient:
         )
         return info.status, info.error
 
-    async def get_coin_record_by_name(self, name: bytes32) -> Optional[CoinRecord]:
+    async def get_coin_record_by_name(self, name: bytes32) -> CoinRecord | None:
         return await self.service.coin_store.get_coin_record(name)
 
     async def get_coin_records_by_names(
         self,
         names: list[bytes32],
-        start_height: Optional[int] = None,
-        end_height: Optional[int] = None,
+        start_height: int | None = None,
+        end_height: int | None = None,
         include_spent_coins: bool = False,
     ) -> list[CoinRecord]:
         kwargs: dict[str, Any] = {"include_spent_coins": include_spent_coins, "names": names}
@@ -368,8 +368,8 @@ class SimClient:
     async def get_coin_records_by_parent_ids(
         self,
         parent_ids: list[bytes32],
-        start_height: Optional[int] = None,
-        end_height: Optional[int] = None,
+        start_height: int | None = None,
+        end_height: int | None = None,
         include_spent_coins: bool = False,
     ) -> list[CoinRecord]:
         kwargs: dict[str, Any] = {"include_spent_coins": include_spent_coins, "parent_ids": parent_ids}
@@ -383,8 +383,8 @@ class SimClient:
         self,
         puzzle_hash: bytes32,
         include_spent_coins: bool = True,
-        start_height: Optional[int] = None,
-        end_height: Optional[int] = None,
+        start_height: int | None = None,
+        end_height: int | None = None,
     ) -> list[CoinRecord]:
         kwargs: dict[str, Any] = {"include_spent_coins": include_spent_coins, "puzzle_hash": puzzle_hash}
         if start_height is not None:
@@ -397,8 +397,8 @@ class SimClient:
         self,
         puzzle_hashes: list[bytes32],
         include_spent_coins: bool = True,
-        start_height: Optional[int] = None,
-        end_height: Optional[int] = None,
+        start_height: int | None = None,
+        end_height: int | None = None,
     ) -> list[CoinRecord]:
         kwargs: dict[str, Any] = {"include_spent_coins": include_spent_coins, "puzzle_hashes": puzzle_hashes}
         if start_height is not None:
@@ -460,7 +460,7 @@ class SimClient:
             spends[item.name] = item
         return spends
 
-    async def get_mempool_item_by_tx_id(self, tx_id: bytes32) -> Optional[dict[str, Any]]:
+    async def get_mempool_item_by_tx_id(self, tx_id: bytes32) -> dict[str, Any] | None:
         item = self.service.mempool_manager.get_mempool_item(tx_id)
         if item is None:
             return None
@@ -471,8 +471,8 @@ class SimClient:
         self,
         hint: bytes32,
         include_spent_coins: bool = True,
-        start_height: Optional[int] = None,
-        end_height: Optional[int] = None,
+        start_height: int | None = None,
+        end_height: int | None = None,
     ) -> list[CoinRecord]:
         """
         Retrieves coins by hint, by default returns unspent coins.

chia/_tests/util/test_async_pool.py

@@ -4,7 +4,6 @@ import asyncio
 import random
 import re
 from dataclasses import dataclass
-from typing import Optional
 
 import anyio
 import pytest
@@ -128,12 +127,12 @@ async def test_worker_exception_logged(caplog: pytest.LogCaptureFixture) -> None
         def __init__(self) -> None:
             super().__init__(expected_message)
 
-    work_queue: asyncio.Queue[Optional[Exception]] = asyncio.Queue()
+    work_queue: asyncio.Queue[Exception | None] = asyncio.Queue()
     result_queue: asyncio.Queue[None] = asyncio.Queue()
 
     async def worker(
         worker_id: int,
-        work_queue: asyncio.Queue[Optional[Exception]] = work_queue,
+        work_queue: asyncio.Queue[Exception | None] = work_queue,
         result_queue: asyncio.Queue[None] = result_queue,
     ) -> None:
         work = await work_queue.get()

chia/_tests/util/test_chia_version.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import pytest
 from packaging.version import Version
 
@@ -46,5 +44,5 @@ def test_chia_short_version() -> None:
         ("something", "something"),
     ],
 )
-def test_chia_short_version_from_str(version: str, result: Optional[str]) -> None:
+def test_chia_short_version_from_str(version: str, result: str | None) -> None:
     assert chia_short_version(version) == result

chia/_tests/util/test_config.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs.sized_ints import uint16
 
@@ -158,8 +158,8 @@ class SetPeerInfoCase(DataCase):
     service_config: dict[str, Any]
     requested_node_type: NodeType
     expected_service_config: dict[str, Any]
-    peer_host: Optional[str] = None
-    peer_port: Optional[int] = None
+    peer_host: str | None = None
+    peer_port: int | None = None
     marks: Marks = ()
 
     @property

chia/_tests/util/test_full_block_utils.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import random
 from collections.abc import Generator, Iterator
-from typing import Optional
 
 import pytest
 from chia_rs import (
@@ -101,6 +100,7 @@ def get_reward_chain_block(height: uint32) -> Generator[RewardChainBlock, None,
                             g2(),  # reward_chain_sp_signature
                             vdf(),  # reward_chain_ip_vdf
                             infused_challenge_chain_ip_vdf,
+                            None,  # header_mmr_root
                             has_transactions,
                         )
 
@@ -135,7 +135,7 @@ def get_foliage() -> Generator[Foliage, None, None]:
                 )
 
 
-def get_foliage_transaction_block() -> Generator[Optional[FoliageTransactionBlock], None, None]:
+def get_foliage_transaction_block() -> Generator[FoliageTransactionBlock | None, None, None]:
     yield None
     timestamp = uint64(1631794488)
     yield FoliageTransactionBlock(
@@ -148,7 +148,7 @@ def get_foliage_transaction_block() -> Generator[Optional[FoliageTransactionBloc
     )
 
 
-def get_transactions_info(height: uint32, foliage_transaction_block: Optional[FoliageTransactionBlock]):
+def get_transactions_info(height: uint32, foliage_transaction_block: FoliageTransactionBlock | None):
     if not foliage_transaction_block:
         yield None
     else:
@@ -255,6 +255,9 @@ def get_full_blocks() -> Iterator[FullBlock]:
 
 
 @pytest.mark.anyio
+@pytest.mark.skip(
+    "Very slow test with limited usefulness: was used to ensure the cheap parser for FullBlock matched the regular one"
+)
 async def test_parser():
     # loop over every combination of Optionals being set and not set
     # along with random values for the FullBlock fields. Ensure

chia/_tests/util/test_limited_semaphore.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-from typing import Optional
 
 import pytest
 
@@ -18,7 +17,7 @@ async def test_stuff() -> None:
     semaphore = LimitedSemaphore.create(active_limit=active_limit, waiting_limit=waiting_limit)
     finish_event = asyncio.Event()
 
-    async def acquire(entered_event: Optional[asyncio.Event] = None) -> None:
+    async def acquire(entered_event: asyncio.Event | None = None) -> None:
         async with semaphore.acquire():
             assert entered_event is not None
             entered_event.set()

chia/_tests/util/test_misc.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import contextlib
 from collections.abc import AsyncIterator, Iterator
-from typing import Optional, TypeVar
+from typing import TypeVar
 
 import aiohttp
 import anyio
@@ -340,7 +340,7 @@ async def test_valued_event_wait_already_set() -> None:
 async def test_valued_event_wait_not_yet_set() -> None:
     valued_event = ValuedEvent[int]()
     value = 37
-    result: Optional[int] = None
+    result: int | None = None
 
     async def wait(valued_event: ValuedEvent[int]) -> None:
         nonlocal result

chia/_tests/util/test_network.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import os
 import sys
 from ipaddress import IPv4Address, IPv6Address
-from typing import Union
 
 import pytest
 
@@ -83,7 +82,7 @@ async def test_resolve6() -> None:
         ("93.184.216.34", IPv4Address),
     ],
 )
-def test_ip_address(address_string: str, expected_inner: type[Union[IPv4Address, IPv6Address]]) -> None:
+def test_ip_address(address_string: str, expected_inner: type[IPv4Address | IPv6Address]) -> None:
     inner = expected_inner(address_string)
     ip = IPAddress.create(address_string)
     # Helpers

chia/_tests/util/test_priority_mutex.py

@@ -7,8 +7,8 @@ import itertools
 import logging
 import random
 import time
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Callable, Optional
 
 import anyio
 import pytest
@@ -119,8 +119,8 @@ class Request:
     # TODO: is the ID unneeded?
     id: str
     priority: MutexPriority
-    acquisition_order: Optional[int] = None
-    release_order: Optional[int] = None
+    acquisition_order: int | None = None
+    release_order: int | None = None
     order_counter: Callable[[], int] = counter.__next__
     # TODO: done may not be needed
     done: bool = False

chia/_tests/util/test_recursive_replace.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import copy
 from dataclasses import dataclass
-from typing import Optional, Union
 
 import pytest
 
@@ -19,7 +18,7 @@ class TestC:
 
     # WARNING: this is just a simple stand in for rust classes and is not a good
     # reference for how such a method should be implemented in python
-    def replace(self, **kwargs: Union[int, str, Optional[TestA]]) -> TestC:
+    def replace(self, **kwargs: int | str | TestA | None) -> TestC:
         ret = TestC(copy.deepcopy(self.a), copy.deepcopy(self.b))
         for key, value in kwargs.items():
             if key == "a":
@@ -36,22 +35,22 @@ class TestA:
     a: int
     b: str
     c: list[int]
-    d: Optional[TestC]
+    d: TestC | None
 
 
 class TestB:
     a: int
     b: str
-    c: Optional[TestA]
+    c: TestA | None
 
-    def __init__(self, a: int, b: str, c: Optional[TestA]):
+    def __init__(self, a: int, b: str, c: TestA | None):
         self.a = a
         self.b = b
         self.c = c
 
     # WARNING: this is just a simple stand in for rust classes and is not a good
     # reference for how such a method should be implemented in python
-    def replace(self, **kwargs: Union[int, str, Optional[TestA]]) -> TestB:
+    def replace(self, **kwargs: int | str | TestA | None) -> TestB:
         ret = TestB(copy.deepcopy(self.a), copy.deepcopy(self.b), copy.deepcopy(self.c))
         for key, value in kwargs.items():
             if key == "a":  # pragma: no cover

chia/_tests/util/test_replace_str_to_bytes.py

@@ -27,8 +27,7 @@ test_constants = ConsensusConstants(
     NUMBER_ZERO_BITS_PLOT_FILTER_V2=uint8(9),
     MIN_PLOT_SIZE_V1=uint8(32),
     MAX_PLOT_SIZE_V1=uint8(50),
-    MIN_PLOT_SIZE_V2=uint8(28),
-    MAX_PLOT_SIZE_V2=uint8(32),
+    PLOT_SIZE_V2=uint8(18),
     SUB_SLOT_TIME_TARGET=uint16(600),
     NUM_SP_INTERVALS_EXTRA=uint8(3),
     MAX_FUTURE_TIME2=uint32(2 * 60),
@@ -56,21 +55,21 @@ test_constants = ConsensusConstants(
     BLOCKS_CACHE_SIZE=uint32(4608 + (128 * 4)),
     WEIGHT_PROOF_RECENT_BLOCKS=uint32(1000),
     MAX_BLOCK_COUNT_PER_REQUESTS=uint32(32),
-    MAX_GENERATOR_SIZE=uint32(1000000),
     MAX_GENERATOR_REF_LIST_SIZE=uint32(512),
     POOL_SUB_SLOT_ITERS=uint64(37600000000),
     HARD_FORK_HEIGHT=uint32(5496000),
     HARD_FORK2_HEIGHT=uint32(0xFFFFFFFF),
-    PLOT_V1_PHASE_OUT=uint32(1179648),
+    SOFT_FORK8_HEIGHT=uint32(8655000),
+    PLOT_V1_PHASE_OUT_EPOCH_BITS=uint8(8),
     PLOT_FILTER_128_HEIGHT=uint32(10542000),
     PLOT_FILTER_64_HEIGHT=uint32(15592000),
     PLOT_FILTER_32_HEIGHT=uint32(20643000),
-    PLOT_STRENGTH_INITIAL=uint8(2),
-    PLOT_STRENGTH_4_HEIGHT=uint32(0xFFFFFFFF),
-    PLOT_STRENGTH_5_HEIGHT=uint32(0xFFFFFFFF),
-    PLOT_STRENGTH_6_HEIGHT=uint32(0xFFFFFFFF),
-    PLOT_STRENGTH_7_HEIGHT=uint32(0xFFFFFFFF),
-    PLOT_STRENGTH_8_HEIGHT=uint32(0xFFFFFFFF),
+    MIN_PLOT_STRENGTH=uint8(2),
+    MAX_PLOT_STRENGTH=uint8(32),
+    QUALITY_PROOF_SCAN_FILTER=uint8(5),
+    PLOT_FILTER_V2_FIRST_ADJUSTMENT_HEIGHT=uint32(0xFFFFFFFA),
+    PLOT_FILTER_V2_SECOND_ADJUSTMENT_HEIGHT=uint32(0xFFFFFFFB),
+    PLOT_FILTER_V2_THIRD_ADJUSTMENT_HEIGHT=uint32(0xFFFFFFFC),
 )
 
 

chia/_tests/util/test_testnet_overrides.py

@@ -8,19 +8,19 @@ from chia.consensus.default_constants import update_testnet_overrides
 def test_testnet11() -> None:
     overrides: dict[str, Any] = {}
     update_testnet_overrides("testnet11", overrides)
-    assert overrides == {"MIN_PLOT_SIZE_V2": 18}
+    assert overrides == {"PLOT_SIZE_V2": 28, "SOFT_FORK8_HEIGHT": 3680000}
 
 
 def test_min_plot_size() -> None:
     overrides: dict[str, Any] = {"MIN_PLOT_SIZE": 18}
     update_testnet_overrides("testnet11", overrides)
-    assert overrides == {"MIN_PLOT_SIZE_V1": 18, "MIN_PLOT_SIZE_V2": 18}
+    assert overrides == {"MIN_PLOT_SIZE_V1": 18, "PLOT_SIZE_V2": 28, "SOFT_FORK8_HEIGHT": 3680000}
 
 
 def test_max_plot_size() -> None:
     overrides: dict[str, Any] = {"MAX_PLOT_SIZE": 32}
     update_testnet_overrides("testnet11", overrides)
-    assert overrides == {"MAX_PLOT_SIZE_V1": 32, "MIN_PLOT_SIZE_V2": 18}
+    assert overrides == {"MAX_PLOT_SIZE_V1": 32, "PLOT_SIZE_V2": 28, "SOFT_FORK8_HEIGHT": 3680000}
 
 
 def test_mainnet() -> None:

chia/_tests/util/time_out_assert.py

@@ -6,10 +6,10 @@ import json
 import logging
 import pathlib
 import time
-from collections.abc import Awaitable, Iterable
+from collections.abc import Awaitable, Callable, Iterable
 from inspect import getframeinfo, stack
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Protocol, TypeVar, cast, final
+from typing import TYPE_CHECKING, Any, ClassVar, Protocol, TypeVar, cast, final
 
 from typing_extensions import Self
 

chia/_tests/wallet/cat_wallet/test_cat_lifecycle.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import pytest
 from chia_rs import AugSchemeMPL, G2Element, PrivateKey
 from chia_rs.sized_ints import uint64
@@ -38,13 +36,13 @@ async def do_spend(
     coins: list[Coin],
     lineage_proofs: list[LineageProof],
     inner_solutions: list[Program],
-    expected_result: tuple[MempoolInclusionStatus, Optional[Err]],
+    expected_result: tuple[MempoolInclusionStatus, Err | None],
     reveal_limitations_program: bool = True,
     signatures: list[G2Element] = [],
-    extra_deltas: Optional[list[int]] = None,
+    extra_deltas: list[int] | None = None,
     additional_spends: list[WalletSpendBundle] = [],
-    limitations_solutions: Optional[list[Program]] = None,
-    cost_logger: Optional[CostLogger] = None,
+    limitations_solutions: list[Program] | None = None,
+    cost_logger: CostLogger | None = None,
     cost_log_msg: str = "",
 ) -> int:
     if limitations_solutions is None:

chia/_tests/wallet/cat_wallet/test_cat_outer_puzzle.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import pytest
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
@@ -22,12 +20,12 @@ def test_cat_outer_puzzle() -> None:
     cat_puzzle: Program = construct_cat_puzzle(CAT_MOD, tail, ACS)
     double_cat_puzzle: Program = construct_cat_puzzle(CAT_MOD, tail, cat_puzzle)
     uncurried_cat_puzzle = uncurry_puzzle(double_cat_puzzle)
-    cat_driver: Optional[PuzzleInfo] = match_puzzle(uncurried_cat_puzzle)
+    cat_driver: PuzzleInfo | None = match_puzzle(uncurried_cat_puzzle)
 
     assert cat_driver is not None
     assert cat_driver.type() == "CAT"
     assert cat_driver["tail"] == tail
-    inside_cat_driver: Optional[PuzzleInfo] = cat_driver.also()
+    inside_cat_driver: PuzzleInfo | None = cat_driver.also()
     assert inside_cat_driver is not None
     assert inside_cat_driver.type() == "CAT"
     assert inside_cat_driver["tail"] == tail