chia-blockchain 2.4.4__py3-none-any.whl

chia/_tests/core/daemon/test_daemon_register.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import aiohttp
+import pytest
+
+from chia.daemon.server import WebSocketServer
+from chia.simulator.block_tools import BlockTools
+from chia.util.ws_message import create_payload
+
+
+@pytest.mark.anyio
+async def test_multiple_register_same(get_daemon: WebSocketServer, bt: BlockTools) -> None:
+    ws_server = get_daemon
+    config = bt.config
+
+    daemon_port = config["daemon_port"]
+
+    # setup receive service to connect to the daemon
+    async with aiohttp.ClientSession() as client:
+        async with client.ws_connect(
+            f"wss://127.0.0.1:{daemon_port}",
+            autoclose=True,
+            autoping=True,
+            ssl=bt.get_daemon_ssl_context(),
+            max_msg_size=100 * 1024 * 1024,
+        ) as ws:
+            service_name = "test_service"
+            data = {"service": service_name}
+            payload = create_payload("register_service", data, service_name, "daemon")
+            for _ in range(4):
+                await ws.send_str(payload)
+                await ws.receive()
+
+            connections = ws_server.connections.get(service_name, set())
+            assert len(connections) == 1
+
+
+@pytest.mark.anyio
+async def test_multiple_register_different(get_daemon: WebSocketServer, bt: BlockTools) -> None:
+    ws_server = get_daemon
+    config = bt.config
+
+    daemon_port = config["daemon_port"]
+
+    # setup receive service to connect to the daemon
+    async with aiohttp.ClientSession() as client:
+        async with client.ws_connect(
+            f"wss://127.0.0.1:{daemon_port}",
+            autoclose=True,
+            autoping=True,
+            ssl=bt.get_daemon_ssl_context(),
+            max_msg_size=100 * 1024 * 1024,
+        ) as ws:
+            test_service_names = ["service1", "service2", "service3"]
+
+            for service_name in test_service_names:
+                data = {"service": service_name}
+                payload = create_payload("register_service", data, service_name, "daemon")
+                await ws.send_str(payload)
+                await ws.receive()
+
+            assert sorted(ws_server.connections.keys()) == test_service_names
+
+            for service_name in test_service_names:
+                connections = ws_server.connections.get(service_name, set())
+                assert len(connections) == 1
+
+        # Check after closing the connection
+        for service_name in test_service_names:
+            connections = ws_server.connections.get(service_name, set())
+            assert connections == set()
+
+
+@pytest.mark.anyio
+async def test_remove_connection(get_daemon: WebSocketServer, bt: BlockTools) -> None:
+    ws_server = get_daemon
+    config = bt.config
+
+    daemon_port = config["daemon_port"]
+
+    # setup receive service to connect to the daemon
+    async with aiohttp.ClientSession() as client:
+        async with client.ws_connect(
+            f"wss://127.0.0.1:{daemon_port}",
+            autoclose=True,
+            autoping=True,
+            ssl=bt.get_daemon_ssl_context(),
+            max_msg_size=100 * 1024 * 1024,
+        ) as ws:
+            test_service_names = ["service1", "service2", "service3", "service4", "service5"]
+
+            for service_name in test_service_names:
+                data = {"service": service_name}
+                payload = create_payload("register_service", data, service_name, "daemon")
+                await ws.send_str(payload)
+                await ws.receive()
+
+            assert sorted(ws_server.connections.keys()) == test_service_names
+
+            connections = ws_server.connections.get(test_service_names[0], set())
+            assert len(connections) == 1
+            ws_to_remove = next(iter(connections))
+
+            removed_names = ws_server.remove_connection(ws_to_remove)
+            assert removed_names == test_service_names
+
+            # remove again, should return empty list and not raise any errors
+            removed_names = ws_server.remove_connection(ws_to_remove)
+            assert removed_names == list()

chia/_tests/core/daemon/test_keychain_proxy.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import replace
+from typing import Any, AsyncGenerator
+
+import pytest
+
+from chia.daemon.keychain_proxy import KeychainProxy, connect_to_keychain_and_validate
+from chia.simulator.block_tools import BlockTools
+from chia.simulator.setup_services import setup_daemon
+from chia.util.errors import KeychainIsEmpty, KeychainKeyNotFound
+from chia.util.keychain import KeyData
+
+TEST_KEY_1 = KeyData.generate(label="🚽🍯")
+TEST_KEY_2 = KeyData.generate(label="👨‍✈️🥦")
+TEST_KEY_3 = KeyData.generate(label="☕️🍬")
+
+
+@pytest.fixture(scope="function", params=[True, False])
+async def keychain_proxy(get_b_tools: BlockTools, request: Any) -> AsyncGenerator[KeychainProxy, None]:
+    async with setup_daemon(btools=get_b_tools) as daemon:
+        log = logging.getLogger("keychain_proxy_fixture")
+        keychain_proxy = await connect_to_keychain_and_validate(daemon.root_path, log)
+        assert keychain_proxy is not None
+        if request.param:
+            keychain_proxy.keychain = daemon.keychain_server._default_keychain
+        yield keychain_proxy
+        await keychain_proxy.close()
+
+
+@pytest.fixture(scope="function")
+async def keychain_proxy_with_keys(keychain_proxy: KeychainProxy) -> KeychainProxy:
+    await keychain_proxy.add_key(TEST_KEY_1.mnemonic_str(), TEST_KEY_1.label)
+    await keychain_proxy.add_key(TEST_KEY_2.mnemonic_str(), TEST_KEY_2.label)
+    return keychain_proxy
+
+
+@pytest.mark.anyio
+async def test_add_private_key(keychain_proxy: KeychainProxy) -> None:
+    keychain = keychain_proxy
+    await keychain.add_key(TEST_KEY_3.mnemonic_str(), TEST_KEY_3.label)
+    key = await keychain.get_key(TEST_KEY_3.fingerprint, include_secrets=True)
+    assert key == TEST_KEY_3
+
+
+@pytest.mark.anyio
+async def test_add_public_key(keychain_proxy: KeychainProxy) -> None:
+    keychain = keychain_proxy
+    await keychain.add_key(bytes(TEST_KEY_3.public_key).hex(), TEST_KEY_3.label, private=False)
+    with pytest.raises(Exception, match="already exists"):
+        await keychain.add_key(bytes(TEST_KEY_3.public_key).hex(), "", private=False)
+    key = await keychain.get_key(TEST_KEY_3.fingerprint, include_secrets=False)
+    assert key is not None
+    assert key.public_key == TEST_KEY_3.public_key
+    assert key.secrets is None
+
+    pk = await keychain.get_key_for_fingerprint(TEST_KEY_3.fingerprint, private=False)
+    assert pk is not None
+    assert pk == TEST_KEY_3.public_key
+
+    pk = await keychain.get_key_for_fingerprint(None, private=False)
+    assert pk is not None
+    assert pk == TEST_KEY_3.public_key
+
+    with pytest.raises(KeychainKeyNotFound):
+        pk = await keychain.get_key_for_fingerprint(1234567890, private=False)
+
+
+@pytest.mark.parametrize("include_secrets", [True, False])
+@pytest.mark.anyio
+async def test_get_key(keychain_proxy_with_keys: KeychainProxy, include_secrets: bool) -> None:
+    keychain = keychain_proxy_with_keys
+    key = await keychain.get_key(TEST_KEY_1.fingerprint, include_secrets=include_secrets)
+    expected_key = TEST_KEY_1 if include_secrets else replace(TEST_KEY_1, secrets=None)
+    assert key == expected_key
+
+
+@pytest.mark.anyio
+async def test_get_key_for_fingerprint(keychain_proxy: KeychainProxy) -> None:
+    keychain = keychain_proxy
+    with pytest.raises(KeychainIsEmpty):
+        await keychain.get_key_for_fingerprint(None, private=False)
+    await keychain_proxy.add_key(TEST_KEY_1.mnemonic_str(), TEST_KEY_1.label)
+    assert await keychain.get_key_for_fingerprint(TEST_KEY_1.fingerprint, private=False) == TEST_KEY_1.public_key
+    assert await keychain.get_key_for_fingerprint(None, private=False) == TEST_KEY_1.public_key
+    with pytest.raises(KeychainKeyNotFound):
+        await keychain.get_key_for_fingerprint(1234567890, private=False)
+
+
+@pytest.mark.parametrize("include_secrets", [True, False])
+@pytest.mark.anyio
+async def test_get_keys(keychain_proxy_with_keys: KeychainProxy, include_secrets: bool) -> None:
+    keychain = keychain_proxy_with_keys
+    keys = await keychain.get_keys(include_secrets=include_secrets)
+    if include_secrets:
+        expected_keys = [TEST_KEY_1, TEST_KEY_2]
+    else:
+        expected_keys = [replace(TEST_KEY_1, secrets=None), replace(TEST_KEY_2, secrets=None)]
+    assert keys == expected_keys

chia/_tests/core/data_layer/config.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+parallel = 4
+job_timeout = 80
+checkout_blocks_and_plots = True

chia/_tests/core/data_layer/conftest.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import os
+import pathlib
+import sys
+import time
+from typing import Any, AsyncIterable, Awaitable, Callable, Dict, Iterator
+
+import pytest
+
+# https://github.com/pytest-dev/pytest/issues/7469
+from _pytest.fixtures import SubRequest
+
+from chia._tests.core.data_layer.util import (
+    ChiaRoot,
+    Example,
+    add_0123_example,
+    add_01234567_example,
+    create_valid_node_values,
+)
+from chia._tests.util.misc import closing_chia_root_popen
+from chia.data_layer.data_layer_util import NodeType, Status
+from chia.data_layer.data_store import DataStore
+from chia.types.blockchain_format.sized_bytes import bytes32
+
+# TODO: These are more general than the data layer and should either move elsewhere or
+#       be replaced with an existing common approach.  For now they can at least be
+#       shared among the data layer test files.
+
+
+@pytest.fixture(name="chia_daemon", scope="function")
+def chia_daemon_fixture(chia_root: ChiaRoot) -> Iterator[None]:
+    with closing_chia_root_popen(chia_root=chia_root, args=[sys.executable, "-m", "chia.daemon.server"]):
+        # TODO: this is not pretty as a hard coded time
+        # let it settle
+        time.sleep(5)
+        yield
+
+
+@pytest.fixture(name="chia_data", scope="function")
+def chia_data_fixture(chia_root: ChiaRoot, chia_daemon: None, scripts_path: pathlib.Path) -> Iterator[None]:
+    with closing_chia_root_popen(chia_root=chia_root, args=[os.fspath(scripts_path.joinpath("chia_data_layer"))]):
+        # TODO: this is not pretty as a hard coded time
+        # let it settle
+        time.sleep(5)
+        yield
+
+
+@pytest.fixture(name="create_example", params=[add_0123_example, add_01234567_example])
+def create_example_fixture(request: SubRequest) -> Callable[[DataStore, bytes32], Awaitable[Example]]:
+    # https://github.com/pytest-dev/pytest/issues/8763
+    return request.param  # type: ignore[no-any-return]
+
+
+@pytest.fixture(name="store_id", scope="function")
+def store_id_fixture() -> bytes32:
+    base = b"a store id"
+    pad = b"." * (32 - len(base))
+    return bytes32(pad + base)
+
+
+@pytest.fixture(name="raw_data_store", scope="function")
+async def raw_data_store_fixture(database_uri: str) -> AsyncIterable[DataStore]:
+    async with DataStore.managed(database=database_uri, uri=True) as store:
+        yield store
+
+
+@pytest.fixture(name="data_store", scope="function")
+async def data_store_fixture(raw_data_store: DataStore, store_id: bytes32) -> AsyncIterable[DataStore]:
+    await raw_data_store.create_tree(store_id=store_id, status=Status.COMMITTED)
+
+    await raw_data_store.check()
+    yield raw_data_store
+    await raw_data_store.check()
+
+
+@pytest.fixture(name="node_type", params=NodeType)
+def node_type_fixture(request: SubRequest) -> NodeType:
+    return request.param  # type: ignore[no-any-return]
+
+
+@pytest.fixture(name="valid_node_values")
+async def valid_node_values_fixture(
+    data_store: DataStore,
+    store_id: bytes32,
+    node_type: NodeType,
+) -> Dict[str, Any]:
+    await add_01234567_example(data_store=data_store, store_id=store_id)
+
+    if node_type == NodeType.INTERNAL:
+        node_a = await data_store.get_node_by_key(key=b"\x02", store_id=store_id)
+        node_b = await data_store.get_node_by_key(key=b"\x04", store_id=store_id)
+        return create_valid_node_values(node_type=node_type, left_hash=node_a.hash, right_hash=node_b.hash)
+    elif node_type == NodeType.TERMINAL:
+        return create_valid_node_values(node_type=node_type)
+    else:
+        raise Exception(f"invalid node type: {node_type!r}")
+
+
+@pytest.fixture(name="bad_node_type", params=range(2 * len(NodeType)))
+def bad_node_type_fixture(request: SubRequest, valid_node_values: Dict[str, Any]) -> int:
+    if request.param == valid_node_values["node_type"]:
+        pytest.skip("Actually, this is a valid node type")
+
+    return request.param  # type: ignore[no-any-return]

chia/_tests/core/data_layer/test_data_cli.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import json
+from typing import Dict, List
+
+import pytest
+
+from chia._tests.core.data_layer.util import ChiaRoot
+
+pytestmark = pytest.mark.data_layer
+
+
+@pytest.mark.anyio
+async def test_help(chia_root: ChiaRoot) -> None:
+    """Just a trivial test to make sure the subprocessing is at least working and the
+    data executable does run.
+    """
+    completed_process = chia_root.run(args=["data", "--help"])
+    assert "Show this message and exit" in completed_process.stdout
+
+
+@pytest.mark.skip
+@pytest.mark.anyio
+def test_round_trip(chia_root: ChiaRoot, chia_daemon: None, chia_data: None) -> None:
+    """Create a table, insert a row, get the row by its hash."""
+
+    with chia_root.print_log_after():
+        create = chia_root.run(args=["data", "create_data_store"])
+        print(f"create_data_store: {create}")
+        dic = json.loads(create.stdout)
+        assert dic["success"]
+        store_id = dic["id"]
+        key = "1a6f915513173902a7216e7d9e4a16bfd088e20683f45de3b432ce72e9cc7aa8"
+        value = "ffff8353594d8083616263"
+        changelist: List[Dict[str, str]] = [{"action": "insert", "key": key, "value": value}]
+        print(json.dumps(changelist))
+        update = chia_root.run(
+            args=["data", "update_data_store", "--id", store_id, "--changelist", json.dumps(changelist)]
+        )
+        dic = json.loads(create.stdout)
+        assert dic["success"]
+        print(f"update_data_store: {update}")
+        completed_process = chia_root.run(args=["data", "get_value", "--id", store_id, "--key", key])
+        parsed = json.loads(completed_process.stdout)
+        expected = {"value": value, "success": True}
+        assert parsed == expected
+        get_keys_values = chia_root.run(args=["data", "get_keys_values", "--id", store_id])
+        print(f"get_keys_values: {get_keys_values}")
+        changelist = [{"action": "delete", "key": key}]
+        update = chia_root.run(
+            args=["data", "update_data_store", "--id", store_id, "--changelist", json.dumps(changelist)]
+        )
+        print(f"update_data_store: {update}")
+        completed_process = chia_root.run(args=["data", "get_value", "--id", store_id, "--key", key])
+        parsed = json.loads(completed_process.stdout)
+        expected = {"data": None, "success": True}
+        assert parsed == expected

chia/_tests/core/data_layer/test_data_layer.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, cast
+
+import pytest
+
+from chia._tests.util.misc import RecordingWebServer
+from chia.data_layer.data_layer import DataLayer
+from chia.data_layer.data_layer_util import PluginRemote
+from chia.rpc.wallet_rpc_client import WalletRpcClient
+from chia.types.blockchain_format.sized_bytes import bytes32
+
+
+async def create_sufficient_wallet_rpc_client() -> WalletRpcClient:
+    return cast(WalletRpcClient, SufficientWalletRpcClient())
+
+
+class SufficientWalletRpcClient:
+    def close(self) -> None:
+        return
+
+    async def await_closed(self) -> None:
+        return
+
+
+@pytest.mark.parametrize(argnames="enable", argvalues=[True, False], ids=["log", "do not log"])
+@pytest.mark.anyio
+async def test_sql_logs(enable: bool, config: Dict[str, Any], tmp_chia_root: Path) -> None:
+    config["data_layer"]["log_sqlite_cmds"] = enable
+
+    log_path = tmp_chia_root.joinpath("log", "data_sql.log")
+
+    data_layer = DataLayer.create(
+        config=config["data_layer"],
+        root_path=tmp_chia_root,
+        wallet_rpc_init=create_sufficient_wallet_rpc_client(),
+        downloaders=[],
+        uploaders=[],
+    )
+    assert not log_path.exists()
+    async with data_layer.manage():
+        pass
+
+    if enable:
+        assert log_path.is_file()
+    else:
+        assert not log_path.exists()
+
+
+@pytest.mark.anyio
+async def test_plugin_requests_use_custom_headers(
+    recording_web_server: RecordingWebServer,
+    config: Dict[str, Any],
+    tmp_chia_root: Path,
+) -> None:
+    header_key = "vbiuoqemnrlah"
+    header_value = "98754718932345"
+
+    plugin_remote = PluginRemote(
+        url=recording_web_server.web_server.url(),
+        headers={header_key: header_value},
+    )
+
+    async def wallet_rpc_init() -> WalletRpcClient:
+        # this return is not presently used for this test
+        return None  # type: ignore[return-value]
+
+    data_layer = DataLayer.create(
+        config=config["data_layer"],
+        root_path=tmp_chia_root,
+        wallet_rpc_init=wallet_rpc_init(),
+        downloaders=[plugin_remote],
+        uploaders=[plugin_remote],
+    )
+
+    async with data_layer.manage():
+        await data_layer.get_downloader(store_id=bytes32([0] * 32), url="")
+        await data_layer.get_uploaders(store_id=bytes32([0] * 32))
+        await data_layer.check_plugins()
+
+    header_values = {request.headers.get(header_key) for request in recording_web_server.requests}
+    assert header_values == {header_value}

chia/_tests/core/data_layer/test_data_layer_util.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import dataclasses
+from random import Random
+from typing import List, Tuple
+
+import pytest
+
+# TODO: update after resolution in https://github.com/pytest-dev/pytest/issues/7469
+from _pytest.fixtures import SubRequest
+
+from chia._tests.util.misc import Marks, datacases, measure_runtime
+from chia.data_layer.data_layer_util import (
+    ClearPendingRootsRequest,
+    ClearPendingRootsResponse,
+    ProofOfInclusion,
+    ProofOfInclusionLayer,
+    Root,
+    Side,
+    Status,
+    internal_hash,
+    key_hash,
+    leaf_hash,
+)
+from chia.rpc.data_layer_rpc_util import MarshallableProtocol
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+from chia.types.blockchain_format.sized_bytes import bytes32
+
+pytestmark = pytest.mark.data_layer
+
+
+def create_valid_proof_of_inclusion(layer_count: int, other_hash_side: Side) -> ProofOfInclusion:
+    node_hash = bytes32(b"a" * 32)
+    layers: List[ProofOfInclusionLayer] = []
+
+    existing_hash = node_hash
+
+    other_hashes = [bytes32([i] * 32) for i in range(layer_count)]
+
+    for other_hash in other_hashes:
+        new_layer = ProofOfInclusionLayer.from_hashes(
+            primary_hash=existing_hash,
+            other_hash_side=other_hash_side,
+            other_hash=other_hash,
+        )
+
+        layers.append(new_layer)
+        existing_hash = new_layer.combined_hash
+
+    return ProofOfInclusion(node_hash=node_hash, layers=layers)
+
+
+@pytest.fixture(name="side", params=[Side.LEFT, Side.RIGHT])
+def side_fixture(request: SubRequest) -> Side:
+    # https://github.com/pytest-dev/pytest/issues/8763
+    return request.param  # type: ignore[no-any-return]
+
+
+@pytest.fixture(name="valid_proof_of_inclusion", params=[0, 1, 5])
+def valid_proof_of_inclusion_fixture(request: SubRequest, side: Side) -> ProofOfInclusion:
+    return create_valid_proof_of_inclusion(layer_count=request.param, other_hash_side=side)
+
+
+@pytest.fixture(
+    name="invalid_proof_of_inclusion",
+    params=["bad root hash", "bad other hash", "bad other side", "bad node hash"],
+)
+def invalid_proof_of_inclusion_fixture(request: SubRequest, side: Side) -> ProofOfInclusion:
+    valid_proof_of_inclusion = create_valid_proof_of_inclusion(layer_count=5, other_hash_side=side)
+
+    layers = list(valid_proof_of_inclusion.layers)
+    a_hash = bytes32(b"f" * 32)
+
+    if request.param == "bad root hash":
+        layers[-1] = dataclasses.replace(layers[-1], combined_hash=a_hash)
+        return dataclasses.replace(valid_proof_of_inclusion, layers=layers)
+    elif request.param == "bad other hash":
+        layers[1] = dataclasses.replace(layers[1], other_hash=a_hash)
+        return dataclasses.replace(valid_proof_of_inclusion, layers=layers)
+    elif request.param == "bad other side":
+        layers[1] = dataclasses.replace(layers[1], other_hash_side=layers[1].other_hash_side.other())
+        return dataclasses.replace(valid_proof_of_inclusion, layers=layers)
+    elif request.param == "bad node hash":
+        return dataclasses.replace(valid_proof_of_inclusion, node_hash=a_hash)
+
+    raise Exception(f"Unhandled parametrization: {request.param!r}")  # pragma: no cover
+
+
+def test_proof_of_inclusion_is_valid(valid_proof_of_inclusion: ProofOfInclusion) -> None:
+    assert valid_proof_of_inclusion.valid()
+
+
+def test_proof_of_inclusion_is_invalid(invalid_proof_of_inclusion: ProofOfInclusion) -> None:
+    assert not invalid_proof_of_inclusion.valid()
+
+
+@dataclasses.dataclass()
+class RoundTripCase:
+    id: str
+    instance: MarshallableProtocol
+    marks: Marks = ()
+
+
+@datacases(
+    RoundTripCase(
+        id="Root",
+        instance=Root(
+            store_id=bytes32(b"\x00" * 32),
+            node_hash=bytes32(b"\x01" * 32),
+            generation=3,
+            status=Status.PENDING,
+        ),
+    ),
+    RoundTripCase(
+        id="ClearPendingRootsRequest",
+        instance=ClearPendingRootsRequest(store_id=bytes32(b"\x12" * 32)),
+    ),
+    RoundTripCase(
+        id="ClearPendingRootsResponse success",
+        instance=ClearPendingRootsResponse(
+            success=True,
+            root=Root(
+                store_id=bytes32(b"\x00" * 32),
+                node_hash=bytes32(b"\x01" * 32),
+                generation=3,
+                status=Status.PENDING,
+            ),
+        ),
+    ),
+    RoundTripCase(
+        id="ClearPendingRootsResponse failure",
+        instance=ClearPendingRootsResponse(success=False, root=None),
+    ),
+)
+def test_marshalling_round_trip(case: RoundTripCase) -> None:
+    marshalled = case.instance.marshal()
+    unmarshalled = type(case.instance).unmarshal(marshalled)
+    assert case.instance == unmarshalled
+
+
+def test_internal_hash(seeded_random: Random) -> None:
+    def definition(left_hash: bytes32, right_hash: bytes32) -> bytes32:
+        return Program.to((left_hash, right_hash)).get_tree_hash_precalc(left_hash, right_hash)
+
+    data: List[Tuple[bytes32, bytes32, bytes32]] = []
+    for _ in range(5000):
+        left_hash = bytes32.random(r=seeded_random)
+        right_hash = bytes32.random(r=seeded_random)
+        reference = definition(left_hash=left_hash, right_hash=right_hash)
+        data.append((left_hash, right_hash, reference))
+
+    with measure_runtime(label="optimization"):
+        for left_hash, right_hash, reference in data:
+            assert internal_hash(left_hash=left_hash, right_hash=right_hash) == reference
+
+    with measure_runtime(label="definition"):
+        for left_hash, right_hash, reference in data:
+            assert definition(left_hash=left_hash, right_hash=right_hash) == reference
+
+
+def get_random_bytes(length: int, r: Random) -> bytes:
+    if length == 0:
+        return b""
+
+    return r.getrandbits(length * 8).to_bytes(length, "big")
+
+
+def test_leaf_hash(seeded_random: Random) -> None:
+    def definition(key: bytes, value: bytes) -> bytes32:
+        return SerializedProgram.to((key, value)).get_tree_hash()
+
+    data: List[Tuple[bytes, bytes, bytes32]] = []
+    for cycle in range(20000):
+        if cycle in (0, 1):
+            length = 0
+        else:
+            length = seeded_random.randrange(100)
+
+        key = get_random_bytes(length=length, r=seeded_random)
+
+        if cycle in (1, 2):
+            length = 0
+        else:
+            length = seeded_random.randrange(100)
+        value = get_random_bytes(length=length, r=seeded_random)
+        reference = definition(key=key, value=value)
+        data.append((key, value, reference))
+
+    with measure_runtime(label="optimization"):
+        for key, value, reference in data:
+            assert leaf_hash(key=key, value=value) == reference
+
+    with measure_runtime(label="definition"):
+        for key, value, reference in data:
+            assert definition(key=key, value=value) == reference
+
+
+def test_key_hash(seeded_random: Random) -> None:
+    def definition(key: bytes) -> bytes32:
+        return SerializedProgram.to(key).get_tree_hash()
+
+    data: List[Tuple[bytes, bytes32]] = []
+    for cycle in range(30000):
+        if cycle == 0:
+            length = 0
+        else:
+            length = seeded_random.randrange(100)
+        key = get_random_bytes(length=length, r=seeded_random)
+        reference = definition(key=key)
+        data.append((key, reference))
+
+    with measure_runtime(label="optimization"):
+        for key, reference in data:
+            assert key_hash(key=key) == reference
+
+    with measure_runtime(label="definition"):
+        for key, reference in data:
+            assert definition(key=key) == reference