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

chia/wallet/dao_wallet/dao_utils.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import logging
+from collections.abc import Iterator
 from itertools import chain
-from typing import Any, Iterator, List, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 from clvm.EvalError import EvalError
 
@@ -217,7 +218,7 @@ def get_p2_singleton_puzhash(treasury_id: bytes32, asset_id: Optional[bytes32] =
 
 def get_lockup_puzzle(
     cat_tail_hash: Union[bytes32, Program],
-    previous_votes_list: Union[List[Optional[bytes32]], Program],
+    previous_votes_list: Union[list[Optional[bytes32]], Program],
     innerpuz: Optional[Program],
 ) -> Program:
     self_hash: Program = DAO_LOCKUP_MOD.curry(
@@ -240,13 +241,13 @@ def add_proposal_to_active_list(
 ) -> Program:
     curried_args, c_a = uncurry_lockup(lockup_puzzle)
     (
-        SINGLETON_MOD_HASH,
-        SINGLETON_LAUNCHER_PUZHASH,
-        DAO_FINISHED_STATE_HASH,
-        CAT_MOD_HASH,
+        _SINGLETON_MOD_HASH,
+        _SINGLETON_LAUNCHER_PUZHASH,
+        _DAO_FINISHED_STATE_HASH,
+        _CAT_MOD_HASH,
         CAT_TAIL_HASH,
     ) = c_a.as_iter()
-    (SELF_HASH, ACTIVE_VOTES, INNERPUZ) = curried_args.as_iter()
+    (_SELF_HASH, ACTIVE_VOTES, INNERPUZ) = curried_args.as_iter()
     new_active_votes = Program.to(proposal_id).cons(ACTIVE_VOTES)  # (c proposal_id ACTIVE_VOTES)
     if inner_puzzle is None:
         inner_puzzle = INNERPUZ
@@ -263,7 +264,7 @@ def get_active_votes_from_lockup_puzzle(lockup_puzzle: Program) -> Program:
         _CAT_TAIL_HASH,
     ) = list(c_a.as_iter())
     (
-        self_hash,
+        _self_hash,
         ACTIVE_VOTES,
         _INNERPUZ,
     ) = curried_args.as_iter()
@@ -284,7 +285,7 @@ def get_innerpuz_from_lockup_puzzle(lockup_puzzle: Program) -> Optional[Program]
         _CAT_TAIL_HASH,
     ) = list(c_a.as_iter())
     (
-        self_hash,
+        _self_hash,
         _ACTIVE_VOTES,
         INNERPUZ,
     ) = list(curried_args.as_iter())
@@ -394,10 +395,10 @@ def get_treasury_rules_from_puzzle(puzzle_reveal: Optional[Program]) -> DAORules
     ) = curried_args
     curried_args_prg = uncurry_proposal_validator(proposal_validator)
     (
-        SINGLETON_STRUCT,
-        PROPOSAL_SELF_HASH,
+        _SINGLETON_STRUCT,
+        _PROPOSAL_SELF_HASH,
         PROPOSAL_MINIMUM_AMOUNT,
-        PAYOUT_PUZHASH,
+        _PAYOUT_PUZHASH,
     ) = curried_args_prg.as_iter()
     return DAORules(
         uint64(proposal_timelock.as_int()),
@@ -419,7 +420,7 @@ def get_new_puzzle_from_treasury_solution(puzzle_reveal: Program, solution: Prog
         if mod == DAO_UPDATE_PROPOSAL_MOD:
             (
                 DAO_TREASURY_MOD_HASH,
-                DAO_VALIDATOR_MOD_HASH,
+                _DAO_VALIDATOR_MOD_HASH,
                 TREASURY_SINGLETON_STRUCT,
                 PROPOSAL_SELF_HASH,
                 proposal_minimum_amount,
@@ -462,19 +463,19 @@ def get_new_puzzle_from_proposal_solution(puzzle_reveal: Program, solution: Prog
         c_a, curried_args = uncurry_proposal(puzzle_reveal)
         assert isinstance(curried_args, Program)
         (
-            DAO_PROPOSAL_TIMER_MOD_HASH,
-            SINGLETON_MOD_HASH,
-            SINGLETON_LAUNCHER_PUZHASH,
-            CAT_MOD_HASH,
-            DAO_FINISHED_STATE_HASH,
-            DAO_TREASURY_MOD_HASH,
-            lockup_self_hash,
+            _DAO_PROPOSAL_TIMER_MOD_HASH,
+            _SINGLETON_MOD_HASH,
+            _SINGLETON_LAUNCHER_PUZHASH,
+            _CAT_MOD_HASH,
+            _DAO_FINISHED_STATE_HASH,
+            _DAO_TREASURY_MOD_HASH,
+            _lockup_self_hash,
             cat_tail_hash,
             treasury_id,
         ) = curried_args.as_iter()
         assert isinstance(c_a, Program)
         (
-            curry_one,
+            _curry_one,
             proposal_id,
             proposed_puzzle_hash,
             yes_votes,
@@ -508,25 +509,25 @@ def get_new_puzzle_from_proposal_solution(puzzle_reveal: Program, solution: Prog
         if mod.uncurry()[0] == DAO_PROPOSAL_MOD:
             c_a, curried_args = uncurry_proposal(puzzle_reveal)
             (
-                DAO_PROPOSAL_TIMER_MOD_HASH,
-                SINGLETON_MOD_HASH,
-                SINGLETON_LAUNCHER_PUZHASH,
-                CAT_MOD_HASH,
-                DAO_FINISHED_STATE_HASH,
-                DAO_TREASURY_MOD_HASH,
-                lockup_self_hash,
+                _DAO_PROPOSAL_TIMER_MOD_HASH,
+                _SINGLETON_MOD_HASH,
+                _SINGLETON_LAUNCHER_PUZHASH,
+                _CAT_MOD_HASH,
+                _DAO_FINISHED_STATE_HASH,
+                _DAO_TREASURY_MOD_HASH,
+                _lockup_self_hash,
                 cat_tail_hash,
                 treasury_id,
             ) = curried_args.as_iter()
             (
-                curry_one,
+                _curry_one,
                 proposal_id,
                 proposed_puzzle_hash,
                 yes_votes,
                 total_votes,
             ) = c_a.as_iter()
         else:  # pragma: no cover
-            SINGLETON_STRUCT, dao_finished_hash = currieds.as_iter()
+            SINGLETON_STRUCT, _dao_finished_hash = currieds.as_iter()
             proposal_id = SINGLETON_STRUCT.rest().first()
         return get_finished_state_inner_puzzle(bytes32(proposal_id.as_atom()))
 
@@ -570,7 +571,7 @@ def uncurry_proposal_validator(proposal_validator_program: Program) -> Program:
     return curried_args
 
 
-def uncurry_treasury(treasury_puzzle: Program) -> List[Program]:
+def uncurry_treasury(treasury_puzzle: Program) -> list[Program]:
     try:
         mod, curried_args = treasury_puzzle.uncurry()
     except ValueError as e:  # pragma: no cover
@@ -582,7 +583,7 @@ def uncurry_treasury(treasury_puzzle: Program) -> List[Program]:
     return list(curried_args.as_iter())
 
 
-def uncurry_proposal(proposal_puzzle: Program) -> Tuple[Program, Program]:
+def uncurry_proposal(proposal_puzzle: Program) -> tuple[Program, Program]:
     try:
         mod, curried_args = proposal_puzzle.uncurry()
     except ValueError as e:  # pragma: no cover
@@ -598,7 +599,7 @@ def uncurry_proposal(proposal_puzzle: Program) -> Tuple[Program, Program]:
     return curried_args, c_a
 
 
-def uncurry_lockup(lockup_puzzle: Program) -> Tuple[Program, Program]:
+def uncurry_lockup(lockup_puzzle: Program) -> tuple[Program, Program]:
     try:
         mod, curried_args = lockup_puzzle.uncurry()
     except ValueError as e:  # pragma: no cover
@@ -615,7 +616,7 @@ def uncurry_lockup(lockup_puzzle: Program) -> Tuple[Program, Program]:
 
 
 # This is the proposed puzzle
-def get_proposal_args(puzzle: Program) -> Tuple[ProposalType, Program]:
+def get_proposal_args(puzzle: Program) -> tuple[ProposalType, Program]:
     try:
         mod, curried_args = puzzle.uncurry()
     except ValueError as e:  # pragma: no cover
@@ -697,7 +698,7 @@ def match_finished_puzzle(mod: Program, curried_args: Program) -> Optional[Itera
 
 # This is used in WSM to determine whether we have a dao funding spend
 def match_funding_puzzle(
-    uncurried: UncurriedPuzzle, solution: Program, coin: Coin, dao_ids: List[bytes32] = []
+    uncurried: UncurriedPuzzle, solution: Program, coin: Coin, dao_ids: list[bytes32] = []
 ) -> Optional[bool]:
     if not dao_ids:
         return None
@@ -710,7 +711,7 @@ def match_funding_puzzle(
             inner_puz, _ = uncurried.args.at("rf").uncurry()
             if inner_puz == DAO_TREASURY_MOD:
                 delegated_puz = solution.at("rrfrrf")
-                delegated_mod, delegated_args = delegated_puz.uncurry()
+                _delegated_mod, delegated_args = delegated_puz.uncurry()
                 if delegated_puz.uncurry()[0] == SPEND_P2_SINGLETON_MOD:
                     if coin.puzzle_hash == delegated_args.at("rrrrf").as_atom():  # pragma: no cover
                         return True
@@ -744,19 +745,19 @@ def match_dao_cat_puzzle(uncurried: UncurriedPuzzle) -> Optional[Iterator[Progra
 
 def generate_simple_proposal_innerpuz(
     treasury_id: bytes32,
-    recipient_puzhashes: List[bytes32],
-    amounts: List[uint64],
-    asset_types: List[Optional[bytes32]] = [None],
+    recipient_puzhashes: list[bytes32],
+    amounts: list[uint64],
+    asset_types: list[Optional[bytes32]] = [None],
 ) -> Program:
     if len(recipient_puzhashes) != len(amounts) != len(asset_types):  # pragma: no cover
         raise ValueError("Mismatch in the number of recipients, amounts, or asset types")
-    xch_conds: List[Any] = []
-    cat_conds: List[Any] = []
+    xch_conds: list[Any] = []
+    cat_conds: list[Any] = []
     seen_assets = set()
     for recipient_puzhash, amount, asset_type in zip(recipient_puzhashes, amounts, asset_types):
         if asset_type:
             if asset_type in seen_assets:
-                asset_conds = [x for x in cat_conds if x[0] == asset_type][0]
+                asset_conds = next(x for x in cat_conds if x[0] == asset_type)
                 asset_conds[1].append([51, recipient_puzhash, amount, [recipient_puzhash]])
             else:
                 cat_conds.append([asset_type, [[51, recipient_puzhash, amount, [recipient_puzhash]]]])

chia/wallet/dao_wallet/dao_wallet.py

@@ -6,7 +6,7 @@ import json
 import logging
 import re
 import time
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Set, Tuple, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
 
 from chia_rs import AugSchemeMPL, G1Element, G2Element
 from clvm.casts import int_from_bytes
@@ -21,9 +21,13 @@ from chia.types.coin_spend import CoinSpend, make_spend
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.util.ints import uint32, uint64, uint128
 from chia.wallet import singleton
-from chia.wallet.cat_wallet.cat_utils import CAT_MOD, SpendableCAT, construct_cat_puzzle
+from chia.wallet.cat_wallet.cat_utils import (
+    CAT_MOD,
+    SpendableCAT,
+    construct_cat_puzzle,
+    unsigned_spend_bundle_for_spendable_cats,
+)
 from chia.wallet.cat_wallet.cat_utils import get_innerpuzzle_from_puzzle as get_innerpuzzle_from_cat_puzzle
-from chia.wallet.cat_wallet.cat_utils import unsigned_spend_bundle_for_spendable_cats
 from chia.wallet.cat_wallet.cat_wallet import CATWallet
 from chia.wallet.cat_wallet.dao_cat_wallet import DAOCATWallet
 from chia.wallet.coin_selection import select_coins
@@ -152,7 +156,7 @@ class DAOWallet:
             raise ValueError(f"Your balance of {bal} mojos is not enough to create {amount_of_cats} CATs")
 
         self.dao_info = DAOInfo(
-            treasury_id=bytes32([0] * 32),
+            treasury_id=bytes32.zeros,
             cat_wallet_id=uint32(0),
             dao_cat_wallet_id=uint32(0),
             proposals_list=[],
@@ -180,7 +184,7 @@ class DAOWallet:
                 fee_for_cat=fee_for_cat,
             )
         except Exception as e_info:  # pragma: no cover
-            await wallet_state_manager.user_store.delete_wallet(self.id())
+            await wallet_state_manager.delete_wallet(self.id())
             self.log.exception(f"Failed to create dao wallet: {e_info}")
             raise
 
@@ -326,14 +330,14 @@ class DAOWallet:
                 parent_info = ccparent
         return parent_info
 
-    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(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:
         # No spendable or receivable value
         return uint128(1)
 
-    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:
         # No spendable or receivable value
         return uint128(1)
 
@@ -341,7 +345,7 @@ class DAOWallet:
         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
@@ -353,13 +357,13 @@ class DAOWallet:
             self.log.warning(f"Can't select {amount}, from spendable {spendable_amount} for wallet id {self.id()}")
             return set()
 
-        spendable_coins: List[WalletCoinRecord] = list(
+        spendable_coins: list[WalletCoinRecord] = list(
             await self.wallet_state_manager.get_spendable_coins_for_wallet(self.wallet_info.id)
         )
 
         # 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.wallet_info.id
         )
         async with action_scope.use() as interface:
@@ -379,7 +383,7 @@ class DAOWallet:
         # No spendable or receivable value
         return uint64(0)
 
-    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:
         # No spendable or receivable value
         return uint128(1)
 
@@ -392,7 +396,7 @@ class DAOWallet:
     # if asset_id == None: then we get normal XCH
     async def select_coins_for_asset_type(
         self, amount: uint64, action_scope: WalletActionScope, asset_id: Optional[bytes32] = None
-    ) -> List[Coin]:
+    ) -> list[Coin]:
         puzhash = get_p2_singleton_puzhash(self.dao_info.treasury_id, asset_id=asset_id)
         records = await self.wallet_state_manager.coin_store.get_coin_records_by_puzzle_hash(puzhash)
         unspent_records = [r for r in records if not r.spent]
@@ -446,7 +450,6 @@ class DAOWallet:
                 self.log.info(f"DAO funding coin added: {coin.name().hex()}:{coin}. Asset ID: {asset_id}")
         except Exception as e:  # pragma: no cover
             self.log.exception(f"Error occurred during dao wallet coin addition: {e}")
-        return
 
     def get_cat_tail_hash(self) -> bytes32:
         cat_wallet: CATWallet = self.wallet_state_manager.wallets[self.dao_info.cat_wallet_id]
@@ -467,7 +470,6 @@ class DAOWallet:
         ]
         dao_info = dataclasses.replace(self.dao_info, proposals_list=new_list)
         await self.save_info(dao_info)
-        return
 
     async def resync_treasury_state(self) -> None:
         """
@@ -490,7 +492,7 @@ class DAOWallet:
             if len(children) == 0:
                 break
 
-            children_state_list: List[CoinState] = [child for child in children if child.coin.amount % 2 == 1]
+            children_state_list: list[CoinState] = [child for child in children if child.coin.amount % 2 == 1]
             # ensure children_state_list has only one odd amount coin (the treasury)
             if (len(children_state_list) == 0) or (len(children_state_list) > 1):  # pragma: no cover
                 raise RuntimeError("Could not retrieve child_state")
@@ -604,8 +606,6 @@ class DAOWallet:
             response: Optional[RespondBlockHeader] = await peer.call_api(FullNodeAPI.request_block_header, request)
             await wallet_node.sync_from_untrusted_close_to_peak(response.header_block, peer)
 
-        return
-
     async def generate_new_dao(
         self,
         amount_of_cats_to_create: Optional[uint64],
@@ -613,7 +613,7 @@ class DAOWallet:
         cat_tail_hash: Optional[bytes32] = None,
         fee: uint64 = uint64(0),
         fee_for_cat: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         """
         Create a new DAO treasury using the dao_rules object. This does the first spend to create the launcher
@@ -846,7 +846,7 @@ class DAOWallet:
         action_scope: WalletActionScope,
         vote_amount: Optional[uint64] = None,
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         dao_rules = get_treasury_rules_from_puzzle(self.dao_info.current_treasury_innerpuz)
         coins = await self.standard_wallet.select_coins(
@@ -1027,7 +1027,7 @@ class DAOWallet:
         is_yes_vote: bool,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         self.log.info(f"Trying to create a proposal close spend with ID: {proposal_id}")
         proposal_info = None
@@ -1145,7 +1145,7 @@ class DAOWallet:
         genesis_id: Optional[bytes32] = None,
         fee: uint64 = uint64(0),
         self_destruct: bool = False,
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         self.log.info(f"Trying to create a proposal close spend with ID: {proposal_id}")
         proposal_info = None
@@ -1215,8 +1215,8 @@ class DAOWallet:
             )
             c_a, curried_args_prg = uncurry_proposal(proposal_info.current_innerpuz)
             (
-                SELF_HASH,
-                PROPOSAL_ID,
+                _SELF_HASH,
+                _PROPOSAL_ID,
                 PROPOSED_PUZ_HASH,
                 YES_VOTES,
                 TOTAL_VOTES,
@@ -1257,11 +1257,11 @@ class DAOWallet:
             proposal_type, curried_args_prg = get_proposal_args(puzzle_reveal)
             if proposal_type == ProposalType.SPEND:
                 (
-                    TREASURY_SINGLETON_STRUCT,
-                    CAT_MOD_HASH,
+                    _TREASURY_SINGLETON_STRUCT,
+                    _CAT_MOD_HASH,
                     CONDITIONS,
                     LIST_OF_TAILHASH_CONDITIONS,
-                    P2_SINGLETON_VIA_DELEGATED_PUZZLE_PUZHASH,
+                    _P2_SINGLETON_VIA_DELEGATED_PUZZLE_PUZHASH,
                 ) = curried_args_prg.as_iter()
 
                 sum = 0
@@ -1421,18 +1421,18 @@ class DAOWallet:
 
             elif proposal_type == ProposalType.UPDATE:
                 (
-                    TREASURY_MOD_HASH,
-                    VALIDATOR_MOD_HASH,
-                    SINGLETON_STRUCT,
-                    PROPOSAL_SELF_HASH,
-                    PROPOSAL_MINIMUM_AMOUNT,
-                    PROPOSAL_EXCESS_PAYOUT_PUZHASH,
-                    PROPOSAL_LENGTH,
-                    PROPOSAL_SOFTCLOSE_LENGTH,
-                    ATTENDANCE_REQUIRED,
-                    PASS_MARGIN,
-                    PROPOSAL_SELF_DESTRUCT_TIME,
-                    ORACLE_SPEND_DELAY,
+                    _TREASURY_MOD_HASH,
+                    _VALIDATOR_MOD_HASH,
+                    _SINGLETON_STRUCT,
+                    _PROPOSAL_SELF_HASH,
+                    _PROPOSAL_MINIMUM_AMOUNT,
+                    _PROPOSAL_EXCESS_PAYOUT_PUZHASH,
+                    _PROPOSAL_LENGTH,
+                    _PROPOSAL_SOFTCLOSE_LENGTH,
+                    _ATTENDANCE_REQUIRED,
+                    _PASS_MARGIN,
+                    _PROPOSAL_SELF_DESTRUCT_TIME,
+                    _ORACLE_SPEND_DELAY,
                 ) = curried_args_prg.as_iter()
                 coin_spends = []
                 treasury_inner_puzhash = self.dao_info.current_treasury_innerpuz.get_tree_hash()
@@ -1473,7 +1473,6 @@ class DAOWallet:
             spend_bundle = WalletSpendBundle([proposal_cs, treasury_cs], AugSchemeMPL.aggregate([]))
         else:
             # TODO: maybe we can refactor this to provide clarity around timer_cs having been defined
-            # pylint: disable-next=E0606
             spend_bundle = WalletSpendBundle([proposal_cs, timer_cs, treasury_cs], AugSchemeMPL.aggregate([]))
         if fee > 0:
             await self.standard_wallet.create_tandem_xch_tx(fee, action_scope)
@@ -1536,7 +1535,7 @@ class DAOWallet:
         amount: uint64,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         if funding_wallet.type() == WalletType.STANDARD_WALLET.value:
             p2_singleton_puzhash = get_p2_singleton_puzhash(self.dao_info.treasury_id, asset_id=None)
@@ -1569,7 +1568,7 @@ class DAOWallet:
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
         funding_wallet_id: uint32 = uint32(1),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         # set up the p2_singleton
         funding_wallet = self.wallet_state_manager.wallets[funding_wallet_id]
@@ -1594,7 +1593,7 @@ class DAOWallet:
         self,
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        extra_conditions: Tuple[Condition, ...] = tuple(),
+        extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
         dao_cat_wallet: DAOCATWallet = self.wallet_state_manager.wallets[self.dao_info.dao_cat_wallet_id]
         spends = []
@@ -1648,7 +1647,7 @@ class DAOWallet:
         async with action_scope.use() as interface:
             interface.side_effects.transactions.append(record)
 
-    async def parse_proposal(self, proposal_id: bytes32) -> Dict[str, Any]:
+    async def parse_proposal(self, proposal_id: bytes32) -> dict[str, Any]:
         for prop_info in self.dao_info.proposals_list:
             if prop_info.proposal_id == proposal_id:
                 state = await self.get_proposal_state(proposal_id)
@@ -1657,11 +1656,11 @@ class DAOWallet:
                 if proposal_type == ProposalType.SPEND:
                     cat_launcher = create_cat_launcher_for_singleton_id(self.dao_info.treasury_id)
                     (
-                        TREASURY_SINGLETON_STRUCT,
-                        CAT_MOD_HASH,
+                        _TREASURY_SINGLETON_STRUCT,
+                        _CAT_MOD_HASH,
                         CONDITIONS,
                         LIST_OF_TAILHASH_CONDITIONS,
-                        P2_SINGLETON_VIA_DELEGATED_PUZZLE_PUZHASH,
+                        _P2_SINGLETON_VIA_DELEGATED_PUZZLE_PUZHASH,
                     ) = curried_args.as_iter()
                     mint_amount = None
                     new_cat_puzhash = None
@@ -1675,10 +1674,10 @@ class DAOWallet:
                                 cc = {"puzzle_hash": cond.at("rf").as_atom(), "amount": cond.at("rrf").as_int()}
                                 xch_created_coins.append(cc)
 
-                    asset_create_coins: List[Dict[Any, Any]] = []
+                    asset_create_coins: list[dict[Any, Any]] = []
                     for asset in LIST_OF_TAILHASH_CONDITIONS.as_iter():
                         if asset == Program.to(0):  # pragma: no cover
-                            asset_dict: Optional[Dict[str, Any]] = None
+                            asset_dict: Optional[dict[str, Any]] = None
                         else:
                             asset_id = asset.first().as_atom()
                             cc_list = []
@@ -1691,7 +1690,7 @@ class DAOWallet:
                                     # cc_list.append([asset_id, asset_dict])
                                     cc_list.append(asset_dict)
                             asset_create_coins.append({"asset_id": asset_id, "conditions": cc_list})
-                    dictionary: Dict[str, Any] = {
+                    dictionary: dict[str, Any] = {
                         "state": state,
                         "proposal_type": proposal_type.value,
                         "proposed_puzzle_reveal": proposed_puzzle_reveal,
@@ -1761,7 +1760,7 @@ class DAOWallet:
         self,
         amount: uint64,
         action_scope: WalletActionScope,
-    ) -> List[TransactionRecord]:
+    ) -> list[TransactionRecord]:
         dao_cat_wallet: DAOCATWallet = self.wallet_state_manager.wallets[self.dao_info.dao_cat_wallet_id]
         return await dao_cat_wallet.enter_dao_cat_voting_mode(amount, action_scope)
 
@@ -1823,7 +1822,7 @@ class DAOWallet:
                     )
                     await self.add_parent(new_state.coin.name(), future_parent)
                     return
-                index = index + 1
+                index += 1
 
         # check if we are the finished state
         if current_innerpuz == get_finished_state_inner_puzzle(singleton_id):
@@ -1831,26 +1830,26 @@ class DAOWallet:
 
         c_a, curried_args = uncurry_proposal(puzzle)
         (
-            DAO_PROPOSAL_TIMER_MOD_HASH,
-            SINGLETON_MOD_HASH,
-            SINGLETON_LAUNCHER_PUZHASH,
-            CAT_MOD_HASH,
-            DAO_FINISHED_STATE_HASH,
+            _DAO_PROPOSAL_TIMER_MOD_HASH,
+            _SINGLETON_MOD_HASH,
+            _SINGLETON_LAUNCHER_PUZHASH,
+            _CAT_MOD_HASH,
+            _DAO_FINISHED_STATE_HASH,
             _DAO_TREASURY_MOD_HASH,
-            lockup_self_hash,
+            _lockup_self_hash,
             cat_tail_hash,
-            treasury_id,
+            _treasury_id,
         ) = curried_args.as_iter()
         (
-            curry_one,
-            proposal_id,
-            proposed_puzzle_hash,
+            _curry_one,
+            _proposal_id,
+            _proposed_puzzle_hash,
             yes_votes,
             total_votes,
         ) = c_a.as_iter()
 
         if current_coin is None:  # pragma: no cover
-            raise RuntimeError("get_most_recent_singleton_coin_from_coin_spend({new_state}) failed")
+            raise RuntimeError(f"get_most_recent_singleton_coin_from_coin_spend({new_state}) failed")
 
         timer_coin = None
         if solution.at("rrrrrrf").as_int() == 0:
@@ -1907,7 +1906,7 @@ class DAOWallet:
                 )
                 await self.add_parent(new_state.coin.name(), future_parent)
                 return
-            index = index + 1
+            index += 1
 
         # Search for the timer coin
         if not ended:
@@ -2002,9 +2001,9 @@ class DAOWallet:
                 )
                 await self.add_parent(new_state.coin.name(), future_parent)
                 return
-            index = index + 1
+            index += 1
 
-    async def get_proposal_state(self, proposal_id: bytes32) -> Dict[str, Union[int, bool]]:
+    async def get_proposal_state(self, proposal_id: bytes32) -> dict[str, Union[int, bool]]:
         """
         Use this to figure out whether a proposal has passed or failed and whether it can be closed
         Given a proposal_id:
@@ -2084,7 +2083,6 @@ class DAOWallet:
             uint64(new_state.coin.amount),
         )
         await self.add_parent(new_state.coin.name(), future_parent)
-        return
 
     async def apply_state_transition(self, new_state: CoinSpend, block_height: uint32) -> bool:
         """
@@ -2105,7 +2103,7 @@ class DAOWallet:
         puzzle = get_inner_puzzle_from_singleton(new_state.puzzle_reveal)
         assert puzzle
         try:
-            mod, curried_args = puzzle.uncurry()
+            mod, _curried_args = puzzle.uncurry()
         except ValueError as e:  # pragma: no cover
             self.log.warning("Cannot uncurry puzzle in DAO Wallet: error: %s", e)
             raise e

chia/wallet/db_wallet/db_wallet_puzzles.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
-from typing import Iterator, List, Tuple, Union
+from collections.abc import Iterator
+from typing import Union
 
-from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.program import INFINITE_COST, Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.condition_opcodes import ConditionOpcode
@@ -40,7 +41,7 @@ def create_host_layer_puzzle(innerpuz: Union[Program, bytes32], current_root: by
     )
 
 
-def match_dl_singleton(puzzle: Union[Program, SerializedProgram]) -> Tuple[bool, Iterator[Program]]:
+def match_dl_singleton(puzzle: Union[Program, SerializedProgram]) -> tuple[bool, Iterator[Program]]:
     """
     Given a puzzle test if it's a CAT and, if it is, return the curried arguments
     """
@@ -56,7 +57,7 @@ def match_dl_singleton(puzzle: Union[Program, SerializedProgram]) -> Tuple[bool,
     return False, iter(())
 
 
-def launch_solution_to_singleton_info(launch_solution: Program) -> Tuple[bytes32, uint64, bytes32, bytes32]:
+def launch_solution_to_singleton_info(launch_solution: Program) -> tuple[bytes32, uint64, bytes32, bytes32]:
     solution = launch_solution.as_python()
     try:
         full_puzzle_hash = bytes32(solution[0])
@@ -77,7 +78,7 @@ def launcher_to_struct(launcher_id: bytes32) -> Program:
 
 
 def create_graftroot_offer_puz(
-    launcher_ids: List[bytes32], values_to_prove: List[List[bytes32]], inner_puzzle: Program
+    launcher_ids: list[bytes32], values_to_prove: list[list[bytes32]], inner_puzzle: Program
 ) -> Program:
     return GRAFTROOT_DL_OFFERS.curry(
         inner_puzzle,
@@ -94,14 +95,17 @@ def create_mirror_puzzle() -> Program:
 MIRROR_PUZZLE_HASH = create_mirror_puzzle().get_tree_hash()
 
 
-def get_mirror_info(parent_puzzle: Program, parent_solution: Program) -> Tuple[bytes32, List[bytes]]:
-    conditions = parent_puzzle.run(parent_solution)
+def get_mirror_info(
+    parent_puzzle: Union[Program, SerializedProgram], parent_solution: Union[Program, SerializedProgram]
+) -> tuple[bytes32, list[bytes]]:
+    assert type(parent_puzzle) is type(parent_solution)
+    _, conditions = parent_puzzle.run_with_cost(INFINITE_COST, parent_solution)
     for condition in conditions.as_iter():
         if (
             condition.first().as_python() == ConditionOpcode.CREATE_COIN
             and condition.at("rf").as_python() == create_mirror_puzzle().get_tree_hash()
         ):
-            memos: List[bytes] = condition.at("rrrf").as_python()
+            memos: list[bytes] = condition.at("rrrf").as_python()
             launcher_id = bytes32(memos[0])
             return launcher_id, [url for url in memos[1:]]
     raise ValueError("The provided puzzle and solution do not create a mirror coin")