chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/timelord/timelord_api.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import logging
+import time
+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.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__)
+        self.timelord = timelord
+
+    def ready(self) -> bool:
+        return True
+
+    def _set_state_changed_callback(self, callback: StateChangedProtocol) -> None:
+        self.timelord.state_changed_callback = callback
+
+    @metadata.request()
+    async def new_peak_timelord(self, new_peak: timelord_protocol.NewPeakTimelord) -> None:
+        if self.timelord.last_state is None:
+            return None
+        async with self.timelord.lock:
+            if self.timelord.bluebox_mode:
+                return None
+            self.timelord.max_allowed_inactivity_time = 60
+
+            if self.timelord.last_state.peak is None:
+                # no known peak
+                log.info("no last known peak, switching to new peak")
+                self.timelord.new_peak = new_peak
+                self.timelord.state_changed("new_peak", {"height": new_peak.reward_chain_block.height})
+                return
+
+            if self.timelord.last_state.get_weight() < new_peak.reward_chain_block.weight:
+                # if there is an unfinished block with less iterations, skip so we dont orphan it
+                if (
+                    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")
+                    self.timelord.state_changed("skipping_peak", {"height": new_peak.reward_chain_block.height})
+                    return
+
+                log.info("Not skipping peak, don't have. Maybe we are not the fastest timelord")
+                log.info(
+                    f"New peak: height: {new_peak.reward_chain_block.height} weight: "
+                    f"{new_peak.reward_chain_block.weight} "
+                )
+                self.timelord.new_peak = new_peak
+                self.timelord.state_changed("new_peak", {"height": new_peak.reward_chain_block.height})
+                return
+
+            if self.timelord.last_state.peak.reward_chain_block.get_hash() == new_peak.reward_chain_block.get_hash():
+                log.info("Skipping peak, already have.")
+            else:
+                log.info("Skipping peak, block has equal or lower weight then our peak.")
+                log.debug(
+                    f"new peak height {new_peak.reward_chain_block.height} "
+                    f"weight {new_peak.reward_chain_block.weight}"
+                )
+
+            self.timelord.state_changed("skipping_peak", {"height": new_peak.reward_chain_block.height})
+
+    def check_orphaned_unfinished_block(self, new_peak: NewPeakTimelord):
+        for unf_block in self.timelord.unfinished_blocks:
+            if unf_block.reward_chain_block.total_iters <= new_peak.reward_chain_block.total_iters:
+                # there is an unfinished block that would be orphaned by this peak
+                return True
+        for unf_block in self.timelord.overflow_blocks:
+            if unf_block.reward_chain_block.total_iters <= new_peak.reward_chain_block.total_iters:
+                # there is an unfinished block (overflow) that would be orphaned by this peak
+                return True
+        return False
+
+    @metadata.request()
+    async def new_unfinished_block_timelord(self, new_unfinished_block: timelord_protocol.NewUnfinishedBlockTimelord):
+        if self.timelord.last_state is None:
+            return None
+        async with self.timelord.lock:
+            if self.timelord.bluebox_mode:
+                return None
+            try:
+                sp_iters, ip_iters = iters_from_block(
+                    self.timelord.constants,
+                    new_unfinished_block.reward_chain_block,
+                    self.timelord.last_state.get_sub_slot_iters(),
+                    self.timelord.last_state.get_difficulty(),
+                    self.timelord.get_height(),
+                )
+            except Exception:
+                return None
+            last_ip_iters = self.timelord.last_state.get_last_ip()
+            if sp_iters > ip_iters:
+                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)
+                if new_block_iters:
+                    self.timelord.unfinished_blocks.append(new_unfinished_block)
+                    for chain in [Chain.REWARD_CHAIN, Chain.CHALLENGE_CHAIN]:
+                        self.timelord.iters_to_submit[chain].append(new_block_iters)
+                    if self.timelord.last_state.get_deficit() < self.timelord.constants.MIN_BLOCKS_PER_CHALLENGE_BLOCK:
+                        self.timelord.iters_to_submit[Chain.INFUSED_CHALLENGE_CHAIN].append(new_block_iters)
+                    self.timelord.iteration_to_proof_type[new_block_iters] = IterationType.INFUSION_POINT
+                    self.timelord.total_unfinished += 1
+                    log.debug(f"Non-overflow unfinished block, total {self.timelord.total_unfinished}")
+
+    @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:
+                return None
+            now = time.time()
+            # work older than 5s can safely be assumed to be from the previous batch, and needs to be cleared
+            while self.timelord.pending_bluebox_info and (now - self.timelord.pending_bluebox_info[0][0] > 5):
+                del self.timelord.pending_bluebox_info[0]
+            self.timelord.pending_bluebox_info.append((now, vdf_info))

chia/timelord/timelord_launcher.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+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, 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 resolve_root_path
+from chia.util.network import resolve
+from chia.util.setproctitle import setproctitle
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class VDFClientProcessMgr:
+    lock: asyncio.Lock = field(default_factory=asyncio.Lock)
+    stopped: bool = False
+    active_processes: list[asyncio.subprocess.Process] = field(default_factory=list)
+
+    async def remove_process(self, proc: asyncio.subprocess.Process) -> None:
+        async with self.lock:
+            try:
+                self.active_processes.remove(proc)
+            except ValueError:
+                pass
+
+    async def add_process(self, proc: asyncio.subprocess.Process) -> None:
+        async with self.lock:
+            self.active_processes.append(proc)
+
+    async def kill_processes(self) -> None:
+        async with self.lock:
+            self.stopped = True
+            for process in self.active_processes:
+                try:
+                    process.kill()
+                    await process.wait()
+                    if sys.version_info < (3, 11, 1):
+                        # hack to avoid `Event loop is closed` errors (fixed in python 3.11.1)
+                        # https://github.com/python/cpython/issues/88050
+                        process._transport.close()  # type: ignore [attr-defined]
+                except (ProcessLookupError, AttributeError):
+                    pass
+            self.active_processes.clear()
+
+    @asynccontextmanager
+    async def manage_proc(self, proc: asyncio.subprocess.Process) -> AsyncIterator[None]:
+        await self.add_process(proc)
+        try:
+            yield
+        finally:
+            await self.remove_process(proc)
+
+
+def find_vdf_client() -> pathlib.Path:
+    try:
+        import chiavdf
+    except ImportError:
+        raise Exception("Cannot import chiavdf package")
+
+    file_string = getattr(chiavdf, "__file__", None)
+    if file_string is None:
+        raise Exception("Cannot find chiavdf package location")
+
+    location = pathlib.Path(file_string).parent
+    p = location.joinpath("vdf_client")
+    if p.is_file():
+        return p
+    raise FileNotFoundError("Cannot find vdf_client binary. Is Timelord installed? See install-timelord.sh")
+
+
+async def spawn_process(
+    host: str,
+    port: int,
+    counter: int,
+    process_mgr: VDFClientProcessMgr,
+    *,
+    prefer_ipv6: bool,
+) -> None:
+    path_to_vdf_client = find_vdf_client()
+    first_10_seconds = True
+    start_time = time.time()
+    while not process_mgr.stopped:
+        try:
+            dirname = path_to_vdf_client.parent
+            basename = path_to_vdf_client.name
+            resolved = await resolve(host, prefer_ipv6=prefer_ipv6)
+            proc = await asyncio.create_subprocess_exec(
+                os.fspath(basename),
+                str(resolved),
+                str(port),
+                str(counter),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env={"PATH": os.fspath(dirname)},
+            )
+        except Exception as e:
+            log.warning(f"Exception while spawning process {counter}: {(e)}")
+            continue
+
+        async with process_mgr.manage_proc(proc):
+            while True:
+                if proc.stdout is None or proc.stderr is None:
+                    break
+                if proc.stdout.at_eof() and proc.stderr.at_eof():
+                    break
+                stdout = (await proc.stdout.readline()).decode().rstrip()
+                if stdout:
+                    log.info(f"VDF client {counter}: {stdout}")
+                stderr = (await proc.stderr.readline()).decode().rstrip()
+                if stderr:
+                    if first_10_seconds:
+                        if time.time() - start_time > 10:
+                            first_10_seconds = False
+                    else:
+                        log.error(f"VDF client {counter}: {stderr}")
+
+                await asyncio.sleep(0.1)
+
+            await proc.communicate()
+
+
+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"]
+    process_count = config["process_count"]
+    if process_count == 0:
+        log.info("Process_count set to 0, stopping TLauncher.")
+        return
+    awaitables = [
+        spawn_process(
+            hostname,
+            port,
+            i,
+            process_mgr,
+            prefer_ipv6=net_config.get("prefer_ipv6", False),
+        )
+        for i in range(process_count)
+    ]
+    await asyncio.gather(*awaitables)
+
+
+async def async_main(config: dict[str, Any], net_config: dict[str, Any]) -> None:
+    process_mgr = VDFClientProcessMgr()
+
+    async def stop(
+        signal_: signal.Signals,
+        stack_frame: Optional[FrameType],
+        loop: asyncio.AbstractEventLoop,
+    ) -> None:
+        await process_mgr.kill_processes()
+
+    async with SignalHandlers.manage() as signal_handlers:
+        signal_handlers.setup_async_signal_handler(handler=stop)
+
+        try:
+            await spawn_all_processes(config, net_config, process_mgr)
+        finally:
+            log.info("Launcher fully closed.")
+
+
+def main():
+    if os.name == "nt":
+        log.info("Timelord launcher not supported on Windows.")
+        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"]
+    initialize_logging("TLauncher", config["logging"], root_path)
+
+    asyncio.run(async_main(config=config, net_config=net_config))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

chia/timelord/timelord_state.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+
+import logging
+from typing import Optional, Union
+
+from chia.consensus.constants import ConsensusConstants
+from chia.protocols import timelord_protocol
+from chia.timelord.iters_from_block import iters_from_block
+from chia.timelord.types import Chain, StateType
+from chia.types.blockchain_format.classgroup import ClassgroupElement
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.blockchain_format.slots import ChallengeBlockInfo
+from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
+from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
+from chia.util.ints import uint8, uint32, uint64, uint128
+
+log = logging.getLogger(__name__)
+
+
+class LastState:
+    """
+    Represents the state that the timelord is in, and should execute VDFs on top of. A state can be one of three types:
+    1. A "peak" or a block
+    2. An end of sub-slot
+    3. None, if it's the first sub-slot and there are no blocks yet
+    Timelords execute VDFs until they reach the next block or sub-slot, at which point the state is changed again.
+    The state can also be changed arbitrarily to a sub-slot or peak, for example in the case the timelord receives
+    a new block in the future.
+    """
+
+    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.last_ip: uint64 = uint64(0)
+        self.deficit: uint8 = constants.MIN_BLOCKS_PER_CHALLENGE_BLOCK
+        self.sub_epoch_summary: Optional[SubEpochSummary] = 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_block_total_iters: Optional[uint128] = None
+        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.new_epoch = False
+        self.passed_ses_height_but_not_yet_included = False
+        self.infused_ses = False
+
+    def set_state(self, state: Union[timelord_protocol.NewPeakTimelord, EndOfSubSlotBundle]) -> None:
+        if isinstance(state, timelord_protocol.NewPeakTimelord):
+            self.state_type = StateType.PEAK
+            self.peak = state
+            self.subslot_end = None
+            _, self.last_ip = iters_from_block(
+                self.constants,
+                state.reward_chain_block,
+                state.sub_slot_iters,
+                state.difficulty,
+                state.reward_chain_block.height,
+            )
+            self.deficit = state.deficit
+            self.sub_epoch_summary = state.sub_epoch_summary
+            self.last_weight = state.reward_chain_block.weight
+            self.last_height = state.reward_chain_block.height
+            self.total_iters = state.reward_chain_block.total_iters
+            self.last_peak_challenge = state.reward_chain_block.get_hash()
+            self.difficulty = state.difficulty
+            self.sub_slot_iters = state.sub_slot_iters
+            if state.reward_chain_block.is_transaction_block:
+                self.last_block_total_iters = self.total_iters
+            self.reward_challenge_cache = state.previous_reward_challenges
+            self.last_challenge_sb_or_eos_total_iters = self.peak.last_challenge_sb_or_eos_total_iters
+            self.new_epoch = False
+            if (self.peak.reward_chain_block.height + 1) % self.constants.SUB_EPOCH_BLOCKS == 0:
+                self.passed_ses_height_but_not_yet_included = True
+            else:
+                self.passed_ses_height_but_not_yet_included = state.passes_ses_height_but_not_yet_included
+        elif isinstance(state, EndOfSubSlotBundle):
+            self.state_type = StateType.END_OF_SUB_SLOT
+            if self.peak is not None:
+                self.total_iters = uint128(self.total_iters - self.get_last_ip() + self.sub_slot_iters)
+            else:
+                self.total_iters = uint128(self.total_iters + self.sub_slot_iters)
+            self.peak = None
+            self.subslot_end = state
+            self.last_ip = uint64(0)
+            self.deficit = state.reward_chain.deficit
+            if state.challenge_chain.new_difficulty is not None:
+                assert state.challenge_chain.new_sub_slot_iters is not None
+                self.difficulty = state.challenge_chain.new_difficulty
+                self.sub_slot_iters = state.challenge_chain.new_sub_slot_iters
+                self.new_epoch = True
+            else:
+                self.new_epoch = False
+            if state.challenge_chain.subepoch_summary_hash is not None:
+                self.infused_ses = True
+                self.passed_ses_height_but_not_yet_included = False
+            else:
+                self.infused_ses = False
+                # Since we have a new sub slot which is not an end of subepoch,
+                # we will use the last value that we saw for
+                # passed_ses_height_but_not_yet_included
+            self.last_challenge_sb_or_eos_total_iters = self.total_iters
+        else:
+            assert False
+
+        reward_challenge: Optional[bytes32] = 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}")
+        while len(self.reward_challenge_cache) > 2 * self.constants.MAX_SUB_SLOT_BLOCKS:
+            self.reward_challenge_cache.pop(0)
+
+    def get_sub_slot_iters(self) -> uint64:
+        return self.sub_slot_iters
+
+    def can_infuse_block(self, overflow: bool) -> bool:
+        if overflow and self.new_epoch:
+            # No overflows in new epoch
+            return False
+        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
+        for _, total_iters in self.reward_challenge_cache:
+            if total_iters > ss_start_iters:
+                already_infused_count += 1
+        if already_infused_count >= self.constants.MAX_SUB_SLOT_BLOCKS:
+            return False
+        return True
+
+    def get_weight(self) -> uint128:
+        return self.last_weight
+
+    def get_height(self) -> uint32:
+        return self.last_height
+
+    def get_total_iters(self) -> uint128:
+        return self.total_iters
+
+    def get_last_peak_challenge(self) -> Optional[bytes32]:
+        return self.last_peak_challenge
+
+    def get_difficulty(self) -> uint64:
+        return self.difficulty
+
+    def get_last_ip(self) -> uint64:
+        return self.last_ip
+
+    def get_deficit(self) -> uint8:
+        return self.deficit
+
+    def just_infused_sub_epoch_summary(self) -> bool:
+        """
+        Returns true if state is an end of sub-slot, and that end of sub-slot infused a sub epoch summary
+        """
+        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 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
+        if self.passed_ses_height_but_not_yet_included and self.get_deficit() == 0:
+            # This will mean we will include the ses in the next sub-slot
+            return self.sub_epoch_summary
+        return None
+
+    def get_last_block_total_iters(self) -> Optional[uint128]:
+        return self.last_block_total_iters
+
+    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]:
+        if self.state_type == StateType.FIRST_SUB_SLOT:
+            assert self.peak is None and self.subslot_end is None
+            if chain == Chain.CHALLENGE_CHAIN:
+                return self.constants.GENESIS_CHALLENGE
+            elif chain == Chain.REWARD_CHAIN:
+                return self.constants.GENESIS_CHALLENGE
+            elif chain == Chain.INFUSED_CHALLENGE_CHAIN:
+                return None
+        elif self.state_type == StateType.PEAK:
+            assert self.peak is not None
+            reward_chain_block = self.peak.reward_chain_block
+            if chain == Chain.CHALLENGE_CHAIN:
+                return reward_chain_block.challenge_chain_ip_vdf.challenge
+            elif chain == Chain.REWARD_CHAIN:
+                return reward_chain_block.get_hash()
+            elif chain == Chain.INFUSED_CHALLENGE_CHAIN:
+                if reward_chain_block.infused_challenge_chain_ip_vdf is not None:
+                    return reward_chain_block.infused_challenge_chain_ip_vdf.challenge
+                elif self.peak.deficit == self.constants.MIN_BLOCKS_PER_CHALLENGE_BLOCK - 1:
+                    return ChallengeBlockInfo(
+                        reward_chain_block.proof_of_space,
+                        reward_chain_block.challenge_chain_sp_vdf,
+                        reward_chain_block.challenge_chain_sp_signature,
+                        reward_chain_block.challenge_chain_ip_vdf,
+                    ).get_hash()
+                return None
+        elif self.state_type == StateType.END_OF_SUB_SLOT:
+            assert self.subslot_end is not None
+            if chain == Chain.CHALLENGE_CHAIN:
+                return self.subslot_end.challenge_chain.get_hash()
+            elif chain == Chain.REWARD_CHAIN:
+                return self.subslot_end.reward_chain.get_hash()
+            elif chain == Chain.INFUSED_CHALLENGE_CHAIN:
+                if self.subslot_end.reward_chain.deficit < self.constants.MIN_BLOCKS_PER_CHALLENGE_BLOCK:
+                    assert self.subslot_end.infused_challenge_chain is not None
+                    return self.subslot_end.infused_challenge_chain.get_hash()
+                return None
+        return None
+
+    def get_initial_form(self, chain: Chain) -> Optional[ClassgroupElement]:
+        if self.state_type == StateType.FIRST_SUB_SLOT:
+            return ClassgroupElement.get_default_element()
+        elif self.state_type == StateType.PEAK:
+            assert self.peak is not None
+            reward_chain_block = self.peak.reward_chain_block
+            if chain == Chain.CHALLENGE_CHAIN:
+                return reward_chain_block.challenge_chain_ip_vdf.output
+            if chain == Chain.REWARD_CHAIN:
+                return ClassgroupElement.get_default_element()
+            if chain == Chain.INFUSED_CHALLENGE_CHAIN:
+                if reward_chain_block.infused_challenge_chain_ip_vdf is not None:
+                    return reward_chain_block.infused_challenge_chain_ip_vdf.output
+                elif self.peak.deficit == self.constants.MIN_BLOCKS_PER_CHALLENGE_BLOCK - 1:
+                    return ClassgroupElement.get_default_element()
+                else:
+                    return None
+        elif self.state_type == StateType.END_OF_SUB_SLOT:
+            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
+                if self.subslot_end.reward_chain.deficit < self.constants.MIN_BLOCKS_PER_CHALLENGE_BLOCK:
+                    return ClassgroupElement.get_default_element()
+                else:
+                    return None
+        return None

chia/timelord/types.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class Chain(Enum):
+    CHALLENGE_CHAIN = 1
+    REWARD_CHAIN = 2
+    INFUSED_CHALLENGE_CHAIN = 3
+    BLUEBOX = 4
+
+
+class IterationType(Enum):
+    SIGNAGE_POINT = 1
+    INFUSION_POINT = 2
+    END_OF_SUBSLOT = 3
+
+
+class StateType(Enum):
+    PEAK = 1
+    END_OF_SUB_SLOT = 2
+    FIRST_SUB_SLOT = 3

chia/types/aliases.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from chia.data_layer.data_layer import DataLayer
+from chia.data_layer.data_layer_api import DataLayerAPI
+from chia.farmer.farmer import Farmer
+from chia.farmer.farmer_api import FarmerAPI
+from chia.full_node.full_node import FullNode
+from chia.full_node.full_node_api import FullNodeAPI
+from chia.harvester.harvester import Harvester
+from chia.harvester.harvester_api import HarvesterAPI
+from chia.introducer.introducer import Introducer
+from chia.introducer.introducer_api import IntroducerAPI
+from chia.rpc.crawler_rpc_api import CrawlerRpcApi
+from chia.rpc.data_layer_rpc_api import DataLayerRpcApi
+from chia.rpc.farmer_rpc_api import FarmerRpcApi
+from chia.rpc.full_node_rpc_api import FullNodeRpcApi
+from chia.rpc.harvester_rpc_api import HarvesterRpcApi
+from chia.rpc.timelord_rpc_api import TimelordRpcApi
+from chia.rpc.wallet_rpc_api import WalletRpcApi
+from chia.seeder.crawler import Crawler
+from chia.seeder.crawler_api import CrawlerAPI
+from chia.server.start_service import Service
+from chia.timelord.timelord import Timelord
+from chia.timelord.timelord_api import TimelordAPI
+from chia.wallet.wallet_node import WalletNode
+from chia.wallet.wallet_node_api import WalletNodeAPI
+
+CrawlerService = Service[Crawler, CrawlerAPI, CrawlerRpcApi]
+DataLayerService = Service[DataLayer, DataLayerAPI, DataLayerRpcApi]
+FarmerService = Service[Farmer, FarmerAPI, FarmerRpcApi]
+FullNodeService = Service[FullNode, FullNodeAPI, FullNodeRpcApi]
+HarvesterService = Service[Harvester, HarvesterAPI, HarvesterRpcApi]
+IntroducerService = Service[Introducer, IntroducerAPI, FullNodeRpcApi]
+TimelordService = Service[Timelord, TimelordAPI, TimelordRpcApi]
+WalletService = Service[WalletNode, WalletNodeAPI, WalletRpcApi]

chia/types/block_protocol.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from typing_extensions import Protocol
+
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint32
+
+
+class BlockInfo(Protocol):
+    @property
+    def prev_header_hash(self) -> bytes32: ...
+
+    @property
+    def transactions_generator(self) -> Optional[SerializedProgram]: ...
+
+    @property
+    def transactions_generator_ref_list(self) -> list[uint32]: ...

chia/types/blockchain_format/classgroup.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from chia_rs import ClassgroupElement
+
+__all__ = ["ClassgroupElement"]