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

chia/_tests/environments/wallet.py

@@ -1,11 +1,16 @@
 from __future__ import annotations
 
+import contextlib
 import json
 import operator
+import unittest
+from collections.abc import Iterator
 from dataclasses import asdict, dataclass, field
-from typing import TYPE_CHECKING, ClassVar, Dict, List, Optional, Tuple, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Union, cast
 
 from chia._tests.environments.common import ServiceEnvironment
+from chia.cmds.cmd_helpers import NeedsTXConfig, NeedsWalletRPC, TransactionEndpoint, TransactionsOut, WalletClientInfo
+from chia.cmds.param_types import CliAmount, cli_amount_none
 from chia.rpc.full_node_rpc_client import FullNodeRpcClient
 from chia.rpc.rpc_server import RpcServer
 from chia.rpc.wallet_rpc_api import WalletRpcApi
@@ -14,9 +19,8 @@ from chia.server.server import ChiaServer
 from chia.server.start_service import Service
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.util.ints import uint32
-from chia.wallet.derivation_record import DerivationRecord
-from chia.wallet.transaction_record import TransactionRecord
+from chia.util.ints import uint32, uint64
+from chia.wallet.transaction_record import LightTransactionRecord
 from chia.wallet.util.transaction_type import CLAWBACK_INCOMING_TRANSACTION_TYPES
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
 from chia.wallet.wallet import Wallet
@@ -24,13 +28,29 @@ from chia.wallet.wallet_node import Balance, WalletNode
 from chia.wallet.wallet_node_api import WalletNodeAPI
 from chia.wallet.wallet_state_manager import WalletStateManager
 
+STANDARD_TX_ENDPOINT_ARGS: dict[str, Any] = TransactionEndpoint(
+    rpc_info=NeedsWalletRPC(client_info=None, wallet_rpc_port=None, fingerprint=None),
+    tx_config_loader=NeedsTXConfig(
+        min_coin_amount=cli_amount_none,
+        max_coin_amount=cli_amount_none,
+        coins_to_exclude=(),
+        amounts_to_exclude=(),
+        reuse=None,
+    ),
+    transaction_writer=TransactionsOut(transaction_file_out=None),
+    fee=uint64(0),
+    push=True,
+    valid_at=None,
+    expires_at=None,
+).__dict__
+
 OPP_DICT = {"<": operator.lt, ">": operator.gt, "<=": operator.le, ">=": operator.ge}
 
 
 class BalanceCheckingError(Exception):
-    errors: Dict[Union[int, str], List[str]]
+    errors: dict[Union[int, str], list[str]]
 
-    def __init__(self, errors: Dict[Union[int, str], List[str]]) -> None:
+    def __init__(self, errors: dict[Union[int, str], list[str]]) -> None:
         self.errors = errors
 
     def __repr__(self) -> str:
@@ -47,10 +67,10 @@ class WalletState:
 
 @dataclass
 class WalletStateTransition:
-    pre_block_balance_updates: Dict[Union[int, str], Dict[str, int]] = field(default_factory=dict)
-    post_block_balance_updates: Dict[Union[int, str], Dict[str, int]] = field(default_factory=dict)
-    pre_block_additional_balance_info: Dict[Union[int, str], Dict[str, int]] = field(default_factory=dict)
-    post_block_additional_balance_info: Dict[Union[int, str], Dict[str, int]] = field(default_factory=dict)
+    pre_block_balance_updates: dict[Union[int, str], dict[str, int]] = field(default_factory=dict)
+    post_block_balance_updates: dict[Union[int, str], dict[str, int]] = field(default_factory=dict)
+    pre_block_additional_balance_info: dict[Union[int, str], dict[str, int]] = field(default_factory=dict)
+    post_block_additional_balance_info: dict[Union[int, str], dict[str, int]] = field(default_factory=dict)
 
 
 @dataclass
@@ -60,14 +80,14 @@ class WalletEnvironment:
             "WalletEnvironment", None
         )
 
-    __match_args__: ClassVar[Tuple[str, ...]] = ()
+    __match_args__: ClassVar[tuple[str, ...]] = ()
 
     service: Service[WalletNode, WalletNodeAPI, WalletRpcApi]
     # TODO: maybe put this in the protocol?
     rpc_client: WalletRpcClient
     # TODO: added the default, but should think through implementing it etc.  `.create()`?
-    wallet_states: Dict[uint32, WalletState] = field(default_factory=dict)
-    wallet_aliases: Dict[str, int] = field(default_factory=dict)
+    wallet_states: dict[uint32, WalletState] = field(default_factory=dict)
+    wallet_aliases: dict[str, int] = field(default_factory=dict)
 
     @property
     def node(self) -> WalletNode:
@@ -113,31 +133,31 @@ class WalletEnvironment:
         """
         This function turns a wallet id into an alias if one is available or the same wallet id if one is not.
         """
-        inverted_wallet_aliases: Dict[int, str] = {v: k for k, v in self.wallet_aliases.items()}
+        inverted_wallet_aliases: dict[int, str] = {v: k for k, v in self.wallet_aliases.items()}
         if wallet_id in inverted_wallet_aliases:
             return inverted_wallet_aliases[wallet_id]
         else:
             return wallet_id
 
-    async def check_balances(self, additional_balance_info: Dict[Union[int, str], Dict[str, int]] = {}) -> None:
+    async def check_balances(self, additional_balance_info: dict[Union[int, str], dict[str, int]] = {}) -> None:
         """
         This function checks the internal representation of what the balances should be against the balances that the
         wallet actually returns via the RPC.
 
         Likely this should be called as part of WalletTestFramework.process_pending_states instead of directly.
         """
-        dealiased_additional_balance_info: Dict[uint32, Dict[str, int]] = {
+        dealiased_additional_balance_info: dict[uint32, dict[str, int]] = {
             self.dealias_wallet_id(k): v for k, v in additional_balance_info.items()
         }
-        errors: Dict[Union[int, str], List[str]] = {}
+        errors: dict[Union[int, str], list[str]] = {}
         for wallet_id in self.wallet_state_manager.wallets:
             if wallet_id not in self.wallet_states:
                 raise KeyError(f"No wallet state for wallet id {wallet_id} (alias: {self.alias_wallet_id(wallet_id)})")
             wallet_state: WalletState = self.wallet_states[wallet_id]
-            wallet_errors: List[str] = []
+            wallet_errors: list[str] = []
 
             assert self.node.logged_in_fingerprint is not None
-            expected_result: Dict[str, int] = {
+            expected_result: dict[str, int] = {
                 **wallet_state.balance.to_json_dict(),
                 "wallet_id": wallet_id,
                 "wallet_type": self.wallet_state_manager.wallets[wallet_id].type().value,
@@ -148,7 +168,7 @@ class WalletEnvironment:
                     else {}
                 ),
             }
-            balance_response: Dict[str, int] = await self.rpc_client.get_wallet_balance(wallet_id)
+            balance_response: dict[str, int] = await self.rpc_client.get_wallet_balance(wallet_id)
 
             if not expected_result.items() <= balance_response.items():
                 for key, value in expected_result.items():
@@ -165,7 +185,7 @@ class WalletEnvironment:
         if errors != {}:
             raise BalanceCheckingError(errors)
 
-    async def change_balances(self, update_dictionary: Dict[Union[int, str], Dict[str, int]]) -> None:
+    async def change_balances(self, update_dictionary: dict[Union[int, str], dict[str, int]]) -> None:
         """
         This method changes the internal representation of what the wallet balances should be. This is probably
         necessary to call before check_balances as most wallet operations will result in a balance change that causes
@@ -193,10 +213,10 @@ class WalletEnvironment:
         for wallet_id_or_alias, kwargs in update_dictionary.items():
             wallet_id: uint32 = self.dealias_wallet_id(wallet_id_or_alias)
 
-            new_values: Dict[str, int] = {}
+            new_values: dict[str, int] = {}
             existing_values: Balance = await self.node.get_balance(wallet_id)
-            if "init" in kwargs and kwargs["init"]:
-                new_values = {k: v for k, v in kwargs.items() if k not in ("set_remainder", "init")}
+            if kwargs.get("init", False):
+                new_values = {k: v for k, v in kwargs.items() if k not in {"set_remainder", "init"}}
             elif wallet_id not in self.wallet_states:
                 raise ValueError(
                     f"Wallet id {wallet_id} (alias: {self.alias_wallet_id(wallet_id)}) does not have a current state. "
@@ -227,17 +247,13 @@ class WalletEnvironment:
                 **self.wallet_states,
                 wallet_id: WalletState(
                     **{
-                        **({} if "init" in kwargs and kwargs["init"] else asdict(self.wallet_states[wallet_id])),
+                        **({} if kwargs.get("init", False) else asdict(self.wallet_states[wallet_id])),
                         "balance": Balance(
                             **{
                                 **(
                                     asdict(existing_values)
-                                    if "set_remainder" in kwargs and kwargs["set_remainder"]
-                                    else (
-                                        {}
-                                        if "init" in kwargs and kwargs["init"]
-                                        else asdict(self.wallet_states[wallet_id].balance)
-                                    )
+                                    if kwargs.get("set_remainder", False)
+                                    else ({} if kwargs.get("init") else asdict(self.wallet_states[wallet_id].balance))
                                 ),
                                 **new_values,
                             }
@@ -247,10 +263,10 @@ class WalletEnvironment:
             }
 
     async def wait_for_transactions_to_settle(
-        self, full_node_api: FullNodeSimulator, _exclude_from_mempool_check: List[bytes32] = []
-    ) -> List[TransactionRecord]:
+        self, full_node_api: FullNodeSimulator, _exclude_from_mempool_check: list[bytes32] = []
+    ) -> list[LightTransactionRecord]:
         # Gather all pending transactions
-        pending_txs: List[TransactionRecord] = await self.wallet_state_manager.tx_store.get_all_unconfirmed()
+        pending_txs: list[LightTransactionRecord] = await self.wallet_state_manager.tx_store.get_all_unconfirmed()
         # Filter clawback txs
         pending_txs = [
             tx
@@ -264,16 +280,62 @@ class WalletEnvironment:
         return pending_txs
 
 
+class NewPuzzleHashError(Exception):
+    pass
+
+
+def catch_puzzle_hash_errors(func: Any) -> Any:
+    @contextlib.asynccontextmanager
+    async def catching_puzhash_errors(self: WalletStateManager, *args: Any, **kwargs: Any) -> Any:
+        try:
+            async with func(self, *args, **kwargs) as action_scope:
+                yield action_scope
+        except NewPuzzleHashError:
+            pass
+
+    return catching_puzhash_errors
+
+
 @dataclass
 class WalletTestFramework:
     full_node: FullNodeSimulator
     full_node_rpc_client: FullNodeRpcClient
     trusted_full_node: bool
-    environments: List[WalletEnvironment]
+    environments: list[WalletEnvironment]
     tx_config: TXConfig = DEFAULT_TX_CONFIG
 
+    def cmd_tx_endpoint_args(self, env: WalletEnvironment) -> dict[str, Any]:
+        return {
+            **STANDARD_TX_ENDPOINT_ARGS,
+            "rpc_info": NeedsWalletRPC(
+                client_info=WalletClientInfo(
+                    env.rpc_client,
+                    env.wallet_state_manager.root_pubkey.get_fingerprint(),
+                    env.wallet_state_manager.config,
+                )
+            ),
+            "tx_config_loader": NeedsTXConfig(
+                min_coin_amount=CliAmount(amount=self.tx_config.min_coin_amount, mojos=True),
+                max_coin_amount=CliAmount(amount=self.tx_config.max_coin_amount, mojos=True),
+                coins_to_exclude=tuple(self.tx_config.excluded_coin_ids),
+                amounts_to_exclude=tuple(
+                    CliAmount(amount=amt, mojos=True) for amt in self.tx_config.excluded_coin_amounts
+                ),
+                reuse=self.tx_config.reuse_puzhash,
+            ),
+        }
+
+    @staticmethod
+    @contextlib.contextmanager
+    def new_puzzle_hashes_allowed() -> Iterator[None]:
+        with unittest.mock.patch(
+            "chia.wallet.wallet_state_manager.WalletStateManager.new_action_scope",
+            catch_puzzle_hash_errors(WalletStateManager.new_action_scope),
+        ):
+            yield
+
     async def process_pending_states(
-        self, state_transitions: List[WalletStateTransition], invalid_transactions: List[bytes32] = []
+        self, state_transitions: list[WalletStateTransition], invalid_transactions: list[bytes32] = []
     ) -> None:
         """
         This is the main entry point for processing state in wallet tests. It does the following things:
@@ -288,21 +350,20 @@ class WalletTestFramework:
         """
         # Take note of the number of puzzle hashes if we're supposed to be reusing
         if self.tx_config.reuse_puzhash:
-            puzzle_hash_indexes: List[Dict[uint32, Optional[DerivationRecord]]] = []
+            puzzle_hash_indexes: list[dict[uint32, int]] = []
             for env in self.environments:
-                ph_indexes: Dict[uint32, Optional[DerivationRecord]] = {}
+                ph_indexes: dict[uint32, int] = {}
                 for wallet_id in env.wallet_state_manager.wallets:
-                    ph_indexes[wallet_id] = (
-                        await env.wallet_state_manager.puzzle_store.get_current_derivation_record_for_wallet(wallet_id)
-                    )
+                    ph_indexes[wallet_id] = await env.wallet_state_manager.puzzle_store.get_unused_count(wallet_id)
                 puzzle_hash_indexes.append(ph_indexes)
 
-        pending_txs: List[List[TransactionRecord]] = []
-
+        pending_txs: list[list[LightTransactionRecord]] = []
+        peak = self.full_node.full_node.blockchain.get_peak_height()
+        assert peak is not None
         # Check balances prior to block
         try:
             for i, env in enumerate(self.environments):
-                await self.full_node.wait_for_wallet_synced(wallet_node=env.node, timeout=20)
+                await self.full_node.wait_for_wallet_synced(wallet_node=env.node, timeout=20, peak_height=peak)
                 try:
                     pending_txs.append(
                         await env.wait_for_transactions_to_settle(
@@ -322,8 +383,6 @@ class WalletTestFramework:
             raise ValueError("Error before block was farmed")
 
         # Farm block
-        peak = self.full_node.full_node.blockchain.get_peak_height()
-        assert peak is not None
         await self.full_node.farm_blocks_to_puzzlehash(count=1, guarantee_transaction_blocks=True)
 
         # Check balances after block
@@ -354,7 +413,9 @@ class WalletTestFramework:
             try:
                 await self.full_node.check_transactions_confirmed(env.wallet_state_manager, txs)
             except TimeoutError:  # pragma: no cover
-                unconfirmed: List[TransactionRecord] = await env.wallet_state_manager.tx_store.get_all_unconfirmed()
+                unconfirmed: list[
+                    LightTransactionRecord
+                ] = await env.wallet_state_manager.tx_store.get_all_unconfirmed()
                 raise TimeoutError(
                     f"ENV-{i} TXs not confirmed: {[tx.to_json_dict() for tx in unconfirmed if tx in txs]}"
                 )
@@ -364,5 +425,5 @@ class WalletTestFramework:
             for env, ph_indexes_before in zip(self.environments, puzzle_hash_indexes):
                 for wallet_id, ph_index in zip(env.wallet_state_manager.wallets, ph_indexes_before):
                     assert ph_indexes_before[wallet_id] == (
-                        await env.wallet_state_manager.puzzle_store.get_current_derivation_record_for_wallet(wallet_id)
+                        await env.wallet_state_manager.puzzle_store.get_unused_count(wallet_id)
                     )

chia/_tests/farmer_harvester/test_farmer.py

@@ -5,7 +5,7 @@ import logging
 from dataclasses import dataclass
 from time import time
 from types import TracebackType
-from typing import Any, Dict, List, Optional, Tuple, Type, Union, cast
+from typing import Any, Optional, Union, cast
 from unittest.mock import ANY
 
 import pytest
@@ -39,23 +39,23 @@ log = logging.getLogger(__name__)
 
 
 class StripOldEntriesCase:
-    pairs: List[Tuple[float, int]]
+    pairs: list[tuple[float, int]]
     before: float
-    expected_result: List[Tuple[float, int]]
+    expected_result: list[tuple[float, int]]
 
-    def __init__(self, pairs: List[Tuple[float, int]], before: float, expected_result: List[Tuple[float, int]]):
+    def __init__(self, pairs: list[tuple[float, int]], before: float, expected_result: list[tuple[float, int]]):
         self.pairs = pairs
         self.before = before
         self.expected_result = expected_result
 
 
 class IncrementPoolStatsCase:
-    pool_states: Dict[bytes32, Any]
+    pool_states: dict[bytes32, Any]
     p2_singleton_puzzle_hash: bytes32
     name: str
     current_time: float
     count: int
-    value: Optional[Union[int, Dict[str, Any]]]
+    value: Optional[Union[int, dict[str, Any]]]
     expected_result: Any
 
     def __init__(
@@ -64,7 +64,7 @@ class IncrementPoolStatsCase:
         name: str,
         current_time: float,
         count: int,
-        value: Optional[Union[int, Dict[str, Any]]],
+        value: Optional[Union[int, dict[str, Any]]],
         expected_result: Any,
     ):
         prepared_p2_singleton_puzzle_hash = std_hash(b"11223344")
@@ -142,10 +142,10 @@ class NewProofOfSpaceCase:
     pool_config: PoolWalletConfig
     pool_difficulty: Optional[uint64]
     authentication_token_timeout: Optional[uint8]
-    farmer_private_keys: List[PrivateKey]
-    authentication_keys: Dict[bytes32, PrivateKey]
+    farmer_private_keys: list[PrivateKey]
+    authentication_keys: dict[bytes32, PrivateKey]
     use_invalid_peer_response: bool
-    expected_pool_state: Dict[str, Any]
+    expected_pool_state: dict[str, Any]
     marks: Marks = ()
 
     # This creates a test case whose proof of space passes plot filter and quality check
@@ -159,7 +159,7 @@ class NewProofOfSpaceCase:
         authentication_token_timeout: Optional[uint8],
         use_invalid_peer_response: bool,
         has_valid_authentication_keys: bool,
-        expected_pool_stats: Dict[str, Any],
+        expected_pool_stats: dict[str, Any],
     ) -> NewProofOfSpaceCase:
         p2_singleton_puzzle_hash = bytes32.fromhex("302e05a1e6af431c22043ae2a9a8f71148c955c372697cb8ab348160976283df")
         pool_config = PoolWalletConfig(
@@ -348,7 +348,7 @@ def test_increment_pool_stats(case: IncrementPoolStatsCase) -> None:
                 expected_pool_stats={
                     "points_found_since_start": 0,
                     # Original item format here is (timestamp, value) but we'll ignore timestamp part
-                    # so every `xxx_24h` item in this dict will be List[Any].
+                    # so every `xxx_24h` item in this dict will be list[Any].
                     "points_found_24h": [],
                     "points_acknowledged_since_start": 0,
                     "points_acknowledged_24h": [],
@@ -380,7 +380,7 @@ def test_increment_pool_stats(case: IncrementPoolStatsCase) -> None:
                 expected_pool_stats={
                     "points_found_since_start": 0,
                     # Original item format here is (timestamp, value) but we'll ignore timestamp part
-                    # so every `xxx_24h` item in this dict will be List[Any].
+                    # so every `xxx_24h` item in this dict will be list[Any].
                     "points_found_24h": [],
                     "points_acknowledged_since_start": 0,
                     "points_acknowledged_24h": [],
@@ -411,7 +411,7 @@ def test_increment_pool_stats(case: IncrementPoolStatsCase) -> None:
                 expected_pool_stats={
                     "points_found_since_start": 0,
                     # Original item format here is (timestamp, value) but we'll ignore timestamp part
-                    # so every `xxx_24h` item in this dict will be List[Any].
+                    # so every `xxx_24h` item in this dict will be list[Any].
                     "points_found_24h": [],
                     "points_acknowledged_since_start": 0,
                     "points_acknowledged_24h": [],
@@ -442,7 +442,7 @@ def test_increment_pool_stats(case: IncrementPoolStatsCase) -> None:
                 expected_pool_stats={
                     "points_found_since_start": 0,
                     # Original item format here is (timestamp, value) but we'll ignore timestamp part
-                    # so every `xxx_24h` item in this dict will be List[Any].
+                    # so every `xxx_24h` item in this dict will be list[Any].
                     "points_found_24h": [],
                     "points_acknowledged_since_start": 0,
                     "points_acknowledged_24h": [],
@@ -473,7 +473,7 @@ def test_increment_pool_stats(case: IncrementPoolStatsCase) -> None:
                 expected_pool_stats={
                     "points_found_since_start": 0,
                     # Original item format here is (timestamp, value) but we'll ignore timestamp part
-                    # so every `xxx_24h` item in this dict will be List[Any].
+                    # so every `xxx_24h` item in this dict will be list[Any].
                     "points_found_24h": [],
                     "points_acknowledged_since_start": 0,
                     "points_acknowledged_24h": [],
@@ -504,7 +504,7 @@ def test_increment_pool_stats(case: IncrementPoolStatsCase) -> None:
                 expected_pool_stats={
                     "points_found_since_start": 0,
                     # Original item format here is (timestamp, value) but we'll ignore timestamp part
-                    # so every `xxx_24h` item in this dict will be List[Any].
+                    # so every `xxx_24h` item in this dict will be list[Any].
                     "points_found_24h": [],
                     "points_acknowledged_since_start": 0,
                     "points_acknowledged_24h": [],
@@ -535,7 +535,7 @@ def test_increment_pool_stats(case: IncrementPoolStatsCase) -> None:
                 expected_pool_stats={
                     "points_found_since_start": 1,
                     # Original item format here is (timestamp, value) but we'll ignore timestamp part
-                    # so every `xxx_24h` item in this dict will be List[Any].
+                    # so every `xxx_24h` item in this dict will be list[Any].
                     "points_found_24h": [1],
                     "points_acknowledged_since_start": 0,
                     "points_acknowledged_24h": [],
@@ -561,7 +561,7 @@ async def test_farmer_new_proof_of_space_for_pool_stats(
     harvester_farmer_environment: HarvesterFarmerEnvironment,
     case: NewProofOfSpaceCase,
 ) -> None:
-    farmer_service, farmer_rpc_client, _, _, _ = harvester_farmer_environment
+    farmer_service, _farmer_rpc_client, _, _, _ = harvester_farmer_environment
     farmer_api = farmer_service._api
 
     sp = farmer_protocol.NewSignagePoint(
@@ -672,7 +672,7 @@ class DummyPoolResponse:
     new_difficulty: Optional[int] = None
 
     async def text(self) -> str:
-        json_dict: Dict[str, Any] = dict()
+        json_dict: dict[str, Any] = dict()
         if self.error_code:
             json_dict["error_code"] = self.error_code
             json_dict["error_message"] = self.error_message if self.error_message else "error-msg"
@@ -686,14 +686,14 @@ class DummyPoolResponse:
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
+        exc_type: Optional[type[BaseException]],
         exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType],
     ) -> None:
         pass
 
 
-def create_valid_pos(farmer: Farmer) -> Tuple[farmer_protocol.NewSignagePoint, ProofOfSpace, NewProofOfSpace]:
+def create_valid_pos(farmer: Farmer) -> tuple[farmer_protocol.NewSignagePoint, ProofOfSpace, NewProofOfSpace]:
     case = NewProofOfSpaceCase.create_verified_quality_case(
         difficulty=uint64(1),
         sub_slot_iters=uint64(1000000000000),
@@ -764,11 +764,11 @@ def create_valid_pos(farmer: Farmer) -> Tuple[farmer_protocol.NewSignagePoint, P
     return sp, pos, new_pos
 
 
-def override_pool_state(overrides: Dict[str, Any]) -> Dict[str, Any]:
+def override_pool_state(overrides: dict[str, Any]) -> dict[str, Any]:
     pool_state = {
         "points_found_since_start": 0,
         # Original item format here is (timestamp, value) but we'll ignore timestamp part
-        # so every `xxx_24h` item in this dict will be List[Any].
+        # so every `xxx_24h` item in this dict will be list[Any].
         "points_found_24h": [],
         "points_acknowledged_since_start": 0,
         "points_acknowledged_24h": [],
@@ -793,7 +793,7 @@ def override_pool_state(overrides: Dict[str, Any]) -> Dict[str, Any]:
 class PoolStateCase:
     id: str
     pool_response: DummyPoolResponse
-    expected_pool_state: Dict[str, Any]
+    expected_pool_state: dict[str, Any]
     marks: Marks = ()
 
 
@@ -867,7 +867,7 @@ class PoolStateCase:
 @pytest.mark.anyio
 async def test_farmer_pool_response(
     mocker: MockerFixture,
-    farmer_one_harvester: Tuple[List[HarvesterService], FarmerService, BlockTools],
+    farmer_one_harvester: tuple[list[HarvesterService], FarmerService, BlockTools],
     case: PoolStateCase,
 ) -> None:
     _, farmer_service, _ = farmer_one_harvester
@@ -927,7 +927,7 @@ async def test_farmer_pool_response(
     assert_stats_24h("missing_partials_24h")
 
 
-def make_pool_list_entry(overrides: Dict[str, Any]) -> Dict[str, Any]:
+def make_pool_list_entry(overrides: dict[str, Any]) -> dict[str, Any]:
     pool_list_entry = {
         "owner_public_key": "84c3fcf9d5581c1ddc702cb0f3b4a06043303b334dd993ab42b2c320ebfa98e5ce558448615b3f69638ba92cf7f43da5",  # noqa: E501
         "p2_singleton_puzzle_hash": "302e05a1e6af431c22043ae2a9a8f71148c955c372697cb8ab348160976283df",
@@ -941,7 +941,7 @@ def make_pool_list_entry(overrides: Dict[str, Any]) -> Dict[str, Any]:
     return pool_list_entry
 
 
-def make_pool_info() -> Dict[str, Any]:
+def make_pool_info() -> dict[str, Any]:
     return {
         "name": "Pool Name",
         "description": "Pool Description",
@@ -955,7 +955,7 @@ def make_pool_info() -> Dict[str, Any]:
     }
 
 
-def make_pool_state(p2_singleton_puzzle_hash: bytes32, overrides: Dict[str, Any]) -> Dict[str, Any]:
+def make_pool_state(p2_singleton_puzzle_hash: bytes32, overrides: dict[str, Any]) -> dict[str, Any]:
     pool_info = {
         "p2_singleton_puzzle_hash": p2_singleton_puzzle_hash.hex(),
         "points_found_since_start": 0,
@@ -995,8 +995,8 @@ class DummyPoolInfoResponse:
     ok: bool
     status: int
     url: URL
-    pool_info: Optional[Dict[str, Any]] = None
-    history: Tuple[DummyClientResponse, ...] = ()
+    pool_info: Optional[dict[str, Any]] = None
+    history: tuple[DummyClientResponse, ...] = ()
 
     async def text(self) -> str:
         if self.pool_info is None:
@@ -1009,7 +1009,7 @@ class DummyPoolInfoResponse:
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
+        exc_type: Optional[type[BaseException]],
         exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType],
     ) -> None:
@@ -1171,7 +1171,7 @@ class PoolInfoCase(DataCase):
 @pytest.mark.anyio
 async def test_farmer_pool_info_config_update(
     mocker: MockerFixture,
-    farmer_one_harvester: Tuple[List[HarvesterService], FarmerService, BlockTools],
+    farmer_one_harvester: tuple[list[HarvesterService], FarmerService, BlockTools],
     case: PoolInfoCase,
 ) -> None:
     _, farmer_service, _ = farmer_one_harvester
@@ -1212,7 +1212,7 @@ async def test_farmer_pool_info_config_update(
 class PartialSubmitHeaderCase(DataCase):
     _id: str
     harvester_peer: DummyHarvesterPeer
-    expected_headers: Dict[str, str]
+    expected_headers: dict[str, str]
     marks: Marks = ()
 
     @property
@@ -1236,7 +1236,7 @@ class PartialSubmitHeaderCase(DataCase):
 @pytest.mark.anyio
 async def test_farmer_additional_headers_on_partial_submit(
     mocker: MockerFixture,
-    farmer_one_harvester: Tuple[List[HarvesterService], FarmerService, BlockTools],
+    farmer_one_harvester: tuple[list[HarvesterService], FarmerService, BlockTools],
     case: PartialSubmitHeaderCase,
 ) -> None:
     _, farmer_service, _ = farmer_one_harvester