chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7rc2__py3-none-any.whl

chia/data_layer/download_data.py

@@ -8,49 +8,21 @@ from pathlib import Path
 from typing import Optional
 
 import aiohttp
+from chia_rs.datalayer import DeltaReader
 from chia_rs.sized_bytes import bytes32
 from typing_extensions import Literal
 
-from chia.data_layer.data_layer_util import NodeType, PluginRemote, Root, SerializedNode, ServerInfo, Status
+from chia.data_layer.data_layer_util import (
+    PluginRemote,
+    Root,
+    ServerInfo,
+    get_delta_filename,
+    get_delta_filename_path,
+    get_full_tree_filename,
+    get_full_tree_filename_path,
+)
 from chia.data_layer.data_store import DataStore
-
-
-def get_full_tree_filename(store_id: bytes32, node_hash: bytes32, generation: int, group_by_store: bool = False) -> str:
-    if group_by_store:
-        return f"{store_id}/{node_hash}-full-{generation}-v1.0.dat"
-    return f"{store_id}-{node_hash}-full-{generation}-v1.0.dat"
-
-
-def get_delta_filename(store_id: bytes32, node_hash: bytes32, generation: int, group_by_store: bool = False) -> str:
-    if group_by_store:
-        return f"{store_id}/{node_hash}-delta-{generation}-v1.0.dat"
-    return f"{store_id}-{node_hash}-delta-{generation}-v1.0.dat"
-
-
-def get_full_tree_filename_path(
-    foldername: Path,
-    store_id: bytes32,
-    node_hash: bytes32,
-    generation: int,
-    group_by_store: bool = False,
-) -> Path:
-    if group_by_store:
-        path = foldername.joinpath(f"{store_id}")
-        return path.joinpath(f"{node_hash}-full-{generation}-v1.0.dat")
-    return foldername.joinpath(f"{store_id}-{node_hash}-full-{generation}-v1.0.dat")
-
-
-def get_delta_filename_path(
-    foldername: Path,
-    store_id: bytes32,
-    node_hash: bytes32,
-    generation: int,
-    group_by_store: bool = False,
-) -> Path:
-    if group_by_store:
-        path = foldername.joinpath(f"{store_id}")
-        return path.joinpath(f"{node_hash}-delta-{generation}-v1.0.dat")
-    return foldername.joinpath(f"{store_id}-{node_hash}-delta-{generation}-v1.0.dat")
+from chia.util.log_exceptions import log_exceptions
 
 
 def is_filename_valid(filename: str, group_by_store: bool = False) -> bool:
@@ -87,45 +59,6 @@ def is_filename_valid(filename: str, group_by_store: bool = False) -> bool:
     return reformatted == filename
 
 
-async def insert_into_data_store_from_file(
-    data_store: DataStore,
-    store_id: bytes32,
-    root_hash: Optional[bytes32],
-    filename: Path,
-) -> int:
-    num_inserted = 0
-    with open(filename, "rb") as reader:
-        while True:
-            chunk = b""
-            while len(chunk) < 4:
-                size_to_read = 4 - len(chunk)
-                cur_chunk = reader.read(size_to_read)
-                if cur_chunk is None or cur_chunk == b"":
-                    if size_to_read < 4:
-                        raise Exception("Incomplete read of length.")
-                    break
-                chunk += cur_chunk
-            if chunk == b"":
-                break
-
-            size = int.from_bytes(chunk, byteorder="big")
-            serialize_nodes_bytes = b""
-            while len(serialize_nodes_bytes) < size:
-                size_to_read = size - len(serialize_nodes_bytes)
-                cur_chunk = reader.read(size_to_read)
-                if cur_chunk is None or cur_chunk == b"":
-                    raise Exception("Incomplete read of blob.")
-                serialize_nodes_bytes += cur_chunk
-            serialized_node = SerializedNode.from_bytes(serialize_nodes_bytes)
-
-            node_type = NodeType.TERMINAL if serialized_node.is_terminal else NodeType.INTERNAL
-            await data_store.insert_node(node_type, serialized_node.value1, serialized_node.value2)
-            num_inserted += 1
-
-    await data_store.insert_root_with_ancestor_table(store_id=store_id, node_hash=root_hash, status=Status.COMMITTED)
-    return num_inserted
-
-
 @dataclass
 class WriteFilesResult:
     result: bool
@@ -165,14 +98,8 @@ async def write_files_for_root(
             pass
 
     try:
-        last_seen_generation = await data_store.get_last_tree_root_by_hash(
-            store_id, root.node_hash, max_generation=root.generation
-        )
-        if last_seen_generation is None:
-            with open(filename_diff_tree, mode) as writer:
-                await data_store.write_tree_to_file(root, node_hash, store_id, True, writer)
-        else:
-            open(filename_diff_tree, mode).close()
+        with open(filename_diff_tree, mode) as writer:
+            await data_store.write_tree_to_file(root, node_hash, store_id, True, writer)
         written = True
     except FileExistsError:
         pass
@@ -250,6 +177,8 @@ async def insert_from_delta_file(
     if group_files_by_store:
         client_foldername.joinpath(f"{store_id}").mkdir(parents=True, exist_ok=True)
 
+    delta_reader: Optional[DeltaReader] = None
+
     for root_hash in root_hashes:
         timestamp = int(time.time())
         existing_generation += 1
@@ -281,33 +210,34 @@ async def insert_from_delta_file(
 
         log.info(f"Successfully downloaded delta file {target_filename_path.name}.")
         try:
-            filename_full_tree = get_full_tree_filename_path(
-                client_foldername,
-                store_id,
-                root_hash,
-                existing_generation,
-                group_files_by_store,
-            )
-            num_inserted = await insert_into_data_store_from_file(
-                data_store,
-                store_id,
-                None if root_hash == bytes32.zeros else root_hash,
-                target_filename_path,
-            )
-            log.info(
-                f"Successfully inserted hash {root_hash} from delta file. "
-                f"Generation: {existing_generation}. Store id: {store_id}. Nodes inserted: {num_inserted}."
-            )
-
-            if target_generation - existing_generation <= maximum_full_file_count - 1:
-                root = await data_store.get_tree_root(store_id=store_id)
-                with open(filename_full_tree, "wb") as writer:
-                    await data_store.write_tree_to_file(root, root_hash, store_id, False, writer)
-                log.info(f"Successfully written full tree filename {filename_full_tree}.")
-            else:
-                log.info(f"Skipping full file generation for {existing_generation}")
-
-            await data_store.received_correct_file(store_id, server_info)
+            with log_exceptions(log=log, message="exception while inserting from delta file"):
+                filename_full_tree = get_full_tree_filename_path(
+                    client_foldername,
+                    store_id,
+                    root_hash,
+                    existing_generation,
+                    group_files_by_store,
+                )
+                delta_reader = await data_store.insert_into_data_store_from_file(
+                    store_id,
+                    None if root_hash == bytes32.zeros else root_hash,
+                    target_filename_path,
+                    delta_reader=delta_reader,
+                )
+                log.info(
+                    f"Successfully inserted hash {root_hash} from delta file. "
+                    f"Generation: {existing_generation}. Store id: {store_id}."
+                )
+
+                if target_generation - existing_generation <= maximum_full_file_count - 1:
+                    root = await data_store.get_tree_root(store_id=store_id)
+                    with open(filename_full_tree, "wb") as writer:
+                        await data_store.write_tree_to_file(root, root_hash, store_id, False, writer)
+                    log.info(f"Successfully written full tree filename {filename_full_tree}.")
+                else:
+                    log.info(f"Skipping full file generation for {existing_generation}")
+
+                await data_store.received_correct_file(store_id, server_info)
         except Exception:
             try:
                 target_filename_path.unlink()
@@ -326,7 +256,6 @@ async def insert_from_delta_file(
             if not filename_exists:
                 # Don't penalize this server if we didn't download the file from it.
                 await data_store.server_misses_file(store_id, server_info, timestamp)
-            await data_store.rollback_to_generation(store_id, existing_generation - 1)
             return False
 
     return True
@@ -386,4 +315,4 @@ async def http_download(
                     new_percentage = f"{progress_byte / size:.0%}"
                     if new_percentage != progress_percentage:
                         progress_percentage = new_percentage
-                        log.debug(f"Downloading delta file {filename}. {progress_percentage} of {size} bytes.")
+                        log.info(f"Downloading delta file {filename}. {progress_percentage} of {size} bytes.")

chia/{server → data_layer}/start_data_layer.py

@@ -12,10 +12,10 @@ from chia.apis import ApiProtocolRegistry
 from chia.data_layer.data_layer import DataLayer
 from chia.data_layer.data_layer_api import DataLayerAPI
 from chia.data_layer.data_layer_rpc_api import DataLayerRpcApi
+from chia.data_layer.data_layer_service import DataLayerService
 from chia.data_layer.data_layer_util import PluginRemote
 from chia.data_layer.util.plugin import load_plugin_configurations
 from chia.protocols.outbound_message import NodeType
-from chia.server.aliases import DataLayerService, WalletService
 from chia.server.signal_handlers import SignalHandlers
 from chia.server.start_service import RpcInfo, Service, async_run
 from chia.ssl.create_ssl import create_all_ssl
@@ -24,6 +24,7 @@ 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
 from chia.wallet.wallet_rpc_client import WalletRpcClient
+from chia.wallet.wallet_service import WalletService
 
 # See: https://bugs.python.org/issue29288
 "".encode("idna")

chia/data_layer/util/benchmark.py

@@ -6,15 +6,14 @@ import sys
 import tempfile
 import time
 from pathlib import Path
-from typing import Optional
 
 from chia_rs.sized_bytes import bytes32
 
-from chia.data_layer.data_layer_util import Side, TerminalNode, leaf_hash
+from chia.data_layer.data_layer_util import Side, Status, leaf_hash
 from chia.data_layer.data_store import DataStore
 
 
-async def generate_datastore(num_nodes: int, slow_mode: bool) -> None:
+async def generate_datastore(num_nodes: int) -> None:
     with tempfile.TemporaryDirectory() as temp_directory:
         temp_directory_path = Path(temp_directory)
         db_path = temp_directory_path.joinpath("dl_benchmark.sqlite")
@@ -23,9 +22,14 @@ async def generate_datastore(num_nodes: int, slow_mode: bool) -> None:
         if os.path.exists(db_path):
             os.remove(db_path)
 
-        async with DataStore.managed(database=db_path) as data_store:
+        start_time = time.monotonic()
+        async with DataStore.managed(
+            database=db_path,
+            merkle_blobs_path=temp_directory_path.joinpath("merkle-blobs"),
+            key_value_blobs_path=temp_directory_path.joinpath("key-value-blobs"),
+        ) as data_store:
             store_id = bytes32(b"0" * 32)
-            await data_store.create_tree(store_id)
+            await data_store.create_tree(store_id, status=Status.COMMITTED)
 
             insert_time = 0.0
             insert_count = 0
@@ -37,58 +41,40 @@ async def generate_datastore(num_nodes: int, slow_mode: bool) -> None:
             for i in range(num_nodes):
                 key = i.to_bytes(4, byteorder="big")
                 value = (2 * i).to_bytes(4, byteorder="big")
-                seed = leaf_hash(key=key, value=value)
-                reference_node_hash: Optional[bytes32] = await data_store.get_terminal_node_for_seed(store_id, seed)
-                side: Optional[Side] = data_store.get_side_for_seed(seed)
+                seed = leaf_hash(key, value)
+                node = await data_store.get_terminal_node_for_seed(seed, store_id)
 
-                if i == 0:
-                    reference_node_hash = None
-                    side = None
                 if i % 3 == 0:
                     t1 = time.time()
-                    if not slow_mode:
-                        await data_store.insert(
-                            key=key,
-                            value=value,
-                            store_id=store_id,
-                            reference_node_hash=reference_node_hash,
-                            side=side,
-                        )
-                    else:
-                        await data_store.insert(
-                            key=key,
-                            value=value,
-                            store_id=store_id,
-                            reference_node_hash=reference_node_hash,
-                            side=side,
-                            use_optimized=False,
-                        )
+                    await data_store.autoinsert(
+                        key=key,
+                        value=value,
+                        store_id=store_id,
+                        status=Status.COMMITTED,
+                    )
                     t2 = time.time()
-                    insert_time += t2 - t1
-                    insert_count += 1
+                    autoinsert_count += 1
                 elif i % 3 == 1:
+                    assert node is not None
+                    reference_node_hash = node.hash
+                    side_seed = bytes(seed)[0]
+                    side = Side.LEFT if side_seed < 128 else Side.RIGHT
                     t1 = time.time()
-                    if not slow_mode:
-                        await data_store.autoinsert(key=key, value=value, store_id=store_id)
-                    else:
-                        await data_store.autoinsert(
-                            key=key,
-                            value=value,
-                            store_id=store_id,
-                            use_optimized=False,
-                        )
+                    await data_store.insert(
+                        key=key,
+                        value=value,
+                        store_id=store_id,
+                        reference_node_hash=reference_node_hash,
+                        side=side,
+                        status=Status.COMMITTED,
+                    )
                     t2 = time.time()
-                    autoinsert_time += t2 - t1
-                    autoinsert_count += 1
+                    insert_time += t2 - t1
+                    insert_count += 1
                 else:
                     t1 = time.time()
-                    assert reference_node_hash is not None
-                    node = await data_store.get_node(reference_node_hash)
-                    assert isinstance(node, TerminalNode)
-                    if not slow_mode:
-                        await data_store.delete(key=node.key, store_id=store_id)
-                    else:
-                        await data_store.delete(key=node.key, store_id=store_id, use_optimized=False)
+                    assert node is not None
+                    await data_store.delete(key=node.key, store_id=store_id, status=Status.COMMITTED)
                     t2 = time.time()
                     delete_time += t2 - t1
                     delete_count += 1
@@ -96,13 +82,12 @@ async def generate_datastore(num_nodes: int, slow_mode: bool) -> None:
             print(f"Average insert time: {insert_time / insert_count}")
             print(f"Average autoinsert time: {autoinsert_time / autoinsert_count}")
             print(f"Average delete time: {delete_time / delete_count}")
-            print(f"Total time for {num_nodes} operations: {insert_time + autoinsert_time + delete_time}")
+            print(f"Total time for {num_nodes} operations: {insert_time + delete_time + autoinsert_time}")
             root = await data_store.get_tree_root(store_id=store_id)
             print(f"Root hash: {root.node_hash}")
+            finish_time = time.monotonic()
+            print(f"Total runtime: {finish_time - start_time}")
 
 
 if __name__ == "__main__":
-    slow_mode = False
-    if len(sys.argv) > 2 and sys.argv[2] == "slow":
-        slow_mode = True
-    asyncio.run(generate_datastore(int(sys.argv[1]), slow_mode))
+    asyncio.run(generate_datastore(int(sys.argv[1])))

chia/farmer/farmer.py

@@ -143,6 +143,9 @@ class Farmer:
         # Quality string to plot identifier and challenge_hash, for use with harvester.RequestSignatures
         self.quality_str_to_identifiers: dict[bytes32, tuple[str, bytes32, bytes32, bytes32]] = {}
 
+        # Track pending solver requests, keyed by partial proof
+        self.pending_solver_requests: dict[bytes, dict[str, Any]] = {}
+
         # number of responses to each signage point
         self.number_of_responses: dict[bytes32, int] = {}
 

chia/farmer/farmer_api.py

@@ -6,7 +6,7 @@ import time
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
 
 import aiohttp
-from chia_rs import AugSchemeMPL, G2Element, PlotSize, PoolTarget, PrivateKey
+from chia_rs import AugSchemeMPL, G2Element, PlotSize, PoolTarget, PrivateKey, ProofOfSpace
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64
 from packaging.version import Version
@@ -18,6 +18,7 @@ from chia.harvester.harvester_api import HarvesterAPI
 from chia.protocols import farmer_protocol, harvester_protocol
 from chia.protocols.farmer_protocol import DeclareProofOfSpace, SignedValues
 from chia.protocols.harvester_protocol import (
+    PartialProofsData,
     PlotSyncDone,
     PlotSyncPathList,
     PlotSyncPlotList,
@@ -34,6 +35,7 @@ from chia.protocols.pool_protocol import (
     get_current_authentication_token,
 )
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.protocols.solver_protocol import SolverInfo, SolverResponse
 from chia.server.api_protocol import ApiMetadata
 from chia.server.server import ssl_context_for_root
 from chia.server.ws_connection import WSChiaConnection
@@ -75,7 +77,7 @@ class FarmerAPI:
         """
         if new_proof_of_space.sp_hash not in self.farmer.number_of_responses:
             self.farmer.number_of_responses[new_proof_of_space.sp_hash] = 0
-            self.farmer.cache_add_time[new_proof_of_space.sp_hash] = uint64(int(time.time()))
+            self.farmer.cache_add_time[new_proof_of_space.sp_hash] = uint64(time.time())
 
         max_pos_per_sp = 5
 
@@ -172,14 +174,14 @@ class FarmerAPI:
                         new_proof_of_space.proof,
                     )
                 )
-                self.farmer.cache_add_time[new_proof_of_space.sp_hash] = uint64(int(time.time()))
+                self.farmer.cache_add_time[new_proof_of_space.sp_hash] = uint64(time.time())
                 self.farmer.quality_str_to_identifiers[computed_quality_string] = (
                     new_proof_of_space.plot_identifier,
                     new_proof_of_space.challenge_hash,
                     new_proof_of_space.sp_hash,
                     peer.peer_node_id,
                 )
-                self.farmer.cache_add_time[computed_quality_string] = uint64(int(time.time()))
+                self.farmer.cache_add_time[computed_quality_string] = uint64(time.time())
 
                 await peer.send_message(make_msg(ProtocolMessageTypes.request_signatures, request))
 
@@ -480,6 +482,103 @@ class FarmerAPI:
 
                 return
 
+    @metadata.request(peer_required=True)
+    async def partial_proofs(self, partial_proof_data: PartialProofsData, peer: WSChiaConnection) -> None:
+        """
+        This is a response from the harvester for V2 plots, containing only partial proof data.
+        We send these to the solver service and wait for a response with the full proof.
+        """
+        if partial_proof_data.sp_hash not in self.farmer.number_of_responses:
+            self.farmer.number_of_responses[partial_proof_data.sp_hash] = 0
+            self.farmer.cache_add_time[partial_proof_data.sp_hash] = uint64(time.time())
+
+        if partial_proof_data.sp_hash not in self.farmer.sps:
+            self.farmer.log.warning(
+                f"Received partial proofs for a signage point that we do not have {partial_proof_data.sp_hash}"
+            )
+            return None
+
+        self.farmer.cache_add_time[partial_proof_data.sp_hash] = uint64(time.time())
+
+        self.farmer.log.info(
+            f"Received V2 partial proof collection with {len(partial_proof_data.partial_proofs)} partail proofs "
+            f"for plot {partial_proof_data.plot_identifier[:10]}... from {peer.peer_node_id}"
+        )
+
+        # Process each partial proof chain through solver service to get full proofs
+        for partial_proof in partial_proof_data.partial_proofs:
+            solver_info = SolverInfo(partial_proof=partial_proof)
+
+            try:
+                # store pending request data for matching with response
+                self.farmer.pending_solver_requests[partial_proof] = {
+                    "proof_data": partial_proof_data,
+                    "peer": peer,
+                }
+
+                # send solve request to all solver connections
+                msg = make_msg(ProtocolMessageTypes.solve, solver_info)
+                await self.farmer.server.send_to_all([msg], NodeType.SOLVER)
+                self.farmer.log.debug(f"Sent solve request for partial proof {partial_proof.hex()[:10]}...")
+
+            except Exception as e:
+                self.farmer.log.error(
+                    f"Failed to call solver service for partial proof {partial_proof.hex()[:10]}...: {e}"
+                )
+                # clean up pending request
+                if partial_proof in self.farmer.pending_solver_requests:
+                    del self.farmer.pending_solver_requests[partial_proof]
+
+    @metadata.request()
+    async def solution_response(self, response: SolverResponse, peer: WSChiaConnection) -> None:
+        """
+        Handle solution response from solver service.
+        This is called when a solver responds to a solve request.
+        """
+        self.farmer.log.debug(f"Received solution response: {len(response.proof)} bytes from {peer.peer_node_id}")
+
+        # find the matching pending request using partial_proof
+
+        if response.partial_proof not in self.farmer.pending_solver_requests:
+            self.farmer.log.warning(
+                f"Received solver response for unknown partial proof {response.partial_proof.hex()}"
+            )
+            return
+
+        # get the original request data
+        request_data = self.farmer.pending_solver_requests.pop(response.partial_proof)
+        proof_data = request_data["proof_data"]
+        original_peer = request_data["peer"]
+        partial_proof = response.partial_proof
+
+        # create the proof of space with the solver's proof
+        proof_bytes = response.proof
+        if proof_bytes is None or len(proof_bytes) == 0:
+            self.farmer.log.warning(f"Received empty proof from solver for proof {partial_proof.hex()}...")
+            return
+
+        sp_challenge_hash = proof_data.challenge_hash
+        new_proof_of_space = harvester_protocol.NewProofOfSpace(
+            proof_data.challenge_hash,
+            proof_data.sp_hash,
+            proof_data.plot_identifier,
+            ProofOfSpace(
+                sp_challenge_hash,
+                proof_data.pool_public_key,
+                proof_data.pool_contract_puzzle_hash,
+                proof_data.plot_public_key,
+                proof_data.plot_size,
+                proof_bytes,
+            ),
+            proof_data.signage_point_index,
+            include_source_signature_data=False,
+            farmer_reward_address_override=None,
+            fee_info=None,
+        )
+
+        # process the proof of space
+        await self.new_proof_of_space(new_proof_of_space, original_peer)
+
     @metadata.request()
     async def respond_signatures(self, response: harvester_protocol.RespondSignatures) -> None:
         request = self._process_respond_signatures(response)
@@ -584,7 +683,7 @@ class FarmerAPI:
 
                     pool_dict[key] = strip_old_entries(pairs=pool_dict[key], before=cutoff_24h)
 
-        now = uint64(int(time.time()))
+        now = uint64(time.time())
         self.farmer.cache_add_time[new_signage_point.challenge_chain_sp] = now
         missing_signage_points = self.farmer.check_missing_signage_points(now, new_signage_point)
         self.farmer.state_changed(

chia/farmer/farmer_rpc_api.py

@@ -11,7 +11,10 @@ from typing_extensions import Protocol
 from chia.farmer.farmer import Farmer
 from chia.plot_sync.receiver import Receiver
 from chia.protocols.harvester_protocol import Plot
+from chia.protocols.outbound_message import NodeType
 from chia.rpc.rpc_server import Endpoint, EndpointResult
+from chia.types.peer_info import PeerInfo
+from chia.util.network import resolve
 from chia.util.paginator import Paginator
 from chia.util.streamable import Streamable, streamable
 from chia.util.ws_message import WsRpcMessage, create_payload_dict
@@ -102,6 +105,7 @@ class FarmerRpcApi:
             "/get_harvester_plots_keys_missing": self.get_harvester_plots_keys_missing,
             "/get_harvester_plots_duplicates": self.get_harvester_plots_duplicates,
             "/get_pool_login_link": self.get_pool_login_link,
+            "/connect_to_solver": self.connect_to_solver,
         }
 
     async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]]) -> list[WsRpcMessage]:
@@ -363,3 +367,19 @@ class FarmerRpcApi:
         if login_link is None:
             raise ValueError(f"Failed to generate login link for {launcher_id.hex()}")
         return {"login_link": login_link}
+
+    async def connect_to_solver(self, request: dict[str, Any]) -> EndpointResult:
+        for connection in self.service.server.get_connections(NodeType.SOLVER):
+            host = connection.peer_info.host
+            port = connection.peer_server_port
+            await connection.close()
+            self.service.log.info(f"Disconnected from solver at {host}:{port}")
+        host = request["host"]
+        port = request["port"]
+        target_node = PeerInfo(await resolve(host), port)
+        on_connect = getattr(self.service, "on_connect", None)
+        if await self.service.server.start_client(target_node, on_connect):
+            self.service.log.info(f"Connected to solver at {host}:{port}")
+            return {"success": True}
+        else:
+            return {"success": False, "error": f"Could not connect to solver at {host}:{port}"}

chia/farmer/farmer_rpc_client.py

@@ -21,7 +21,7 @@ class FarmerRpcClient(RpcClient):
     async def get_signage_point(self, sp_hash: bytes32) -> Optional[dict[str, Any]]:
         try:
             return await self.fetch("get_signage_point", {"sp_hash": sp_hash.hex()})
-        except ValueError:
+        except ValueError:  # not synced
             return None
 
     async def get_signage_points(self) -> list[dict[str, Any]]:
@@ -83,5 +83,9 @@ class FarmerRpcClient(RpcClient):
         try:
             result = await self.fetch("get_pool_login_link", {"launcher_id": launcher_id.hex()})
             return cast(Optional[str], result["login_link"])
-        except ValueError:
+        except ValueError:  # not connected to pool.
             return None
+
+    async def connect_to_solver(self, host: str, port: int) -> dict[str, Any]:
+        """Connect farmer to specific solver"""
+        return await self.fetch("connect_to_solver", {"host": host, "port": port})

chia/farmer/farmer_service.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from chia.farmer.farmer import Farmer
+from chia.farmer.farmer_api import FarmerAPI
+from chia.farmer.farmer_rpc_api import FarmerRpcApi
+from chia.server.start_service import Service
+
+FarmerService = Service[Farmer, FarmerAPI, FarmerRpcApi]

chia/{server → farmer}/start_farmer.py

@@ -13,8 +13,8 @@ from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_o
 from chia.farmer.farmer import Farmer
 from chia.farmer.farmer_api import FarmerAPI
 from chia.farmer.farmer_rpc_api import FarmerRpcApi
+from chia.farmer.farmer_service import FarmerService
 from chia.protocols.outbound_message import NodeType
-from chia.server.aliases import FarmerService
 from chia.server.resolve_peer_info import get_unresolved_peer_infos
 from chia.server.signal_handlers import SignalHandlers
 from chia.server.start_service import RpcInfo, Service, async_run
@@ -62,7 +62,8 @@ def create_farmer_service(
         node_type=NodeType.FARMER,
         advertised_port=service_config["port"],
         service_name=SERVICE_NAME,
-        connect_peers=get_unresolved_peer_infos(service_config, NodeType.FULL_NODE),
+        connect_peers=get_unresolved_peer_infos(service_config, NodeType.FULL_NODE)
+        | get_unresolved_peer_infos(service_config, NodeType.SOLVER),
         on_connect_callback=node.on_connect,
         network_id=network_id,
         rpc_info=rpc_info,
@@ -73,7 +74,7 @@ def create_farmer_service(
 
 async def async_main(root_path: pathlib.Path) -> int:
     # TODO: refactor to avoid the double load
-    config = load_config(root_path, "config.yaml")
+    config = load_config(root_path, "config.yaml", fill_missing_services=True)
     service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME)
     config[SERVICE_NAME] = service_config
     config_pool = load_config_cli(root_path, "config.yaml", "pool")