add solver service

Author: almogdepaz

chia/protocols/farmer_protocol.py

@@ -105,3 +105,10 @@ class SignedValues(Streamable):
     quality_string: bytes32
     foliage_block_data_signature: G2Element
     foliage_transaction_block_signature: G2Element
+
+
+
+@streamable
+@dataclass(frozen=True)
+class SolutionResponse(Streamable):
+    proof: bytes

chia/protocols/outbound_message.py

@@ -18,6 +18,7 @@ class NodeType(IntEnum):
     INTRODUCER = 5
     WALLET = 6
     DATA_LAYER = 7
+    SOLVER = 8
 
 
 @streamable

chia/protocols/protocol_message_types.py

@@ -136,4 +136,10 @@ class ProtocolMessageTypes(Enum):
     request_cost_info = 106
     respond_cost_info = 107
 
+    # new farmer protocol messages
+    solution_resonse = 108
+
+    # solver protocol
+    solve = 109
+
     error = 255

chia/protocols/solver_protocol.py

@@ -0,0 +1,17 @@
+
+from dataclasses import dataclass
+
+from chia_rs import PlotSize
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint64
+from chia.util.streamable import Streamable, streamable
+
+
+
+
+@streamable
+@dataclass(frozen=True)
+class SolverInfo(Streamable):
+    plot_size: PlotSize  
+    plot_diffculty: uint64
+    quality_string: bytes32

chia/server/start_solver.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import os
+import pathlib
+import sys
+from multiprocessing import freeze_support
+from typing import Any, Optional
+
+from chia_rs import ConsensusConstants
+from chia_rs.sized_ints import uint16
+
+from chia.apis import ApiProtocolRegistry
+from chia.consensus.constants import replace_str_to_bytes
+from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
+from chia.full_node.full_node import FullNode
+from chia.full_node.full_node_api import FullNodeAPI
+from chia.full_node.full_node_rpc_api import FullNodeRpcApi
+from chia.protocols.outbound_message import NodeType
+from chia.server.aliases import FullNodeService
+from chia.server.signal_handlers import SignalHandlers
+from chia.server.start_service import RpcInfo, Service, async_run
+from chia.util.chia_logging import initialize_service_logging
+from chia.util.config import load_config, load_config_cli
+from chia.util.default_root import resolve_root_path
+from chia.util.task_timing import maybe_manage_task_instrumentation
+
+# See: https://bugs.python.org/issue29288
+"".encode("idna")
+
+SERVICE_NAME = "solver"
+
+
+async def create_solver_service(
+    root_path: pathlib.Path,
+    config: dict[str, Any],
+    consensus_constants: ConsensusConstants,
+    connect_to_daemon: bool = True,
+    override_capabilities: Optional[list[tuple[uint16, str]]] = None,
+) -> FullNodeService:
+    service_config = config[SERVICE_NAME]
+
+    network_id = service_config["selected_network"]
+    upnp_list = []
+    if service_config["enable_upnp"]:
+        upnp_list = [service_config["port"]]
+
+    node = await FullNode.create(
+        service_config,
+        root_path=root_path,
+        consensus_constants=consensus_constants,
+    )
+    peer_api = FullNodeAPI(node)
+
+    rpc_info: Optional[RpcInfo[FullNodeRpcApi]] = None
+    if service_config.get("start_rpc_server", True):
+        rpc_info = (FullNodeRpcApi, service_config["rpc_port"])
+
+    return Service(
+        root_path=root_path,
+        config=config,
+        node=node,
+        peer_api=peer_api,
+        node_type=NodeType.SOLVER,
+        advertised_port=service_config["port"],
+        service_name=SERVICE_NAME,
+        upnp_ports=upnp_list,
+        # connect_peers=get_unresolved_peer_infos(service_config, NodeType.SOLVER),
+        on_connect_callback=node.on_connect,
+        network_id=network_id,
+        rpc_info=rpc_info,
+        connect_to_daemon=connect_to_daemon,
+        override_capabilities=override_capabilities,
+        class_for_type=ApiProtocolRegistry,
+    )
+
+
+async def async_main(service_config: dict[str, Any], root_path: pathlib.Path) -> int:
+    # TODO: refactor to avoid the double load
+    config = load_config(root_path, "config.yaml")
+    config[SERVICE_NAME] = service_config
+    network_id = service_config["selected_network"]
+    overrides = service_config["network_overrides"]["constants"][network_id]
+    update_testnet_overrides(network_id, overrides)
+    updated_constants = replace_str_to_bytes(DEFAULT_CONSTANTS, **overrides)
+    initialize_service_logging(service_name=SERVICE_NAME, config=config, root_path=root_path)
+
+    service = await create_solver_service(root_path, config, updated_constants)
+    async with SignalHandlers.manage() as signal_handlers:
+        await service.setup_process_global_state(signal_handlers=signal_handlers)
+        await service.run()
+
+    return 0
+
+
+def main() -> int:
+    freeze_support()
+    root_path = resolve_root_path(override=None)
+
+    with maybe_manage_task_instrumentation(
+        enable=os.environ.get(f"CHIA_INSTRUMENT_{SERVICE_NAME.upper()}") is not None
+    ):
+        service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME)
+        # target_peer_count = service_config.get("target_peer_count", 40) - service_config.get(
+        #     "target_outbound_peer_count", 8
+        # )
+        # if target_peer_count < 0:
+        #     target_peer_count = None
+        # if not service_config.get("use_chia_loop_policy", True):
+        #     target_peer_count = None
+        return async_run(coro=async_main(service_config, root_path=root_path))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

chia/solver/solver.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import asyncio
+import concurrent
+import contextlib
+import logging
+from collections.abc import AsyncIterator
+from concurrent.futures.thread import ThreadPoolExecutor
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+from chia_rs import ConsensusConstants
+from chia.protocols.solver_protocol import SolverInfo
+from chia.protocols.outbound_message import NodeType
+from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
+from chia.server.server import ChiaServer
+from chia.server.ws_connection import WSChiaConnection
+
+
+log = logging.getLogger(__name__)
+
+
+class Solver:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcServiceProtocol
+        _protocol_check: ClassVar[RpcServiceProtocol] = cast("Solver", None)
+
+    root_path: Path
+    _server: Optional[ChiaServer]    
+    _shut_down: bool
+    started: bool = False
+    executor: ThreadPoolExecutor
+    state_changed_callback: Optional[StateChangedProtocol] = None
+    constants: ConsensusConstants
+    event_loop: asyncio.events.AbstractEventLoop
+    
+    
+
+    @property
+    def server(self) -> ChiaServer:        
+        if self._server is None:
+            raise RuntimeError("server not assigned")
+
+        return self._server
+
+    def __init__(self, root_path: Path, config: dict[str, Any], constants: ConsensusConstants):
+        self.log = log
+        self.root_path = root_path
+        self._shut_down = False
+        self.executor = concurrent.futures.ThreadPoolExecutor(
+            max_workers=config["num_threads"], thread_name_prefix="solver-"
+        )
+        self._server = None
+        self.constants = constants
+        self.state_changed_callback: Optional[StateChangedProtocol] = None
+        
+
+
+    @contextlib.asynccontextmanager
+    async def manage(self) -> AsyncIterator[None]:
+        try:
+            self.started = True
+            yield
+        finally:
+            self._shut_down = True
+
+    def solve(self, info: SolverInfo) -> Optional[bytes]:        
+        return None
+
+    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
+        return default_get_connections(server=self.server, request_node_type=request_node_type)
+
+    async def on_connect(self, connection: WSChiaConnection) -> None:
+        pass
+
+
+    async def on_disconnect(self, connection: WSChiaConnection) -> None:
+        self.log.info(f"peer disconnected {connection.get_peer_logging()}")
+        
+
+    def set_server(self, server: ChiaServer) -> None:
+        self._server = server
+
+    def _set_state_changed_callback(self, callback: StateChangedProtocol) -> None:
+        self.state_changed_callback = callback
+    

chia/solver/solver_api.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import json
+import logging
+import time
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
+
+import aiohttp
+from chia.protocols.outbound_message import  make_msg
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint8, uint16, uint32, uint64
+
+from chia import __version__
+from chia.protocols.farmer_protocol import SolutionResponse
+from chia.protocols.outbound_message import Message
+from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.protocols.solver_protocol import SolverInfo
+from chia.server.api_protocol import ApiMetadata
+from chia.solver.solver import Solver
+
+
+
+class SolverAPI:
+    if TYPE_CHECKING:
+        from chia.server.api_protocol import ApiProtocol
+        _protocol_check: ClassVar[ApiProtocol] = cast("SolverAPI", None)
+
+    log: logging.Logger
+    solver: Solver
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
+
+    def __init__(self, solver: Solver) -> None:
+        self.log = logging.getLogger(__name__)
+        self.solver = solver
+
+    def ready(self) -> bool:
+        return self.solver.started
+
+    @metadata.request()
+    async def solve(
+        self,
+        request: SolverInfo,
+    ) -> Optional[Message]:        
+        if not self.solver.started:
+            raise RuntimeError("Solver is not started")
+
+        proof = self.solver.solve(request)
+        if proof is None:
+          return None
+        
+        response: SolutionResponse = SolutionResponse(
+            proof=proof,
+        )            
+        return make_msg(ProtocolMessageTypes.solution_resonse,response)
+