chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/consensus/pot_iterations.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from chia.consensus.constants import ConsensusConstants
+from chia.consensus.pos_quality import _expected_plot_size
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.hash import std_hash
+from chia.util.ints import uint8, uint64, uint128
+
+
+def is_overflow_block(constants: ConsensusConstants, signage_point_index: uint8) -> bool:
+    if signage_point_index >= constants.NUM_SPS_SUB_SLOT:
+        raise ValueError("SP index too high")
+    return signage_point_index >= constants.NUM_SPS_SUB_SLOT - constants.NUM_SP_INTERVALS_EXTRA
+
+
+def calculate_sp_interval_iters(constants: ConsensusConstants, sub_slot_iters: uint64) -> uint64:
+    assert sub_slot_iters % constants.NUM_SPS_SUB_SLOT == 0
+    return uint64(sub_slot_iters // constants.NUM_SPS_SUB_SLOT)
+
+
+def calculate_sp_iters(constants: ConsensusConstants, sub_slot_iters: uint64, signage_point_index: uint8) -> uint64:
+    if signage_point_index >= constants.NUM_SPS_SUB_SLOT:
+        raise ValueError("SP index too high")
+    return uint64(calculate_sp_interval_iters(constants, sub_slot_iters) * signage_point_index)
+
+
+def calculate_ip_iters(
+    constants: ConsensusConstants,
+    sub_slot_iters: uint64,
+    signage_point_index: uint8,
+    required_iters: uint64,
+) -> uint64:
+    # Note that the SSI is for the block passed in, which might be in the previous epoch
+    sp_iters = calculate_sp_iters(constants, sub_slot_iters, signage_point_index)
+    sp_interval_iters: uint64 = calculate_sp_interval_iters(constants, sub_slot_iters)
+    if sp_iters % sp_interval_iters != 0 or sp_iters >= sub_slot_iters:
+        raise ValueError(f"Invalid sp iters {sp_iters} for this ssi {sub_slot_iters}")
+
+    if required_iters >= sp_interval_iters or required_iters == 0:
+        raise ValueError(
+            f"Required iters {required_iters} is not below the sp interval iters {sp_interval_iters} "
+            f"{sub_slot_iters} or not >0."
+        )
+
+    return uint64((sp_iters + constants.NUM_SP_INTERVALS_EXTRA * sp_interval_iters + required_iters) % sub_slot_iters)
+
+
+def calculate_iterations_quality(
+    difficulty_constant_factor: uint128,
+    quality_string: bytes32,
+    size: int,
+    difficulty: uint64,
+    cc_sp_output_hash: bytes32,
+) -> uint64:
+    """
+    Calculates the number of iterations from the quality. This is derives as the difficulty times the constant factor
+    times a random number between 0 and 1 (based on quality string), divided by plot size.
+    """
+    sp_quality_string: bytes32 = std_hash(quality_string + cc_sp_output_hash)
+
+    iters = uint64(
+        int(difficulty)
+        * int(difficulty_constant_factor)
+        * int.from_bytes(sp_quality_string, "big", signed=False)
+        // (int(pow(2, 256)) * int(_expected_plot_size(size)))
+    )
+    return max(iters, uint64(1))

chia/consensus/puzzles/chialisp_deserialisation.clsp

@@ -0,0 +1,69 @@
+;; this code is included in the ROM. Unfortunately, it has a problem that limits
+;; its usefulness: it is incapable of deserializing atoms with length longer than
+;; 8191 = 0x1fff.
+;;
+;; Because this code is included in the ROM, fixing the bug would be a hard fork
+;; so we're rather stuck with this bug. We recommend simply using a local version
+;; of this code when necessary.
+
+(mod (input)
+
+  (defconstant MAX_SINGLE_BYTE 0x7F)
+  (defconstant MAX_TWO_BYTE 0xbf)
+  (defconstant MAX_THREE_BYTE 0xdf)
+  (defconstant MAX_FOUR_BYTE 0xef)
+  (defconstant MAX_FIVE_BYTE 0xf7)
+  (defconstant MAX_SIX_BYTE 0xfb)
+  (defconstant CONS_BOX_MARKER 0xFF)
+
+  (defun sexp_from_stream (input_stream)
+    (if (= (substr input_stream 0 1) CONS_BOX_MARKER)
+        (cons_sexp_from_stream (sexp_from_stream (substr input_stream 1)))
+        (atom_from_stream (substr input_stream 1) (substr input_stream 0 1))
+    )
+  )
+
+  (defun cons_sexp_from_stream (left_sexp_with_input)
+    (cons_return (f left_sexp_with_input) (sexp_from_stream (f (r left_sexp_with_input))))
+  )
+
+  (defun cons_return (left_sexp right_sexp_with_input)
+    (list (c left_sexp (f right_sexp_with_input)) (f (r right_sexp_with_input)))
+  )
+
+  (defun atom_from_stream (input_file input_bits)
+    (if (= input_bits (quote 0x80))
+        (list () input_file)
+        (if (>s input_bits MAX_SINGLE_BYTE)
+            (atom_from_stream_part_two (get_bitcount input_bits input_file))
+            (list input_bits input_file)
+        )
+    )
+  )
+
+  ; Note that we reject any serialized atom here with more than 3 bytes of
+  ; encoded length prefix, even though the Rust and Python CLVM interpreters
+  ; and deserializers support more.
+  ; This allows 5 + 8 = 13 bits = 8191-byte atoms
+  ; Also note that this does not limit intermediate atom length. Those limits
+  ; are implemented in the clvm interpreters theselves
+  (defun-inline get_bitcount (input_bits input_file)
+    (if (>s input_bits MAX_TWO_BYTE)
+        (if (>s input_bits MAX_THREE_BYTE)
+            (x)
+            ;three byte length prefix
+            (list (concat (logand (quote 0x1f) input_bits) (substr input_file 0 1)) (substr input_file 1))
+        )
+        ;two byte length prefix
+        (list (logand (quote 0x3f) input_bits) input_file)
+    )
+  )
+
+  (defun atom_from_stream_part_two ((size_to_read input_file))
+    (list (substr input_file 0 size_to_read) (substr input_file size_to_read))
+  )
+
+  ; main
+  (f (sexp_from_stream input))
+
+)

chia/consensus/puzzles/chialisp_deserialisation.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff05ffff02ff3effff04ff02ffff04ff05ff8080808080ffff04ffff01ffffff81ff7fff81df81bfffffff02ffff03ffff09ff0bffff01818080ffff01ff04ff80ffff04ff05ff808080ffff01ff02ffff03ffff0aff0bff1880ffff01ff02ff1affff04ff02ffff04ffff02ffff03ffff0aff0bff1c80ffff01ff02ffff03ffff0aff0bff1480ffff01ff0880ffff01ff04ffff0effff18ffff011fff0b80ffff0cff05ff80ffff01018080ffff04ffff0cff05ffff010180ff80808080ff0180ffff01ff04ffff18ffff013fff0b80ffff04ff05ff80808080ff0180ff80808080ffff01ff04ff0bffff04ff05ff80808080ff018080ff0180ff04ffff0cff15ff80ff0980ffff04ffff0cff15ff0980ff808080ffff04ffff04ff05ff1380ffff04ff2bff808080ffff02ff16ffff04ff02ffff04ff09ffff04ffff02ff3effff04ff02ffff04ff15ff80808080ff8080808080ff02ffff03ffff09ffff0cff05ff80ffff010180ff1080ffff01ff02ff2effff04ff02ffff04ffff02ff3effff04ff02ffff04ffff0cff05ffff010180ff80808080ff80808080ffff01ff02ff12ffff04ff02ffff04ffff0cff05ffff010180ffff04ffff0cff05ff80ffff010180ff808080808080ff0180ff018080

chia/consensus/puzzles/rom_bootstrap_generator.clsp

@@ -0,0 +1,37 @@
+(mod (block_decompresser_program (historical_blocks_tree))
+
+  (defconstant local_deserialize_mod
+    ;; this monstrosity is the assembly output of `chialisp_deserialisation.clsp`
+    ;; it's pasted in here because the compiler doesn't yet support nested `mod`
+    ;; my apologies -- RK
+
+    (a (q 5 (a 62 (c 2 (c 5 ()))))
+      (c (q ((-1 . 127) -33 . -65) ((a (i (= 11 (q . -128)) (q 4 () (c 5 ())) (q 2 (i (>s 11 24) (q 2 26 (c 2 (c (a (i (>s 11 28) (q 2 (i (>s 11 20) (q 8) (q 4 (concat (logand (q . 31) 11) (substr 5 () (q . 1))) (c (substr 5 (q . 1)) ()))) 1) (q 4 (logand (q . 63) 11) (c 5 ()))) 1) ()))) (q 4 11 (c 5 ()))) 1)) 1) 4 (substr 21 () 9) (c (substr 21 9) ())) (c (c 5 19) (c 43 ())) (a 22 (c 2 (c 9 (c (a 62 (c 2 (c 21 ()))) ())))) 2 (i (= (substr 5 () (q . 1)) 16) (q 2 46 (c 2 (c (a 62 (c 2 (c (substr 5 (q . 1)) ()))) ()))) (q 2 18 (c 2 (c (substr 5 (q . 1)) (c (substr 5 () (q . 1)) ()))))) 1)
+    1))
+  )
+
+  (defun sha256tree
+    (TREE)
+    (if (l TREE)
+        (sha256 2 (sha256tree (f TREE)) (sha256tree (r TREE)))
+        (sha256 1 TREE)
+    )
+  )
+
+  (defun process_coin_spend ((parent puzzle amount solution . spend_level_extras))
+    (c parent (c (sha256tree puzzle) (c amount (c (a puzzle solution) spend_level_extras))))
+  )
+
+  (defun recurse (coin_spends)
+    (if coin_spends
+        (c (process_coin_spend (f coin_spends)) (recurse (r coin_spends)))
+        0
+    )
+  )
+
+  (defun process-decompressor ((coin_spends . block-level-extras))
+    (c (recurse coin_spends) block-level-extras)
+  )
+
+(process-decompressor (a block_decompresser_program (list local_deserialize_mod historical_blocks_tree))))
+)

chia/consensus/puzzles/rom_bootstrap_generator.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ff0cffff04ff02ffff04ffff02ff05ffff04ff08ffff04ff13ff80808080ff80808080ffff04ffff01ffffff02ffff01ff05ffff02ff3effff04ff02ffff04ff05ff8080808080ffff04ffff01ffffff81ff7fff81df81bfffffff02ffff03ffff09ff0bffff01818080ffff01ff04ff80ffff04ff05ff808080ffff01ff02ffff03ffff0aff0bff1880ffff01ff02ff1affff04ff02ffff04ffff02ffff03ffff0aff0bff1c80ffff01ff02ffff03ffff0aff0bff1480ffff01ff0880ffff01ff04ffff0effff18ffff011fff0b80ffff0cff05ff80ffff01018080ffff04ffff0cff05ffff010180ff80808080ff0180ffff01ff04ffff18ffff013fff0b80ffff04ff05ff80808080ff0180ff80808080ffff01ff04ff0bffff04ff05ff80808080ff018080ff0180ff04ffff0cff15ff80ff0980ffff04ffff0cff15ff0980ff808080ffff04ffff04ff05ff1380ffff04ff2bff808080ffff02ff16ffff04ff02ffff04ff09ffff04ffff02ff3effff04ff02ffff04ff15ff80808080ff8080808080ff02ffff03ffff09ffff0cff05ff80ffff010180ff1080ffff01ff02ff2effff04ff02ffff04ffff02ff3effff04ff02ffff04ffff0cff05ffff010180ff80808080ff80808080ffff01ff02ff12ffff04ff02ffff04ffff0cff05ffff010180ffff04ffff0cff05ff80ffff010180ff808080808080ff0180ff018080ff04ffff02ff16ffff04ff02ffff04ff09ff80808080ff0d80ffff04ff09ffff04ffff02ff1effff04ff02ffff04ff15ff80808080ffff04ff2dffff04ffff02ff15ff5d80ff7d80808080ffff02ffff03ff05ffff01ff04ffff02ff0affff04ff02ffff04ff09ff80808080ffff02ff16ffff04ff02ffff04ff0dff8080808080ff8080ff0180ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff1effff04ff02ffff04ff09ff80808080ffff02ff1effff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080

chia/consensus/vdf_info_computation.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from chia.consensus.block_record import BlockRecord
+from chia.consensus.blockchain_interface import BlockRecordsProtocol
+from chia.consensus.constants import ConsensusConstants
+from chia.types.blockchain_format.classgroup import ClassgroupElement
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
+from chia.util.ints import uint64, uint128
+
+
+def get_signage_point_vdf_info(
+    constants: ConsensusConstants,
+    finished_sub_slots: list[EndOfSubSlotBundle],
+    overflow: bool,
+    prev_b: Optional[BlockRecord],
+    blocks: BlockRecordsProtocol,
+    sp_total_iters: uint128,
+    sp_iters: uint64,
+) -> tuple[bytes32, bytes32, ClassgroupElement, ClassgroupElement, uint64, uint64]:
+    """
+    Returns the following information, for the VDF of the signage point at sp_total_iters.
+    cc and rc challenge hash
+    cc and rc input
+    cc and rc iterations
+    """
+
+    new_sub_slot: bool = len(finished_sub_slots) > 0
+    genesis_block: bool = prev_b is None
+
+    if new_sub_slot and not overflow:
+        # Case 1: start from start of this slot. Case of no overflow slots. Also includes genesis block after empty
+        # slot(s), but not overflowing
+        rc_vdf_challenge: bytes32 = finished_sub_slots[-1].reward_chain.get_hash()
+        cc_vdf_challenge = finished_sub_slots[-1].challenge_chain.get_hash()
+        sp_vdf_iters = sp_iters
+        cc_vdf_input = ClassgroupElement.get_default_element()
+    elif new_sub_slot and overflow and len(finished_sub_slots) > 1:
+        # Case 2: start from start of prev slot. This is a rare case of empty prev slot. Includes genesis block after
+        # 2 empty slots
+        rc_vdf_challenge = finished_sub_slots[-2].reward_chain.get_hash()
+        cc_vdf_challenge = finished_sub_slots[-2].challenge_chain.get_hash()
+        sp_vdf_iters = sp_iters
+        cc_vdf_input = ClassgroupElement.get_default_element()
+    elif genesis_block:
+        # Case 3: Genesis block case, first challenge
+        rc_vdf_challenge = constants.GENESIS_CHALLENGE
+        cc_vdf_challenge = constants.GENESIS_CHALLENGE
+        sp_vdf_iters = sp_iters
+        cc_vdf_input = ClassgroupElement.get_default_element()
+    elif new_sub_slot and overflow and len(finished_sub_slots) == 1:
+        # Case 4: Starting at prev will put us in the previous, sub-slot, since case 2 handled more empty slots
+        assert prev_b is not None
+        curr: BlockRecord = prev_b
+        while not curr.first_in_sub_slot and curr.total_iters > sp_total_iters:
+            curr = blocks.block_record(curr.prev_hash)
+        if curr.total_iters < sp_total_iters:
+            sp_vdf_iters = uint64(sp_total_iters - curr.total_iters)
+            cc_vdf_input = curr.challenge_vdf_output
+            rc_vdf_challenge = curr.reward_infusion_new_challenge
+        else:
+            assert curr.finished_reward_slot_hashes is not None
+            sp_vdf_iters = sp_iters
+            cc_vdf_input = ClassgroupElement.get_default_element()
+            rc_vdf_challenge = curr.finished_reward_slot_hashes[-1]
+
+        while not curr.first_in_sub_slot:
+            curr = blocks.block_record(curr.prev_hash)
+        assert curr.finished_challenge_slot_hashes is not None
+        cc_vdf_challenge = curr.finished_challenge_slot_hashes[-1]
+    elif not new_sub_slot and overflow:
+        # Case 5: prev is in the same sub slot and also overflow. Starting at prev does not skip any sub slots
+        assert prev_b is not None
+        curr = prev_b
+
+        # Collects the last two finished slots
+        if curr.first_in_sub_slot:
+            assert curr.finished_challenge_slot_hashes is not None
+            assert curr.finished_reward_slot_hashes is not None
+            found_sub_slots = list(
+                reversed(
+                    list(
+                        zip(
+                            curr.finished_challenge_slot_hashes,
+                            curr.finished_reward_slot_hashes,
+                        )
+                    )
+                )
+            )
+        else:
+            found_sub_slots = []
+        sp_pre_sb: Optional[BlockRecord] = None
+        while len(found_sub_slots) < 2 and curr.height > 0:
+            if sp_pre_sb is None and curr.total_iters < sp_total_iters:
+                sp_pre_sb = curr
+            curr = blocks.block_record(curr.prev_hash)
+            if curr.first_in_sub_slot:
+                assert curr.finished_challenge_slot_hashes is not None
+                assert curr.finished_reward_slot_hashes is not None
+                found_sub_slots += list(
+                    reversed(
+                        list(
+                            zip(
+                                curr.finished_challenge_slot_hashes,
+                                curr.finished_reward_slot_hashes,
+                            )
+                        )
+                    )
+                )
+        if sp_pre_sb is None and curr.total_iters < sp_total_iters:
+            sp_pre_sb = curr
+        if sp_pre_sb is not None:
+            sp_vdf_iters = uint64(sp_total_iters - sp_pre_sb.total_iters)
+            cc_vdf_input = sp_pre_sb.challenge_vdf_output
+            rc_vdf_challenge = sp_pre_sb.reward_infusion_new_challenge
+        else:
+            sp_vdf_iters = sp_iters
+            cc_vdf_input = ClassgroupElement.get_default_element()
+            rc_vdf_challenge = found_sub_slots[1][1]
+        cc_vdf_challenge = found_sub_slots[1][0]
+
+    elif not new_sub_slot and not overflow:
+        # Case 6: prev is in the same sub slot. Starting at prev does not skip any sub slots. We do not need
+        # to go back another sub slot, because it's not overflow, so the VDF to signage point is this sub-slot.
+        assert prev_b is not None
+        curr = prev_b
+        while not curr.first_in_sub_slot and curr.total_iters > sp_total_iters:
+            curr = blocks.block_record(curr.prev_hash)
+        if curr.total_iters < sp_total_iters:
+            sp_vdf_iters = uint64(sp_total_iters - curr.total_iters)
+            cc_vdf_input = curr.challenge_vdf_output
+            rc_vdf_challenge = curr.reward_infusion_new_challenge
+        else:
+            assert curr.finished_reward_slot_hashes is not None
+            sp_vdf_iters = sp_iters
+            cc_vdf_input = ClassgroupElement.get_default_element()
+            rc_vdf_challenge = curr.finished_reward_slot_hashes[-1]
+
+        while not curr.first_in_sub_slot:
+            curr = blocks.block_record(curr.prev_hash)
+        assert curr.finished_challenge_slot_hashes is not None
+        cc_vdf_challenge = curr.finished_challenge_slot_hashes[-1]
+    else:
+        # All cases are handled above
+        assert False
+
+    return (
+        cc_vdf_challenge,
+        rc_vdf_challenge,
+        cc_vdf_input,
+        ClassgroupElement.get_default_element(),
+        sp_vdf_iters,
+        sp_vdf_iters,
+    )

chia/daemon/client.py

@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import ssl
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any, Optional
+
+import aiohttp
+
+from chia.util.ints import uint32
+from chia.util.json_util import dict_to_json_str
+from chia.util.task_referencer import create_referenced_task
+from chia.util.ws_message import WsRpcMessage, create_payload_dict
+
+
+class DaemonProxy:
+    def __init__(
+        self,
+        uri: str,
+        ssl_context: Optional[ssl.SSLContext],
+        heartbeat: int,
+        max_message_size: int = 50 * 1000 * 1000,
+    ):
+        self._uri = uri
+        self._request_dict: dict[str, asyncio.Event] = {}
+        self.response_dict: dict[str, WsRpcMessage] = {}
+        self.ssl_context = ssl_context
+        self.heartbeat = heartbeat
+        self.client_session: Optional[aiohttp.ClientSession] = None
+        self.websocket: Optional[aiohttp.ClientWebSocketResponse] = None
+        self.max_message_size = max_message_size
+
+    def format_request(self, command: str, data: dict[str, Any]) -> WsRpcMessage:
+        request = create_payload_dict(command, data, "client", "daemon")
+        return request
+
+    async def start(self, wait_for_start: bool = False) -> None:
+        self.client_session = aiohttp.ClientSession()
+
+        connect_backoff = 2
+        while (self.websocket is None or self.websocket.closed) and connect_backoff <= 60:
+            try:
+                self.websocket = await self.client_session.ws_connect(
+                    self._uri,
+                    autoclose=True,
+                    autoping=True,
+                    heartbeat=self.heartbeat,
+                    ssl=self.ssl_context if self.ssl_context is not None else True,
+                    max_msg_size=self.max_message_size,
+                )
+                break
+            except aiohttp.ClientError:
+                if not wait_for_start:
+                    break
+                await asyncio.sleep(connect_backoff)
+                connect_backoff *= 2
+
+        if self.websocket is None or self.websocket.closed:
+            await self.close()
+            raise Exception("Failed to connect to daemon")
+
+        async def listener_task() -> None:
+            try:
+                await self.listener()
+            finally:
+                await self.close()
+
+        create_referenced_task(listener_task(), known_unreferenced=True)
+        await asyncio.sleep(1)
+
+    async def listener(self) -> None:
+        if self.websocket is None:
+            raise TypeError("Websocket is None in listener!")
+        while True:
+            message = await self.websocket.receive()
+            if message.type == aiohttp.WSMsgType.TEXT:
+                decoded: WsRpcMessage = json.loads(message.data)
+                request_id = decoded["request_id"]
+
+                if request_id in self._request_dict:
+                    self.response_dict[request_id] = decoded
+                    self._request_dict[request_id].set()
+            else:
+                return None
+
+    async def _get(self, request: WsRpcMessage) -> WsRpcMessage:
+        request_id = request["request_id"]
+        self._request_dict[request_id] = asyncio.Event()
+        string = dict_to_json_str(request)
+        if self.websocket is None or self.websocket.closed:
+            raise Exception("Websocket is not connected")
+        create_referenced_task(self.websocket.send_str(string), known_unreferenced=True)
+        try:
+            await asyncio.wait_for(self._request_dict[request_id].wait(), timeout=30)
+            self._request_dict.pop(request_id)
+            response: WsRpcMessage = self.response_dict[request_id]
+            self.response_dict.pop(request_id)
+            return response
+        except asyncio.TimeoutError:
+            self._request_dict.pop(request_id)
+            raise Exception(f"No response from daemon for request_id: {request_id}")
+
+    async def get_version(self) -> WsRpcMessage:
+        data: dict[str, Any] = {}
+        request = self.format_request("get_version", data)
+        response = await self._get(request)
+        return response
+
+    async def get_network_info(self) -> WsRpcMessage:
+        data: dict[str, Any] = {}
+        request = self.format_request("get_network_info", data)
+        response = await self._get(request)
+        return response
+
+    async def start_service(self, service_name: str) -> WsRpcMessage:
+        data = {"service": service_name}
+        request = self.format_request("start_service", data)
+        response = await self._get(request)
+        return response
+
+    async def stop_service(self, service_name: str, delay_before_kill: int = 15) -> WsRpcMessage:
+        data = {"service": service_name}
+        request = self.format_request("stop_service", data)
+        response = await self._get(request)
+        return response
+
+    async def is_running(self, service_name: str) -> bool:
+        data = {"service": service_name}
+        request = self.format_request("is_running", data)
+        response = await self._get(request)
+        if "is_running" in response["data"]:
+            return bool(response["data"]["is_running"])
+        return False
+
+    async def is_keyring_locked(self) -> bool:
+        data: dict[str, Any] = {}
+        request = self.format_request("is_keyring_locked", data)
+        response = await self._get(request)
+        if "is_keyring_locked" in response["data"]:
+            return bool(response["data"]["is_keyring_locked"])
+        return False
+
+    async def unlock_keyring(self, passphrase: str) -> WsRpcMessage:
+        data = {"key": passphrase}
+        request = self.format_request("unlock_keyring", data)
+        response = await self._get(request)
+        return response
+
+    async def ping(self) -> WsRpcMessage:
+        request = self.format_request("ping", {})
+        response = await self._get(request)
+        return response
+
+    async def close(self) -> None:
+        if self.websocket is not None:
+            await self.websocket.close()
+        if self.client_session is not None:
+            await self.client_session.close()
+
+    async def exit(self) -> WsRpcMessage:
+        request = self.format_request("exit", {})
+        return await self._get(request)
+
+    async def get_keys_for_plotting(self, fingerprints: Optional[list[uint32]] = None) -> WsRpcMessage:
+        data = {"fingerprints": fingerprints} if fingerprints else {}
+        request = self.format_request("get_keys_for_plotting", data)
+        response = await self._get(request)
+        return response
+
+
+async def connect_to_daemon(
+    self_hostname: str,
+    daemon_port: int,
+    max_message_size: int,
+    ssl_context: ssl.SSLContext,
+    heartbeat: int,
+    wait_for_start: bool = False,
+) -> DaemonProxy:
+    """
+    Connect to the local daemon.
+    """
+
+    client = DaemonProxy(
+        f"wss://{self_hostname}:{daemon_port}",
+        ssl_context=ssl_context,
+        max_message_size=max_message_size,
+        heartbeat=heartbeat,
+    )
+
+    await client.start(wait_for_start=wait_for_start)
+    return client
+
+
+async def connect_to_daemon_and_validate(
+    root_path: Path, config: dict[str, Any], quiet: bool = False, wait_for_start: bool = False
+) -> Optional[DaemonProxy]:
+    """
+    Connect to the local daemon and do a ping to ensure that something is really
+    there and running.
+    """
+    from chia.server.server import ssl_context_for_client
+
+    try:
+        daemon_max_message_size = config.get("daemon_max_message_size", 50 * 1000 * 1000)
+        daemon_heartbeat = config.get("daemon_heartbeat", 300)
+        crt_path = root_path / config["daemon_ssl"]["private_crt"]
+        key_path = root_path / config["daemon_ssl"]["private_key"]
+        ca_crt_path = root_path / config["private_ssl_ca"]["crt"]
+        ca_key_path = root_path / config["private_ssl_ca"]["key"]
+        ssl_context = ssl_context_for_client(ca_crt_path, ca_key_path, crt_path, key_path)
+        connection = await connect_to_daemon(
+            config["self_hostname"],
+            config["daemon_port"],
+            max_message_size=daemon_max_message_size,
+            ssl_context=ssl_context,
+            heartbeat=daemon_heartbeat,
+            wait_for_start=wait_for_start,
+        )
+        r = await connection.ping()
+
+        if "value" in r["data"] and r["data"]["value"] == "pong":
+            return connection
+    except Exception:
+        if not quiet:
+            print("Daemon not started yet")
+        return None
+    return None
+
+
+@asynccontextmanager
+async def acquire_connection_to_daemon(
+    root_path: Path, config: dict[str, Any], quiet: bool = False
+) -> AsyncIterator[Optional[DaemonProxy]]:
+    """
+    Asynchronous context manager which attempts to create a connection to the daemon.
+    The connection object (DaemonProxy) is yielded to the caller. After the caller's
+    block exits scope, execution resumes in this function, wherein the connection is
+    closed.
+    """
+
+    daemon: Optional[DaemonProxy] = None
+    try:
+        daemon = await connect_to_daemon_and_validate(root_path, config, quiet=quiet)
+        yield daemon  # <----
+    except Exception as e:
+        print(f"Exception occurred while communicating with the daemon: {e}")
+    finally:
+        if daemon is not None:
+            await daemon.close()