chia-blockchain 2.4.4__py3-none-any.whl

chia/__init__.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+import importlib.metadata
+
+__version__: str
+try:
+    __version__ = importlib.metadata.version("chia-blockchain")
+except importlib.metadata.PackageNotFoundError:
+    # package is not installed
+    __version__ = "unknown"

chia/__main__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from chia.cmds.chia import main
+
+main()

chia/_tests/README.md

@@ -0,0 +1,53 @@
+# Test CI Job generation
+
+The CI jobs for these tests are managed by `build-workflows.py`.
+
+If you add a test file, or move one to another directory, please run `build-workflows.py`.
+Tests are recognized by the file glob `test_*.py`.
+Changing the contents of a file does not require running `build-workflows.py`.
+
+We currently use github actions. Default runners have two vcpus.
+The workflows are located in [../.github/workflows/](https://github.com/Chia-Network/chia-blockchain/tree/main/.github/workflows).
+
+The inputs to `build-workflows.py` are the templates in `runner-templates`, the file `testconfig.py` in this directory, and the optional `config.py` files in some test subdirectories.
+Files in the template directory ending in `include.yml` are included in jobs based on the per-directory settings.
+
+The generated workflows are output to `../.github/workflows/`.
+
+Each subdirectory below the directories `root_test_dirs` in `testconfig.py` becomes a job in the github workflow matrix.
+If your jobs run too long, simply move some tests into new subdirectories and run `build-workflows.py`.
+A workflow built from a parent directory does not include the tests in its subdirectories.
+The subdirectory jobs do not include the tests from their parents.
+
+## testconfig.py
+
+In the top tests directory, [testconfig.py](https://github.com/Chia-Network/chia-blockchain/tree/main/tests/testconfig.py)
+contains the application settings and the per-directory default settings.
+
+## config.py
+
+Each directory has an optional `config.py` file, which can override the per-directory default settings.
+
+Per directory settings defaults:
+
+```
+parallel = False
+checkout_blocks_and_plots = True
+install_timelord = True
+job_timeout = 30
+```
+
+### Parallel test execution
+
+If you are certain that all the tests in a directory can run in parallel, set `parallel = True` in `config.py` inside that directory.
+
+### Optional job stages
+
+Set `checkout_blocks_and_plots` to `False` to omit checking out the [test-cache](https://github.com/Chia-Network/test-cache) repo.
+
+Set `install_timelord` to `False` to omit the step of installing a Time Lord for your directory's job.
+
+### Job Timeout
+
+Set `job_timeout` to the number of minutes you want the CI system to wait before it kills your job.
+Add two or three minutes to allow for job setup.

chia/_tests/blockchain/blockchain_test_utils.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+from typing import List, Optional
+
+from chia_rs import BLSCache
+
+from chia.consensus.block_body_validation import ForkInfo
+from chia.consensus.blockchain import AddBlockResult, Blockchain
+from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty
+from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_blocks_multiprocessing
+from chia.types.full_block import FullBlock
+from chia.util.errors import Err
+from chia.util.ints import uint32, uint64
+
+
+async def check_block_store_invariant(bc: Blockchain):
+    db_wrapper = bc.block_store.db_wrapper
+
+    if db_wrapper.db_version == 1:
+        return
+
+    in_chain = set()
+    max_height = -1
+    async with db_wrapper.writer_maybe_transaction() as conn:
+        async with conn.execute("SELECT height, in_main_chain FROM full_blocks") as cursor:
+            rows = await cursor.fetchall()
+            for row in rows:
+                height = row[0]
+
+                # if this block is in-chain, ensure we haven't found another block
+                # at this height that's also in chain. That would be an invariant
+                # violation
+                if row[1]:
+                    # make sure we don't have any duplicate heights. Each block
+                    # height can only have a single block with in_main_chain set
+                    assert height not in in_chain
+                    in_chain.add(height)
+                    max_height = max(max_height, height)
+
+            # make sure every height is represented in the set
+            assert len(in_chain) == max_height + 1
+
+
+async def _validate_and_add_block(
+    blockchain: Blockchain,
+    block: FullBlock,
+    *,
+    expected_result: Optional[AddBlockResult] = None,
+    expected_error: Optional[Err] = None,
+    skip_prevalidation: bool = False,
+    fork_info: Optional[ForkInfo] = None,
+    use_bls_cache: bool = False,
+) -> None:
+    # Tries to validate and add the block, and checks that there are no errors in the process and that the
+    # block is added to the peak.
+    # If expected_result is not None, that result will be enforced.
+    # If expected_error is not None, that error will be enforced. If expected_error is not None,
+    # add_block must return Err.INVALID_BLOCK.
+    # If expected_result == INVALID_BLOCK but expected_error is None, we will allow for errors to happen
+
+    prev_b = None
+    prev_ses_block = None
+    if block.height > 0:
+        prev_b = await blockchain.get_block_record_from_db(block.prev_header_hash)
+        if prev_b is not None:  # some negative tests require this
+            curr = prev_b
+            while curr.height > 0 and curr.sub_epoch_summary_included is None:
+                curr = blockchain.block_record(curr.prev_hash)
+            prev_ses_block = curr
+    new_slot = len(block.finished_sub_slots) > 0
+    ssi, diff = get_next_sub_slot_iters_and_difficulty(blockchain.constants, new_slot, prev_b, blockchain)
+    await check_block_store_invariant(blockchain)
+    if skip_prevalidation:
+        results = PreValidationResult(None, uint64(1), None, False, uint32(0))
+    else:
+        # validate_signatures must be False in order to trigger add_block() to
+        # validate the signature.
+        pre_validation_results: List[PreValidationResult] = await pre_validate_blocks_multiprocessing(
+            blockchain.constants,
+            blockchain,
+            [block],
+            blockchain.pool,
+            {},
+            sub_slot_iters=ssi,
+            difficulty=diff,
+            prev_ses_block=prev_ses_block,
+            validate_signatures=False,
+        )
+        assert pre_validation_results is not None
+        results = pre_validation_results[0]
+    if results.error is not None:
+        if expected_result == AddBlockResult.INVALID_BLOCK and expected_error is None:
+            # We expected an error but didn't specify which one
+            await check_block_store_invariant(blockchain)
+            return None
+        if expected_error is None:
+            # We did not expect an error
+            raise AssertionError(Err(results.error))
+        elif Err(results.error) != expected_error:
+            # We expected an error but a different one
+            raise AssertionError(f"Expected {expected_error} but got {Err(results.error)}")
+        await check_block_store_invariant(blockchain)
+        return None
+
+    if use_bls_cache:
+        bls_cache = BLSCache(100)
+    else:
+        bls_cache = None
+
+    (
+        result,
+        err,
+        _,
+    ) = await blockchain.add_block(block, results, bls_cache, ssi, fork_info=fork_info)
+    await check_block_store_invariant(blockchain)
+
+    if expected_error is None and expected_result != AddBlockResult.INVALID_BLOCK:
+        # Expecting an error here (but didn't specify which), let's check if we actually got an error
+        if err is not None:
+            # Got an error
+            raise AssertionError(err)
+    else:
+        # Here we will enforce checking of the exact error
+        if err != expected_error:
+            # Did not get the right error, or did not get an error
+            raise AssertionError(f"Expected {expected_error} but got {err}")
+
+    if expected_result is not None and expected_result != result:
+        raise AssertionError(f"Expected {expected_result} but got {result}")
+    elif expected_result is None:
+        # If we expected an error assume that expected_result = INVALID_BLOCK
+        if expected_error is not None and result != AddBlockResult.INVALID_BLOCK:
+            raise AssertionError(f"Block should be invalid, but received: {result}")
+        # Otherwise, assume that expected_result = NEW_PEAK
+        if expected_error is None and result != AddBlockResult.NEW_PEAK:
+            raise AssertionError(f"Block was not added: {result}")
+
+
+async def _validate_and_add_block_multi_error(
+    blockchain: Blockchain,
+    block: FullBlock,
+    expected_errors: List[Err],
+    skip_prevalidation: bool = False,
+    fork_info: Optional[ForkInfo] = None,
+) -> None:
+    # Checks that the blockchain returns one of the expected errors
+    try:
+        await _validate_and_add_block(blockchain, block, skip_prevalidation=skip_prevalidation, fork_info=fork_info)
+    except Exception as e:
+        assert isinstance(e, AssertionError)
+        assert e.args[0] in expected_errors
+        return
+
+    raise AssertionError("Did not return an error")
+
+
+async def _validate_and_add_block_multi_result(
+    blockchain: Blockchain,
+    block: FullBlock,
+    expected_result: List[AddBlockResult],
+    skip_prevalidation: bool = False,
+    fork_info: Optional[ForkInfo] = None,
+) -> None:
+    try:
+        await _validate_and_add_block(
+            blockchain,
+            block,
+            skip_prevalidation=skip_prevalidation,
+            fork_info=fork_info,
+        )
+    except Exception as e:
+        assert isinstance(e, AssertionError)
+        assert "Block was not added" in e.args[0]
+        expected_list: List[str] = [f"Block was not added: {res}" for res in expected_result]
+        if e.args[0] not in expected_list:
+            raise AssertionError(f"{e.args[0].split('Block was not added: ')[1]} not in {expected_result}")
+
+
+async def _validate_and_add_block_no_error(
+    blockchain: Blockchain,
+    block: FullBlock,
+    skip_prevalidation: bool = False,
+    fork_info: Optional[ForkInfo] = None,
+) -> None:
+    # adds a block and ensures that there is no error. However, does not ensure that block extended the peak of
+    # the blockchain
+    await _validate_and_add_block_multi_result(
+        blockchain,
+        block,
+        expected_result=[
+            AddBlockResult.ALREADY_HAVE_BLOCK,
+            AddBlockResult.NEW_PEAK,
+            AddBlockResult.ADDED_AS_ORPHAN,
+        ],
+        skip_prevalidation=skip_prevalidation,
+        fork_info=fork_info,
+    )

chia/_tests/blockchain/config.py

@@ -0,0 +1,4 @@
+from __future__ import annotations
+
+job_timeout = 70
+checkout_blocks_and_plots = True

chia/_tests/blockchain/test_augmented_chain.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, ClassVar, Dict, List, Optional, Set, cast
+
+import pytest
+
+from chia.consensus.block_record import BlockRecord
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.full_block import FullBlock
+from chia.util.augmented_chain import AugmentedBlockchain
+from chia.util.errors import Err
+from chia.util.ints import uint32
+
+
+@dataclass
+class NullBlockchain:
+
+    if TYPE_CHECKING:
+        from chia.consensus.blockchain_interface import BlocksProtocol
+
+        _protocol_check: ClassVar[BlocksProtocol] = cast("NullBlockchain", None)
+
+    added_blocks: Set[bytes32] = field(default_factory=set)
+    heights: Dict[uint32, bytes32] = field(default_factory=dict)
+
+    # BlocksProtocol
+    async def lookup_block_generators(self, header_hash: bytes32, generator_refs: Set[uint32]) -> Dict[uint32, bytes]:
+        raise ValueError(Err.GENERATOR_REF_HAS_NO_GENERATOR)  # pragma: no cover
+
+    async def get_block_record_from_db(self, header_hash: bytes32) -> Optional[BlockRecord]:
+        return None  # pragma: no cover
+
+    def add_block_record(self, block_record: BlockRecord) -> None:
+        self.added_blocks.add(block_record.header_hash)
+
+    # BlockRecordsProtocol
+    def try_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
+        return None  # pragma: no cover
+
+    def block_record(self, header_hash: bytes32) -> BlockRecord:
+        raise KeyError("no block records in NullBlockchain")  # pragma: no cover
+
+    def height_to_block_record(self, height: uint32) -> BlockRecord:
+        raise ValueError("Height is not in blockchain")
+
+    def height_to_hash(self, height: uint32) -> Optional[bytes32]:
+        return self.heights.get(height)
+
+    def contains_block(self, header_hash: bytes32) -> bool:
+        return False  # pragma: no cover
+
+    def contains_height(self, height: uint32) -> bool:
+        return height in self.heights.keys()
+
+    async def prev_block_hash(self, header_hashes: List[bytes32]) -> List[bytes32]:
+        raise KeyError("no block records in NullBlockchain")  # pragma: no cover
+
+
+@dataclass
+class FakeBlockRecord:
+    height: uint32
+    header_hash: bytes32
+    prev_hash: bytes32
+
+
+def BR(b: FullBlock) -> BlockRecord:
+    ret = FakeBlockRecord(b.height, b.header_hash, b.prev_header_hash)
+    return ret  # type: ignore[return-value]
+
+
+@pytest.mark.anyio
+@pytest.mark.limit_consensus_modes(reason="save time")
+async def test_augmented_chain(default_10000_blocks: List[FullBlock]) -> None:
+
+    blocks = default_10000_blocks
+    # this test blockchain is expected to have block generators at these
+    # heights:
+    # 2, 3, 4, 5, 6, 7, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+    # 24, 25, 26, 28
+
+    null = NullBlockchain()
+    abc = AugmentedBlockchain(null)
+
+    # before adding anything to the augmented blockchain, make sure we just pass
+    # through all requests
+    with pytest.raises(ValueError, match="Height is not in blockchain"):
+        abc.height_to_block_record(uint32(1))
+
+    with pytest.raises(KeyError):
+        abc.block_record(blocks[2].header_hash)
+
+    with pytest.raises(KeyError):
+        await abc.prev_block_hash([blocks[2].header_hash])
+
+    with pytest.raises(ValueError, match="Err.GENERATOR_REF_HAS_NO_GENERATOR"):
+        await abc.lookup_block_generators(blocks[3].header_hash, {uint32(3)})
+
+    block_records = []
+
+    # now add some blocks
+    for b in blocks[:5]:
+        block_records.append(BR(b))
+        abc.add_extra_block(b, BR(b))
+
+    assert abc.height_to_block_record(uint32(1)) == block_records[1]
+
+    with pytest.raises(ValueError, match="Err.GENERATOR_REF_HAS_NO_GENERATOR"):
+        await abc.lookup_block_generators(blocks[10].header_hash, {uint32(3), uint32(10)})
+
+    # block 1 exists in the chain, but it doesn't have a generator
+    with pytest.raises(ValueError, match="Err.GENERATOR_REF_HAS_NO_GENERATOR"):
+        await abc.lookup_block_generators(blocks[1].header_hash, {uint32(1)})
+
+    expect_gen = blocks[2].transactions_generator
+    assert expect_gen is not None
+    assert await abc.lookup_block_generators(blocks[5].prev_header_hash, {uint32(2)}) == {uint32(2): bytes(expect_gen)}
+
+    for i in range(1, 5):
+        assert await abc.prev_block_hash([blocks[i].header_hash]) == [blocks[i - 1].header_hash]
+
+    for i in range(5):
+        assert abc.block_record(blocks[i].header_hash) == block_records[i]
+        assert abc.try_block_record(blocks[i].header_hash) == block_records[i]
+        assert abc.height_to_hash(uint32(i)) == blocks[i].header_hash
+        assert await abc.prev_block_hash([blocks[i].header_hash]) == [blocks[i].prev_header_hash]
+        assert abc.contains_block(blocks[i].header_hash) is True
+        assert await abc.get_block_record_from_db(blocks[i].header_hash) == block_records[i]
+        assert abc.contains_height(uint32(i))
+
+    for i in range(5, 10):
+        assert abc.height_to_hash(uint32(i)) is None
+        assert not abc.contains_block(blocks[i].header_hash)
+        assert not await abc.get_block_record_from_db(blocks[i].header_hash)
+        assert not abc.contains_height(uint32(i))
+
+    assert abc.height_to_hash(uint32(5)) is None
+    null.heights = {uint32(5): blocks[5].header_hash}
+    assert abc.height_to_hash(uint32(5)) == blocks[5].header_hash
+
+    # if we add blocks to cache that are already augmented into the chain, the
+    # augmented blocks should be removed
+    assert len(abc._extra_blocks) == 5
+    for b in blocks[:5]:
+        abc.add_block_record(BR(b))
+    assert len(abc._extra_blocks) == 0
+    assert null.added_blocks == {br.header_hash for br in blocks[:5]}