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

chia/wallet/transaction_record.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
+import builtins
 from dataclasses import dataclass
-from typing import Any, Dict, Generic, List, Optional, Tuple, Type, TypeVar
+from typing import Any, Generic, Optional, TypeVar
+
+from chia_rs import SpendBundle
 
 from chia.consensus.coinbase import farmer_parent_id, pool_parent_id
 from chia.types.blockchain_format.coin import Coin
@@ -24,7 +27,7 @@ minimum_send_attempts = 6
 @dataclass
 class ItemAndTransactionRecords(Generic[T]):
     item: T
-    transaction_records: List[TransactionRecord]
+    transaction_records: list[TransactionRecord]
 
 
 @streamable
@@ -42,31 +45,31 @@ class TransactionRecordOld(Streamable):
     confirmed: bool
     sent: uint32
     spend_bundle: Optional[WalletSpendBundle]
-    additions: List[Coin]
-    removals: List[Coin]
+    additions: list[Coin]
+    removals: list[Coin]
     wallet_id: uint32
 
     # Represents the list of peers that we sent the transaction to, whether each one
     # included it in the mempool, and what the error message (if any) was
-    sent_to: List[Tuple[str, uint8, Optional[str]]]
+    sent_to: list[tuple[str, uint8, Optional[str]]]
     trade_id: Optional[bytes32]
     type: uint32  # TransactionType
 
     # name is also called bundle_id and tx_id
     name: bytes32
-    memos: List[Tuple[bytes32, List[bytes]]]
+    memos: list[tuple[bytes32, list[bytes]]]
 
     def is_in_mempool(self) -> bool:
         # If one of the nodes we sent it to responded with success or pending, we return True
         for _, mis, _ in self.sent_to:
-            if MempoolInclusionStatus(mis) in (MempoolInclusionStatus.SUCCESS, MempoolInclusionStatus.PENDING):
+            if MempoolInclusionStatus(mis) in {MempoolInclusionStatus.SUCCESS, MempoolInclusionStatus.PENDING}:
                 return True
         return False
 
     def height_farmed(self, genesis_challenge: bytes32) -> Optional[uint32]:
         if not self.confirmed:
             return None
-        if self.type == TransactionType.FEE_REWARD or self.type == TransactionType.COINBASE_REWARD:
+        if self.type in {TransactionType.FEE_REWARD, TransactionType.COINBASE_REWARD}:
             for block_index in range(self.confirmed_at_height, self.confirmed_at_height - 100, -1):
                 if block_index < 0:
                     return None
@@ -78,19 +81,21 @@ class TransactionRecordOld(Streamable):
                     return uint32(block_index)
         return None
 
-    def get_memos(self) -> Dict[bytes32, List[bytes]]:
+    def get_memos(self) -> dict[bytes32, list[bytes]]:
         return {coin_id: ms for coin_id, ms in self.memos}
 
     @classmethod
-    def from_json_dict_convenience(cls: Type[_T_TransactionRecord], modified_tx_input: Dict) -> _T_TransactionRecord:
+    def from_json_dict_convenience(
+        cls: builtins.type[_T_TransactionRecord], modified_tx_input: dict
+    ) -> _T_TransactionRecord:
         modified_tx = modified_tx_input.copy()
         if "to_address" in modified_tx:
             modified_tx["to_puzzle_hash"] = decode_puzzle_hash(modified_tx["to_address"]).hex()
         if "to_address" in modified_tx:
             del modified_tx["to_address"]
         # Converts memos from a flat dict into a nested list
-        memos_dict: Dict[str, List[str]] = {}
-        memos_list: List = []
+        memos_dict: dict[str, list[str]] = {}
+        memos_list: list = []
         if "memos" in modified_tx:
             for coin_id, memo in modified_tx["memos"].items():
                 if coin_id not in memos_dict:
@@ -102,13 +107,13 @@ class TransactionRecordOld(Streamable):
         return cls.from_json_dict(modified_tx)
 
     @classmethod
-    def from_json_dict(cls: Type[_T_TransactionRecord], json_dict: Dict[str, Any]) -> _T_TransactionRecord:
+    def from_json_dict(cls: builtins.type[_T_TransactionRecord], json_dict: dict[str, Any]) -> _T_TransactionRecord:
         try:
             return super().from_json_dict(json_dict)
         except Exception:
             return cls.from_json_dict_convenience(json_dict)
 
-    def to_json_dict_convenience(self, config: Dict) -> Dict:
+    def to_json_dict_convenience(self, config: dict) -> dict:
         selected = config["selected_network"]
         prefix = config["network_overrides"]["config"][selected]["address_prefix"]
         formatted = self.to_json_dict()
@@ -128,12 +133,12 @@ class TransactionRecordOld(Streamable):
         if any(x[1] == MempoolInclusionStatus.SUCCESS for x in self.sent_to):
             # we managed to push it to mempool at least once
             return True
-        if any(x[2] in (Err.INVALID_FEE_LOW_FEE.name, Err.INVALID_FEE_TOO_CLOSE_TO_ZERO.name) for x in self.sent_to):
+        if any(x[2] in {Err.INVALID_FEE_LOW_FEE.name, Err.INVALID_FEE_TOO_CLOSE_TO_ZERO.name} for x in self.sent_to):
             # we tried to push it to mempool and got a fee error so it's a temporary error
             return True
         return False
 
-    def hint_dict(self) -> Dict[bytes32, bytes32]:
+    def hint_dict(self) -> dict[bytes32, bytes32]:
         return {coin_id: bytes32(memos[0]) for coin_id, memos in self.memos if len(memos) > 0 and len(memos[0]) == 32}
 
 
@@ -141,3 +146,13 @@ class TransactionRecordOld(Streamable):
 @dataclass(frozen=True)
 class TransactionRecord(TransactionRecordOld):
     valid_times: ConditionValidTimes
+
+
+@streamable
+@dataclass(frozen=True)
+class LightTransactionRecord(Streamable):
+    name: bytes32
+    type: uint32
+    additions: list[Coin]
+    removals: list[Coin]
+    spend_bundle: Optional[SpendBundle]

chia/wallet/util/address_type.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Any, Dict, Set
+from typing import Any
 
 from chia.util.bech32m import bech32_decode, convertbits
 from chia.util.config import selected_network_address_prefix
@@ -12,7 +12,7 @@ class AddressType(Enum):
     NFT = "nft"
     DID = "did:chia:"
 
-    def hrp(self, config: Dict[str, Any]) -> str:
+    def hrp(self, config: dict[str, Any]) -> str:
         if self == AddressType.XCH:
             # Special case to map XCH to the current network's address prefix
             return selected_network_address_prefix(config)
@@ -24,7 +24,7 @@ class AddressType(Enum):
         return 32
 
 
-def is_valid_address(address: str, allowed_types: Set[AddressType], config: Dict[str, Any]) -> bool:
+def is_valid_address(address: str, allowed_types: set[AddressType], config: dict[str, Any]) -> bool:
     try:
         ensure_valid_address(address, allowed_types=allowed_types, config=config)
         return True
@@ -32,7 +32,7 @@ def is_valid_address(address: str, allowed_types: Set[AddressType], config: Dict
         return False
 
 
-def ensure_valid_address(address: str, *, allowed_types: Set[AddressType], config: Dict[str, Any]) -> str:
+def ensure_valid_address(address: str, *, allowed_types: set[AddressType], config: dict[str, Any]) -> str:
     hrp, b32data = bech32_decode(address)
     if not b32data or not hrp:
         raise ValueError(f"Invalid address: {address}")

chia/wallet/util/blind_signer_tl.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import List
 
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.ints import uint64
@@ -18,9 +17,6 @@ from chia.wallet.signer_protocol import (
 )
 from chia.wallet.util.clvm_streamable import TranslationLayer, TranslationLayerMapping, clvm_streamable
 
-# Pylint doesn't understand that these classes are in fact dataclasses
-# pylint: disable=invalid-field-call
-
 
 @clvm_streamable
 @dataclass(frozen=True)
@@ -41,7 +37,7 @@ class BSTLSigningTarget(Streamable):
 @clvm_streamable
 @dataclass(frozen=True)
 class BSTLSumHint(Streamable):
-    fingerprints: List[bytes] = field(metadata=dict(key="f"))
+    fingerprints: list[bytes] = field(metadata=dict(key="f"))
     synthetic_offset: bytes = field(metadata=dict(key="o"))
     final_pubkey: bytes = field(metadata=dict(key="p"))
 
@@ -58,7 +54,7 @@ class BSTLSumHint(Streamable):
 @dataclass(frozen=True)
 class BSTLPathHint(Streamable):
     root_fingerprint: bytes = field(metadata=dict(key="f"))
-    path: List[uint64] = field(metadata=dict(key="p"))
+    path: list[uint64] = field(metadata=dict(key="p"))
 
     @staticmethod
     def from_wallet_api(_from: PathHint) -> BSTLPathHint:
@@ -72,9 +68,9 @@ class BSTLPathHint(Streamable):
 @clvm_streamable
 @dataclass(frozen=True)
 class BSTLSigningInstructions(Streamable):
-    sum_hints: List[BSTLSumHint] = field(metadata=dict(key="s"))
-    path_hints: List[BSTLPathHint] = field(metadata=dict(key="p"))
-    targets: List[BSTLSigningTarget] = field(metadata=dict(key="t"))
+    sum_hints: list[BSTLSumHint] = field(metadata=dict(key="s"))
+    path_hints: list[BSTLPathHint] = field(metadata=dict(key="p"))
+    targets: list[BSTLSigningTarget] = field(metadata=dict(key="t"))
 
     @staticmethod
     def from_wallet_api(_from: SigningInstructions) -> BSTLSigningInstructions:
@@ -98,9 +94,9 @@ class BSTLSigningInstructions(Streamable):
 @clvm_streamable
 @dataclass(frozen=True)
 class BSTLUnsignedTransaction(Streamable):
-    sum_hints: List[BSTLSumHint] = field(metadata=dict(key="s"))
-    path_hints: List[BSTLPathHint] = field(metadata=dict(key="p"))
-    targets: List[BSTLSigningTarget] = field(metadata=dict(key="t"))
+    sum_hints: list[BSTLSumHint] = field(metadata=dict(key="s"))
+    path_hints: list[BSTLPathHint] = field(metadata=dict(key="p"))
+    targets: list[BSTLSigningTarget] = field(metadata=dict(key="t"))
 
     @staticmethod
     def from_wallet_api(_from: UnsignedTransaction) -> BSTLUnsignedTransaction:

chia/wallet/util/clvm_streamable.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import dataclasses
 import functools
 from types import MappingProxyType
-from typing import Any, Callable, Dict, Generic, List, Optional, Type, TypeVar, Union, get_args, get_type_hints
+from typing import Any, Callable, Generic, Optional, TypeVar, Union, get_args, get_type_hints
 
 from hsms.clvm_serde import from_program_for_type, to_program_for_type
 from typing_extensions import TypeGuard
@@ -22,8 +22,8 @@ from chia.util.streamable import (
 _T_Streamable = TypeVar("_T_Streamable", bound=Streamable)
 
 
-def clvm_streamable(cls: Type[Streamable]) -> Type[Streamable]:
-    wrapped_cls: Type[Streamable] = streamable(cls)
+def clvm_streamable(cls: type[Streamable]) -> type[Streamable]:
+    wrapped_cls: type[Streamable] = streamable(cls)
     setattr(wrapped_cls, "_clvm_streamable", True)
 
     hints = get_type_hints(cls)
@@ -55,10 +55,10 @@ def byte_serialize_clvm_streamable(
 
 def json_serialize_with_clvm_streamable(
     streamable: object,
-    next_recursion_step: Optional[Callable[..., Dict[str, Any]]] = None,
+    next_recursion_step: Optional[Callable[..., dict[str, Any]]] = None,
     translation_layer: Optional[TranslationLayer] = None,
     **next_recursion_env: Any,
-) -> Union[str, Dict[str, Any]]:
+) -> Union[str, dict[str, Any]]:
     if next_recursion_step is None:
         next_recursion_step = recurse_jsonify
     if is_clvm_streamable(streamable):
@@ -71,9 +71,9 @@ def json_serialize_with_clvm_streamable(
 
 
 def program_deserialize_clvm_streamable(
-    program: Program, clvm_streamable_type: Type[_T_Streamable], translation_layer: Optional[TranslationLayer] = None
+    program: Program, clvm_streamable_type: type[_T_Streamable], translation_layer: Optional[TranslationLayer] = None
 ) -> _T_Streamable:
-    type_to_deserialize_from: Type[Streamable] = clvm_streamable_type
+    type_to_deserialize_from: type[Streamable] = clvm_streamable_type
     if translation_layer is not None:
         mapping = translation_layer.get_mapping(clvm_streamable_type)
         if mapping is not None:
@@ -87,7 +87,7 @@ def program_deserialize_clvm_streamable(
 
 
 def byte_deserialize_clvm_streamable(
-    blob: bytes, clvm_streamable_type: Type[_T_Streamable], translation_layer: Optional[TranslationLayer] = None
+    blob: bytes, clvm_streamable_type: type[_T_Streamable], translation_layer: Optional[TranslationLayer] = None
 ) -> _T_Streamable:
     return program_deserialize_clvm_streamable(
         Program.from_bytes(blob), clvm_streamable_type, translation_layer=translation_layer
@@ -100,7 +100,7 @@ def is_compound_type(typ: Any) -> bool:
 
 # TODO: this is more than _just_ a Streamable, but it is also a Streamable and that's
 #       useful for now
-def is_clvm_streamable_type(v: Type[object]) -> TypeGuard[Type[Streamable]]:
+def is_clvm_streamable_type(v: type[object]) -> TypeGuard[type[Streamable]]:
     return issubclass(v, Streamable) and hasattr(v, "_clvm_streamable")
 
 
@@ -111,8 +111,8 @@ def is_clvm_streamable(v: object) -> TypeGuard[Streamable]:
 
 
 def json_deserialize_with_clvm_streamable(
-    json_dict: Union[str, Dict[str, Any]],
-    streamable_type: Type[_T_Streamable],
+    json_dict: Union[str, dict[str, Any]],
+    streamable_type: type[_T_Streamable],
     translation_layer: Optional[TranslationLayer] = None,
 ) -> _T_Streamable:
     if isinstance(json_dict, str):
@@ -165,18 +165,18 @@ _T_TLClvmStreamable = TypeVar("_T_TLClvmStreamable", bound="Streamable")
 
 @dataclasses.dataclass(frozen=True)
 class TranslationLayerMapping(Generic[_T_ClvmStreamable, _T_TLClvmStreamable]):
-    from_type: Type[_T_ClvmStreamable]
-    to_type: Type[_T_TLClvmStreamable]
+    from_type: type[_T_ClvmStreamable]
+    to_type: type[_T_TLClvmStreamable]
     serialize_function: Callable[[_T_ClvmStreamable], _T_TLClvmStreamable]
     deserialize_function: Callable[[_T_TLClvmStreamable], _T_ClvmStreamable]
 
 
 @dataclasses.dataclass(frozen=True)
 class TranslationLayer:
-    type_mappings: List[TranslationLayerMapping[Any, Any]]
+    type_mappings: list[TranslationLayerMapping[Any, Any]]
 
     def get_mapping(
-        self, _type: Type[_T_ClvmStreamable]
+        self, _type: type[_T_ClvmStreamable]
     ) -> Optional[TranslationLayerMapping[_T_ClvmStreamable, Streamable]]:
         mappings = [m for m in self.type_mappings if m.from_type == _type]
         if len(mappings) == 1:

chia/wallet/util/compute_hints.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Dict, Optional, Tuple
+from typing import Optional
 
 from chia.consensus.condition_costs import ConditionCost
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
@@ -24,16 +24,16 @@ def compute_spend_hints_and_additions(
     cs: CoinSpend,
     *,
     max_cost: int = DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
-) -> Tuple[Dict[bytes32, HintedCoin], int]:
+) -> tuple[dict[bytes32, HintedCoin], int]:
     cost, result_program = cs.puzzle_reveal.run_with_cost(max_cost, cs.solution)
 
-    hinted_coins: Dict[bytes32, HintedCoin] = {}
+    hinted_coins: dict[bytes32, HintedCoin] = {}
     for condition in result_program.as_iter():
         if cost > max_cost:
             raise ValidationError(Err.BLOCK_COST_EXCEEDS_MAX, "compute_spend_hints_and_additions() for CoinSpend")
         atoms = condition.as_iter()
         op = next(atoms).atom
-        if op in [
+        if op in {
             ConditionOpcode.AGG_SIG_PARENT,
             ConditionOpcode.AGG_SIG_PUZZLE,
             ConditionOpcode.AGG_SIG_AMOUNT,
@@ -42,7 +42,7 @@ def compute_spend_hints_and_additions(
             ConditionOpcode.AGG_SIG_PARENT_PUZZLE,
             ConditionOpcode.AGG_SIG_UNSAFE,
             ConditionOpcode.AGG_SIG_ME,
-        ]:
+        }:
             cost += ConditionCost.AGG_SIG.value
             continue
         if op != ConditionOpcode.CREATE_COIN.value:

chia/wallet/util/compute_memos.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Dict, List
-
 from clvm.casts import int_from_bytes
 
 from chia.types.blockchain_format.coin import Coin
@@ -13,9 +11,9 @@ from chia.util.ints import uint64
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 
-def compute_memos_for_spend(coin_spend: CoinSpend) -> Dict[bytes32, List[bytes]]:
+def compute_memos_for_spend(coin_spend: CoinSpend) -> dict[bytes32, list[bytes]]:
     _, result = coin_spend.puzzle_reveal.run_with_cost(INFINITE_COST, coin_spend.solution)
-    memos: Dict[bytes32, List[bytes]] = {}
+    memos: dict[bytes32, list[bytes]] = {}
     for condition in result.as_python():
         if condition[0] == ConditionOpcode.CREATE_COIN and len(condition) >= 4:
             # If only 3 elements (opcode + 2 args), there is no memo, this is ph, amount
@@ -27,13 +25,13 @@ def compute_memos_for_spend(coin_spend: CoinSpend) -> Dict[bytes32, List[bytes]]
     return memos
 
 
-def compute_memos(bundle: WalletSpendBundle) -> Dict[bytes32, List[bytes]]:
+def compute_memos(bundle: WalletSpendBundle) -> dict[bytes32, list[bytes]]:
     """
     Retrieves the memos for additions in this spend_bundle, which are formatted as a list in the 3rd parameter of
     CREATE_COIN. If there are no memos, the addition coin_id is not included. If they are not formatted as a list
     of bytes, they are not included. This is expensive to call, it should not be used in full node code.
     """
-    memos: Dict[bytes32, List[bytes]] = {}
+    memos: dict[bytes32, list[bytes]] = {}
     for coin_spend in bundle.coin_spends:
         spend_memos = compute_memos_for_spend(coin_spend)
         for coin_name, coin_memos in spend_memos.items():

chia/wallet/util/curry_and_treehash.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Sequence
 from hashlib import sha256
-from typing import Callable, List, Sequence
+from typing import Callable
 
 from clvm.casts import int_to_bytes
 
@@ -56,7 +57,7 @@ def shatree_int(val: int) -> bytes32:
 # `1` if R is 0
 
 
-def curried_values_tree_hash(arguments: List[bytes32]) -> bytes32:
+def curried_values_tree_hash(arguments: list[bytes32]) -> bytes32:
     if len(arguments) == 0:
         return ONE_TREEHASH
 

chia/wallet/util/debug_spend_bundle.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import List
-
 from chia_rs import AugSchemeMPL
 from clvm.operators import KEYWORD_FROM_ATOM
 from clvm_tools.binutils import disassemble as bu_disassemble
@@ -14,7 +12,7 @@ from chia.util.condition_tools import conditions_dict_for_solution, pkm_pairs_fo
 from chia.util.hash import std_hash
 from chia.wallet.uncurried_puzzle import UncurriedPuzzle
 
-CONDITIONS = {k: bytes(v)[0] for k, v in ConditionOpcode.__members__.items()}  # pylint: disable=E1101
+CONDITIONS = {opcode.name: opcode.value[0] for opcode in ConditionOpcode}
 KFA = {v: k for k, v in CONDITIONS.items()}
 
 
@@ -76,9 +74,9 @@ def debug_spend_bundle(spend_bundle, agg_sig_additional_data=DEFAULT_CONSTANTS.A
     pks = []
     msgs = []
 
-    created_coin_announcements: List[List[bytes]] = []
+    created_coin_announcements: list[list[bytes]] = []
     asserted_coin_announcements = []
-    created_puzzle_announcements: List[List[bytes]] = []
+    created_puzzle_announcements: list[list[bytes]] = []
     asserted_puzzle_announcements = []
 
     print("=" * 80)
@@ -110,7 +108,7 @@ def debug_spend_bundle(spend_bundle, agg_sig_additional_data=DEFAULT_CONSTANTS.A
             pks.append(pk)
             msgs.append(m)
         print()
-        cost, r = puzzle_reveal.run_with_cost(INFINITE_COST, solution)
+        _cost, r = puzzle_reveal.run_with_cost(INFINITE_COST, solution)
         print(disassemble(r))
         create_coin_conditions = [con for con in r.as_iter() if con.first().as_int() == 51]
         print()
@@ -141,13 +139,13 @@ def debug_spend_bundle(spend_bundle, agg_sig_additional_data=DEFAULT_CONSTANTS.A
 
                     print(f"  {disassemble(as_prog)}")
             created_coin_announcements.extend(
-                [coin_name] + _.vars for _ in conditions.get(ConditionOpcode.CREATE_COIN_ANNOUNCEMENT, [])
+                [coin_name, *_.vars] for _ in conditions.get(ConditionOpcode.CREATE_COIN_ANNOUNCEMENT, [])
             )
             asserted_coin_announcements.extend(
                 [_.vars[0].hex() for _ in conditions.get(ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT, [])]
             )
             created_puzzle_announcements.extend(
-                [puzzle_reveal.get_tree_hash()] + _.vars
+                [puzzle_reveal.get_tree_hash(), *_.vars]
                 for _ in conditions.get(ConditionOpcode.CREATE_PUZZLE_ANNOUNCEMENT, [])
             )
             asserted_puzzle_announcements.extend(

chia/wallet/util/merkle_tree.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import math
 from enum import Enum
-from typing import List, Optional, Tuple
+from typing import Optional
 
 from clvm.casts import int_to_bytes
 
@@ -28,13 +28,13 @@ class TreeType(Enum):
 
 class MerkleTree:
     type: TreeType
-    nodes: List[bytes32]
+    nodes: list[bytes32]
 
-    def __init__(self, nodes: List[bytes32], waterfall: bool = False) -> None:
+    def __init__(self, nodes: list[bytes32], waterfall: bool = False) -> None:
         self.type = TreeType.WATERFALL if waterfall else TreeType.TREE
         self.nodes = nodes
 
-    def split_list(self, puzzle_hashes: List[bytes32]) -> Tuple[List[bytes32], List[bytes32]]:
+    def split_list(self, puzzle_hashes: list[bytes32]) -> tuple[list[bytes32], list[bytes32]]:
         if self.type == TreeType.TREE:
             mid_index = math.ceil(len(puzzle_hashes) / 2)
             first = puzzle_hashes[0:mid_index]
@@ -45,7 +45,7 @@ class MerkleTree:
 
         return first, rest
 
-    def _root(self, puzzle_hashes: List[bytes32]) -> bytes32:
+    def _root(self, puzzle_hashes: list[bytes32]) -> bytes32:
         if len(puzzle_hashes) == 1:
             return hash_an_atom(puzzle_hashes[0])
         else:
@@ -56,8 +56,8 @@ class MerkleTree:
         return self._root(self.nodes)
 
     def _proof(
-        self, puzzle_hashes: List[bytes32], searching_for: bytes32
-    ) -> Tuple[Optional[int], Optional[List[bytes32]], bytes32, Optional[int]]:
+        self, puzzle_hashes: list[bytes32], searching_for: bytes32
+    ) -> tuple[Optional[int], Optional[list[bytes32]], bytes32, Optional[int]]:
         if len(puzzle_hashes) == 1:
             atom_hash = hash_an_atom(puzzle_hashes[0])
             if puzzle_hashes[0] == searching_for:
@@ -76,14 +76,14 @@ class MerkleTree:
             if first_hash[0] is not None:
                 final_list = first_hash[1]
                 # TODO: handle hints
-                #       error: Item "None" of "Optional[List[bytes32]]" has no attribute "append"  [union-attr]
+                #       error: Item "None" of "Optional[list[bytes32]]" has no attribute "append"  [union-attr]
                 final_list.append(rest_hash[2])  # type: ignore[union-attr]
                 bit_num = first_hash[3]
                 final_path = first_hash[0]
             elif rest_hash[0] is not None:
                 final_list = rest_hash[1]
                 # TODO: handle hints
-                #       error: Item "None" of "Optional[List[bytes32]]" has no attribute "append"  [union-attr]
+                #       error: Item "None" of "Optional[list[bytes32]]" has no attribute "append"  [union-attr]
                 final_list.append(first_hash[2])  # type: ignore[union-attr]
                 bit_num = rest_hash[3]
                 # TODO: handle hints
@@ -95,6 +95,6 @@ class MerkleTree:
 
             return (final_path, final_list, pair_hash, bit_num + 1 if bit_num is not None else None)
 
-    def generate_proof(self, leaf_reveal: bytes32) -> Tuple[Optional[int], List[Optional[List[bytes32]]]]:
+    def generate_proof(self, leaf_reveal: bytes32) -> tuple[Optional[int], list[Optional[list[bytes32]]]]:
         proof = self._proof(self.nodes, leaf_reveal)
         return (proof[0], [proof[1]])

chia/wallet/util/merkle_utils.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 import hashlib
-from typing import Any, Dict, List, Tuple
+from typing import Any
 
 from chia.types.blockchain_format.sized_bytes import bytes32
 
-TupleTree = Any  # Union[bytes32, Tuple["TupleTree", "TupleTree"]]
-Proof_Tree_Type = Any  # Union[bytes32, Tuple[bytes32, "Proof_Tree_Type"]]
+TupleTree = Any  # Union[bytes32, tuple["TupleTree", "TupleTree"]]
+Proof_Tree_Type = Any  # Union[bytes32, tuple[bytes32, "Proof_Tree_Type"]]
 
 
 HASH_TREE_PREFIX = bytes([2])
@@ -24,7 +24,7 @@ def sha256(*args: bytes) -> bytes32:
     return bytes32(hashlib.sha256(b"".join(args)).digest())
 
 
-def build_merkle_tree_from_binary_tree(tuples: TupleTree) -> Tuple[bytes32, Dict[bytes32, Tuple[int, List[bytes32]]]]:
+def build_merkle_tree_from_binary_tree(tuples: TupleTree) -> tuple[bytes32, dict[bytes32, tuple[int, list[bytes32]]]]:
     if isinstance(tuples, bytes):
         tuples = bytes32(tuples)
         return sha256(HASH_LEAF_PREFIX, tuples), {tuples: (0, [])}
@@ -45,7 +45,7 @@ def build_merkle_tree_from_binary_tree(tuples: TupleTree) -> Tuple[bytes32, Dict
     return new_root, new_proofs
 
 
-def list_to_binary_tree(objects: List[Any]) -> Any:
+def list_to_binary_tree(objects: list[Any]) -> Any:
     size = len(objects)
     if size == 0:
         raise ValueError("Cannot build a tree out of 0 objects")
@@ -57,7 +57,7 @@ def list_to_binary_tree(objects: List[Any]) -> Any:
     return (list_to_binary_tree(first_half), list_to_binary_tree(last_half))
 
 
-def build_merkle_tree(objects: List[bytes32]) -> Tuple[bytes32, Dict[bytes32, Tuple[int, List[bytes32]]]]:
+def build_merkle_tree(objects: list[bytes32]) -> tuple[bytes32, dict[bytes32, tuple[int, list[bytes32]]]]:
     """
     return (merkle_root, dict_of_proofs)
     """
@@ -65,7 +65,7 @@ def build_merkle_tree(objects: List[bytes32]) -> Tuple[bytes32, Dict[bytes32, Tu
     return build_merkle_tree_from_binary_tree(objects_binary_tree)
 
 
-def merkle_proof_from_path_and_tree(node_path: int, proof_tree: Proof_Tree_Type) -> Tuple[int, List[bytes32]]:
+def merkle_proof_from_path_and_tree(node_path: int, proof_tree: Proof_Tree_Type) -> tuple[int, list[bytes32]]:
     proof_path = 0
     proof = []
     while not isinstance(proof_tree, bytes32):
@@ -82,7 +82,7 @@ def merkle_proof_from_path_and_tree(node_path: int, proof_tree: Proof_Tree_Type)
     return proof_path, proof
 
 
-def _simplify_merkle_proof(tree_hash: bytes32, proof: Tuple[int, List[bytes32]]) -> bytes32:
+def _simplify_merkle_proof(tree_hash: bytes32, proof: tuple[int, list[bytes32]]) -> bytes32:
     # we return the expected merkle root
     path, nodes = proof
     for node in nodes:
@@ -94,9 +94,9 @@ def _simplify_merkle_proof(tree_hash: bytes32, proof: Tuple[int, List[bytes32]])
     return tree_hash
 
 
-def simplify_merkle_proof(tree_hash: bytes32, proof: Tuple[int, List[bytes32]]) -> bytes32:
+def simplify_merkle_proof(tree_hash: bytes32, proof: tuple[int, list[bytes32]]) -> bytes32:
     return _simplify_merkle_proof(sha256(HASH_LEAF_PREFIX, tree_hash), proof)
 
 
-def check_merkle_proof(merkle_root: bytes32, tree_hash: bytes32, proof: Tuple[int, List[bytes32]]) -> bool:
+def check_merkle_proof(merkle_root: bytes32, tree_hash: bytes32, proof: tuple[int, list[bytes32]]) -> bool:
     return merkle_root == simplify_merkle_proof(tree_hash, proof)

chia/wallet/util/new_peak_queue.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import dataclasses
 from enum import IntEnum
-from typing import Any, List
+from typing import Any
 
 from chia.protocols.wallet_protocol import CoinStateUpdate, NewPeakWallet
 from chia.server.ws_connection import WSChiaConnection
@@ -57,11 +57,11 @@ class NewPeakQueue:
         self._inner_queue: asyncio.PriorityQueue = inner_queue
         self._pending_data_process_items: int = 0
 
-    async def subscribe_to_coin_ids(self, coin_ids: List[bytes32]):
+    async def subscribe_to_coin_ids(self, coin_ids: list[bytes32]):
         self._pending_data_process_items += 1
         await self._inner_queue.put(NewPeakItem(NewPeakQueueTypes.COIN_ID_SUBSCRIPTION, coin_ids))
 
-    async def subscribe_to_puzzle_hashes(self, puzzle_hashes: List[bytes32]):
+    async def subscribe_to_puzzle_hashes(self, puzzle_hashes: list[bytes32]):
         self._pending_data_process_items += 1
         await self._inner_queue.put(NewPeakItem(NewPeakQueueTypes.PUZZLE_HASH_SUBSCRIPTION, puzzle_hashes))