chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/rpc/full_node_rpc_client.py

@@ -0,0 +1,292 @@
+from __future__ import annotations
+
+from typing import Any, Optional, cast
+
+from chia.consensus.block_record import BlockRecord
+from chia.full_node.signage_point import SignagePoint
+from chia.rpc.rpc_client import RpcClient
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_record import CoinRecord
+from chia.types.coin_spend import CoinSpend, CoinSpendWithConditions
+from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
+from chia.types.full_block import FullBlock
+from chia.types.spend_bundle import SpendBundle
+from chia.types.unfinished_header_block import UnfinishedHeaderBlock
+from chia.util.ints import uint32
+
+
+def coin_record_dict_backwards_compat(coin_record: dict[str, Any]) -> dict[str, Any]:
+    del coin_record["spent"]
+    return coin_record
+
+
+class FullNodeRpcClient(RpcClient):
+    """
+    Client to Chia RPC, connects to a local full node. Uses HTTP/JSON, and converts back from
+    JSON into native python objects before returning. All api calls use POST requests.
+    Note that this is not the same as the peer protocol, or wallet protocol (which run Chia's
+    protocol on top of TCP), it's a separate protocol on top of HTTP that provides easy access
+    to the full node.
+    """
+
+    async def get_blockchain_state(self) -> dict[str, Any]:
+        response = await self.fetch("get_blockchain_state", {})
+        if response["blockchain_state"]["peak"] is not None:
+            response["blockchain_state"]["peak"] = BlockRecord.from_json_dict(response["blockchain_state"]["peak"])
+        return cast(dict[str, Any], response["blockchain_state"])
+
+    async def get_block(self, header_hash: bytes32) -> Optional[FullBlock]:
+        try:
+            response = await self.fetch("get_block", {"header_hash": header_hash.hex()})
+        except Exception:
+            return None
+        return FullBlock.from_json_dict(response["block"])
+
+    async def get_blocks(self, start: int, end: int, exclude_reorged: bool = False) -> list[FullBlock]:
+        response = await self.fetch(
+            "get_blocks", {"start": start, "end": end, "exclude_header_hash": True, "exclude_reorged": exclude_reorged}
+        )
+        return [FullBlock.from_json_dict(block) for block in response["blocks"]]
+
+    async def get_block_record_by_height(self, height: int) -> Optional[BlockRecord]:
+        try:
+            response = await self.fetch("get_block_record_by_height", {"height": height})
+        except Exception:
+            return None
+        return BlockRecord.from_json_dict(response["block_record"])
+
+    async def get_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
+        try:
+            response = await self.fetch("get_block_record", {"header_hash": header_hash.hex()})
+            if response["block_record"] is None:
+                return None
+        except Exception:
+            return None
+        return BlockRecord.from_json_dict(response["block_record"])
+
+    async def get_unfinished_block_headers(self) -> list[UnfinishedHeaderBlock]:
+        response = await self.fetch("get_unfinished_block_headers", {})
+        return [UnfinishedHeaderBlock.from_json_dict(r) for r in response["headers"]]
+
+    async def get_all_block(self, start: uint32, end: uint32) -> list[FullBlock]:
+        response = await self.fetch("get_blocks", {"start": start, "end": end, "exclude_header_hash": True})
+        return [FullBlock.from_json_dict(r) for r in response["blocks"]]
+
+    async def get_network_space(self, newer_block_header_hash: bytes32, older_block_header_hash: bytes32) -> int:
+        network_space_bytes_estimate = await self.fetch(
+            "get_network_space",
+            {
+                "newer_block_header_hash": newer_block_header_hash.hex(),
+                "older_block_header_hash": older_block_header_hash.hex(),
+            },
+        )
+
+        return cast(int, network_space_bytes_estimate["space"])
+
+    async def get_coin_record_by_name(self, coin_id: bytes32) -> Optional[CoinRecord]:
+        try:
+            response = await self.fetch("get_coin_record_by_name", {"name": coin_id.hex()})
+        except Exception:
+            return None
+
+        return CoinRecord.from_json_dict(coin_record_dict_backwards_compat(response["coin_record"]))
+
+    async def get_coin_records_by_names(
+        self,
+        names: list[bytes32],
+        include_spent_coins: bool = True,
+        start_height: Optional[int] = None,
+        end_height: Optional[int] = None,
+    ) -> list[CoinRecord]:
+        names_hex = [name.hex() for name in names]
+        d = {"names": names_hex, "include_spent_coins": include_spent_coins}
+        if start_height is not None:
+            d["start_height"] = start_height
+        if end_height is not None:
+            d["end_height"] = end_height
+
+        response = await self.fetch("get_coin_records_by_names", d)
+        return [CoinRecord.from_json_dict(coin_record_dict_backwards_compat(coin)) for coin in response["coin_records"]]
+
+    async def get_coin_records_by_puzzle_hash(
+        self,
+        puzzle_hash: bytes32,
+        include_spent_coins: bool = True,
+        start_height: Optional[int] = None,
+        end_height: Optional[int] = None,
+    ) -> list[CoinRecord]:
+        d = {"puzzle_hash": puzzle_hash.hex(), "include_spent_coins": include_spent_coins}
+        if start_height is not None:
+            d["start_height"] = start_height
+        if end_height is not None:
+            d["end_height"] = end_height
+
+        response = await self.fetch("get_coin_records_by_puzzle_hash", d)
+        return [CoinRecord.from_json_dict(coin_record_dict_backwards_compat(coin)) for coin in response["coin_records"]]
+
+    async def get_coin_records_by_puzzle_hashes(
+        self,
+        puzzle_hashes: list[bytes32],
+        include_spent_coins: bool = True,
+        start_height: Optional[int] = None,
+        end_height: Optional[int] = None,
+    ) -> list[CoinRecord]:
+        puzzle_hashes_hex = [ph.hex() for ph in puzzle_hashes]
+        d = {"puzzle_hashes": puzzle_hashes_hex, "include_spent_coins": include_spent_coins}
+        if start_height is not None:
+            d["start_height"] = start_height
+        if end_height is not None:
+            d["end_height"] = end_height
+
+        response = await self.fetch("get_coin_records_by_puzzle_hashes", d)
+        return [CoinRecord.from_json_dict(coin_record_dict_backwards_compat(coin)) for coin in response["coin_records"]]
+
+    async def get_coin_records_by_parent_ids(
+        self,
+        parent_ids: list[bytes32],
+        include_spent_coins: bool = True,
+        start_height: Optional[int] = None,
+        end_height: Optional[int] = None,
+    ) -> list[CoinRecord]:
+        parent_ids_hex = [pid.hex() for pid in parent_ids]
+        d = {"parent_ids": parent_ids_hex, "include_spent_coins": include_spent_coins}
+        if start_height is not None:
+            d["start_height"] = start_height
+        if end_height is not None:
+            d["end_height"] = end_height
+
+        response = await self.fetch("get_coin_records_by_parent_ids", d)
+        return [CoinRecord.from_json_dict(coin_record_dict_backwards_compat(coin)) for coin in response["coin_records"]]
+
+    async def get_aggsig_additional_data(self) -> bytes32:
+        result = await self.fetch("get_aggsig_additional_data", {})
+        return bytes32.from_hexstr(result["additional_data"])
+
+    async def get_coin_records_by_hint(
+        self,
+        hint: bytes32,
+        include_spent_coins: bool = True,
+        start_height: Optional[int] = None,
+        end_height: Optional[int] = None,
+    ) -> list[CoinRecord]:
+        d = {"hint": hint.hex(), "include_spent_coins": include_spent_coins}
+        if start_height is not None:
+            d["start_height"] = start_height
+        if end_height is not None:
+            d["end_height"] = end_height
+
+        response = await self.fetch("get_coin_records_by_hint", d)
+        return [CoinRecord.from_json_dict(coin_record_dict_backwards_compat(coin)) for coin in response["coin_records"]]
+
+    async def get_additions_and_removals(self, header_hash: bytes32) -> tuple[list[CoinRecord], list[CoinRecord]]:
+        try:
+            response = await self.fetch("get_additions_and_removals", {"header_hash": header_hash.hex()})
+        except Exception:
+            return [], []
+        removals = []
+        additions = []
+        for coin_record in response["removals"]:
+            removals.append(CoinRecord.from_json_dict(coin_record_dict_backwards_compat(coin_record)))
+        for coin_record in response["additions"]:
+            additions.append(CoinRecord.from_json_dict(coin_record_dict_backwards_compat(coin_record)))
+        return additions, removals
+
+    async def get_block_records(self, start: int, end: int) -> list[dict[str, Any]]:
+        try:
+            response = await self.fetch("get_block_records", {"start": start, "end": end})
+            if response["block_records"] is None:
+                return []
+        except Exception:
+            return []
+        # TODO: return block records
+        return cast(list[dict[str, Any]], response["block_records"])
+
+    async def get_block_spends(self, header_hash: bytes32) -> Optional[list[CoinSpend]]:
+        try:
+            response = await self.fetch("get_block_spends", {"header_hash": header_hash.hex()})
+            block_spends = []
+            for block_spend in response["block_spends"]:
+                block_spends.append(CoinSpend.from_json_dict(block_spend))
+            return block_spends
+        except Exception:
+            return None
+
+    async def get_block_spends_with_conditions(self, header_hash: bytes32) -> Optional[list[CoinSpendWithConditions]]:
+        try:
+            response = await self.fetch("get_block_spends_with_conditions", {"header_hash": header_hash.hex()})
+            block_spends: list[CoinSpendWithConditions] = []
+            for block_spend in response["block_spends_with_conditions"]:
+                block_spends.append(CoinSpendWithConditions.from_json_dict(block_spend))
+            return block_spends
+
+        except Exception:
+            return None
+
+    async def push_tx(self, spend_bundle: SpendBundle) -> dict[str, Any]:
+        return await self.fetch("push_tx", {"spend_bundle": spend_bundle.to_json_dict()})
+
+    async def get_puzzle_and_solution(self, coin_id: bytes32, height: uint32) -> Optional[CoinSpend]:
+        try:
+            response = await self.fetch("get_puzzle_and_solution", {"coin_id": coin_id.hex(), "height": height})
+            return CoinSpend.from_json_dict(response["coin_solution"])
+        except Exception:
+            return None
+
+    async def get_all_mempool_tx_ids(self) -> list[bytes32]:
+        response = await self.fetch("get_all_mempool_tx_ids", {})
+        return [bytes32.from_hexstr(tx_id_hex) for tx_id_hex in response["tx_ids"]]
+
+    async def get_all_mempool_items(self) -> dict[bytes32, dict[str, Any]]:
+        response = await self.fetch("get_all_mempool_items", {})
+        converted: dict[bytes32, dict[str, Any]] = {}
+        for tx_id_hex, item in response["mempool_items"].items():
+            converted[bytes32.from_hexstr(tx_id_hex)] = item
+        return converted
+
+    async def get_mempool_item_by_tx_id(
+        self,
+        tx_id: bytes32,
+        include_pending: bool = False,
+    ) -> Optional[dict[str, Any]]:
+        try:
+            response = await self.fetch(
+                "get_mempool_item_by_tx_id", {"tx_id": tx_id.hex(), "include_pending": include_pending}
+            )
+            return cast(dict[str, Any], response["mempool_item"])
+        except Exception:
+            return None
+
+    async def get_mempool_items_by_coin_name(self, coin_name: bytes32) -> dict[str, Any]:
+        response = await self.fetch("get_mempool_items_by_coin_name", {"coin_name": coin_name.hex()})
+        return response
+
+    async def get_recent_signage_point_or_eos(
+        self, sp_hash: Optional[bytes32], challenge_hash: Optional[bytes32]
+    ) -> Optional[Any]:
+        try:
+            if sp_hash is not None:
+                assert challenge_hash is None
+                response = await self.fetch("get_recent_signage_point_or_eos", {"sp_hash": sp_hash.hex()})
+                return {
+                    "signage_point": SignagePoint.from_json_dict(response["signage_point"]),
+                    "time_received": response["time_received"],
+                    "reverted": response["reverted"],
+                }
+            else:
+                assert challenge_hash is not None
+                response = await self.fetch("get_recent_signage_point_or_eos", {"challenge_hash": challenge_hash.hex()})
+                return {
+                    "eos": EndOfSubSlotBundle.from_json_dict(response["eos"]),
+                    "time_received": response["time_received"],
+                    "reverted": response["reverted"],
+                }
+        except Exception:
+            return None
+
+    async def get_fee_estimate(
+        self,
+        target_times: Optional[list[int]],
+        cost: Optional[int],
+    ) -> dict[str, Any]:
+        response = await self.fetch("get_fee_estimate", {"cost": cost, "target_times": target_times})
+        return response

chia/rpc/harvester_rpc_api.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+
+from chia.harvester.harvester import Harvester
+from chia.rpc.rpc_server import Endpoint, EndpointResult
+from chia.util.ints import uint32
+from chia.util.ws_message import WsRpcMessage, create_payload_dict
+
+
+class HarvesterRpcApi:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcApiProtocol
+
+        _protocol_check: ClassVar[RpcApiProtocol] = cast("HarvesterRpcApi", None)
+
+    def __init__(self, harvester: Harvester):
+        self.service = harvester
+        self.service_name = "chia_harvester"
+
+    def get_routes(self) -> dict[str, Endpoint]:
+        return {
+            "/get_plots": self.get_plots,
+            "/refresh_plots": self.refresh_plots,
+            "/delete_plot": self.delete_plot,
+            "/add_plot_directory": self.add_plot_directory,
+            "/get_plot_directories": self.get_plot_directories,
+            "/remove_plot_directory": self.remove_plot_directory,
+            "/get_harvester_config": self.get_harvester_config,
+            "/update_harvester_config": self.update_harvester_config,
+        }
+
+    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> list[WsRpcMessage]:
+        if change_data is None:
+            change_data = {}
+
+        payloads = []
+
+        if change == "plots":
+            data = await self.get_plots({})
+            payload = create_payload_dict("get_plots", data, self.service_name, "wallet_ui")
+            payloads.append(payload)
+
+        if change == "farming_info":
+            payloads.append(create_payload_dict("farming_info", change_data, self.service_name, "metrics"))
+            payloads.append(create_payload_dict("farming_info", change_data, self.service_name, "wallet_ui"))
+
+        if change == "add_connection":
+            payloads.append(create_payload_dict("add_connection", change_data, self.service_name, "metrics"))
+
+        if change == "close_connection":
+            payloads.append(create_payload_dict("close_connection", change_data, self.service_name, "metrics"))
+
+        return payloads
+
+    async def get_plots(self, _: dict[str, Any]) -> EndpointResult:
+        plots, failed_to_open, not_found = self.service.get_plots()
+        return {
+            "plots": plots,
+            "failed_to_open_filenames": failed_to_open,
+            "not_found_filenames": not_found,
+        }
+
+    async def refresh_plots(self, _: dict[str, Any]) -> EndpointResult:
+        self.service.plot_manager.trigger_refresh()
+        return {}
+
+    async def delete_plot(self, request: dict[str, Any]) -> EndpointResult:
+        filename = request["filename"]
+        if self.service.delete_plot(filename):
+            return {}
+        raise ValueError(f"Not able to delete file {filename}")
+
+    async def add_plot_directory(self, request: dict[str, Any]) -> EndpointResult:
+        directory_name = request["dirname"]
+        if await self.service.add_plot_directory(directory_name):
+            return {}
+        raise ValueError(f"Did not add plot directory {directory_name}")
+
+    async def get_plot_directories(self, _: dict[str, Any]) -> EndpointResult:
+        plot_dirs = await self.service.get_plot_directories()
+        return {"directories": plot_dirs}
+
+    async def remove_plot_directory(self, request: dict[str, Any]) -> EndpointResult:
+        directory_name = request["dirname"]
+        if await self.service.remove_plot_directory(directory_name):
+            return {}
+        raise ValueError(f"Did not remove plot directory {directory_name}")
+
+    async def get_harvester_config(self, _: dict[str, Any]) -> EndpointResult:
+        harvester_config = await self.service.get_harvester_config()
+        return {
+            "use_gpu_harvesting": harvester_config["use_gpu_harvesting"],
+            "gpu_index": harvester_config["gpu_index"],
+            "enforce_gpu_index": harvester_config["enforce_gpu_index"],
+            "disable_cpu_affinity": harvester_config["disable_cpu_affinity"],
+            "parallel_decompressor_count": harvester_config["parallel_decompressor_count"],
+            "decompressor_thread_count": harvester_config["decompressor_thread_count"],
+            "recursive_plot_scan": harvester_config["recursive_plot_scan"],
+            "refresh_parameter_interval_seconds": harvester_config["plots_refresh_parameter"].get("interval_seconds"),
+        }
+
+    async def update_harvester_config(self, request: dict[str, Any]) -> EndpointResult:
+        use_gpu_harvesting: Optional[bool] = None
+        gpu_index: Optional[int] = None
+        enforce_gpu_index: Optional[bool] = None
+        disable_cpu_affinity: Optional[bool] = None
+        parallel_decompressor_count: Optional[int] = None
+        decompressor_thread_count: Optional[int] = None
+        recursive_plot_scan: Optional[bool] = None
+        refresh_parameter_interval_seconds: Optional[uint32] = None
+        if "use_gpu_harvesting" in request:
+            use_gpu_harvesting = bool(request["use_gpu_harvesting"])
+        if "gpu_index" in request:
+            gpu_index = int(request["gpu_index"])
+        if "enforce_gpu_index" in request:
+            enforce_gpu_index = bool(request["enforce_gpu_index"])
+        if "disable_cpu_affinity" in request:
+            disable_cpu_affinity = bool(request["disable_cpu_affinity"])
+        if "parallel_decompressor_count" in request:
+            parallel_decompressor_count = int(request["parallel_decompressor_count"])
+        if "decompressor_thread_count" in request:
+            decompressor_thread_count = int(request["decompressor_thread_count"])
+        if "recursive_plot_scan" in request:
+            recursive_plot_scan = bool(request["recursive_plot_scan"])
+        if "refresh_parameter_interval_seconds" in request:
+            refresh_parameter_interval_seconds = uint32(request["refresh_parameter_interval_seconds"])
+            if refresh_parameter_interval_seconds < 3:
+                raise ValueError(f"Plot refresh interval seconds({refresh_parameter_interval_seconds}) is too short")
+
+        await self.service.update_harvester_config(
+            use_gpu_harvesting=use_gpu_harvesting,
+            gpu_index=gpu_index,
+            enforce_gpu_index=enforce_gpu_index,
+            disable_cpu_affinity=disable_cpu_affinity,
+            parallel_decompressor_count=parallel_decompressor_count,
+            decompressor_thread_count=decompressor_thread_count,
+            recursive_plot_scan=recursive_plot_scan,
+            refresh_parameter_interval_seconds=refresh_parameter_interval_seconds,
+        )
+        return {}

chia/rpc/harvester_rpc_client.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from chia.rpc.rpc_client import RpcClient
+
+
+class HarvesterRpcClient(RpcClient):
+    """
+    Client to Chia RPC, connects to a local harvester. Uses HTTP/JSON, and converts back from
+    JSON into native python objects before returning. All api calls use POST requests.
+    Note that this is not the same as the peer protocol, or wallet protocol (which run Chia's
+    protocol on top of TCP), it's a separate protocol on top of HTTP that provides easy access
+    to the full node.
+    """
+
+    async def get_plots(self) -> dict[str, Any]:
+        return await self.fetch("get_plots", {})
+
+    async def refresh_plots(self) -> None:
+        await self.fetch("refresh_plots", {})
+
+    async def delete_plot(self, filename: str) -> bool:
+        response = await self.fetch("delete_plot", {"filename": filename})
+        # TODO: casting due to lack of type checked deserialization
+        result = cast(bool, response["success"])
+        return result
+
+    async def add_plot_directory(self, dirname: str) -> bool:
+        response = await self.fetch("add_plot_directory", {"dirname": dirname})
+        # TODO: casting due to lack of type checked deserialization
+        result = cast(bool, response["success"])
+        return result
+
+    async def get_plot_directories(self) -> list[str]:
+        response = await self.fetch("get_plot_directories", {})
+        # TODO: casting due to lack of type checked deserialization
+        result = cast(list[str], response["directories"])
+        return result
+
+    async def remove_plot_directory(self, dirname: str) -> bool:
+        response = await self.fetch("remove_plot_directory", {"dirname": dirname})
+        # TODO: casting due to lack of type checked deserialization
+        result = cast(bool, response["success"])
+        return result
+
+    async def get_harvester_config(self) -> dict[str, Any]:
+        return await self.fetch("get_harvester_config", {})
+
+    async def update_harvester_config(self, config: dict[str, Any]) -> bool:
+        response = await self.fetch("update_harvester_config", config)
+        # TODO: casting due to lack of type checked deserialization
+        result = cast(bool, response["success"])
+        return result

chia/rpc/rpc_client.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from ssl import SSLContext
+from typing import Any, Optional, TypeVar
+
+import aiohttp
+
+from chia.server.outbound_message import NodeType
+from chia.server.server import ssl_context_for_client
+from chia.server.ssl_context import private_ssl_ca_paths
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.byte_types import hexstr_to_bytes
+from chia.util.ints import uint16
+from chia.util.task_referencer import create_referenced_task
+
+_T_RpcClient = TypeVar("_T_RpcClient", bound="RpcClient")
+
+
+# It would be better to not inherit from ValueError.  This is being done to separate
+# the possibility to identify these errors in new code from having to review and
+# clean up existing code.
+class ResponseFailureError(ValueError):
+    def __init__(self, response: dict[str, Any]):
+        self.response = response
+        super().__init__(f"RPC response failure: {json.dumps(response)}")
+
+
+@dataclass
+class RpcClient:
+    """
+    Client to Chia RPC, connects to a local service. Uses HTTP/JSON, and converts back from
+    JSON into native python objects before returning. All api calls use POST requests.
+    Note that this is not the same as the peer protocol, or wallet protocol (which run Chia's
+    protocol on top of TCP), it's a separate protocol on top of HTTP that provides easy access
+    to the full node.
+    """
+
+    url: str
+    session: aiohttp.ClientSession
+    ssl_context: Optional[SSLContext]
+    hostname: str
+    port: uint16
+    closing_task: Optional[asyncio.Task] = None
+
+    @classmethod
+    async def create(
+        cls: type[_T_RpcClient],
+        self_hostname: str,
+        port: uint16,
+        root_path: Optional[Path],
+        net_config: Optional[dict[str, Any]],
+    ) -> _T_RpcClient:
+        if (root_path is not None) != (net_config is not None):
+            raise ValueError("Either both or neither of root_path and net_config must be provided")
+
+        ssl_context: Optional[SSLContext]
+        if root_path is None:
+            scheme = "http"
+            ssl_context = None
+        else:
+            assert root_path is not None
+            assert net_config is not None
+            scheme = "https"
+            ca_crt_path, ca_key_path = private_ssl_ca_paths(root_path, net_config)
+            crt_path = root_path / net_config["daemon_ssl"]["private_crt"]
+            key_path = root_path / net_config["daemon_ssl"]["private_key"]
+            ssl_context = ssl_context_for_client(ca_crt_path, ca_key_path, crt_path, key_path)
+
+        timeout = 300
+        if net_config is not None:
+            timeout = net_config.get("rpc_timeout", timeout)
+
+        self = cls(
+            hostname=self_hostname,
+            port=port,
+            url=f"{scheme}://{self_hostname}:{port!s}/",
+            session=aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=timeout)),
+            ssl_context=ssl_context,
+        )
+
+        return self
+
+    @classmethod
+    @asynccontextmanager
+    async def create_as_context(
+        cls: type[_T_RpcClient],
+        self_hostname: str,
+        port: uint16,
+        root_path: Optional[Path] = None,
+        net_config: Optional[dict[str, Any]] = None,
+    ) -> AsyncIterator[_T_RpcClient]:
+        self = await cls.create(
+            self_hostname=self_hostname,
+            port=port,
+            root_path=root_path,
+            net_config=net_config,
+        )
+        try:
+            yield self
+        finally:
+            self.close()
+            await self.await_closed()
+
+    async def fetch(self, path, request_json) -> dict[str, Any]:
+        async with self.session.post(
+            self.url + path, json=request_json, ssl=self.ssl_context if self.ssl_context is not None else True
+        ) as response:
+            response.raise_for_status()
+            res_json = await response.json()
+            if not res_json["success"]:
+                raise ResponseFailureError(res_json)
+            return res_json
+
+    async def get_connections(self, node_type: Optional[NodeType] = None) -> list[dict]:
+        request = {}
+        if node_type is not None:
+            request["node_type"] = node_type.value
+        response = await self.fetch("get_connections", request)
+        for connection in response["connections"]:
+            connection["node_id"] = hexstr_to_bytes(connection["node_id"])
+        return response["connections"]
+
+    async def open_connection(self, host: str, port: int) -> dict:
+        return await self.fetch("open_connection", {"host": host, "port": int(port)})
+
+    async def close_connection(self, node_id: bytes32) -> dict:
+        return await self.fetch("close_connection", {"node_id": node_id.hex()})
+
+    async def stop_node(self) -> dict:
+        return await self.fetch("stop_node", {})
+
+    async def healthz(self) -> dict:
+        return await self.fetch("healthz", {})
+
+    async def get_network_info(self) -> dict:
+        return await self.fetch("get_network_info", {})
+
+    async def get_routes(self) -> dict:
+        return await self.fetch("get_routes", {})
+
+    async def get_version(self) -> dict:
+        return await self.fetch("get_version", {})
+
+    async def get_log_level(self) -> dict:
+        return await self.fetch("get_log_level", {})
+
+    async def set_log_level(self, level: str) -> dict:
+        return await self.fetch("set_log_level", {"level": level})
+
+    async def reset_log_level(self) -> dict:
+        return await self.fetch("reset_log_level", {})
+
+    def close(self) -> None:
+        self.closing_task = create_referenced_task(self.session.close())
+
+    async def await_closed(self) -> None:
+        if self.closing_task is not None:
+            await self.closing_task