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

chia/_tests/wallet/sync/test_wallet_sync.py

@@ -4,9 +4,8 @@ import asyncio
 import contextlib
 import functools
 import logging
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
-from typing import Callable, Optional
 from unittest.mock import MagicMock
 
 import pytest
@@ -111,7 +110,9 @@ async def test_request_block_headers(
     assert [x.transactions_filter for x in bh] == [b"\x00"] * 6
 
     num_blocks = 20
-    new_blocks = bt.get_consecutive_blocks(num_blocks, block_list_input=default_400_blocks, pool_reward_puzzle_hash=ph)
+    new_blocks = bt.get_consecutive_blocks(
+        num_blocks, block_list_input=default_400_blocks, farmer_reward_puzzle_hash=ph
+    )
     await add_blocks_in_batches(new_blocks, full_node_api.full_node)
     msg = await full_node_api.request_block_headers(wallet_protocol.RequestBlockHeaders(uint32(110), uint32(115), True))
     assert msg is not None
@@ -626,7 +627,7 @@ async def test_request_additions_errors(simulator_and_wallet: OldSimulatorsAndWa
 
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
-    last_block: Optional[BlockRecord] = full_node_api.full_node.blockchain.get_peak()
+    last_block: BlockRecord | None = full_node_api.full_node.blockchain.get_peak()
     assert last_block is not None
 
     # Invalid height
@@ -1431,10 +1432,10 @@ async def test_retry_store(
 
     def flaky_get_coin_state(
         flakiness_info: FlakinessInfo,
-        func: Callable[[list[bytes32], WSChiaConnection, Optional[uint32]], Awaitable[list[CoinState]]],
-    ) -> Callable[[list[bytes32], WSChiaConnection, Optional[uint32]], Awaitable[list[CoinState]]]:
+        func: Callable[[list[bytes32], WSChiaConnection, uint32 | None], Awaitable[list[CoinState]]],
+    ) -> Callable[[list[bytes32], WSChiaConnection, uint32 | None], Awaitable[list[CoinState]]]:
         async def new_func(
-            coin_names: list[bytes32], peer: WSChiaConnection, fork_height: Optional[uint32] = None
+            coin_names: list[bytes32], peer: WSChiaConnection, fork_height: uint32 | None = None
         ) -> list[CoinState]:
             if flakiness_info.coin_state_flaky:
                 flakiness_info.coin_state_flaky = False
@@ -1447,10 +1448,10 @@ async def test_retry_store(
     request_puzzle_solution_failure_tested = False
 
     def flaky_request_puzzle_solution(
-        func: Callable[[FullNodeAPI, wallet_protocol.RequestPuzzleSolution], Awaitable[Optional[Message]]],
-    ) -> Callable[[FullNodeAPI, wallet_protocol.RequestPuzzleSolution], Awaitable[Optional[Message]]]:
+        func: Callable[[FullNodeAPI, wallet_protocol.RequestPuzzleSolution], Awaitable[Message | None]],
+    ) -> Callable[[FullNodeAPI, wallet_protocol.RequestPuzzleSolution], Awaitable[Message | None]]:
         @functools.wraps(func)
-        async def new_func(self: FullNodeAPI, request: wallet_protocol.RequestPuzzleSolution) -> Optional[Message]:
+        async def new_func(self: FullNodeAPI, request: wallet_protocol.RequestPuzzleSolution) -> Message | None:
             nonlocal request_puzzle_solution_failure_tested
             if not request_puzzle_solution_failure_tested:
                 request_puzzle_solution_failure_tested = True
@@ -1464,10 +1465,10 @@ async def test_retry_store(
 
     def flaky_fetch_children(
         flakiness_info: FlakinessInfo,
-        func: Callable[[bytes32, WSChiaConnection, Optional[uint32]], Awaitable[list[CoinState]]],
-    ) -> Callable[[bytes32, WSChiaConnection, Optional[uint32]], Awaitable[list[CoinState]]]:
+        func: Callable[[bytes32, WSChiaConnection, uint32 | None], Awaitable[list[CoinState]]],
+    ) -> Callable[[bytes32, WSChiaConnection, uint32 | None], Awaitable[list[CoinState]]]:
         async def new_func(
-            coin_name: bytes32, peer: WSChiaConnection, fork_height: Optional[uint32] = None
+            coin_name: bytes32, peer: WSChiaConnection, fork_height: uint32 | None = None
         ) -> list[CoinState]:
             if flakiness_info.fetch_children_flaky:
                 flakiness_info.fetch_children_flaky = False
@@ -1490,9 +1491,9 @@ async def test_retry_store(
         return new_func
 
     def flaky_info_for_puzhash(
-        flakiness_info: FlakinessInfo, func: Callable[[bytes32], Awaitable[Optional[WalletIdentifier]]]
-    ) -> Callable[[bytes32], Awaitable[Optional[WalletIdentifier]]]:
-        async def new_func(puzzle_hash: bytes32) -> Optional[WalletIdentifier]:
+        flakiness_info: FlakinessInfo, func: Callable[[bytes32], Awaitable[WalletIdentifier | None]]
+    ) -> Callable[[bytes32], Awaitable[WalletIdentifier | None]]:
+        async def new_func(puzzle_hash: bytes32) -> WalletIdentifier | None:
             if flakiness_info.db_flaky:
                 flakiness_info.db_flaky = False
                 raise AIOSqliteError
@@ -1605,7 +1606,7 @@ async def test_bad_peak_mismatch(
         full_node_protocol.RespondProofOfWeight(wp, wp.recent_chain_data[-1].header_hash),
     )
     with monkeypatch.context() as m:
-        f: asyncio.Future[Optional[Message]] = asyncio.Future()
+        f: asyncio.Future[Message | None] = asyncio.Future()
         f.set_result(wp_msg)
         m.setattr(full_node_api, "request_proof_of_weight", MagicMock(return_value=f))
 
@@ -1614,7 +1615,7 @@ async def test_bad_peak_mismatch(
             ProtocolMessageTypes.respond_block_header,
             wallet_protocol.RespondBlockHeader(wp.recent_chain_data[-1]),
         )
-        f2: asyncio.Future[Optional[Message]] = asyncio.Future()
+        f2: asyncio.Future[Message | None] = asyncio.Future()
         f2.set_result(header_block_msg)
         m.setattr(full_node_api, "request_block_header", MagicMock(return_value=f2))
 
@@ -1638,7 +1639,7 @@ async def test_bad_peak_mismatch(
 async def test_long_sync_untrusted_break(
     setup_two_nodes_and_wallet: OldSimulatorsAndWallets,
     default_1000_blocks: list[FullBlock],
-    default_400_blocks: list[FullBlock],
+    default_1500_blocks: list[FullBlock],
     self_hostname: str,
     caplog: pytest.LogCaptureFixture,
     use_delta_sync: bool,
@@ -1649,27 +1650,16 @@ async def test_long_sync_untrusted_break(
     wallet_node.config["trusted_peers"] = {trusted_full_node_server.node_id.hex(): None}
     wallet_node.config["use_delta_sync"] = use_delta_sync
 
-    sync_canceled = False
-
     async def register_for_ph_updates(
         self: object,
         request: wallet_protocol.RegisterForPhUpdates,
         peer: WSChiaConnection,
     ) -> None:
-        nonlocal sync_canceled
-        # Just sleep a long time here to simulate a long-running untrusted sync
-        try:
-            await asyncio.sleep(120)
-        except Exception:
-            sync_canceled = True
-            raise
+        await peer.wait_until_closed()
 
     def wallet_syncing() -> bool:
         return wallet_node.wallet_state_manager.sync_mode
 
-    def check_sync_canceled() -> bool:
-        return sync_canceled
-
     def synced_to_trusted() -> bool:
         return trusted_full_node_server.node_id in wallet_node.synced_peers
 
@@ -1678,26 +1668,32 @@ async def test_long_sync_untrusted_break(
         untrusted_peers = sum(not wallet_node.is_trusted(peer) for peer in wallet_server.all_connections.values())
         return trusted_peers == 1 and untrusted_peers == 0
 
-    await add_blocks_in_batches(default_400_blocks, trusted_full_node_api.full_node)
+    await add_blocks_in_batches(default_1500_blocks[:600], trusted_full_node_api.full_node)
+    await add_blocks_in_batches(default_1000_blocks[:600], untrusted_full_node_api.full_node)
 
-    await add_blocks_in_batches(default_1000_blocks[:400], untrusted_full_node_api.full_node)
-
-    with patch_request_handler(api=untrusted_full_node_api, handler=register_for_ph_updates):
+    with (
+        patch_request_handler(api=untrusted_full_node_api, handler=register_for_ph_updates),
+        caplog.at_level(logging.INFO),
+    ):
         # Connect to the untrusted peer and wait until the long sync started
-        await wallet_server.start_client(PeerInfo(self_hostname, untrusted_full_node_server.get_port()), None)
+        assert await wallet_server.start_client(PeerInfo(self_hostname, untrusted_full_node_server.get_port()), None)
+        untrusted_conn = wallet_server.all_connections.get(untrusted_full_node_server.node_id)
+        assert untrusted_conn is not None
         await time_out_assert(30, wallet_syncing)
-        with caplog.at_level(logging.INFO):
-            # Connect to the trusted peer and make sure the running untrusted long sync gets interrupted via disconnect
-            await wallet_server.start_client(PeerInfo(self_hostname, trusted_full_node_server.get_port()), None)
-            await time_out_assert(600, wallet_height_at_least, True, wallet_node, len(default_400_blocks) - 1)
-            assert time_out_assert(10, synced_to_trusted)
-            assert untrusted_full_node_server.node_id not in wallet_node.synced_peers
-            assert "Connected to a synced trusted peer, disconnecting from all untrusted nodes." in caplog.text
-
-        # Make sure the sync was interrupted
-        assert time_out_assert(30, check_sync_canceled)
+
+        # Connect to the trusted peer and make sure the running untrusted long sync gets interrupted via disconnect
+        assert await wallet_server.start_client(PeerInfo(self_hostname, trusted_full_node_server.get_port()), None)
+        await time_out_assert(600, wallet_height_at_least, True, wallet_node, 599)
+        await time_out_assert(10, synced_to_trusted)
+        assert untrusted_full_node_server.node_id not in wallet_node.synced_peers
+
+        assert "Connected to a synced trusted peer, disconnecting from all untrusted nodes." in caplog.text
+        assert (
+            f"Connection closed: {untrusted_conn.peer_info.host}, node id: {untrusted_full_node_server.node_id}"
+            in caplog.text
+        )
         # And that we only have a trusted peer left
-        assert time_out_assert(30, only_trusted_peer)
+        await time_out_assert(30, only_trusted_peer)
 
 
 @pytest.mark.anyio

chia/_tests/wallet/test_clvm_streamable.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Optional
 
 import pytest
 from chia_rs.sized_bytes import bytes32
@@ -77,14 +76,14 @@ def test_nested_serialization() -> None:
 @streamable
 @dataclasses.dataclass(frozen=True)
 class Compound(Streamable):
-    optional: Optional[BasicCLVMStreamable]
+    optional: BasicCLVMStreamable | None
     list: list[BasicCLVMStreamable]
 
 
 @clvm_streamable
 @dataclasses.dataclass(frozen=True)
 class CompoundCLVM(Streamable):
-    optional: Optional[BasicCLVMStreamable]
+    optional: BasicCLVMStreamable | None
     list: list[BasicCLVMStreamable]
 
 

chia/_tests/wallet/test_coin_management.py

@@ -66,8 +66,8 @@ def test_list_parsing(id: ValueAndArgs, show_unconfirmed: ValueAndArgs, paginate
         {
             "num_environments": 1,
             "blocks_needed": [3],  # 6 coins to test pagination
-            "reuse_puzhash": True,  # irrelevent
-            "trusted": True,  # irrelevent
+            "reuse_puzhash": True,  # irrelevant
+            "trusted": True,  # irrelevant
         }
     ],
     indirect=True,

chia/_tests/wallet/test_conditions.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Optional, Union
+from typing import Any
 
 import pytest
 from chia_rs.sized_bytes import bytes32
@@ -214,11 +214,9 @@ def test_unknown_condition() -> None:
     ],
 )
 def test_announcement_inversions(
-    drivers: Union[
-        tuple[type[CreateCoinAnnouncement], type[AssertCoinAnnouncement]],
-        tuple[type[CreatePuzzleAnnouncement], type[AssertPuzzleAnnouncement]],
-        tuple[type[CreateAnnouncement], type[AssertAnnouncement]],
-    ],
+    drivers: tuple[type[CreateCoinAnnouncement], type[AssertCoinAnnouncement]]
+    | tuple[type[CreatePuzzleAnnouncement], type[AssertPuzzleAnnouncement]]
+    | tuple[type[CreateAnnouncement], type[AssertAnnouncement]],
 ) -> None:
     create_driver, assert_driver = drivers
     # mypy is not smart enough to understand that this `if` narrows down the potential types it could be
@@ -250,7 +248,7 @@ def test_announcement_inversions(
 class TimelockInfo:
     drivers: list[Condition]
     parsed_info: ConditionValidTimes
-    conditions_after: Optional[list[Condition]] = None
+    conditions_after: list[Condition] | None = None
 
 
 @pytest.mark.parametrize(
@@ -285,9 +283,7 @@ class TimelockInfo:
     ],
 )
 def test_timelock_parsing(timelock_info: TimelockInfo) -> None:
-    assert timelock_info.parsed_info == parse_timelock_info(
-        [UnknownCondition(Program.to(None), []), *timelock_info.drivers]
-    )
+    assert timelock_info.parsed_info == parse_timelock_info([UnknownCondition(Program.NIL, []), *timelock_info.drivers])
     assert timelock_info.parsed_info.to_conditions() == (
         timelock_info.conditions_after if timelock_info.conditions_after is not None else timelock_info.drivers
     )
@@ -349,47 +345,45 @@ def test_timelock_parsing(timelock_info: TimelockInfo) -> None:
 )
 def test_invalid_condition(
     cond: type[
-        Union[
-            AggSigParent,
-            AggSigPuzzle,
-            AggSigAmount,
-            AggSigPuzzleAmount,
-            AggSigParentAmount,
-            AggSigParentPuzzle,
-            AggSigUnsafe,
-            AggSigMe,
-            CreateCoin,
-            ReserveFee,
-            AssertCoinAnnouncement,
-            CreateCoinAnnouncement,
-            AssertPuzzleAnnouncement,
-            CreatePuzzleAnnouncement,
-            AssertConcurrentSpend,
-            AssertConcurrentPuzzle,
-            AssertMyCoinID,
-            AssertMyParentID,
-            AssertMyPuzzleHash,
-            AssertMyAmount,
-            AssertMyBirthSeconds,
-            AssertMyBirthHeight,
-            AssertSecondsRelative,
-            AssertSecondsAbsolute,
-            AssertHeightRelative,
-            AssertHeightAbsolute,
-            AssertBeforeSecondsRelative,
-            AssertBeforeSecondsAbsolute,
-            AssertBeforeHeightRelative,
-            AssertBeforeHeightAbsolute,
-            Softfork,
-            Remark,
-            UnknownCondition,
-            AggSig,
-            CreateAnnouncement,
-            AssertAnnouncement,
-            Timelock,
-            SendMessage,
-            ReceiveMessage,
-        ]
+        AggSigParent
+        | AggSigPuzzle
+        | AggSigAmount
+        | AggSigPuzzleAmount
+        | AggSigParentAmount
+        | AggSigParentPuzzle
+        | AggSigUnsafe
+        | AggSigMe
+        | CreateCoin
+        | ReserveFee
+        | AssertCoinAnnouncement
+        | CreateCoinAnnouncement
+        | AssertPuzzleAnnouncement
+        | CreatePuzzleAnnouncement
+        | AssertConcurrentSpend
+        | AssertConcurrentPuzzle
+        | AssertMyCoinID
+        | AssertMyParentID
+        | AssertMyPuzzleHash
+        | AssertMyAmount
+        | AssertMyBirthSeconds
+        | AssertMyBirthHeight
+        | AssertSecondsRelative
+        | AssertSecondsAbsolute
+        | AssertHeightRelative
+        | AssertHeightAbsolute
+        | AssertBeforeSecondsRelative
+        | AssertBeforeSecondsAbsolute
+        | AssertBeforeHeightRelative
+        | AssertBeforeHeightAbsolute
+        | Softfork
+        | Remark
+        | UnknownCondition
+        | AggSig
+        | CreateAnnouncement
+        | AssertAnnouncement
+        | Timelock
+        | SendMessage
+        | ReceiveMessage
     ],
     prg: bytes,
 ) -> None:

chia/_tests/wallet/test_debug_spend_bundle.py

@@ -50,7 +50,7 @@ def test_debug_spend_bundle(capsys: pytest.CaptureFixture[str]) -> None:
                 make_spend(
                     coin_bad_reveal,
                     ACS,
-                    Program.to(None),
+                    Program.NIL,
                 ),
                 make_spend(
                     coin,
@@ -60,7 +60,7 @@ def test_debug_spend_bundle(capsys: pytest.CaptureFixture[str]) -> None:
                 make_spend(
                     child_coin,
                     ACS,
-                    Program.to(None),
+                    Program.NIL,
                 ),
             ],
             sig,

chia/_tests/wallet/test_new_wallet_protocol.py

@@ -5,10 +5,9 @@ from collections import OrderedDict
 from collections.abc import AsyncGenerator
 from dataclasses import dataclass
 from random import Random
-from typing import Optional
 
 import pytest
-from chia_rs import AugSchemeMPL, Coin, CoinSpend, CoinState, Program, SpendBundle
+from chia_rs import AugSchemeMPL, Coin, CoinRecord, CoinSpend, CoinState, Program, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64
 
@@ -26,7 +25,6 @@ from chia.simulator import simulator_protocol
 from chia.simulator.block_tools import BlockTools
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.start_simulator import SimulatorFullNodeService
-from chia.types.coin_record import CoinRecord
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.util.hash import std_hash
 from chia.wallet.wallet_service import WalletService
@@ -621,14 +619,14 @@ async def test_request_puzzle_state_limit(one_node: OneNode, self_hostname: str)
 class PuzzleStateData:
     coin_states: list[CoinState]
     end_of_batch: bool
-    previous_height: Optional[uint32]
+    previous_height: uint32 | None
     header_hash: bytes32
 
 
 async def sync_puzzle_hashes(
     puzzle_hashes: list[bytes32],
     *,
-    initial_previous_height: Optional[uint32],
+    initial_previous_height: uint32 | None,
     initial_header_hash: bytes32,
     filters: wallet_protocol.CoinStateFilters,
     subscribe_when_finished: bool = False,
@@ -893,7 +891,7 @@ async def subscribe_puzzle(
     assert len(response.coin_states) == existing_coin_states
 
 
-async def spend_coin(simulator: FullNodeSimulator, coin: Coin, solution: Optional[Program] = None) -> bytes32:
+async def spend_coin(simulator: FullNodeSimulator, coin: Coin, solution: Program | None = None) -> bytes32:
     bundle = SpendBundle(
         [CoinSpend(coin, IDENTITY_PUZZLE, Program.to([]) if solution is None else solution)], AugSchemeMPL.aggregate([])
     )

chia/_tests/wallet/test_notifications.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import random
 import tempfile
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import pytest
 from chia_rs.sized_bytes import bytes32
@@ -109,8 +109,8 @@ async def test_notifications(
 
     notification_manager_2.potentially_add_new_notification = track_coin_state
 
-    allow_larger_height: Optional[int] = None
-    allow_height: Optional[int] = None
+    allow_larger_height: int | None = None
+    allow_height: int | None = None
 
     for case in ("block all", "block too low", "allow", "allow_larger", "block_too_large"):
         msg: bytes = bytes(case, "utf8")
@@ -165,34 +165,34 @@ async def test_notifications(
     assert allow_larger_height is not None
     assert allow_height is not None
 
-    notifications = await notification_manager_2.notification_store.get_all_notifications(pagination=(0, 2))
+    notifications = await notification_manager_2.notification_store.get_notifications(pagination=(0, 2))
     assert len(notifications) == 2
     assert notifications[0].message == b"allow_larger"
     assert notifications[0].height == allow_larger_height
-    notifications = await notification_manager_2.notification_store.get_all_notifications(pagination=(1, None))
+    notifications = await notification_manager_2.notification_store.get_notifications(pagination=(1, None))
     assert len(notifications) == 1
     assert notifications[0].message == b"allow"
     assert notifications[0].height == allow_height
-    notifications = await notification_manager_2.notification_store.get_all_notifications(pagination=(0, 1))
+    notifications = await notification_manager_2.notification_store.get_notifications(pagination=(0, 1))
     assert len(notifications) == 1
     assert notifications[0].message == b"allow_larger"
-    notifications = await notification_manager_2.notification_store.get_all_notifications(pagination=(None, 1))
+    notifications = await notification_manager_2.notification_store.get_notifications(pagination=(None, 1))
     assert len(notifications) == 1
     assert notifications[0].message == b"allow_larger"
     assert (
-        await notification_manager_2.notification_store.get_notifications([n.id for n in notifications])
+        await notification_manager_2.notification_store.get_notifications(coin_ids=[n.id for n in notifications])
         == notifications
     )
 
-    sent_notifications = await notification_manager_1.notification_store.get_all_notifications()
+    sent_notifications = await notification_manager_1.notification_store.get_notifications()
     assert len(sent_notifications) == 0
 
-    await notification_manager_2.notification_store.delete_all_notifications()
-    assert len(await notification_manager_2.notification_store.get_all_notifications()) == 0
+    await notification_manager_2.notification_store.delete_notifications()
+    assert len(await notification_manager_2.notification_store.get_notifications()) == 0
     await notification_manager_2.notification_store.add_notification(notifications[0])
-    await notification_manager_2.notification_store.delete_notifications([n.id for n in notifications])
-    assert len(await notification_manager_2.notification_store.get_all_notifications()) == 0
+    await notification_manager_2.notification_store.delete_notifications(coin_ids=[n.id for n in notifications])
+    assert len(await notification_manager_2.notification_store.get_notifications()) == 0
 
     assert not await func(*notification_manager_2.most_recent_args)
-    await notification_manager_2.notification_store.delete_all_notifications()
+    await notification_manager_2.notification_store.delete_notifications()
     assert not await func(*notification_manager_2.most_recent_args)

chia/_tests/wallet/test_signer_protocol.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Optional
 
 import click
 import pytest
@@ -135,7 +134,7 @@ async def test_p2dohp_wallet_signer_protocol(wallet_environments: WalletTestFram
     async with wallet.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=False) as action_scope:
         [coin] = await wallet.select_coins(uint64(0), action_scope)
     puzzle: Program = await wallet.puzzle_for_puzzle_hash(coin.puzzle_hash)
-    delegated_puzzle: Program = Program.to(None)
+    delegated_puzzle: Program = Program.NIL
     delegated_puzzle_hash: bytes32 = delegated_puzzle.get_tree_hash()
     solution: Program = Program.to([None, None, None])
 
@@ -145,9 +144,9 @@ async def test_p2dohp_wallet_signer_protocol(wallet_environments: WalletTestFram
         solution,
     )
 
-    derivation_record: Optional[
-        DerivationRecord
-    ] = await wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(coin.puzzle_hash)
+    derivation_record: (
+        DerivationRecord | None
+    ) = await wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(coin.puzzle_hash)
     assert derivation_record is not None
     pubkey: G1Element = derivation_record.pubkey
     atom = puzzle.uncurry()[1].at("f").atom
@@ -687,6 +686,7 @@ async def test_signer_commands(wallet_environments: WalletTestFramework) -> None
         )
 
 
+@pytest.mark.filterwarnings("ignore:The parameter .* is used more than once:UserWarning")
 def test_signer_command_default_parsing() -> None:
     check_click_parsing(
         GatherSigningInfoCMD(

chia/_tests/wallet/test_singleton_lifecycle_fast.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any, Callable, Optional, TypeVar, cast, get_args, get_origin
+from typing import Any, TypeVar, cast, get_args, get_origin
 
 from chia_rs import CoinSpend, G1Element, G2Element
 from chia_rs.sized_bytes import bytes32
@@ -78,7 +79,7 @@ class PuzzleDB:
     def add_puzzle(self, puzzle: Program) -> None:
         self._db[puzzle.get_tree_hash()] = Program.from_bytes(bytes(puzzle))
 
-    def puzzle_for_hash(self, puzzle_hash: bytes32) -> Optional[Program]:
+    def puzzle_for_hash(self, puzzle_hash: bytes32) -> Program | None:
         return self._db.get(puzzle_hash)
 
 
@@ -237,7 +238,7 @@ class SingletonWallet:
     current_state: Coin
     lineage_proof: Program
 
-    def inner_puzzle(self, puzzle_db: PuzzleDB) -> Optional[Program]:
+    def inner_puzzle(self, puzzle_db: PuzzleDB) -> Program | None:
         puzzle = puzzle_db.puzzle_for_hash(self.current_state.puzzle_hash)
         if puzzle is None:
             return None

chia/_tests/wallet/test_transaction_store.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import dataclasses
 import random
-from typing import Any, Optional
+from typing import Any
 
 import pytest
 from chia_rs.sized_bytes import bytes32
@@ -31,24 +31,24 @@ coin_2 = Coin(bytes32.random(module_seeded_random), bytes32.random(module_seeded
 coin_3 = Coin(bytes32.random(module_seeded_random), bytes32.random(module_seeded_random), uint64(12312 - 1234))
 
 tr1 = TransactionRecord(
-    uint32(0),  # confirmed height
-    uint64(1000),  # created_at_time
-    bytes32(bytes32.zeros),  # to_puzzle_hash
-    uint64(1234),  # amount
-    uint64(12),  # fee_amount
-    False,  # confirmed
-    uint32(0),  # sent
-    None,  # Optional[SpendBundle] spend_bundle
-    [coin_2, coin_3],  # additions
-    [coin_1],  # removals
-    uint32(1),  # wallet_id
-    [],  # list[tuple[str, uint8, Optional[str]]] sent_to
-    bytes32(bytes32.random(module_seeded_random)),  # trade_id
-    uint32(TransactionType.OUTGOING_TX),  # type
-    bytes32(bytes32.random(module_seeded_random)),  # name
-    {},  # memos
-    ConditionValidTimes(),
-    encode_puzzle_hash(bytes32(bytes32.zeros), "txch"),
+    confirmed_at_height=uint32(0),
+    created_at_time=uint64(1000),
+    to_puzzle_hash=bytes32(bytes32.zeros),
+    to_address=encode_puzzle_hash(bytes32(bytes32.zeros), "txch"),
+    amount=uint64(1234),
+    fee_amount=uint64(12),
+    confirmed=False,
+    sent=uint32(0),
+    spend_bundle=None,
+    additions=[coin_2, coin_3],
+    removals=[coin_1],
+    wallet_id=uint32(1),
+    sent_to=[],
+    trade_id=bytes32(bytes32.random(module_seeded_random)),
+    type=uint32(TransactionType.OUTGOING_TX),
+    name=bytes32(bytes32.random(module_seeded_random)),
+    memos={},
+    valid_times=ConditionValidTimes(),
 )
 
 MINIMUM_CONFIG = {
@@ -811,7 +811,7 @@ async def test_get_not_sent(seeded_random: random.Random) -> None:
 
 @pytest.mark.anyio
 async def test_transaction_record_is_valid() -> None:
-    invalid_attempts: list[tuple[str, uint8, Optional[str]]] = []
+    invalid_attempts: list[tuple[str, uint8, str | None]] = []
     # The tx should be valid as long as we don't have minimum_send_attempts failed attempts
     while len(invalid_attempts) < minimum_send_attempts:
         assert dataclasses.replace(tr1, sent_to=invalid_attempts).is_valid()

chia/_tests/wallet/test_util.py

@@ -106,7 +106,7 @@ def test_list_to_binary_tree() -> None:
 @pytest.mark.parametrize(
     "serializations",
     [
-        (tuple(), Program.to(None), []),
+        (tuple(), Program.NIL, []),
         ((bytes32.zeros,), Program.to([bytes32.zeros]), [LineageProofField.PARENT_NAME]),
         (
             (bytes32.zeros, bytes32.zeros),
@@ -129,7 +129,7 @@ def test_lineage_proof_varargs(serializations: tuple[tuple[Any, ...], Program, l
 @pytest.mark.parametrize(
     "serializations",
     [
-        ({}, Program.to(None), []),
+        ({}, Program.NIL, []),
         ({"parent_name": bytes32.zeros}, Program.to([bytes32.zeros]), [LineageProofField.PARENT_NAME]),
         (
             {"parent_name": bytes32.zeros, "inner_puzzle_hash": bytes32.zeros},