chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/_tests/core/server/test_rate_limits.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
 import asyncio
-from typing import List
 
 import pytest
 
 from chia._tests.conftest import node_with_params
+from chia._tests.util.time_out_assert import time_out_assert
+from chia.protocols.full_node_protocol import RejectBlock, RejectBlocks, RespondBlock, RespondBlocks
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.shared_protocol import Capability
 from chia.server.outbound_message import make_msg
@@ -14,12 +15,14 @@ from chia.server.rate_limit_numbers import rate_limits as rl_numbers
 from chia.server.rate_limits import RateLimiter
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
+from chia.simulator.block_tools import BlockTools
 from chia.types.peer_info import PeerInfo
+from chia.util.ints import uint32
 
 rl_v2 = [Capability.BASE, Capability.BLOCK_HEADERS, Capability.RATE_LIMITS_V2]
 rl_v1 = [Capability.BASE]
 node_with_params_b = node_with_params
-test_different_versions_results: List[int] = []
+test_different_versions_results: list[int] = []
 
 
 class TestRateLimits:
@@ -35,12 +38,12 @@ class TestRateLimits:
         r = RateLimiter(incoming=True)
         new_tx_message = make_msg(ProtocolMessageTypes.new_transaction, bytes([1] * 40))
         for i in range(4999):
-            assert r.process_msg_and_check(new_tx_message, rl_v2, rl_v2)
+            assert r.process_msg_and_check(new_tx_message, rl_v2, rl_v2) is None
 
         saw_disconnect = False
         for i in range(4999):
             response = r.process_msg_and_check(new_tx_message, rl_v2, rl_v2)
-            if not response:
+            if response is not None:
                 saw_disconnect = True
         assert saw_disconnect
 
@@ -48,12 +51,12 @@ class TestRateLimits:
         r = RateLimiter(incoming=True)
         new_peak_message = make_msg(ProtocolMessageTypes.new_peak, bytes([1] * 40))
         for i in range(200):
-            assert r.process_msg_and_check(new_peak_message, rl_v2, rl_v2)
+            assert r.process_msg_and_check(new_peak_message, rl_v2, rl_v2) is None
 
         saw_disconnect = False
         for i in range(200):
             response = r.process_msg_and_check(new_peak_message, rl_v2, rl_v2)
-            if not response:
+            if response is not None:
                 saw_disconnect = True
         assert saw_disconnect
 
@@ -64,15 +67,18 @@ class TestRateLimits:
         large_tx_message = make_msg(ProtocolMessageTypes.new_transaction, bytes([1] * 3 * 1024 * 1024))
 
         r = RateLimiter(incoming=True)
-        assert r.process_msg_and_check(small_tx_message, rl_v2, rl_v2)
-        assert not r.process_msg_and_check(large_tx_message, rl_v2, rl_v2)
+        assert r.process_msg_and_check(small_tx_message, rl_v2, rl_v2) is None
+        assert r.process_msg_and_check(large_tx_message, rl_v2, rl_v2) is not None
 
         small_vdf_message = make_msg(ProtocolMessageTypes.respond_signage_point, bytes([1] * 5 * 1024))
         large_vdf_message = make_msg(ProtocolMessageTypes.respond_signage_point, bytes([1] * 600 * 1024))
+        large_blocks_message = make_msg(ProtocolMessageTypes.respond_blocks, bytes([1] * 51 * 1024 * 1024))
         r = RateLimiter(incoming=True)
-        assert r.process_msg_and_check(small_vdf_message, rl_v2, rl_v2)
-        assert r.process_msg_and_check(small_vdf_message, rl_v2, rl_v2)
-        assert not r.process_msg_and_check(large_vdf_message, rl_v2, rl_v2)
+        assert r.process_msg_and_check(small_vdf_message, rl_v2, rl_v2) is None
+        assert r.process_msg_and_check(small_vdf_message, rl_v2, rl_v2) is None
+        assert r.process_msg_and_check(large_vdf_message, rl_v2, rl_v2) is not None
+        # this limit applies even though this message type is unlimited
+        assert r.process_msg_and_check(large_blocks_message, rl_v2, rl_v2) is not None
 
     @pytest.mark.anyio
     async def test_too_much_data(self):
@@ -80,24 +86,24 @@ class TestRateLimits:
         r = RateLimiter(incoming=True)
         tx_message = make_msg(ProtocolMessageTypes.respond_transaction, bytes([1] * 500 * 1024))
         for i in range(40):
-            assert r.process_msg_and_check(tx_message, rl_v2, rl_v2)
+            assert r.process_msg_and_check(tx_message, rl_v2, rl_v2) is None
 
         saw_disconnect = False
         for i in range(300):
             response = r.process_msg_and_check(tx_message, rl_v2, rl_v2)
-            if not response:
+            if response is not None:
                 saw_disconnect = True
         assert saw_disconnect
 
         r = RateLimiter(incoming=True)
-        block_message = make_msg(ProtocolMessageTypes.respond_block, bytes([1] * 1024 * 1024))
+        block_message = make_msg(ProtocolMessageTypes.respond_unfinished_block, bytes([1] * 1024 * 1024))
         for i in range(10):
-            assert r.process_msg_and_check(block_message, rl_v2, rl_v2)
+            assert r.process_msg_and_check(block_message, rl_v2, rl_v2) is None
 
         saw_disconnect = False
         for i in range(40):
             response = r.process_msg_and_check(block_message, rl_v2, rl_v2)
-            if not response:
+            if response is not None:
                 saw_disconnect = True
         assert saw_disconnect
 
@@ -110,30 +116,30 @@ class TestRateLimits:
         message_3 = make_msg(ProtocolMessageTypes.plot_sync_start, bytes([1] * 64))
 
         for i in range(500):
-            assert r.process_msg_and_check(message_1, rl_v2, rl_v2)
+            assert r.process_msg_and_check(message_1, rl_v2, rl_v2) is None
 
         for i in range(500):
-            assert r.process_msg_and_check(message_2, rl_v2, rl_v2)
+            assert r.process_msg_and_check(message_2, rl_v2, rl_v2) is None
 
         saw_disconnect = False
         for i in range(500):
             response = r.process_msg_and_check(message_3, rl_v2, rl_v2)
-            if not response:
+            if response is not None:
                 saw_disconnect = True
         assert saw_disconnect
 
         # Size limits
         r = RateLimiter(incoming=True)
         message_4 = make_msg(ProtocolMessageTypes.respond_proof_of_weight, bytes([1] * 49 * 1024 * 1024))
-        message_5 = make_msg(ProtocolMessageTypes.respond_blocks, bytes([1] * 49 * 1024 * 1024))
+        message_5 = make_msg(ProtocolMessageTypes.request_blocks, bytes([1] * 49 * 1024 * 1024))
 
         for i in range(2):
-            assert r.process_msg_and_check(message_4, rl_v2, rl_v2)
+            assert r.process_msg_and_check(message_4, rl_v2, rl_v2) is None
 
         saw_disconnect = False
         for i in range(2):
             response = r.process_msg_and_check(message_5, rl_v2, rl_v2)
-            if not response:
+            if response is not None:
                 saw_disconnect = True
         assert saw_disconnect
 
@@ -142,56 +148,56 @@ class TestRateLimits:
         r = RateLimiter(True, 5)
         tx_message = make_msg(ProtocolMessageTypes.respond_transaction, bytes([1] * 500 * 1024))
         for i in range(10):
-            assert r.process_msg_and_check(tx_message, rl_v2, rl_v2)
+            assert r.process_msg_and_check(tx_message, rl_v2, rl_v2) is None
 
         saw_disconnect = False
         for i in range(300):
             response = r.process_msg_and_check(tx_message, rl_v2, rl_v2)
-            if not response:
+            if response is not None:
                 saw_disconnect = True
         assert saw_disconnect
-        assert not r.process_msg_and_check(tx_message, rl_v2, rl_v2)
+        assert r.process_msg_and_check(tx_message, rl_v2, rl_v2) is not None
         await asyncio.sleep(6)
-        assert r.process_msg_and_check(tx_message, rl_v2, rl_v2)
+        assert r.process_msg_and_check(tx_message, rl_v2, rl_v2) is None
 
         # Counts reset also
         r = RateLimiter(True, 5)
         new_tx_message = make_msg(ProtocolMessageTypes.new_transaction, bytes([1] * 40))
         for i in range(4999):
-            assert r.process_msg_and_check(new_tx_message, rl_v2, rl_v2)
+            assert r.process_msg_and_check(new_tx_message, rl_v2, rl_v2) is None
 
         saw_disconnect = False
         for i in range(4999):
             response = r.process_msg_and_check(new_tx_message, rl_v2, rl_v2)
-            if not response:
+            if response is not None:
                 saw_disconnect = True
         assert saw_disconnect
         await asyncio.sleep(6)
-        assert r.process_msg_and_check(new_tx_message, rl_v2, rl_v2)
+        assert r.process_msg_and_check(new_tx_message, rl_v2, rl_v2) is None
 
     @pytest.mark.anyio
     async def test_percentage_limits(self):
         r = RateLimiter(True, 60, 40)
         new_peak_message = make_msg(ProtocolMessageTypes.new_peak, bytes([1] * 40))
         for i in range(50):
-            assert r.process_msg_and_check(new_peak_message, rl_v2, rl_v2)
+            assert r.process_msg_and_check(new_peak_message, rl_v2, rl_v2) is None
 
         saw_disconnect = False
         for i in range(50):
             response = r.process_msg_and_check(new_peak_message, rl_v2, rl_v2)
-            if not response:
+            if response is not None:
                 saw_disconnect = True
         assert saw_disconnect
 
         r = RateLimiter(True, 60, 40)
-        block_message = make_msg(ProtocolMessageTypes.respond_block, bytes([1] * 1024 * 1024))
+        block_message = make_msg(ProtocolMessageTypes.respond_unfinished_block, bytes([1] * 1024 * 1024))
         for i in range(5):
-            assert r.process_msg_and_check(block_message, rl_v2, rl_v2)
+            assert r.process_msg_and_check(block_message, rl_v2, rl_v2) is None
 
         saw_disconnect = False
         for i in range(5):
             response = r.process_msg_and_check(block_message, rl_v2, rl_v2)
-            if not response:
+            if response is not None:
                 saw_disconnect = True
         assert saw_disconnect
 
@@ -202,29 +208,29 @@ class TestRateLimits:
         message_3 = make_msg(ProtocolMessageTypes.plot_sync_start, bytes([1] * 32))
 
         for i in range(180):
-            assert r.process_msg_and_check(message_1, rl_v2, rl_v2)
+            assert r.process_msg_and_check(message_1, rl_v2, rl_v2) is None
         for i in range(180):
-            assert r.process_msg_and_check(message_2, rl_v2, rl_v2)
+            assert r.process_msg_and_check(message_2, rl_v2, rl_v2) is None
 
         saw_disconnect = False
         for i in range(100):
             response = r.process_msg_and_check(message_3, rl_v2, rl_v2)
-            if not response:
+            if response is not None:
                 saw_disconnect = True
         assert saw_disconnect
 
         # Aggregate percentage limit max total size
         r = RateLimiter(True, 60, 40)
         message_4 = make_msg(ProtocolMessageTypes.respond_proof_of_weight, bytes([1] * 18 * 1024 * 1024))
-        message_5 = make_msg(ProtocolMessageTypes.respond_blocks, bytes([1] * 24 * 1024 * 1024))
+        message_5 = make_msg(ProtocolMessageTypes.respond_unfinished_block, bytes([1] * 24 * 1024 * 1024))
 
         for i in range(2):
-            assert r.process_msg_and_check(message_4, rl_v2, rl_v2)
+            assert r.process_msg_and_check(message_4, rl_v2, rl_v2) is None
 
         saw_disconnect = False
         for i in range(2):
             response = r.process_msg_and_check(message_5, rl_v2, rl_v2)
-            if not response:
+            if response is not None:
                 saw_disconnect = True
         assert saw_disconnect
 
@@ -238,7 +244,7 @@ class TestRateLimits:
         passed = 0
         blocked = 0
         for i in range(non_tx_freq):
-            if r.process_msg_and_check(new_peers_message, rl_v2, rl_v2):
+            if r.process_msg_and_check(new_peers_message, rl_v2, rl_v2) is None:
                 passed += 1
             else:
                 blocked += 1
@@ -249,7 +255,7 @@ class TestRateLimits:
         # ensure that *another* message type is not blocked because of this
 
         new_signatures_message = make_msg(ProtocolMessageTypes.respond_signatures, bytes([1]))
-        assert r.process_msg_and_check(new_signatures_message, rl_v2, rl_v2)
+        assert r.process_msg_and_check(new_signatures_message, rl_v2, rl_v2) is None
 
     @pytest.mark.anyio
     async def test_too_many_incoming_messages(self):
@@ -261,7 +267,7 @@ class TestRateLimits:
         passed = 0
         blocked = 0
         for i in range(non_tx_freq):
-            if r.process_msg_and_check(new_peers_message, rl_v2, rl_v2):
+            if r.process_msg_and_check(new_peers_message, rl_v2, rl_v2) is None:
                 passed += 1
             else:
                 blocked += 1
@@ -272,7 +278,7 @@ class TestRateLimits:
         # ensure that other message types *are* blocked because of this
 
         new_signatures_message = make_msg(ProtocolMessageTypes.respond_signatures, bytes([1]))
-        assert not r.process_msg_and_check(new_signatures_message, rl_v2, rl_v2)
+        assert r.process_msg_and_check(new_signatures_message, rl_v2, rl_v2) is not None
 
     @pytest.mark.parametrize(
         "node_with_params",
@@ -368,3 +374,109 @@ class TestRateLimits:
         # Otherwise, fall back to v1
         assert ProtocolMessageTypes.request_block in rl_1["rate_limits_other"]
         assert ProtocolMessageTypes.request_block not in rl_1["rate_limits_tx"]
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "msg_type, size",
+    [
+        (ProtocolMessageTypes.respond_blocks, 10 * 1024 * 1024),
+        (ProtocolMessageTypes.reject_blocks, 90),
+        (ProtocolMessageTypes.respond_block, 1024 * 1024),
+        (ProtocolMessageTypes.reject_block, 90),
+    ],
+)
+async def test_unlimited(msg_type: ProtocolMessageTypes, size: int):
+    r = RateLimiter(incoming=False)
+
+    message = make_msg(msg_type, bytes([1] * size))
+
+    for i in range(1000):
+        # since this is a backwards compatible change, it also affects V1
+        assert r.process_msg_and_check(message, rl_v1, rl_v1) is None
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "msg_type",
+    [
+        ProtocolMessageTypes.respond_blocks,
+        ProtocolMessageTypes.reject_blocks,
+        ProtocolMessageTypes.respond_block,
+        ProtocolMessageTypes.reject_block,
+    ],
+)
+@pytest.mark.parametrize(
+    "node_with_params",
+    [
+        pytest.param(
+            dict(
+                disable_capabilities=[Capability.BLOCK_HEADERS, Capability.RATE_LIMITS_V2],
+            ),
+            id="V1",
+        ),
+        pytest.param(
+            dict(
+                disable_capabilities=[],
+            ),
+            id="V2",
+        ),
+    ],
+    indirect=True,
+)
+@pytest.mark.parametrize(
+    "node_with_params_b",
+    [
+        pytest.param(
+            dict(
+                disable_capabilities=[Capability.BLOCK_HEADERS, Capability.RATE_LIMITS_V2],
+            ),
+            id="V1",
+        ),
+        pytest.param(
+            dict(
+                disable_capabilities=[],
+            ),
+            id="V2",
+        ),
+    ],
+    indirect=True,
+)
+async def test_unsolicited_responses(
+    node_with_params, node_with_params_b, self_hostname: str, msg_type: ProtocolMessageTypes, bt: BlockTools
+):
+    node_a = node_with_params
+    node_b = node_with_params_b
+
+    msg = {
+        ProtocolMessageTypes.respond_blocks: make_msg(
+            ProtocolMessageTypes.respond_blocks, bytes(RespondBlocks(uint32(1), uint32(2), []))
+        ),
+        ProtocolMessageTypes.reject_blocks: make_msg(
+            ProtocolMessageTypes.reject_blocks, bytes(RejectBlocks(uint32(1), uint32(2)))
+        ),
+        ProtocolMessageTypes.respond_block: make_msg(
+            ProtocolMessageTypes.respond_block, bytes(RespondBlock(bt.get_consecutive_blocks(1)[0]))
+        ),
+        ProtocolMessageTypes.reject_block: make_msg(ProtocolMessageTypes.reject_block, bytes(RejectBlock(uint32(0)))),
+    }[msg_type]
+
+    full_node_server_a: ChiaServer = node_a.full_node.server
+    full_node_server_b: ChiaServer = node_b.full_node.server
+
+    await full_node_server_b.start_client(PeerInfo(self_hostname, full_node_server_a.get_port()), None)
+
+    assert len(full_node_server_b.get_connections()) == 1
+    assert len(full_node_server_a.get_connections()) == 1
+
+    a_con: WSChiaConnection = full_node_server_a.get_connections()[0]
+    b_con: WSChiaConnection = full_node_server_b.get_connections()[0]
+
+    assert not a_con.closed
+    assert not b_con.closed
+
+    await a_con.send_message(msg)
+
+    # make sure the connection is closed because of the unsolicited response
+    # message
+    await time_out_assert(5, lambda: a_con.closed)

chia/_tests/core/server/test_server.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass
-from typing import Callable, Tuple, cast
+from typing import Callable, ClassVar, cast
 
 import pytest
 from packaging.version import Version
@@ -16,6 +16,7 @@ from chia.protocols.full_node_protocol import RejectBlock, RequestBlock, Request
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.shared_protocol import Error, protocol_version
 from chia.protocols.wallet_protocol import RejectHeaderRequest
+from chia.server.api_protocol import ApiMetadata
 from chia.server.outbound_message import NodeType, make_msg
 from chia.server.server import ChiaServer
 from chia.server.start_full_node import create_full_node_service
@@ -24,7 +25,6 @@ from chia.server.ws_connection import WSChiaConnection, error_response_version
 from chia.simulator.block_tools import BlockTools
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.peer_info import PeerInfo
-from chia.util.api_decorators import api_request
 from chia.util.errors import ApiError, Err
 from chia.util.ints import int16, uint32
 
@@ -32,19 +32,20 @@ from chia.util.ints import int16, uint32
 @dataclass
 class TestAPI:
     log: logging.Logger = logging.getLogger(__name__)
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
 
     def ready(self) -> bool:
         return True
 
     # API call from FullNodeAPI
-    @api_request()
+    @metadata.request()
     async def request_transaction(self, request: RequestTransaction) -> None:
         raise ApiError(Err.NO_TRANSACTIONS_WHILE_SYNCING, f"Some error message: {request.transaction_id}", b"ab")
 
 
 @pytest.mark.anyio
 async def test_duplicate_client_connection(
-    two_nodes: Tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools], self_hostname: str
+    two_nodes: tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools], self_hostname: str
 ) -> None:
     _, _, server_1, server_2, _ = two_nodes
     assert await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
@@ -54,7 +55,7 @@ async def test_duplicate_client_connection(
 @pytest.mark.anyio
 @pytest.mark.parametrize("method", [repr, str])
 async def test_connection_string_conversion(
-    two_nodes_one_block: Tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools],
+    two_nodes_one_block: tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools],
     self_hostname: str,
     method: Callable[[object], str],
 ) -> None:
@@ -178,7 +179,7 @@ async def test_error_receive(
 
 @pytest.mark.anyio
 async def test_call_api_of_specific(
-    two_nodes: Tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools], self_hostname: str
+    two_nodes: tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools], self_hostname: str
 ) -> None:
     _, _, server_1, server_2, _ = two_nodes
     assert await server_1.start_client(PeerInfo(self_hostname, server_2.get_port()), None)
@@ -193,7 +194,7 @@ async def test_call_api_of_specific(
 
 @pytest.mark.anyio
 async def test_call_api_of_specific_for_missing_peer(
-    two_nodes: Tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools]
+    two_nodes: tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools],
 ) -> None:
     _, _, server_1, server_2, _ = two_nodes
 

chia/_tests/core/services/test_services.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import signal
 import sys
 import time
+from collections.abc import AsyncIterator
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Optional, cast
 
 import aiohttp.client_exceptions
 import pytest
@@ -34,16 +36,18 @@ else:
 
 
 class CreateServiceProtocol(Protocol):
+    @contextlib.asynccontextmanager
     async def __call__(
         self,
         self_hostname: str,
         port: uint16,
         root_path: Path,
-        net_config: Dict[str, Any],
-    ) -> RpcClient: ...
+        net_config: dict[str, Any],
+    ) -> AsyncIterator[RpcClient]:
+        yield cast(RpcClient, None)  # pragma: no cover
 
 
-async def wait_for_daemon_connection(root_path: Path, config: Dict[str, Any], timeout: float = 15) -> DaemonProxy:
+async def wait_for_daemon_connection(root_path: Path, config: dict[str, Any], timeout: float = 15) -> DaemonProxy:
     timeout = adjusted_timeout(timeout=timeout)
 
     start = time.monotonic()
@@ -82,34 +86,46 @@ async def test_daemon_terminates(signal_number: signal.Signals, chia_root: ChiaR
 @pytest.mark.parametrize(
     argnames=["create_service", "module_path", "service_config_name"],
     argvalues=[
-        [DataLayerRpcClient.create, "chia.server.start_data_layer", "data_layer"],
-        [FarmerRpcClient.create, "chia.server.start_farmer", "farmer"],
-        [FullNodeRpcClient.create, "chia.server.start_full_node", "full_node"],
-        [HarvesterRpcClient.create, "chia.server.start_harvester", "harvester"],
-        [WalletRpcClient.create, "chia.server.start_wallet", "wallet"],
-        # TODO: review and somehow test the other services too
-        # [, "chia.server.start_introducer", "introducer"],
-        # [, "chia.seeder.start_crawler", ""],
-        # [, "chia.server.start_timelord", "timelord"],
-        # [, "chia.timelord.timelord_launcher", ],
-        # [, "chia.simulator.start_simulator", ],
-        # [, "chia.data_layer.data_layer_server", "data_layer"],
+        [DataLayerRpcClient.create_as_context, "chia.server.start_data_layer", "data_layer"],
+        [FarmerRpcClient.create_as_context, "chia.server.start_farmer", "farmer"],
+        [FullNodeRpcClient.create_as_context, "chia.server.start_full_node", "full_node"],
+        [HarvesterRpcClient.create_as_context, "chia.server.start_harvester", "harvester"],
+        [WalletRpcClient.create_as_context, "chia.server.start_wallet", "wallet"],
+        [None, "chia.server.start_introducer", "introducer"],
+        # TODO: fails...  make it not do that
+        # [None, "chia.seeder.start_crawler", "crawler"],
+        [None, "chia.server.start_timelord", "timelord"],
+        pytest.param(
+            None,
+            "chia.timelord.timelord_launcher",
+            "timelord_launcher",
+            marks=pytest.mark.skipif(
+                sys.platform in {"win32", "cygwin"},
+                reason="windows is not supported by the timelord launcher",
+            ),
+        ),
+        # TODO: fails...  starts creating plots etc
+        # [None, "chia.simulator.start_simulator", "simulator"],
+        # TODO: fails...  make it not do that
+        # [None, "chia.data_layer.data_layer_server", "data_layer"],
     ],
 )
 @pytest.mark.anyio
 async def test_services_terminate(
     signal_number: signal.Signals,
     chia_root: ChiaRoot,
-    create_service: CreateServiceProtocol,
+    create_service: Optional[CreateServiceProtocol],
     module_path: str,
     service_config_name: str,
 ) -> None:
     with lock_and_load_config(root_path=chia_root.path, filename="config.yaml") as config:
         config["daemon_port"] = find_available_listen_port(name="daemon")
         service_config = config[service_config_name]
-        if "port" in service_config:
-            port = find_available_listen_port(name="service")
-            service_config["port"] = port
+        api_port_group = service_config
+        if service_config_name == "timelord":
+            api_port_group = api_port_group["vdf_server"]
+        if "port" in api_port_group:
+            api_port_group["port"] = 0
         rpc_port = find_available_listen_port(name="rpc")
         service_config["rpc_port"] = rpc_port
         save_config(root_path=chia_root.path, filename="config.yaml", config_data=config)
@@ -125,17 +141,26 @@ async def test_services_terminate(
         daemon_client = await wait_for_daemon_connection(root_path=chia_root.path, config=config)
         await daemon_client.close()
 
-        with closing_chia_root_popen(
-            chia_root=chia_root,
-            args=[sys.executable, "-m", module_path],
-        ) as process:
-            client = await create_service(
-                self_hostname=config["self_hostname"],
-                port=uint16(rpc_port),
-                root_path=chia_root.path,
-                net_config=config,
+        async with contextlib.AsyncExitStack() as exit_stack:
+            process = exit_stack.enter_context(
+                closing_chia_root_popen(
+                    chia_root=chia_root,
+                    args=[sys.executable, "-m", module_path],
+                )
             )
-            try:
+
+            if create_service is None:
+                await asyncio.sleep(5)
+            else:
+                client = await exit_stack.enter_async_context(
+                    create_service(
+                        self_hostname=config["self_hostname"],
+                        port=uint16(rpc_port),
+                        root_path=chia_root.path,
+                        net_config=config,
+                    )
+                )
+
                 start = time.monotonic()
                 while time.monotonic() - start < 50:
                     return_code = process.poll()
@@ -156,11 +181,8 @@ async def test_services_terminate(
                 else:
                     raise Exception("unable to connect")
 
-                return_code = process.poll()
-                assert return_code is None
+            return_code = process.poll()
+            assert return_code is None
 
-                process.send_signal(signal_number)
-                process.communicate(timeout=adjusted_timeout(timeout=30))
-            finally:
-                client.close()
-                await client.await_closed()
+            process.send_signal(signal_number)
+            process.communicate(timeout=adjusted_timeout(timeout=30))

chia/_tests/core/ssl/test_ssl.py

@@ -8,6 +8,7 @@ import ssl
 import aiohttp
 import pytest
 
+from chia.apis import ApiProtocolRegistry
 from chia.protocols.shared_protocol import default_capabilities
 from chia.server.outbound_message import NodeType
 from chia.server.server import ChiaServer, ssl_context_for_client
@@ -33,10 +34,11 @@ async def establish_connection(server: ChiaServer, self_hostname: str, ssl_conte
             True,
             server.received_message_callback,
             None,
-            bytes32(b"\x00" * 32),
+            bytes32.zeros,
             100,
             30,
             local_capabilities_for_handshake=default_capabilities[NodeType.FULL_NODE],
+            class_for_type=ApiProtocolRegistry,
         )
         await wsc.perform_handshake(server._network_id, dummy_port, NodeType.FULL_NODE)
         await wsc.close()
@@ -84,7 +86,7 @@ class TestSSL:
         full_nodes, wallets, _ = simulator_and_wallet
         full_node_api = full_nodes[0]
         server_1: ChiaServer = full_node_api.full_node.server
-        wallet_node, server_2 = wallets[0]
+        _wallet_node, server_2 = wallets[0]
 
         success = await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
         assert success is True
@@ -165,7 +167,7 @@ class TestSSL:
 
     @pytest.mark.anyio
     async def test_full_node(self, simulator_and_wallet, self_hostname):
-        full_nodes, wallets, bt = simulator_and_wallet
+        full_nodes, _wallets, bt = simulator_and_wallet
         full_node_api = full_nodes[0]
         full_node_server = full_node_api.full_node.server
         chia_ca_crt_path, chia_ca_key_path = chia_ssl_ca_paths(bt.root_path, bt.config)