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

chia/wallet/cat_wallet/cat_wallet.py

@@ -4,7 +4,7 @@ import dataclasses
 import logging
 import time
 import traceback
-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 G1Element
 from typing_extensions import Unpack
@@ -69,12 +69,12 @@ CAT_MOD_HASH_HASH = Program.to(CAT_MOD_HASH).get_tree_hash()
 QUOTED_MOD_HASH = calculate_hash_of_quoted_mod_hash(CAT_MOD_HASH)
 
 
-def not_ephemeral_additions(sp: WalletSpendBundle) -> List[Coin]:
-    removals: Set[Coin] = set()
+def not_ephemeral_additions(sp: WalletSpendBundle) -> list[Coin]:
+    removals: set[Coin] = set()
     for cs in sp.coin_spends:
         removals.add(cs.coin)
 
-    additions: List[Coin] = []
+    additions: list[Coin] = []
     max_cost = int(DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM)
     for cs in sp.coin_spends:
         coins, cost = compute_additions_with_cost(cs, max_cost=max_cost)
@@ -106,7 +106,7 @@ class 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),
@@ -144,10 +144,10 @@ class CATWallet:
             )
             assert self.cat_info.limitations_program_hash != empty_bytes
         except Exception:
-            await wallet_state_manager.user_store.delete_wallet(self.id())
+            await wallet_state_manager.delete_wallet(self.id())
             raise
         if spend_bundle is None:
-            await wallet_state_manager.user_store.delete_wallet(self.id())
+            await wallet_state_manager.delete_wallet(self.id())
             raise ValueError("Failed to create spend.")
 
         await self.wallet_state_manager.add_new_wallet(self)
@@ -160,7 +160,7 @@ class CATWallet:
             await self.set_name(name)
 
         # Change and actual CAT coin
-        non_ephemeral_coins: List[Coin] = not_ephemeral_additions(spend_bundle)
+        non_ephemeral_coins: list[Coin] = not_ephemeral_additions(spend_bundle)
         cat_coin = None
         puzzle_store = self.wallet_state_manager.puzzle_store
         for c in non_ephemeral_coins:
@@ -257,7 +257,7 @@ class 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:
         next_layer: Optional[PuzzleInfo] = puzzle_driver.also()
         if next_layer is not None:
@@ -310,7 +310,7 @@ class CATWallet:
     def id(self) -> uint32:
         return self.wallet_info.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:
         if record_list is None:
             record_list = await self.wallet_state_manager.coin_store.get_unspent_coins_for_wallet(self.id())
 
@@ -323,7 +323,7 @@ class CATWallet:
         self.log.info(f"Confirmed balance for cat wallet {self.id()} is {amount}")
         return uint128(amount)
 
-    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)
 
     @property
@@ -335,14 +335,14 @@ class CATWallet:
         # avoid full block TXs
         return int(self.wallet_state_manager.constants.MAX_BLOCK_COST_CLVM / 2 / 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()))
 
     def get_name(self) -> str:
@@ -422,27 +422,6 @@ class CATWallet:
                         # We also need to make sure there's no record of the transaction
                         await self.wallet_state_manager.tx_store.delete_transaction_record(record.coin.name())
 
-    async def get_new_inner_hash(self) -> bytes32:
-        puzzle = await self.get_new_inner_puzzle()
-        return puzzle.get_tree_hash()
-
-    async def get_new_inner_puzzle(self) -> Program:
-        return await self.standard_wallet.get_new_puzzle()
-
-    async def get_new_puzzlehash(self) -> bytes32:
-        return await self.standard_wallet.get_new_puzzlehash()
-
-    async def get_puzzle_hash(self, new: bool) -> bytes32:
-        if new:
-            return await self.get_new_puzzlehash()
-        else:
-            record: Optional[DerivationRecord] = (
-                await self.wallet_state_manager.get_current_derivation_record_for_wallet(self.standard_wallet.id())
-            )
-            if record is None:
-                return await self.get_new_puzzlehash()
-            return record.puzzle_hash
-
     def require_derivation_paths(self) -> bool:
         return True
 
@@ -456,10 +435,17 @@ class CATWallet:
         limitations_program_hash_hash = Program.to(self.cat_info.limitations_program_hash).get_tree_hash()
         return curry_and_treehash(QUOTED_MOD_HASH, CAT_MOD_HASH_HASH, limitations_program_hash_hash, inner_puzzle_hash)
 
-    async def get_new_cat_puzzle_hash(self) -> bytes32:
-        return (await self.wallet_state_manager.get_unused_derivation_record(self.id())).puzzle_hash
+    async def get_cat_puzzle_hash(self, new: bool) -> bytes32:
+        if new:
+            return (await self.wallet_state_manager.get_unused_derivation_record(self.id())).puzzle_hash
+        else:
+            derivation_record = await self.wallet_state_manager.get_current_derivation_record_for_wallet(self.id())
+            if derivation_record is None:
+                return (await self.wallet_state_manager.get_unused_derivation_record(self.id())).puzzle_hash
+
+            return derivation_record.puzzle_hash
 
-    async def get_spendable_balance(self, records: Optional[Set[WalletCoinRecord]] = None) -> uint128:
+    async def get_spendable_balance(self, records: Optional[set[WalletCoinRecord]] = None) -> uint128:
         coins = await self.get_cat_spendable_coins(records)
         amount = 0
         for record in coins:
@@ -493,10 +479,10 @@ class CATWallet:
 
         return uint64(addition_amount)
 
-    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
         )
 
@@ -511,17 +497,17 @@ class CATWallet:
         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] = await self.get_cat_spendable_coins()
+        spendable_coins: list[WalletCoinRecord] = await self.get_cat_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:
@@ -538,18 +524,18 @@ class CATWallet:
         return coins
 
     async def inner_puzzle_for_cat_puzhash(self, cat_hash: bytes32) -> Program:
-        record: Optional[DerivationRecord] = (
-            await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(cat_hash)
-        )
+        record: Optional[
+            DerivationRecord
+        ] = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(cat_hash)
         if record is None:
             raise RuntimeError(f"Missing Derivation Record for CAT puzzle_hash {cat_hash}")
         inner_puzzle: Program = self.standard_wallet.puzzle_for_pk(record.pubkey)
         return inner_puzzle
 
     async def convert_puzzle_hash(self, puzzle_hash: bytes32) -> bytes32:
-        record: Optional[DerivationRecord] = (
-            await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(puzzle_hash)
-        )
+        record: Optional[
+            DerivationRecord
+        ] = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(puzzle_hash)
         if record is None:
             return puzzle_hash  # TODO: check if we have a test for this case!
         else:
@@ -563,7 +549,7 @@ class CATWallet:
         fee: uint64,
         amount_to_claim: uint64,
         action_scope: WalletActionScope,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> Optional[AssertCoinAnnouncement]:
         """
         This function creates a non-CAT transaction to pay fees, contribute funds for issuance, and absorb melt value.
@@ -579,7 +565,7 @@ class CATWallet:
                     fee,
                     action_scope,
                 )
-                origin_id = list(chia_coins)[0].name()
+                origin_id = next(iter(chia_coins)).name()
                 await self.standard_wallet.generate_signed_transaction(
                     uint64(0),
                     (await self.standard_wallet.get_puzzle_hash(not action_scope.config.tx_config.reuse_puzhash)),
@@ -595,7 +581,7 @@ class CATWallet:
                     fee,
                     action_scope,
                 )
-                origin_id = list(chia_coins)[0].name()
+                origin_id = next(iter(chia_coins)).name()
                 selected_amount = sum(c.amount for c in chia_coins)
                 await self.standard_wallet.generate_signed_transaction(
                     uint64(selected_amount + amount_to_claim - fee),
@@ -627,12 +613,12 @@ class 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(),
     ) -> WalletSpendBundle:
         if cat_discrepancy is not None:
             extra_delta, tail_reveal, tail_solution = cat_discrepancy
@@ -666,17 +652,17 @@ class CATWallet:
 
         if change > 0:
             derivation_record = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(
-                list(cat_coins)[0].puzzle_hash
+                next(iter(cat_coins)).puzzle_hash
             )
             if derivation_record is not None and action_scope.config.tx_config.reuse_puzhash:
                 change_puzhash = self.standard_wallet.puzzle_hash_for_pk(derivation_record.pubkey)
                 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]))
 
         # Loop through the coins we've selected and gather the information we need to spend them
@@ -756,17 +742,17 @@ class 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)
         if memos is None:
             memos = [[] for _ in range(len(puzzle_hashes))]
 
@@ -775,7 +761,7 @@ class 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)
             payments.append(Payment(puzhash, amount, memos_with_hint))
 
@@ -790,10 +776,10 @@ class 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] = {
                 removal for tx in interface.side_effects.transactions for removal in tx.additions
             }
             interface.side_effects.transactions.append(
@@ -854,7 +840,7 @@ class CATWallet:
         asset_id: Optional[bytes32],
         amount: uint64,
         action_scope: WalletActionScope,
-    ) -> Set[Coin]:
+    ) -> set[Coin]:
         balance = await self.get_confirmed_balance()
         if balance < amount:
             raise Exception(f"insufficient funds in wallet {self.id()}")

chia/wallet/cat_wallet/dao_cat_info.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Optional
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
@@ -15,7 +15,7 @@ from chia.util.streamable import Streamable, streamable
 class LockedCoinInfo(Streamable):
     coin: Coin
     inner_puzzle: Program  # This is the lockup puzzle, not the lockup_puzzle's inner_puzzle
-    active_votes: List[Optional[bytes32]]
+    active_votes: list[Optional[bytes32]]
 
 
 @streamable
@@ -25,4 +25,4 @@ class DAOCATInfo(Streamable):
     free_cat_wallet_id: uint64
     limitations_program_hash: bytes32
     my_tail: Optional[Program]  # this is the program
-    locked_coins: List[LockedCoinInfo]
+    locked_coins: list[LockedCoinInfo]

chia/wallet/cat_wallet/dao_cat_wallet.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 import time
-from typing import TYPE_CHECKING, Any, ClassVar, List, Optional, Set, Tuple, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
 from chia_rs import G1Element
 
@@ -152,7 +152,7 @@ class DAOCATWallet:
         parent_spend = await fetch_coin_spend(height, parent_coin.coin, peer)
         uncurried = parent_spend.puzzle_reveal.uncurry()
         cat_inner = uncurried[1].at("rrf")
-        active_votes_list: List[Optional[bytes32]] = []
+        active_votes_list: list[Optional[bytes32]] = []
 
         record = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(coin.puzzle_hash)
         if record:
@@ -227,7 +227,7 @@ class DAOCATWallet:
         self.log.info(f"Removing parent {name} (probably had a non-CAT parent)")
         await self.lineage_store.remove_lineage_proof(name)
 
-    async def advanced_select_coins(self, amount: uint64, proposal_id: bytes32) -> List[LockedCoinInfo]:
+    async def advanced_select_coins(self, amount: uint64, proposal_id: bytes32) -> list[LockedCoinInfo]:
         coins = []
         s = 0
         for coin in self.dao_cat_info.locked_coins:
@@ -258,7 +258,7 @@ class DAOCATWallet:
         is_yes_vote: bool,
         proposal_puzzle: Optional[Program] = None,
     ) -> WalletSpendBundle:
-        coins: List[LockedCoinInfo] = await self.advanced_select_coins(amount, proposal_id)
+        coins: list[LockedCoinInfo] = await self.advanced_select_coins(amount, proposal_id)
         running_sum = 0  # this will be used for change calculation
         change = sum(c.coin.amount for c in coins) - amount
         extra_delta, limitations_solution = 0, Program.to([])
@@ -288,7 +288,7 @@ class DAOCATWallet:
             lockup_innerpuz_list = []
             if running_sum + coin.amount <= amount:
                 vote_amount = coin.amount
-                running_sum = running_sum + coin.amount
+                running_sum += coin.amount
                 primaries = [
                     Payment(
                         new_innerpuzzle.get_tree_hash(),
@@ -303,7 +303,7 @@ class DAOCATWallet:
                 )
             else:
                 vote_amount = uint64(amount - running_sum)
-                running_sum = running_sum + coin.amount
+                running_sum += coin.amount
                 primaries = [
                     Payment(
                         new_innerpuzzle.get_tree_hash(),
@@ -365,8 +365,8 @@ class DAOCATWallet:
         amount: uint64,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
-    ) -> List[TransactionRecord]:
+        extra_conditions: tuple[Condition, ...] = tuple(),
+    ) -> list[TransactionRecord]:
         """
         Enter existing CATs for the DAO into voting mode
         """
@@ -378,7 +378,7 @@ class DAOCATWallet:
         # get the lockup puzzle hash
         lockup_puzzle = await self.get_new_puzzle()
         # create the cat spend
-        txs: List[TransactionRecord] = await cat_wallet.generate_signed_transaction(
+        txs: list[TransactionRecord] = await cat_wallet.generate_signed_transaction(
             [amount],
             [lockup_puzzle.get_tree_hash()],
             action_scope,
@@ -393,10 +393,10 @@ class DAOCATWallet:
 
     async def exit_vote_state(
         self,
-        coins: List[LockedCoinInfo],
+        coins: list[LockedCoinInfo],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         extra_delta, limitations_solution = 0, Program.to([])
         limitations_program_reveal = Program.to([])
@@ -495,11 +495,11 @@ class DAOCATWallet:
 
     async def remove_active_proposal(
         self,
-        proposal_id_list: List[bytes32],
+        proposal_id_list: list[bytes32],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
     ) -> WalletSpendBundle:
-        locked_coins: List[Tuple[LockedCoinInfo, List[bytes32]]] = []
+        locked_coins: list[tuple[LockedCoinInfo, list[bytes32]]] = []
         for lci in self.dao_cat_info.locked_coins:
             my_finished_proposals = []
             for active_vote in lci.active_votes:
@@ -609,16 +609,16 @@ class DAOCATWallet:
     async def match_hinted_coin(self, coin: Coin, hint: bytes32) -> bool:
         raise NotImplementedError("Method not implemented for DAO CAT Wallet")  # pragma: no cover
 
-    async def get_spendable_balance(self, records: Optional[Set[WalletCoinRecord]] = None) -> uint128:
+    async def get_spendable_balance(self, records: Optional[set[WalletCoinRecord]] = None) -> uint128:
         return uint128(0)
 
-    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:
         amount = 0
         for coin in self.dao_cat_info.locked_coins:
             amount += coin.coin.amount
         return uint128(amount)
 
-    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 uint128(0)
 
     async def get_pending_change_balance(self) -> uint64:
@@ -628,10 +628,10 @@ class DAOCATWallet:
         self,
         amount: uint64,
         action_scope: WalletActionScope,
-    ) -> Set[Coin]:
+    ) -> set[Coin]:
         return set()
 
-    async def get_max_send_amount(self, unspent_records: Optional[Set[WalletCoinRecord]] = None) -> uint128:
+    async def get_max_send_amount(self, unspent_records: Optional[set[WalletCoinRecord]] = None) -> uint128:
         return uint128(0)
 
     async def get_votable_balance(

chia/wallet/cat_wallet/lineage_store.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Dict, Optional
+from typing import Optional
 
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.db_wrapper import DBWrapper2
@@ -60,7 +60,7 @@ class CATLineageStore:
 
         return None
 
-    async def get_all_lineage_proofs(self) -> Dict[bytes32, LineageProof]:
+    async def get_all_lineage_proofs(self) -> dict[bytes32, LineageProof]:
         async with self.db_wrapper.reader_no_transaction() as conn:
             cursor = await conn.execute(f"SELECT * FROM {self.table_name}")
             rows = await cursor.fetchall()

chia/wallet/coin_selection.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 import random
-from typing import Dict, List, Optional, Set
+from typing import Optional
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -14,11 +14,11 @@ from chia.wallet.wallet_coin_record import WalletCoinRecord
 async def select_coins(
     spendable_amount: uint128,
     coin_selection_config: CoinSelectionConfig,
-    spendable_coins: List[WalletCoinRecord],
-    unconfirmed_removals: Dict[bytes32, Coin],
+    spendable_coins: list[WalletCoinRecord],
+    unconfirmed_removals: dict[bytes32, Coin],
     log: logging.Logger,
     amount: uint128,
-) -> Set[Coin]:
+) -> set[Coin]:
     """
     Returns a set of coins that can be used for generating a new transaction.
     """
@@ -33,7 +33,7 @@ async def select_coins(
 
     max_num_coins = 500
     sum_spendable_coins = 0
-    valid_spendable_coins: List[Coin] = []
+    valid_spendable_coins: list[Coin] = []
 
     for coin_record in spendable_coins:  # remove all the unconfirmed coins, excluded coins and dust.
         coin_name: bytes32 = coin_record.coin.name()
@@ -76,7 +76,7 @@ async def select_coins(
     # Check for an exact match with all of the coins smaller than the amount.
     # If we have more, smaller coins than the amount we run the next algorithm.
     smaller_coin_sum = 0  # coins smaller than target.
-    smaller_coins: List[Coin] = []
+    smaller_coins: list[Coin] = []
     for coin in valid_spendable_coins:
         if coin.amount < amount:
             smaller_coin_sum += coin.amount
@@ -90,7 +90,7 @@ async def select_coins(
         log.debug(f"Selected closest greater coin: {smallest_coin.name()}")
         return {smallest_coin}
     elif smaller_coin_sum > amount:
-        coin_set: Optional[Set[Coin]] = knapsack_coin_algorithm(
+        coin_set: Optional[set[Coin]] = knapsack_coin_algorithm(
             smaller_coins, amount, coin_selection_config.max_coin_amount, max_num_coins
         )
         log.debug(f"Selected coins from knapsack algorithm: {coin_set}")
@@ -119,7 +119,7 @@ async def select_coins(
 
 
 # we use this to check if one of the coins exactly matches the target.
-def check_for_exact_match(coin_list: List[Coin], target: uint64) -> Optional[Coin]:
+def check_for_exact_match(coin_list: list[Coin], target: uint64) -> Optional[Coin]:
     for coin in coin_list:
         if coin.amount == target:
             return coin
@@ -128,7 +128,7 @@ def check_for_exact_match(coin_list: List[Coin], target: uint64) -> Optional[Coi
 
 # amount of coins smaller than target, followed by a list of all valid spendable coins.
 # Coins must be sorted in descending amount order.
-def select_smallest_coin_over_target(target: uint128, sorted_coin_list: List[Coin]) -> Optional[Coin]:
+def select_smallest_coin_over_target(target: uint128, sorted_coin_list: list[Coin]) -> Optional[Coin]:
     if sorted_coin_list[0].amount < target:
         return None
     for coin in reversed(sorted_coin_list):
@@ -140,15 +140,15 @@ def select_smallest_coin_over_target(target: uint128, sorted_coin_list: List[Coi
 # we use this to find the set of coins which have total value closest to the target, but at least the target.
 # IMPORTANT: The coins have to be sorted in descending order or else this function will not work.
 def knapsack_coin_algorithm(
-    smaller_coins: List[Coin], target: uint128, max_coin_amount: int, max_num_coins: int, seed: bytes = b"knapsack seed"
-) -> Optional[Set[Coin]]:
+    smaller_coins: list[Coin], target: uint128, max_coin_amount: int, max_num_coins: int, seed: bytes = b"knapsack seed"
+) -> Optional[set[Coin]]:
     best_set_sum = max_coin_amount
-    best_set_of_coins: Optional[Set[Coin]] = None
+    best_set_of_coins: Optional[set[Coin]] = None
     ran: random.Random = random.Random()
     ran.seed(seed)
     for i in range(1000):
         # reset these variables every loop.
-        selected_coins: Set[Coin] = set()
+        selected_coins: set[Coin] = set()
         selected_coins_sum = 0
         n_pass = 0
         target_reached = False
@@ -177,9 +177,9 @@ def knapsack_coin_algorithm(
 
 # Adds up the largest coins in the list, resulting in the minimum number of selected coins. A solution
 # is guaranteed if and only if the sum(coins) >= target. Coins must be sorted in descending amount order.
-def sum_largest_coins(target: uint128, sorted_coins: List[Coin]) -> Optional[Set[Coin]]:
+def sum_largest_coins(target: uint128, sorted_coins: list[Coin]) -> Optional[set[Coin]]:
     total_value = 0
-    selected_coins: Set[Coin] = set()
+    selected_coins: set[Coin] = set()
     for coin in sorted_coins:
         total_value += coin.amount
         selected_coins.add(coin)