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

chia/wallet/vc_wallet/cr_cat_drivers.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 import functools
+from collections.abc import Iterable
 from dataclasses import dataclass, replace
 from enum import IntEnum
-from typing import Iterable, List, Optional, Tuple, Type, TypeVar
+from typing import Optional, TypeVar
 
 from clvm.casts import int_to_bytes
 
@@ -94,7 +95,7 @@ CREDENTIAL_STRUCT_HASH: bytes32 = CREDENTIAL_STRUCT.get_tree_hash()
 
 # Basic drivers
 def construct_cr_layer(
-    authorized_providers: List[bytes32],
+    authorized_providers: list[bytes32],
     proofs_checker: Program,
     inner_puzzle: Program,
 ) -> Program:
@@ -128,7 +129,7 @@ def construct_cr_layer_hash(
 
 def match_cr_layer(
     uncurried_puzzle: UncurriedPuzzle,
-) -> Optional[Tuple[List[bytes32], Program, Program]]:
+) -> Optional[tuple[list[bytes32], Program, Program]]:
     extra_uncurried_puzzle = uncurry_puzzle(uncurried_puzzle.mod)
     if extra_uncurried_puzzle.mod == CREDENTIAL_RESTRICTION:
         return (
@@ -176,24 +177,24 @@ class CRCAT:
     coin: Coin
     tail_hash: bytes32
     lineage_proof: LineageProof
-    authorized_providers: List[bytes32]
+    authorized_providers: list[bytes32]
     proofs_checker: Program
     inner_puzzle_hash: bytes32
 
     @classmethod
     def launch(
-        cls: Type[_T_CRCAT],
+        cls: type[_T_CRCAT],
         # General CAT launching info
         origin_coin: Coin,
         payment: Payment,
         tail: Program,
         tail_solution: Program,
         # CR Layer params
-        authorized_providers: List[bytes32],
+        authorized_providers: list[bytes32],
         proofs_checker: Program,
         # Probably never need this but some tail might
         optional_lineage_proof: Optional[LineageProof] = None,
-    ) -> Tuple[Program, CoinSpend, CRCAT]:
+    ) -> tuple[Program, CoinSpend, CRCAT]:
         """
         Launch a new CR-CAT from XCH.
 
@@ -288,7 +289,7 @@ class CRCAT:
         )
 
     @staticmethod
-    def is_cr_cat(puzzle_reveal: UncurriedPuzzle) -> Tuple[bool, str]:
+    def is_cr_cat(puzzle_reveal: UncurriedPuzzle) -> tuple[bool, str]:
         """
         This takes an (uncurried) puzzle reveal and returns a boolean for whether the puzzle is a CR-CAT and an error
         message for if the puzzle is a mismatch.
@@ -310,7 +311,7 @@ class CRCAT:
         return solution.at("f").at("rrrrrrf")
 
     @classmethod
-    def get_current_from_coin_spend(cls: Type[_T_CRCAT], spend: CoinSpend) -> CRCAT:  # pragma: no cover
+    def get_current_from_coin_spend(cls: type[_T_CRCAT], spend: CoinSpend) -> CRCAT:  # pragma: no cover
         uncurried_puzzle: UncurriedPuzzle = uncurry_puzzle(spend.puzzle_reveal)
         first_uncurried_cr_layer: UncurriedPuzzle = uncurry_puzzle(uncurried_puzzle.args.at("rrf"))
         second_uncurried_cr_layer: UncurriedPuzzle = uncurry_puzzle(first_uncurried_cr_layer.mod)
@@ -329,10 +330,10 @@ class CRCAT:
 
     @classmethod
     def get_next_from_coin_spend(
-        cls: Type[_T_CRCAT],
+        cls: type[_T_CRCAT],
         parent_spend: CoinSpend,
         conditions: Optional[Program] = None,  # For optimization purposes, the conditions may already have been run
-    ) -> List[CRCAT]:
+    ) -> list[CRCAT]:
         """
         Given a coin spend, this will return the next CR-CATs that were created as an output of that spend.
         Inner puzzle output conditions may also be supplied as an optimization.
@@ -388,12 +389,12 @@ class CRCAT:
             uint64(parent_spend.coin.amount),
         )
 
-        all_conditions: List[Program] = list(conditions.as_iter())
+        all_conditions: list[Program] = list(conditions.as_iter())
         if len(all_conditions) > 1000:
             raise RuntimeError("More than 1000 conditions not currently supported by CRCAT drivers")  # pragma: no cover
 
         # Almost complete except the coin's full puzzle hash which we want to use the class method to calculate
-        partially_completed_crcats: List[CRCAT] = [
+        partially_completed_crcats: list[CRCAT] = [
             CRCAT(
                 Coin(coin_name, bytes(32), uint64(condition.at("rrf").as_int())),
                 bytes32(tail_hash_as_prog.as_atom()),
@@ -438,7 +439,7 @@ class CRCAT:
         inner_solution: Program,
         # For optimization purposes the conditions may already have been run
         conditions: Optional[Iterable[Program]] = None,
-    ) -> Tuple[List[AssertCoinAnnouncement], CoinSpend, List[CRCAT]]:
+    ) -> tuple[list[AssertCoinAnnouncement], CoinSpend, list[CRCAT]]:
         """
         Spend a CR-CAT.
 
@@ -449,8 +450,8 @@ class CRCAT:
         Likely, spend_many is more useful.
         """
         # Gather the output information
-        announcements: List[AssertCoinAnnouncement] = []
-        new_inner_puzzle_hashes_and_amounts: List[Tuple[bytes32, uint64]] = []
+        announcements: list[AssertCoinAnnouncement] = []
+        new_inner_puzzle_hashes_and_amounts: list[tuple[bytes32, uint64]] = []
         if conditions is None:
             conditions = inner_puzzle.run(inner_solution).as_iter()  # pragma: no cover
         assert conditions is not None
@@ -518,15 +519,15 @@ class CRCAT:
 
     @classmethod
     def spend_many(
-        cls: Type[_T_CRCAT],
-        inner_spends: List[Tuple[_T_CRCAT, int, Program, Program]],  # CRCAT, extra_delta, inner puzzle, inner solution
+        cls: type[_T_CRCAT],
+        inner_spends: list[tuple[_T_CRCAT, int, Program, Program]],  # CRCAT, extra_delta, inner puzzle, inner solution
         # CR layer solving info
         proof_of_inclusions: Program,
         proof_checker_solution: Program,
         provider_id: bytes32,
         vc_launcher_id: bytes32,
         vc_inner_puzhash: Optional[bytes32],  # Optional for incomplete spends
-    ) -> Tuple[List[AssertCoinAnnouncement], List[CoinSpend], List[CRCAT]]:
+    ) -> tuple[list[AssertCoinAnnouncement], list[CoinSpend], list[CRCAT]]:
         """
         Spend a multiple CR-CATs.
 
@@ -541,19 +542,19 @@ class CRCAT:
         def prev_index(index: int) -> int:
             return index - 1
 
-        sorted_inner_spends: List[Tuple[_T_CRCAT, int, Program, Program]] = sorted(
+        sorted_inner_spends: list[tuple[_T_CRCAT, int, Program, Program]] = sorted(
             inner_spends,
             key=lambda spend: spend[0].coin.name(),
         )
 
-        all_expected_announcements: List[AssertCoinAnnouncement] = []
-        all_coin_spends: List[CoinSpend] = []
-        all_new_crcats: List[CRCAT] = []
+        all_expected_announcements: list[AssertCoinAnnouncement] = []
+        all_coin_spends: list[CoinSpend] = []
+        all_new_crcats: list[CRCAT] = []
 
         subtotal: int = 0
         for i, inner_spend in enumerate(sorted_inner_spends):
             crcat, extra_delta, inner_puzzle, inner_solution = inner_spend
-            conditions: List[Program] = list(inner_puzzle.run(inner_solution).as_iter())
+            conditions: list[Program] = list(inner_puzzle.run(inner_solution).as_iter())
             output_amount: int = (
                 sum(
                     c.at("rrf").as_int()
@@ -604,9 +605,9 @@ class CRCATSpend:
     crcat: CRCAT
     inner_puzzle: Program
     inner_solution: Program
-    children: List[CRCAT]
+    children: list[CRCAT]
     incomplete: bool
-    inner_conditions: List[Program]
+    inner_conditions: list[Program]
     proof_of_inclusions: Program
 
     @classmethod
@@ -628,7 +629,7 @@ class CRCATSpend:
 @streamable
 @dataclass(frozen=True)
 class ProofsChecker(Streamable):
-    flags: List[str]
+    flags: list[str]
 
     def as_program(self) -> Program:
         def byte_sort_flags(f1: str, f2: str) -> int:

chia/wallet/vc_wallet/cr_cat_wallet.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 import time
 import traceback
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Tuple
+from typing import TYPE_CHECKING, Any, Optional
 
 from chia_rs import G1Element, G2Element
 from typing_extensions import Unpack
@@ -82,7 +82,7 @@ class CRCATWallet(CATWallet):
     async def create_new_cat_wallet(
         wallet_state_manager: WalletStateManager,
         wallet: Wallet,
-        cat_tail_info: Dict[str, Any],
+        cat_tail_info: dict[str, Any],
         amount: uint64,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
@@ -97,7 +97,7 @@ class CRCATWallet(CATWallet):
         wallet: Wallet,
         limitations_program_hash_hex: str,
         name: Optional[str] = None,
-        authorized_providers: Optional[List[bytes32]] = None,
+        authorized_providers: Optional[list[bytes32]] = None,
         proofs_checker: Optional[ProofsChecker] = None,
     ) -> CRCATWallet:
         if authorized_providers is None or proofs_checker is None:  # pragma: no cover
@@ -134,7 +134,7 @@ class CRCATWallet(CATWallet):
         puzzle_driver: PuzzleInfo,
         name: Optional[str] = None,
         # We're hinting this as Any for mypy by should explore adding this to the wallet protocol and hinting properly
-        potential_subclasses: Dict[AssetType, Any] = {},
+        potential_subclasses: dict[AssetType, Any] = {},
     ) -> Any:
         cr_layer: Optional[PuzzleInfo] = puzzle_driver.also()
         if cr_layer is None:  # pragma: no cover
@@ -167,7 +167,7 @@ class CRCATWallet(CATWallet):
     async def convert_to_cr(
         cls,
         cat_wallet: CATWallet,
-        authorized_providers: List[bytes32],
+        authorized_providers: list[bytes32],
         proofs_checker: ProofsChecker,
     ) -> None:
         replace_self = cls()
@@ -216,13 +216,13 @@ class CRCATWallet(CATWallet):
 
     async def add_crcat_coin(self, coin_spend: CoinSpend, coin: Coin, height: uint32) -> None:
         try:
-            new_cr_cats: List[CRCAT] = CRCAT.get_next_from_coin_spend(coin_spend)
+            new_cr_cats: list[CRCAT] = CRCAT.get_next_from_coin_spend(coin_spend)
             hint_dict = {
                 id: hc.hint
                 for id, hc in compute_spend_hints_and_additions(coin_spend)[0].items()
                 if hc.hint is not None
             }
-            cr_cat: CRCAT = list(filter(lambda c: c.coin.name() == coin.name(), new_cr_cats))[0]
+            cr_cat: CRCAT = next(filter(lambda c: c.coin.name() == coin.name(), new_cr_cats))
             if (
                 await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(
                     cr_cat.inner_puzzle_hash
@@ -316,10 +316,10 @@ class CRCATWallet(CATWallet):
             "inner_puzzle_for_cat_puzhash is a legacy method and is not available on CR-CAT wallets"
         )
 
-    async def get_cat_spendable_coins(self, records: Optional[Set[WalletCoinRecord]] = None) -> List[WalletCoinRecord]:
-        result: List[WalletCoinRecord] = []
+    async def get_cat_spendable_coins(self, records: Optional[set[WalletCoinRecord]] = None) -> list[WalletCoinRecord]:
+        result: list[WalletCoinRecord] = []
 
-        record_list: Set[WalletCoinRecord] = await self.wallet_state_manager.get_spendable_coins_for_wallet(
+        record_list: set[WalletCoinRecord] = await self.wallet_state_manager.get_spendable_coins_for_wallet(
             self.id(), records
         )
 
@@ -330,7 +330,7 @@ class CRCATWallet(CATWallet):
 
         return result
 
-    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:
         if record_list is None:
             record_list = await self.wallet_state_manager.coin_store.get_unspent_coins_for_wallet(
                 self.id(), CoinType.CRCAT
@@ -344,7 +344,7 @@ class CRCATWallet(CATWallet):
         self.log.info(f"Confirmed balance for cat wallet {self.id()} is {amount}")
         return uint128(amount)
 
-    async def get_pending_approval_balance(self, record_list: Optional[Set[WalletCoinRecord]] = None) -> uint128:
+    async def get_pending_approval_balance(self, record_list: Optional[set[WalletCoinRecord]] = None) -> uint128:
         if record_list is None:
             record_list = await self.wallet_state_manager.coin_store.get_unspent_coins_for_wallet(
                 self.id(), CoinType.CRCAT_PENDING
@@ -397,12 +397,12 @@ class CRCATWallet(CATWallet):
 
     async def _generate_unsigned_spendbundle(
         self,
-        payments: List[Payment],
+        payments: list[Payment],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        cat_discrepancy: Optional[Tuple[int, Program, Program]] = None,  # (extra_delta, tail_reveal, tail_solution)
-        coins: Optional[Set[Coin]] = None,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        cat_discrepancy: Optional[tuple[int, Program, Program]] = None,  # (extra_delta, tail_reveal, tail_solution)
+        coins: Optional[set[Coin]] = None,
+        extra_conditions: tuple[Condition, ...] = tuple(),
         add_authorizations_to_cr_cats: bool = True,
     ) -> WalletSpendBundle:
         if cat_discrepancy is not None:
@@ -438,12 +438,14 @@ class CRCATWallet(CATWallet):
 
         # Calculate standard puzzle solutions
         change = selected_cat_amount - starting_amount
-        primaries: List[Payment] = []
+        primaries: list[Payment] = []
         for payment in payments:
             primaries.append(payment)
 
         if change > 0:
-            origin_crcat_record = await self.wallet_state_manager.coin_store.get_coin_record(list(cat_coins)[0].name())
+            origin_crcat_record = await self.wallet_state_manager.coin_store.get_coin_record(
+                next(iter(cat_coins)).name()
+            )
             if origin_crcat_record is None:
                 raise RuntimeError("A CR-CAT coin was selected that we don't have a record for")  # pragma: no cover
             origin_crcat = self.coin_record_to_crcat(origin_crcat_record)
@@ -456,10 +458,10 @@ class CRCATWallet(CATWallet):
                 for payment in payments:
                     if change_puzhash == payment.puzzle_hash and change == payment.amount:
                         # We cannot create two coins has same id, create a new puzhash for the change
-                        change_puzhash = await self.get_new_inner_hash()
+                        change_puzhash = await self.standard_wallet.get_puzzle_hash(new=True)
                         break
             else:
-                change_puzhash = await self.get_new_inner_hash()
+                change_puzhash = await self.standard_wallet.get_puzzle_hash(new=True)
             primaries.append(Payment(change_puzhash, uint64(change), [change_puzhash]))
 
         # Find the VC Wallet
@@ -474,12 +476,12 @@ class CRCATWallet(CATWallet):
 
         # Loop through the coins we've selected and gather the information we need to spend them
         vc: Optional[VerifiedCredential] = None
-        vc_announcements_to_make: List[bytes] = []
-        inner_spends: List[Tuple[CRCAT, int, Program, Program]] = []
+        vc_announcements_to_make: list[bytes] = []
+        inner_spends: list[tuple[CRCAT, int, Program, Program]] = []
         first = True
         announcement: CreateCoinAnnouncement
-        coin_ids: List[bytes32] = [coin.name() for coin in cat_coins]
-        coin_records: List[WalletCoinRecord] = (
+        coin_ids: list[bytes32] = [coin.name() for coin in cat_coins]
+        coin_records: list[WalletCoinRecord] = (
             await self.wallet_state_manager.coin_store.get_coin_records(coin_id_filter=HashFilter.include(coin_ids))
         ).records
         assert len(coin_records) == len(cat_coins)
@@ -596,17 +598,17 @@ class CRCATWallet(CATWallet):
 
     async def generate_signed_transaction(
         self,
-        amounts: List[uint64],
-        puzzle_hashes: List[bytes32],
+        amounts: list[uint64],
+        puzzle_hashes: list[bytes32],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        coins: Optional[Set[Coin]] = None,
-        memos: Optional[List[List[bytes]]] = None,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        coins: Optional[set[Coin]] = None,
+        memos: Optional[list[list[bytes]]] = None,
+        extra_conditions: tuple[Condition, ...] = tuple(),
         **kwargs: Unpack[GSTOptionalArgs],
     ) -> None:
         # (extra_delta, tail_reveal, tail_solution)
-        cat_discrepancy: Optional[Tuple[int, Program, Program]] = kwargs.get("cat_discrepancy", None)
+        cat_discrepancy: Optional[tuple[int, Program, Program]] = kwargs.get("cat_discrepancy", None)
         add_authorizations_to_cr_cats: bool = kwargs.get("add_authorizations_to_cr_cats", True)
         if memos is None:
             memos = [[] for _ in range(len(puzzle_hashes))]
@@ -616,7 +618,7 @@ class CRCATWallet(CATWallet):
 
         payments = []
         for amount, puzhash, memo_list in zip(amounts, puzzle_hashes, memos):
-            memos_with_hint: List[bytes] = [puzhash]
+            memos_with_hint: list[bytes] = [puzhash]
             memos_with_hint.extend(memo_list)
             # Force wrap the outgoing coins in the pending state if not going to us
             payments.append(
@@ -643,10 +645,10 @@ class CRCATWallet(CATWallet):
         )
 
         async with action_scope.use() as interface:
-            other_tx_removals: Set[Coin] = {
+            other_tx_removals: set[Coin] = {
                 removal for tx in interface.side_effects.transactions for removal in tx.removals
             }
-            other_tx_additions: Set[Coin] = {
+            other_tx_additions: set[Coin] = {
                 addition for tx in interface.side_effects.transactions for addition in tx.additions
             }
             tx_list = [
@@ -679,15 +681,15 @@ class CRCATWallet(CATWallet):
         min_amount_to_claim: uint64,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        coins: Optional[Set[Coin]] = None,
+        coins: Optional[set[Coin]] = None,
         min_coin_amount: Optional[uint64] = None,
         max_coin_amount: Optional[uint64] = None,
-        excluded_coin_amounts: Optional[List[uint64]] = None,
+        excluded_coin_amounts: Optional[list[uint64]] = None,
         reuse_puzhash: Optional[bool] = None,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         # Select the relevant CR-CAT coins
-        crcat_records: Set[WalletCoinRecord] = await self.wallet_state_manager.coin_store.get_unspent_coins_for_wallet(
+        crcat_records: set[WalletCoinRecord] = await self.wallet_state_manager.coin_store.get_unspent_coins_for_wallet(
             self.id(), CoinType.CRCAT_PENDING
         )
         if coins is None:
@@ -730,7 +732,7 @@ class CRCATWallet(CATWallet):
         ).get_tree_hash()
 
         # Make CR-CAT bundle
-        crcats_and_puzhashes: List[Tuple[CRCAT, bytes32]] = [
+        crcats_and_puzhashes: list[tuple[CRCAT, bytes32]] = [
             (crcat, CRCATWallet.get_metadata_from_record(record).inner_puzzle_hash)
             for record in [r for r in crcat_records if r.coin in coins]
             for crcat in [self.coin_record_to_crcat(record)]
@@ -775,8 +777,8 @@ class CRCATWallet(CATWallet):
         )
 
         async with action_scope.use() as interface:
-            other_additions: Set[Coin] = {rem for tx in interface.side_effects.transactions for rem in tx.additions}
-            other_removals: Set[Coin] = {rem for tx in interface.side_effects.transactions for rem in tx.removals}
+            other_additions: set[Coin] = {rem for tx in interface.side_effects.transactions for rem in tx.additions}
+            other_removals: set[Coin] = {rem for tx in interface.side_effects.transactions for rem in tx.removals}
             interface.side_effects.transactions.append(
                 TransactionRecord(
                     confirmed_at_height=uint32(0),

chia/wallet/vc_wallet/cr_outer_puzzle.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional, Tuple
+from typing import Any, Callable, Optional
 
 from clvm_tools.binutils import disassemble
 
@@ -23,11 +23,11 @@ class CROuterPuzzle:
     _get_inner_solution: Callable[[PuzzleInfo, Program], Optional[Program]]
 
     def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
-        args: Optional[Tuple[List[bytes32], Program, Program]] = match_cr_layer(puzzle)
+        args: Optional[tuple[list[bytes32], Program, Program]] = match_cr_layer(puzzle)
         if args is None:
             return None
         authorized_providers, proofs_checker, inner_puzzle = args
-        constructor_dict: Dict[str, Any] = {
+        constructor_dict: dict[str, Any] = {
             "type": "credential restricted",
             "authorized_providers": ["0x" + ap.hex() for ap in authorized_providers],
             "proofs_checker": disassemble(proofs_checker),
@@ -38,7 +38,7 @@ class CROuterPuzzle:
         return PuzzleInfo(constructor_dict)
 
     def get_inner_puzzle(self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle) -> Optional[Program]:
-        args: Optional[Tuple[List[bytes32], Program, Program]] = match_cr_layer(puzzle_reveal)
+        args: Optional[tuple[list[bytes32], Program, Program]] = match_cr_layer(puzzle_reveal)
         if args is None:
             raise ValueError("This driver is not for the specified puzzle reveal")  # pragma: no cover
         _, _, inner_puzzle = args

chia/wallet/vc_wallet/vc_drivers.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, replace
-from typing import List, Optional, Tuple, Type, TypeVar
+from typing import Optional, TypeVar
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
@@ -103,7 +103,7 @@ def create_covenant_layer(initial_puzzle_hash: bytes32, parent_morpher: Program,
     )
 
 
-def match_covenant_layer(uncurried_puzzle: UncurriedPuzzle) -> Optional[Tuple[bytes32, Program, Program]]:
+def match_covenant_layer(uncurried_puzzle: UncurriedPuzzle) -> Optional[tuple[bytes32, Program, Program]]:
     if uncurried_puzzle.mod == COVENANT_LAYER:
         return (
             bytes32(uncurried_puzzle.args.at("f").as_atom()),
@@ -166,7 +166,7 @@ def create_did_tp(
 EML_DID_TP_FULL_HASH = create_did_tp().get_tree_hash()
 
 
-def match_did_tp(uncurried_puzzle: UncurriedPuzzle) -> Optional[Tuple[()]]:
+def match_did_tp(uncurried_puzzle: UncurriedPuzzle) -> Optional[tuple[()]]:
     if uncurried_puzzle.mod == EML_DID_TP:
         return ()
     else:
@@ -198,7 +198,7 @@ def create_viral_backdoor(hidden_puzzle_hash: bytes32, inner_puzzle_hash: bytes3
     )
 
 
-def match_viral_backdoor(uncurried_puzzle: UncurriedPuzzle) -> Optional[Tuple[bytes32, bytes32]]:
+def match_viral_backdoor(uncurried_puzzle: UncurriedPuzzle) -> Optional[tuple[bytes32, bytes32]]:
     if uncurried_puzzle.mod == VIRAL_BACKDOOR:
         return bytes32(uncurried_puzzle.args.at("rf").as_atom()), bytes32(uncurried_puzzle.args.at("rrf").as_atom())
     else:
@@ -328,14 +328,14 @@ class VerifiedCredential(Streamable):
 
     @classmethod
     def launch(
-        cls: Type[_T_VerifiedCredential],
-        origin_coins: List[Coin],
+        cls: type[_T_VerifiedCredential],
+        origin_coins: list[Coin],
         provider_id: bytes32,
         new_inner_puzzle_hash: bytes32,
-        memos: List[bytes32],
+        memos: list[bytes32],
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
-    ) -> Tuple[List[Program], List[CoinSpend], _T_VerifiedCredential]:
+        extra_conditions: tuple[Condition, ...] = tuple(),
+    ) -> tuple[list[Program], list[CoinSpend], _T_VerifiedCredential]:
         """
         Launch a VC.
 
@@ -414,7 +414,7 @@ class VerifiedCredential(Streamable):
         )
 
         primary_dpuz: Program = Program.to((1, create_launcher_conditions))
-        additional_dpuzs: List[Program] = [Program.to((1, [[61, second_launcher_announcement_hash]]))]
+        additional_dpuzs: list[Program] = [Program.to((1, [[61, second_launcher_announcement_hash]]))]
         return (
             [primary_dpuz, *additional_dpuzs],
             [
@@ -496,7 +496,7 @@ class VerifiedCredential(Streamable):
     ####################################################################################################################
 
     @staticmethod
-    def is_vc(puzzle_reveal: UncurriedPuzzle) -> Tuple[bool, str]:
+    def is_vc(puzzle_reveal: UncurriedPuzzle) -> tuple[bool, str]:
         """
         This takes an (uncurried) puzzle reveal and returns a boolean for whether the puzzle is a VC and an error
         message for if the puzzle is a mismatch. Returns True for VC launcher spends.
@@ -555,7 +555,7 @@ class VerifiedCredential(Streamable):
         return True, ""
 
     @classmethod
-    def get_next_from_coin_spend(cls: Type[_T_VerifiedCredential], parent_spend: CoinSpend) -> _T_VerifiedCredential:
+    def get_next_from_coin_spend(cls: type[_T_VerifiedCredential], parent_spend: CoinSpend) -> _T_VerifiedCredential:
         """
         Given a coin spend, this will return the next VC that was create as an output of that spend. This is the main
         method to use when syncing. If a spend has been identified as having a VC puzzle reveal, running this method
@@ -585,7 +585,7 @@ class VerifiedCredential(Streamable):
             dpuz: Program = solution.at("rrf").at("f").at("f")
             dsol: Program = solution.at("rrf").at("f").at("rf")
 
-            conditions: List[Program] = list(dpuz.run(dsol).as_iter())
+            conditions: list[Program] = list(dpuz.run(dsol).as_iter())
             remark_condition: Program = next(c for c in conditions if c.at("f").as_int() == 1)
             inner_puzzle_hash = bytes32(remark_condition.at("rf").as_atom())
             magic_condition: Program = next(c for c in conditions if c.at("f").as_int() == -10)
@@ -707,7 +707,7 @@ class VerifiedCredential(Streamable):
         inner_solution: Program,
         new_proof_hash: Optional[bytes32] = None,
         new_proof_provider: Optional[bytes32] = None,
-    ) -> Tuple[Optional[CreatePuzzleAnnouncement], CoinSpend, VerifiedCredential]:
+    ) -> tuple[Optional[CreatePuzzleAnnouncement], CoinSpend, VerifiedCredential]:
         """
         Given an inner puzzle reveal and solution, spend the VC (potentially updating the proofs in the process).
         Note that the inner puzzle is already expected to output the 'magic' condition (which can be created above).
@@ -760,7 +760,7 @@ class VerifiedCredential(Streamable):
 
     def activate_backdoor(
         self, provider_innerpuzhash: bytes32, announcement_nonce: Optional[bytes32] = None
-    ) -> Tuple[CreatePuzzleAnnouncement, CoinSpend]:
+    ) -> tuple[CreatePuzzleAnnouncement, CoinSpend]:
         """
         Activates the backdoor in the VC to revoke the credentials and remove the provider's DID.
 
@@ -810,7 +810,7 @@ class VerifiedCredential(Streamable):
         Private method that creates the next VC class instance.
         """
         slightly_incomplete_vc: VerifiedCredential = VerifiedCredential(
-            Coin(self.coin.name(), bytes32([0] * 32), next_amount),
+            Coin(self.coin.name(), bytes32.zeros, next_amount),
             LineageProof(
                 self.coin.parent_coin_info,
                 self.construct_exigent_metadata_layer().get_tree_hash(),

chia/wallet/vc_wallet/vc_store.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import dataclasses
 from functools import cmp_to_key
-from typing import Dict, List, Optional, Tuple, Type, TypeVar
+from typing import Optional, TypeVar
 
 from aiosqlite import Row
 
@@ -19,10 +19,10 @@ from chia.wallet.vc_wallet.vc_drivers import VCLineageProof, VerifiedCredential
 
 @dataclasses.dataclass(frozen=True)
 class VCProofs:
-    key_value_pairs: Dict[str, str]
+    key_value_pairs: dict[str, str]
 
     def as_program(self) -> Program:
-        def byte_sort_pairs(f1: Tuple[str, str], f2: Tuple[str, str]) -> int:
+        def byte_sort_pairs(f1: tuple[str, str], f2: tuple[str, str]) -> int:
             return 1 if Program.to([10, (1, f1[0]), (1, f2[0])]).run([]) == Program.to(None) else -1
 
         prog: Program = Program.to(
@@ -45,7 +45,7 @@ class VCProofs:
         first: Program = prog.at("f")
         rest: Program = prog.at("r")
         if first.atom is None and rest.atom is None:
-            final_dict: Dict[str, str] = {}
+            final_dict: dict[str, str] = {}
             final_dict.update(VCProofs.from_program(first).key_value_pairs)
             final_dict.update(VCProofs.from_program(rest).key_value_pairs)
             return VCProofs(final_dict)
@@ -54,7 +54,7 @@ class VCProofs:
         else:
             raise ValueError("Malformatted VCProofs program")  # pragma: no cover
 
-    def prove_keys(self, keys: List[str], tree: Optional[Program] = None) -> Program:
+    def prove_keys(self, keys: list[str], tree: Optional[Program] = None) -> Program:
         if tree is None:
             tree = self.as_program()
 
@@ -114,7 +114,7 @@ class VCStore:
     db_wrapper: DBWrapper2
 
     @classmethod
-    async def create(cls: Type[_T_VCStore], db_wrapper: DBWrapper2) -> _T_VCStore:
+    async def create(cls: type[_T_VCStore], db_wrapper: DBWrapper2) -> _T_VCStore:
         self = cls()
 
         self.db_wrapper = db_wrapper
@@ -191,7 +191,7 @@ class VCStore:
             return _row_to_vc_record(row)
         return None
 
-    async def get_vc_records_by_providers(self, provider_ids: List[bytes32]) -> List[VCRecord]:  # pragma: no cover
+    async def get_vc_records_by_providers(self, provider_ids: list[bytes32]) -> list[VCRecord]:  # pragma: no cover
         """
         Checks DB for VCs with a proof_provider in a specified list and returns them.
         """
@@ -206,7 +206,7 @@ class VCStore:
 
         return [_row_to_vc_record(row) for row in rows]
 
-    async def get_unconfirmed_vcs(self) -> List[VCRecord]:
+    async def get_unconfirmed_vcs(self) -> list[VCRecord]:
         """
         Returns all VCs that have not yet been marked confirmed (confirmed_height == 0)
         """
@@ -222,7 +222,7 @@ class VCStore:
         self,
         start_index: int = 0,
         count: int = 50,
-    ) -> List[VCRecord]:
+    ) -> list[VCRecord]:
         """
         Return all VCs
         :param start_index: Start index