connect to solver cli

Author: almogdepaz

chia/cmds/configure.py

@@ -36,6 +36,7 @@ def configure(
     crawler_minimum_version_count: Optional[int],
     seeder_domain_name: str,
     seeder_nameserver: str,
+    set_solver_trusted_peers_only: str,
 ) -> None:
     config_yaml = "config.yaml"
     with lock_and_load_config(root_path, config_yaml, fill_missing_services=True) as config:
@@ -63,11 +64,19 @@ def configure(
         if set_solver_peer:
             try:
                 host, port = parse_host_port(set_solver_peer)
+                # Set single solver peer (overrides any existing)
                 config["farmer"]["solver_peers"] = [{"host": host, "port": port}]
-                print("Solver peer updated for farmer")
+                print(f"Solver peer updated to {host}:{port}")
                 change_made = True
             except ValueError:
                 print("Solver address must be in format [IP:Port]")
+        if set_solver_trusted_peers_only:
+            config["solver"]["trusted_peers_only"] = str2bool(set_solver_trusted_peers_only)
+            if str2bool(set_solver_trusted_peers_only):
+                print("Solver will only accept trusted peer connections")
+            else:
+                print("Solver will accept connections from all peers")
+            change_made = True
         if set_fullnode_port:
             config["full_node"]["port"] = int(set_fullnode_port)
             config["full_node"]["introducer_peer"]["port"] = int(set_fullnode_port)
@@ -247,6 +256,11 @@ def configure(
 @click.option("--set-node-introducer", help="Set the introducer for node - IP:Port", type=str)
 @click.option("--set-farmer-peer", help="Set the farmer peer for harvester - IP:Port", type=str)
 @click.option("--set-solver-peer", help="Set the solver peer for farmer - IP:Port", type=str)
+@click.option(
+    "--set-solver-trusted-peers-only",
+    help="Enable/disable trusted peer requirement for solver connections",
+    type=click.Choice(["true", "t", "false", "f"]),
+)
 @click.option(
     "--set-fullnode-port",
     help="Set the port to use for the fullnode, useful for testing",
@@ -316,6 +330,7 @@ def configure_cmd(
     crawler_minimum_version_count: int,
     seeder_domain_name: str,
     seeder_nameserver: str,
+    set_solver_trusted_peers_only: str,
 ) -> None:
     configure(
         ChiaCliContext.set_default(ctx).root_path,
@@ -334,4 +349,5 @@ def configure_cmd(
         crawler_minimum_version_count,
         seeder_domain_name,
         seeder_nameserver,
+        set_solver_trusted_peers_only,
     )

chia/cmds/farm.py

@@ -105,3 +105,26 @@ def challenges_cmd(ctx: click.Context, farmer_rpc_port: Optional[int], limit: in
     from chia.cmds.farm_funcs import challenges
 
     asyncio.run(challenges(ChiaCliContext.set_default(ctx).root_path, farmer_rpc_port, limit))
+
+
+@farm_cmd.command("connect-solver", help="Connect to a solver")
+@click.option(
+    "-fp",
+    "--farmer-rpc-port",
+    help="Set the port where the Farmer is hosting the RPC interface",
+    type=int,
+    default=None,
+    show_default=True,
+)
+@click.argument("solver_address", required=True)
+@click.pass_context
+def connect_solver_cmd(
+    ctx: click.Context,
+    farmer_rpc_port: Optional[int],
+    solver_address: str,
+) -> None:
+    import asyncio
+
+    from chia.cmds.farm_funcs import solver_connect
+
+    asyncio.run(solver_connect(ChiaCliContext.set_default(ctx).root_path, farmer_rpc_port, solver_address))

chia/cmds/farm_funcs.py

@@ -11,6 +11,7 @@
 from chia.cmds.units import units
 from chia.farmer.farmer_rpc_client import FarmerRpcClient
 from chia.full_node.full_node_rpc_client import FullNodeRpcClient
+from chia.util.config import lock_and_load_config, save_config
 from chia.util.errors import CliRpcConnectionError
 from chia.util.network import is_localhost
 from chia.wallet.wallet_rpc_client import WalletRpcClient
@@ -217,3 +218,33 @@ def process_harvesters(harvester_peers_in: dict[str, dict[str, Any]]) -> None:
             print("For details on farmed rewards and fees you should run 'chia wallet show'")
     else:
         print("Note: log into your key using 'chia wallet show' to see rewards for each key")
+
+
+async def solver_connect(root_path: Path, farmer_rpc_port: Optional[int], solver_address: str) -> None:
+    from chia.util.network import parse_host_port
+
+    try:
+        host, port = parse_host_port(solver_address)
+    except ValueError:
+        print("Solver address must be in format [IP:Port]")
+        return
+    try:
+        with lock_and_load_config(root_path, "config.yaml") as config:
+            config["farmer"]["solver_peers"] = [{"host": host, "port": port}]
+            save_config(root_path, "config.yaml", config)
+        print(f"✓ Updated config with solver peer {host}:{port}")
+    except Exception as e:
+        print(f"✗ Failed to update config: {e}")
+        return
+    try:
+        async with get_any_service_client(FarmerRpcClient, root_path, farmer_rpc_port) as (farmer_client, _):
+            result = await farmer_client.connect_to_solver(host, port)
+            if result.get("success"):
+                print(f"✓ Connected to solver at {host}:{port}")
+            else:
+                error = result.get("error", "Unknown error")
+                print(f"✗ Failed to connect to solver: {error}")
+    except CliRpcConnectionError:
+        print("✗ Could not connect to farmer. Make sure farmer is running.")
+    except Exception as e:
+        print(f"✗ Error connecting to solver: {e}")

chia/cmds/init_funcs.py

@@ -299,6 +299,7 @@ def chia_init(
                 seeder_domain_name="",
                 seeder_nameserver="",
                 set_solver_peer="",
+                set_solver_trusted_peers_only="",
             )
         if fix_ssl_permissions:
             fix_ssl(root_path)
@@ -326,6 +327,7 @@ def chia_init(
             seeder_domain_name="",
             seeder_nameserver="",
             set_solver_peer="",
+            set_solver_trusted_peers_only="",
         )
     create_all_ssl(root_path)
     if fix_ssl_permissions:

chia/farmer/farmer_rpc_api.py

@@ -11,7 +11,10 @@
 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 @@ def get_routes(self) -> dict[str, Endpoint]:
             "/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 @@ async def get_pool_login_link(self, request: dict[str, Any]) -> EndpointResult:
         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

@@ -85,3 +85,7 @@ async def get_pool_login_link(self, launcher_id: bytes32) -> Optional[str]:
             return cast(Optional[str], result["login_link"])
         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/solver/solver.py

@@ -14,7 +14,6 @@
 from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
-from chia.util.network import is_localhost
 
 log = logging.getLogger(__name__)
 
@@ -76,15 +75,13 @@ def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[st
         return default_get_connections(server=self.server, request_node_type=request_node_type)
 
     async def on_connect(self, connection: WSChiaConnection) -> None:
-        if is_localhost(connection.peer_info.host):
-            self.log.info(f"Accepting localhost connection from {connection.connection_type}: {connection.get_peer_logging()}")
+        if not self.config.get("trusted_peers_only", True):
+            self.log.info(f"trusted peers check disabled, Accepting connection from {connection.get_peer_logging()}")
             return
-
-        trusted_peers = self.config.get("trusted_peers", {})
-        if self.server.is_trusted_peer(connection, trusted_peers):
-            self.log.info(f"Accepting trusted peer connection from {connection.connection_type}: {connection.get_peer_logging()}")
+        if self.server.is_trusted_peer(connection, self.config.get("trusted_peers", {})):
+            self.log.info(f"Accepting connection from {connection.get_peer_logging()}")
             return
-        self.log.warning(f"Rejecting untrusted connection from {connection.connection_type}: {connection.get_peer_logging()}")
+        self.log.warning(f"Rejecting untrusted connection from {connection.get_peer_logging()}")
         await connection.close()
 
     async def on_disconnect(self, connection: WSChiaConnection) -> None:

chia/util/initial-config.yaml

@@ -643,7 +643,11 @@ solver:
 
   # Node IDs of trusted solver peers, only these can connect by default
   trusted_peers:
-    0ThisisanexampleNodeID7ff9d60f1c3fa270c213c0ad0cb89c01274634a7c3cb7: Does_not_matter
+    localhost: 9999
+
+  # If False, accepts connections from all peers (not just trusted_peers)
+  # If True (default), only accepts localhost and trusted_peers connections
+  trusted_peers_only: True
 
   # Logging configuration
   logging: *logging