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

chia/_tests/conftest.py

@@ -1,8 +1,7 @@
-# flake8: noqa E402 # See imports after multiprocessing.set_start_method
+# ruff: noqa: E402 # See imports after multiprocessing.set_start_method
 from __future__ import annotations
 
 import asyncio
-import dataclasses
 import datetime
 import functools
 import json
@@ -13,8 +12,9 @@ import os
 import random
 import sysconfig
 import tempfile
+from collections.abc import AsyncIterator, Iterator
 from contextlib import AsyncExitStack
-from typing import Any, AsyncIterator, Callable, Dict, Iterator, List, Tuple, Union
+from typing import Any, Callable, Union
 
 import aiohttp
 import pytest
@@ -23,7 +23,6 @@ import pytest
 from _pytest.fixtures import SubRequest
 from pytest import MonkeyPatch
 
-import chia._tests
 from chia._tests import ether
 from chia._tests.core.data_layer.util import ChiaRoot
 from chia._tests.core.node_height import node_height_at_least
@@ -46,16 +45,13 @@ from chia._tests.util.setup_nodes import (
     setup_simulators_and_wallets_service,
     setup_two_nodes,
 )
+from chia._tests.util.spend_sim import CostLogger
 from chia._tests.util.time_out_assert import time_out_assert
-from chia.clvm.spend_sim import CostLogger
 from chia.consensus.constants import ConsensusConstants
-from chia.full_node.full_node import FullNode
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.rpc.farmer_rpc_client import FarmerRpcClient
 from chia.rpc.harvester_rpc_client import HarvesterRpcClient
 from chia.rpc.wallet_rpc_client import WalletRpcClient
-from chia.seeder.crawler import Crawler
-from chia.seeder.crawler_api import CrawlerAPI
 from chia.seeder.dns_server import DNSServer
 from chia.server.server import ChiaServer
 from chia.server.start_service import Service
@@ -70,13 +66,10 @@ from chia.simulator.setup_services import (
 )
 from chia.simulator.start_simulator import SimulatorFullNodeService
 from chia.simulator.wallet_tools import WalletTool
-from chia.timelord.timelord import Timelord
-from chia.timelord.timelord_api import TimelordAPI
 
 # Set spawn after stdlib imports, but before other imports
 from chia.types.aliases import (
     CrawlerService,
-    DataLayerService,
     FarmerService,
     FullNodeService,
     HarvesterService,
@@ -91,16 +84,21 @@ from chia.util.keychain import Keychain
 from chia.util.task_timing import main as task_instrumentation_main
 from chia.util.task_timing import start_task_instrumentation, stop_task_instrumentation
 from chia.wallet.wallet_node import WalletNode
-from chia.wallet.wallet_node_api import WalletNodeAPI
 
 multiprocessing.set_start_method("spawn")
 
+from dataclasses import replace
 from pathlib import Path
 
+from chia._tests.environments.wallet import WalletEnvironment, WalletState, WalletTestFramework
 from chia._tests.util.setup_nodes import setup_farmer_multi_harvester
+from chia.rpc.full_node_rpc_client import FullNodeRpcClient
 from chia.simulator.block_tools import BlockTools, create_block_tools_async, test_constants
 from chia.simulator.keyring import TempKeyring
+from chia.util.ints import uint128
 from chia.util.keyring_wrapper import KeyringWrapper
+from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
+from chia.wallet.wallet_node import Balance
 
 
 @pytest.fixture(name="ether_setup", autouse=True)
@@ -255,7 +253,7 @@ async def empty_blockchain(latest_db_version, blockchain_constants):
     """
     from chia._tests.util.blockchain import create_blockchain
 
-    async with create_blockchain(blockchain_constants, latest_db_version) as (bc1, db_wrapper):
+    async with create_blockchain(blockchain_constants, latest_db_version) as (bc1, _):
         yield bc1
 
 
@@ -550,12 +548,12 @@ def pytest_configure(config):
         globals()[time_out_assert_repeat_fixture.__name__] = time_out_assert_repeat_fixture
 
 
-def pytest_collection_modifyitems(session, config: pytest.Config, items: List[pytest.Function]):
+def pytest_collection_modifyitems(session, config: pytest.Config, items: list[pytest.Function]):
     # https://github.com/pytest-dev/pytest/issues/3730#issuecomment-567142496
     removed = []
     kept = []
-    all_error_lines: List[str] = []
-    limit_consensus_modes_problems: List[str] = []
+    all_error_lines: list[str] = []
+    limit_consensus_modes_problems: list[str] = []
     for item in items:
         limit_consensus_modes_marker = item.get_closest_marker("limit_consensus_modes")
         if limit_consensus_modes_marker is not None:
@@ -583,7 +581,7 @@ def pytest_collection_modifyitems(session, config: pytest.Config, items: List[py
         all_error_lines.append("@pytest.mark.limit_consensus_modes used without consensus_mode:")
         all_error_lines.extend(f"    {line}" for line in limit_consensus_modes_problems)
 
-    benchmark_problems: List[str] = []
+    benchmark_problems: list[str] = []
     for item in items:
         existing_benchmark_mark = item.get_closest_marker("benchmark")
         if existing_benchmark_mark is not None:
@@ -619,7 +617,7 @@ async def two_nodes(db_version: int, self_hostname, blockchain_constants: Consen
 @pytest.fixture(scope="function")
 async def setup_two_nodes_fixture(
     db_version: int, blockchain_constants: ConsensusConstants
-) -> AsyncIterator[Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools]]:
+) -> AsyncIterator[tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools]]:
     async with setup_simulators_and_wallets(2, 0, blockchain_constants, db_version=db_version) as new:
         yield make_old_setup_simulators_and_wallets(new=new)
 
@@ -638,13 +636,12 @@ async def five_nodes(db_version: int, self_hostname, blockchain_constants):
 
 @pytest.fixture(scope="function")
 async def wallet_nodes(blockchain_constants, consensus_mode):
-    constants = blockchain_constants
     async with setup_simulators_and_wallets(
         2,
         1,
         blockchain_constants.replace(MEMPOOL_BLOCK_BUFFER=1, MAX_BLOCK_COST_CLVM=400000000),
     ) as new:
-        (nodes, wallets, bt) = make_old_setup_simulators_and_wallets(new=new)
+        (nodes, _wallets, bt) = make_old_setup_simulators_and_wallets(new=new)
         full_node_1 = nodes[0]
         full_node_2 = nodes[1]
         server_1 = full_node_1.full_node.server
@@ -681,7 +678,7 @@ async def wallet_node_100_pk(blockchain_constants: ConsensusConstants):
 @pytest.fixture(scope="function")
 async def simulator_and_wallet(
     blockchain_constants: ConsensusConstants,
-) -> AsyncIterator[Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools]]:
+) -> AsyncIterator[tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools]]:
     async with setup_simulators_and_wallets(1, 1, blockchain_constants) as new:
         yield make_old_setup_simulators_and_wallets(new=new)
 
@@ -698,7 +695,7 @@ async def two_wallet_nodes(request, blockchain_constants: ConsensusConstants):
 @pytest.fixture(scope="function")
 async def two_wallet_nodes_services(
     blockchain_constants: ConsensusConstants,
-) -> AsyncIterator[Tuple[List[SimulatorFullNodeService], List[WalletService], BlockTools]]:
+) -> AsyncIterator[tuple[list[SimulatorFullNodeService], list[WalletService], BlockTools]]:
     async with setup_simulators_and_wallets_service(1, 2, blockchain_constants) as _:
         yield _
 
@@ -764,7 +761,7 @@ async def wallet_nodes_perf(blockchain_constants: ConsensusConstants):
     async with setup_simulators_and_wallets(
         1, 1, blockchain_constants, config_overrides={"MEMPOOL_BLOCK_BUFFER": 1, "MAX_BLOCK_COST_CLVM": 11000000000}
     ) as new:
-        (nodes, wallets, bt) = make_old_setup_simulators_and_wallets(new=new)
+        (nodes, _wallets, bt) = make_old_setup_simulators_and_wallets(new=new)
         full_node_1 = nodes[0]
         server_1 = full_node_1.full_node.server
         wallet_a = bt.get_pool_wallet_tool()
@@ -781,7 +778,7 @@ async def three_nodes_two_wallets(blockchain_constants: ConsensusConstants):
 @pytest.fixture(scope="function")
 async def one_node(
     blockchain_constants: ConsensusConstants,
-) -> AsyncIterator[Tuple[List[Service], List[FullNodeSimulator], BlockTools]]:
+) -> AsyncIterator[tuple[list[Service], list[FullNodeSimulator], BlockTools]]:
     async with setup_simulators_and_wallets_service(1, 0, blockchain_constants) as _:
         yield _
 
@@ -789,7 +786,7 @@ async def one_node(
 @pytest.fixture(scope="function")
 async def one_node_one_block(
     blockchain_constants: ConsensusConstants,
-) -> AsyncIterator[Tuple[Union[FullNodeAPI, FullNodeSimulator], ChiaServer, BlockTools]]:
+) -> AsyncIterator[tuple[Union[FullNodeAPI, FullNodeSimulator], ChiaServer, BlockTools]]:
     async with setup_simulators_and_wallets(1, 0, blockchain_constants) as new:
         (nodes, _, bt) = make_old_setup_simulators_and_wallets(new=new)
         full_node_1 = nodes[0]
@@ -849,7 +846,7 @@ async def farmer_one_harvester_simulator_wallet(
     tmp_path: Path,
     blockchain_constants: ConsensusConstants,
 ) -> AsyncIterator[
-    Tuple[
+    tuple[
         HarvesterService,
         FarmerService,
         SimulatorFullNodeService,
@@ -866,7 +863,7 @@ async def farmer_one_harvester_simulator_wallet(
             yield harvester_services[0], farmer_service, nodes[0], wallets[0], bt
 
 
-FarmerOneHarvester = Tuple[List[HarvesterService], FarmerService, BlockTools]
+FarmerOneHarvester = tuple[list[HarvesterService], FarmerService, BlockTools]
 
 
 @pytest.fixture(scope="function")
@@ -878,7 +875,7 @@ async def farmer_one_harvester(tmp_path: Path, get_b_tools: BlockTools) -> Async
 @pytest.fixture(scope="function")
 async def farmer_one_harvester_not_started(
     tmp_path: Path, get_b_tools: BlockTools
-) -> AsyncIterator[Tuple[List[Service], Service]]:
+) -> AsyncIterator[tuple[list[Service], Service]]:
     async with setup_farmer_multi_harvester(get_b_tools, 1, tmp_path, get_b_tools.constants, start_services=False) as _:
         yield _
 
@@ -886,7 +883,7 @@ async def farmer_one_harvester_not_started(
 @pytest.fixture(scope="function")
 async def farmer_two_harvester_not_started(
     tmp_path: Path, get_b_tools: BlockTools
-) -> AsyncIterator[Tuple[List[Service], Service]]:
+) -> AsyncIterator[tuple[list[Service], Service]]:
     async with setup_farmer_multi_harvester(get_b_tools, 2, tmp_path, get_b_tools.constants, start_services=False) as _:
         yield _
 
@@ -894,7 +891,7 @@ async def farmer_two_harvester_not_started(
 @pytest.fixture(scope="function")
 async def farmer_three_harvester_not_started(
     tmp_path: Path, get_b_tools: BlockTools
-) -> AsyncIterator[Tuple[List[Service], Service]]:
+) -> AsyncIterator[tuple[list[Service], Service]]:
     async with setup_farmer_multi_harvester(get_b_tools, 3, tmp_path, get_b_tools.constants, start_services=False) as _:
         yield _
 
@@ -934,7 +931,7 @@ async def get_b_tools(get_temp_keyring):
 @pytest.fixture(scope="function")
 async def daemon_connection_and_temp_keychain(
     get_b_tools: BlockTools,
-) -> AsyncIterator[Tuple[aiohttp.ClientWebSocketResponse, Keychain]]:
+) -> AsyncIterator[tuple[aiohttp.ClientWebSocketResponse, Keychain]]:
     async with setup_daemon(btools=get_b_tools) as daemon:
         keychain = daemon.keychain_server._default_keychain
         async with aiohttp.ClientSession() as session:
@@ -1128,13 +1125,13 @@ def root_path_populated_with_config(tmp_chia_root) -> Path:
 
 
 @pytest.fixture(scope="function")
-def config(root_path_populated_with_config: Path) -> Dict[str, Any]:
+def config(root_path_populated_with_config: Path) -> dict[str, Any]:
     with lock_and_load_config(root_path_populated_with_config, "config.yaml") as config:
         return config
 
 
 @pytest.fixture(scope="function")
-def config_with_address_prefix(root_path_populated_with_config: Path, prefix: str) -> Dict[str, Any]:
+def config_with_address_prefix(root_path_populated_with_config: Path, prefix: str) -> dict[str, Any]:
     with lock_and_load_config(root_path_populated_with_config, "config.yaml") as config:
         if prefix is not None:
             config["network_overrides"]["config"][config["selected_network"]]["address_prefix"] = prefix
@@ -1174,12 +1171,12 @@ async def simulation(bt, get_b_tools):
         yield full_system, get_b_tools
 
 
-HarvesterFarmerEnvironment = Tuple[FarmerService, FarmerRpcClient, HarvesterService, HarvesterRpcClient, BlockTools]
+HarvesterFarmerEnvironment = tuple[FarmerService, FarmerRpcClient, HarvesterService, HarvesterRpcClient, BlockTools]
 
 
 @pytest.fixture(scope="function")
 async def harvester_farmer_environment(
-    farmer_one_harvester: Tuple[List[HarvesterService], FarmerService, BlockTools],
+    farmer_one_harvester: tuple[list[HarvesterService], FarmerService, BlockTools],
     self_hostname: str,
 ) -> AsyncIterator[HarvesterFarmerEnvironment]:
     harvesters, farmer_service, bt = farmer_one_harvester
@@ -1229,7 +1226,7 @@ def populated_temp_file_keyring_fixture() -> Iterator[TempKeyring]:
 async def farmer_harvester_2_simulators_zero_bits_plot_filter(
     tmp_path: Path, get_temp_keyring: Keychain
 ) -> AsyncIterator[
-    Tuple[
+    tuple[
         FarmerService,
         HarvesterService,
         Union[FullNodeService, SimulatorFullNodeService],
@@ -1248,7 +1245,7 @@ async def farmer_harvester_2_simulators_zero_bits_plot_filter(
             keychain=get_temp_keyring,
         )
 
-        config_overrides: Dict[str, int] = {"full_node.max_sync_wait": 0}
+        config_overrides: dict[str, int] = {"full_node.max_sync_wait": 0}
 
         bts = [
             await create_block_tools_async(
@@ -1262,7 +1259,7 @@ async def farmer_harvester_2_simulators_zero_bits_plot_filter(
             for _ in range(2)
         ]
 
-        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]
@@ -1302,3 +1299,121 @@ async def recording_web_server_fixture(self_hostname: str) -> AsyncIterator[Reco
 )
 def use_delta_sync(request: SubRequest):
     return request.param
+
+
+# originally from _tests/wallet/conftest.py
+@pytest.fixture(scope="function", params=[True, False])
+def trusted_full_node(request: Any) -> bool:
+    trusted: bool = request.param
+    return trusted
+
+
+@pytest.fixture(scope="function", params=[True, False])
+def tx_config(request: Any) -> TXConfig:
+    return replace(DEFAULT_TX_CONFIG, reuse_puzhash=request.param)
+
+
+# This fixture automatically creates 4 parametrized tests trusted/untrusted x reuse/new derivations
+# These parameterizations can be skipped by manually specifying "trusted" or "reuse puzhash" to the fixture
+@pytest.fixture(scope="function")
+async def wallet_environments(
+    trusted_full_node: bool,
+    tx_config: TXConfig,
+    blockchain_constants: ConsensusConstants,
+    request: pytest.FixtureRequest,
+) -> AsyncIterator[WalletTestFramework]:
+    if "trusted" in request.param:
+        if request.param["trusted"] != trusted_full_node:
+            pytest.skip("Skipping not specified trusted mode")
+    if "reuse_puzhash" in request.param:
+        if request.param["reuse_puzhash"] != tx_config.reuse_puzhash:
+            pytest.skip("Skipping not specified reuse_puzhash mode")
+    assert len(request.param["blocks_needed"]) == request.param["num_environments"]
+    if "config_overrides" in request.param:
+        config_overrides: dict[str, Any] = request.param["config_overrides"]
+    else:  # pragma: no cover
+        config_overrides = {}
+    async with setup_simulators_and_wallets_service(
+        1,
+        request.param["num_environments"],
+        blockchain_constants,
+        initial_num_public_keys=config_overrides.get("initial_num_public_keys", 5),
+    ) as wallet_nodes_services:
+        full_node, wallet_services, bt = wallet_nodes_services
+
+        full_node[0]._api.full_node.config = {**full_node[0]._api.full_node.config, **config_overrides}
+
+        wallet_rpc_clients: list[WalletRpcClient] = []
+        async with AsyncExitStack() as astack:
+            for service in wallet_services:
+                service._node.config = {
+                    **service._node.config,
+                    "trusted_peers": (
+                        {full_node[0]._api.server.node_id.hex(): full_node[0]._api.server.node_id.hex()}
+                        if trusted_full_node
+                        else {}
+                    ),
+                    **config_overrides,
+                }
+                service._node.wallet_state_manager.config = service._node.config
+                # Shorten the 10 seconds default value
+                service._node.coin_state_retry_seconds = 2
+                await service._node.server.start_client(
+                    PeerInfo(bt.config["self_hostname"], full_node[0]._api.full_node.server.get_port()), None
+                )
+                wallet_rpc_clients.append(
+                    await astack.enter_async_context(
+                        WalletRpcClient.create_as_context(
+                            bt.config["self_hostname"],
+                            # Semantics guarantee us a non-None value here
+                            service.rpc_server.listen_port,  # type: ignore[union-attr]
+                            service.root_path,
+                            service.config,
+                        )
+                    )
+                )
+
+            wallet_states: list[WalletState] = []
+            for service, blocks_needed in zip(wallet_services, request.param["blocks_needed"]):
+                if blocks_needed > 0:
+                    await full_node[0]._api.farm_blocks_to_wallet(
+                        count=blocks_needed, wallet=service._node.wallet_state_manager.main_wallet
+                    )
+                    await full_node[0]._api.wait_for_wallet_synced(wallet_node=service._node, timeout=20)
+                wallet_states.append(
+                    WalletState(
+                        Balance(
+                            confirmed_wallet_balance=uint128(2_000_000_000_000 * blocks_needed),
+                            unconfirmed_wallet_balance=uint128(2_000_000_000_000 * blocks_needed),
+                            spendable_balance=uint128(2_000_000_000_000 * blocks_needed),
+                            pending_change=uint64(0),
+                            max_send_amount=uint128(2_000_000_000_000 * blocks_needed),
+                            unspent_coin_count=uint32(2 * blocks_needed),
+                            pending_coin_removal_count=uint32(0),
+                        ),
+                    )
+                )
+
+            assert full_node[0].rpc_server is not None
+            client_node = await astack.enter_async_context(
+                FullNodeRpcClient.create_as_context(
+                    bt.config["self_hostname"],
+                    full_node[0].rpc_server.listen_port,
+                    full_node[0].root_path,
+                    full_node[0].config,
+                )
+            )
+            yield WalletTestFramework(
+                full_node[0]._api,
+                client_node,
+                trusted_full_node,
+                [
+                    WalletEnvironment(
+                        service=service,
+                        rpc_client=rpc_client,
+                        wallet_states={uint32(1): wallet_state},
+                    )
+                    for service, rpc_client, wallet_state in zip(wallet_services, wallet_rpc_clients, wallet_states)
+                ],
+                tx_config,
+            )

chia/_tests/connection_utils.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import asyncio
 import logging
 from pathlib import Path
-from typing import List, Set, Tuple
 
 import aiohttp
 from cryptography import x509
@@ -11,6 +10,7 @@ from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import hashes, serialization
 
 from chia._tests.util.time_out_assert import time_out_assert
+from chia.apis import ApiProtocolRegistry
 from chia.protocols.shared_protocol import default_capabilities
 from chia.server.outbound_message import NodeType
 from chia.server.server import ChiaServer, ssl_context_for_client
@@ -44,8 +44,8 @@ async def add_dummy_connection(
     dummy_port: int,
     type: NodeType = NodeType.FULL_NODE,
     *,
-    additional_capabilities: List[Tuple[uint16, str]] = [],
-) -> Tuple[asyncio.Queue, bytes32]:
+    additional_capabilities: list[tuple[uint16, str]] = [],
+) -> tuple[asyncio.Queue, bytes32]:
     wsc, peer_id = await add_dummy_connection_wsc(
         server, self_hostname, dummy_port, type, additional_capabilities=additional_capabilities
     )
@@ -58,15 +58,15 @@ async def add_dummy_connection_wsc(
     self_hostname: str,
     dummy_port: int,
     type: NodeType = NodeType.FULL_NODE,
-    additional_capabilities: List[Tuple[uint16, str]] = [],
-) -> Tuple[WSChiaConnection, bytes32]:
+    additional_capabilities: list[tuple[uint16, str]] = [],
+) -> tuple[WSChiaConnection, bytes32]:
     timeout = aiohttp.ClientTimeout(total=10)
     session = aiohttp.ClientSession(timeout=timeout)
     config = load_config(server.root_path, "config.yaml")
 
     ca_crt_path: Path
     ca_key_path: Path
-    authenticated_client_types: Set[NodeType] = {NodeType.HARVESTER}
+    authenticated_client_types: set[NodeType] = {NodeType.HARVESTER}
     if type in authenticated_client_types:
         private_ca_crt_path, private_ca_key_path = private_ssl_ca_paths(server.root_path, config)
         ca_crt_path = private_ca_crt_path
@@ -98,6 +98,7 @@ async def add_dummy_connection_wsc(
         100,
         30,
         local_capabilities_for_handshake=default_capabilities[type] + additional_capabilities,
+        class_for_type=ApiProtocolRegistry,
     )
     await wsc.perform_handshake(server._network_id, dummy_port, type)
     if wsc.incoming_message_task is not None:

chia/_tests/core/cmds/test_beta.py

@@ -342,7 +342,7 @@ def test_prepare_submission(
     assert output in result.output
 
     if exit_code == 0:
-        submission_file = list(beta_path.rglob("*.zip"))[0]
+        submission_file = next(iter(beta_path.rglob("*.zip")))
         assert submission_file.name.startswith(f"submission_{choice - 1}")
         with zipfile.ZipFile(submission_file) as zip_file:
             all_files = [Path(info.filename) for info in zip_file.filelist]
@@ -378,5 +378,5 @@ def test_beta_status(root_path_populated_with_config: Path, enabled: bool, path:
 
     assert result.exit_code == 0
     assert f"enabled: {enabled}" in result.output
-    assert f"path: {str(path)}" in result.output
-    assert f"metrics log interval: {str(metrics_log_interval_default)}" in result.output
+    assert f"path: {path!s}" in result.output
+    assert f"metrics log interval: {metrics_log_interval_default!s}" in result.output

chia/_tests/core/cmds/test_keys.py

@@ -4,7 +4,7 @@ import json
 import os
 import re
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Optional
 
 import pytest
 from click.testing import CliRunner, Result
@@ -105,7 +105,7 @@ class TestKeysCommands:
         assert len(address_matches) > 1
         address = address_matches[0]
 
-        config: Dict = load_config(tmp_path, "config.yaml")
+        config: dict = load_config(tmp_path, "config.yaml")
         assert config["farmer"]["xch_target_address"] == address
         assert config["pool"]["xch_target_address"] == address
 
@@ -153,7 +153,7 @@ class TestKeysCommands:
         assert len(address_matches) > 1
         address = address_matches[0]
 
-        existing_config: Dict = load_config(tmp_path, "config.yaml")
+        existing_config: dict = load_config(tmp_path, "config.yaml")
         assert existing_config["farmer"]["xch_target_address"] == address
         assert existing_config["pool"]["xch_target_address"] == address
 
@@ -177,7 +177,7 @@ class TestKeysCommands:
         assert len(keychain.get_all_private_keys()) == 2
 
         # Verify that the config's xch_target_address entries have not changed
-        config: Dict = load_config(tmp_path, "config.yaml")
+        config: dict = load_config(tmp_path, "config.yaml")
         assert config["farmer"]["xch_target_address"] == existing_config["farmer"]["xch_target_address"]
         assert config["pool"]["xch_target_address"] == existing_config["pool"]["xch_target_address"]
 
@@ -200,7 +200,7 @@ class TestKeysCommands:
         ],
     )
     def test_generate_and_add_label_parameter(
-        self, cmd_params: List[str], label: Optional[str], input_str: Optional[str], tmp_path, empty_keyring
+        self, cmd_params: list[str], label: Optional[str], input_str: Optional[str], tmp_path, empty_keyring
     ):
         keychain = empty_keyring
         keys_root_path = keychain.keyring_wrapper.keys_root_path
@@ -1322,7 +1322,7 @@ class TestKeysCommands:
         assert result.exit_code == 0
         assert (
             result.output.find(
-                "Wallet address 9 (m/12381/8444/2/9): " "xch1p33y7kv48u7l68m490mr8levl6nkyxm3x8tfcnnec555egxzd3gs829wkl"
+                "Wallet address 9 (m/12381/8444/2/9): xch1p33y7kv48u7l68m490mr8levl6nkyxm3x8tfcnnec555egxzd3gs829wkl"
             )
             != -1
         )

chia/_tests/core/cmds/test_wallet.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Optional
 
 import pytest
 
@@ -12,14 +12,14 @@ TEST_DUCKSAUCE_ASSET_ID = "10000000000000000000000000000000000000000000000000000
 TEST_CRUNCHBERRIES_ASSET_ID = "1000000000000000000000000000000000000000000000000000000000000002"
 TEST_UNICORNTEARS_ASSET_ID = "1000000000000000000000000000000000000000000000000000000000000003"
 
-TEST_ASSET_ID_NAME_MAPPING: Dict[bytes32, Tuple[uint32, str]] = {
+TEST_ASSET_ID_NAME_MAPPING: dict[bytes32, tuple[uint32, str]] = {
     bytes32.from_hexstr(TEST_DUCKSAUCE_ASSET_ID): (uint32(2), "DuckSauce"),
     bytes32.from_hexstr(TEST_CRUNCHBERRIES_ASSET_ID): (uint32(3), "CrunchBerries"),
     bytes32.from_hexstr(TEST_UNICORNTEARS_ASSET_ID): (uint32(4), "UnicornTears"),
 }
 
 
-async def cat_name_resolver(asset_id: bytes32) -> Optional[Tuple[Optional[uint32], str]]:
+async def cat_name_resolver(asset_id: bytes32) -> Optional[tuple[Optional[uint32], str]]:
     return TEST_ASSET_ID_NAME_MAPPING.get(asset_id)
 
 

chia/_tests/core/consensus/test_block_creation.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import List
-
 import pytest
 
 from chia._tests.core.make_block_generator import make_block_generator
@@ -15,9 +13,9 @@ from chia.util.ints import uint32, uint64
 
 @pytest.mark.parametrize("add_amount", [[0], [1, 2, 3], []])
 @pytest.mark.parametrize("rem_amount", [[0], [1, 2, 3], []])
-def test_compute_block_fee(add_amount: List[int], rem_amount: List[int]) -> None:
-    additions: List[Coin] = [Coin(bytes32.random(), bytes32.random(), uint64(amt)) for amt in add_amount]
-    removals: List[Coin] = [Coin(bytes32.random(), bytes32.random(), uint64(amt)) for amt in rem_amount]
+def test_compute_block_fee(add_amount: list[int], rem_amount: list[int]) -> None:
+    additions: list[Coin] = [Coin(bytes32.random(), bytes32.random(), uint64(amt)) for amt in add_amount]
+    removals: list[Coin] = [Coin(bytes32.random(), bytes32.random(), uint64(amt)) for amt in rem_amount]
 
     # the fee is the left-overs from the removals (spent) coins after deducting
     # the newly created coins (additions)

chia/_tests/core/custom_types/test_coin.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import List
-
 import pytest
 
 from chia.types.blockchain_format.coin import Coin
@@ -65,7 +63,7 @@ def test_serialization():
         (0x7FFFFFFFFFFFFFFF, [0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]),
     ],
 )
-def test_name(amount: int, clvm: List[int]) -> None:
+def test_name(amount: int, clvm: list[int]) -> None:
     H1 = bytes32(b"a" * 32)
     H2 = bytes32(b"b" * 32)
 

chia/_tests/core/custom_types/test_spend_bundle.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import random
 import unittest
-from typing import List, Tuple
 
 import pytest
 from chia_rs import G2Element
@@ -36,9 +35,9 @@ def rand_hash(rng: random.Random) -> bytes32:
     return bytes32(ret)
 
 
-def create_spends(num: int) -> Tuple[List[CoinSpend], List[Coin]]:
-    spends: List[CoinSpend] = []
-    create_coin: List[Coin] = []
+def create_spends(num: int) -> tuple[list[CoinSpend], list[Coin]]:
+    spends: list[CoinSpend] = []
+    create_coin: list[Coin] = []
     rng = random.Random()
 
     puzzle = Program.to(1)