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

chia/server/rate_limits.py

@@ -4,7 +4,7 @@ import dataclasses
 import logging
 import time
 from collections import Counter
-from typing import Optional
+from typing import Callable, Optional, Union
 
 from chia.protocols.outbound_message import Message
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
@@ -18,14 +18,22 @@ log = logging.getLogger(__name__)
 class RateLimiter:
     incoming: bool
     reset_seconds: int
-    current_minute: int
+    current_slot: int
     message_counts: Counter[ProtocolMessageTypes]
     message_cumulative_sizes: Counter[ProtocolMessageTypes]
     percentage_of_limit: int
     non_tx_message_counts: int = 0
     non_tx_cumulative_size: int = 0
+    get_time: Callable[[], float]
 
-    def __init__(self, incoming: bool, reset_seconds: int = 60, percentage_of_limit: int = 100):
+    def __init__(
+        self,
+        incoming: bool,
+        reset_seconds: int = 60,
+        percentage_of_limit: int = 100,
+        *,
+        get_time: Callable[[], float] = time.monotonic,
+    ):
         """
         The incoming parameter affects whether counters are incremented
         unconditionally or not. For incoming messages, the counters are always
@@ -33,9 +41,10 @@ class RateLimiter:
         if they are allowed to be sent by the rate limiter, since we won't send
         the messages otherwise.
         """
+        self.get_time = get_time
         self.incoming = incoming
         self.reset_seconds = reset_seconds
-        self.current_minute = int(time.time() // reset_seconds)
+        self.current_slot = int(get_time() // reset_seconds)
         self.message_counts = Counter()
         self.message_cumulative_sizes = Counter()
         self.percentage_of_limit = percentage_of_limit
@@ -51,9 +60,9 @@ class RateLimiter:
         hit and the message is good to be sent or received.
         """
 
-        current_minute = int(time.time() // self.reset_seconds)
-        if current_minute != self.current_minute:
-            self.current_minute = current_minute
+        current_slot = int(self.get_time() // self.reset_seconds)
+        if current_slot != self.current_slot:
+            self.current_slot = current_slot
             self.message_counts = Counter()
             self.message_cumulative_sizes = Counter()
             self.non_tx_message_counts = 0
@@ -71,39 +80,33 @@ class RateLimiter:
         proportion_of_limit: float = self.percentage_of_limit / 100
 
         ret: bool = False
-        rate_limits = get_rate_limits_to_use(our_capabilities, peer_capabilities)
+        rate_limits: dict[ProtocolMessageTypes, Union[RLSettings, Unlimited]]
+        rate_limits, agg_limit = get_rate_limits_to_use(our_capabilities, peer_capabilities)
 
         try:
-            limits: RLSettings = rate_limits["default_settings"]
-            if message_type in rate_limits["rate_limits_tx"]:
-                limits = rate_limits["rate_limits_tx"][message_type]
-            elif message_type in rate_limits["rate_limits_other"]:
-                limits = rate_limits["rate_limits_other"][message_type]
-                if isinstance(limits, RLSettings):
-                    non_tx_freq = rate_limits["non_tx_freq"]
-                    non_tx_max_total_size = rate_limits["non_tx_max_total_size"]
-                    new_non_tx_count = self.non_tx_message_counts + 1
-                    new_non_tx_size = self.non_tx_cumulative_size + len(message.data)
-                    if new_non_tx_count > non_tx_freq * proportion_of_limit:
-                        return " ".join(
-                            [
-                                f"non-tx count: {new_non_tx_count}",
-                                f"> {non_tx_freq * proportion_of_limit}",
-                                f"(scale factor: {proportion_of_limit})",
-                            ]
-                        )
-                    if new_non_tx_size > non_tx_max_total_size * proportion_of_limit:
-                        return " ".join(
-                            [
-                                f"non-tx size: {new_non_tx_size}",
-                                f"> {non_tx_max_total_size * proportion_of_limit}",
-                                f"(scale factor: {proportion_of_limit})",
-                            ]
-                        )
-            else:  # pragma: no cover
-                log.warning(
-                    f"Message type {message_type} not found in rate limits (scale factor: {proportion_of_limit})",
-                )
+            limits: Union[RLSettings, Unlimited] = rate_limits[message_type]
+            if isinstance(limits, RLSettings) and limits.aggregate_limit:
+                non_tx_freq = agg_limit.frequency
+                assert agg_limit.max_total_size is not None
+                non_tx_max_total_size = agg_limit.max_total_size
+                new_non_tx_count = self.non_tx_message_counts + 1
+                new_non_tx_size = self.non_tx_cumulative_size + len(message.data)
+                if new_non_tx_count > non_tx_freq * proportion_of_limit:
+                    return " ".join(
+                        [
+                            f"non-tx count: {new_non_tx_count}",
+                            f"> {non_tx_freq * proportion_of_limit}",
+                            f"(scale factor: {proportion_of_limit})",
+                        ]
+                    )
+                if new_non_tx_size > non_tx_max_total_size * proportion_of_limit:
+                    return " ".join(
+                        [
+                            f"non-tx size: {new_non_tx_size}",
+                            f"> {non_tx_max_total_size * proportion_of_limit}",
+                            f"(scale factor: {proportion_of_limit})",
+                        ]
+                    )
 
             if isinstance(limits, Unlimited):
                 # this message type is not rate limited. This is used for
@@ -121,9 +124,9 @@ class RateLimiter:
                 if new_message_counts > limits.frequency * proportion_of_limit:
                     return " ".join(
                         [
-                            f"message count: {new_message_counts}"
-                            f"> {limits.frequency * proportion_of_limit}"
-                            f"(scale factor: {proportion_of_limit})"
+                            f"message count: {new_message_counts}",
+                            f"> {limits.frequency * proportion_of_limit}",
+                            f"(scale factor: {proportion_of_limit})",
                         ]
                     )
                 if len(message.data) > limits.max_size:

chia/server/resolve_peer_info.py

@@ -11,6 +11,7 @@ log = logging.getLogger(__name__)
 PEER_INFO_MAPPING: dict[NodeType, str] = {
     NodeType.FULL_NODE: "full_node_peer",
     NodeType.FARMER: "farmer_peer",
+    NodeType.SOLVER: "solver_peer",
 }
 
 
@@ -21,6 +22,10 @@ def get_unresolved_peer_infos(service_config: dict[str, Any], peer_type: NodeTyp
     if peer_info is not None:
         peer_infos.append(peer_info)
 
+    # Default solver peer if none configured
+    if peer_type == NodeType.SOLVER and not peer_infos:
+        peer_infos = [{"host": "localhost", "port": 8666}]
+
     return {UnresolvedPeerInfo(host=peer["host"], port=peer["port"]) for peer in peer_infos}
 
 

chia/server/server.py

@@ -173,7 +173,12 @@ class ChiaServer:
         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_server_types = {
+            NodeType.HARVESTER,
+            NodeType.FARMER,
+            NodeType.WALLET,
+            NodeType.DATA_LAYER,
+        }
 
         if local_type in authenticated_client_types:
             # Authenticated clients
@@ -260,9 +265,8 @@ class ChiaServer:
                     if is_crawler is not None:
                         if time.time() - connection.creation_time > 5:
                             to_remove.append(connection)
-                    else:
-                        if time.time() - connection.last_message_time > 1800:
-                            to_remove.append(connection)
+                    elif time.time() - connection.last_message_time > 1800:
+                        to_remove.append(connection)
             for connection in to_remove:
                 self.log.debug(f"Garbage collecting connection {connection.peer_info.host} due to inactivity")
                 if connection.closed:
@@ -548,9 +552,15 @@ class ChiaServer:
         # in this case we still want to do the banning logic and remove the connection from the list
         # but the other cleanup should already have been done so we skip that
 
-        if is_localhost(connection.peer_info.host) and ban_time != 0:
-            self.log.warning(f"Trying to ban localhost for {ban_time}, but will not ban")
-            ban_time = 0
+        if ban_time > 0:
+            if is_localhost(connection.peer_info.host):
+                self.log.warning(f"Trying to ban localhost for {ban_time}, but will not ban")
+                ban_time = 0
+            elif self.is_trusted_peer(connection, self.config.get("trusted_peers", {})):
+                self.log.warning(
+                    f"Trying to ban trusted peer {connection.peer_info.host} for {ban_time}, but will not ban"
+                )
+                ban_time = 0
         if ban_time > 0:
             ban_until: float = time.time() + ban_time
             self.log.warning(f"Banning {connection.peer_info.host} for {ban_time} seconds")

chia/server/start_service.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import logging
-import logging.config
 import os
 import signal
 from collections.abc import AsyncIterator, Awaitable, Coroutine

chia/simulator/block_tools.py

@@ -14,7 +14,7 @@ from collections.abc import Sequence
 from dataclasses import dataclass, replace
 from pathlib import Path
 from random import Random
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, Union
 
 import anyio
 from chia_puzzles_py.programs import CHIALISP_DESERIALISATION, ROM_BOOTSTRAP_GENERATOR
@@ -28,7 +28,6 @@ from chia_rs import (
     G1Element,
     G2Element,
     InfusedChallengeChainSubSlot,
-    PlotSize,
     PoolTarget,
     PrivateKey,
     ProofOfSpace,
@@ -65,6 +64,7 @@ from chia.daemon.keychain_proxy import KeychainProxy, connect_to_keychain_and_va
 from chia.full_node.bundle_tools import simple_solution_generator, simple_solution_generator_backrefs
 from chia.plotting.create_plots import PlotKeys, create_plots
 from chia.plotting.manager import PlotManager
+from chia.plotting.prover import PlotVersion
 from chia.plotting.util import (
     Params,
     PlotRefreshEvents,
@@ -92,9 +92,13 @@ from chia.types.blockchain_format.program import DEFAULT_FLAGS, INFINITE_COST, P
 from chia.types.blockchain_format.proof_of_space import (
     calculate_pos_challenge,
     calculate_prefix_bits,
+    calculate_required_plot_strength,
     generate_plot_public_key,
     generate_taproot_sk,
+    make_pos,
     passes_plot_filter,
+    quality_for_partial_proof,
+    solve_proof,
 )
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
@@ -772,7 +776,7 @@ class BlockTools:
                 seed,
                 force_overflow=force_overflow,
                 skip_slots=skip_slots,
-                timestamp=(uint64(int(time.time())) if genesis_timestamp is None else genesis_timestamp),
+                timestamp=(uint64(time.time()) if genesis_timestamp is None else genesis_timestamp),
             )
             self.log.info(f"Created block 0 iters: {genesis.total_iters}")
             num_empty_slots_added = skip_slots
@@ -898,11 +902,10 @@ class BlockTools:
                                 # address, so continue until a proof of space tied to a pk is found
                                 continue
                             pool_target = PoolTarget(proof_of_space.pool_contract_puzzle_hash, uint32(0))
+                        elif pool_reward_puzzle_hash is not None:
+                            pool_target = PoolTarget(pool_reward_puzzle_hash, uint32(0))
                         else:
-                            if pool_reward_puzzle_hash is not None:
-                                pool_target = PoolTarget(pool_reward_puzzle_hash, uint32(0))
-                            else:
-                                pool_target = PoolTarget(self.pool_ph, uint32(0))
+                            pool_target = PoolTarget(self.pool_ph, uint32(0))
 
                         new_gen = self.setup_new_gen(
                             tx_block_heights,
@@ -966,7 +969,6 @@ class BlockTools:
                         block_list.append(full_block)
 
                         if include_transactions:
-                            prev_tx_height = full_block.height
                             for coin in full_block.get_included_reward_coins():
                                 if coin.puzzle_hash == self.farmer_ph:
                                     pending_rewards.append(coin)
@@ -980,6 +982,7 @@ class BlockTools:
 
                         if full_block.transactions_generator is not None:
                             tx_block_heights.append(full_block.height)
+                            prev_tx_height = full_block.height
 
                         blocks_added_this_sub_slot += 1
                         blocks[full_block.header_hash] = block_record
@@ -1193,11 +1196,10 @@ class BlockTools:
                                 # address, so continue until a proof of space tied to a pk is found
                                 continue
                             pool_target = PoolTarget(proof_of_space.pool_contract_puzzle_hash, uint32(0))
+                        elif pool_reward_puzzle_hash is not None:
+                            pool_target = PoolTarget(pool_reward_puzzle_hash, uint32(0))
                         else:
-                            if pool_reward_puzzle_hash is not None:
-                                pool_target = PoolTarget(pool_reward_puzzle_hash, uint32(0))
-                            else:
-                                pool_target = PoolTarget(self.pool_ph, uint32(0))
+                            pool_target = PoolTarget(self.pool_ph, uint32(0))
 
                         new_gen = self.setup_new_gen(
                             tx_block_heights,
@@ -1261,7 +1263,6 @@ class BlockTools:
                         block_list.append(full_block)
 
                         if include_transactions:
-                            prev_tx_height = full_block.height
                             for coin in full_block.get_included_reward_coins():
                                 if coin.puzzle_hash == self.farmer_ph:
                                     pending_rewards.append(coin)
@@ -1275,6 +1276,7 @@ class BlockTools:
 
                         if full_block.transactions_generator is not None:
                             tx_block_heights.append(full_block.height)
+                            prev_tx_height = full_block.height
 
                         blocks_added_this_sub_slot += 1
                         blocks[full_block.header_hash] = block_record
@@ -1311,7 +1313,7 @@ class BlockTools:
         skip_slots: int = 0,
     ) -> FullBlock:
         if timestamp is None:
-            timestamp = uint64(int(time.time()))
+            timestamp = uint64(time.time())
 
         finished_sub_slots: list[EndOfSubSlotBundle] = []
         unfinished_block: Optional[UnfinishedBlock] = None
@@ -1502,53 +1504,81 @@ class BlockTools:
         found_proofs: list[tuple[uint64, ProofOfSpace]] = []
         rng = random.Random()
         rng.seed(seed)
+
+        required_plot_strength = calculate_required_plot_strength(constants, prev_transaction_b_height)
+
         for plot_info in self.plot_manager.plots.values():
             plot_id: bytes32 = plot_info.prover.get_id()
             if force_plot_id is not None and plot_id != force_plot_id:
                 continue
-            # TODO: todo_v2_plots support v2 plots in the plot manager
-            prefix_bits = calculate_prefix_bits(constants, height, PlotSize.make_v1(plot_info.prover.get_size()))
-            if passes_plot_filter(prefix_bits, plot_id, challenge_hash, signage_point):
-                new_challenge: bytes32 = calculate_pos_challenge(plot_id, challenge_hash, signage_point)
-                qualities = plot_info.prover.get_qualities_for_challenge(new_challenge)
-
-                for proof_index, quality_str in enumerate(qualities):
-                    required_iters = calculate_iterations_quality(
-                        constants,
-                        quality_str,
-                        # TODO: todo_v2_plots support v2 plots in the plot manager
-                        PlotSize.make_v1(plot_info.prover.get_size()),
-                        difficulty,
-                        signage_point,
-                        sub_slot_iters,
-                        prev_transaction_b_height,
-                    )
-                    if required_iters < calculate_sp_interval_iters(constants, sub_slot_iters):
-                        proof_xs: bytes = plot_info.prover.get_full_proof(new_challenge, proof_index)
+            prefix_bits = calculate_prefix_bits(constants, height, plot_info.prover.get_size())
+            if not passes_plot_filter(prefix_bits, plot_id, challenge_hash, signage_point):
+                continue
 
-                        # Look up local_sk from plot to save locked memory
-                        (
-                            pool_public_key_or_puzzle_hash,
-                            farmer_public_key,
-                            local_master_sk,
-                        ) = parse_plot_info(plot_info.prover.get_memo())
-                        local_sk = master_sk_to_local_sk(local_master_sk)
-
-                        if isinstance(pool_public_key_or_puzzle_hash, G1Element):
-                            include_taproot = False
-                        else:
-                            assert isinstance(pool_public_key_or_puzzle_hash, bytes32)
-                            include_taproot = True
-                        plot_pk = generate_plot_public_key(local_sk.get_g1(), farmer_public_key, include_taproot)
-                        proof_of_space: ProofOfSpace = ProofOfSpace(
-                            new_challenge,
-                            plot_info.pool_public_key,
-                            plot_info.pool_contract_puzzle_hash,
-                            plot_pk,
-                            plot_info.prover.get_size(),
-                            proof_xs,
-                        )
-                        found_proofs.append((required_iters, proof_of_space))
+            # v2 plots aren't valid until after the hard fork
+            if (
+                prev_transaction_b_height < constants.HARD_FORK2_HEIGHT
+                and plot_info.prover.get_version() == PlotVersion.V2
+            ):
+                continue
+
+            new_challenge: bytes32 = calculate_pos_challenge(plot_id, challenge_hash, signage_point)
+
+            # these are either qualities (v1) or partial proofs (v2)
+            proofs: Sequence[Union[bytes32, bytes]]
+            v = plot_info.prover.get_version()
+            if v == PlotVersion.V1:
+                proofs = plot_info.prover.get_qualities_for_challenge(new_challenge)
+            else:
+                proofs = plot_info.prover.get_partial_proofs_for_challenge(new_challenge, required_plot_strength)
+
+            for proof_index, proof in enumerate(proofs):
+                if v == PlotVersion.V2:
+                    quality_str = quality_for_partial_proof(proof, new_challenge)
+                elif v == PlotVersion.V1:
+                    quality_str = bytes32(proof)
+
+                required_iters = calculate_iterations_quality(
+                    constants,
+                    quality_str,
+                    plot_info.prover.get_size(),
+                    difficulty,
+                    signage_point,
+                    sub_slot_iters,
+                    prev_transaction_b_height,
+                )
+                if required_iters >= calculate_sp_interval_iters(constants, sub_slot_iters):
+                    continue
+
+                proof_xs: bytes
+                if v == PlotVersion.V1:
+                    proof_xs = plot_info.prover.get_full_proof(new_challenge, proof_index)
+                else:
+                    proof_xs = solve_proof(proof)
+
+                # Look up local_sk from plot to save locked memory
+                (
+                    pool_public_key_or_puzzle_hash,
+                    farmer_public_key,
+                    local_master_sk,
+                ) = parse_plot_info(plot_info.prover.get_memo())
+                local_sk = master_sk_to_local_sk(local_master_sk)
+
+                if isinstance(pool_public_key_or_puzzle_hash, G1Element):
+                    include_taproot = False
+                else:
+                    assert isinstance(pool_public_key_or_puzzle_hash, bytes32)
+                    include_taproot = True
+                plot_pk = generate_plot_public_key(local_sk.get_g1(), farmer_public_key, include_taproot)
+                proof_of_space: ProofOfSpace = make_pos(
+                    new_challenge,
+                    plot_info.pool_public_key,
+                    plot_info.pool_contract_puzzle_hash,
+                    plot_pk,
+                    plot_info.prover.get_size(),
+                    proof_xs,
+                )
+                found_proofs.append((required_iters, proof_of_space))
         random_sample = found_proofs
         if len(found_proofs) >= 1:
             if rng.random() < 0.1:
@@ -1734,7 +1764,8 @@ def get_plot_dir(plot_dir_name: str = "test-plots", automated_testing: bool = Tr
     if not automated_testing:  # make sure we don't accidentally stack directories.
         root_dir = (
             root_dir.parent
-            if root_dir.parts[-1] == plot_dir_name.split("/")[0] or root_dir.parts[-1] == plot_dir_name.split("\\")[0]
+            if root_dir.parts[-1] == plot_dir_name.split("/", maxsplit=1)[0]
+            or root_dir.parts[-1] == plot_dir_name.split("\\", maxsplit=1)[0]
             else root_dir
         )
     cache_path = root_dir.joinpath(plot_dir_name)
@@ -1758,6 +1789,7 @@ def load_block_list(
     sub_slot_iters = uint64(constants.SUB_SLOT_ITERS_STARTING)
     height_to_hash: dict[uint32, bytes32] = {}
     blocks: dict[bytes32, BlockRecord] = {}
+    prev_transaction_b_height = uint32(0)
     for full_block in block_list:
         if full_block.height != 0:
             if len(full_block.finished_sub_slots) > 0:
@@ -1774,7 +1806,6 @@ def load_block_list(
             sp_hash = full_block.reward_chain_block.challenge_chain_sp_vdf.output.get_hash()
 
         cache = BlockCache(blocks)
-        prev_transaction_b_height = uint32(0)  # TODO: todo_v2_plots
 
         required_iters = validate_pospace_and_get_required_iters(
             constants,
@@ -1788,6 +1819,9 @@ def load_block_list(
         )
         assert required_iters is not None
 
+        if full_block.is_transaction_block():
+            prev_transaction_b_height = full_block.height
+
         blocks[full_block.header_hash] = block_to_block_record(
             constants,
             cache,

chia/simulator/full_node_simulator.py

@@ -167,7 +167,7 @@ class FullNodeSimulator(FullNodeAPI):
                 raise ValueError("Cannot revert to a height less than 1.")
             block_record: BlockRecord = self.full_node.blockchain.height_to_block_record(new_height)
             # remove enough data to allow a bunch of blocks to be wiped.
-            async with self.full_node.block_store.db_wrapper.writer():
+            async with self.full_node.block_store.transaction():
                 # set coinstore
                 await self.full_node.coin_store.rollback_to_block(new_height)
                 # set blockstore to new height

chia/simulator/setup_services.py

@@ -18,33 +18,31 @@ from chia_rs.sized_ints import uint16
 from chia.cmds.init_funcs import init
 from chia.consensus.constants import replace_str_to_bytes
 from chia.daemon.server import WebSocketServer, daemon_launch_lock_path
+from chia.farmer.farmer_service import FarmerService
+from chia.farmer.start_farmer import create_farmer_service
+from chia.full_node.full_node_service import FullNodeService
+from chia.full_node.start_full_node import create_full_node_service
+from chia.harvester.harvester_service import HarvesterService
+from chia.harvester.start_harvester import create_harvester_service
+from chia.introducer.introducer_service import IntroducerService
+from chia.introducer.start_introducer import create_introducer_service
 from chia.protocols.outbound_message import NodeType
 from chia.protocols.shared_protocol import Capability, default_capabilities
+from chia.seeder.crawler_service import CrawlerService
 from chia.seeder.dns_server import DNSServer, create_dns_server_service
 from chia.seeder.start_crawler import create_full_node_crawler_service
-from chia.server.aliases import (
-    CrawlerService,
-    FarmerService,
-    FullNodeService,
-    HarvesterService,
-    IntroducerService,
-    TimelordService,
-    WalletService,
-)
 from chia.server.resolve_peer_info import set_peer_info
 from chia.server.signal_handlers import SignalHandlers
-from chia.server.start_farmer import create_farmer_service
-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_timelord import create_timelord_service
-from chia.server.start_wallet import create_wallet_service
 from chia.simulator.block_tools import BlockTools, test_constants
 from chia.simulator.keyring import TempKeyring
 from chia.simulator.ssl_certs import get_next_nodes_certs_and_keys, get_next_private_ca_cert_and_key
 from chia.simulator.start_simulator import SimulatorFullNodeService, create_full_node_simulator_service
+from chia.solver.solver_service import SolverService
+from chia.solver.start_solver import create_solver_service
 from chia.ssl.create_ssl import create_all_ssl
+from chia.timelord.start_timelord import create_timelord_service
 from chia.timelord.timelord_launcher import VDFClientProcessMgr, find_vdf_client, spawn_process
+from chia.timelord.timelord_service import TimelordService
 from chia.types.peer_info import UnresolvedPeerInfo
 from chia.util.bech32m import encode_puzzle_hash
 from chia.util.config import config_path_for_filename, load_config, lock_and_load_config, save_config
@@ -52,6 +50,8 @@ from chia.util.db_wrapper import generate_in_memory_db_uri
 from chia.util.keychain import bytes_to_mnemonic
 from chia.util.lock import Lockfile
 from chia.util.task_referencer import create_referenced_task
+from chia.wallet.start_wallet import create_wallet_service
+from chia.wallet.wallet_service import WalletService
 
 log = logging.getLogger(__name__)
 
@@ -359,6 +359,7 @@ async def setup_farmer(
     full_node_port: Optional[uint16] = None,
     start_service: bool = True,
     port: uint16 = uint16(0),
+    solver_peer: Optional[UnresolvedPeerInfo] = None,
 ) -> AsyncGenerator[FarmerService, None]:
     with create_lock_and_load_config(b_tools.root_path / "config" / "ssl" / "ca", root_path) as root_config:
         root_config["logging"]["log_stdout"] = True
@@ -386,6 +387,16 @@ async def setup_farmer(
         service_config.pop("full_node_peer", None)
         service_config.pop("full_node_peers", None)
 
+    if solver_peer:
+        service_config["solver_peers"] = [
+            {
+                "host": solver_peer.host,
+                "port": solver_peer.port,
+            },
+        ]
+    else:
+        service_config.pop("solver_peers", None)
+
     service = create_farmer_service(
         root_path,
         root_config,
@@ -393,6 +404,7 @@ async def setup_farmer(
         consensus_constants,
         b_tools.local_keychain,
         connect_to_daemon=False,
+        solver_peer=solver_peer,
     )
 
     async with service.manage(start=start_service):
@@ -506,3 +518,28 @@ async def setup_timelord(
 
     async with service.manage():
         yield service
+
+
+@asynccontextmanager
+async def setup_solver(
+    root_path: Path,
+    b_tools: BlockTools,
+    consensus_constants: ConsensusConstants,
+    start_service: bool = True,
+) -> AsyncGenerator[SolverService, None]:
+    with create_lock_and_load_config(b_tools.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