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

chia/wallet/derivation_record.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Union
 
 from chia_rs import G1Element
 from chia_rs.sized_bytes import bytes32
@@ -20,7 +19,7 @@ class DerivationRecord:
 
     index: uint32
     puzzle_hash: bytes32
-    _pubkey: Union[G1Element, bytes]
+    _pubkey: G1Element | bytes
     wallet_type: WalletType
     wallet_id: uint32
     hardened: bool

chia/wallet/derive_keys.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from chia_rs import AugSchemeMPL, G1Element, PrivateKey
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
@@ -95,7 +93,7 @@ def master_sk_to_pooling_authentication_sk(master: PrivateKey, pool_wallet_index
     return _derive_path(master, [12381, 8444, 6, pool_wallet_index * 10000 + index])
 
 
-def find_owner_sk(all_sks: list[PrivateKey], owner_pk: G1Element) -> Optional[tuple[PrivateKey, uint32]]:
+def find_owner_sk(all_sks: list[PrivateKey], owner_pk: G1Element) -> tuple[PrivateKey, uint32] | None:
     for pool_wallet_index in range(MAX_POOL_WALLETS):
         for sk in all_sks:
             try_owner_sk = master_sk_to_singleton_owner_sk(sk, uint32(pool_wallet_index))
@@ -104,7 +102,7 @@ def find_owner_sk(all_sks: list[PrivateKey], owner_pk: G1Element) -> Optional[tu
     return None
 
 
-def find_authentication_sk(all_sks: list[PrivateKey], owner_pk: G1Element) -> Optional[PrivateKey]:
+def find_authentication_sk(all_sks: list[PrivateKey], owner_pk: G1Element) -> PrivateKey | None:
     # NOTE: might need to increase this if using a large number of wallets, or have switched authentication keys
     # many times.
     for pool_wallet_index in range(MAX_POOL_WALLETS):

chia/wallet/did_wallet/did_info.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Optional
 
 from chia_rs import CoinState
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint64
 
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.program import NIL, Program
+from chia.types.blockchain_format.program import Program
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.lineage_proof import LineageProof
 from chia.wallet.util.curry_and_treehash import NIL_TREEHASH
@@ -16,7 +15,7 @@ from chia.wallet.util.curry_and_treehash import NIL_TREEHASH
 
 def did_recovery_is_nil(recovery_program: Program) -> bool:
     # cannot use set as not hashable
-    if recovery_program in (NIL, NIL_TREEHASH):  # noqa: PLR6201
+    if recovery_program in (Program.NIL, NIL_TREEHASH):  # noqa: PLR6201
         return True
     else:
         return False
@@ -25,14 +24,14 @@ def did_recovery_is_nil(recovery_program: Program) -> bool:
 @streamable
 @dataclass(frozen=True)
 class DIDInfo(Streamable):
-    origin_coin: Optional[Coin]  # Coin ID of this coin is our DID
+    origin_coin: Coin | None  # Coin ID of this coin is our DID
     backup_ids: list[bytes32]
     num_of_backup_ids_needed: uint64
-    parent_info: list[tuple[bytes32, Optional[LineageProof]]]  # {coin.name(): LineageProof}
-    current_inner: Optional[Program]  # represents a Program as bytes
-    temp_coin: Optional[Coin]  # partially recovered wallet uses these to hold info
-    temp_puzhash: Optional[bytes32]
-    temp_pubkey: Optional[bytes]
+    parent_info: list[tuple[bytes32, LineageProof | None]]  # {coin.name(): LineageProof}
+    current_inner: Program | None  # represents a Program as bytes
+    temp_coin: Coin | None  # partially recovered wallet uses these to hold info
+    temp_puzhash: bytes32 | None
+    temp_pubkey: bytes | None
     sent_recovery_transaction: bool
     metadata: str  # JSON of the user defined metadata
 
@@ -41,9 +40,9 @@ class DIDInfo(Streamable):
 @dataclass(frozen=True)
 class DIDCoinData(Streamable):
     p2_puzzle: Program
-    recovery_list_hash: Optional[bytes32]
+    recovery_list_hash: bytes32 | None
     num_verification: uint16
     singleton_struct: Program
     metadata: Program
-    inner_puzzle: Optional[Program]
+    inner_puzzle: Program | None
     coin_state: CoinState

chia/wallet/did_wallet/did_wallet.py

@@ -5,7 +5,7 @@ import json
 import logging
 import re
 import time
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from chia_rs import AugSchemeMPL, CoinSpend, CoinState, G1Element, G2Element
 from chia_rs.sized_bytes import bytes32
@@ -16,14 +16,12 @@ from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.coin_spend import make_spend
-from chia.types.signing_mode import CHIP_0002_SIGN_MESSAGE_PREFIX, SigningMode
 from chia.wallet.conditions import (
     AssertCoinAnnouncement,
     Condition,
     ConditionValidTimes,
     CreateCoin,
     CreateCoinAnnouncement,
-    parse_timelock_info,
 )
 from chia.wallet.derivation_record import DerivationRecord
 from chia.wallet.did_wallet import did_wallet_puzzles
@@ -31,8 +29,6 @@ from chia.wallet.did_wallet.did_info import DIDCoinData, DIDInfo, did_recovery_i
 from chia.wallet.did_wallet.did_wallet_puzzles import match_did_puzzle, uncurry_innerpuz
 from chia.wallet.lineage_proof import LineageProof
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import (
-    DEFAULT_HIDDEN_PUZZLE_HASH,
-    calculate_synthetic_secret_key,
     puzzle_for_pk,
     puzzle_hash_for_pk,
 )
@@ -44,7 +40,6 @@ from chia.wallet.singleton import (
 )
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.uncurried_puzzle import uncurry_puzzle
-from chia.wallet.util.compute_memos import compute_memos
 from chia.wallet.util.curry_and_treehash import NIL_TREEHASH, shatree_int, shatree_pair
 from chia.wallet.util.transaction_type import TransactionType
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
@@ -68,8 +63,8 @@ class DIDWallet:
     wallet_info: WalletInfo
     did_info: DIDInfo
     standard_wallet: Wallet
-    base_puzzle_program: Optional[bytes]
-    base_inner_puzzle_hash: Optional[bytes32]
+    base_puzzle_program: bytes | None
+    base_inner_puzzle_hash: bytes32 | None
     wallet_id: int
 
     @staticmethod
@@ -79,7 +74,7 @@ class DIDWallet:
         amount: uint64,
         action_scope: WalletActionScope,
         metadata: dict[str, str] = {},
-        name: Optional[str] = None,
+        name: str | None = None,
         fee: uint64 = uint64(0),
         extra_conditions: tuple[Condition, ...] = tuple(),
     ):
@@ -149,7 +144,7 @@ class DIDWallet:
         wallet_state_manager: Any,
         wallet: Wallet,
         backup_data: str,
-        name: Optional[str] = None,
+        name: str | None = None,
     ):
         """
         Create a DID wallet from a backup file
@@ -191,7 +186,7 @@ class DIDWallet:
         launch_coin: Coin,
         inner_puzzle: Program,
         coin_spend: CoinSpend,
-        name: Optional[str] = None,
+        name: str | None = None,
     ):
         """
         Create a DID wallet from a transfer
@@ -264,7 +259,7 @@ class DIDWallet:
         wallet_state_manager: Any,
         wallet: Wallet,
         wallet_info: WalletInfo,
-        name: Optional[str] = None,
+        name: str | None = None,
     ):
         """
         Create a DID wallet based on the local database
@@ -362,7 +357,7 @@ class DIDWallet:
     # We can improve this interface by passing in the CoinSpend, as well
     # We need to change DID Wallet coin_added to expect p2 spends as well as recovery spends,
     # or only call it in the recovery spend case
-    async def coin_added(self, coin: Coin, _: uint32, peer: WSChiaConnection, parent_coin_data: Optional[DIDCoinData]):
+    async def coin_added(self, coin: Coin, _: uint32, peer: WSChiaConnection, parent_coin_data: DIDCoinData | None):
         """Notification from wallet state manager that wallet has been received."""
         parent = self.get_parent_for_coin(coin)
         if parent_coin_data is not None:
@@ -381,9 +376,7 @@ class DIDWallet:
             p2_puzzle, recovery_list_hash, num_verification, singleton_struct, metadata = did_curried_args
             did_data = DIDCoinData(
                 p2_puzzle=p2_puzzle,
-                recovery_list_hash=bytes32(recovery_list_hash.as_atom())
-                if recovery_list_hash != Program.to(None)
-                else None,
+                recovery_list_hash=bytes32(recovery_list_hash.as_atom()) if recovery_list_hash != Program.NIL else None,
                 num_verification=uint16(num_verification.as_int()),
                 singleton_struct=singleton_struct,
                 metadata=metadata,
@@ -649,25 +642,16 @@ class DIDWallet:
                 extra_conditions=(AssertCoinAnnouncement(asserted_id=coin_name, asserted_msg=coin_name),),
             )
         to_ph = await action_scope.get_puzzle_hash(self.wallet_state_manager, override_reuse_puzhash_with=True)
-        did_record = TransactionRecord(
-            confirmed_at_height=uint32(0),
-            created_at_time=uint64(time.time()),
-            to_puzzle_hash=to_ph,
-            to_address=self.wallet_state_manager.encode_puzzle_hash(to_ph),
+        did_record = self.wallet_state_manager.new_outgoing_transaction(
+            wallet_id=self.id(),
+            puzzle_hash=to_ph,
             amount=uint64(coin.amount),
-            fee_amount=uint64(0),
-            confirmed=False,
-            sent=uint32(0),
+            fee=uint64(0),
             spend_bundle=spend_bundle,
             additions=spend_bundle.additions(),
             removals=spend_bundle.removals(),
-            wallet_id=self.wallet_info.id,
-            sent_to=[],
-            trade_id=None,
-            type=uint32(TransactionType.OUTGOING_TX.value),
-            name=bytes32.secret(),
-            memos=compute_memos(spend_bundle),
-            valid_times=parse_timelock_info(extra_conditions),
+            name=spend_bundle.name(),
+            extra_conditions=extra_conditions,
         )
 
         async with action_scope.use() as interface:
@@ -735,25 +719,16 @@ class DIDWallet:
                 extra_conditions=(AssertCoinAnnouncement(asserted_id=coin_name, asserted_msg=coin_name),),
             )
         to_ph = await action_scope.get_puzzle_hash(self.wallet_state_manager, override_reuse_puzhash_with=True)
-        did_record = TransactionRecord(
-            confirmed_at_height=uint32(0),
-            created_at_time=uint64(time.time()),
-            to_puzzle_hash=to_ph,
-            to_address=self.wallet_state_manager.encode_puzzle_hash(to_ph),
+        did_record = self.wallet_state_manager.new_outgoing_transaction(
+            wallet_id=self.id(),
+            puzzle_hash=to_ph,
             amount=uint64(coin.amount),
-            fee_amount=fee,
-            confirmed=False,
-            sent=uint32(0),
+            fee=fee,
             spend_bundle=spend_bundle,
             additions=spend_bundle.additions(),
             removals=spend_bundle.removals(),
-            wallet_id=self.wallet_info.id,
-            sent_to=[],
-            trade_id=None,
-            type=uint32(TransactionType.OUTGOING_TX.value),
             name=spend_bundle.name(),
-            memos=compute_memos(spend_bundle),
-            valid_times=parse_timelock_info(extra_conditions),
+            extra_conditions=extra_conditions,
         )
 
         async with action_scope.use() as interface:
@@ -815,25 +790,16 @@ class DIDWallet:
         )
         list_of_coinspends = [make_spend(coin, full_puzzle, fullsol)]
         unsigned_spend_bundle = WalletSpendBundle(list_of_coinspends, G2Element())
-        tx = TransactionRecord(
-            confirmed_at_height=uint32(0),
-            created_at_time=uint64(time.time()),
-            to_puzzle_hash=p2_ph,
-            to_address=self.wallet_state_manager.encode_puzzle_hash(p2_ph),
+        tx = self.wallet_state_manager.new_outgoing_transaction(
+            wallet_id=self.id(),
+            puzzle_hash=p2_ph,
             amount=uint64(coin.amount),
-            fee_amount=uint64(0),
-            confirmed=False,
-            sent=uint32(0),
+            fee=uint64(0),
             spend_bundle=unsigned_spend_bundle,
             additions=unsigned_spend_bundle.additions(),
             removals=[coin],
-            wallet_id=self.id(),
-            sent_to=[],
-            trade_id=None,
-            type=uint32(TransactionType.OUTGOING_TX.value),
             name=unsigned_spend_bundle.name(),
-            memos=compute_memos(unsigned_spend_bundle),
-            valid_times=parse_timelock_info(extra_conditions),
+            extra_conditions=extra_conditions,
         )
         async with action_scope.use() as interface:
             interface.side_effects.transactions.append(tx)
@@ -841,8 +807,8 @@ class DIDWallet:
     async def get_did_innerpuz(
         self,
         action_scope: WalletActionScope,
-        origin_id: Optional[bytes32] = None,
-        override_reuse_puzhash_with: Optional[bool] = None,
+        origin_id: bytes32 | None = None,
+        override_reuse_puzhash_with: bool | None = None,
     ) -> Program:
         if self.did_info.origin_coin is not None:
             launcher_id = self.did_info.origin_coin.name()
@@ -904,7 +870,7 @@ class DIDWallet:
         )
         return inner_puzzle
 
-    def reset_recovery_list(self) -> Optional[Program]:
+    def reset_recovery_list(self) -> Program | None:
         if self.did_info.current_inner is None:
             return None
 
@@ -921,7 +887,7 @@ class DIDWallet:
 
         return og_recovery_list_hash
 
-    def get_parent_for_coin(self, coin) -> Optional[LineageProof]:
+    def get_parent_for_coin(self, coin) -> LineageProof | None:
         parent_info = None
         for name, ccparent in self.did_info.parent_info:
             if name == coin.parent_coin_info:
@@ -929,27 +895,15 @@ class DIDWallet:
 
         return parent_info
 
-    async def sign_message(self, message: str, mode: SigningMode) -> tuple[G1Element, G2Element]:
+    async def current_p2_puzzle_hash(self) -> bytes32:
         if self.did_info.current_inner is None:
             raise ValueError("Missing DID inner puzzle.")
         puzzle_args = did_wallet_puzzles.uncurry_innerpuz(self.did_info.current_inner)
         if puzzle_args is not None:
             p2_puzzle, _, _, _, _ = puzzle_args
-            puzzle_hash = p2_puzzle.get_tree_hash()
-            private = await self.wallet_state_manager.get_private_key(puzzle_hash)
-            synthetic_secret_key = calculate_synthetic_secret_key(private, DEFAULT_HIDDEN_PUZZLE_HASH)
-            synthetic_pk = synthetic_secret_key.get_g1()
-            if mode == SigningMode.CHIP_0002_HEX_INPUT:
-                hex_message: bytes = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, bytes.fromhex(message))).get_tree_hash()
-            elif mode == SigningMode.BLS_MESSAGE_AUGMENTATION_UTF8_INPUT:
-                hex_message = bytes(message, "utf-8")
-            elif mode == SigningMode.BLS_MESSAGE_AUGMENTATION_HEX_INPUT:
-                hex_message = bytes.fromhex(message)
-            else:
-                hex_message = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, message)).get_tree_hash()
-            return synthetic_pk, AugSchemeMPL.sign(synthetic_secret_key, hex_message)
+            return p2_puzzle.get_tree_hash()
         else:
-            raise ValueError("Invalid inner DID puzzle.")
+            raise ValueError("Invalid DID inner puzzle.")
 
     async def generate_new_decentralised_id(
         self,
@@ -1084,14 +1038,14 @@ class DIDWallet:
         )
         return spendable_am
 
-    async def get_max_send_amount(self, records: Optional[set[WalletCoinRecord]] = None):
+    async def get_max_send_amount(self, records: set[WalletCoinRecord] | None = None):
         spendable: list[WalletCoinRecord] = list(
             await self.wallet_state_manager.get_spendable_coins_for_wallet(self.id(), records)
         )
         max_send_amount = sum(cr.coin.amount for cr in spendable)
         return max_send_amount
 
-    async def add_parent(self, name: bytes32, parent: Optional[LineageProof]):
+    async def add_parent(self, name: bytes32, parent: LineageProof | None):
         self.log.info(f"Adding parent {name}: {parent}")
         current_list = self.did_info.parent_info.copy()
         current_list.append((name, parent))
@@ -1234,8 +1188,8 @@ class DIDWallet:
         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:

chia/wallet/did_wallet/did_wallet_puzzles.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from collections.abc import Iterator
-from typing import Optional, Union
 
 from chia_puzzles_py.programs import DID_INNERPUZ, DID_INNERPUZ_HASH, NFT_INTERMEDIATE_LAUNCHER
 from chia_rs import CoinSpend, G1Element
@@ -36,12 +35,12 @@ INTERMEDIATE_LAUNCHER_MOD = Program.from_bytes(NFT_INTERMEDIATE_LAUNCHER)
 
 
 def create_innerpuz(
-    p2_puzzle_or_hash: Union[Program, bytes32],
+    p2_puzzle_or_hash: Program | bytes32,
     recovery_list: list[bytes32],
     num_of_backup_ids_needed: uint64,
     launcher_id: bytes32,
     metadata: Program = Program.to([]),
-    recovery_list_hash: Optional[Program] = None,
+    recovery_list_hash: Program | None = None,
 ) -> Program:
     """
     Create DID inner puzzle
@@ -55,7 +54,7 @@ def create_innerpuz(
     Note: Receiving a standard P2 puzzle hash wouldn't calculate a valid puzzle, but
     that can be useful if calling `.get_tree_hash_precalc()` on it.
     """
-    backup_ids_hash: Union[Program, bytes32] = Program.to(recovery_list).get_tree_hash()
+    backup_ids_hash: Program | bytes32 = Program.to(recovery_list).get_tree_hash()
     if recovery_list_hash is not None:
         backup_ids_hash = recovery_list_hash
     singleton_struct = Program.to((SINGLETON_TOP_LAYER_MOD_HASH, (launcher_id, SINGLETON_LAUNCHER_PUZZLE_HASH)))
@@ -69,8 +68,8 @@ def get_inner_puzhash_by_p2(
     num_of_backup_ids_needed: uint64,
     launcher_id: bytes32,
     metadata: Program = Program.to([]),
-    recovery_list: Optional[list[bytes32]] = None,
-    recovery_list_hash: Optional[Program] = None,
+    recovery_list: list[bytes32] | None = None,
+    recovery_list_hash: Program | None = None,
 ) -> bytes32:
     """
     Calculate DID inner puzzle hash based on a P2 puzzle hash
@@ -118,7 +117,7 @@ def is_did_innerpuz(inner_f: Program) -> bool:
     return inner_f == DID_INNERPUZ_MOD
 
 
-def uncurry_innerpuz(puzzle: Program) -> Optional[tuple[Program, Program, Program, Program, Program]]:
+def uncurry_innerpuz(puzzle: Program) -> tuple[Program, Program, Program, Program, Program] | None:
     """
     Uncurry a DID inner puzzle
     :param puzzle: DID puzzle
@@ -172,7 +171,7 @@ def create_spend_for_message(
     return make_spend(coin, puzzle, solution)
 
 
-def match_did_puzzle(mod: Program, curried_args: Program) -> Optional[Iterator[Program]]:
+def match_did_puzzle(mod: Program, curried_args: Program) -> Iterator[Program] | None:
     """
     Given a puzzle test if it's a DID, if it is, return the curried arguments
     :param puzzle: Puzzle

chia/wallet/driver_protocol.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from chia_rs.sized_bytes import bytes32
 from typing_extensions import Protocol
 
@@ -11,15 +9,15 @@ from chia.wallet.uncurried_puzzle import UncurriedPuzzle
 
 
 class DriverProtocol(Protocol):
-    def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]: ...
+    def match(self, puzzle: UncurriedPuzzle) -> PuzzleInfo | None: ...
 
     def get_inner_puzzle(
-        self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle, solution: Optional[Program] = ...
-    ) -> Optional[Program]: ...
+        self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle, solution: Program | None = ...
+    ) -> Program | None: ...
 
-    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Optional[Program]: ...
+    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Program | None: ...
 
-    def asset_id(self, constructor: PuzzleInfo) -> Optional[bytes32]: ...
+    def asset_id(self, constructor: PuzzleInfo) -> bytes32 | None: ...
 
     def construct(self, constructor: PuzzleInfo, inner_puzzle: Program) -> Program: ...
 

chia/wallet/lineage_proof.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
@@ -20,9 +20,9 @@ class LineageProofField(Enum):
 @streamable
 @dataclass(frozen=True)
 class LineageProof(Streamable):
-    parent_name: Optional[bytes32] = None
-    inner_puzzle_hash: Optional[bytes32] = None
-    amount: Optional[uint64] = None
+    parent_name: bytes32 | None = None
+    inner_puzzle_hash: bytes32 | None = None
+    amount: uint64 | None = None
 
     @classmethod
     def from_program(cls, program: Program, fields: list[LineageProofField]) -> LineageProof:

chia/wallet/nft_wallet/metadata_outer_puzzle.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Callable, Optional
 
 from chia_rs.sized_bytes import bytes32
 
@@ -30,13 +30,13 @@ def solution_for_metadata_layer(inner_solution: Program) -> Program:
 
 @dataclass(frozen=True)
 class MetadataOuterPuzzle:
-    _match: Callable[[UncurriedPuzzle], Optional[PuzzleInfo]]
+    _match: Callable[[UncurriedPuzzle], PuzzleInfo | None]
     _construct: Callable[[PuzzleInfo, Program], Program]
     _solve: Callable[[PuzzleInfo, Solver, Program, Program], Program]
-    _get_inner_puzzle: Callable[[PuzzleInfo, UncurriedPuzzle, Optional[Program]], Optional[Program]]
-    _get_inner_solution: Callable[[PuzzleInfo, Program], Optional[Program]]
+    _get_inner_puzzle: Callable[[PuzzleInfo, UncurriedPuzzle, Program | None], Program | None]
+    _get_inner_solution: Callable[[PuzzleInfo, Program], Program | None]
 
-    def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
+    def match(self, puzzle: UncurriedPuzzle) -> PuzzleInfo | None:
         matched, curried_args = match_metadata_layer_puzzle(puzzle)
         if matched:
             _, metadata, updater_hash, inner_puzzle = curried_args
@@ -53,7 +53,7 @@ class MetadataOuterPuzzle:
             return None
         return None  # Uncomment above when match_metadata_layer_puzzle works
 
-    def asset_id(self, constructor: PuzzleInfo) -> Optional[bytes32]:
+    def asset_id(self, constructor: PuzzleInfo) -> bytes32 | None:
         return bytes32(constructor["updater_hash"])
 
     def construct(self, constructor: PuzzleInfo, inner_puzzle: Program) -> Program:
@@ -63,25 +63,25 @@ class MetadataOuterPuzzle:
         return puzzle_for_metadata_layer(constructor["metadata"], constructor["updater_hash"], inner_puzzle)
 
     def get_inner_puzzle(
-        self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle, solution: Optional[Program] = None
-    ) -> Optional[Program]:
+        self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle, solution: Program | None = None
+    ) -> Program | None:
         matched, curried_args = match_metadata_layer_puzzle(puzzle_reveal)
         if matched:
             _, _, _, inner_puzzle = curried_args
             also = constructor.also()
             if also is not None:
-                deep_inner_puzzle: Optional[Program] = self._get_inner_puzzle(also, uncurry_puzzle(inner_puzzle), None)
+                deep_inner_puzzle: Program | None = self._get_inner_puzzle(also, uncurry_puzzle(inner_puzzle), None)
                 return deep_inner_puzzle
             else:
                 return inner_puzzle
         else:
             raise ValueError("This driver is not for the specified puzzle reveal")
 
-    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Optional[Program]:
+    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Program | None:
         my_inner_solution: Program = solution.first()
         also = constructor.also()
         if also:
-            deep_inner_solution: Optional[Program] = self._get_inner_solution(also, my_inner_solution)
+            deep_inner_solution: Program | None = self._get_inner_solution(also, my_inner_solution)
             return deep_inner_solution
         else:
             return my_inner_solution

chia/wallet/nft_wallet/nft_info.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Optional
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint32, uint64
@@ -32,13 +31,13 @@ class NFTInfo(Streamable):
     nft_coin_confirmation_height: uint32
     """Current NFT coin confirmation height"""
 
-    owner_did: Optional[bytes32]
+    owner_did: bytes32 | None
     """Owner DID"""
 
-    royalty_percentage: Optional[uint16]
+    royalty_percentage: uint16 | None
     """Percentage of the transaction fee paid to the author, e.g. 1000 = 1%"""
 
-    royalty_puzzle_hash: Optional[bytes32]
+    royalty_puzzle_hash: bytes32 | None
     """Puzzle hash where royalty will be sent to"""
     data_uris: list[str]
     """ A list of content URIs"""
@@ -82,13 +81,13 @@ class NFTInfo(Streamable):
     pending_transaction: bool = False
     """Indicate if the NFT is pending for a transaction"""
 
-    minter_did: Optional[bytes32] = None
+    minter_did: bytes32 | None = None
     """DID of the NFT minter"""
 
     launcher_puzhash: bytes32 = SINGLETON_LAUNCHER_PUZZLE_HASH
     """Puzzle hash of the singleton launcher in hex"""
 
-    off_chain_metadata: Optional[str] = None
+    off_chain_metadata: str | None = None
     """Serialized off-chain metadata"""
 
 
@@ -101,13 +100,13 @@ class NFTCoinInfo(Streamable):
     """The latest coin of the NFT"""
     coin: Coin
     """NFT lineage proof"""
-    lineage_proof: Optional[LineageProof]
+    lineage_proof: LineageProof | None
     """NFT full puzzle"""
     full_puzzle: Program
     """NFT minting block height"""
     mint_height: uint32
     """The DID of the NFT minter"""
-    minter_did: Optional[bytes32] = None
+    minter_did: bytes32 | None = None
     """The block height of the latest coin"""
     latest_height: uint32 = uint32(0)
     """If the NFT is in the transaction"""
@@ -117,4 +116,4 @@ class NFTCoinInfo(Streamable):
 @streamable
 @dataclass(frozen=True)
 class NFTWalletInfo(Streamable):
-    did_id: Optional[bytes32] = None
+    did_id: bytes32 | None = None