chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/_tests/core/server/test_server.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Callable, ClassVar, cast
+
+import pytest
+from packaging.version import Version
+
+from chia import __version__
+from chia._tests.connection_utils import connect_and_get_peer
+from chia._tests.util.setup_nodes import SimulatorsAndWalletsServices
+from chia._tests.util.time_out_assert import time_out_assert
+from chia.full_node.full_node_api import FullNodeAPI
+from chia.protocols.full_node_protocol import RejectBlock, RequestBlock, RequestTransaction
+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
+from chia.server.start_wallet import create_wallet_service
+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.errors import ApiError, Err
+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
+    @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
+) -> None:
+    _, _, server_1, server_2, _ = two_nodes
+    assert await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
+    assert not await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
+
+
+@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],
+    self_hostname: str,
+    method: Callable[[object], str],
+) -> None:
+    _, _, server_1, server_2, _ = two_nodes_one_block
+    peer = await connect_and_get_peer(server_1, server_2, self_hostname)
+    # 1000 is based on the current implementation (example below), should be reconsidered/adjusted if this test fails
+    # WSChiaConnection(local_type=<NodeType.FULL_NODE: 1>, local_port=50632, local_capabilities=[<Capability.BASE: 1>, <Capability.BLOCK_HEADERS: 2>, <Capability.RATE_LIMITS_V2: 3>], peer_host='127.0.0.1', peer_port=50640, peer_node_id=<bytes32: 566a318f0f656125b4fef0e85fbddcf9bc77f8003d35293c392479fc5d067f4d>, outbound_rate_limiter=<chia.server.rate_limits.RateLimiter object at 0x114a13f50>, inbound_rate_limiter=<chia.server.rate_limits.RateLimiter object at 0x114a13e90>, is_outbound=False, creation_time=1675271096.275591, bytes_read=68, bytes_written=162, last_message_time=1675271096.276271, peer_server_port=50636, active=False, closed=False, connection_type=<NodeType.FULL_NODE: 1>, request_nonce=32768, peer_capabilities=[<Capability.BASE: 1>, <Capability.BLOCK_HEADERS: 2>, <Capability.RATE_LIMITS_V2: 3>], version='', protocol_version='') # noqa
+    converted = method(peer)
+    print(converted)
+    assert len(converted) < 1000
+
+
+@pytest.mark.anyio
+async def test_connection_versions(
+    self_hostname: str, one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices
+) -> None:
+    [full_node_service], [wallet_service], _ = one_wallet_and_one_simulator_services
+    wallet_node = wallet_service._node
+    full_node = full_node_service._node
+    await wallet_node.server.start_client(
+        PeerInfo(self_hostname, cast(FullNodeAPI, full_node_service._api).server.get_port()), None
+    )
+    outgoing_connection = wallet_node.server.all_connections[full_node.server.node_id]
+    incoming_connection = full_node.server.all_connections[wallet_node.server.node_id]
+    for connection in [outgoing_connection, incoming_connection]:
+        assert connection.protocol_version == Version(protocol_version[NodeType.WALLET])
+        assert connection.version == __version__
+        assert connection.get_version() == connection.version
+
+
+@pytest.mark.anyio
+async def test_api_not_ready(
+    self_hostname: str,
+    one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    [full_node_service], [wallet_service], _ = one_wallet_and_one_simulator_services
+    wallet_node = wallet_service._node
+    full_node = full_node_service._node
+    await wallet_node.server.start_client(
+        PeerInfo(self_hostname, cast(FullNodeAPI, full_node_service._api).server.get_port()), None
+    )
+    wallet_node.log_out()
+    assert not wallet_service._api.ready()
+    connection = full_node.server.all_connections[wallet_node.server.node_id]
+
+    def request_ignored() -> bool:
+        return "API not ready, ignore request: {'data': '0x00000000', 'id': None, 'type': 53}" in caplog.text
+
+    with caplog.at_level(logging.WARNING):
+        assert await connection.send_message(
+            make_msg(ProtocolMessageTypes.reject_header_request, RejectHeaderRequest(uint32(0)))
+        )
+        await time_out_assert(10, request_ignored)
+
+
+@pytest.mark.parametrize("version", ["0.0.34", "0.0.35", "0.0.36"])
+@pytest.mark.anyio
+async def test_error_response(
+    one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices,
+    self_hostname: str,
+    caplog: pytest.LogCaptureFixture,
+    version: str,
+) -> None:
+    [full_node_service], [wallet_service], _ = one_wallet_and_one_simulator_services
+    wallet_node = wallet_service._node
+    full_node = full_node_service._node
+
+    full_node.server.api = TestAPI()
+
+    await wallet_node.server.start_client(
+        PeerInfo(self_hostname, cast(FullNodeAPI, full_node_service._api).server.get_port()), None
+    )
+    wallet_connection = full_node.server.all_connections[wallet_node.server.node_id]
+    full_node_connection = wallet_node.server.all_connections[full_node.server.node_id]
+    test_version = Version(version)
+    wallet_connection.protocol_version = test_version
+    request = RequestTransaction(bytes32(32 * b"1"))
+    error_message = f"Some error message: {request.transaction_id}"
+    with caplog.at_level(logging.DEBUG):
+        response = await full_node_connection.call_api(TestAPI.request_transaction, request, timeout=5)
+        error = ApiError(Err.NO_TRANSACTIONS_WHILE_SYNCING, error_message)
+        assert f"ApiError: {error} from {wallet_connection.peer_node_id}, {wallet_connection.peer_info}" in caplog.text
+        if test_version >= error_response_version:
+            assert response == Error(int16(Err.NO_TRANSACTIONS_WHILE_SYNCING.value), error_message, b"ab")
+            assert "Request timeout:" not in caplog.text
+        else:
+            assert response is None
+            assert "Request timeout:" in caplog.text
+
+
+@pytest.mark.parametrize(
+    "error", [Error(int16(Err.UNKNOWN.value), "1", bytes([1, 2, 3])), Error(int16(Err.UNKNOWN.value), "2", None)]
+)
+@pytest.mark.anyio
+async def test_error_receive(
+    one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices,
+    self_hostname: str,
+    caplog: pytest.LogCaptureFixture,
+    error: Error,
+) -> None:
+    [full_node_service], [wallet_service], _ = one_wallet_and_one_simulator_services
+    wallet_node = wallet_service._node
+    full_node = full_node_service._node
+    await wallet_node.server.start_client(
+        PeerInfo(self_hostname, cast(FullNodeAPI, full_node_service._api).server.get_port()), None
+    )
+    wallet_connection = full_node.server.all_connections[wallet_node.server.node_id]
+    full_node_connection = wallet_node.server.all_connections[full_node.server.node_id]
+    message = make_msg(ProtocolMessageTypes.error, error)
+
+    def error_log_found(connection: WSChiaConnection) -> bool:
+        return f"ApiError: {error} from {connection.peer_node_id}, {connection.peer_info}" in caplog.text
+
+    with caplog.at_level(logging.WARNING):
+        await full_node_connection.outgoing_queue.put(message)
+        await wallet_connection.outgoing_queue.put(message)
+        await time_out_assert(10, error_log_found, True, full_node_connection)
+        await time_out_assert(10, error_log_found, True, wallet_connection)
+
+
+@pytest.mark.anyio
+async def test_call_api_of_specific(
+    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)
+
+    message = await server_1.call_api_of_specific(
+        FullNodeAPI.request_block, RequestBlock(uint32(42), False), server_2.node_id
+    )
+
+    assert message is not None
+    assert isinstance(message, RejectBlock)
+
+
+@pytest.mark.anyio
+async def test_call_api_of_specific_for_missing_peer(
+    two_nodes: tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools],
+) -> None:
+    _, _, server_1, server_2, _ = two_nodes
+
+    message = await server_1.call_api_of_specific(
+        FullNodeAPI.request_block, RequestBlock(uint32(42), False), server_2.node_id
+    )
+
+    assert message is None
+
+
+@pytest.mark.limit_consensus_modes(reason="save time")
+@pytest.mark.anyio
+async def test_get_peer_info(bt: BlockTools) -> None:
+    wallet_service = create_wallet_service(
+        bt.root_path, bt.config, bt.constants, keychain=None, connect_to_daemon=False
+    )
+
+    # Wallet server should not have a port or peer info
+    with pytest.raises(ValueError, match="Port not set"):
+        local_port = wallet_service._server.get_port()
+    local_peer_info = await wallet_service._server.get_peer_info()
+    assert local_peer_info is None
+
+    # Full node server should have a local port
+    # testing get_peer_info() directly is flakey because it depends on IP lookup
+    # from either chia or aws
+    node_service = await create_full_node_service(bt.root_path, bt.config, bt.constants, connect_to_daemon=False)
+    local_port = node_service._server.get_port()
+    assert local_port is not None

chia/_tests/core/server/test_upnp.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+
+def test_miniupnpc_imports_successfully() -> None:
+    import miniupnpc
+
+    # use it to avoid all related warnings
+    assert miniupnpc is not None

chia/_tests/core/services/config.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+parallel = False

chia/_tests/core/services/test_services.py

@@ -0,0 +1,188 @@
+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, Optional, cast
+
+import aiohttp.client_exceptions
+import pytest
+from typing_extensions import Protocol
+
+from chia._tests.core.data_layer.util import ChiaRoot
+from chia._tests.util.misc import closing_chia_root_popen
+from chia.daemon.client import DaemonProxy, connect_to_daemon_and_validate
+from chia.rpc.data_layer_rpc_client import DataLayerRpcClient
+from chia.rpc.farmer_rpc_client import FarmerRpcClient
+from chia.rpc.full_node_rpc_client import FullNodeRpcClient
+from chia.rpc.harvester_rpc_client import HarvesterRpcClient
+from chia.rpc.rpc_client import RpcClient
+from chia.rpc.wallet_rpc_client import WalletRpcClient
+from chia.simulator.socket import find_available_listen_port
+from chia.util.config import lock_and_load_config, save_config
+from chia.util.ints import uint16
+from chia.util.timing import adjusted_timeout
+
+if sys.platform == "win32" or sys.platform == "cygwin":
+    termination_signals = [signal.SIGBREAK, signal.SIGINT, signal.SIGTERM]
+    sendable_termination_signals = [signal.SIGTERM]
+else:
+    termination_signals = [signal.SIGINT, signal.SIGTERM]
+    sendable_termination_signals = termination_signals
+
+
+class CreateServiceProtocol(Protocol):
+    @contextlib.asynccontextmanager
+    async def __call__(
+        self,
+        self_hostname: str,
+        port: uint16,
+        root_path: Path,
+        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:
+    timeout = adjusted_timeout(timeout=timeout)
+
+    start = time.monotonic()
+    while time.monotonic() - start < timeout:
+        client = await connect_to_daemon_and_validate(root_path=root_path, config=config, quiet=True)
+        if client is not None:
+            break
+        await asyncio.sleep(0.1)
+    else:
+        raise Exception(f"unable to connect within {timeout} seconds")
+    return client
+
+
+@pytest.mark.parametrize(argnames="signal_number", argvalues=sendable_termination_signals)
+@pytest.mark.anyio
+async def test_daemon_terminates(signal_number: signal.Signals, chia_root: ChiaRoot) -> None:
+    port = find_available_listen_port()
+    with lock_and_load_config(root_path=chia_root.path, filename="config.yaml") as config:
+        config["daemon_port"] = port
+        save_config(root_path=chia_root.path, filename="config.yaml", config_data=config)
+
+    with closing_chia_root_popen(chia_root=chia_root, args=[sys.executable, "-m", "chia.daemon.server"]) as process:
+        client = await wait_for_daemon_connection(root_path=chia_root.path, config=config)
+
+        try:
+            return_code = process.poll()
+            assert return_code is None
+
+            process.send_signal(signal_number)
+            process.communicate(timeout=adjusted_timeout(timeout=10))
+        finally:
+            await client.close()
+
+
+@pytest.mark.parametrize(argnames="signal_number", argvalues=sendable_termination_signals)
+@pytest.mark.parametrize(
+    argnames=["create_service", "module_path", "service_config_name"],
+    argvalues=[
+        [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: 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]
+        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)
+
+    # TODO: make the wallet start up regardless so this isn't needed
+    with closing_chia_root_popen(
+        chia_root=chia_root,
+        args=[sys.executable, "-m", "chia.daemon.server"],
+    ):
+        # Make sure the daemon is running and responsive before starting other services.
+        # This probably shouldn't be required.  For now, it helps at least with the
+        # farmer.
+        daemon_client = await wait_for_daemon_connection(root_path=chia_root.path, config=config)
+        await daemon_client.close()
+
+        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],
+                )
+            )
+
+            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()
+                    assert return_code is None
+
+                    try:
+                        result = await client.healthz()
+                    except (
+                        aiohttp.client_exceptions.ClientConnectorError,
+                        aiohttp.client_exceptions.ClientResponseError,
+                    ):
+                        pass
+                    else:
+                        if result.get("success", False):
+                            break
+
+                    await asyncio.sleep(0.1)
+                else:
+                    raise Exception("unable to connect")
+
+            return_code = process.poll()
+            assert return_code is None
+
+            process.send_signal(signal_number)
+            process.communicate(timeout=adjusted_timeout(timeout=30))

chia/_tests/core/ssl/config.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+checkout_blocks_and_plots = True

chia/_tests/core/ssl/test_ssl.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+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
+from chia.server.ssl_context import chia_ssl_ca_paths, private_ssl_ca_paths
+from chia.server.ws_connection import WSChiaConnection
+from chia.ssl.create_ssl import generate_ca_signed_cert
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.peer_info import PeerInfo
+
+
+async def establish_connection(server: ChiaServer, self_hostname: str, ssl_context) -> None:
+    timeout = aiohttp.ClientTimeout(total=10)
+    dummy_port = 5  # this does not matter
+    async with aiohttp.ClientSession(timeout=timeout) as session:
+        url = f"wss://{self_hostname}:{server._port}/ws"
+        ws = await session.ws_connect(url, autoclose=False, autoping=True, ssl=ssl_context)
+        wsc = WSChiaConnection.create(
+            NodeType.FULL_NODE,
+            ws,
+            server.api,
+            dummy_port,
+            server.log,
+            True,
+            server.received_message_callback,
+            None,
+            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()
+
+
+#
+# This is needed on linux and mac when running in asyncio debug otherwise
+# The SSL Error causes the test to exit and fail prematurely in an uncatchable way
+# This doesn't seem to work on Windows as the exception handler is never called
+# at least for this SSL failure
+#
+@contextlib.contextmanager
+def ignore_ssl_cert_error():
+    current_loop = asyncio.get_event_loop()
+    old_handler = current_loop.get_exception_handler()
+
+    def find_and_ignore(loop, ctx):
+        exc = ctx.get("exception")
+        if isinstance(exc, ssl.SSLCertVerificationError):
+            return
+
+        old_handler(loop, ctx)  # pragma: no cover
+
+    current_loop.set_exception_handler(find_and_ignore)
+    try:
+        yield
+    finally:
+        current_loop.set_exception_handler(old_handler)
+
+
+@contextlib.contextmanager
+def set_asyncio_debug():
+    loop = asyncio.get_event_loop()
+    original_state = loop.get_debug()
+    loop.set_debug(True)
+    try:
+        yield
+    finally:
+        loop.set_debug(original_state)
+
+
+class TestSSL:
+    @pytest.mark.anyio
+    async def test_public_connections(self, simulator_and_wallet, self_hostname):
+        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]
+
+        success = await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), None)
+        assert success is True
+
+    @pytest.mark.anyio
+    async def test_farmer_happy(self, farmer_one_harvester, self_hostname):
+        _, farmer_service, bt = farmer_one_harvester
+        farmer_api = farmer_service._api
+
+        farmer_server = farmer_api.farmer.server
+        ca_private_crt_path, ca_private_key_path = private_ssl_ca_paths(bt.root_path, bt.config)
+        # Create valid cert (valid meaning signed with private CA)
+        priv_crt = farmer_server.root_path / "valid.crt"
+        priv_key = farmer_server.root_path / "valid.key"
+        generate_ca_signed_cert(
+            ca_private_crt_path.read_bytes(),
+            ca_private_key_path.read_bytes(),
+            priv_crt,
+            priv_key,
+        )
+
+        ssl_context = ssl_context_for_client(ca_private_crt_path, ca_private_key_path, priv_crt, priv_key)
+        await establish_connection(farmer_server, self_hostname, ssl_context)
+
+    @pytest.mark.anyio
+    async def test_farmer_wrong_ca(self, farmer_one_harvester, self_hostname):
+        _, farmer_service, bt = farmer_one_harvester
+        farmer_api = farmer_service._api
+
+        farmer_server = farmer_api.farmer.server
+        chia_ca_crt_path, chia_ca_key_path = chia_ssl_ca_paths(bt.root_path, bt.config)
+
+        #
+        # Use client certificate signed by public CA (instead of private one) and use public CA for SSL context
+        # This reliably raises ClientConnectorCertificateError
+        #
+        pub_crt = farmer_server.root_path / "non_valid.crt"
+        pub_key = farmer_server.root_path / "non_valid.key"
+        generate_ca_signed_cert(chia_ca_crt_path.read_bytes(), chia_ca_key_path.read_bytes(), pub_crt, pub_key)
+        ssl_context = ssl_context_for_client(chia_ca_crt_path, chia_ca_key_path, pub_crt, pub_key)
+        with pytest.raises(aiohttp.ClientConnectorCertificateError):
+            await establish_connection(farmer_server, self_hostname, ssl_context)
+
+    @pytest.mark.anyio
+    async def test_farmer_mismatch_context(self, farmer_one_harvester_not_started, self_hostname, caplog):
+        _, farmer_service, bt = farmer_one_harvester_not_started
+        farmer_api = farmer_service._api
+
+        farmer_server = farmer_api.farmer.server
+        ca_private_crt_path, ca_private_key_path = private_ssl_ca_paths(bt.root_path, bt.config)
+        chia_ca_crt_path, chia_ca_key_path = chia_ssl_ca_paths(bt.root_path, bt.config)
+        #
+        # Use client certificate generated from public CA but use private CA for SSL context
+        # This doesn't reliable raise a specific exception on all platforms so resorting to searching
+        # the log for certificate failed messages. However, this is complicated in that the log
+        # for this is only generated with asyncio in debug mode which due to further complications
+        # needs to be set near the beginning when the farmer service starts
+        #
+        with set_asyncio_debug():
+            async with farmer_service.manage():
+                pub_crt = farmer_server.root_path / "non_valid.crt"
+                pub_key = farmer_server.root_path / "non_valid.key"
+                generate_ca_signed_cert(chia_ca_crt_path.read_bytes(), chia_ca_key_path.read_bytes(), pub_crt, pub_key)
+
+                ssl_context = ssl_context_for_client(ca_private_crt_path, ca_private_key_path, pub_crt, pub_key)
+                caplog.clear()
+                with (
+                    pytest.raises(Exception),
+                    ignore_ssl_cert_error(),
+                    caplog.at_level(logging.DEBUG, logger="asyncio"),
+                ):
+                    await establish_connection(farmer_server, self_hostname, ssl_context)
+
+                assert (
+                    "[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: certificate signature failure"
+                    in caplog.text
+                )
+
+    @pytest.mark.anyio
+    async def test_full_node(self, simulator_and_wallet, self_hostname):
+        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)
+
+        # Create not authenticated cert
+        pub_crt = full_node_server.root_path / "p2p.crt"
+        pub_key = full_node_server.root_path / "p2p.key"
+        generate_ca_signed_cert(
+            chia_ca_crt_path.read_bytes(),
+            chia_ca_key_path.read_bytes(),
+            pub_crt,
+            pub_key,
+        )
+        ssl_context = ssl_context_for_client(chia_ca_crt_path, chia_ca_key_path, pub_crt, pub_key)
+        await establish_connection(full_node_server, self_hostname, ssl_context)
+
+    @pytest.mark.anyio
+    async def test_introducer(self, introducer_service, self_hostname):
+        introducer_server = introducer_service._node.server
+        chia_ca_crt_path, chia_ca_key_path = chia_ssl_ca_paths(introducer_service.root_path, introducer_service.config)
+
+        # Create not authenticated cert
+        pub_crt = introducer_server.root_path / "p2p.crt"
+        pub_key = introducer_server.root_path / "p2p.key"
+        generate_ca_signed_cert(
+            chia_ca_crt_path.read_bytes(),
+            chia_ca_key_path.read_bytes(),
+            pub_crt,
+            pub_key,
+        )
+        ssl_context = ssl_context_for_client(chia_ca_crt_path, chia_ca_key_path, pub_crt, pub_key)
+        await establish_connection(introducer_server, self_hostname, ssl_context)

chia/_tests/core/test_coins.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from itertools import permutations
+
+from chia._tests.util.benchmarks import rand_hash
+from chia.types.blockchain_format.coin import hash_coin_ids
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.hash import std_hash
+
+
+def test_hash_coin_ids_empty() -> None:
+    assert hash_coin_ids([]) == std_hash(b"")
+
+
+def test_hash_coin_ids() -> None:
+    A = bytes32([1] + [0] * 31)
+    B = bytes32([2] + [0] * 31)
+    C = bytes32([3] + [0] * 31)
+    D = bytes32([4] + [0] * 31)
+    E = bytes32([254] + [0] * 31)
+    F = bytes32([255] + [0] * 31)
+
+    expected = std_hash(F + E + D + C + B + A)
+
+    for i in permutations([A, B, C, D, E, F]):
+        assert hash_coin_ids(list(i)) == expected
+
+
+def test_sorting() -> None:
+    for _ in range(5000):
+        h1 = rand_hash()
+        h2 = rand_hash()
+        assert (h1 < h2) == (h1.hex() < h2.hex())