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

chia/timelord/timelord.py

@@ -7,11 +7,13 @@ import io
 import logging
 import os
 import random
+import tempfile
 import time
 import traceback
+from collections.abc import AsyncIterator
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, AsyncIterator, ClassVar, Dict, List, Optional, Set, Tuple, cast
+from typing import IO, TYPE_CHECKING, Any, ClassVar, Optional, cast
 
 from chiavdf import create_discriminant, prove
 
@@ -40,6 +42,7 @@ from chia.types.blockchain_format.vdf import VDFInfo, VDFProof, validate_vdf
 from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
 from chia.util.ints import uint8, uint16, uint32, uint64, uint128
 from chia.util.streamable import Streamable, streamable
+from chia.util.task_referencer import create_referenced_task
 
 log = logging.getLogger(__name__)
 
@@ -52,7 +55,7 @@ class BlueboxProcessData(Streamable):
     iters: uint64
 
 
-def prove_bluebox_slow(payload: bytes) -> bytes:
+def prove_bluebox_slow(payload: bytes, executor_shutdown_tempfile_name: str) -> bytes:
     bluebox_process_data = BlueboxProcessData.from_bytes(payload)
     initial_el = b"\x08" + (b"\x00" * 99)
     return cast(
@@ -62,10 +65,15 @@ def prove_bluebox_slow(payload: bytes) -> bytes:
             initial_el,
             bluebox_process_data.size_bits,
             bluebox_process_data.iters,
+            executor_shutdown_tempfile_name,
         ),
     )
 
 
+def _create_shutdown_file() -> IO[bytes]:
+    return tempfile.NamedTemporaryFile(prefix="chia_timelord_executor_shutdown_trigger")
+
+
 class Timelord:
     if TYPE_CHECKING:
         from chia.rpc.rpc_server import RpcServiceProtocol
@@ -81,50 +89,50 @@ class Timelord:
 
         return self._server
 
-    def __init__(self, root_path: Path, config: Dict[str, Any], constants: ConsensusConstants) -> None:
+    def __init__(self, root_path: Path, config: dict[str, Any], constants: ConsensusConstants) -> None:
         self.config = config
         self.root_path = root_path
         self.constants = constants
         self._shut_down = False
-        self.free_clients: List[Tuple[str, asyncio.StreamReader, asyncio.StreamWriter]] = []
+        self.free_clients: list[tuple[str, asyncio.StreamReader, asyncio.StreamWriter]] = []
         self.ip_whitelist = self.config["vdf_clients"]["ip"]
         self._server: Optional[ChiaServer] = None
-        self.chain_type_to_stream: Dict[Chain, Tuple[str, asyncio.StreamReader, asyncio.StreamWriter]] = {}
-        self.chain_start_time: Dict[Chain, float] = {}
+        self.chain_type_to_stream: dict[Chain, tuple[str, asyncio.StreamReader, asyncio.StreamWriter]] = {}
+        self.chain_start_time: dict[Chain, float] = {}
         # Chains that currently don't have a vdf_client.
-        self.unspawned_chains: List[Chain] = [
+        self.unspawned_chains: list[Chain] = [
             Chain.CHALLENGE_CHAIN,
             Chain.REWARD_CHAIN,
             Chain.INFUSED_CHALLENGE_CHAIN,
         ]
         # Chains that currently accept iterations.
-        self.allows_iters: List[Chain] = []
+        self.allows_iters: list[Chain] = []
         # Last peak received, None if it's already processed.
         self.new_peak: Optional[timelord_protocol.NewPeakTimelord] = None
         # Last state received. Can either be a new peak or a new EndOfSubslotBundle.
         # Unfinished block info, iters adjusted to the last peak.
-        self.unfinished_blocks: List[timelord_protocol.NewUnfinishedBlockTimelord] = []
+        self.unfinished_blocks: list[timelord_protocol.NewUnfinishedBlockTimelord] = []
         # Signage points iters, adjusted to the last peak.
-        self.signage_point_iters: List[Tuple[uint64, uint8]] = []
+        self.signage_point_iters: list[tuple[uint64, uint8]] = []
         # For each chain, send those info when the process spawns.
-        self.iters_to_submit: Dict[Chain, List[uint64]] = {}
-        self.iters_submitted: Dict[Chain, List[uint64]] = {}
-        self.iters_finished: Set[uint64] = set()
+        self.iters_to_submit: dict[Chain, list[uint64]] = {}
+        self.iters_submitted: dict[Chain, list[uint64]] = {}
+        self.iters_finished: set[uint64] = set()
         # For each iteration submitted, know if it's a signage point, an infusion point or an end of slot.
-        self.iteration_to_proof_type: Dict[uint64, IterationType] = {}
+        self.iteration_to_proof_type: dict[uint64, IterationType] = {}
         # List of proofs finished.
-        self.proofs_finished: List[Tuple[Chain, VDFInfo, VDFProof, int]] = []
+        self.proofs_finished: list[tuple[Chain, VDFInfo, VDFProof, int]] = []
         # Data to send at vdf_client initialization.
-        self.overflow_blocks: List[timelord_protocol.NewUnfinishedBlockTimelord] = []
+        self.overflow_blocks: list[timelord_protocol.NewUnfinishedBlockTimelord] = []
         # Incremented each time `reset_chains` has been called.
         # Used to label proofs in `finished_proofs` and to only filter proofs corresponding to the most recent state.
         self.num_resets: int = 0
 
-        self.process_communication_tasks: List[asyncio.Task[None]] = []
+        self.process_communication_tasks: list[asyncio.Task[None]] = []
         self.main_loop: Optional[asyncio.Task[None]] = None
         self.vdf_server: Optional[asyncio.base_events.Server] = None
         self._shut_down = False
-        self.vdf_failures: List[Tuple[Chain, Optional[int]]] = []
+        self.vdf_failures: list[tuple[Chain, Optional[int]]] = []
         self.vdf_failures_count: int = 0
         self.vdf_failure_time: float = 0
         self.total_unfinished: int = 0
@@ -134,9 +142,10 @@ class Timelord:
         # Support backwards compatibility for the old `config.yaml` that has field `sanitizer_mode`.
         if not self.bluebox_mode:
             self.bluebox_mode = self.config.get("sanitizer_mode", False)
-        self.pending_bluebox_info: List[Tuple[float, timelord_protocol.RequestCompactProofOfTime]] = []
+        self.pending_bluebox_info: list[tuple[float, timelord_protocol.RequestCompactProofOfTime]] = []
         self.last_active_time = time.time()
         self.max_allowed_inactivity_time = 60
+        self._executor_shutdown_tempfile: Optional[IO[bytes]] = None
         self.bluebox_pool: Optional[ThreadPoolExecutor] = None
 
     @contextlib.asynccontextmanager
@@ -150,24 +159,27 @@ class Timelord:
         self.last_state: LastState = LastState(self.constants)
         slow_bluebox = self.config.get("slow_bluebox", False)
         if not self.bluebox_mode:
-            self.main_loop = asyncio.create_task(self._manage_chains())
+            self.main_loop = create_referenced_task(self._manage_chains())
         else:
             if os.name == "nt" or slow_bluebox:
                 # `vdf_client` doesn't build on windows, use `prove()` from chiavdf.
                 workers = self.config.get("slow_bluebox_process_count", 1)
+                self._executor_shutdown_tempfile = _create_shutdown_file()
                 self.bluebox_pool = ThreadPoolExecutor(
                     max_workers=workers,
                 )
-                self.main_loop = asyncio.create_task(
+                self.main_loop = create_referenced_task(
                     self._start_manage_discriminant_queue_sanitizer_slow(self.bluebox_pool, workers)
                 )
             else:
-                self.main_loop = asyncio.create_task(self._manage_discriminant_queue_sanitizer())
+                self.main_loop = create_referenced_task(self._manage_discriminant_queue_sanitizer())
         log.info(f"Started timelord, listening on port {self.get_vdf_server_port()}")
         try:
             yield
         finally:
             self._shut_down = True
+            if self._executor_shutdown_tempfile is not None:
+                self._executor_shutdown_tempfile.close()
             for task in self.process_communication_tasks:
                 task.cancel()
             if self.main_loop is not None:
@@ -175,7 +187,7 @@ class Timelord:
             if self.bluebox_pool is not None:
                 self.bluebox_pool.shutdown()
 
-    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 on_connect(self, connection: WSChiaConnection) -> None:
@@ -189,7 +201,7 @@ class Timelord:
     def _set_state_changed_callback(self, callback: StateChangedProtocol) -> None:
         self.state_changed_callback = callback
 
-    def state_changed(self, change: str, change_data: Optional[Dict[str, Any]] = None) -> None:
+    def state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> None:
         if self.state_changed_callback is not None:
             self.state_changed_callback(change, change_data)
 
@@ -206,18 +218,17 @@ class Timelord:
 
     async def _stop_chain(self, chain: Chain) -> None:
         try:
-            _, _, stop_writer = self.chain_type_to_stream[chain]
+            _, _, stop_writer = self.chain_type_to_stream.pop(chain)
+            if chain not in self.unspawned_chains:
+                self.unspawned_chains.append(chain)
             if chain in self.allows_iters:
+                self.allows_iters.remove(chain)
                 stop_writer.write(b"010")
                 await stop_writer.drain()
-                self.allows_iters.remove(chain)
             else:
                 log.error(f"Trying to stop {chain} before its initialization.")
                 stop_writer.close()
                 await stop_writer.wait_closed()
-            if chain not in self.unspawned_chains:
-                self.unspawned_chains.append(chain)
-            del self.chain_type_to_stream[chain]
         except ConnectionResetError as e:
             log.error(f"{e}")
         except Exception as e:
@@ -326,6 +337,11 @@ class Timelord:
                     self.iteration_to_proof_type[new_block_iters] = IterationType.INFUSION_POINT
         # Remove all unfinished blocks that have already passed.
         self.unfinished_blocks = new_unfinished_blocks
+
+        # remove overflow blocks that were moved to unfinished cache
+        for block in new_unfinished_blocks:
+            if block in self.overflow_blocks:
+                self.overflow_blocks.remove(block)
         # Signage points.
         if not only_eos and len(self.signage_point_iters) > 0:
             count_signage = 0
@@ -407,7 +423,7 @@ class Timelord:
             assert challenge is not None
             assert initial_form is not None
             self.process_communication_tasks.append(
-                asyncio.create_task(
+                create_referenced_task(
                     self._do_process_communication(
                         picked_chain, challenge, initial_form, ip, reader, writer, proof_label=self.num_resets
                     )
@@ -431,7 +447,7 @@ class Timelord:
                     writer.write(iter_str.encode())
                     await writer.drain()
 
-    def _clear_proof_list(self, iters: uint64) -> List[Tuple[Chain, VDFInfo, VDFProof, int]]:
+    def _clear_proof_list(self, iters: uint64) -> list[tuple[Chain, VDFInfo, VDFProof, int]]:
         return [
             (chain, info, proof, label)
             for chain, info, proof, label in self.proofs_finished
@@ -1082,6 +1098,8 @@ class Timelord:
 
         except ConnectionResetError as e:
             log.debug(f"Connection reset with VDF client {e}")
+        except Exception:
+            log.exception("VDF client communication terminated abruptly")
 
     async def _manage_discriminant_queue_sanitizer(self) -> None:
         while not self._shut_down:
@@ -1101,7 +1119,7 @@ class Timelord:
                             info = self.pending_bluebox_info[0]
                         ip, reader, writer = self.free_clients[0]
                         self.process_communication_tasks.append(
-                            asyncio.create_task(
+                            create_referenced_task(
                                 self._do_process_communication(
                                     Chain.BLUEBOX,
                                     info[1].new_proof_of_time.challenge,
@@ -1125,7 +1143,7 @@ class Timelord:
     async def _start_manage_discriminant_queue_sanitizer_slow(self, pool: ThreadPoolExecutor, counter: int) -> None:
         tasks = []
         for _ in range(counter):
-            tasks.append(asyncio.create_task(self._manage_discriminant_queue_sanitizer_slow(pool)))
+            tasks.append(create_referenced_task(self._manage_discriminant_queue_sanitizer_slow(pool)))
         for task in tasks:
             await task
 
@@ -1167,6 +1185,7 @@ class Timelord:
                         pool,
                         prove_bluebox_slow,
                         bytes(bluebox_process_data),
+                        "" if self._executor_shutdown_tempfile is None else self._executor_shutdown_tempfile.name,
                     )
                     t2 = time.time()
                     delta = t2 - t1
@@ -1174,6 +1193,11 @@ class Timelord:
                         ips = picked_info.new_proof_of_time.number_of_iterations / delta
                     else:
                         ips = 0
+
+                    if len(proof) == 0:
+                        log.info(f"Empty VDF proof returned: {picked_info.height}. Time: {delta}s. IPS: {ips}.")
+                        return
+
                     log.info(f"Finished compact proof: {picked_info.height}. Time: {delta}s. IPS: {ips}.")
                     output = proof[:100]
                     proof_part = proof[100:200]

chia/timelord/timelord_api.py

@@ -2,23 +2,29 @@ from __future__ import annotations
 
 import logging
 import time
-from typing import Optional
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
 from chia.protocols import timelord_protocol
 from chia.protocols.timelord_protocol import NewPeakTimelord
 from chia.rpc.rpc_server import StateChangedProtocol
+from chia.server.api_protocol import ApiMetadata
 from chia.timelord.iters_from_block import iters_from_block
 from chia.timelord.timelord import Timelord
 from chia.timelord.types import Chain, IterationType
-from chia.util.api_decorators import api_request
 from chia.util.ints import uint64
 
 log = logging.getLogger(__name__)
 
 
 class TimelordAPI:
+    if TYPE_CHECKING:
+        from chia.server.api_protocol import ApiProtocol
+
+        _protocol_check: ClassVar[ApiProtocol] = cast("TimelordAPI", None)
+
     log: logging.Logger
     timelord: Timelord
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
 
     def __init__(self, timelord) -> None:
         self.log = logging.getLogger(__name__)
@@ -30,7 +36,7 @@ class TimelordAPI:
     def _set_state_changed_callback(self, callback: StateChangedProtocol) -> None:
         self.timelord.state_changed_callback = callback
 
-    @api_request()
+    @metadata.request()
     async def new_peak_timelord(self, new_peak: timelord_protocol.NewPeakTimelord) -> None:
         if self.timelord.last_state is None:
             return None
@@ -52,7 +58,7 @@ class TimelordAPI:
                     new_peak.reward_chain_block.height == self.timelord.last_state.last_height + 1
                     and self.check_orphaned_unfinished_block(new_peak) is True
                 ):
-                    log.info("there is an unfinished block that this peak would orphan - " "skip peak")
+                    log.info("there is an unfinished block that this peak would orphan - skip peak")
                     self.timelord.state_changed("skipping_peak", {"height": new_peak.reward_chain_block.height})
                     return
 
@@ -87,7 +93,7 @@ class TimelordAPI:
                 return True
         return False
 
-    @api_request()
+    @metadata.request()
     async def new_unfinished_block_timelord(self, new_unfinished_block: timelord_protocol.NewUnfinishedBlockTimelord):
         if self.timelord.last_state is None:
             return None
@@ -120,7 +126,7 @@ class TimelordAPI:
                     self.timelord.total_unfinished += 1
                     log.debug(f"Non-overflow unfinished block, total {self.timelord.total_unfinished}")
 
-    @api_request()
+    @metadata.request()
     async def request_compact_proof_of_time(self, vdf_info: timelord_protocol.RequestCompactProofOfTime):
         async with self.timelord.lock:
             if not self.timelord.bluebox_mode:

chia/timelord/timelord_launcher.py

@@ -7,15 +7,16 @@ import pathlib
 import signal
 import sys
 import time
+from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from types import FrameType
-from typing import Any, AsyncIterator, Dict, List, Optional
+from typing import Any, Optional
 
 from chia.server.signal_handlers import SignalHandlers
 from chia.util.chia_logging import initialize_logging
 from chia.util.config import load_config
-from chia.util.default_root import DEFAULT_ROOT_PATH
+from chia.util.default_root import resolve_root_path
 from chia.util.network import resolve
 from chia.util.setproctitle import setproctitle
 
@@ -26,7 +27,7 @@ log = logging.getLogger(__name__)
 class VDFClientProcessMgr:
     lock: asyncio.Lock = field(default_factory=asyncio.Lock)
     stopped: bool = False
-    active_processes: List[asyncio.subprocess.Process] = field(default_factory=list)
+    active_processes: list[asyncio.subprocess.Process] = field(default_factory=list)
 
     async def remove_process(self, proc: asyncio.subprocess.Process) -> None:
         async with self.lock:
@@ -131,7 +132,7 @@ async def spawn_process(
             await proc.communicate()
 
 
-async def spawn_all_processes(config: Dict, net_config: Dict, process_mgr: VDFClientProcessMgr):
+async def spawn_all_processes(config: dict, net_config: dict, process_mgr: VDFClientProcessMgr):
     await asyncio.sleep(5)
     hostname = net_config["self_hostname"] if "host" not in config else config["host"]
     port = config["port"]
@@ -152,7 +153,7 @@ async def spawn_all_processes(config: Dict, net_config: Dict, process_mgr: VDFCl
     await asyncio.gather(*awaitables)
 
 
-async def async_main(config: Dict[str, Any], net_config: Dict[str, Any]) -> None:
+async def async_main(config: dict[str, Any], net_config: dict[str, Any]) -> None:
     process_mgr = VDFClientProcessMgr()
 
     async def stop(
@@ -174,8 +175,9 @@ async def async_main(config: Dict[str, Any], net_config: Dict[str, Any]) -> None
 def main():
     if os.name == "nt":
         log.info("Timelord launcher not supported on Windows.")
-        return
-    root_path = DEFAULT_ROOT_PATH
+        return 1
+    root_path = resolve_root_path(override=None)
+
     setproctitle("chia_timelord_launcher")
     net_config = load_config(root_path, "config.yaml")
     config = net_config["timelord_launcher"]
@@ -185,4 +187,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    sys.exit(main())

chia/timelord/timelord_state.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import List, Optional, Tuple, Union
+from typing import Optional, Union
 
 from chia.consensus.constants import ConsensusConstants
 from chia.protocols import timelord_protocol
@@ -44,7 +44,7 @@ class LastState:
         self.last_peak_challenge: bytes32 = constants.GENESIS_CHALLENGE
         self.difficulty: uint64 = constants.DIFFICULTY_STARTING
         self.sub_slot_iters: uint64 = constants.SUB_SLOT_ITERS_STARTING
-        self.reward_challenge_cache: List[Tuple[bytes32, uint128]] = [(constants.GENESIS_CHALLENGE, uint128(0))]
+        self.reward_challenge_cache: list[tuple[bytes32, uint128]] = [(constants.GENESIS_CHALLENGE, uint128(0))]
         self.new_epoch = False
         self.passed_ses_height_but_not_yet_included = False
         self.infused_ses = False
@@ -121,7 +121,7 @@ class LastState:
         if overflow and self.new_epoch:
             # No overflows in new epoch
             return False
-        if self.state_type == StateType.FIRST_SUB_SLOT or self.state_type == StateType.END_OF_SUB_SLOT:
+        if self.state_type in {StateType.FIRST_SUB_SLOT, StateType.END_OF_SUB_SLOT}:
             return True
         ss_start_iters = self.get_total_iters() - self.get_last_ip()
         already_infused_count: int = 0
@@ -160,7 +160,7 @@ class LastState:
         return self.state_type == StateType.END_OF_SUB_SLOT and self.infused_ses
 
     def get_next_sub_epoch_summary(self) -> Optional[SubEpochSummary]:
-        if self.state_type == StateType.FIRST_SUB_SLOT or self.state_type == StateType.END_OF_SUB_SLOT:
+        if self.state_type in {StateType.FIRST_SUB_SLOT, StateType.END_OF_SUB_SLOT}:
             # Can only infuse SES after a peak (in an end of sub slot)
             return None
         assert self.peak is not None
@@ -233,7 +233,7 @@ class LastState:
                 else:
                     return None
         elif self.state_type == StateType.END_OF_SUB_SLOT:
-            if chain == Chain.CHALLENGE_CHAIN or chain == Chain.REWARD_CHAIN:
+            if chain in {Chain.CHALLENGE_CHAIN, Chain.REWARD_CHAIN}:
                 return ClassgroupElement.get_default_element()
             if chain == Chain.INFUSED_CHALLENGE_CHAIN:
                 assert self.subslot_end is not None

chia/types/block_protocol.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import List, Optional
+from typing import Optional
 
 from typing_extensions import Protocol
 
@@ -17,4 +17,4 @@ class BlockInfo(Protocol):
     def transactions_generator(self) -> Optional[SerializedProgram]: ...
 
     @property
-    def transactions_generator_ref_list(self) -> List[uint32]: ...
+    def transactions_generator_ref_list(self) -> list[uint32]: ...

chia/types/blockchain_format/coin.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import List, Union
+from typing import Union
 
 from chia_rs import Coin
 
@@ -11,11 +11,11 @@ from chia.util.ints import uint64
 __all__ = ["Coin", "coin_as_list", "hash_coin_ids"]
 
 
-def coin_as_list(c: Coin) -> List[Union[bytes32, uint64]]:
+def coin_as_list(c: Coin) -> list[Union[bytes32, uint64]]:
     return [c.parent_coin_info, c.puzzle_hash, uint64(c.amount)]
 
 
-def hash_coin_ids(coin_ids: List[bytes32]) -> bytes32:
+def hash_coin_ids(coin_ids: list[bytes32]) -> bytes32:
     if len(coin_ids) == 1:
         return std_hash(coin_ids[0])
 

chia/types/blockchain_format/program.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import io
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Set, Tuple, Type, TypeVar
+from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar
 
-from chia_rs import ALLOW_BACKREFS, MEMPOOL_MODE, run_chia_program, tree_hash
+from chia_rs import MEMPOOL_MODE, run_chia_program, tree_hash
 from clvm.casts import int_from_bytes
 from clvm.CLVMObject import CLVMStorage
 from clvm.EvalError import EvalError
@@ -11,11 +11,10 @@ from clvm.serialize import sexp_from_stream, sexp_to_stream
 from clvm.SExp import SExp
 
 from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.blockchain_format.tree_hash import sha256_treehash
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.hash import std_hash
 
-from .tree_hash import sha256_treehash
-
 INFINITE_COST = 11000000000
 
 DEFAULT_FLAGS = MEMPOOL_MODE
@@ -30,32 +29,32 @@ class Program(SExp):
     """
 
     @classmethod
-    def parse(cls: Type[T_Program], f) -> T_Program:
+    def parse(cls: type[T_Program], f) -> T_Program:
         return sexp_from_stream(f, cls.to)
 
     def stream(self, f):
         sexp_to_stream(self, f)
 
     @classmethod
-    def from_bytes(cls: Type[T_Program], blob: bytes) -> T_Program:
+    def from_bytes(cls: type[T_Program], blob: bytes) -> T_Program:
         # this runs the program "1", which just returns the first argument.
         # the first argument is the buffer we want to parse. This effectively
         # leverages the rust parser and LazyNode, making it a lot faster to
         # parse serialized programs into a python compatible structure
-        cost, ret = run_chia_program(
+        _cost, ret = run_chia_program(
             b"\x01",
             blob,
             50,
-            ALLOW_BACKREFS,
+            0,
         )
         return cls.to(ret)
 
     @classmethod
-    def fromhex(cls: Type[T_Program], hexstr: str) -> T_Program:
+    def fromhex(cls: type[T_Program], hexstr: str) -> T_Program:
         return cls.from_bytes(hexstr_to_bytes(hexstr))
 
     @classmethod
-    def from_json_dict(cls: Type[Program], json_dict: Any) -> Program:
+    def from_json_dict(cls: type[Program], json_dict: Any) -> Program:
         if isinstance(json_dict, cls):
             return json_dict
         item = hexstr_to_bytes(json_dict)
@@ -66,7 +65,7 @@ class Program(SExp):
 
     def __bytes__(self) -> bytes:
         f = io.BytesIO()
-        self.stream(f)  # noqa
+        self.stream(f)
         return f.getvalue()
 
     def __str__(self) -> str:
@@ -124,21 +123,21 @@ class Program(SExp):
     def get_tree_hash(self) -> bytes32:
         return bytes32(tree_hash(bytes(self)))
 
-    def _run(self, max_cost: int, flags: int, args: Any) -> Tuple[int, Program]:
+    def _run(self, max_cost: int, flags: int, args: Any) -> tuple[int, Program]:
         prog_args = Program.to(args)
         cost, r = run_chia_program(self.as_bin(), prog_args.as_bin(), max_cost, flags)
         return cost, Program.to(r)
 
-    def run_with_cost(self, max_cost: int, args: Any, flags=DEFAULT_FLAGS) -> Tuple[int, Program]:
+    def run_with_cost(self, max_cost: int, args: Any, flags=DEFAULT_FLAGS) -> tuple[int, Program]:
         # when running puzzles in the wallet, default to enabling all soft-forks
         # as well as enabling mempool-mode (i.e. strict mode)
         return self._run(max_cost, flags, args)
 
     def run(self, args: Any, max_cost=INFINITE_COST, flags=DEFAULT_FLAGS) -> Program:
-        cost, r = self._run(max_cost, flags, args)
+        _cost, r = self._run(max_cost, flags, args)
         return r
 
-    def run_with_flags(self, max_cost: int, flags: int, args: Any) -> Tuple[int, Program]:
+    def run_with_flags(self, max_cost: int, flags: int, args: Any) -> tuple[int, Program]:
         return self._run(max_cost, flags, args)
 
     # Replicates the curry function from clvm_tools, taking advantage of *args
@@ -163,7 +162,7 @@ class Program(SExp):
             fixed_args = [4, (1, arg), fixed_args]
         return Program.to([2, (1, self), fixed_args])
 
-    def uncurry(self) -> Tuple[Program, Program]:
+    def uncurry(self) -> tuple[Program, Program]:
         def match(o: CLVMStorage, expected: bytes) -> None:
             if o.atom != expected:
                 raise ValueError(f"expected: {expected.hex()}")
@@ -216,7 +215,7 @@ class Program(SExp):
     EvalError = EvalError
 
 
-def _tree_hash(node: SExp, precalculated: Set[bytes32]) -> bytes32:
+def _tree_hash(node: SExp, precalculated: set[bytes32]) -> bytes32:
     """
     Hash values in `precalculated` are presumed to have been hashed already.
     """
@@ -252,7 +251,7 @@ def _sexp_replace(sexp: T_CLVMStorage, to_sexp: Callable[[Any], T_Program], **kw
     # Now split `kwargs` into two groups: those
     # that start with `f` and those that start with `r`
 
-    args_by_prefix: Dict[str, Dict[str, Any]] = {}
+    args_by_prefix: dict[str, dict[str, Any]] = {}
     for k, v in kwargs.items():
         c = k[0]
         if c not in "fr":

chia/types/blockchain_format/tree_hash.py

@@ -8,7 +8,7 @@ have to worry about blowing out the python stack.
 
 from __future__ import annotations
 
-from typing import Callable, List, Optional, Set, Union
+from typing import Callable, Optional, Union
 
 from clvm.CLVMObject import CLVMStorage
 from clvm.SExp import SExp
@@ -17,12 +17,12 @@ from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.hash import std_hash
 
 ValueType = Union[bytes, CLVMStorage]
-ValueStackType = List[ValueType]
-Op = Callable[[ValueStackType, "OpStackType", Set[bytes32]], None]
-OpStackType = List[Op]
+ValueStackType = list[ValueType]
+Op = Callable[[ValueStackType, "OpStackType", set[bytes32]], None]
+OpStackType = list[Op]
 
 
-def sha256_treehash(sexp: CLVMStorage, precalculated: Optional[Set[bytes32]] = None) -> bytes32:
+def sha256_treehash(sexp: CLVMStorage, precalculated: Optional[set[bytes32]] = None) -> bytes32:
     """
     Hash values in `precalculated` are presumed to have been hashed already.
     """
@@ -30,7 +30,7 @@ def sha256_treehash(sexp: CLVMStorage, precalculated: Optional[Set[bytes32]] = N
     if precalculated is None:
         precalculated = set()
 
-    def handle_sexp(sexp_stack: ValueStackType, op_stack: OpStackType, precalculated: Set[bytes32]) -> None:
+    def handle_sexp(sexp_stack: ValueStackType, op_stack: OpStackType, precalculated: set[bytes32]) -> None:
         # just trusting it is right, otherwise we get an attribute error
         sexp: SExp = sexp_stack.pop()  # type: ignore[assignment]
         if sexp.pair:
@@ -50,20 +50,20 @@ def sha256_treehash(sexp: CLVMStorage, precalculated: Optional[Set[bytes32]] = N
                 r = std_hash(b"\1" + atom)
             sexp_stack.append(r)
 
-    def handle_pair(sexp_stack: ValueStackType, op_stack: OpStackType, precalculated: Set[bytes32]) -> None:
+    def handle_pair(sexp_stack: ValueStackType, op_stack: OpStackType, precalculated: set[bytes32]) -> None:
         # just trusting it is right, otherwise we get a type error
         p0: bytes = sexp_stack.pop()  # type: ignore[assignment]
         p1: bytes = sexp_stack.pop()  # type: ignore[assignment]
         sexp_stack.append(std_hash(b"\2" + p0 + p1))
 
-    def roll(sexp_stack: ValueStackType, op_stack: OpStackType, precalculated: Set[bytes32]) -> None:
+    def roll(sexp_stack: ValueStackType, op_stack: OpStackType, precalculated: set[bytes32]) -> None:
         p0 = sexp_stack.pop()
         p1 = sexp_stack.pop()
         sexp_stack.append(p0)
         sexp_stack.append(p1)
 
     sexp_stack: ValueStackType = [sexp]
-    op_stack: List[Op] = [handle_sexp]
+    op_stack: list[Op] = [handle_sexp]
     while len(op_stack) > 0:
         op = op_stack.pop()
         op(sexp_stack, op_stack, precalculated)