chia-blockchain 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

chia/wallet/vc_wallet/vc_wallet.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 import time
 import traceback
-from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, Type, TypeVar, Union
+from typing import TYPE_CHECKING, Optional, TypeVar, Union
 
 from chia_rs import G1Element, G2Element
 from clvm.casts import int_to_bytes
@@ -63,7 +63,7 @@ class VCWallet:
 
     @classmethod
     async def create_new_vc_wallet(
-        cls: Type[_T_VCWallet],
+        cls: type[_T_VCWallet],
         wallet_state_manager: WalletStateManager,
         wallet: Wallet,
         name: Optional[str] = None,
@@ -80,7 +80,7 @@ class VCWallet:
 
     @classmethod
     async def create(
-        cls: Type[_T_VCWallet],
+        cls: type[_T_VCWallet],
         wallet_state_manager: WalletStateManager,
         wallet: Wallet,
         wallet_info: WalletInfo,
@@ -110,7 +110,7 @@ class VCWallet:
         """
         # TODO Use coin_data instead of calling peer API
         wallet_node = self.wallet_state_manager.wallet_node
-        coin_states: Optional[List[CoinState]] = await wallet_node.get_coin_state([coin.parent_coin_info], peer=peer)
+        coin_states: Optional[list[CoinState]] = await wallet_node.get_coin_state([coin.parent_coin_info], peer=peer)
         if coin_states is None:
             self.log.error(
                 f"Cannot find parent coin of the verified credential coin: {coin.name().hex()}"
@@ -165,7 +165,7 @@ class VCWallet:
         action_scope: WalletActionScope,
         inner_puzzle_hash: Optional[bytes32] = None,
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> VCRecord:
         """
         Given the DID ID of a proof provider, mint a brand new VC with an empty slot for proofs.
@@ -204,8 +204,8 @@ class VCWallet:
             coin_spends.append(make_spend(coin, puzzle, solution))
         spend_bundle = WalletSpendBundle(coin_spends, G2Element())
         now = uint64(int(time.time()))
-        add_list: List[Coin] = list(spend_bundle.additions())
-        rem_list: List[Coin] = list(spend_bundle.removals())
+        add_list: list[Coin] = list(spend_bundle.additions())
+        rem_list: list[Coin] = list(spend_bundle.removals())
         vc_record: VCRecord = VCRecord(vc, uint32(0))
         async with action_scope.use() as interface:
             interface.side_effects.transactions.append(
@@ -238,7 +238,7 @@ class VCWallet:
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
         new_inner_puzhash: Optional[bytes32] = None,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
         **kwargs: Unpack[GSTOptionalArgs],
     ) -> None:
         new_proof_hash: Optional[bytes32] = kwargs.get(
@@ -265,7 +265,7 @@ class VCWallet:
         if new_inner_puzhash is None:
             new_inner_puzhash = inner_puzhash
 
-        primaries: List[Payment] = [Payment(new_inner_puzhash, uint64(vc_record.vc.coin.amount), [new_inner_puzhash])]
+        primaries: list[Payment] = [Payment(new_inner_puzhash, uint64(vc_record.vc.coin.amount), [new_inner_puzhash])]
 
         if fee > 0:
             coin_name = vc_record.vc.coin.name()
@@ -301,7 +301,7 @@ class VCWallet:
             primaries=primaries,
             conditions=extra_conditions,
         )
-        did_announcement, coin_spend, vc = vc_record.vc.do_spend(inner_puzzle, innersol, new_proof_hash)
+        did_announcement, coin_spend, _vc = vc_record.vc.do_spend(inner_puzzle, innersol, new_proof_hash)
         spend_bundle = WalletSpendBundle([coin_spend], G2Element())
         if did_announcement is not None:
             # Need to spend DID
@@ -316,8 +316,8 @@ class VCWallet:
                 raise ValueError(
                     f"Cannot find the required DID {vc_record.vc.proof_provider.hex()}."
                 )  # pragma: no cover
-        add_list: List[Coin] = list(spend_bundle.additions())
-        rem_list: List[Coin] = list(spend_bundle.removals())
+        add_list: list[Coin] = list(spend_bundle.additions())
+        rem_list: list[Coin] = list(spend_bundle.removals())
         now = uint64(int(time.time()))
 
         async with action_scope.use() as interface:
@@ -349,9 +349,9 @@ class VCWallet:
         peer: WSChiaConnection,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
-        vc_coin_states: List[CoinState] = await self.wallet_state_manager.wallet_node.get_coin_state(
+        vc_coin_states: list[CoinState] = await self.wallet_state_manager.wallet_node.get_coin_state(
             [parent_id], peer=peer
         )
         if vc_coin_states is None:
@@ -377,7 +377,7 @@ class VCWallet:
             )
             return
 
-        recovery_info: Optional[Tuple[bytes32, bytes32, uint64]] = await did_wallet.get_info_for_recovery()
+        recovery_info: Optional[tuple[bytes32, bytes32, uint64]] = await did_wallet.get_info_for_recovery()
         if recovery_info is None:
             raise RuntimeError("DID could not currently be accessed while trying to revoke VC")  # pragma: no cover
         _, provider_inner_puzhash, _ = recovery_info
@@ -387,8 +387,8 @@ class VCWallet:
         coins.add(vc.coin)
         if fee > 0:
             coins.update(await self.standard_wallet.select_coins(fee, action_scope))
-        sorted_coins: List[Coin] = sorted(coins, key=Coin.name)
-        sorted_coin_list: List[List[Union[bytes32, uint64]]] = [coin_as_list(c) for c in sorted_coins]
+        sorted_coins: list[Coin] = sorted(coins, key=Coin.name)
+        sorted_coin_list: list[list[Union[bytes32, uint64]]] = [coin_as_list(c) for c in sorted_coins]
         nonce: bytes32 = SerializedProgram.to(sorted_coin_list).get_tree_hash()
         vc_announcement: AssertCoinAnnouncement = AssertCoinAnnouncement(asserted_id=vc.coin.name(), asserted_msg=nonce)
 
@@ -408,7 +408,7 @@ class VCWallet:
 
     async def add_vc_authorization(
         self, offer: Offer, solver: Solver, action_scope: WalletActionScope
-    ) -> Tuple[Offer, Solver]:
+    ) -> tuple[Offer, Solver]:
         """
         This method takes an existing offer and adds a VC authorization spend to it where it can/is willing.
         The only coins types that it looks for to approve are CR-CATs at the moment.
@@ -422,9 +422,9 @@ class VCWallet:
         send the change back to it's original puzzle hash or else a taker wallet will not approve it.
         """
         # Gather all of the CRCATs being spent and the CRCATs that each creates
-        crcat_spends: List[CRCATSpend] = []
-        other_spends: List[CoinSpend] = []
-        spends_to_fix: Dict[bytes32, CoinSpend] = {}
+        crcat_spends: list[CRCATSpend] = []
+        other_spends: list[CoinSpend] = []
+        spends_to_fix: dict[bytes32, CoinSpend] = {}
         for spend in offer.to_valid_spend().coin_spends:
             if CRCAT.is_cr_cat(uncurry_puzzle(spend.puzzle_reveal))[0]:
                 crcat_spend: CRCATSpend = CRCATSpend.from_coin_spend(spend)
@@ -440,13 +440,13 @@ class VCWallet:
                     other_spends.append(spend)
 
         # Figure out what VC announcements are needed
-        announcements_to_make: Dict[bytes32, List[CreatePuzzleAnnouncement]] = {}
-        announcements_to_assert: Dict[bytes32, List[AssertCoinAnnouncement]] = {}
-        vcs: Dict[bytes32, VerifiedCredential] = {}
-        coin_args: Dict[str, List[str]] = {}
+        announcements_to_make: dict[bytes32, list[CreatePuzzleAnnouncement]] = {}
+        announcements_to_assert: dict[bytes32, list[AssertCoinAnnouncement]] = {}
+        vcs: dict[bytes32, VerifiedCredential] = {}
+        coin_args: dict[str, list[str]] = {}
         for crcat_spend in crcat_spends:
             # Check first whether we can approve...
-            available_vcs: List[VCRecord] = [
+            available_vcs: list[VCRecord] = [
                 vc_rec
                 for vc_rec in await self.store.get_vc_records_by_providers(crcat_spend.crcat.authorized_providers)
                 if vc_rec.confirmed_at_height != 0
@@ -556,7 +556,7 @@ class VCWallet:
                             *(
                                 spend
                                 for spend in offer.to_spend_bundle().coin_spends
-                                if spend.coin.parent_coin_info == bytes32([0] * 32)
+                                if spend.coin.parent_coin_info == bytes32.zeros
                             ),
                             *other_spends,
                         ],
@@ -572,9 +572,9 @@ class VCWallet:
         ), Solver({"vc_authorizations": coin_args})
 
     async def get_vc_with_provider_in_and_proofs(
-        self, authorized_providers: List[bytes32], proofs: List[str]
+        self, authorized_providers: list[bytes32], proofs: list[str]
     ) -> VerifiedCredential:
-        vc_records: List[VCRecord] = await self.store.get_vc_records_by_providers(authorized_providers)
+        vc_records: list[VCRecord] = await self.store.get_vc_records_by_providers(authorized_providers)
         if len(vc_records) == 0:  # pragma: no cover
             raise ValueError(f"VCWallet has no VCs with providers in the following list: {authorized_providers}")
         else:
@@ -588,7 +588,7 @@ class VCWallet:
                     return rec.vc
         raise ValueError(f"No authorized VC has the correct proofs: {proofs}")  # pragma: no cover
 
-    async def proof_of_inclusions_for_root_and_keys(self, root: bytes32, keys: List[str]) -> Program:
+    async def proof_of_inclusions_for_root_and_keys(self, root: bytes32, keys: list[str]) -> Program:
         vc_proofs: Optional[VCProofs] = await self.store.get_proofs_for_root(root)
         if vc_proofs is None:
             raise RuntimeError(f"No proofs exist for VC root: {root.hex()}")  # pragma: no cover
@@ -599,25 +599,25 @@ class VCWallet:
         self,
         amount: uint64,
         action_scope: WalletActionScope,
-    ) -> Set[Coin]:
+    ) -> set[Coin]:
         raise RuntimeError("VCWallet does not support select_coins()")  # pragma: no cover
 
-    async def get_confirmed_balance(self, record_list: Optional[Set[WalletCoinRecord]] = None) -> uint128:
+    async def get_confirmed_balance(self, record_list: Optional[set[WalletCoinRecord]] = None) -> uint128:
         """The VC wallet doesn't really have a balance."""
         return uint128(0)  # pragma: no cover
 
-    async def get_unconfirmed_balance(self, record_list: Optional[Set[WalletCoinRecord]] = None) -> uint128:
+    async def get_unconfirmed_balance(self, record_list: Optional[set[WalletCoinRecord]] = None) -> uint128:
         """The VC wallet doesn't really have a balance."""
         return uint128(0)  # pragma: no cover
 
-    async def get_spendable_balance(self, unspent_records: Optional[Set[WalletCoinRecord]] = None) -> uint128:
+    async def get_spendable_balance(self, unspent_records: Optional[set[WalletCoinRecord]] = None) -> uint128:
         """The VC wallet doesn't really have a balance."""
         return uint128(0)  # pragma: no cover
 
     async def get_pending_change_balance(self) -> uint64:
         return uint64(0)  # pragma: no cover
 
-    async def get_max_send_amount(self, records: Optional[Set[WalletCoinRecord]] = None) -> uint128:
+    async def get_max_send_amount(self, records: Optional[set[WalletCoinRecord]] = None) -> uint128:
         """This is the confirmed balance, which we set to 0 as the VC wallet doesn't have one."""
         return uint128(0)  # pragma: no cover
 

chia/wallet/wallet.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 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, PrivateKey
 from typing_extensions import Unpack
@@ -94,14 +94,14 @@ class Wallet:
         # avoid full block TXs
         return int(self.wallet_state_manager.constants.MAX_BLOCK_COST_CLVM / 5 / self.cost_of_single_tx)
 
-    async def get_max_spendable_coins(self, records: Optional[Set[WalletCoinRecord]] = None) -> Set[WalletCoinRecord]:
-        spendable: List[WalletCoinRecord] = list(
+    async def get_max_spendable_coins(self, records: Optional[set[WalletCoinRecord]] = None) -> set[WalletCoinRecord]:
+        spendable: list[WalletCoinRecord] = list(
             await self.wallet_state_manager.get_spendable_coins_for_wallet(self.id(), records)
         )
         spendable.sort(reverse=True, key=lambda record: record.coin.amount)
         return set(spendable[0 : min(len(spendable), self.max_send_quantity)])
 
-    async def get_max_send_amount(self, records: Optional[Set[WalletCoinRecord]] = None) -> uint128:
+    async def get_max_send_amount(self, records: Optional[set[WalletCoinRecord]] = None) -> uint128:
         return uint128(sum(cr.coin.amount for cr in await self.get_max_spendable_coins()))
 
     @classmethod
@@ -111,20 +111,20 @@ class Wallet:
     def id(self) -> uint32:
         return self.wallet_id
 
-    async def get_confirmed_balance(self, record_list: Optional[Set[WalletCoinRecord]] = None) -> uint128:
+    async def get_confirmed_balance(self, record_list: Optional[set[WalletCoinRecord]] = None) -> uint128:
         return await self.wallet_state_manager.get_confirmed_balance_for_wallet(self.id(), record_list)
 
-    async def get_unconfirmed_balance(self, unspent_records: Optional[Set[WalletCoinRecord]] = None) -> uint128:
+    async def get_unconfirmed_balance(self, unspent_records: Optional[set[WalletCoinRecord]] = None) -> uint128:
         return await self.wallet_state_manager.get_unconfirmed_balance(self.id(), unspent_records)
 
-    async def get_spendable_balance(self, unspent_records: Optional[Set[WalletCoinRecord]] = None) -> uint128:
+    async def get_spendable_balance(self, unspent_records: Optional[set[WalletCoinRecord]] = None) -> uint128:
         spendable = await self.wallet_state_manager.get_confirmed_spendable_balance_for_wallet(
             self.id(), unspent_records
         )
         return spendable
 
     async def get_pending_change_balance(self) -> uint64:
-        unconfirmed_tx: List[TransactionRecord] = await self.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(
+        unconfirmed_tx: list[TransactionRecord] = await self.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(
             self.id()
         )
         addition_amount = 0
@@ -181,9 +181,9 @@ class Wallet:
         if new:
             return await self.get_new_puzzle()
         else:
-            record: Optional[DerivationRecord] = (
-                await self.wallet_state_manager.get_current_derivation_record_for_wallet(self.id())
-            )
+            record: Optional[
+                DerivationRecord
+            ] = await self.wallet_state_manager.get_current_derivation_record_for_wallet(self.id())
             if record is None:
                 return await self.get_new_puzzle()  # pragma: no cover
             puzzle = puzzle_for_pk(record.pubkey)
@@ -193,9 +193,9 @@ class Wallet:
         if new:
             return await self.get_new_puzzlehash()
         else:
-            record: Optional[DerivationRecord] = (
-                await self.wallet_state_manager.get_current_derivation_record_for_wallet(self.id())
-            )
+            record: Optional[
+                DerivationRecord
+            ] = await self.wallet_state_manager.get_current_derivation_record_for_wallet(self.id())
             if record is None:
                 return await self.get_new_puzzlehash()
             return record.puzzle_hash
@@ -206,12 +206,12 @@ class Wallet:
 
     def make_solution(
         self,
-        primaries: List[Payment],
-        conditions: Tuple[Condition, ...] = tuple(),
+        primaries: list[Payment],
+        conditions: tuple[Condition, ...] = tuple(),
         fee: uint64 = uint64(0),
     ) -> Program:
         assert fee >= 0
-        condition_list: List[Any] = [condition.to_program() for condition in conditions]
+        condition_list: list[Any] = [condition.to_program() for condition in conditions]
         if len(primaries) > 0:
             for primary in primaries:
                 condition_list.append(make_create_coin_condition(primary.puzzle_hash, primary.amount, primary.memos))
@@ -229,17 +229,17 @@ class Wallet:
         self,
         amount: uint64,
         action_scope: WalletActionScope,
-    ) -> Set[Coin]:
+    ) -> set[Coin]:
         """
         Returns a set of coins that can be used for generating a new transaction.
         Note: Must be called under wallet state manager lock
         """
         spendable_amount: uint128 = await self.get_spendable_balance()
-        spendable_coins: List[WalletCoinRecord] = list(await self.get_max_spendable_coins())
+        spendable_coins: list[WalletCoinRecord] = list(await self.get_max_spendable_coins())
 
         # Try to use coins from the store, if there isn't enough of "unused"
         # coins use change coins that are not confirmed yet
-        unconfirmed_removals: Dict[bytes32, Coin] = await self.wallet_state_manager.unconfirmed_removals_for_wallet(
+        unconfirmed_removals: dict[bytes32, Coin] = await self.wallet_state_manager.unconfirmed_removals_for_wallet(
             self.id()
         )
         async with action_scope.use() as interface:
@@ -262,13 +262,13 @@ class Wallet:
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
         origin_id: Optional[bytes32] = None,
-        coins: Optional[Set[Coin]] = None,
-        primaries_input: Optional[List[Payment]] = None,
-        memos: Optional[List[bytes]] = None,
+        coins: Optional[set[Coin]] = None,
+        primaries_input: Optional[list[Payment]] = None,
+        memos: Optional[list[bytes]] = None,
         negative_change_allowed: bool = False,
-        puzzle_decorator_override: Optional[List[Dict[str, Any]]] = None,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
-    ) -> List[CoinSpend]:
+        puzzle_decorator_override: Optional[list[dict[str, Any]]] = None,
+        extra_conditions: tuple[Condition, ...] = tuple(),
+    ) -> list[CoinSpend]:
         """
         Generates a unsigned transaction in form of List(Puzzle, Solutions)
         Note: this must be called under a wallet state manager lock
@@ -303,7 +303,7 @@ class Wallet:
 
         assert change >= 0
 
-        spends: List[CoinSpend] = []
+        spends: list[CoinSpend] = []
         primary_announcement: Optional[AssertCoinAnnouncement] = None
 
         # Check for duplicates
@@ -312,13 +312,13 @@ class Wallet:
             raise ValueError("Cannot create two identical coins")
         for coin in coins:
             # Only one coin creates outputs
-            if origin_id in (None, coin.name()):
+            if origin_id in {None, coin.name()}:
                 origin_id = coin.name()
                 inner_puzzle = await self.puzzle_for_puzzle_hash(coin.puzzle_hash)
                 decorated_target_puzzle_hash = decorator_manager.decorate_target_puzzle_hash(
                     inner_puzzle, newpuzzlehash
                 )
-                target_primary: List[Payment] = []
+                target_primary: list[Payment] = []
                 if memos is None:
                     memos = []
                 memos = decorator_manager.decorate_memos(inner_puzzle, newpuzzlehash, memos)
@@ -337,7 +337,7 @@ class Wallet:
                     else:
                         change_puzzle_hash = await self.get_new_puzzlehash()
                     primaries.append(Payment(change_puzzle_hash, uint64(change)))
-                message_list: List[bytes32] = [c.name() for c in coins]
+                message_list: list[bytes32] = [c.name() for c in coins]
                 for primary in primaries:
                     message_list.append(Coin(coin.name(), primary.puzzle_hash, primary.amount).name())
                 message: bytes32 = std_hash(b"".join(message_list))
@@ -375,7 +375,7 @@ class Wallet:
         self.log.debug(f"Spends is {spends}")
         return spends
 
-    async def sign_message(self, message: str, puzzle_hash: bytes32, mode: SigningMode) -> Tuple[G1Element, G2Element]:
+    async def sign_message(self, message: str, puzzle_hash: bytes32, mode: SigningMode) -> tuple[G1Element, G2Element]:
         # CHIP-0002 message signing as documented at:
         # https://github.com/Chia-Network/chips/blob/80e4611fe52b174bf1a0382b9dff73805b18b8c6/CHIPs/chip-0002.md#signmessage
         private = await self.wallet_state_manager.get_private_key(puzzle_hash)
@@ -397,11 +397,11 @@ class Wallet:
         puzzle_hash: bytes32,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        coins: Optional[Set[Coin]] = None,
-        primaries: Optional[List[Payment]] = None,
-        memos: Optional[List[bytes]] = None,
-        puzzle_decorator_override: Optional[List[Dict[str, Any]]] = None,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        coins: Optional[set[Coin]] = None,
+        primaries: Optional[list[Payment]] = None,
+        memos: Optional[list[bytes]] = None,
+        puzzle_decorator_override: Optional[list[dict[str, Any]]] = None,
+        extra_conditions: tuple[Condition, ...] = tuple(),
         **kwargs: Unpack[GSTOptionalArgs],
     ) -> None:
         origin_id: Optional[bytes32] = kwargs.get("origin_id", None)
@@ -434,8 +434,8 @@ class Wallet:
         spend_bundle = WalletSpendBundle(transaction, G2Element())
 
         now = uint64(int(time.time()))
-        add_list: List[Coin] = list(spend_bundle.additions())
-        rem_list: List[Coin] = list(spend_bundle.removals())
+        add_list: list[Coin] = list(spend_bundle.additions())
+        rem_list: list[Coin] = list(spend_bundle.removals())
 
         output_amount = sum(a.amount for a in add_list) + fee
         input_amount = sum(r.amount for r in rem_list)
@@ -471,7 +471,7 @@ class Wallet:
         self,
         fee: uint64,
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         chia_coins = await self.select_coins(fee, action_scope)
         await self.generate_signed_transaction(
@@ -488,7 +488,7 @@ class Wallet:
         asset_id: Optional[bytes32],
         amount: uint64,
         action_scope: WalletActionScope,
-    ) -> Set[Coin]:
+    ) -> set[Coin]:
         if asset_id is not None:
             raise ValueError(f"The standard wallet cannot offer coins with asset id {asset_id}")
         balance = await self.get_spendable_balance()
@@ -501,7 +501,7 @@ class Wallet:
     # WSChiaConnection is only imported for type checking
     async def coin_added(
         self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: Optional[Streamable]
-    ) -> None:  # pylint: disable=used-before-assignment
+    ) -> None:
         pass
 
     def get_name(self) -> str:
@@ -509,9 +509,9 @@ class Wallet:
 
     async def match_hinted_coin(self, coin: Coin, hint: bytes32) -> bool:
         if hint == coin.puzzle_hash:
-            wallet_identifier: Optional[WalletIdentifier] = (
-                await self.wallet_state_manager.puzzle_store.get_wallet_identifier_for_puzzle_hash(coin.puzzle_hash)
-            )
+            wallet_identifier: Optional[
+                WalletIdentifier
+            ] = await self.wallet_state_manager.puzzle_store.get_wallet_identifier_for_puzzle_hash(coin.puzzle_hash)
             if wallet_identifier is not None and wallet_identifier.id == self.id():
                 return True
         return False
@@ -557,18 +557,18 @@ class Wallet:
 
     async def execute_signing_instructions(
         self, signing_instructions: SigningInstructions, partial_allowed: bool = False
-    ) -> List[SigningResponse]:
+    ) -> list[SigningResponse]:
         root_pubkey: G1Element = self.wallet_state_manager.root_pubkey
-        pk_lookup: Dict[int, G1Element] = (
+        pk_lookup: dict[int, G1Element] = (
             {root_pubkey.get_fingerprint(): root_pubkey} if self.wallet_state_manager.private_key is not None else {}
         )
-        sk_lookup: Dict[int, PrivateKey] = (
+        sk_lookup: dict[int, PrivateKey] = (
             {root_pubkey.get_fingerprint(): self.wallet_state_manager.get_master_private_key()}
             if self.wallet_state_manager.private_key is not None
             else {}
         )
         aggregate_responses_at_end: bool = True
-        responses: List[SigningResponse] = []
+        responses: list[SigningResponse] = []
 
         # TODO: expand path hints and sum hints recursively (a sum hint can give a new key to path hint)
         # Next, expand our pubkey set with path hints
@@ -593,9 +593,9 @@ class Wallet:
                     sk_lookup[derive_child_pk_unhardened.get_fingerprint()] = derive_child_sk_unhardened
 
         # Next, expand our pubkey set with sum hints
-        sum_hint_lookup: Dict[int, List[int]] = {}
+        sum_hint_lookup: dict[int, list[int]] = {}
         for sum_hint in signing_instructions.key_hints.sum_hints:
-            fingerprints_we_have: List[int] = []
+            fingerprints_we_have: list[int] = []
             for fingerprint in sum_hint.fingerprints:
                 fingerprint_as_int = int.from_bytes(fingerprint, "big")
                 if fingerprint_as_int not in pk_lookup:
@@ -635,7 +635,7 @@ class Wallet:
                     )
                 )
             else:  # Implicit if pk_fingerprint in sum_hint_lookup
-                signatures: List[G2Element] = []
+                signatures: list[G2Element] = []
                 for partial_fingerprint in sum_hint_lookup[pk_fingerprint]:
                     signatures.append(
                         AugSchemeMPL.sign(sk_lookup[partial_fingerprint], target.message, pk_lookup[pk_fingerprint])
@@ -660,8 +660,8 @@ class Wallet:
 
         # If we have the full set of signing responses for the instructions, aggregate them as much as possible
         if aggregate_responses_at_end:
-            new_responses: List[SigningResponse] = []
-            grouped_responses: Dict[bytes32, List[SigningResponse]] = {}
+            new_responses: list[SigningResponse] = []
+            grouped_responses: dict[bytes32, list[SigningResponse]] = {}
             for response in responses:
                 grouped_responses.setdefault(response.hook, [])
                 grouped_responses[response.hook].append(response)
@@ -677,7 +677,7 @@ class Wallet:
         return responses
 
     async def apply_signatures(
-        self, spends: List[Spend], signing_responses: List[SigningResponse]
+        self, spends: list[Spend], signing_responses: list[SigningResponse]
     ) -> SignedTransaction:
         signing_responses_set = set(signing_responses)
         return SignedTransaction(

chia/wallet/wallet_action_scope.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import contextlib
+from collections.abc import AsyncIterator
 from dataclasses import dataclass, field, replace
-from typing import TYPE_CHECKING, AsyncIterator, List, Optional, cast, final
+from typing import TYPE_CHECKING, Optional, cast, final
 
 from chia.types.blockchain_format.coin import Coin
 from chia.util.action_scope import ActionScope
@@ -20,18 +21,18 @@ if TYPE_CHECKING:
 @streamable
 @dataclass(frozen=True)
 class _StreamableWalletSideEffects(Streamable):
-    transactions: List[TransactionRecord]
-    signing_responses: List[SigningResponse]
-    extra_spends: List[WalletSpendBundle]
-    selected_coins: List[Coin]
+    transactions: list[TransactionRecord]
+    signing_responses: list[SigningResponse]
+    extra_spends: list[WalletSpendBundle]
+    selected_coins: list[Coin]
 
 
 @dataclass
 class WalletSideEffects:
-    transactions: List[TransactionRecord] = field(default_factory=list)
-    signing_responses: List[SigningResponse] = field(default_factory=list)
-    extra_spends: List[WalletSpendBundle] = field(default_factory=list)
-    selected_coins: List[Coin] = field(default_factory=list)
+    transactions: list[TransactionRecord] = field(default_factory=list)
+    signing_responses: list[SigningResponse] = field(default_factory=list)
+    extra_spends: list[WalletSpendBundle] = field(default_factory=list)
+    selected_coins: list[Coin] = field(default_factory=list)
 
     def __bytes__(self) -> bytes:
         return bytes(_StreamableWalletSideEffects(**self.__dict__))
@@ -47,8 +48,8 @@ class WalletActionConfig:
     push: bool
     merge_spends: bool
     sign: Optional[bool]
-    additional_signing_responses: List[SigningResponse]
-    extra_spends: List[WalletSpendBundle]
+    additional_signing_responses: list[SigningResponse]
+    extra_spends: list[WalletSpendBundle]
     tx_config: TXConfig
 
     def adjust_for_side_effects(self, side_effects: WalletSideEffects) -> WalletActionConfig:
@@ -71,8 +72,8 @@ async def new_wallet_action_scope(
     push: bool = False,
     merge_spends: bool = True,
     sign: Optional[bool] = None,
-    additional_signing_responses: List[SigningResponse] = [],
-    extra_spends: List[WalletSpendBundle] = [],
+    additional_signing_responses: list[SigningResponse] = [],
+    extra_spends: list[WalletSpendBundle] = [],
 ) -> AsyncIterator[WalletActionScope]:
     async with ActionScope.new_scope(
         WalletSideEffects,

chia/wallet/wallet_blockchain.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, ClassVar, Dict, List, Optional, Tuple, cast
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
 from chia.consensus.block_header_validation import validate_finished_header_block
 from chia.consensus.block_record import BlockRecord
@@ -11,6 +11,7 @@ from chia.consensus.find_fork_point import find_fork_point_in_chain
 from chia.consensus.full_block_to_block_record import block_to_block_record
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.header_block import HeaderBlock
+from chia.types.validation_state import ValidationState
 from chia.types.weight_proof import WeightProof
 from chia.util.errors import Err
 from chia.util.ints import uint32, uint64
@@ -35,8 +36,8 @@ class WalletBlockchain:
     _finished_sync_up_to: uint32
 
     _peak: Optional[HeaderBlock]
-    _height_to_hash: Dict[uint32, bytes32]
-    _block_records: Dict[bytes32, BlockRecord]
+    _height_to_hash: dict[uint32, bytes32]
+    _block_records: dict[bytes32, BlockRecord]
     _latest_timestamp: uint64
     _sub_slot_iters: uint64
     _difficulty: uint64
@@ -69,7 +70,7 @@ class WalletBlockchain:
 
         return self
 
-    async def new_valid_weight_proof(self, weight_proof: WeightProof, records: List[BlockRecord]) -> None:
+    async def new_valid_weight_proof(self, weight_proof: WeightProof, records: list[BlockRecord]) -> None:
         peak: Optional[HeaderBlock] = await self.get_peak_block()
 
         if peak is not None and weight_proof.recent_chain_data[-1].weight <= peak.weight:
@@ -93,7 +94,7 @@ class WalletBlockchain:
             await self.set_peak_block(weight_proof.recent_chain_data[-1], latest_timestamp)
             await self.clean_block_records()
 
-    async def add_block(self, block: HeaderBlock) -> Tuple[AddBlockResult, Optional[Err]]:
+    async def add_block(self, block: HeaderBlock) -> tuple[AddBlockResult, Optional[Err]]:
         if self.contains_block(block.header_hash):
             return AddBlockResult.ALREADY_HAVE_BLOCK, None
         if not self.contains_block(block.prev_header_hash) and block.height > 0:
@@ -110,9 +111,8 @@ class WalletBlockchain:
             difficulty = self._difficulty
 
         # Validation requires a block cache (self) that goes back to a subepoch barrier
-        required_iters, error = validate_finished_header_block(
-            self.constants, self, block, False, difficulty, sub_slot_iters, False
-        )
+        expected_vs = ValidationState(sub_slot_iters, difficulty, None)
+        required_iters, error = validate_finished_header_block(self.constants, self, block, False, expected_vs, False)
         if error is not None:
             return AddBlockResult.INVALID_BLOCK, error.code
         if required_iters is None:
@@ -217,7 +217,7 @@ class WalletBlockchain:
         # blockchain_interface
         return self._block_records.get(header_hash)
 
-    async def prev_block_hash(self, header_hashes: List[bytes32]) -> List[bytes32]:
+    async def prev_block_hash(self, header_hashes: list[bytes32]) -> list[bytes32]:
         ret = []
         for h in header_hashes:
             ret.append(self._block_records[h].prev_hash)
@@ -235,7 +235,7 @@ class WalletBlockchain:
         if len(self._block_records) < self.CACHE_SIZE:
             return None
 
-        to_remove: List[bytes32] = []
+        to_remove: list[bytes32] = []
         for header_hash, block_record in self._block_records.items():
             if block_record.height < height_limit:
                 to_remove.append(header_hash)