chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.5.8rc1__py3-none-any.whl

chia/timelord/timelord.py

@@ -13,7 +13,7 @@ import traceback
 from collections.abc import AsyncIterator
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
-from typing import IO, TYPE_CHECKING, Any, ClassVar, Optional, cast
+from typing import IO, TYPE_CHECKING, Any, ClassVar, cast
 
 from chia_rs import (
     ChallengeChainSubSlot,
@@ -80,6 +80,9 @@ class Timelord:
 
         _protocol_check: ClassVar[RpcServiceProtocol] = cast("Timelord", None)
 
+    unfinished_blocks: list[timelord_protocol.NewUnfinishedBlockTimelord]
+    overflow_blocks: list[timelord_protocol.NewUnfinishedBlockTimelord]
+
     @property
     def server(self) -> ChiaServer:
         # This is a stop gap until the class usage is refactored such the values of
@@ -96,7 +99,7 @@ class Timelord:
         self._shut_down = False
         self.free_clients: list[tuple[str, asyncio.StreamReader, asyncio.StreamWriter]] = []
         self.ip_whitelist = self.config["vdf_clients"]["ip"]
-        self._server: Optional[ChiaServer] = None
+        self._server: ChiaServer | None = None
         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.
@@ -108,7 +111,7 @@ class Timelord:
         # Chains that currently accept iterations.
         self.allows_iters: list[Chain] = []
         # Last peak received, None if it's already processed.
-        self.new_peak: Optional[timelord_protocol.NewPeakTimelord] = None
+        self.new_peak: timelord_protocol.NewPeakTimelord | None = 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] = []
@@ -129,15 +132,15 @@ class Timelord:
         self.num_resets: int = 0
 
         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.main_loop: asyncio.Task[None] | None = None
+        self.vdf_server: asyncio.base_events.Server | None = None
         self._shut_down = False
-        self.vdf_failures: list[tuple[Chain, Optional[int]]] = []
+        self.vdf_failures: list[tuple[Chain, int | None]] = []
         self.vdf_failures_count: int = 0
         self.vdf_failure_time: float = 0
         self.total_unfinished: int = 0
         self.total_infused: int = 0
-        self.state_changed_callback: Optional[StateChangedProtocol] = None
+        self.state_changed_callback: StateChangedProtocol | None = None
         self.bluebox_mode = self.config.get("bluebox_mode", False)
         # Support backwards compatibility for the old `config.yaml` that has field `sanitizer_mode`.
         if not self.bluebox_mode:
@@ -145,8 +148,8 @@ class Timelord:
         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
+        self._executor_shutdown_tempfile: IO[bytes] | None = None
+        self.bluebox_pool: ThreadPoolExecutor | None = None
 
     @contextlib.asynccontextmanager
     async def manage(self) -> AsyncIterator[None]:
@@ -187,13 +190,13 @@ 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: NodeType | None) -> 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:
         pass
 
-    def get_vdf_server_port(self) -> Optional[uint16]:
+    def get_vdf_server_port(self) -> uint16 | None:
         if self.vdf_server is not None:
             return uint16(self.vdf_server.sockets[0].getsockname()[1])
         return None
@@ -201,7 +204,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: dict[str, Any] | None = None) -> None:
         if self.state_changed_callback is not None:
             self.state_changed_callback(change, change_data)
 
@@ -240,7 +243,7 @@ class Timelord:
         else:
             return uint32(self.last_state.get_height() + 1)
 
-    def _can_infuse_unfinished_block(self, block: timelord_protocol.NewUnfinishedBlockTimelord) -> Optional[uint64]:
+    def _can_infuse_unfinished_block(self, block: timelord_protocol.NewUnfinishedBlockTimelord) -> uint64 | None:
         assert self.last_state is not None
         sub_slot_iters = self.last_state.get_sub_slot_iters()
         difficulty = self.last_state.get_difficulty()
@@ -325,7 +328,7 @@ class Timelord:
         self.iteration_to_proof_type = {}
         if not only_eos:
             for block in self.unfinished_blocks + self.overflow_blocks:
-                new_block_iters: Optional[uint64] = self._can_infuse_unfinished_block(block)
+                new_block_iters: uint64 | None = self._can_infuse_unfinished_block(block)
                 # Does not add duplicates, or blocks that we cannot infuse
                 if new_block_iters and new_block_iters not in self.iters_to_submit[Chain.CHALLENGE_CHAIN]:
                     if block not in self.unfinished_blocks:
@@ -473,10 +476,10 @@ class Timelord:
             ]
             # Wait for both cc and rc to have the signage point.
             if len(proofs_with_iter) == 2:
-                cc_info: Optional[VDFInfo] = None
-                cc_proof: Optional[VDFProof] = None
-                rc_info: Optional[VDFInfo] = None
-                rc_proof: Optional[VDFProof] = None
+                cc_info: VDFInfo | None = None
+                cc_proof: VDFProof | None = None
+                rc_info: VDFInfo | None = None
+                rc_proof: VDFProof | None = None
                 for chain, info, proof in proofs_with_iter:
                     if chain == Chain.CHALLENGE_CHAIN:
                         cc_info = info
@@ -511,7 +514,7 @@ class Timelord:
                 to_remove.append((signage_iter, signage_point_index))
 
                 self.proofs_finished = self._clear_proof_list(signage_iter)
-                # Send the next 3 signage point to the chains.
+                # Send the next 10 signage point to the chains.
                 next_iters_count = 0
                 for next_sp, k in self.signage_point_iters:
                     for chain in [Chain.CHALLENGE_CHAIN, Chain.REWARD_CHAIN]:
@@ -568,12 +571,12 @@ class Timelord:
                 if block is not None:
                     ip_total_iters = self.last_state.get_total_iters() + iteration
                     challenge = block.reward_chain_block.get_hash()
-                    icc_info: Optional[VDFInfo] = None
-                    icc_proof: Optional[VDFProof] = None
-                    cc_info: Optional[VDFInfo] = None
-                    cc_proof: Optional[VDFProof] = None
-                    rc_info: Optional[VDFInfo] = None
-                    rc_proof: Optional[VDFProof] = None
+                    icc_info: VDFInfo | None = None
+                    icc_proof: VDFProof | None = None
+                    cc_info: VDFInfo | None = None
+                    cc_proof: VDFProof | None = None
+                    rc_info: VDFInfo | None = None
+                    rc_proof: VDFProof | None = None
                     for chain, info, proof in proofs_with_iter:
                         if chain == Chain.CHALLENGE_CHAIN:
                             cc_info = info
@@ -669,6 +672,7 @@ class Timelord:
                         block.reward_chain_block.reward_chain_sp_signature,
                         rc_info,
                         icc_info,
+                        None,  # header_mmr_root
                         is_transaction_block,
                     )
                     if self.last_state.state_type == StateType.FIRST_SUB_SLOT:
@@ -743,12 +747,12 @@ class Timelord:
         else:
             chain_count = 2
         if len(chains_finished) == chain_count:
-            icc_ip_vdf: Optional[VDFInfo] = None
-            icc_ip_proof: Optional[VDFProof] = None
-            cc_vdf: Optional[VDFInfo] = None
-            cc_proof: Optional[VDFProof] = None
-            rc_vdf: Optional[VDFInfo] = None
-            rc_proof: Optional[VDFProof] = None
+            icc_ip_vdf: VDFInfo | None = None
+            icc_ip_proof: VDFProof | None = None
+            cc_vdf: VDFInfo | None = None
+            cc_proof: VDFProof | None = None
+            rc_vdf: VDFInfo | None = None
+            rc_proof: VDFProof | None = None
             for chain, info, proof in chains_finished:
                 if chain == Chain.CHALLENGE_CHAIN:
                     cc_vdf = info
@@ -789,17 +793,17 @@ class Timelord:
                 assert iters_from_cb <= self.last_state.sub_slot_iters
                 icc_ip_vdf = icc_ip_vdf.replace(number_of_iterations=iters_from_cb)
 
-            icc_sub_slot: Optional[InfusedChallengeChainSubSlot] = (
+            icc_sub_slot: InfusedChallengeChainSubSlot | None = (
                 None if icc_ip_vdf is None else InfusedChallengeChainSubSlot(icc_ip_vdf)
             )
-            icc_sub_slot_hash: Optional[bytes32]
+            icc_sub_slot_hash: bytes32 | None
             if self.last_state.get_deficit() == 0:
                 assert icc_sub_slot is not None
                 icc_sub_slot_hash = icc_sub_slot.get_hash()
             else:
                 icc_sub_slot_hash = None
-            next_ses: Optional[SubEpochSummary] = self.last_state.get_next_sub_epoch_summary()
-            ses_hash: Optional[bytes32]
+            next_ses: SubEpochSummary | None = self.last_state.get_next_sub_epoch_summary()
+            ses_hash: bytes32 | None
             if next_ses is not None:
                 log.info(f"Including sub epoch summary{next_ses}")
                 ses_hash = next_ses.get_hash()
@@ -929,12 +933,12 @@ class Timelord:
         reader: asyncio.StreamReader,
         writer: asyncio.StreamWriter,
         # Data specific only when running in bluebox mode.
-        bluebox_iteration: Optional[uint64] = None,
-        header_hash: Optional[bytes32] = None,
-        height: Optional[uint32] = None,
-        field_vdf: Optional[uint8] = None,
+        bluebox_iteration: uint64 | None = None,
+        header_hash: bytes32 | None = None,
+        height: uint32 | None = None,
+        field_vdf: uint8 | None = None,
         # Labels a proof to the current state only
-        proof_label: Optional[int] = None,
+        proof_label: int | None = None,
     ) -> None:
         disc: int = create_discriminant(challenge, self.constants.DISCRIMINANT_SIZE_BITS)
 

chia/timelord/timelord_api.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 import time
-from typing import TYPE_CHECKING, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, ClassVar
 
 from chia_rs.sized_ints import uint64
 
@@ -19,9 +19,11 @@ log = logging.getLogger(__name__)
 
 class TimelordAPI:
     if TYPE_CHECKING:
-        from chia.server.api_protocol import ApiProtocol
+        from chia.apis.timelord_stub import TimelordApiStub
 
-        _protocol_check: ClassVar[ApiProtocol] = cast("TimelordAPI", None)
+        # Verify this class implements the TimelordApiStub protocol
+        def _protocol_check(self: TimelordAPI) -> TimelordApiStub:
+            return self
 
     log: logging.Logger
     timelord: Timelord
@@ -143,7 +145,7 @@ class TimelordAPI:
                 self.timelord.overflow_blocks.append(new_unfinished_block)
                 log.debug(f"Overflow unfinished block, total {self.timelord.total_unfinished}")
             elif ip_iters > last_ip_iters:
-                new_block_iters: Optional[uint64] = self.timelord._can_infuse_unfinished_block(new_unfinished_block)
+                new_block_iters: uint64 | None = self.timelord._can_infuse_unfinished_block(new_unfinished_block)
                 if new_block_iters:
                     self.timelord.unfinished_blocks.append(new_unfinished_block)
                     for chain in [Chain.REWARD_CHAIN, Chain.CHALLENGE_CHAIN]:

chia/timelord/timelord_launcher.py

@@ -11,7 +11,7 @@ from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from types import FrameType
-from typing import Any, Optional
+from typing import Any
 
 from chia.server.signal_handlers import SignalHandlers
 from chia.util.chia_logging import initialize_logging
@@ -158,7 +158,7 @@ async def async_main(config: dict[str, Any], net_config: dict[str, Any]) -> None
 
     async def stop(
         signal_: signal.Signals,
-        stack_frame: Optional[FrameType],
+        stack_frame: FrameType | None,
         loop: asyncio.AbstractEventLoop,
     ) -> None:
         await process_mgr.kill_processes()

chia/timelord/timelord_rpc_api.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from chia.rpc.rpc_server import Endpoint
 from chia.timelord.timelord import Timelord
@@ -20,7 +20,7 @@ class TimelordRpcApi:
     def get_routes(self) -> dict[str, Endpoint]:
         return {}
 
-    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> list[WsRpcMessage]:
+    async def _state_changed(self, change: str, change_data: dict[str, Any] | None = None) -> list[WsRpcMessage]:
         payloads = []
 
         if change_data is None:

chia/timelord/timelord_state.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional, Union
 
 from chia_rs import ChallengeBlockInfo, ConsensusConstants, EndOfSubSlotBundle, SubEpochSummary
 from chia_rs.sized_bytes import bytes32
@@ -28,17 +27,17 @@ class LastState:
 
     def __init__(self, constants: ConsensusConstants):
         self.state_type: StateType = StateType.FIRST_SUB_SLOT
-        self.peak: Optional[timelord_protocol.NewPeakTimelord] = None
-        self.subslot_end: Optional[EndOfSubSlotBundle] = None
+        self.peak: timelord_protocol.NewPeakTimelord | None = None
+        self.subslot_end: EndOfSubSlotBundle | None = None
         self.last_ip: uint64 = uint64(0)
         self.deficit: uint8 = constants.MIN_BLOCKS_PER_CHALLENGE_BLOCK
-        self.sub_epoch_summary: Optional[SubEpochSummary] = None
+        self.sub_epoch_summary: SubEpochSummary | None = None
         self.constants: ConsensusConstants = constants
         self.last_weight: uint128 = uint128(0)
         self.last_height: uint32 = uint32(0)
         self.total_iters: uint128 = uint128(0)
         self.last_challenge_sb_or_eos_total_iters = uint128(0)
-        self.last_tx_block_total_iters: Optional[uint128] = None
+        self.last_tx_block_total_iters: uint128 | None = None
         self.last_tx_block_block_height: uint32 = uint32(0)
         self.last_tx_block_sp_index: uint8 = uint8(0)
         self.last_peak_challenge: bytes32 = constants.GENESIS_CHALLENGE
@@ -49,7 +48,7 @@ class LastState:
         self.passed_ses_height_but_not_yet_included = False
         self.infused_ses = False
 
-    def set_state(self, state: Union[timelord_protocol.NewPeakTimelord, EndOfSubSlotBundle]) -> None:
+    def set_state(self, state: timelord_protocol.NewPeakTimelord | EndOfSubSlotBundle) -> None:
         if isinstance(state, timelord_protocol.NewPeakTimelord):
             self.state_type = StateType.PEAK
             self.peak = state
@@ -111,7 +110,7 @@ class LastState:
         else:
             assert False
 
-        reward_challenge: Optional[bytes32] = self.get_challenge(Chain.REWARD_CHAIN)
+        reward_challenge: bytes32 | None = self.get_challenge(Chain.REWARD_CHAIN)
         assert reward_challenge is not None  # Reward chain always has VDFs
         self.reward_challenge_cache.append((reward_challenge, self.total_iters))
         log.info(f"Updated timelord peak to {reward_challenge.hex()}, total iters: {self.total_iters}")
@@ -145,7 +144,7 @@ class LastState:
     def get_total_iters(self) -> uint128:
         return self.total_iters
 
-    def get_last_peak_challenge(self) -> Optional[bytes32]:
+    def get_last_peak_challenge(self) -> bytes32 | None:
         return self.last_peak_challenge
 
     def get_difficulty(self) -> uint64:
@@ -163,7 +162,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]:
+    def get_next_sub_epoch_summary(self) -> SubEpochSummary | None:
         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
@@ -173,7 +172,7 @@ class LastState:
             return self.sub_epoch_summary
         return None
 
-    def get_last_block_total_iters(self) -> Optional[uint128]:
+    def get_last_block_total_iters(self) -> uint128 | None:
         return self.last_tx_block_total_iters
 
     def get_last_tx_height(self) -> uint32:
@@ -182,7 +181,7 @@ class LastState:
     def get_passed_ses_height_but_not_yet_included(self) -> bool:
         return self.passed_ses_height_but_not_yet_included
 
-    def get_challenge(self, chain: Chain) -> Optional[bytes32]:
+    def get_challenge(self, chain: Chain) -> bytes32 | None:
         if self.state_type == StateType.FIRST_SUB_SLOT:
             assert self.peak is None and self.subslot_end is None
             if chain == Chain.CHALLENGE_CHAIN:
@@ -222,7 +221,7 @@ class LastState:
                 return None
         return None
 
-    def get_initial_form(self, chain: Chain) -> Optional[ClassgroupElement]:
+    def get_initial_form(self, chain: Chain) -> ClassgroupElement | None:
         if self.state_type == StateType.FIRST_SUB_SLOT:
             return ClassgroupElement.get_default_element()
         elif self.state_type == StateType.PEAK:

chia/types/block_protocol.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 from typing_extensions import Protocol
@@ -14,7 +12,7 @@ class BlockInfo(Protocol):
     def prev_header_hash(self) -> bytes32: ...
 
     @property
-    def transactions_generator(self) -> Optional[SerializedProgram]: ...
+    def transactions_generator(self) -> SerializedProgram | None: ...
 
     @property
     def transactions_generator_ref_list(self) -> list[uint32]: ...

chia/types/blockchain_format/coin.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Union
-
 from chia_rs import Coin
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
@@ -11,7 +9,7 @@ from chia.util.hash import std_hash
 __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[bytes32 | uint64]:
     return [c.parent_coin_info, c.puzzle_hash, uint64(c.amount)]
 
 

chia/types/blockchain_format/program.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import io
-from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, ClassVar, TypeVar
 
 from chia_rs import MEMPOOL_MODE, run_chia_program, tree_hash
 from chia_rs.sized_bytes import bytes32
@@ -30,6 +31,8 @@ class Program(SExp):
     A thin wrapper around s-expression data intended to be invoked with "eval".
     """
 
+    NIL: ClassVar[Program]
+
     @classmethod
     def parse(cls, f) -> Self:
         return sexp_from_stream(f, cls.to)
@@ -219,7 +222,7 @@ class Program(SExp):
         return int_from_bytes(self.as_atom())
 
     def as_atom(self) -> bytes:
-        ret: Optional[bytes] = self.atom
+        ret: bytes | None = self.atom
         if ret is None:
             raise ValueError("expected atom")
         return ret
@@ -247,7 +250,7 @@ def _tree_hash(node: SExp, precalculated: set[bytes32]) -> bytes32:
     return bytes32(std_hash(s))
 
 
-NIL = Program.from_bytes(b"\x80")
+Program.NIL = Program.to(None)
 
 
 # real return type is more like Union[T_Program, CastableType] when considering corner and terminal cases
@@ -284,7 +287,7 @@ def _sexp_replace(sexp: T_CLVMStorage, to_sexp: Callable[[Any], T_Program], **kw
     return to_sexp((new_f, new_r))
 
 
-def _run(prg: Union[SerializedProgram, Program], max_cost: int, flags: int, args: Any) -> tuple[int, Program]:
+def _run(prg: SerializedProgram | Program, max_cost: int, flags: int, args: Any) -> tuple[int, Program]:
     if isinstance(prg, SerializedProgram):
         result = prg.run_rust(max_cost, flags, args)
         return result[0], Program(result[1])  # type: ignore[arg-type]
@@ -292,7 +295,7 @@ def _run(prg: Union[SerializedProgram, Program], max_cost: int, flags: int, args
         return prg._run(max_cost, flags, args)
 
 
-def uncurry(prg: Union[SerializedProgram, Program]) -> tuple[Program, Program]:
+def uncurry(prg: SerializedProgram | Program) -> tuple[Program, Program]:
     if isinstance(prg, SerializedProgram):
         result = prg.uncurry_rust()
         return Program(result[0]), Program(result[1])  # type: ignore[arg-type]
@@ -300,13 +303,13 @@ def uncurry(prg: Union[SerializedProgram, Program]) -> tuple[Program, Program]:
         return prg.uncurry()
 
 
-def run(prg: Union[SerializedProgram, Program], args: Any) -> Program:
+def run(prg: SerializedProgram | Program, args: Any) -> Program:
     return _run(prg, INFINITE_COST, 0, args)[1]
 
 
-def run_with_cost(prg: Union[SerializedProgram, Program], max_cost: int, args: Any) -> tuple[int, Program]:
+def run_with_cost(prg: SerializedProgram | Program, max_cost: int, args: Any) -> tuple[int, Program]:
     return _run(prg, max_cost, 0, args)
 
 
-def run_mempool_with_cost(prg: Union[SerializedProgram, Program], max_cost: int, args: Any) -> tuple[int, Program]:
+def run_mempool_with_cost(prg: SerializedProgram | Program, max_cost: int, args: Any) -> tuple[int, Program]:
     return _run(prg, max_cost, MEMPOOL_MODE, args)