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

chia/wallet/wallet_nft_store.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import json
 import logging
 from sqlite3 import Row
-from typing import Optional, Union
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
@@ -110,7 +109,7 @@ class WalletNftStore:
             )
             return c.rowcount > 0
 
-    async def save_nft(self, wallet_id: uint32, did_id: Optional[bytes32], nft_coin_info: NFTCoinInfo) -> None:
+    async def save_nft(self, wallet_id: uint32, did_id: bytes32 | None, nft_coin_info: NFTCoinInfo) -> None:
         async with self.db_wrapper.writer_maybe_transaction() as conn:
             columns = (
                 "nft_id, nft_coin_id, wallet_id, did_id, coin, lineage_proof, mint_height, status, full_puzzle, "
@@ -143,9 +142,9 @@ class WalletNftStore:
                 (int(nft_coin_info.latest_height) - REMOVE_BUFF_BLOCKS,),
             )
 
-    async def count(self, wallet_id: Optional[uint32] = None, did_id: Optional[bytes32] = None) -> int:
+    async def count(self, wallet_id: uint32 | None = None, did_id: bytes32 | None = None) -> int:
         sql = "SELECT COUNT(nft_id) FROM users_nfts WHERE removed_height is NULL"
-        params: list[Union[uint32, bytes32]] = []
+        params: list[uint32 | bytes32] = []
         if wallet_id is not None:
             sql += " AND wallet_id=?"
             params.append(wallet_id)
@@ -158,9 +157,9 @@ class WalletNftStore:
                 return int(count_row[0])
         return -1
 
-    async def is_empty(self, wallet_id: Optional[uint32] = None) -> bool:
+    async def is_empty(self, wallet_id: uint32 | None = None) -> bool:
         sql = "SELECT 1 FROM users_nfts WHERE removed_height is NULL"
-        params: list[Union[uint32, bytes32]] = []
+        params: list[uint32 | bytes32] = []
         if wallet_id is not None:
             sql += " AND wallet_id=?"
             params.append(wallet_id)
@@ -173,8 +172,8 @@ class WalletNftStore:
 
     async def get_nft_list(
         self,
-        wallet_id: Optional[uint32] = None,
-        did_id: Optional[bytes32] = None,
+        wallet_id: uint32 | None = None,
+        did_id: bytes32 | None = None,
         start_index: int = 0,
         count: int = 50,
     ) -> list[NFTCoinInfo]:
@@ -224,7 +223,7 @@ class WalletNftStore:
             )
             return True if rows and rows[0] == 1 else False
 
-    async def get_nft_by_coin_id(self, nft_coin_id: bytes32) -> Optional[NFTCoinInfo]:
+    async def get_nft_by_coin_id(self, nft_coin_id: bytes32) -> NFTCoinInfo | None:
         async with self.db_wrapper.reader_no_transaction() as conn:
             rows = await conn.execute_fetchall(
                 f"SELECT {NFT_COIN_INFO_COLUMNS} from users_nfts WHERE removed_height is NULL and nft_coin_id = ?",
@@ -237,10 +236,10 @@ class WalletNftStore:
             raise ValueError("Can only return one NFT, but found > 1 from given coin ids")
         return None
 
-    async def get_nft_by_id(self, nft_id: bytes32, wallet_id: Optional[uint32] = None) -> Optional[NFTCoinInfo]:
+    async def get_nft_by_id(self, nft_id: bytes32, wallet_id: uint32 | None = None) -> NFTCoinInfo | None:
         async with self.db_wrapper.reader_no_transaction() as conn:
             sql = f"SELECT {NFT_COIN_INFO_COLUMNS} from users_nfts WHERE removed_height is NULL and nft_id=?"
-            params: list[Union[uint32, str]] = [nft_id.hex()]
+            params: list[uint32 | str] = [nft_id.hex()]
             if wallet_id:
                 sql += " and wallet_id=?"
                 params.append(wallet_id)

chia/wallet/wallet_node.py

@@ -11,7 +11,7 @@ import time
 import traceback
 from collections.abc import AsyncIterator
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar, Literal, Optional, Union, cast, overload
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, cast, overload
 
 import aiosqlite
 from chia_rs import AugSchemeMPL, CoinState, ConsensusConstants, G1Element, G2Element, HeaderBlock, PrivateKey
@@ -112,37 +112,37 @@ class WalletNode:
     config: dict[str, Any]
     root_path: Path
     constants: ConsensusConstants
-    local_keychain: Optional[Keychain] = None
+    local_keychain: Keychain | None = None
 
     log: logging.Logger = logging.getLogger(__name__)
 
     # Sync data
-    state_changed_callback: Optional[StateChangedProtocol] = None
-    _wallet_state_manager: Optional[WalletStateManager] = None
-    _weight_proof_handler: Optional[WalletWeightProofHandler] = None
-    _server: Optional[ChiaServer] = None
-    sync_task: Optional[asyncio.Task[None]] = None
-    logged_in_fingerprint: Optional[int] = None
+    state_changed_callback: StateChangedProtocol | None = None
+    _wallet_state_manager: WalletStateManager | None = None
+    _weight_proof_handler: WalletWeightProofHandler | None = None
+    _server: ChiaServer | None = None
+    sync_task: asyncio.Task[None] | None = None
+    logged_in_fingerprint: int | None = None
     logged_in: bool = False
-    _keychain_proxy: Optional[KeychainProxy] = None
+    _keychain_proxy: KeychainProxy | None = None
     _balance_cache: dict[int, Balance] = dataclasses.field(default_factory=dict)
     # Peers that we have long synced to
     synced_peers: set[bytes32] = dataclasses.field(default_factory=set)
-    wallet_peers: Optional[WalletPeers] = None
+    wallet_peers: WalletPeers | None = None
     peer_caches: dict[bytes32, PeerRequestCache] = dataclasses.field(default_factory=dict)
-    validation_semaphore: Optional[asyncio.Semaphore] = None
+    validation_semaphore: asyncio.Semaphore | None = None
     local_node_synced: bool = False
     LONG_SYNC_THRESHOLD: int = 300
     last_wallet_tx_resend_time: int = 0
     # Duration in seconds
     coin_state_retry_seconds: int = 10
     wallet_tx_resend_timeout_secs: int = 1800
-    _new_peak_queue: Optional[NewPeakQueue] = None
+    _new_peak_queue: NewPeakQueue | None = None
 
     _shut_down: bool = False
-    _process_new_subscriptions_task: Optional[asyncio.Task[None]] = None
-    _retry_failed_states_task: Optional[asyncio.Task[None]] = None
-    _secondary_peer_sync_task: Optional[asyncio.Task[None]] = None
+    _process_new_subscriptions_task: asyncio.Task[None] | None = None
+    _retry_failed_states_task: asyncio.Task[None] | None = None
+    _secondary_peer_sync_task: asyncio.Task[None] | None = None
     _tx_messages_in_progress: dict[bytes32, list[bytes32]] = dataclasses.field(default_factory=dict)
 
     @contextlib.asynccontextmanager
@@ -190,7 +190,7 @@ class WalletNode:
 
         return self._new_peak_queue
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
+    def get_connections(self, request_node_type: NodeType | None) -> list[dict[str, Any]]:
         return default_get_connections(server=self.server, request_node_type=request_node_type)
 
     async def ensure_keychain_proxy(self) -> KeychainProxy:
@@ -214,30 +214,26 @@ class WalletNode:
             cache.clear_after_height(reorg_height)
 
     @overload
-    async def get_key_for_fingerprint(self, fingerprint: Optional[int]) -> Optional[G1Element]: ...
+    async def get_key_for_fingerprint(self, fingerprint: int | None) -> G1Element | None: ...
 
     @overload
-    async def get_key_for_fingerprint(
-        self, fingerprint: Optional[int], private: Literal[True]
-    ) -> Optional[PrivateKey]: ...
+    async def get_key_for_fingerprint(self, fingerprint: int | None, private: Literal[True]) -> PrivateKey | None: ...
 
     @overload
-    async def get_key_for_fingerprint(
-        self, fingerprint: Optional[int], private: Literal[False]
-    ) -> Optional[G1Element]: ...
+    async def get_key_for_fingerprint(self, fingerprint: int | None, private: Literal[False]) -> G1Element | None: ...
 
     @overload
     async def get_key_for_fingerprint(
-        self, fingerprint: Optional[int], private: bool
-    ) -> Optional[Union[PrivateKey, G1Element]]: ...
+        self, fingerprint: int | None, private: bool
+    ) -> PrivateKey | G1Element | None: ...
 
     async def get_key_for_fingerprint(
-        self, fingerprint: Optional[int], private: bool = False
-    ) -> Optional[Union[PrivateKey, G1Element]]:
+        self, fingerprint: int | None, private: bool = False
+    ) -> PrivateKey | G1Element | None:
         try:
             keychain_proxy = await self.ensure_keychain_proxy()
             # Returns first key if fingerprint is None
-            key: Optional[Union[PrivateKey, G1Element]] = await keychain_proxy.get_key_for_fingerprint(
+            key: PrivateKey | G1Element | None = await keychain_proxy.get_key_for_fingerprint(
                 fingerprint, private=private
             )
         except KeychainIsEmpty:
@@ -257,14 +253,14 @@ class WalletNode:
         return key
 
     async def get_key(
-        self, fingerprint: Optional[int], private: bool = True, find_a_default: bool = True
-    ) -> Optional[Union[PrivateKey, G1Element]]:
+        self, fingerprint: int | None, private: bool = True, find_a_default: bool = True
+    ) -> PrivateKey | G1Element | None:
         """
         Attempt to get the private key for the given fingerprint. If the fingerprint is None,
         get_key_for_fingerprint() will return the first private key. Similarly, if a key isn't
         returned for the provided fingerprint, the first key will be returned.
         """
-        key: Optional[Union[PrivateKey, G1Element]] = await self.get_key_for_fingerprint(fingerprint, private=private)
+        key: PrivateKey | G1Element | None = await self.get_key_for_fingerprint(fingerprint, private=private)
 
         if key is None and fingerprint is not None and find_a_default:
             key = await self.get_key_for_fingerprint(None, private=private)
@@ -304,7 +300,7 @@ class WalletNode:
                 save_config(self.root_path, "config.yaml", config)
         return auto_claim_config.to_json_dict()
 
-    async def reset_sync_db(self, db_path: Union[Path, str], fingerprint: int) -> bool:
+    async def reset_sync_db(self, db_path: Path | str, fingerprint: int) -> bool:
         conn: aiosqlite.Connection
         # are not part of core wallet tables, but might appear later
         ignore_tables = {"lineage_proofs_", "sqlite_", "MIGRATED_VALID_TIMES_TXS", "MIGRATED_VALID_TIMES_TRADES"}
@@ -388,7 +384,7 @@ class WalletNode:
 
     async def _start_with_fingerprint(
         self,
-        fingerprint: Optional[int] = None,
+        fingerprint: int | None = None,
     ) -> bool:
         # Makes sure the coin_state_updates get higher priority than new_peak messages.
         # Delayed instantiation until here to avoid errors.
@@ -601,8 +597,8 @@ class WalletNode:
         while not self._shut_down:
             # Here we process four types of messages in the queue, where the first one has higher priority (lower
             # number in the queue), and priority decreases for each type.
-            peer: Optional[WSChiaConnection] = None
-            item: Optional[NewPeakItem] = None
+            peer: WSChiaConnection | None = None
+            item: NewPeakItem | None = None
             try:
                 peer, item = None, None
                 item = await self.new_peak_queue.get()
@@ -676,8 +672,8 @@ class WalletNode:
         path.write_text(str(fingerprint))
         self.log.info(f"Updated last used fingerprint: {fingerprint}")
 
-    def get_last_used_fingerprint(self) -> Optional[int]:
-        fingerprint: Optional[int] = None
+    def get_last_used_fingerprint(self) -> int | None:
+        fingerprint: int | None = None
         try:
             path = self.get_last_used_fingerprint_path()
             if path.exists():
@@ -760,7 +756,7 @@ class WalletNode:
         if self.wallet_peers is not None:
             await self.wallet_peers.on_connect(peer)
 
-    async def perform_atomic_rollback(self, fork_height: int, cache: Optional[PeerRequestCache] = None) -> None:
+    async def perform_atomic_rollback(self, fork_height: int, cache: PeerRequestCache | None = None) -> None:
         self.log.info(f"perform_atomic_rollback to {fork_height}")
         # this is to start a write transaction
         async with self.wallet_state_manager.db_wrapper.writer():
@@ -882,8 +878,8 @@ class WalletNode:
         self,
         items_input: list[CoinState],
         peer: WSChiaConnection,
-        fork_height: Optional[uint32] = None,
-        height: Optional[uint32] = None,
+        fork_height: uint32 | None = None,
+        height: uint32 | None = None,
     ) -> bool:
         # Adds the state to the wallet state manager. If the peer is trusted, we do not validate. If the peer is
         # untrusted we do, but we might not add the state, since we need to receive the new_peak message as well.
@@ -1064,7 +1060,7 @@ class WalletNode:
                 neither.append(node)
         return synced_and_trusted + synced + trusted + neither
 
-    async def get_timestamp_for_height_from_peer(self, height: uint32, peer: WSChiaConnection) -> Optional[uint64]:
+    async def get_timestamp_for_height_from_peer(self, height: uint32, peer: WSChiaConnection) -> uint64 | None:
         """
         Returns the timestamp for transaction block at h=height, if not transaction block, backtracks until it finds
         a transaction block
@@ -1078,7 +1074,7 @@ class WalletNode:
             block = cache.get_block(uint32(request_height))
             if block is None:
                 self.log.debug(f"get_timestamp_for_height_from_peer cache miss for height {request_height}")
-                response: Optional[list[HeaderBlock]] = await request_header_blocks(
+                response: list[HeaderBlock] | None = await request_header_blocks(
                     peer, uint32(request_height), uint32(request_height)
                 )
                 if response is not None and len(response) > 0:
@@ -1111,7 +1107,7 @@ class WalletNode:
             self.log.debug("state manager is None (shutdown)")
             return
 
-        peak_hb: Optional[HeaderBlock] = await self.wallet_state_manager.blockchain.get_peak_block()
+        peak_hb: HeaderBlock | None = await self.wallet_state_manager.blockchain.get_peak_block()
         if peak_hb is not None and peak_hb.header_hash == new_peak.header_hash:
             self.log.debug("skip known peak.")
             return
@@ -1122,7 +1118,7 @@ class WalletNode:
             return
 
         request = RequestBlockHeader(new_peak.height)
-        response: Optional[RespondBlockHeader] = await peer.call_api(FullNodeAPI.request_block_header, request)
+        response: RespondBlockHeader | None = await peer.call_api(FullNodeAPI.request_block_header, request)
         if response is None:
             self.log.warning(f"Peer {peer.get_peer_info()} did not respond in time.")
             await peer.close(120)
@@ -1291,7 +1287,7 @@ class WalletNode:
             return True
 
     async def wallet_short_sync_backtrack(self, header_block: HeaderBlock, peer: WSChiaConnection) -> int:
-        peak: Optional[HeaderBlock] = await self.wallet_state_manager.blockchain.get_peak_block()
+        peak: HeaderBlock | None = await self.wallet_state_manager.blockchain.get_peak_block()
 
         top = header_block
         blocks = [top]
@@ -1303,7 +1299,7 @@ class WalletNode:
 
         while not self.wallet_state_manager.blockchain.contains_block(top.prev_header_hash) and top.height > 0:
             request_prev = RequestBlockHeader(uint32(top.height - 1))
-            response_prev: Optional[RespondBlockHeader] = await peer.call_api(
+            response_prev: RespondBlockHeader | None = await peer.call_api(
                 FullNodeAPI.request_block_header, request_prev
             )
             if response_prev is None or not isinstance(response_prev, RespondBlockHeader):
@@ -1384,7 +1380,7 @@ class WalletNode:
         coin_state: CoinState,
         peer: WSChiaConnection,
         peer_request_cache: PeerRequestCache,
-        fork_height: Optional[uint32],
+        fork_height: uint32 | None,
     ) -> bool:
         """
         Returns True if the coin_state is valid and included in the blockchain proved by the weight proof.
@@ -1396,8 +1392,8 @@ class WalletNode:
         if can_use_peer_request_cache(coin_state, peer_request_cache, fork_height):
             return True
 
-        spent_height: Optional[uint32] = None if coin_state.spent_height is None else uint32(coin_state.spent_height)
-        confirmed_height: Optional[uint32] = (
+        spent_height: uint32 | None = None if coin_state.spent_height is None else uint32(coin_state.spent_height)
+        confirmed_height: uint32 | None = (
             None if coin_state.created_height is None else uint32(coin_state.created_height)
         )
         current = await self.wallet_state_manager.coin_store.get_coin_record(coin_state.coin.name())
@@ -1429,7 +1425,7 @@ class WalletNode:
             confirmed_height = current.confirmed_block_height
 
         # request header block for created height
-        state_block: Optional[HeaderBlock] = peer_request_cache.get_block(confirmed_height)
+        state_block: HeaderBlock | None = peer_request_cache.get_block(confirmed_height)
         if state_block is None or reorg_mode:
             state_blocks = await request_header_blocks(peer, confirmed_height, confirmed_height)
             if state_blocks is None:
@@ -1467,7 +1463,7 @@ class WalletNode:
                 # Peer is telling us that coin that was previously known to be spent is not spent anymore
                 # Check old state
 
-                spent_state_blocks: Optional[list[HeaderBlock]] = await request_header_blocks(
+                spent_state_blocks: list[HeaderBlock] | None = await request_header_blocks(
                     peer, current.spent_block_height, current.spent_block_height
                 )
                 if spent_state_blocks is None:
@@ -1535,7 +1531,7 @@ class WalletNode:
                 if stored_record.header_hash == block.header_hash:
                     return True
 
-        weight_proof: Optional[WeightProof] = self.wallet_state_manager.blockchain.synced_weight_proof
+        weight_proof: WeightProof | None = self.wallet_state_manager.blockchain.synced_weight_proof
         if weight_proof is None:
             return False
 
@@ -1593,9 +1589,7 @@ class WalletNode:
             return False
         all_peers_c = self.server.get_connections(NodeType.FULL_NODE)
         all_peers = [(con, self.is_trusted(con)) for con in all_peers_c]
-        blocks: Optional[list[HeaderBlock]] = await fetch_header_blocks_in_range(
-            start, end, peer_request_cache, all_peers
-        )
+        blocks: list[HeaderBlock] | None = await fetch_header_blocks_in_range(start, end, peer_request_cache, all_peers)
         if blocks is None:
             log_level = logging.DEBUG if self._shut_down or peer.closed else logging.ERROR
             self.log.log(log_level, f"Error fetching blocks {start} {end}")
@@ -1675,10 +1669,10 @@ class WalletNode:
         return True
 
     async def get_coin_state(
-        self, coin_names: list[bytes32], peer: WSChiaConnection, fork_height: Optional[uint32] = None
+        self, coin_names: list[bytes32], peer: WSChiaConnection, fork_height: uint32 | None = None
     ) -> list[CoinState]:
         msg = RegisterForCoinUpdates(coin_names, uint32(0))
-        coin_state: Optional[RespondToCoinUpdates] = await peer.call_api(FullNodeAPI.register_for_coin_updates, msg)
+        coin_state: RespondToCoinUpdates | None = await peer.call_api(FullNodeAPI.register_for_coin_updates, msg)
         if coin_state is None or not isinstance(coin_state, RespondToCoinUpdates):
             raise PeerRequestException(f"Was not able to get states for {coin_names}")
 
@@ -1699,11 +1693,9 @@ class WalletNode:
         return coin_state.coin_states
 
     async def fetch_children(
-        self, coin_name: bytes32, peer: WSChiaConnection, fork_height: Optional[uint32] = None
+        self, coin_name: bytes32, peer: WSChiaConnection, fork_height: uint32 | None = None
     ) -> list[CoinState]:
-        response: Optional[RespondChildren] = await peer.call_api(
-            FullNodeAPI.request_children, RequestChildren(coin_name)
-        )
+        response: RespondChildren | None = await peer.call_api(FullNodeAPI.request_children, RequestChildren(coin_name))
         if response is None or not isinstance(response, RespondChildren):
             raise PeerRequestException(f"Was not able to obtain children {response}")
 

chia/wallet/wallet_node_api.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, ClassVar, cast
+from typing import TYPE_CHECKING, ClassVar
 
 from chia_rs import RespondToPhUpdates
 
@@ -16,9 +16,11 @@ from chia.wallet.wallet_node import WalletNode
 
 class WalletNodeAPI:
     if TYPE_CHECKING:
-        from chia.server.api_protocol import ApiProtocol
+        from chia.apis.wallet_stub import WalletNodeApiStub
 
-        _protocol_check: ClassVar[ApiProtocol] = cast("WalletNodeAPI", None)
+        # Verify this class implements the WalletNodeApiStub protocol
+        def _protocol_check(self: WalletNodeAPI) -> WalletNodeApiStub:
+            return self
 
     log: logging.Logger
     wallet_node: WalletNode

chia/wallet/wallet_protocol.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, TypeVar
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from chia_rs import G1Element
 from chia_rs.sized_bytes import bytes32
@@ -31,7 +31,7 @@ class WalletProtocol(Protocol[T_contra]):
     def id(self) -> uint32: ...
 
     async def coin_added(
-        self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: Optional[T_contra]
+        self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: T_contra | None
     ) -> None: ...
 
     async def select_coins(
@@ -40,15 +40,15 @@ class WalletProtocol(Protocol[T_contra]):
         action_scope: WalletActionScope,
     ) -> set[Coin]: ...
 
-    async def get_confirmed_balance(self, record_list: Optional[set[WalletCoinRecord]] = None) -> uint128: ...
+    async def get_confirmed_balance(self, record_list: set[WalletCoinRecord] | None = None) -> uint128: ...
 
-    async def get_unconfirmed_balance(self, unspent_records: Optional[set[WalletCoinRecord]] = None) -> uint128: ...
+    async def get_unconfirmed_balance(self, unspent_records: set[WalletCoinRecord] | None = None) -> uint128: ...
 
-    async def get_spendable_balance(self, unspent_records: Optional[set[WalletCoinRecord]] = None) -> uint128: ...
+    async def get_spendable_balance(self, unspent_records: set[WalletCoinRecord] | None = None) -> uint128: ...
 
     async def get_pending_change_balance(self) -> uint64: ...
 
-    async def get_max_send_amount(self, records: Optional[set[WalletCoinRecord]] = None) -> uint128: ...
+    async def get_max_send_amount(self, records: set[WalletCoinRecord] | None = None) -> uint128: ...
 
     # not all wallet supports this. To signal support, make
     # require_derivation_paths() return true
@@ -66,8 +66,8 @@ class WalletProtocol(Protocol[T_contra]):
         puzzle_hashes: list[bytes32],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        coins: Optional[set[Coin]] = None,
-        memos: Optional[list[list[bytes]]] = None,
+        coins: set[Coin] | None = None,
+        memos: list[list[bytes]] | None = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
         **kwargs: Unpack[GSTOptionalArgs],
     ) -> None: ...
@@ -78,29 +78,29 @@ class WalletProtocol(Protocol[T_contra]):
 
 class GSTOptionalArgs(TypedDict):
     # DataLayerWallet
-    launcher_id: NotRequired[Optional[bytes32]]
-    new_root_hash: NotRequired[Optional[bytes32]]
+    launcher_id: NotRequired[bytes32 | None]
+    new_root_hash: NotRequired[bytes32 | None]
     sign: NotRequired[bool]
     announce_new_state: NotRequired[bool]
     # CATWallet
-    cat_discrepancy: NotRequired[Optional[tuple[int, Program, Program]]]
+    cat_discrepancy: NotRequired[tuple[int, Program, Program] | None]
     # NFTWallet
-    nft_coin: NotRequired[Optional[NFTCoinInfo]]
-    new_owner: NotRequired[Optional[bytes]]
-    new_did_inner_hash: NotRequired[Optional[bytes]]
-    trade_prices_list: NotRequired[Optional[Program]]
+    nft_coin: NotRequired[NFTCoinInfo | None]
+    new_owner: NotRequired[bytes | None]
+    new_did_inner_hash: NotRequired[bytes | None]
+    trade_prices_list: NotRequired[Program | None]
     additional_bundles: NotRequired[list[WalletSpendBundle]]
-    metadata_update: NotRequired[Optional[tuple[str, str]]]
+    metadata_update: NotRequired[tuple[str, str] | None]
     # CR-CAT Wallet
     add_authorizations_to_cr_cats: NotRequired[bool]
     # VCWallet
-    new_proof_hash: NotRequired[Optional[bytes32]]
-    provider_inner_puzhash: NotRequired[Optional[bytes32]]
+    new_proof_hash: NotRequired[bytes32 | None]
+    provider_inner_puzhash: NotRequired[bytes32 | None]
     self_revoke: NotRequired[bool]
-    vc_id: NotRequired[Optional[bytes32]]
+    vc_id: NotRequired[bytes32 | None]
     # Wallet
-    origin_id: NotRequired[Optional[bytes32]]
+    origin_id: NotRequired[bytes32 | None]
     negative_change_allowed: NotRequired[bool]
-    puzzle_decorator_override: NotRequired[Optional[list[dict[str, Any]]]]
-    reserve_fee: NotRequired[Optional[uint64]]
-    preferred_change_puzzle_hash: NotRequired[Optional[bytes32]]
+    puzzle_decorator_override: NotRequired[list[dict[str, Any]] | None]
+    reserve_fee: NotRequired[uint64 | None]
+    preferred_change_puzzle_hash: NotRequired[bytes32 | None]

chia/wallet/wallet_puzzle_store.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Optional
 
 from chia_rs import G1Element
 from chia_rs.sized_bytes import bytes32
@@ -28,7 +27,7 @@ class WalletPuzzleStore:
     wallet_identifier_cache: LRUCache
     # maps wallet_id -> last_derivation_index
     last_wallet_derivation_index: dict[uint32, uint32]
-    last_derivation_index: Optional[uint32]
+    last_derivation_index: uint32 | None
 
     @classmethod
     async def create(cls, db_wrapper: DBWrapper2):
@@ -110,9 +109,7 @@ class WalletPuzzleStore:
                 )
             ).close()
 
-    async def get_derivation_record(
-        self, index: uint32, wallet_id: uint32, hardened: bool
-    ) -> Optional[DerivationRecord]:
+    async def get_derivation_record(self, index: uint32, wallet_id: uint32, hardened: bool) -> DerivationRecord | None:
         """
         Returns the derivation record by index and wallet id.
         """
@@ -133,7 +130,7 @@ class WalletPuzzleStore:
 
         return None
 
-    async def get_derivation_record_for_puzzle_hash(self, puzzle_hash: bytes32) -> Optional[DerivationRecord]:
+    async def get_derivation_record_for_puzzle_hash(self, puzzle_hash: bytes32) -> DerivationRecord | None:
         """
         Returns the derivation record by index and wallet id.
         """
@@ -183,7 +180,7 @@ class WalletPuzzleStore:
             bool(row[5]),
         )
 
-    async def index_for_pubkey(self, pubkey: G1Element) -> Optional[uint32]:
+    async def index_for_pubkey(self, pubkey: G1Element) -> uint32 | None:
         """
         Returns derivation paths for the given pubkey.
         Returns None if not present.
@@ -199,7 +196,7 @@ class WalletPuzzleStore:
 
         return None
 
-    async def record_for_pubkey(self, pubkey: G1Element) -> Optional[DerivationRecord]:
+    async def record_for_pubkey(self, pubkey: G1Element) -> DerivationRecord | None:
         """
         Returns derivation record for the given pubkey.
         Returns None if not present.
@@ -216,7 +213,7 @@ class WalletPuzzleStore:
 
         return None if row is None else self.row_to_record(row)
 
-    async def index_for_puzzle_hash(self, puzzle_hash: bytes32) -> Optional[uint32]:
+    async def index_for_puzzle_hash(self, puzzle_hash: bytes32) -> uint32 | None:
         """
         Returns the derivation path for the puzzle_hash.
         Returns None if not present.
@@ -227,7 +224,7 @@ class WalletPuzzleStore:
             )
         return None if row is None else uint32(row[0])
 
-    async def record_for_puzzle_hash(self, puzzle_hash: bytes32) -> Optional[DerivationRecord]:
+    async def record_for_puzzle_hash(self, puzzle_hash: bytes32) -> DerivationRecord | None:
         """
         Returns the derivation path for the puzzle_hash.
         Returns None if not present.
@@ -246,7 +243,7 @@ class WalletPuzzleStore:
 
         return None
 
-    async def get_wallet_identifier_for_puzzle_hash(self, puzzle_hash: bytes32) -> Optional[WalletIdentifier]:
+    async def get_wallet_identifier_for_puzzle_hash(self, puzzle_hash: bytes32) -> WalletIdentifier | None:
         """
         Returns the derivation path for the puzzle_hash.
         Returns None if not present.
@@ -267,7 +264,7 @@ class WalletPuzzleStore:
 
         return None
 
-    async def get_all_puzzle_hashes(self, wallet_id: Optional[int] = None) -> set[bytes32]:
+    async def get_all_puzzle_hashes(self, wallet_id: int | None = None) -> set[bytes32]:
         """
         Return a set containing all puzzle_hashes we generated.
         """
@@ -281,7 +278,7 @@ class WalletPuzzleStore:
                 )
             return {bytes32.fromhex(row[0]) for row in rows}
 
-    async def get_last_derivation_path(self) -> Optional[uint32]:
+    async def get_last_derivation_path(self) -> uint32 | None:
         """
         Returns the last derivation path by derivation_index.
         """
@@ -294,11 +291,11 @@ class WalletPuzzleStore:
             self.last_derivation_index = last_derivation_index
             return self.last_derivation_index
 
-    async def get_last_derivation_path_for_wallet(self, wallet_id: int) -> Optional[uint32]:
+    async def get_last_derivation_path_for_wallet(self, wallet_id: int) -> uint32 | None:
         """
         Returns the last derivation path by derivation_index.
         """
-        cached_derivation_index: Optional[uint32] = self.last_wallet_derivation_index.get(uint32(wallet_id))
+        cached_derivation_index: uint32 | None = self.last_wallet_derivation_index.get(uint32(wallet_id))
         if cached_derivation_index is not None:
             return cached_derivation_index
 
@@ -311,7 +308,7 @@ class WalletPuzzleStore:
                 self.last_wallet_derivation_index[uint32(wallet_id)] = derivation_index
             return derivation_index
 
-    async def get_current_derivation_record_for_wallet(self, wallet_id: uint32) -> Optional[DerivationRecord]:
+    async def get_current_derivation_record_for_wallet(self, wallet_id: uint32) -> DerivationRecord | None:
         """
         Returns the current derivation record by derivation_index.
         """
@@ -329,7 +326,7 @@ class WalletPuzzleStore:
 
         return None
 
-    async def get_unused_derivation_path(self) -> Optional[uint32]:
+    async def get_unused_derivation_path(self) -> uint32 | None:
         """
         Returns the first unused derivation path by derivation_index.
         """
@@ -343,7 +340,7 @@ class WalletPuzzleStore:
 
         return None
 
-    async def get_unused_derivation_path_for_wallet(self, wallet_id: uint32) -> Optional[uint32]:
+    async def get_unused_derivation_path_for_wallet(self, wallet_id: uint32) -> uint32 | None:
         """
         Returns the first unused derivation path by derivation_index.
         """