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

chia/simulator/full_node_simulator.py

@@ -3,18 +3,21 @@ from __future__ import annotations
 import asyncio
 import itertools
 import time
-from typing import Any, Collection, Dict, List, Optional, Set, Tuple, Union
+from collections.abc import Collection
+from typing import Any, Optional, Union
 
 import anyio
 
+from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.block_record import BlockRecord
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.consensus.blockchain import BlockchainMutexPriority
-from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_blocks_multiprocessing
+from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_block
 from chia.full_node.full_node import FullNode
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.rpc.rpc_server import default_get_connections
 from chia.server.outbound_message import NodeType
+from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
 from chia.simulator.block_tools import BlockTools
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol, GetAllCoinsProtocol, ReorgProtocol
 from chia.types.blockchain_format.coin import Coin
@@ -22,11 +25,13 @@ from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_record import CoinRecord
 from chia.types.full_block import FullBlock
 from chia.types.spend_bundle import SpendBundle
+from chia.types.validation_state import ValidationState
+from chia.util.augmented_chain import AugmentedBlockchain
 from chia.util.config import lock_and_load_config, save_config
 from chia.util.ints import uint8, uint32, uint64, uint128
 from chia.util.timing import adjusted_timeout, backoff_times
 from chia.wallet.payment import Payment
-from chia.wallet.transaction_record import TransactionRecord
+from chia.wallet.transaction_record import LightTransactionRecord, TransactionRecord
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_node import WalletNode
@@ -42,7 +47,7 @@ default = _Default()
 timeout_per_block = 5
 
 
-async def wait_for_coins_in_wallet(coins: Set[Coin], wallet: Wallet, timeout: Optional[float] = 5):
+async def wait_for_coins_in_wallet(coins: set[Coin], wallet: Wallet, timeout: Optional[float] = 5):
     """Wait until all of the specified coins are simultaneously reported as spendable
     by the wallet.
 
@@ -64,7 +69,7 @@ async def wait_for_coins_in_wallet(coins: Set[Coin], wallet: Wallet, timeout: Op
 
 
 class FullNodeSimulator(FullNodeAPI):
-    def __init__(self, full_node: FullNode, block_tools: BlockTools, config: Dict) -> None:
+    def __init__(self, full_node: FullNode, block_tools: BlockTools, config: dict) -> None:
         super().__init__(full_node)
         self.bt = block_tools
         self.full_node = full_node
@@ -74,10 +79,10 @@ class FullNodeSimulator(FullNodeAPI):
         self.use_current_time: bool = self.config.get("simulator", {}).get("use_current_time", False)
         self.auto_farm: bool = self.config.get("simulator", {}).get("auto_farm", False)
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> List[Dict[str, Any]]:
+    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
         return default_get_connections(server=self.server, request_node_type=request_node_type)
 
-    async def get_all_full_blocks(self) -> List[FullBlock]:
+    async def get_all_full_blocks(self) -> list[FullBlock]:
         peak: Optional[BlockRecord] = self.full_node.blockchain.get_peak()
         if peak is None:
             return []
@@ -119,7 +124,7 @@ class FullNodeSimulator(FullNodeAPI):
                 await self.farm_new_transaction_block(FarmNewBlockProtocol(self.bt.farmer_ph))
             return self.auto_farm
 
-    async def get_all_coins(self, request: GetAllCoinsProtocol) -> List[CoinRecord]:
+    async def get_all_coins(self, request: GetAllCoinsProtocol) -> list[CoinRecord]:
         return await self.full_node.coin_store.get_all_coins(request.include_spent_coins)
 
     async def revert_block_height(self, new_height: uint32) -> None:
@@ -148,15 +153,15 @@ class FullNodeSimulator(FullNodeAPI):
         # reload mempool
         await self.full_node.mempool_manager.new_peak(block_record, None)
 
-    async def get_all_puzzle_hashes(self) -> Dict[bytes32, Tuple[uint128, int]]:
+    async def get_all_puzzle_hashes(self) -> dict[bytes32, tuple[uint128, int]]:
         # puzzle_hash, (total_amount, num_transactions)
-        ph_total_amount: Dict[bytes32, Tuple[uint128, int]] = {}
-        all_non_spent_coins: List[CoinRecord] = await self.get_all_coins(GetAllCoinsProtocol(False))
+        ph_total_amount: dict[bytes32, tuple[uint128, int]] = {}
+        all_non_spent_coins: list[CoinRecord] = await self.get_all_coins(GetAllCoinsProtocol(False))
         for cr in all_non_spent_coins:
             if cr.coin.puzzle_hash not in ph_total_amount:
                 ph_total_amount[cr.coin.puzzle_hash] = (uint128(cr.coin.amount), 1)
             else:
-                dict_value: Tuple[uint128, int] = ph_total_amount[cr.coin.puzzle_hash]
+                dict_value: tuple[uint128, int] = ph_total_amount[cr.coin.puzzle_hash]
                 ph_total_amount[cr.coin.puzzle_hash] = (uint128(cr.coin.amount + dict_value[0]), dict_value[1] + 1)
         return ph_total_amount
 
@@ -170,23 +175,21 @@ class FullNodeSimulator(FullNodeAPI):
             current_blocks = await self.get_all_full_blocks()
             if len(current_blocks) == 0:
                 genesis = self.bt.get_consecutive_blocks(uint8(1))[0]
-                pre_validation_results: List[PreValidationResult] = await pre_validate_blocks_multiprocessing(
+                future = await pre_validate_block(
                     self.full_node.blockchain.constants,
-                    self.full_node.blockchain,
-                    [genesis],
+                    AugmentedBlockchain(self.full_node.blockchain),
+                    genesis,
                     self.full_node.blockchain.pool,
-                    {},
-                    sub_slot_iters=ssi,
-                    difficulty=diff,
-                    prev_ses_block=None,
-                    validate_signatures=True,
+                    None,
+                    ValidationState(ssi, diff, None),
                 )
-                assert pre_validation_results is not None
+                pre_validation_result: PreValidationResult = await future
+                fork_info = ForkInfo(-1, -1, self.full_node.constants.GENESIS_CHALLENGE)
                 await self.full_node.blockchain.add_block(
                     genesis,
-                    pre_validation_results[0],
-                    self.full_node._bls_cache,
+                    pre_validation_result,
                     self.full_node.constants.SUB_SLOT_ITERS_STARTING,
+                    fork_info,
                 )
 
             peak = self.full_node.blockchain.get_peak()
@@ -227,30 +230,23 @@ class FullNodeSimulator(FullNodeAPI):
 
     async def farm_new_block(self, request: FarmNewBlockProtocol, force_wait_for_timestamp: bool = False):
         ssi = self.full_node.constants.SUB_SLOT_ITERS_STARTING
-        diffculty = self.full_node.constants.DIFFICULTY_STARTING
+        diff = self.full_node.constants.DIFFICULTY_STARTING
         async with self.full_node.blockchain.priority_mutex.acquire(priority=BlockchainMutexPriority.high):
             self.log.info("Farming new block!")
             current_blocks = await self.get_all_full_blocks()
             if len(current_blocks) == 0:
                 genesis = self.bt.get_consecutive_blocks(uint8(1))[0]
-                pre_validation_results: List[PreValidationResult] = await pre_validate_blocks_multiprocessing(
+                future = await pre_validate_block(
                     self.full_node.blockchain.constants,
-                    self.full_node.blockchain,
-                    [genesis],
-                    self.full_node.blockchain.pool,
-                    {},
-                    sub_slot_iters=ssi,
-                    difficulty=diffculty,
-                    prev_ses_block=None,
-                    validate_signatures=True,
-                )
-                assert pre_validation_results is not None
-                await self.full_node.blockchain.add_block(
+                    AugmentedBlockchain(self.full_node.blockchain),
                     genesis,
-                    pre_validation_results[0],
-                    self.full_node._bls_cache,
-                    ssi,
+                    self.full_node.blockchain.pool,
+                    None,
+                    ValidationState(ssi, diff, None),
                 )
+                pre_validation_result: PreValidationResult = await future
+                fork_info = ForkInfo(-1, -1, self.full_node.constants.GENESIS_CHALLENGE)
+                await self.full_node.blockchain.add_block(genesis, pre_validation_result, ssi, fork_info)
             peak = self.full_node.blockchain.get_peak()
             assert peak is not None
             curr: BlockRecord = peak
@@ -304,16 +300,14 @@ class FullNodeSimulator(FullNodeAPI):
             guarantee_transaction_block=True,
             seed=seed,
         )
-
-        for block in more_blocks:
-            await self.full_node.add_block(block)
+        await add_blocks_in_batches(more_blocks[old_index + 1 :], self.full_node)
 
     async def farm_blocks_to_puzzlehash(
         self,
         count: int,
-        farm_to: bytes32 = bytes32([0] * 32),
+        farm_to: bytes32 = bytes32.zeros,
         guarantee_transaction_blocks: bool = False,
-        timeout: Union[None, _Default, float] = default,
+        timeout: Union[_Default, float, None] = default,
         _wait_for_synced: bool = True,
     ) -> int:
         """Process the requested number of blocks including farming to the passed puzzle
@@ -357,7 +351,7 @@ class FullNodeSimulator(FullNodeAPI):
         self,
         count: int,
         wallet: Wallet,
-        timeout: Union[None, _Default, float] = default,
+        timeout: Union[_Default, float, None] = default,
         _wait_for_synced: bool = True,
     ) -> int:
         """Farm the requested number of blocks to the passed wallet. This will
@@ -429,7 +423,7 @@ class FullNodeSimulator(FullNodeAPI):
         self,
         amount: int,
         wallet: Wallet,
-        timeout: Union[None, _Default, float] = default,
+        timeout: Union[_Default, float, None] = default,
     ) -> int:
         """Farm at least the requested amount of mojos to the passed wallet. Extra
         mojos will be received based on the block rewards at the present block height.
@@ -469,8 +463,8 @@ class FullNodeSimulator(FullNodeAPI):
 
     async def wait_transaction_records_entered_mempool(
         self,
-        records: Collection[TransactionRecord],
-        timeout: Union[None, float] = 5,
+        records: Collection[Union[TransactionRecord, LightTransactionRecord]],
+        timeout: Union[float, None] = 5,
     ) -> None:
         """Wait until the transaction records have entered the mempool.  Transaction
         records with no spend bundle are ignored.
@@ -479,7 +473,7 @@ class FullNodeSimulator(FullNodeAPI):
             records: The transaction records to wait for.
         """
         with anyio.fail_after(delay=adjusted_timeout(timeout)):
-            ids_to_check: Set[bytes32] = set()
+            ids_to_check: set[bytes32] = set()
             for record in records:
                 if record.spend_bundle is None:
                     continue
@@ -502,7 +496,7 @@ class FullNodeSimulator(FullNodeAPI):
     async def wait_bundle_ids_in_mempool(
         self,
         bundle_ids: Collection[bytes32],
-        timeout: Union[None, float] = 5,
+        timeout: Union[float, None] = 5,
     ) -> None:
         """Wait until the ids of specific spend bundles have entered the mempool.
 
@@ -510,7 +504,7 @@ class FullNodeSimulator(FullNodeAPI):
             records: The bundle ids to wait for.
         """
         with anyio.fail_after(delay=adjusted_timeout(timeout)):
-            ids_to_check: Set[bytes32] = set(bundle_ids)
+            ids_to_check: set[bytes32] = set(bundle_ids)
 
             for backoff in backoff_times():
                 found = set()
@@ -529,7 +523,7 @@ class FullNodeSimulator(FullNodeAPI):
         self,
         record_ids: Collection[bytes32],
         wallet_node: WalletNode,
-        timeout: Union[None, float] = 10,
+        timeout: Union[float, None] = 10,
     ) -> None:
         """Wait until the transaction records have been marked that they have made it into the mempool.  Transaction
         records with no spend bundle are ignored.
@@ -538,7 +532,7 @@ class FullNodeSimulator(FullNodeAPI):
             records: The transaction records to wait for.
         """
         with anyio.fail_after(delay=adjusted_timeout(timeout)):
-            ids_to_check: Set[bytes32] = set(record_ids)
+            ids_to_check: set[bytes32] = set(record_ids)
 
             for backoff in backoff_times():
                 found = set()
@@ -556,7 +550,7 @@ class FullNodeSimulator(FullNodeAPI):
     async def process_transaction_records(
         self,
         records: Collection[TransactionRecord],
-        timeout: Union[None, float] = (2 * timeout_per_block) + 5,
+        timeout: Union[float, None] = (2 * timeout_per_block) + 5,
     ) -> None:
         """Process the specified transaction records and wait until they have been
         included in a block.
@@ -567,7 +561,7 @@ class FullNodeSimulator(FullNodeAPI):
         with anyio.fail_after(delay=adjusted_timeout(timeout)):
             await self.wait_for_self_synced(timeout=None)
 
-            coins_to_wait_for: Set[Coin] = set()
+            coins_to_wait_for: set[Coin] = set()
             for record in records:
                 if record.spend_bundle is None:
                     continue
@@ -581,7 +575,7 @@ class FullNodeSimulator(FullNodeAPI):
     async def process_spend_bundles(
         self,
         bundles: Collection[SpendBundle],
-        timeout: Union[None, float] = (2 * timeout_per_block) + 5,
+        timeout: Union[float, None] = (2 * timeout_per_block) + 5,
     ) -> None:
         """Process the specified spend bundles and wait until they have been included
         in a block.
@@ -591,13 +585,13 @@ class FullNodeSimulator(FullNodeAPI):
         """
 
         with anyio.fail_after(delay=adjusted_timeout(timeout)):
-            coins_to_wait_for: Set[Coin] = {addition for bundle in bundles for addition in bundle.additions()}
+            coins_to_wait_for: set[Coin] = {addition for bundle in bundles for addition in bundle.additions()}
             return await self.process_coin_spends(coins=coins_to_wait_for, timeout=None)
 
     async def process_coin_spends(
         self,
         coins: Collection[Coin],
-        timeout: Union[None, float] = (2 * timeout_per_block) + 5,
+        timeout: Union[float, None] = (2 * timeout_per_block) + 5,
     ) -> None:
         """Process the specified coin names and wait until they have been created in a
         block.
@@ -613,7 +607,7 @@ class FullNodeSimulator(FullNodeAPI):
             while True:
                 await self.farm_blocks_to_puzzlehash(count=1, guarantee_transaction_blocks=True, timeout=None)
 
-                found: Set[Coin] = set()
+                found: set[Coin] = set()
                 for coin in coin_set:
                     # TODO: is this the proper check?
                     if await coin_store.get_coin_record(coin.name()) is not None:
@@ -649,15 +643,13 @@ class FullNodeSimulator(FullNodeAPI):
     async def check_transactions_confirmed(
         self,
         wallet_state_manager: WalletStateManager,
-        transactions: List[TransactionRecord],
+        transactions: Union[list[TransactionRecord], list[LightTransactionRecord]],
         timeout: Optional[float] = 5,
     ) -> None:
-        transactions_left: Set[bytes32] = {tx.name for tx in transactions}
+        transactions_left: set[bytes32] = {tx.name for tx in transactions}
         with anyio.fail_after(delay=adjusted_timeout(timeout)):
             for backoff in backoff_times():
-                transactions_left = transactions_left & {
-                    tx.name for tx in await wallet_state_manager.tx_store.get_all_unconfirmed()
-                }
+                transactions_left &= {tx.name for tx in await wallet_state_manager.tx_store.get_all_unconfirmed()}
                 if len(transactions_left) == 0:
                     break
 
@@ -666,11 +658,11 @@ class FullNodeSimulator(FullNodeAPI):
 
     async def create_coins_with_amounts(
         self,
-        amounts: List[uint64],
+        amounts: list[uint64],
         wallet: Wallet,
         per_transaction_record_group: int = 50,
-        timeout: Union[None, float] = 15,
-    ) -> Set[Coin]:
+        timeout: Union[float, None] = 15,
+    ) -> set[Coin]:
         """Create coins with the requested amount.  This is useful when you need a
         bunch of coins for a test and don't need to farm that many.
 
@@ -694,8 +686,8 @@ class FullNodeSimulator(FullNodeAPI):
             if len(amounts) == 0:
                 return set()
 
-            outputs: List[Payment] = []
-            amounts_seen: Set[uint64] = set()
+            outputs: list[Payment] = []
+            amounts_seen: set[uint64] = set()
             for amount in amounts:
                 # We need unique puzzle hash amount combos so we'll only generate a new puzzle hash when we've already
                 # seen that amount sent to that puzzle hash
@@ -703,7 +695,7 @@ class FullNodeSimulator(FullNodeAPI):
                 outputs.append(Payment(puzzle_hash, amount))
                 amounts_seen.add(amount)
 
-            transaction_records: List[TransactionRecord] = []
+            transaction_records: list[TransactionRecord] = []
             outputs_iterator = iter(outputs)
             while True:
                 # The outputs iterator must be second in the zip() call otherwise we lose
@@ -739,14 +731,14 @@ class FullNodeSimulator(FullNodeAPI):
         spendbundle = self.full_node.mempool_manager.get_spendbundle(bundle_hash=tx_id)
         return spendbundle is not None
 
-    def txs_in_mempool(self, txs: List[TransactionRecord]) -> bool:
+    def txs_in_mempool(self, txs: list[TransactionRecord]) -> bool:
         return all(self.tx_id_in_mempool(tx_id=tx.spend_bundle.name()) for tx in txs if tx.spend_bundle is not None)
 
     async def self_is_synced(self) -> bool:
         return await self.full_node.synced()
 
     async def wallet_is_synced(self, wallet_node: WalletNode, peak_height: Optional[uint32] = None) -> bool:
-        if not self.self_is_synced():
+        if not await self.self_is_synced():
             # Depending on races, may not be covered every time
             return False  # pragma: no cover
         if not await wallet_node.wallet_state_manager.synced():
@@ -770,7 +762,7 @@ class FullNodeSimulator(FullNodeAPI):
                     break
                 await asyncio.sleep(backoff_time)
 
-    async def wallets_are_synced(self, wallet_nodes: List[WalletNode], peak_height: Optional[uint32] = None) -> bool:
+    async def wallets_are_synced(self, wallet_nodes: list[WalletNode], peak_height: Optional[uint32] = None) -> bool:
         return all(
             [
                 await self.wallet_is_synced(wallet_node=wallet_node, peak_height=peak_height)
@@ -780,7 +772,7 @@ class FullNodeSimulator(FullNodeAPI):
 
     async def wait_for_wallets_synced(
         self,
-        wallet_nodes: List[WalletNode],
+        wallet_nodes: list[WalletNode],
         timeout: Optional[float] = 5,
         peak_height: Optional[uint32] = None,
     ) -> None:

chia/simulator/setup_services.py

@@ -5,11 +5,11 @@ import gc
 import logging
 import signal
 import sqlite3
-import time
+from collections.abc import AsyncGenerator, AsyncIterator, Iterator
 from contextlib import asynccontextmanager, contextmanager
 from pathlib import Path
 from types import FrameType
-from typing import Any, AsyncGenerator, AsyncIterator, Dict, Iterator, List, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 from chia.cmds.init_funcs import init
 from chia.consensus.constants import ConsensusConstants, replace_str_to_bytes
@@ -48,12 +48,13 @@ from chia.util.db_wrapper import generate_in_memory_db_uri
 from chia.util.ints import uint16
 from chia.util.keychain import bytes_to_mnemonic
 from chia.util.lock import Lockfile
+from chia.util.task_referencer import create_referenced_task
 
 log = logging.getLogger(__name__)
 
 
 @contextmanager
-def create_lock_and_load_config(certs_path: Path, root_path: Path) -> Iterator[Dict[str, Any]]:
+def create_lock_and_load_config(certs_path: Path, root_path: Path) -> Iterator[dict[str, Any]]:
     init(None, root_path)
     init(certs_path, root_path)
     path = config_path_for_filename(root_path=root_path, filename="config.yaml")
@@ -63,7 +64,7 @@ def create_lock_and_load_config(certs_path: Path, root_path: Path) -> Iterator[D
         yield config
 
 
-def get_capability_overrides(node_type: NodeType, disabled_capabilities: List[Capability]) -> List[Tuple[uint16, str]]:
+def get_capability_overrides(node_type: NodeType, disabled_capabilities: list[Capability]) -> list[tuple[uint16, str]]:
     return [
         (
             capability
@@ -102,7 +103,7 @@ async def setup_full_node(
     sanitize_weight_proof_only: bool = False,
     connect_to_daemon: bool = False,
     db_version: int = 1,
-    disable_capabilities: Optional[List[Capability]] = None,
+    disable_capabilities: Optional[list[Capability]] = None,
     *,
     reuse_db: bool = False,
 ) -> AsyncGenerator[Union[FullNodeService, SimulatorFullNodeService], None]:
@@ -309,7 +310,7 @@ async def setup_wallet_node(
                         break
                     except PermissionError as e:
                         print(f"db_path.unlink(): {e}")
-                        time.sleep(0.1)
+                        await asyncio.sleep(0.1)
                         # filesystem operations are async on windows
                         # [WinError 32] The process cannot access the file because it is
                         # being used by another process
@@ -413,7 +414,7 @@ async def setup_introducer(bt: BlockTools, port: int) -> AsyncGenerator[Introduc
 async def setup_vdf_client(bt: BlockTools, self_hostname: str, port: int) -> AsyncIterator[None]:
     find_vdf_client()  # raises FileNotFoundError if not found
     process_mgr = VDFClientProcessMgr()
-    vdf_task_1 = asyncio.create_task(
+    vdf_task_1 = create_referenced_task(
         spawn_process(self_hostname, port, 1, process_mgr, prefer_ipv6=bt.config.get("prefer_ipv6", False)),
         name="vdf_client_1",
     )
@@ -447,7 +448,7 @@ async def setup_vdf_clients(bt: BlockTools, self_hostname: str, port: int) -> As
     prefer_ipv6 = bt.config.get("prefer_ipv6", False)
     for i in range(1, 4):
         tasks.append(
-            asyncio.create_task(
+            create_referenced_task(
                 spawn_process(
                     host=self_hostname, port=port, counter=i, process_mgr=process_mgr, prefer_ipv6=prefer_ipv6
                 ),
@@ -482,7 +483,7 @@ async def setup_timelord(
     full_node_port: int,
     sanitizer: bool,
     consensus_constants: ConsensusConstants,
-    config: Dict[str, Any],
+    config: dict[str, Any],
     root_path: Path,
     vdf_port: uint16 = uint16(0),
 ) -> AsyncGenerator[TimelordService, None]:

chia/simulator/simulator_full_node_rpc_api.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Dict, List
-
 from chia.rpc.full_node_rpc_api import FullNodeRpcApi
 from chia.rpc.rpc_server import Endpoint, EndpointResult
 from chia.simulator.full_node_simulator import FullNodeSimulator
@@ -19,7 +17,7 @@ class SimulatorFullNodeRpcApi(FullNodeRpcApi):
         assert isinstance(self.service.server.api, FullNodeSimulator)
         return self.service.server.api
 
-    def get_routes(self) -> Dict[str, Endpoint]:
+    def get_routes(self) -> dict[str, Endpoint]:
         routes = super().get_routes()
         routes["/get_all_blocks"] = self.get_all_blocks
         routes["/farm_block"] = self.farm_block
@@ -32,11 +30,11 @@ class SimulatorFullNodeRpcApi(FullNodeRpcApi):
         routes["/reorg_blocks"] = self.reorg_blocks
         return routes
 
-    async def get_all_blocks(self, _request: Dict[str, object]) -> EndpointResult:
-        all_blocks: List[FullBlock] = await self.simulator_api.get_all_full_blocks()
+    async def get_all_blocks(self, _request: dict[str, object]) -> EndpointResult:
+        all_blocks: list[FullBlock] = await self.simulator_api.get_all_full_blocks()
         return {"blocks": [block.to_json_dict() for block in all_blocks]}
 
-    async def farm_block(self, _request: Dict[str, object]) -> EndpointResult:
+    async def farm_block(self, _request: dict[str, object]) -> EndpointResult:
         request_address = str(_request["address"])
         guarantee_tx_block = bool(_request.get("guarantee_tx_block", False))
         blocks = int(str(_request.get("blocks", 1)))  # mypy made me do this
@@ -51,29 +49,29 @@ class SimulatorFullNodeRpcApi(FullNodeRpcApi):
                 await self.simulator_api.farm_new_block(req)
         return {"new_peak_height": (cur_height if cur_height is not None else 0) + blocks}
 
-    async def set_auto_farming(self, _request: Dict[str, object]) -> EndpointResult:
+    async def set_auto_farming(self, _request: dict[str, object]) -> EndpointResult:
         auto_farm = bool(_request["auto_farm"])
         result = await self.simulator_api.update_autofarm_config(auto_farm)
         return {"auto_farm_enabled": result}
 
-    async def get_auto_farming(self, _request: Dict[str, object]) -> EndpointResult:
+    async def get_auto_farming(self, _request: dict[str, object]) -> EndpointResult:
         return {"auto_farm_enabled": self.simulator_api.auto_farm}
 
-    async def get_farming_ph(self, _request: Dict[str, object]) -> EndpointResult:
+    async def get_farming_ph(self, _request: dict[str, object]) -> EndpointResult:
         return {"puzzle_hash": self.simulator_api.bt.farmer_ph.hex()}
 
-    async def get_all_coins(self, _request: Dict[str, object]) -> EndpointResult:
+    async def get_all_coins(self, _request: dict[str, object]) -> EndpointResult:
         p_request = GetAllCoinsProtocol(bool(_request.get("include_spent_coins", False)))
-        result: List[CoinRecord] = await self.simulator_api.get_all_coins(p_request)
+        result: list[CoinRecord] = await self.simulator_api.get_all_coins(p_request)
         return {"coin_records": [coin_record.to_json_dict() for coin_record in result]}
 
-    async def get_all_puzzle_hashes(self, _request: Dict[str, object]) -> EndpointResult:
+    async def get_all_puzzle_hashes(self, _request: dict[str, object]) -> EndpointResult:
         result = await self.simulator_api.get_all_puzzle_hashes()
         return {
             "puzzle_hashes": {puzzle_hash.hex(): (amount, num_tx) for (puzzle_hash, (amount, num_tx)) in result.items()}
         }
 
-    async def revert_blocks(self, _request: Dict[str, object]) -> EndpointResult:
+    async def revert_blocks(self, _request: dict[str, object]) -> EndpointResult:
         blocks = int(str(_request.get("num_of_blocks", 1)))  # number of blocks to revert
         all_blocks = bool(_request.get("delete_all_blocks", False))  # revert all blocks
         height = self.service.blockchain.get_peak_height()
@@ -84,7 +82,7 @@ class SimulatorFullNodeRpcApi(FullNodeRpcApi):
         await self.simulator_api.revert_block_height(uint32(new_height))
         return {"new_peak_height": new_height}
 
-    async def reorg_blocks(self, _request: Dict[str, object]) -> EndpointResult:
+    async def reorg_blocks(self, _request: dict[str, object]) -> EndpointResult:
         fork_blocks = int(str(_request.get("num_of_blocks_to_rev", 1)))  # number of blocks to go back
         new_blocks = int(str(_request.get("num_of_new_blocks", 1)))  # how many extra blocks should we add
         all_blocks = bool(_request.get("revert_all_blocks", False))  # fork all blocks

chia/simulator/simulator_full_node_rpc_client.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Dict, List, Tuple
-
 from chia.rpc.full_node_rpc_client import FullNodeRpcClient
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_record import CoinRecord
@@ -11,7 +9,7 @@ from chia.util.ints import uint128
 
 
 class SimulatorFullNodeRpcClient(FullNodeRpcClient):
-    async def get_all_blocks(self) -> List[FullBlock]:
+    async def get_all_blocks(self) -> list[FullBlock]:
         json_blocks = (await self.fetch("get_all_blocks", {}))["blocks"]
         return [FullBlock.from_json_dict(block) for block in json_blocks]
 
@@ -34,11 +32,11 @@ class SimulatorFullNodeRpcClient(FullNodeRpcClient):
         result = await self.fetch("get_farming_ph", {})
         return bytes32.from_hexstr(result["puzzle_hash"])
 
-    async def get_all_coins(self, include_spent_coins: bool = False) -> List[CoinRecord]:
+    async def get_all_coins(self, include_spent_coins: bool = False) -> list[CoinRecord]:
         json_result = await self.fetch("get_all_coins", {"include_spent_coins": include_spent_coins})
         return [CoinRecord.from_json_dict(coin_records) for coin_records in json_result["coin_records"]]
 
-    async def get_all_puzzle_hashes(self) -> Dict[bytes32, Tuple[uint128, int]]:
+    async def get_all_puzzle_hashes(self) -> dict[bytes32, tuple[uint128, int]]:
         str_result = (await self.fetch("get_all_puzzle_hashes", {}))["puzzle_hashes"]
         return {bytes32.from_hexstr(ph): (uint128(amount), num_tx) for (ph, (amount, num_tx)) in str_result.items()}
 

chia/simulator/simulator_test_tools.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import sys
+from collections.abc import AsyncGenerator
 from pathlib import Path
-from typing import Any, AsyncGenerator, Dict, Optional, Tuple
+from typing import Any, Optional
 
 from chia_rs import PrivateKey
 
@@ -34,7 +35,7 @@ These functions are used to test the simulator.
 """
 
 
-def mnemonic_fingerprint(keychain: Keychain) -> Tuple[str, int]:
+def mnemonic_fingerprint(keychain: Keychain) -> tuple[str, int]:
     mnemonic = (
         "today grape album ticket joy idle supreme sausage "
         "oppose voice angle roast you oven betray exact "
@@ -62,10 +63,10 @@ def get_puzzle_hash_from_key(keychain: Keychain, fingerprint: int, key_id: int =
 def create_config(
     chia_root: Path,
     fingerprint: int,
-    private_ca_crt_and_key: Tuple[bytes, bytes],
-    node_certs_and_keys: Dict[str, Dict[str, Dict[str, bytes]]],
+    private_ca_crt_and_key: tuple[bytes, bytes],
+    node_certs_and_keys: dict[str, dict[str, dict[str, bytes]]],
     keychain: Keychain,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     # create chia directories
     create_default_chia_config(chia_root)
     create_all_ssl(
@@ -119,8 +120,8 @@ async def get_full_chia_simulator(
     chia_root: Path,
     keychain: Optional[Keychain] = None,
     automated_testing: bool = False,
-    config: Optional[Dict[str, Any]] = None,
-) -> AsyncGenerator[Tuple[FullNodeSimulator, Path, Dict[str, Any], str, int, Keychain], None]:
+    config: Optional[dict[str, Any]] = None,
+) -> AsyncGenerator[tuple[FullNodeSimulator, Path, dict[str, Any], str, int, Keychain], None]:
     """
     A chia root Path is required.
     The chia root Path can be a temporary directory (tempfile.TemporaryDirectory)

chia/simulator/socket.py

@@ -2,14 +2,11 @@ from __future__ import annotations
 
 import socket
 from contextlib import closing
-from typing import Set
 
-recent_ports: Set[int] = set()
+recent_ports: set[int] = set()
 
 
 def find_available_listen_port(name: str = "free") -> int:
-    global recent_ports
-
     while True:
         with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
             try: