chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/_tests/util/rpc.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from chia.rpc.rpc_client import RpcClient
+from chia.rpc.rpc_server import RpcApiProtocol
+
+
+async def validate_get_routes(client: RpcClient, api: RpcApiProtocol) -> None:
+    routes_client = (await client.fetch("get_routes", {}))["routes"]
+    assert len(routes_client) > 0
+    routes_api = list(api.get_routes().keys())
+    # TODO: avoid duplication of RpcServer.get_routes()
+    routes_server = [
+        "/get_network_info",
+        "/get_connections",
+        "/open_connection",
+        "/close_connection",
+        "/stop_node",
+        "/get_routes",
+        "/get_version",
+        "/healthz",
+        "/get_log_level",
+        "/set_log_level",
+        "/reset_log_level",
+    ]
+    assert len(routes_api) > 0
+    assert sorted(routes_client) == sorted(routes_api + routes_server)

chia/_tests/util/run_block.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from chia_rs import Coin
+
+from chia.consensus.constants import ConsensusConstants
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.types.condition_with_args import ConditionWithArgs
+from chia.types.generator_types import BlockGenerator
+from chia.util.ints import uint32, uint64
+from chia.wallet.cat_wallet.cat_utils import match_cat_puzzle
+from chia.wallet.puzzles.load_clvm import load_serialized_clvm_maybe_recompile
+from chia.wallet.uncurried_puzzle import uncurry_puzzle
+
+DESERIALIZE_MOD = load_serialized_clvm_maybe_recompile(
+    "chialisp_deserialisation.clsp", package_or_requirement="chia.consensus.puzzles"
+)
+
+
+@dataclass
+class NPC:
+    coin_name: bytes32
+    puzzle_hash: bytes32
+    conditions: list[tuple[ConditionOpcode, list[ConditionWithArgs]]]
+
+
+@dataclass
+class CAT:
+    asset_id: str
+    memo: str
+    npc: NPC
+
+    def cat_to_dict(self) -> dict[str, Any]:
+        return {"asset_id": self.asset_id, "memo": self.memo, "npc": npc_to_dict(self.npc)}
+
+
+def condition_with_args_to_dict(condition_with_args: ConditionWithArgs) -> dict[str, Any]:
+    return {
+        "condition_opcode": condition_with_args.opcode.name,
+        "arguments": [arg.hex() for arg in condition_with_args.vars],
+    }
+
+
+def condition_list_to_dict(condition_list: tuple[ConditionOpcode, list[ConditionWithArgs]]) -> list[dict[str, Any]]:
+    assert all([condition_list[0] == cwa.opcode for cwa in condition_list[1]])
+    return [condition_with_args_to_dict(cwa) for cwa in condition_list[1]]
+
+
+def npc_to_dict(npc: NPC) -> dict[str, Any]:
+    return {
+        "coin_name": npc.coin_name.hex(),
+        "conditions": [{"condition_type": c[0].name, "conditions": condition_list_to_dict(c)} for c in npc.conditions],
+        "puzzle_hash": npc.puzzle_hash.hex(),
+    }
+
+
+def run_generator(block_generator: BlockGenerator, constants: ConsensusConstants, max_cost: int) -> list[CAT]:
+    block_args = block_generator.generator_refs
+    _cost, block_result = block_generator.program.run_with_cost(max_cost, [DESERIALIZE_MOD, block_args])
+
+    coin_spends = block_result.first()
+
+    cat_list: list[CAT] = []
+    for spend in coin_spends.as_iter():
+        parent, puzzle, amount, solution = spend.as_iter()
+        args = match_cat_puzzle(uncurry_puzzle(puzzle))
+
+        if args is None:
+            continue
+
+        _, asset_id, _ = args
+        memo = ""
+
+        puzzle_result = puzzle.run(solution)
+
+        conds: dict[ConditionOpcode, list[ConditionWithArgs]] = {}
+
+        for condition in puzzle_result.as_python():
+            op = ConditionOpcode(condition[0])
+
+            if op not in conds:
+                conds[op] = []
+
+            if condition[0] != ConditionOpcode.CREATE_COIN or len(condition) < 4:
+                conds[op].append(ConditionWithArgs(op, [i for i in condition[1:3]]))
+                continue
+
+            # If only 3 elements (opcode + 2 args), there is no memo, this is ph, amount
+            if type(condition[3]) is not list:
+                # If it's not a list, it's not the correct format
+                conds[op].append(ConditionWithArgs(op, [i for i in condition[1:3]]))
+                continue
+
+            conds[op].append(ConditionWithArgs(op, [i for i in condition[1:3]] + [condition[3][0]]))
+
+            # special retirement address
+            if condition[3][0].hex() != "0000000000000000000000000000000000000000000000000000000000000000":
+                continue
+
+            if len(condition[3]) >= 2:
+                try:
+                    memo = condition[3][1].decode("utf-8", errors="strict")
+                except UnicodeError:
+                    pass  # ignore this error which should leave memo as empty string
+
+            # technically there could be more such create_coin ops in the list but our wallet does not
+            # so leaving it for the future
+            break
+
+        puzzle_hash = puzzle.get_tree_hash()
+        coin = Coin(bytes32(parent.as_atom()), puzzle_hash, uint64(amount.as_int()))
+        cat_list.append(
+            CAT(
+                asset_id=bytes(asset_id).hex()[2:],
+                memo=memo,
+                npc=NPC(coin.name(), puzzle_hash, [(op, cond) for op, cond in conds.items()]),
+            )
+        )
+
+    return cat_list
+
+
+def ref_list_to_args(ref_list: list[uint32], root_path: Path) -> list[bytes]:
+    args = []
+    for height in ref_list:
+        with open(root_path / f"{height}.json", "rb") as f:
+            program_str = json.load(f)["block"]["transactions_generator"]
+            # we need to SerializedProgram to handle possible leading 0x in the
+            # hex string
+            args.append(bytes(SerializedProgram.fromhex(program_str)))
+    return args
+
+
+def run_generator_with_args(
+    generator_program_hex: str,
+    generator_args: list[bytes],
+    constants: ConsensusConstants,
+    cost: uint64,
+) -> list[CAT]:
+    if not generator_program_hex:
+        return []
+    generator_program = SerializedProgram.fromhex(generator_program_hex)
+    block_generator = BlockGenerator(generator_program, generator_args)
+    return run_generator(block_generator, constants, min(constants.MAX_BLOCK_COST_CLVM, cost))
+
+
+def run_json_block(full_block: dict[str, Any], parent: Path, constants: ConsensusConstants) -> list[CAT]:
+    ref_list = full_block["block"]["transactions_generator_ref_list"]
+    tx_info: dict[str, Any] = full_block["block"]["transactions_info"]
+    generator_program_hex: str = full_block["block"]["transactions_generator"]
+    cat_list: list[CAT] = []
+    if tx_info and generator_program_hex:
+        cost = tx_info["cost"]
+        args = ref_list_to_args(ref_list, parent)
+        cat_list = run_generator_with_args(generator_program_hex, args, constants, cost)
+
+    return cat_list

chia/_tests/util/setup_nodes.py

@@ -0,0 +1,481 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+from collections.abc import AsyncIterator
+from contextlib import AsyncExitStack, ExitStack, asynccontextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Union
+
+import anyio
+
+from chia._tests.environments.full_node import FullNodeEnvironment
+from chia._tests.environments.wallet import WalletEnvironment
+from chia.consensus.constants import ConsensusConstants
+from chia.daemon.server import WebSocketServer
+from chia.farmer.farmer import Farmer
+from chia.full_node.full_node_api import FullNodeAPI
+from chia.harvester.harvester import Harvester
+from chia.introducer.introducer_api import IntroducerAPI
+from chia.protocols.shared_protocol import Capability
+from chia.rpc.wallet_rpc_client import WalletRpcClient
+from chia.server.server import ChiaServer
+from chia.simulator.block_tools import BlockTools, create_block_tools_async
+from chia.simulator.full_node_simulator import FullNodeSimulator
+from chia.simulator.keyring import TempKeyring
+from chia.simulator.setup_services import (
+    setup_daemon,
+    setup_farmer,
+    setup_full_node,
+    setup_harvester,
+    setup_introducer,
+    setup_timelord,
+    setup_vdf_client,
+    setup_vdf_clients,
+    setup_wallet_node,
+)
+from chia.simulator.socket import find_available_listen_port
+from chia.simulator.start_simulator import SimulatorFullNodeService
+from chia.types.aliases import FarmerService, FullNodeService, HarvesterService, TimelordService, WalletService
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.peer_info import UnresolvedPeerInfo
+from chia.util.hash import std_hash
+from chia.util.ints import uint16, uint32
+from chia.util.keychain import Keychain
+from chia.util.timing import adjusted_timeout, backoff_times
+from chia.wallet.wallet_node import WalletNode
+
+OldSimulatorsAndWallets = tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools]
+SimulatorsAndWalletsServices = tuple[list[SimulatorFullNodeService], list[WalletService], BlockTools]
+
+
+@dataclass(frozen=True)
+class FullSystem:
+    node_1: Union[FullNodeService, SimulatorFullNodeService]
+    node_2: Union[FullNodeService, SimulatorFullNodeService]
+    harvester: Harvester
+    farmer: Farmer
+    introducer: IntroducerAPI
+    timelord: TimelordService
+    timelord_bluebox: TimelordService
+    daemon: WebSocketServer
+
+
+@dataclass
+class SimulatorsAndWallets:
+    simulators: list[FullNodeEnvironment]
+    wallets: list[WalletEnvironment]
+    bt: BlockTools
+
+
+def cleanup_keyring(keyring: TempKeyring) -> None:
+    keyring.cleanup()
+
+
+log = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def setup_two_nodes(
+    consensus_constants: ConsensusConstants, db_version: int, self_hostname: str
+) -> AsyncIterator[tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools]]:
+    """
+    Setup and teardown of two full nodes, with blockchains and separate DBs.
+    """
+
+    config_overrides = {"full_node.max_sync_wait": 0, "full_node.log_coins": True}
+    with TempKeyring(populate=True) as keychain1, TempKeyring(populate=True) as keychain2:
+        bt1 = await create_block_tools_async(
+            constants=consensus_constants, keychain=keychain1, config_overrides=config_overrides
+        )
+        async with setup_full_node(
+            consensus_constants,
+            "blockchain_test.db",
+            self_hostname,
+            bt1,
+            simulator=False,
+            db_version=db_version,
+        ) as service1:
+            async with setup_full_node(
+                consensus_constants,
+                "blockchain_test_2.db",
+                self_hostname,
+                await create_block_tools_async(
+                    constants=consensus_constants, keychain=keychain2, config_overrides=config_overrides
+                ),
+                simulator=False,
+                db_version=db_version,
+            ) as service2:
+                fn1 = service1._api
+                fn2 = service2._api
+
+                yield fn1, fn2, fn1.full_node.server, fn2.full_node.server, bt1
+
+
+@asynccontextmanager
+async def setup_n_nodes(
+    consensus_constants: ConsensusConstants, n: int, db_version: int, self_hostname: str
+) -> AsyncIterator[list[FullNodeAPI]]:
+    """
+    Setup and teardown of n full nodes, with blockchains and separate DBs.
+    """
+    config_overrides = {"full_node.max_sync_wait": 0, "full_node.log_coins": True}
+    with ExitStack() as stack:
+        keychains = [stack.enter_context(TempKeyring(populate=True)) for _ in range(n)]
+        async with AsyncExitStack() as async_exit_stack:
+            nodes = [
+                await async_exit_stack.enter_async_context(
+                    setup_full_node(
+                        consensus_constants,
+                        f"blockchain_test_{i}.db",
+                        self_hostname,
+                        await create_block_tools_async(
+                            constants=consensus_constants, keychain=keychain, config_overrides=config_overrides
+                        ),
+                        simulator=False,
+                        db_version=db_version,
+                    )
+                )
+                for i, keychain in enumerate(keychains)
+            ]
+
+            yield [node._api for node in nodes]
+
+
+@asynccontextmanager
+async def setup_simulators_and_wallets(
+    simulator_count: int,
+    wallet_count: int,
+    consensus_constants: ConsensusConstants,
+    spam_filter_after_n_txs: int = 200,
+    xch_spam_amount: int = 1000000,
+    *,
+    key_seed: Optional[bytes32] = None,
+    initial_num_public_keys: int = 5,
+    db_version: int = 2,
+    config_overrides: Optional[dict[str, int]] = None,
+    disable_capabilities: Optional[list[Capability]] = None,
+) -> AsyncIterator[SimulatorsAndWallets]:
+    with TempKeyring(populate=True) as keychain1, TempKeyring(populate=True) as keychain2:
+        if config_overrides is None:
+            config_overrides = {}
+        async with setup_simulators_and_wallets_inner(
+            db_version,
+            consensus_constants,
+            initial_num_public_keys,
+            key_seed,
+            keychain1,
+            keychain2,
+            simulator_count,
+            spam_filter_after_n_txs,
+            wallet_count,
+            xch_spam_amount,
+            config_overrides,
+            disable_capabilities,
+        ) as (bt_tools, simulators, wallets_services):
+            async with contextlib.AsyncExitStack() as exit_stack:
+                wallets: list[WalletEnvironment] = []
+                for service in wallets_services:
+                    assert service.rpc_server is not None
+
+                    rpc_client = await exit_stack.enter_async_context(
+                        WalletRpcClient.create_as_context(
+                            self_hostname=service.self_hostname,
+                            port=service.rpc_server.listen_port,
+                            root_path=service.root_path,
+                            net_config=service.config,
+                        ),
+                    )
+                    wallets.append(WalletEnvironment(service=service, rpc_client=rpc_client))
+
+                yield SimulatorsAndWallets(
+                    simulators=[FullNodeEnvironment(service=service) for service in simulators],
+                    wallets=wallets,
+                    bt=bt_tools[0],
+                )
+
+
+@asynccontextmanager
+async def setup_simulators_and_wallets_service(
+    simulator_count: int,
+    wallet_count: int,
+    consensus_constants: ConsensusConstants,
+    spam_filter_after_n_txs: int = 200,
+    xch_spam_amount: int = 1000000,
+    *,
+    key_seed: Optional[bytes32] = None,
+    initial_num_public_keys: int = 5,
+    db_version: int = 2,
+    config_overrides: Optional[dict[str, int]] = None,
+    disable_capabilities: Optional[list[Capability]] = None,
+) -> AsyncIterator[tuple[list[SimulatorFullNodeService], list[WalletService], BlockTools]]:
+    with TempKeyring(populate=True) as keychain1, TempKeyring(populate=True) as keychain2:
+        async with setup_simulators_and_wallets_inner(
+            db_version,
+            consensus_constants,
+            initial_num_public_keys,
+            key_seed,
+            keychain1,
+            keychain2,
+            simulator_count,
+            spam_filter_after_n_txs,
+            wallet_count,
+            xch_spam_amount,
+            config_overrides,
+            disable_capabilities,
+        ) as (bt_tools, simulators, wallets_services):
+            yield simulators, wallets_services, bt_tools[0]
+
+
+@asynccontextmanager
+async def setup_simulators_and_wallets_inner(
+    db_version: int,
+    consensus_constants: ConsensusConstants,
+    initial_num_public_keys: int,
+    key_seed: Optional[bytes32],
+    keychain1: Keychain,
+    keychain2: Keychain,
+    simulator_count: int,
+    spam_filter_after_n_txs: int,
+    wallet_count: int,
+    xch_spam_amount: int,
+    config_overrides: Optional[dict[str, int]],
+    disable_capabilities: Optional[list[Capability]],
+) -> AsyncIterator[tuple[list[BlockTools], list[SimulatorFullNodeService], list[WalletService]]]:
+    if config_overrides is not None and "full_node.max_sync_wait" not in config_overrides:
+        config_overrides["full_node.max_sync_wait"] = 0
+        config_overrides["full_node.log_coins"] = True
+    async with AsyncExitStack() as async_exit_stack:
+        bt_tools: list[BlockTools] = [
+            await create_block_tools_async(consensus_constants, keychain=keychain1, config_overrides=config_overrides)
+            for _ in range(0, simulator_count)
+        ]
+        if wallet_count > simulator_count:
+            for _ in range(0, wallet_count - simulator_count):
+                bt_tools.append(
+                    await create_block_tools_async(
+                        consensus_constants, keychain=keychain2, config_overrides=config_overrides
+                    )
+                )
+
+        simulators: list[SimulatorFullNodeService] = [
+            await async_exit_stack.enter_async_context(
+                # Passing simulator=True gets us this type guaranteed
+                setup_full_node(  # type: ignore[arg-type]
+                    consensus_constants=bt_tools[index].constants,
+                    db_name=f"blockchain_test_{index}_sim_and_wallets.db",
+                    self_hostname=bt_tools[index].config["self_hostname"],
+                    local_bt=bt_tools[index],
+                    simulator=True,
+                    db_version=db_version,
+                    disable_capabilities=disable_capabilities,
+                )
+            )
+            for index in range(0, simulator_count)
+        ]
+
+        wallets: list[WalletService] = [
+            await async_exit_stack.enter_async_context(
+                setup_wallet_node(
+                    bt_tools[index].config["self_hostname"],
+                    bt_tools[index].constants,
+                    bt_tools[index],
+                    spam_filter_after_n_txs,
+                    xch_spam_amount,
+                    None,
+                    key_seed=std_hash(uint32(index).stream_to_bytes()) if key_seed is None else key_seed,
+                    initial_num_public_keys=initial_num_public_keys,
+                )
+            )
+            for index in range(0, wallet_count)
+        ]
+
+        yield bt_tools, simulators, wallets
+
+
+@asynccontextmanager
+async def setup_farmer_multi_harvester(
+    block_tools: BlockTools,
+    harvester_count: int,
+    temp_dir: Path,
+    consensus_constants: ConsensusConstants,
+    *,
+    start_services: bool,
+) -> AsyncIterator[tuple[list[HarvesterService], FarmerService, BlockTools]]:
+    async with AsyncExitStack() as async_exit_stack:
+        farmer_service = await async_exit_stack.enter_async_context(
+            setup_farmer(
+                block_tools,
+                temp_dir / "farmer",
+                block_tools.config["self_hostname"],
+                consensus_constants,
+                port=uint16(0),
+                start_service=start_services,
+            )
+        )
+        if start_services:
+            farmer_peer = UnresolvedPeerInfo(block_tools.config["self_hostname"], farmer_service._server.get_port())
+        else:
+            farmer_peer = None
+        harvester_services = [
+            await async_exit_stack.enter_async_context(
+                setup_harvester(
+                    block_tools,
+                    temp_dir / f"harvester_{i}",
+                    farmer_peer,
+                    consensus_constants,
+                    start_service=start_services,
+                )
+            )
+            for i in range(0, harvester_count)
+        ]
+
+        yield harvester_services, farmer_service, block_tools
+
+
+@asynccontextmanager
+async def setup_full_system(
+    consensus_constants: ConsensusConstants,
+    shared_b_tools: BlockTools,
+    b_tools: Optional[BlockTools] = None,
+    b_tools_1: Optional[BlockTools] = None,
+    db_version: int = 2,
+) -> AsyncIterator[FullSystem]:
+    with TempKeyring(populate=True) as keychain1, TempKeyring(populate=True) as keychain2:
+        async with setup_full_system_inner(
+            b_tools, b_tools_1, False, consensus_constants, db_version, keychain1, keychain2, shared_b_tools
+        ) as full_system:
+            yield full_system
+
+
+@asynccontextmanager
+async def setup_full_system_inner(
+    b_tools: Optional[BlockTools],
+    b_tools_1: Optional[BlockTools],
+    connect_to_daemon: bool,
+    consensus_constants: ConsensusConstants,
+    db_version: int,
+    keychain1: Keychain,
+    keychain2: Keychain,
+    shared_b_tools: BlockTools,
+) -> AsyncIterator[FullSystem]:
+    config_overrides = {"full_node.max_sync_wait": 0, "full_node.log_coins": True}
+    if b_tools is None:
+        b_tools = await create_block_tools_async(
+            constants=consensus_constants, keychain=keychain1, config_overrides=config_overrides
+        )
+    if b_tools_1 is None:
+        b_tools_1 = await create_block_tools_async(
+            constants=consensus_constants, keychain=keychain2, config_overrides=config_overrides
+        )
+
+    self_hostname = shared_b_tools.config["self_hostname"]
+
+    async with AsyncExitStack() as async_exit_stack:
+        vdf1_port = uint16(find_available_listen_port("vdf1"))
+        vdf2_port = uint16(find_available_listen_port("vdf2"))
+
+        await async_exit_stack.enter_async_context(
+            setup_vdf_clients(bt=b_tools, self_hostname=self_hostname, port=vdf1_port)
+        )
+        await async_exit_stack.enter_async_context(
+            setup_vdf_client(bt=shared_b_tools, self_hostname=self_hostname, port=vdf2_port)
+        )
+
+        daemon_ws = await async_exit_stack.enter_async_context(setup_daemon(btools=b_tools))
+
+        # Start the introducer first so we can find out the port, and use that for the nodes
+        introducer_service = await async_exit_stack.enter_async_context(setup_introducer(shared_b_tools, uint16(0)))
+        introducer = introducer_service._api
+        introducer_server = introducer_service._node.server
+
+        # Then start the full node so we can use the port for the farmer and timelord
+        node_1 = await async_exit_stack.enter_async_context(
+            setup_full_node(
+                consensus_constants,
+                "blockchain_test_1.db",
+                self_hostname=self_hostname,
+                local_bt=b_tools,
+                introducer_port=introducer_server._port,
+                simulator=False,
+                send_uncompact_interval=0,
+                sanitize_weight_proof_only=False,
+                connect_to_daemon=connect_to_daemon,
+                db_version=db_version,
+            )
+        )
+        node_2 = await async_exit_stack.enter_async_context(
+            setup_full_node(
+                consensus_constants,
+                "blockchain_test_2.db",
+                self_hostname=self_hostname,
+                local_bt=b_tools_1,
+                introducer_port=introducer_server._port,
+                simulator=False,
+                send_uncompact_interval=10,
+                sanitize_weight_proof_only=True,
+                connect_to_daemon=False,  # node 2 doesn't connect to the daemon
+                db_version=db_version,
+            )
+        )
+
+        farmer_service = await async_exit_stack.enter_async_context(
+            setup_farmer(
+                shared_b_tools,
+                shared_b_tools.root_path / "harvester",
+                self_hostname=self_hostname,
+                consensus_constants=consensus_constants,
+                full_node_port=node_1._api.full_node.server.get_port(),
+            )
+        )
+        harvester_service = await async_exit_stack.enter_async_context(
+            setup_harvester(
+                shared_b_tools,
+                shared_b_tools.root_path / "harvester",
+                UnresolvedPeerInfo(self_hostname, farmer_service._server.get_port()),
+                consensus_constants,
+            )
+        )
+        harvester = harvester_service._node
+
+        timelord = await async_exit_stack.enter_async_context(
+            setup_timelord(
+                full_node_port=node_1._api.full_node.server.get_port(),
+                sanitizer=False,
+                consensus_constants=consensus_constants,
+                config=b_tools.config,
+                root_path=b_tools.root_path,
+                vdf_port=vdf1_port,
+            )
+        )
+        timelord_bluebox_service = await async_exit_stack.enter_async_context(
+            setup_timelord(
+                node_2._api.full_node.server.get_port(),
+                True,
+                consensus_constants,
+                b_tools_1.config,
+                b_tools_1.root_path,
+                vdf_port=vdf2_port,
+            )
+        )
+
+        with anyio.fail_after(delay=adjusted_timeout(10)):
+            for backoff in backoff_times():
+                if len(harvester.server.all_connections.items()) > 0:
+                    break
+
+                await asyncio.sleep(backoff)
+
+        full_system = FullSystem(
+            node_1=node_1,
+            node_2=node_2,
+            harvester=harvester,
+            farmer=farmer_service._node,
+            introducer=introducer,
+            timelord=timelord,
+            timelord_bluebox=timelord_bluebox_service,
+            daemon=daemon_ws,
+        )
+        yield full_system