chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/wallet/derive_keys.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import List, Optional, Set, Tuple
+from typing import Optional
 
 from chia_rs import AugSchemeMPL, G1Element, PrivateKey
 
@@ -18,19 +18,19 @@ from chia.util.ints import uint32
 MAX_POOL_WALLETS = 100
 
 
-def _derive_path(sk: PrivateKey, path: List[int]) -> PrivateKey:
+def _derive_path(sk: PrivateKey, path: list[int]) -> PrivateKey:
     for index in path:
         sk = AugSchemeMPL.derive_child_sk(sk, index)
     return sk
 
 
-def _derive_path_unhardened(sk: PrivateKey, path: List[int]) -> PrivateKey:
+def _derive_path_unhardened(sk: PrivateKey, path: list[int]) -> PrivateKey:
     for index in path:
         sk = AugSchemeMPL.derive_child_sk_unhardened(sk, index)
     return sk
 
 
-def _derive_pk_unhardened(pk: G1Element, path: List[int]) -> G1Element:
+def _derive_pk_unhardened(pk: G1Element, path: list[int]) -> G1Element:
     for index in path:
         pk = AugSchemeMPL.derive_child_pk_unhardened(pk, index)
     return pk
@@ -95,7 +95,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) -> Optional[tuple[PrivateKey, uint32]]:
     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 +104,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) -> Optional[PrivateKey]:
     # 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):
@@ -117,8 +117,8 @@ def find_authentication_sk(all_sks: List[PrivateKey], owner_pk: G1Element) -> Op
 
 
 def match_address_to_sk(
-    sk: PrivateKey, addresses_to_search: List[bytes32], max_ph_to_search: int = 500
-) -> Set[bytes32]:
+    sk: PrivateKey, addresses_to_search: list[bytes32], max_ph_to_search: int = 500
+) -> set[bytes32]:
     """
     Checks the list of given address is a derivation of the given sk within the given number of derivations
     Returns a Set of the addresses that are derivations of the given sk
@@ -126,8 +126,8 @@ def match_address_to_sk(
     if sk is None or not addresses_to_search:
         return set()
 
-    found_addresses: Set[bytes32] = set()
-    search_list: Set[bytes32] = set(addresses_to_search)
+    found_addresses: set[bytes32] = set()
+    search_list: set[bytes32] = set(addresses_to_search)
 
     for i in range(max_ph_to_search):
         phs = [
@@ -139,7 +139,7 @@ def match_address_to_sk(
             if address in phs:
                 found_addresses.add(address)
 
-        search_list = search_list - found_addresses
+        search_list -= found_addresses
         if not len(search_list):
             return found_addresses
 

chia/wallet/did_wallet/did_info.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import List, Optional, Tuple
+from typing import Optional
 
 from chia.protocols.wallet_protocol import CoinState
 from chia.types.blockchain_format.coin import Coin
@@ -16,9 +16,9 @@ from chia.wallet.lineage_proof import LineageProof
 @dataclass(frozen=True)
 class DIDInfo(Streamable):
     origin_coin: Optional[Coin]  # Coin ID of this coin is our DID
-    backup_ids: List[bytes32]
+    backup_ids: list[bytes32]
     num_of_backup_ids_needed: uint64
-    parent_info: List[Tuple[bytes32, Optional[LineageProof]]]  # {coin.name(): LineageProof}
+    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]

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, Dict, List, Optional, Set, Tuple, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
 from chia_rs import AugSchemeMPL, G1Element, G2Element
 
@@ -77,12 +77,12 @@ class DIDWallet:
         wallet: Wallet,
         amount: uint64,
         action_scope: WalletActionScope,
-        backups_ids: List[bytes32] = [],
+        backups_ids: list[bytes32] = [],
         num_of_backup_ids_needed: uint64 = None,
-        metadata: Dict[str, str] = {},
+        metadata: dict[str, str] = {},
         name: Optional[str] = None,
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ):
         """
         Create a brand new DID wallet
@@ -142,7 +142,7 @@ class DIDWallet:
         try:
             await self.generate_new_decentralised_id(amount, action_scope, fee, extra_conditions)
         except Exception:
-            await wallet_state_manager.user_store.delete_wallet(self.id())
+            await wallet_state_manager.delete_wallet(self.id())
             raise
 
         await self.wallet_state_manager.add_new_wallet(self)
@@ -208,7 +208,6 @@ class DIDWallet:
         :param name: Wallet name
         :return: DID wallet
         """
-
         self = DIDWallet()
         self.wallet_state_manager = wallet_state_manager
         if name is None:
@@ -226,7 +225,7 @@ class DIDWallet:
         _, recovery_list_hash, num_verification, _, metadata = args
         full_solution: Program = Program.from_bytes(bytes(coin_spend.solution))
         inner_solution: Program = full_solution.rest().rest().first()
-        recovery_list: List[bytes32] = []
+        recovery_list: list[bytes32] = []
         backup_required: int = num_verification.as_int()
         if recovery_list_hash != NIL_TREEHASH:
             try:
@@ -269,7 +268,7 @@ class DIDWallet:
         wallet_state_manager: Any,
         wallet: Wallet,
         wallet_info: WalletInfo,
-        name: str = None,
+        name: Optional[str] = None,
     ):
         """
         Create a DID wallet based on the local database
@@ -317,6 +316,7 @@ class DIDWallet:
 
         for record in unconfirmed_tx:
             our_spend = False
+            # Need to check belonging with hint_dict
             for coin in record.removals:
                 if await self.wallet_state_manager.does_coin_belong_to_wallet(coin, self.id()):
                     our_spend = True
@@ -326,7 +326,14 @@ class DIDWallet:
                 continue
 
             for coin in record.additions:
-                if await self.wallet_state_manager.does_coin_belong_to_wallet(coin, self.id()):
+                hint_dict = {
+                    coin_id: bytes32(memos[0])
+                    for coin_id, memos in record.memos
+                    if len(memos) > 0 and len(memos[0]) == 32
+                }
+                if (await self.wallet_state_manager.does_coin_belong_to_wallet(coin, self.id(), hint_dict)) and (
+                    coin not in record.removals
+                ):
                     addition_amount += coin.amount
 
         return uint64(addition_amount)
@@ -338,7 +345,7 @@ class DIDWallet:
         self,
         amount: uint64,
         action_scope: WalletActionScope,
-    ) -> Set[Coin]:
+    ) -> set[Coin]:
         try:
             async with action_scope.use() as interface:
                 coin = await self.get_coin()
@@ -528,14 +535,14 @@ class DIDWallet:
             return create_singleton_puzzle(innerpuz, self.did_info.origin_coin.name())
         else:
             innerpuz = Program.to((8, 0))
-            return create_singleton_puzzle(innerpuz, bytes32([0] * 32))
+            return create_singleton_puzzle(innerpuz, bytes32.zeros)
 
     def puzzle_hash_for_pk(self, pubkey: G1Element) -> bytes32:
         if self.did_info.origin_coin is None:
             # TODO: this seem dumb. Why bother with this case? Is it ever used?
             # inner puzzle: (8 . 0)
             innerpuz_hash = shatree_pair(shatree_int(8), NIL_TREEHASH)
-            return create_singleton_puzzle_hash(innerpuz_hash, bytes32([0] * 32))
+            return create_singleton_puzzle_hash(innerpuz_hash, bytes32.zeros)
         origin_coin_name = self.did_info.origin_coin.name()
         innerpuz_hash = did_wallet_puzzles.get_inner_puzhash_by_p2(
             p2_puzhash=puzzle_hash_for_pk(pubkey),
@@ -546,11 +553,6 @@ class DIDWallet:
         )
         return create_singleton_puzzle_hash(innerpuz_hash, origin_coin_name)
 
-    async def get_new_puzzle(self) -> Program:
-        return self.puzzle_for_pk(
-            (await self.wallet_state_manager.get_unused_derivation_record(self.wallet_info.id)).pubkey
-        )
-
     def get_my_DID(self) -> str:
         assert self.did_info.origin_coin is not None
         core = self.did_info.origin_coin.name()
@@ -569,12 +571,12 @@ class DIDWallet:
         self,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         assert self.did_info.current_inner is not None
         assert self.did_info.origin_coin is not None
         coin = await self.get_coin()
-        new_inner_puzzle = await self.get_new_did_innerpuz()
+        new_inner_puzzle = await self.get_did_innerpuz(new=not action_scope.config.tx_config.reuse_puzhash)
         uncurried = did_wallet_puzzles.uncurry_innerpuz(new_inner_puzzle)
         assert uncurried is not None
         p2_puzzle = uncurried[0]
@@ -668,7 +670,7 @@ class DIDWallet:
         fee: uint64,
         with_recovery: bool,
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         """
         Transfer the current DID to another owner
@@ -757,7 +759,7 @@ class DIDWallet:
     async def create_message_spend(
         self,
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         assert self.did_info.current_inner is not None
         assert self.did_info.origin_coin is not None
@@ -890,8 +892,8 @@ class DIDWallet:
         newpuz: bytes32,
         pubkey: G1Element,
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
-    ) -> Tuple[WalletSpendBundle, str]:
+        extra_conditions: tuple[Condition, ...] = tuple(),
+    ) -> tuple[WalletSpendBundle, str]:
         """
         Create an attestment
         TODO:
@@ -969,7 +971,7 @@ class DIDWallet:
         attest_str += f"{self.did_info.current_inner.get_tree_hash().hex()}:{coin.amount}"
         return message_spend_bundle, attest_str
 
-    async def get_info_for_recovery(self) -> Optional[Tuple[bytes32, bytes32, uint64]]:
+    async def get_info_for_recovery(self) -> Optional[tuple[bytes32, bytes32, uint64]]:
         assert self.did_info.current_inner is not None
         assert self.did_info.origin_coin is not None
         try:
@@ -981,7 +983,7 @@ class DIDWallet:
         amount = uint64(coin.amount)
         return (parent, innerpuzhash, amount)
 
-    async def load_attest_files_for_recovery_spend(self, attest_data: List[str]) -> Tuple[List, WalletSpendBundle]:
+    async def load_attest_files_for_recovery_spend(self, attest_data: list[str]) -> tuple[list, WalletSpendBundle]:
         spend_bundle_list = []
         info_dict = {}
         for attest in attest_data:
@@ -994,7 +996,7 @@ class DIDWallet:
             new_sb = WalletSpendBundle.from_bytes(bytes.fromhex(info[1]))
             spend_bundle_list.append(new_sb)
         # info_dict {0xidentity: "(0xparent_info 0xinnerpuz amount)"}
-        my_recovery_list: List[bytes32] = self.did_info.backup_ids
+        my_recovery_list: list[bytes32] = self.did_info.backup_ids
 
         # convert info dict into recovery list - same order as wallet
         info_list = []
@@ -1016,7 +1018,7 @@ class DIDWallet:
         self,
         coin: Coin,
         puzhash: bytes32,
-        parent_innerpuzhash_amounts_for_recovery_ids: List[Tuple[bytes, bytes, int]],
+        parent_innerpuzhash_amounts_for_recovery_ids: list[tuple[bytes, bytes, int]],
         pubkey: G1Element,
         spend_bundle: WalletSpendBundle,
         action_scope: WalletActionScope,
@@ -1095,14 +1097,13 @@ class DIDWallet:
         )
         await self.save_info(new_did_info)
 
-    async def get_new_p2_inner_hash(self) -> bytes32:
-        puzzle = await self.get_new_p2_inner_puzzle()
-        return puzzle.get_tree_hash()
+    async def get_p2_inner_hash(self, new: bool) -> bytes32:
+        return await self.standard_wallet.get_puzzle_hash(new=new)
 
-    async def get_new_p2_inner_puzzle(self) -> Program:
-        return await self.standard_wallet.get_new_puzzle()
+    async def get_p2_inner_puzzle(self, new: bool) -> Program:
+        return await self.standard_wallet.get_puzzle(new=new)
 
-    async def get_new_did_innerpuz(self, origin_id: Optional[bytes32] = None) -> Program:
+    async def get_did_innerpuz(self, new: bool, origin_id: Optional[bytes32] = None) -> Program:
         if self.did_info.origin_coin is not None:
             launcher_id = self.did_info.origin_coin.name()
         elif origin_id is not None:
@@ -1110,15 +1111,15 @@ class DIDWallet:
         else:
             raise ValueError("must have origin coin")
         return did_wallet_puzzles.create_innerpuz(
-            p2_puzzle_or_hash=await self.get_new_p2_inner_puzzle(),
+            p2_puzzle_or_hash=await self.get_p2_inner_puzzle(new=new),
             recovery_list=self.did_info.backup_ids,
             num_of_backup_ids_needed=self.did_info.num_of_backup_ids_needed,
             launcher_id=launcher_id,
             metadata=did_wallet_puzzles.metadata_to_program(json.loads(self.did_info.metadata)),
         )
 
-    async def get_new_did_inner_hash(self) -> bytes32:
-        innerpuz = await self.get_new_did_innerpuz()
+    async def get_did_inner_hash(self, new: bool) -> bytes32:
+        innerpuz = await self.get_did_innerpuz(new=new)
         return innerpuz.get_tree_hash()
 
     async def get_innerpuz_for_new_innerhash(self, pubkey: G1Element):
@@ -1174,7 +1175,7 @@ class DIDWallet:
 
         return parent_info
 
-    async def sign_message(self, message: str, mode: SigningMode) -> Tuple[G1Element, G2Element]:
+    async def sign_message(self, message: str, mode: SigningMode) -> tuple[G1Element, G2Element]:
         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)
@@ -1201,7 +1202,7 @@ class DIDWallet:
         amount: uint64,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         """
         This must be called under the wallet state manager lock
@@ -1213,7 +1214,9 @@ class DIDWallet:
         genesis_launcher_puz = SINGLETON_LAUNCHER_PUZZLE
         launcher_coin = Coin(origin.name(), genesis_launcher_puz.get_tree_hash(), amount)
 
-        did_inner: Program = await self.get_new_did_innerpuz(launcher_coin.name())
+        did_inner: Program = await self.get_did_innerpuz(
+            new=not action_scope.config.tx_config.reuse_puzhash, origin_id=launcher_coin.name()
+        )
         did_inner_hash = did_inner.get_tree_hash()
         did_full_puz = create_singleton_puzzle(did_inner, launcher_coin.name())
         did_puzzle_hash = did_full_puz.get_tree_hash()
@@ -1298,7 +1301,7 @@ class DIDWallet:
         coin: Coin,
         full_puzzle: Program,
         innerpuz: Program,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ):
         assert self.did_info.origin_coin is not None
         uncurried = did_wallet_puzzles.uncurry_innerpuz(innerpuz)
@@ -1328,9 +1331,11 @@ class DIDWallet:
         )
         return spendable_am
 
-    async def get_max_send_amount(self, records: Optional[Set[WalletCoinRecord]] = None):
-        max_send_amount = await self.get_confirmed_balance()
-
+    async def get_max_send_amount(self, records: Optional[set[WalletCoinRecord]] = 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]):
@@ -1351,7 +1356,7 @@ class DIDWallet:
         )
         await self.save_info(did_info)
 
-    async def update_recovery_list(self, recover_list: List[bytes32], num_of_backup_ids_needed: uint64) -> bool:
+    async def update_recovery_list(self, recover_list: list[bytes32], num_of_backup_ids_needed: uint64) -> bool:
         if num_of_backup_ids_needed > len(recover_list):
             return False
         did_info = DIDInfo(
@@ -1370,7 +1375,7 @@ class DIDWallet:
         await self.wallet_state_manager.update_wallet_puzzle_hashes(self.wallet_info.id)
         return True
 
-    async def update_metadata(self, metadata: Dict[str, str]) -> bool:
+    async def update_metadata(self, metadata: dict[str, str]) -> bool:
         # validate metadata
         if not all(isinstance(k, str) and isinstance(v, str) for k, v in metadata.items()):
             raise ValueError("Metadata key value pairs must be strings.")
@@ -1441,7 +1446,11 @@ class DIDWallet:
         if num_of_backup_ids_needed > len(backup_ids):
             raise Exception
         innerpuz: Program = Program.from_bytes(bytes.fromhex(details[4]))
-        metadata: str = details[6]
+        metadata: str = ""
+        for d in details[6:]:
+            metadata = metadata + d + ":"
+        if len(metadata) > 0:
+            metadata = metadata[:-1]
         did_info = DIDInfo(
             origin_coin=origin,
             backup_ids=backup_ids,
@@ -1460,7 +1469,7 @@ class DIDWallet:
         return True
 
     async def get_coin(self) -> Coin:
-        spendable_coins: Set[WalletCoinRecord] = await self.wallet_state_manager.get_spendable_coins_for_wallet(
+        spendable_coins: set[WalletCoinRecord] = await self.wallet_state_manager.get_spendable_coins_for_wallet(
             self.wallet_info.id
         )
         if len(spendable_coins) == 0:

chia/wallet/did_wallet/did_wallet_puzzles.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import Dict, Iterator, List, Optional, Tuple, Union
+from collections.abc import Iterator
+from typing import Optional, Union
 
 from chia_rs import G1Element
 
@@ -40,7 +41,7 @@ INTERMEDIATE_LAUNCHER_MOD = load_clvm_maybe_recompile(
 
 def create_innerpuz(
     p2_puzzle_or_hash: Union[Program, bytes32],
-    recovery_list: List[bytes32],
+    recovery_list: list[bytes32],
     num_of_backup_ids_needed: uint64,
     launcher_id: bytes32,
     metadata: Program = Program.to([]),
@@ -69,7 +70,7 @@ def create_innerpuz(
 
 def get_inner_puzhash_by_p2(
     p2_puzhash: bytes32,
-    recovery_list: List[bytes32],
+    recovery_list: list[bytes32],
     num_of_backup_ids_needed: uint64,
     launcher_id: bytes32,
     metadata: Program = Program.to([]),
@@ -111,7 +112,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) -> Optional[tuple[Program, Program, Program, Program, Program]]:
     """
     Uncurry a DID inner puzzle
     :param puzzle: DID puzzle
@@ -196,7 +197,7 @@ def check_is_did_puzzle(puzzle: Program) -> bool:
     return is_singleton(inner_f)
 
 
-def metadata_to_program(metadata: Dict[str, str]) -> Program:
+def metadata_to_program(metadata: dict[str, str]) -> Program:
     """
     Convert the metadata dict to a Chialisp program
     :param metadata: User defined metadata
@@ -208,7 +209,7 @@ def metadata_to_program(metadata: Dict[str, str]) -> Program:
     return Program.to(kv_list)
 
 
-def did_program_to_metadata(program: Program) -> Dict[str, str]:
+def did_program_to_metadata(program: Program) -> dict[str, str]:
     """
     Convert a program to a metadata dict
     :param program: Chialisp program contains the metadata

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, Dict, List, Optional
+from typing import Any, Optional
 
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -24,8 +24,8 @@ class LineageProof(Streamable):
     amount: Optional[uint64] = None
 
     @classmethod
-    def from_program(cls, program: Program, fields: List[LineageProofField]) -> LineageProof:
-        lineage_proof_info: Dict[str, Any] = {}
+    def from_program(cls, program: Program, fields: list[LineageProofField]) -> LineageProof:
+        lineage_proof_info: dict[str, Any] = {}
         field_iter = iter(fields)
         program_iter = program.as_iter()
         for program_value in program_iter:
@@ -45,7 +45,7 @@ class LineageProof(Streamable):
         return LineageProof(**lineage_proof_info)
 
     def to_program(self) -> Program:
-        final_list: List[Any] = []
+        final_list: list[Any] = []
         if self.parent_name is not None:
             final_list.append(self.parent_name)
         if self.inner_puzzle_hash is not None:

chia/wallet/nft_wallet/metadata_outer_puzzle.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Callable, List, Optional, Tuple
+from typing import Callable, Optional
 
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -15,7 +15,7 @@ NFT_STATE_LAYER_MOD = load_clvm_maybe_recompile(
 NFT_STATE_LAYER_MOD_HASH = NFT_STATE_LAYER_MOD.get_tree_hash()
 
 
-def match_metadata_layer_puzzle(puzzle: UncurriedPuzzle) -> Tuple[bool, List[Program]]:
+def match_metadata_layer_puzzle(puzzle: UncurriedPuzzle) -> tuple[bool, list[Program]]:
     if puzzle.mod == NFT_STATE_LAYER_MOD:
         return True, list(puzzle.args.as_iter())
     return False, []

chia/wallet/nft_wallet/nft_info.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Optional
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
@@ -40,19 +40,19 @@ class NFTInfo(Streamable):
 
     royalty_puzzle_hash: Optional[bytes32]
     """Puzzle hash where royalty will be sent to"""
-    data_uris: List[str]
+    data_uris: list[str]
     """ A list of content URIs"""
 
     data_hash: bytes
     """Hash of the content"""
 
-    metadata_uris: List[str]
+    metadata_uris: list[str]
     """A list of metadata URIs"""
 
     metadata_hash: bytes
     """Hash of the metadata"""
 
-    license_uris: List[str]
+    license_uris: list[str]
     """A list of license URIs"""
 
     license_hash: bytes

chia/wallet/nft_wallet/nft_puzzles.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+from typing import Any, Literal, Optional, Union
 
 from clvm_tools.binutils import disassemble
 
@@ -86,7 +86,7 @@ def create_full_puzzle(
     return full_puzzle
 
 
-async def get_nft_info_from_puzzle(nft_coin_info: NFTCoinInfo, config: Dict[str, Any]) -> NFTInfo:
+async def get_nft_info_from_puzzle(nft_coin_info: NFTCoinInfo, config: dict[str, Any]) -> NFTInfo:
     """
     Extract NFT info from a full puzzle
     :param nft_coin_info NFTCoinInfo in local database
@@ -96,15 +96,15 @@ async def get_nft_info_from_puzzle(nft_coin_info: NFTCoinInfo, config: Dict[str,
     """
     uncurried_nft: Optional[UncurriedNFT] = UncurriedNFT.uncurry(*nft_coin_info.full_puzzle.uncurry())
     assert uncurried_nft is not None
-    data_uris: List[str] = []
+    data_uris: list[str] = []
 
-    for uri in uncurried_nft.data_uris.as_python():  # pylint: disable=E1133
+    for uri in uncurried_nft.data_uris.as_python():
         data_uris.append(str(uri, "utf-8"))
-    meta_uris: List[str] = []
-    for uri in uncurried_nft.meta_uris.as_python():  # pylint: disable=E1133
+    meta_uris: list[str] = []
+    for uri in uncurried_nft.meta_uris.as_python():
         meta_uris.append(str(uri, "utf-8"))
-    license_uris: List[str] = []
-    for uri in uncurried_nft.license_uris.as_python():  # pylint: disable=E1133
+    license_uris: list[str] = []
+    for uri in uncurried_nft.license_uris.as_python():
         license_uris.append(str(uri, "utf-8"))
     off_chain_metadata: Optional[str] = None
     nft_info = NFTInfo(
@@ -135,7 +135,7 @@ async def get_nft_info_from_puzzle(nft_coin_info: NFTCoinInfo, config: Dict[str,
     return nft_info
 
 
-def metadata_to_program(metadata: Dict[bytes, Any]) -> Program:
+def metadata_to_program(metadata: dict[bytes, Any]) -> Program:
     """
     Convert the metadata dict to a Chialisp program
     :param metadata: User defined metadata
@@ -148,7 +148,7 @@ def metadata_to_program(metadata: Dict[bytes, Any]) -> Program:
     return program
 
 
-def nft_program_to_metadata(program: Program) -> Dict[bytes, Any]:
+def nft_program_to_metadata(program: Program) -> dict[bytes, Any]:
     """
     Convert a program to a metadata dict
     :param program: Chialisp program contains the metadata
@@ -160,7 +160,7 @@ def nft_program_to_metadata(program: Program) -> Dict[bytes, Any]:
     return metadata
 
 
-def prepend_value(key: bytes, value: Program, metadata: Dict[bytes, Any]) -> None:
+def prepend_value(key: bytes, value: Program, metadata: dict[bytes, Any]) -> None:
     """
     Prepend a value to a list in the metadata
     :param key: Key of the field
@@ -182,7 +182,7 @@ def update_metadata(metadata: Program, update_condition: Program) -> Program:
     :param update_condition: Update metadata conditions
     :return: Updated metadata
     """
-    new_metadata: Dict[bytes, Any] = nft_program_to_metadata(metadata)
+    new_metadata: dict[bytes, Any] = nft_program_to_metadata(metadata)
     uri: Program = update_condition.rest().rest().first()
     prepend_value(uri.first().as_python(), uri.rest(), new_metadata)
     return metadata_to_program(new_metadata)
@@ -223,7 +223,7 @@ def create_ownership_layer_puzzle(
 
 
 def create_ownership_layer_transfer_solution(
-    new_did: bytes, new_did_inner_hash: bytes, trade_prices_list: List[List[int]], new_puzhash: bytes32
+    new_did: bytes, new_did_inner_hash: bytes, trade_prices_list: list[list[int]], new_puzhash: bytes32
 ) -> Program:
     log.debug(
         "Creating a transfer solution with: DID:%s Inner_puzhash:%s trade_price:%s puzhash:%s",
@@ -239,7 +239,7 @@ def create_ownership_layer_transfer_solution(
     return solution
 
 
-def get_metadata_and_phs(unft: UncurriedNFT, solution: SerializedProgram) -> Tuple[Program, bytes32]:
+def get_metadata_and_phs(unft: UncurriedNFT, solution: SerializedProgram) -> tuple[Program, bytes32]:
     conditions = unft.p2_puzzle.run(unft.get_innermost_solution(solution.to_program()))
     metadata = unft.metadata
     puzhash_for_derivation: Optional[bytes32] = None
@@ -291,9 +291,9 @@ def recurry_nft_puzzle(unft: UncurriedNFT, solution: Program, new_inner_puzzle:
     return new_ownership_puzzle
 
 
-def get_new_owner_did(unft: UncurriedNFT, solution: Program) -> Union[None, Literal[b""], bytes32]:
+def get_new_owner_did(unft: UncurriedNFT, solution: Program) -> Union[Literal[b""], bytes32, None]:
     conditions = unft.p2_puzzle.run(unft.get_innermost_solution(solution))
-    new_did_id: Union[None, Literal[b""], bytes32] = None
+    new_did_id: Union[Literal[b""], bytes32, None] = None
     for condition in conditions.as_iter():
         if condition.first().as_int() == -10:
             # this is the change owner magic condition