wire service evrywhear

Author: almogdepaz

chia/_tests/conftest.py

@@ -58,6 +58,7 @@
     FarmerService,
     FullNodeService,
     HarvesterService,
+    SolverService,
     TimelordService,
     WalletService,
 )
@@ -70,6 +71,7 @@
     setup_full_node,
     setup_introducer,
     setup_seeder,
+    setup_solver,
     setup_timelord,
 )
 from chia.simulator.start_simulator import SimulatorFullNodeService
@@ -1115,6 +1117,12 @@ async def seeder_service(root_path_populated_with_config: Path, database_uri: st
         yield seeder
 
 
+@pytest.fixture(scope="function")
+async def solver_service(bt: BlockTools) -> AsyncIterator[SolverService]:
+    async with setup_solver(bt.root_path, bt.constants) as _:
+        yield _
+
+
 @pytest.fixture(scope="function")
 def tmp_chia_root(tmp_path):
     """

chia/_tests/solver/__init__.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import pytest
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint8, uint64
+
+from chia.protocols.solver_protocol import SolverInfo
+from chia.server.aliases import SolverService
+
+
+@pytest.mark.anyio
+async def test_solver_solve(solver_service: SolverService) -> None:
+    """Test that the solver service can process a solve request."""
+    solver = solver_service._node
+    solver_api = solver_service._api
+
+    # Create test SolverInfo
+    test_info = SolverInfo(plot_size=uint8(32), plot_diffculty=uint64(1000), quality_string=bytes32.zeros)
+
+    # Call solve directly on the solver
+    result = solver.solve(test_info)
+
+    # Should return None since it's not implemented
+    assert result is None
+
+    # Test through the API
+    api_result = await solver_api.solve(test_info)
+
+    # Should return None since solver.solve returns None
+    assert api_result is None

chia/_tests/solver/test_solver.py

@@ -33,6 +33,7 @@
     setup_full_node,
     setup_harvester,
     setup_introducer,
+    setup_solver,
     setup_timelord,
     setup_vdf_client,
     setup_vdf_clients,
@@ -469,6 +470,16 @@ async def setup_full_system_inner(
 
                 await asyncio.sleep(backoff)
 
+        setup_solver(
+            b_tools,
+            shared_b_tools.root_path / "harvester",
+            UnresolvedPeerInfo(self_hostname, farmer_service._server.get_port()),
+            consensus_constants,
+        )
+        # solver_service = await async_exit_stack.enter_async_context(
+
+        # )
+
         full_system = FullSystem(
             node_1=node_1,
             node_2=node_2,

chia/_tests/util/setup_nodes.py

@@ -65,6 +65,7 @@ class Capability(IntEnum):
     NodeType.INTRODUCER: _capabilities,
     NodeType.WALLET: _capabilities,
     NodeType.DATA_LAYER: _capabilities,
+    NodeType.SOLVER: [],
 }
 
 

chia/protocols/shared_protocol.py

@@ -2,16 +2,15 @@
 
 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_rs.sized_ints import uint8, uint64
 
 from chia.util.streamable import Streamable, streamable
 
 
 @streamable
 @dataclass(frozen=True)
 class SolverInfo(Streamable):
-    plot_size: PlotSize
+    plot_size: uint8
     plot_diffculty: uint64
     quality_string: bytes32

chia/protocols/solver_protocol.py

@@ -18,6 +18,8 @@
 from chia.seeder.crawler_api import CrawlerAPI
 from chia.seeder.crawler_rpc_api import CrawlerRpcApi
 from chia.server.start_service import Service
+from chia.solver.solver import Solver
+from chia.solver.solver_api import SolverAPI
 from chia.timelord.timelord import Timelord
 from chia.timelord.timelord_api import TimelordAPI
 from chia.timelord.timelord_rpc_api import TimelordRpcApi
@@ -33,3 +35,4 @@
 IntroducerService = Service[Introducer, IntroducerAPI, FullNodeRpcApi]
 TimelordService = Service[Timelord, TimelordAPI, TimelordRpcApi]
 WalletService = Service[WalletNode, WalletNodeAPI, WalletRpcApi]
+SolverService = Service[Solver, SolverAPI, FullNodeRpcApi]

chia/server/aliases.py

@@ -172,8 +172,14 @@ def create(
         private_cert_path, private_key_path = None, None
         public_cert_path, public_key_path = None, None
 
-        authenticated_client_types = {NodeType.HARVESTER}
-        authenticated_server_types = {NodeType.HARVESTER, NodeType.FARMER, NodeType.WALLET, NodeType.DATA_LAYER}
+        authenticated_client_types = {NodeType.HARVESTER, NodeType.SOLVER}
+        authenticated_server_types = {
+            NodeType.HARVESTER,
+            NodeType.FARMER,
+            NodeType.WALLET,
+            NodeType.DATA_LAYER,
+            NodeType.SOLVER,
+        }
 
         if local_type in authenticated_client_types:
             # Authenticated clients

chia/server/server.py

@@ -12,13 +12,13 @@
 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.aliases import SolverService
 from chia.server.signal_handlers import SignalHandlers
-from chia.server.start_service import RpcInfo, Service, async_run
+from chia.server.start_service import Service, async_run
+from chia.solver.solver import Solver
+from chia.solver.solver_api import SolverAPI
 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
@@ -30,28 +30,24 @@
 SERVICE_NAME = "solver"
 
 
-async def create_solver_service(
+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:
+) -> SolverService:
     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)
+    node = Solver(root_path, service_config, consensus_constants)
+    peer_api = SolverAPI(node)
+    network_id = service_config["selected_network"]
 
-    rpc_info: Optional[RpcInfo[FullNodeRpcApi]] = None
     if service_config.get("start_rpc_server", True):
         rpc_info = (FullNodeRpcApi, service_config["rpc_port"])
 
@@ -64,7 +60,6 @@ async def create_solver_service(
         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,
@@ -84,7 +79,7 @@ async def async_main(service_config: dict[str, Any], root_path: pathlib.Path) ->
     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)
+    service = 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()

chia/server/start_solver.py

@@ -28,6 +28,7 @@
     FullNodeService,
     HarvesterService,
     IntroducerService,
+    SolverService,
     TimelordService,
     WalletService,
 )
@@ -37,6 +38,7 @@
 from chia.server.start_full_node import create_full_node_service
 from chia.server.start_harvester import create_harvester_service
 from chia.server.start_introducer import create_introducer_service
+from chia.server.start_solver import create_solver_service
 from chia.server.start_timelord import create_timelord_service
 from chia.server.start_wallet import create_wallet_service
 from chia.simulator.block_tools import BlockTools, test_constants
@@ -506,3 +508,27 @@ async def setup_timelord(
 
     async with service.manage():
         yield service
+
+
+@asynccontextmanager
+async def setup_solver(
+    root_path: Path,
+    consensus_constants: ConsensusConstants,
+    start_service: bool = True,
+) -> AsyncGenerator[SolverService, None]:
+    with create_lock_and_load_config(root_path / "config" / "ssl" / "ca", root_path) as config:
+        config["logging"]["log_stdout"] = True
+        config["solver"]["enable_upnp"] = True
+        config["solver"]["selected_network"] = "testnet0"
+        config["solver"]["port"] = 0
+        config["solver"]["rpc_port"] = 0
+        config["solver"]["num_threads"] = 1
+        save_config(root_path, "config.yaml", config)
+    service = create_solver_service(
+        root_path,
+        config,
+        consensus_constants,
+    )
+
+    async with service.manage(start=start_service):
+        yield service