chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/_tests/util/blockchain_mock.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
+
+from chia.consensus.block_record import BlockRecord
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
+from chia.types.blockchain_format.vdf import VDFInfo
+from chia.types.header_block import HeaderBlock
+from chia.types.weight_proof import SubEpochChallengeSegment, SubEpochSegments
+from chia.util.ints import uint32
+
+
+# implements BlockchainInterface
+class BlockchainMock:
+    if TYPE_CHECKING:
+        from chia.consensus.blockchain_interface import BlocksProtocol
+
+        _protocol_check: ClassVar[BlocksProtocol] = cast("BlockchainMock", None)
+
+    def __init__(
+        self,
+        blocks: dict[bytes32, BlockRecord],
+        headers: Optional[dict[bytes32, HeaderBlock]] = None,
+        height_to_hash: Optional[dict[uint32, bytes32]] = None,
+        sub_epoch_summaries: Optional[dict[uint32, SubEpochSummary]] = None,
+    ):
+        if sub_epoch_summaries is None:
+            sub_epoch_summaries = {}
+        if height_to_hash is None:
+            height_to_hash = {}
+        if headers is None:
+            headers = {}
+        self._block_records = blocks
+        self._headers = headers
+        self._height_to_hash = height_to_hash
+        self._sub_epoch_summaries = sub_epoch_summaries
+        self._sub_epoch_segments: dict[bytes32, SubEpochSegments] = {}
+        self.log = logging.getLogger(__name__)
+
+    def get_peak(self) -> Optional[BlockRecord]:
+        return None
+
+    def get_peak_height(self) -> Optional[uint32]:
+        return None
+
+    def block_record(self, header_hash: bytes32) -> BlockRecord:
+        return self._block_records[header_hash]
+
+    def height_to_block_record(self, height: uint32, check_db: bool = False) -> BlockRecord:
+        # Precondition: height is < peak height
+
+        header_hash: Optional[bytes32] = self.height_to_hash(height)
+        assert header_hash is not None
+
+        return self.block_record(header_hash)
+
+    def get_ses_heights(self) -> list[uint32]:
+        return sorted(self._sub_epoch_summaries.keys())
+
+    def get_ses(self, height: uint32) -> SubEpochSummary:
+        return self._sub_epoch_summaries[height]
+
+    def height_to_hash(self, height: uint32) -> Optional[bytes32]:
+        assert height in self._height_to_hash
+        return self._height_to_hash[height]
+
+    def contains_block(self, header_hash: bytes32) -> bool:
+        return header_hash in self._block_records
+
+    async def contains_block_from_db(self, header_hash: bytes32) -> bool:
+        return header_hash in self._block_records
+
+    def contains_height(self, height: uint32) -> bool:
+        return height in self._height_to_hash
+
+    async def warmup(self, fork_point: uint32) -> None:
+        return
+
+    async def get_block_records_in_range(self, start: int, stop: int) -> dict[bytes32, BlockRecord]:
+        return self._block_records
+
+    async def get_block_records_at(self, heights: list[uint32]) -> list[BlockRecord]:
+        block_records: list[BlockRecord] = []
+        for height in heights:
+            block_records.append(self.height_to_block_record(height))
+        return block_records
+
+    def try_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
+        return self._block_records.get(header_hash)
+
+    async def get_block_record_from_db(self, header_hash: bytes32) -> Optional[BlockRecord]:
+        return self._block_records[header_hash]
+
+    async def prev_block_hash(self, header_hashes: list[bytes32]) -> list[bytes32]:
+        ret = []
+        for h in header_hashes:
+            ret.append(self._block_records[h].prev_hash)
+        return ret
+
+    def remove_block_record(self, header_hash: bytes32) -> None:
+        del self._block_records[header_hash]
+
+    def add_block_record(self, block: BlockRecord) -> None:
+        self._block_records[block.header_hash] = block
+
+    async def get_header_blocks_in_range(
+        self, start: int, stop: int, tx_filter: bool = True
+    ) -> dict[bytes32, HeaderBlock]:
+        return self._headers
+
+    async def persist_sub_epoch_challenge_segments(
+        self, sub_epoch_summary_hash: bytes32, segments: list[SubEpochChallengeSegment]
+    ) -> None:
+        self._sub_epoch_segments[sub_epoch_summary_hash] = SubEpochSegments(segments)
+
+    async def get_sub_epoch_challenge_segments(
+        self,
+        sub_epoch_summary_hash: bytes32,
+    ) -> Optional[list[SubEpochChallengeSegment]]:
+        segments = self._sub_epoch_segments.get(sub_epoch_summary_hash)
+        if segments is None:
+            return None
+        return segments.challenge_segments
+
+    def seen_compact_proofs(self, vdf_info: VDFInfo, height: uint32) -> bool:
+        return False
+
+    async def lookup_block_generators(self, header_hash: bytes32, generator_refs: set[uint32]) -> dict[uint32, bytes]:
+        # not implemented
+        assert False  # pragma: no cover

chia/_tests/util/build_network_protocol_files.py

@@ -0,0 +1,302 @@
+# ruff: noqa: F405
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Callable
+
+from chia._tests.util.network_protocol_data import *  # noqa: F403
+from chia.util.ints import uint32
+
+version = "1.0"
+
+
+tests_dir = Path(__file__).resolve().parent
+
+
+def get_network_protocol_filename() -> Path:
+    return tests_dir / Path("protocol_messages_bytes-v" + version)
+
+
+def encode_data(data: Any) -> bytes:
+    data_bytes = bytes(data)
+    size = uint32(len(data_bytes))
+    return size.to_bytes(4, "big") + data_bytes
+
+
+def visit_farmer_protocol(visitor: Callable[[Any, str], None]) -> None:
+    visitor(new_signage_point, "new_signage_point")
+    visitor(declare_proof_of_space, "declare_proof_of_space")
+    visitor(request_signed_values, "request_signed_values")
+    visitor(farming_info, "farming_info")
+    visitor(signed_values, "signed_values")
+
+
+def visit_full_node(visitor: Callable[[Any, str], None]) -> None:
+    visitor(new_peak, "new_peak")
+    visitor(new_transaction, "new_transaction")
+    visitor(request_transaction, "request_transaction")
+    visitor(respond_transaction, "respond_transaction")
+    visitor(request_proof_of_weight, "request_proof_of_weight")
+    visitor(respond_proof_of_weight, "respond_proof_of_weight")
+    visitor(request_block, "request_block")
+    visitor(reject_block, "reject_block")
+    visitor(request_blocks, "request_blocks")
+    visitor(respond_blocks, "respond_blocks")
+    visitor(reject_blocks, "reject_blocks")
+    visitor(respond_block, "respond_block")
+    visitor(new_unfinished_block, "new_unfinished_block")
+    visitor(request_unfinished_block, "request_unfinished_block")
+    visitor(respond_unfinished_block, "respond_unfinished_block")
+    visitor(new_signage_point_or_end_of_subslot, "new_signage_point_or_end_of_subslot")
+    visitor(request_signage_point_or_end_of_subslot, "request_signage_point_or_end_of_subslot")
+    visitor(respond_signage_point, "respond_signage_point")
+    visitor(respond_end_of_subslot, "respond_end_of_subslot")
+    visitor(request_mempool_transaction, "request_mempool_transaction")
+    visitor(new_compact_vdf, "new_compact_vdf")
+    visitor(request_compact_vdf, "request_compact_vdf")
+    visitor(respond_compact_vdf, "respond_compact_vdf")
+    visitor(request_peers, "request_peers")
+    visitor(respond_peers, "respond_peers")
+    visitor(new_unfinished_block2, "new_unfinished_block2")
+    visitor(request_unfinished_block2, "request_unfinished_block2")
+
+
+def visit_wallet_protocol(visitor: Callable[[Any, str], None]) -> None:
+    visitor(request_puzzle_solution, "request_puzzle_solution")
+    visitor(puzzle_solution_response, "puzzle_solution_response")
+    visitor(respond_puzzle_solution, "respond_puzzle_solution")
+    visitor(reject_puzzle_solution, "reject_puzzle_solution")
+    visitor(send_transaction, "send_transaction")
+    visitor(transaction_ack, "transaction_ack")
+    visitor(new_peak_wallet, "new_peak_wallet")
+    visitor(request_block_header, "request_block_header")
+    visitor(request_block_headers, "request_block_headers")
+    visitor(respond_header_block, "respond_header_block")
+    visitor(respond_block_headers, "respond_block_headers")
+    visitor(reject_header_request, "reject_header_request")
+    visitor(request_removals, "request_removals")
+    visitor(respond_removals, "respond_removals")
+    visitor(reject_removals_request, "reject_removals_request")
+    visitor(request_additions, "request_additions")
+    visitor(respond_additions, "respond_additions")
+    visitor(reject_additions, "reject_additions")
+    visitor(request_header_blocks, "request_header_blocks")
+    visitor(reject_header_blocks, "reject_header_blocks")
+    visitor(respond_header_blocks, "respond_header_blocks")
+    visitor(coin_state, "coin_state")
+    visitor(register_for_ph_updates, "register_for_ph_updates")
+    visitor(reject_block_headers, "reject_block_headers")
+    visitor(respond_to_ph_updates, "respond_to_ph_updates")
+    visitor(register_for_coin_updates, "register_for_coin_updates")
+    visitor(respond_to_coin_updates, "respond_to_coin_updates")
+    visitor(coin_state_update, "coin_state_update")
+    visitor(request_children, "request_children")
+    visitor(respond_children, "respond_children")
+    visitor(request_ses_info, "request_ses_info")
+    visitor(respond_ses_info, "respond_ses_info")
+    visitor(coin_state_filters, "coin_state_filters")
+    visitor(request_remove_puzzle_subscriptions, "request_remove_puzzle_subscriptions")
+    visitor(respond_remove_puzzle_subscriptions, "respond_remove_puzzle_subscriptions")
+    visitor(request_remove_coin_subscriptions, "request_remove_coin_subscriptions")
+    visitor(respond_remove_coin_subscriptions, "respond_remove_coin_subscriptions")
+    visitor(request_puzzle_state, "request_puzzle_state")
+    visitor(reject_puzzle_state, "reject_puzzle_state")
+    visitor(respond_puzzle_state, "respond_puzzle_state")
+    visitor(request_coin_state, "request_coin_state")
+    visitor(respond_coin_state, "respond_coin_state")
+    visitor(reject_coin_state, "reject_coin_state")
+    visitor(request_cost_info, "request_cost_info")
+    visitor(respond_cost_info, "respond_cost_info")
+
+
+def visit_harvester_protocol(visitor: Callable[[Any, str], None]) -> None:
+    visitor(pool_difficulty, "pool_difficulty")
+    visitor(harvester_handhsake, "harvester_handhsake")
+    visitor(new_signage_point_harvester, "new_signage_point_harvester")
+    visitor(new_proof_of_space, "new_proof_of_space")
+    visitor(request_signatures, "request_signatures")
+    visitor(respond_signatures, "respond_signatures")
+    visitor(plot, "plot")
+    visitor(request_plots, "request_plots")
+    visitor(respond_plots, "respond_plots")
+
+
+def visit_introducer_protocol(visitor: Callable[[Any, str], None]) -> None:
+    visitor(request_peers_introducer, "request_peers_introducer")
+    visitor(respond_peers_introducer, "respond_peers_introducer")
+
+
+def visit_pool_protocol(visitor: Callable[[Any, str], None]) -> None:
+    visitor(authentication_payload, "authentication_payload")
+    visitor(get_pool_info_response, "get_pool_info_response")
+    visitor(post_partial_payload, "post_partial_payload")
+    visitor(post_partial_request, "post_partial_request")
+    visitor(post_partial_response, "post_partial_response")
+    visitor(get_farmer_response, "get_farmer_response")
+    visitor(post_farmer_payload, "post_farmer_payload")
+    visitor(post_farmer_request, "post_farmer_request")
+    visitor(post_farmer_response, "post_farmer_response")
+    visitor(put_farmer_payload, "put_farmer_payload")
+    visitor(put_farmer_request, "put_farmer_request")
+    visitor(put_farmer_response, "put_farmer_response")
+    visitor(error_response, "error_response")
+
+
+def visit_timelord_protocol(visitor: Callable[[Any, str], None]) -> None:
+    visitor(new_peak_timelord, "new_peak_timelord")
+    visitor(new_unfinished_block_timelord, "new_unfinished_block_timelord")
+    visitor(new_infusion_point_vdf, "new_infusion_point_vdf")
+    visitor(new_signage_point_vdf, "new_signage_point_vdf")
+    visitor(new_end_of_sub_slot_bundle, "new_end_of_sub_slot_bundle")
+    visitor(request_compact_proof_of_time, "request_compact_proof_of_time")
+    visitor(respond_compact_proof_of_time, "respond_compact_proof_of_time")
+
+
+def visit_shared_protocol(visitor: Callable[[Any, str], None]) -> None:
+    visitor(error_without_data, "error_without_data")
+    visitor(error_with_data, "error_with_data")
+
+
+def visit_all_messages(visitor: Callable[[Any, str], None]) -> None:
+    visit_farmer_protocol(visitor)
+    visit_full_node(visitor)
+    visit_wallet_protocol(visitor)
+    visit_harvester_protocol(visitor)
+    visit_introducer_protocol(visitor)
+    visit_pool_protocol(visitor)
+    visit_timelord_protocol(visitor)
+    visit_shared_protocol(visitor)
+
+
+def get_protocol_bytes() -> bytes:
+    result = b""
+
+    def visitor(obj: Any, name: str) -> None:
+        nonlocal result
+        result += encode_data(obj)
+
+    visit_all_messages(visitor)
+
+    return result
+
+
+def build_protocol_test() -> str:
+    result = """# ruff: noqa: F405
+# this file is generated by build_network_protocol_files.py
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from chia._tests.util.build_network_protocol_files import get_network_protocol_filename
+from chia._tests.util.network_protocol_data import *  # noqa: F403
+from chia._tests.util.protocol_messages_json import *  # noqa: F403
+
+
+def parse_blob(input_bytes: bytes) -> tuple[bytes, bytes]:
+    size_bytes = input_bytes[:4]
+    input_bytes = input_bytes[4:]
+    size = int.from_bytes(size_bytes, "big")
+    message_bytes = input_bytes[:size]
+    input_bytes = input_bytes[size:]
+    return (message_bytes, input_bytes)
+
+
+def test_protocol_bytes() -> None:
+
+    filename: Path = get_network_protocol_filename()
+    assert filename.exists()
+    with open(filename, "rb") as f:
+        input_bytes = f.read()
+
+"""
+
+    counter = 0
+
+    def visitor(obj: Any, name: str) -> None:
+        nonlocal result
+        nonlocal counter
+        result += f"""    message_bytes, input_bytes = parse_blob(input_bytes)
+    message_{counter} = type({name}).from_bytes(message_bytes)
+    assert message_{counter} == {name}
+    assert bytes(message_{counter}) == bytes({name})
+
+"""
+        counter += 1
+
+    visit_all_messages(visitor)
+
+    result += '    assert input_bytes == b""\n'
+    return result
+
+
+def get_protocol_json() -> str:
+    result = """# ruff: noqa: E501
+# this file is generated by build_network_protocol_files.py
+from __future__ import annotations
+
+from typing import Any
+"""
+    counter = 0
+
+    def visitor(obj: Any, name: str) -> None:
+        nonlocal result
+        nonlocal counter
+        result += f"\n{name}_json: dict[str, Any] = {obj.to_json_dict()}\n"
+        counter += 1
+
+    visit_all_messages(visitor)
+
+    return result
+
+
+def build_json_test() -> str:
+    result = """# ruff: noqa: F405
+# this file is generated by build_network_protocol_files.py
+
+from __future__ import annotations
+
+from chia._tests.util.network_protocol_data import *  # noqa: F403
+from chia._tests.util.protocol_messages_json import *  # noqa: F403
+
+
+def test_protocol_json() -> None:
+"""
+    counter = 0
+
+    def visitor(obj: Any, name: str) -> None:
+        nonlocal result
+        nonlocal counter
+        result += f"    assert str({name}_json) == str({name}.to_json_dict())\n"
+        result += f"    assert type({name}).from_json_dict({name}_json) == {name}\n"
+        counter += 1
+
+    visit_all_messages(visitor)
+
+    return result
+
+
+def main() -> None:
+    get_network_protocol_filename().write_bytes(get_protocol_bytes())
+
+    name_to_function = {
+        "test_network_protocol_files.py": build_protocol_test,
+        "protocol_messages_json.py": get_protocol_json,
+        "test_network_protocol_json.py": build_json_test,
+    }
+
+    for name, function in name_to_function.items():
+        path = tests_dir.joinpath(name)
+        path.write_text(function())
+        subprocess.run(
+            [sys.executable, "-m", "ruff", "format", os.fspath(path.relative_to(tests_dir))],
+            check=True,
+            cwd=tests_dir,
+        )
+
+
+if __name__ == "__main__":
+    main()

chia/_tests/util/config.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+job_timeout = 60

chia/_tests/util/constants.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.util.ints import uint8, uint16, uint32, uint64, uint128
+
+test_constants = DEFAULT_CONSTANTS.replace(
+    MIN_PLOT_SIZE=uint8(18),
+    MIN_BLOCKS_PER_CHALLENGE_BLOCK=uint8(12),
+    DIFFICULTY_STARTING=uint64(2**9),
+    DISCRIMINANT_SIZE_BITS=uint16(16),
+    SUB_EPOCH_BLOCKS=uint32(170),
+    WEIGHT_PROOF_THRESHOLD=uint8(2),
+    WEIGHT_PROOF_RECENT_BLOCKS=uint32(380),
+    DIFFICULTY_CONSTANT_FACTOR=uint128(33554432),
+    NUM_SPS_SUB_SLOT=uint32(16),  # Must be a power of 2
+    MAX_SUB_SLOT_BLOCKS=uint32(50),
+    EPOCH_BLOCKS=uint32(340),
+    SUB_SLOT_ITERS_STARTING=uint64(2**10),  # Must be a multiple of 64
+    NUMBER_ZERO_BITS_PLOT_FILTER=uint8(1),  # H(plot signature of the challenge) must start with these many zeroes
+)

chia/_tests/util/db_connection.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import tempfile
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Optional
+
+import aiosqlite
+
+from chia.util.db_wrapper import DBWrapper2, generate_in_memory_db_uri
+
+
+@asynccontextmanager
+async def DBConnection(
+    db_version: int,
+    foreign_keys: Optional[bool] = None,
+    row_factory: Optional[type[aiosqlite.Row]] = None,
+) -> AsyncIterator[DBWrapper2]:
+    db_uri = generate_in_memory_db_uri()
+    async with DBWrapper2.managed(
+        database=db_uri,
+        uri=True,
+        reader_count=4,
+        db_version=db_version,
+        foreign_keys=foreign_keys,
+        row_factory=row_factory,
+    ) as _db_wrapper:
+        yield _db_wrapper
+
+
+@asynccontextmanager
+async def PathDBConnection(db_version: int) -> AsyncIterator[DBWrapper2]:
+    with tempfile.TemporaryDirectory() as directory:
+        db_path = Path(directory).joinpath("db.sqlite")
+        async with DBWrapper2.managed(database=db_path, reader_count=4, db_version=db_version) as _db_wrapper:
+            yield _db_wrapper