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

chia/_tests/util/rpc.py

@@ -18,6 +18,9 @@ async def validate_get_routes(client: RpcClient, api: RpcApiProtocol) -> None:
         "/get_routes",
         "/get_version",
         "/healthz",
+        "/get_log_level",
+        "/set_log_level",
+        "/reset_log_level",
     ]
     assert len(routes_api) > 0
     assert sorted(routes_client) == sorted(routes_api + routes_server)

chia/_tests/util/run_block.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, List, Tuple
+from typing import Any
 
 from chia_rs import Coin
 
@@ -27,7 +27,7 @@ DESERIALIZE_MOD = load_serialized_clvm_maybe_recompile(
 class NPC:
     coin_name: bytes32
     puzzle_hash: bytes32
-    conditions: List[Tuple[ConditionOpcode, List[ConditionWithArgs]]]
+    conditions: list[tuple[ConditionOpcode, list[ConditionWithArgs]]]
 
 
 @dataclass
@@ -36,23 +36,23 @@ class CAT:
     memo: str
     npc: NPC
 
-    def cat_to_dict(self) -> Dict[str, Any]:
+    def cat_to_dict(self) -> dict[str, Any]:
         return {"asset_id": self.asset_id, "memo": self.memo, "npc": npc_to_dict(self.npc)}
 
 
-def condition_with_args_to_dict(condition_with_args: ConditionWithArgs) -> Dict[str, Any]:
+def condition_with_args_to_dict(condition_with_args: ConditionWithArgs) -> dict[str, Any]:
     return {
         "condition_opcode": condition_with_args.opcode.name,
         "arguments": [arg.hex() for arg in condition_with_args.vars],
     }
 
 
-def condition_list_to_dict(condition_list: Tuple[ConditionOpcode, List[ConditionWithArgs]]) -> List[Dict[str, Any]]:
+def condition_list_to_dict(condition_list: tuple[ConditionOpcode, list[ConditionWithArgs]]) -> list[dict[str, Any]]:
     assert all([condition_list[0] == cwa.opcode for cwa in condition_list[1]])
     return [condition_with_args_to_dict(cwa) for cwa in condition_list[1]]
 
 
-def npc_to_dict(npc: NPC) -> Dict[str, Any]:
+def npc_to_dict(npc: NPC) -> dict[str, Any]:
     return {
         "coin_name": npc.coin_name.hex(),
         "conditions": [{"condition_type": c[0].name, "conditions": condition_list_to_dict(c)} for c in npc.conditions],
@@ -60,13 +60,13 @@ def npc_to_dict(npc: NPC) -> Dict[str, Any]:
     }
 
 
-def run_generator(block_generator: BlockGenerator, constants: ConsensusConstants, max_cost: int) -> List[CAT]:
+def run_generator(block_generator: BlockGenerator, constants: ConsensusConstants, max_cost: int) -> list[CAT]:
     block_args = block_generator.generator_refs
-    cost, block_result = block_generator.program.run_with_cost(max_cost, [DESERIALIZE_MOD, block_args])
+    _cost, block_result = block_generator.program.run_with_cost(max_cost, [DESERIALIZE_MOD, block_args])
 
     coin_spends = block_result.first()
 
-    cat_list: List[CAT] = []
+    cat_list: list[CAT] = []
     for spend in coin_spends.as_iter():
         parent, puzzle, amount, solution = spend.as_iter()
         args = match_cat_puzzle(uncurry_puzzle(puzzle))
@@ -79,7 +79,7 @@ def run_generator(block_generator: BlockGenerator, constants: ConsensusConstants
 
         puzzle_result = puzzle.run(solution)
 
-        conds: Dict[ConditionOpcode, List[ConditionWithArgs]] = {}
+        conds: dict[ConditionOpcode, list[ConditionWithArgs]] = {}
 
         for condition in puzzle_result.as_python():
             op = ConditionOpcode(condition[0])
@@ -126,7 +126,7 @@ def run_generator(block_generator: BlockGenerator, constants: ConsensusConstants
     return cat_list
 
 
-def ref_list_to_args(ref_list: List[uint32], root_path: Path) -> List[bytes]:
+def ref_list_to_args(ref_list: list[uint32], root_path: Path) -> list[bytes]:
     args = []
     for height in ref_list:
         with open(root_path / f"{height}.json", "rb") as f:
@@ -139,10 +139,10 @@ def ref_list_to_args(ref_list: List[uint32], root_path: Path) -> List[bytes]:
 
 def run_generator_with_args(
     generator_program_hex: str,
-    generator_args: List[bytes],
+    generator_args: list[bytes],
     constants: ConsensusConstants,
     cost: uint64,
-) -> List[CAT]:
+) -> list[CAT]:
     if not generator_program_hex:
         return []
     generator_program = SerializedProgram.fromhex(generator_program_hex)
@@ -150,11 +150,11 @@ def run_generator_with_args(
     return run_generator(block_generator, constants, min(constants.MAX_BLOCK_COST_CLVM, cost))
 
 
-def run_json_block(full_block: Dict[str, Any], parent: Path, constants: ConsensusConstants) -> List[CAT]:
+def run_json_block(full_block: dict[str, Any], parent: Path, constants: ConsensusConstants) -> list[CAT]:
     ref_list = full_block["block"]["transactions_generator_ref_list"]
-    tx_info: Dict[str, Any] = full_block["block"]["transactions_info"]
+    tx_info: dict[str, Any] = full_block["block"]["transactions_info"]
     generator_program_hex: str = full_block["block"]["transactions_generator"]
-    cat_list: List[CAT] = []
+    cat_list: list[CAT] = []
     if tx_info and generator_program_hex:
         cost = tx_info["cost"]
         args = ref_list_to_args(ref_list, parent)

chia/_tests/util/setup_nodes.py

@@ -3,10 +3,11 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import logging
+from collections.abc import AsyncIterator
 from contextlib import AsyncExitStack, ExitStack, asynccontextmanager
 from dataclasses import dataclass
 from pathlib import Path
-from typing import AsyncIterator, Dict, List, Optional, Tuple, Union
+from typing import Optional, Union
 
 import anyio
 
@@ -46,8 +47,8 @@ from chia.util.keychain import Keychain
 from chia.util.timing import adjusted_timeout, backoff_times
 from chia.wallet.wallet_node import WalletNode
 
-OldSimulatorsAndWallets = Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools]
-SimulatorsAndWalletsServices = Tuple[List[SimulatorFullNodeService], List[WalletService], BlockTools]
+OldSimulatorsAndWallets = tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools]
+SimulatorsAndWalletsServices = tuple[list[SimulatorFullNodeService], list[WalletService], BlockTools]
 
 
 @dataclass(frozen=True)
@@ -64,8 +65,8 @@ class FullSystem:
 
 @dataclass
 class SimulatorsAndWallets:
-    simulators: List[FullNodeEnvironment]
-    wallets: List[WalletEnvironment]
+    simulators: list[FullNodeEnvironment]
+    wallets: list[WalletEnvironment]
     bt: BlockTools
 
 
@@ -79,12 +80,12 @@ log = logging.getLogger(__name__)
 @asynccontextmanager
 async def setup_two_nodes(
     consensus_constants: ConsensusConstants, db_version: int, self_hostname: str
-) -> AsyncIterator[Tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools]]:
+) -> AsyncIterator[tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools]]:
     """
     Setup and teardown of two full nodes, with blockchains and separate DBs.
     """
 
-    config_overrides = {"full_node.max_sync_wait": 0}
+    config_overrides = {"full_node.max_sync_wait": 0, "full_node.log_coins": True}
     with TempKeyring(populate=True) as keychain1, TempKeyring(populate=True) as keychain2:
         bt1 = await create_block_tools_async(
             constants=consensus_constants, keychain=keychain1, config_overrides=config_overrides
@@ -116,11 +117,11 @@ async def setup_two_nodes(
 @asynccontextmanager
 async def setup_n_nodes(
     consensus_constants: ConsensusConstants, n: int, db_version: int, self_hostname: str
-) -> AsyncIterator[List[FullNodeAPI]]:
+) -> AsyncIterator[list[FullNodeAPI]]:
     """
     Setup and teardown of n full nodes, with blockchains and separate DBs.
     """
-    config_overrides = {"full_node.max_sync_wait": 0}
+    config_overrides = {"full_node.max_sync_wait": 0, "full_node.log_coins": True}
     with ExitStack() as stack:
         keychains = [stack.enter_context(TempKeyring(populate=True)) for _ in range(n)]
         async with AsyncExitStack() as async_exit_stack:
@@ -154,8 +155,8 @@ async def setup_simulators_and_wallets(
     key_seed: Optional[bytes32] = None,
     initial_num_public_keys: int = 5,
     db_version: int = 2,
-    config_overrides: Optional[Dict[str, int]] = None,
-    disable_capabilities: Optional[List[Capability]] = None,
+    config_overrides: Optional[dict[str, int]] = None,
+    disable_capabilities: Optional[list[Capability]] = None,
 ) -> AsyncIterator[SimulatorsAndWallets]:
     with TempKeyring(populate=True) as keychain1, TempKeyring(populate=True) as keychain2:
         if config_overrides is None:
@@ -175,7 +176,7 @@ async def setup_simulators_and_wallets(
             disable_capabilities,
         ) as (bt_tools, simulators, wallets_services):
             async with contextlib.AsyncExitStack() as exit_stack:
-                wallets: List[WalletEnvironment] = []
+                wallets: list[WalletEnvironment] = []
                 for service in wallets_services:
                     assert service.rpc_server is not None
 
@@ -207,9 +208,9 @@ async def setup_simulators_and_wallets_service(
     key_seed: Optional[bytes32] = None,
     initial_num_public_keys: int = 5,
     db_version: int = 2,
-    config_overrides: Optional[Dict[str, int]] = None,
-    disable_capabilities: Optional[List[Capability]] = None,
-) -> AsyncIterator[Tuple[List[SimulatorFullNodeService], List[WalletService], BlockTools]]:
+    config_overrides: Optional[dict[str, int]] = None,
+    disable_capabilities: Optional[list[Capability]] = None,
+) -> AsyncIterator[tuple[list[SimulatorFullNodeService], list[WalletService], BlockTools]]:
     with TempKeyring(populate=True) as keychain1, TempKeyring(populate=True) as keychain2:
         async with setup_simulators_and_wallets_inner(
             db_version,
@@ -240,13 +241,14 @@ async def setup_simulators_and_wallets_inner(
     spam_filter_after_n_txs: int,
     wallet_count: int,
     xch_spam_amount: int,
-    config_overrides: Optional[Dict[str, int]],
-    disable_capabilities: Optional[List[Capability]],
-) -> AsyncIterator[Tuple[List[BlockTools], List[SimulatorFullNodeService], List[WalletService]]]:
+    config_overrides: Optional[dict[str, int]],
+    disable_capabilities: Optional[list[Capability]],
+) -> AsyncIterator[tuple[list[BlockTools], list[SimulatorFullNodeService], list[WalletService]]]:
     if config_overrides is not None and "full_node.max_sync_wait" not in config_overrides:
         config_overrides["full_node.max_sync_wait"] = 0
+        config_overrides["full_node.log_coins"] = True
     async with AsyncExitStack() as async_exit_stack:
-        bt_tools: List[BlockTools] = [
+        bt_tools: list[BlockTools] = [
             await create_block_tools_async(consensus_constants, keychain=keychain1, config_overrides=config_overrides)
             for _ in range(0, simulator_count)
         ]
@@ -258,7 +260,7 @@ async def setup_simulators_and_wallets_inner(
                     )
                 )
 
-        simulators: List[SimulatorFullNodeService] = [
+        simulators: list[SimulatorFullNodeService] = [
             await async_exit_stack.enter_async_context(
                 # Passing simulator=True gets us this type guaranteed
                 setup_full_node(  # type: ignore[arg-type]
@@ -274,7 +276,7 @@ async def setup_simulators_and_wallets_inner(
             for index in range(0, simulator_count)
         ]
 
-        wallets: List[WalletService] = [
+        wallets: list[WalletService] = [
             await async_exit_stack.enter_async_context(
                 setup_wallet_node(
                     bt_tools[index].config["self_hostname"],
@@ -301,7 +303,7 @@ async def setup_farmer_multi_harvester(
     consensus_constants: ConsensusConstants,
     *,
     start_services: bool,
-) -> AsyncIterator[Tuple[List[HarvesterService], FarmerService, BlockTools]]:
+) -> AsyncIterator[tuple[list[HarvesterService], FarmerService, BlockTools]]:
     async with AsyncExitStack() as async_exit_stack:
         farmer_service = await async_exit_stack.enter_async_context(
             setup_farmer(
@@ -359,7 +361,7 @@ async def setup_full_system_inner(
     keychain2: Keychain,
     shared_b_tools: BlockTools,
 ) -> AsyncIterator[FullSystem]:
-    config_overrides = {"full_node.max_sync_wait": 0}
+    config_overrides = {"full_node.max_sync_wait": 0, "full_node.log_coins": True}
     if b_tools is None:
         b_tools = await create_block_tools_async(
             constants=consensus_constants, keychain=keychain1, config_overrides=config_overrides

chia/{clvm → _tests/util}/spend_sim.py

@@ -3,23 +3,24 @@ from __future__ import annotations
 import contextlib
 import json
 import random
+from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, AsyncIterator, Callable, Dict, List, Optional, Tuple, Type, TypeVar
+from typing import Any, Callable, Optional, TypeVar
 
 import anyio
+from chia_rs import DONT_VALIDATE_SIGNATURE, G2Element, get_flags_for_height_and_constants, run_block_generator2
 
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
 from chia.consensus.constants import ConsensusConstants
-from chia.consensus.cost_calculator import NPCResult
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.bundle_tools import simple_solution_generator
 from chia.full_node.coin_store import CoinStore
 from chia.full_node.hint_store import HintStore
 from chia.full_node.mempool import Mempool
-from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions, get_puzzle_and_solution_for_coin
+from chia.full_node.mempool_check_conditions import get_puzzle_and_solution_for_coin
 from chia.full_node.mempool_manager import MempoolManager
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import INFINITE_COST
@@ -51,7 +52,7 @@ and is designed so that you could test with it and then swap in a real rpc clien
 @asynccontextmanager
 async def sim_and_client(
     db_path: Optional[Path] = None, defaults: ConsensusConstants = DEFAULT_CONSTANTS, pass_prefarm: bool = True
-) -> AsyncIterator[Tuple[SpendSim, SimClient]]:
+) -> AsyncIterator[tuple[SpendSim, SimClient]]:
     async with SpendSim.managed(db_path, defaults) as sim:
         client: SimClient = SimClient(sim)
         if pass_prefarm:
@@ -61,19 +62,22 @@ async def sim_and_client(
 
 class CostLogger:
     def __init__(self) -> None:
-        self.cost_dict: Dict[str, int] = {}
-        self.cost_dict_no_puzs: Dict[str, int] = {}
+        self.cost_dict: dict[str, int] = {}
+        self.cost_dict_no_puzs: dict[str, int] = {}
 
     def add_cost(self, descriptor: str, spend_bundle: T_SpendBundle) -> T_SpendBundle:
         program: BlockGenerator = simple_solution_generator(spend_bundle)
-        npc_result: NPCResult = get_name_puzzle_conditions(
-            program,
+        flags = get_flags_for_height_and_constants(DEFAULT_CONSTANTS.HARD_FORK_HEIGHT, DEFAULT_CONSTANTS)
+        _err, conds = run_block_generator2(
+            bytes(program.program),
+            [],
             INFINITE_COST,
-            mempool_mode=True,
-            height=DEFAULT_CONSTANTS.HARD_FORK_HEIGHT,
-            constants=DEFAULT_CONSTANTS,
+            flags | DONT_VALIDATE_SIGNATURE,
+            G2Element(),
+            None,
+            DEFAULT_CONSTANTS,
         )
-        cost = uint64(0 if npc_result.conds is None else npc_result.conds.cost)
+        cost = uint64(0 if conds is None else conds.cost)
         self.cost_dict[descriptor] = cost
         cost_to_subtract: int = 0
         for cs in spend_bundle.coin_spends:
@@ -102,7 +106,7 @@ _T_SimBlockRecord = TypeVar("_T_SimBlockRecord", bound="SimBlockRecord")
 @streamable
 @dataclass(frozen=True)
 class SimBlockRecord(Streamable):
-    reward_claims_incorporated: List[Coin]
+    reward_claims_incorporated: list[Coin]
     height: uint32
     prev_transaction_block_height: uint32
     timestamp: uint64
@@ -111,7 +115,7 @@ class SimBlockRecord(Streamable):
     prev_transaction_block_hash: bytes32
 
     @classmethod
-    def create(cls: Type[_T_SimBlockRecord], rci: List[Coin], height: uint32, timestamp: uint64) -> _T_SimBlockRecord:
+    def create(cls: type[_T_SimBlockRecord], rci: list[Coin], height: uint32, timestamp: uint64) -> _T_SimBlockRecord:
         prev_transaction_block_height = uint32(height - 1 if height > 0 else 0)
         return cls(
             rci,
@@ -129,8 +133,8 @@ class SimBlockRecord(Streamable):
 class SimStore(Streamable):
     timestamp: uint64
     block_height: uint32
-    block_records: List[SimBlockRecord]
-    blocks: List[SimFullBlock]
+    block_records: list[SimBlockRecord]
+    blocks: list[SimFullBlock]
 
 
 _T_SpendSim = TypeVar("_T_SpendSim", bound="SpendSim")
@@ -140,8 +144,8 @@ class SpendSim:
     db_wrapper: DBWrapper2
     coin_store: CoinStore
     mempool_manager: MempoolManager
-    block_records: List[SimBlockRecord]
-    blocks: List[SimFullBlock]
+    block_records: list[SimBlockRecord]
+    blocks: list[SimFullBlock]
     timestamp: uint64
     block_height: uint32
     defaults: ConsensusConstants
@@ -150,7 +154,7 @@ class SpendSim:
     @classmethod
     @contextlib.asynccontextmanager
     async def managed(
-        cls: Type[_T_SpendSim], db_path: Optional[Path] = None, defaults: ConsensusConstants = DEFAULT_CONSTANTS
+        cls: type[_T_SpendSim], db_path: Optional[Path] = None, defaults: ConsensusConstants = DEFAULT_CONSTANTS
     ) -> AsyncIterator[_T_SpendSim]:
         self = cls()
         if db_path is None:
@@ -196,7 +200,7 @@ class SpendSim:
                         )
                         await c.close()
 
-    async def new_peak(self, spent_coins_ids: Optional[List[bytes32]]) -> None:
+    async def new_peak(self, spent_coins_ids: Optional[list[bytes32]]) -> None:
         await self.mempool_manager.new_peak(self.block_records[-1], spent_coins_ids)
 
     def new_coin_record(self, coin: Coin, coinbase: bool = False) -> CoinRecord:
@@ -208,7 +212,7 @@ class SpendSim:
             self.timestamp,
         )
 
-    async def all_non_reward_coins(self) -> List[Coin]:
+    async def all_non_reward_coins(self) -> list[Coin]:
         coins = set()
         async with self.db_wrapper.reader_no_transaction() as conn:
             cursor = await conn.execute(
@@ -231,7 +235,7 @@ class SpendSim:
         self,
         puzzle_hash: bytes32 = bytes32(b"0" * 32),
         item_inclusion_filter: Optional[Callable[[bytes32], bool]] = None,
-    ) -> Tuple[List[Coin], List[Coin]]:
+    ) -> tuple[list[Coin], list[Coin]]:
         # Fees get calculated
         fees = uint64(0)
         for item in self.mempool_manager.mempool.all_items():
@@ -257,8 +261,8 @@ class SpendSim:
 
         # Coin store gets updated
         generator_bundle: Optional[SpendBundle] = None
-        return_additions: List[Coin] = []
-        return_removals: List[Coin] = []
+        return_additions: list[Coin] = []
+        return_removals: list[Coin] = []
         spent_coins_ids = None
         if (len(self.block_records) > 0) and (self.mempool_manager.mempool.size() > 0):
             peak = self.mempool_manager.peak
@@ -274,7 +278,7 @@ class SpendSim:
                     generator_bundle = bundle
                     for spend in generator_bundle.coin_spends:
                         hint_dict, _ = compute_spend_hints_and_additions(spend)
-                        hints: List[Tuple[bytes32, bytes]] = []
+                        hints: list[tuple[bytes32, bytes]] = []
                         hint_obj: HintedCoin
                         for coin_name, hint_obj in hint_dict.items():
                             if hint_obj.hint is not None:
@@ -334,7 +338,7 @@ class SimClient:
     def __init__(self, service: SpendSim) -> None:
         self.service = service
 
-    async def push_tx(self, spend_bundle: SpendBundle) -> Tuple[MempoolInclusionStatus, Optional[Err]]:
+    async def push_tx(self, spend_bundle: SpendBundle) -> tuple[MempoolInclusionStatus, Optional[Err]]:
         try:
             spend_bundle_id = spend_bundle.name()
             sbc = await self.service.mempool_manager.pre_validate_spendbundle(spend_bundle, spend_bundle_id)
@@ -351,12 +355,12 @@ class SimClient:
 
     async def get_coin_records_by_names(
         self,
-        names: List[bytes32],
+        names: list[bytes32],
         start_height: Optional[int] = None,
         end_height: Optional[int] = None,
         include_spent_coins: bool = False,
-    ) -> List[CoinRecord]:
-        kwargs: Dict[str, Any] = {"include_spent_coins": include_spent_coins, "names": names}
+    ) -> list[CoinRecord]:
+        kwargs: dict[str, Any] = {"include_spent_coins": include_spent_coins, "names": names}
         if start_height is not None:
             kwargs["start_height"] = start_height
         if end_height is not None:
@@ -365,12 +369,12 @@ class SimClient:
 
     async def get_coin_records_by_parent_ids(
         self,
-        parent_ids: List[bytes32],
+        parent_ids: list[bytes32],
         start_height: Optional[int] = None,
         end_height: Optional[int] = None,
         include_spent_coins: bool = False,
-    ) -> List[CoinRecord]:
-        kwargs: Dict[str, Any] = {"include_spent_coins": include_spent_coins, "parent_ids": parent_ids}
+    ) -> list[CoinRecord]:
+        kwargs: dict[str, Any] = {"include_spent_coins": include_spent_coins, "parent_ids": parent_ids}
         if start_height is not None:
             kwargs["start_height"] = start_height
         if end_height is not None:
@@ -383,8 +387,8 @@ class SimClient:
         include_spent_coins: bool = True,
         start_height: Optional[int] = None,
         end_height: Optional[int] = None,
-    ) -> List[CoinRecord]:
-        kwargs: Dict[str, Any] = {"include_spent_coins": include_spent_coins, "puzzle_hash": puzzle_hash}
+    ) -> list[CoinRecord]:
+        kwargs: dict[str, Any] = {"include_spent_coins": include_spent_coins, "puzzle_hash": puzzle_hash}
         if start_height is not None:
             kwargs["start_height"] = start_height
         if end_height is not None:
@@ -393,12 +397,12 @@ class SimClient:
 
     async def get_coin_records_by_puzzle_hashes(
         self,
-        puzzle_hashes: List[bytes32],
+        puzzle_hashes: list[bytes32],
         include_spent_coins: bool = True,
         start_height: Optional[int] = None,
         end_height: Optional[int] = None,
-    ) -> List[CoinRecord]:
-        kwargs: Dict[str, Any] = {"include_spent_coins": include_spent_coins, "puzzle_hashes": puzzle_hashes}
+    ) -> list[CoinRecord]:
+        kwargs: dict[str, Any] = {"include_spent_coins": include_spent_coins, "puzzle_hashes": puzzle_hashes}
         if start_height is not None:
             kwargs["start_height"] = start_height
         if end_height is not None:
@@ -406,32 +410,32 @@ class SimClient:
         return await self.service.coin_store.get_coin_records_by_puzzle_hashes(**kwargs)
 
     async def get_block_record_by_height(self, height: uint32) -> SimBlockRecord:
-        return list(filter(lambda block: block.height == height, self.service.block_records))[0]
+        return next(filter(lambda block: block.height == height, self.service.block_records))
 
     async def get_block_record(self, header_hash: bytes32) -> SimBlockRecord:
-        return list(filter(lambda block: block.header_hash == header_hash, self.service.block_records))[0]
+        return next(filter(lambda block: block.header_hash == header_hash, self.service.block_records))
 
-    async def get_block_records(self, start: uint32, end: uint32) -> List[SimBlockRecord]:
+    async def get_block_records(self, start: uint32, end: uint32) -> list[SimBlockRecord]:
         return list(filter(lambda block: (block.height >= start) and (block.height < end), self.service.block_records))
 
     async def get_block(self, header_hash: bytes32) -> SimFullBlock:
-        selected_block: SimBlockRecord = list(
+        selected_block: SimBlockRecord = next(
             filter(lambda br: br.header_hash == header_hash, self.service.block_records)
-        )[0]
+        )
         block_height: uint32 = selected_block.height
-        block: SimFullBlock = list(filter(lambda block: block.height == block_height, self.service.blocks))[0]
+        block: SimFullBlock = next(filter(lambda block: block.height == block_height, self.service.blocks))
         return block
 
-    async def get_all_block(self, start: uint32, end: uint32) -> List[SimFullBlock]:
+    async def get_all_block(self, start: uint32, end: uint32) -> list[SimFullBlock]:
         return list(filter(lambda block: (block.height >= start) and (block.height < end), self.service.blocks))
 
-    async def get_additions_and_removals(self, header_hash: bytes32) -> Tuple[List[CoinRecord], List[CoinRecord]]:
-        selected_block: SimBlockRecord = list(
+    async def get_additions_and_removals(self, header_hash: bytes32) -> tuple[list[CoinRecord], list[CoinRecord]]:
+        selected_block: SimBlockRecord = next(
             filter(lambda br: br.header_hash == header_hash, self.service.block_records)
-        )[0]
+        )
         block_height: uint32 = selected_block.height
-        additions: List[CoinRecord] = await self.service.coin_store.get_coins_added_at_height(block_height)
-        removals: List[CoinRecord] = await self.service.coin_store.get_coins_removed_at_height(block_height)
+        additions: list[CoinRecord] = await self.service.coin_store.get_coins_added_at_height(block_height)
+        removals: list[CoinRecord] = await self.service.coin_store.get_coins_removed_at_height(block_height)
         return additions, removals
 
     async def get_puzzle_and_solution(self, coin_id: bytes32, height: uint32) -> CoinSpend:
@@ -443,16 +447,16 @@ class SimClient:
         spend_info = get_puzzle_and_solution_for_coin(generator, coin_record.coin, height, self.service.defaults)
         return CoinSpend(coin_record.coin, spend_info.puzzle, spend_info.solution)
 
-    async def get_all_mempool_tx_ids(self) -> List[bytes32]:
+    async def get_all_mempool_tx_ids(self) -> list[bytes32]:
         return self.service.mempool_manager.mempool.all_item_ids()
 
-    async def get_all_mempool_items(self) -> Dict[bytes32, MempoolItem]:
+    async def get_all_mempool_items(self) -> dict[bytes32, MempoolItem]:
         spends = {}
         for item in self.service.mempool_manager.mempool.all_items():
             spends[item.name] = item
         return spends
 
-    async def get_mempool_item_by_tx_id(self, tx_id: bytes32) -> Optional[Dict[str, Any]]:
+    async def get_mempool_item_by_tx_id(self, tx_id: bytes32) -> Optional[dict[str, Any]]:
         item = self.service.mempool_manager.get_mempool_item(tx_id)
         if item is None:
             return None
@@ -465,13 +469,13 @@ class SimClient:
         include_spent_coins: bool = True,
         start_height: Optional[int] = None,
         end_height: Optional[int] = None,
-    ) -> List[CoinRecord]:
+    ) -> list[CoinRecord]:
         """
         Retrieves coins by hint, by default returns unspent coins.
         """
-        names: List[bytes32] = await self.service.hint_store.get_coin_ids(hint)
+        names: list[bytes32] = await self.service.hint_store.get_coin_ids(hint)
 
-        kwargs: Dict[str, Any] = {
+        kwargs: dict[str, Any] = {
             "include_spent_coins": False,
             "names": names,
         }

chia/_tests/util/split_managers.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import contextlib
+from collections.abc import AsyncIterator, Iterator
 from dataclasses import dataclass
-from typing import AsyncContextManager, AsyncIterator, ContextManager, Generic, Iterator, List, TypeVar
+from typing import Generic, TypeVar
 
 T = TypeVar("T")
 
@@ -10,13 +11,13 @@ T = TypeVar("T")
 @dataclass
 class SplitManager(Generic[T]):
     # NOTE: only for transitional testing use, please avoid usage
-    manager: ContextManager[object]
+    manager: contextlib.AbstractContextManager[object]
     object: T
     _entered: bool = False
     _exited: bool = False
 
     def enter(self) -> None:
-        messages: List[str] = []
+        messages: list[str] = []
         if self._entered:
             messages.append("already entered")
         if self._exited:
@@ -31,7 +32,7 @@ class SplitManager(Generic[T]):
         if if_needed and (not self._entered or self._exited):
             return
 
-        messages: List[str] = []
+        messages: list[str] = []
         if not self._entered:
             messages.append("not yet entered")
         if self._exited:
@@ -46,13 +47,13 @@ class SplitManager(Generic[T]):
 @dataclass
 class SplitAsyncManager(Generic[T]):
     # NOTE: only for transitional testing use, please avoid usage
-    manager: AsyncContextManager[object]
+    manager: contextlib.AbstractAsyncContextManager[object]
     object: T
     _entered: bool = False
     _exited: bool = False
 
     async def enter(self) -> None:
-        messages: List[str] = []
+        messages: list[str] = []
         if self._entered:
             messages.append("already entered")
         if self._exited:
@@ -67,7 +68,7 @@ class SplitAsyncManager(Generic[T]):
         if if_needed and (not self._entered or self._exited):
             return
 
-        messages: List[str] = []
+        messages: list[str] = []
         if not self._entered:
             messages.append("not yet entered")
         if self._exited:
@@ -80,7 +81,7 @@ class SplitAsyncManager(Generic[T]):
 
 
 @contextlib.contextmanager
-def split_manager(manager: ContextManager[object], object: T) -> Iterator[SplitManager[T]]:
+def split_manager(manager: contextlib.AbstractContextManager[object], object: T) -> Iterator[SplitManager[T]]:
     # NOTE: only for transitional testing use, please avoid usage
     split = SplitManager(manager=manager, object=object)
     try:
@@ -90,7 +91,9 @@ def split_manager(manager: ContextManager[object], object: T) -> Iterator[SplitM
 
 
 @contextlib.asynccontextmanager
-async def split_async_manager(manager: AsyncContextManager[object], object: T) -> AsyncIterator[SplitAsyncManager[T]]:
+async def split_async_manager(
+    manager: contextlib.AbstractAsyncContextManager[object], object: T
+) -> AsyncIterator[SplitAsyncManager[T]]:
     # NOTE: only for transitional testing use, please avoid usage
     split = SplitAsyncManager(manager=manager, object=object)
     try:

chia/_tests/util/temp_file.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import contextlib
 import tempfile
+from collections.abc import Iterator
 from pathlib import Path
-from typing import Iterator
 
 
 @contextlib.contextmanager