chia-blockchain 2.5.7rc4__tar.gz → 2.5.8rc1__tar.gz

chia_blockchain-2.5.8rc1/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: chia-blockchain
+Version: 2.5.8rc1
+Summary: Chia blockchain full node, farmer, timelord, and wallet.
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: chia,blockchain,node
+Author: Mariano Sorgente
+Author-email: mariano@chia.net
+Requires-Python: >=3.10, <4
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: dev
+Provides-Extra: legacy-keyring
+Provides-Extra: upnp
+Requires-Dist: aiofiles (>=24.1.0)
+Requires-Dist: aiohttp (>=3.10.4)
+Requires-Dist: aiohttp_cors ; extra == "dev"
+Requires-Dist: aiosqlite (>=0.20.0)
+Requires-Dist: anyio (>=4.6.2.post1)
+Requires-Dist: bitstring (>=4.1.4)
+Requires-Dist: boto3 (>=1.35.43)
+Requires-Dist: build ; extra == "dev"
+Requires-Dist: chia-puzzles-py (>=0.20.1)
+Requires-Dist: chia_rs (>=0.35,<0.36)
+Requires-Dist: chiabip158 (>=1.5.2)
+Requires-Dist: chialisp (>=0.4.1)
+Requires-Dist: chiapos (>=2.0.10)
+Requires-Dist: chiavdf (>=1.1.10)
+Requires-Dist: click (>=8.1.7)
+Requires-Dist: clvm (>=0.9.14)
+Requires-Dist: clvm_tools (>=0.4.9)
+Requires-Dist: colorama (>=0.4.6)
+Requires-Dist: colorlog (>=6.9.0)
+Requires-Dist: concurrent_log_handler (>=0.9.25)
+Requires-Dist: coverage ; extra == "dev"
+Requires-Dist: cryptography (>=43.0.1)
+Requires-Dist: diff-cover ; extra == "dev"
+Requires-Dist: dnslib (>=0.9.25)
+Requires-Dist: dnspython (>=2.6.1)
+Requires-Dist: filelock (>=3.16.1)
+Requires-Dist: hsms (>=0.3.2)
+Requires-Dist: importlib-resources (>=6.4.5)
+Requires-Dist: keyring (>=25.5.0)
+Requires-Dist: keyrings.cryptfile ; extra == "legacy-keyring"
+Requires-Dist: lxml ; extra == "dev"
+Requires-Dist: miniupnpc ; extra == "upnp"
+Requires-Dist: mypy ; extra == "dev"
+Requires-Dist: packaging (>=24.0)
+Requires-Dist: pip (>=24.2)
+Requires-Dist: pre-commit ; extra == "dev"
+Requires-Dist: psutil (>=6.1.0)
+Requires-Dist: py3createtorrent ; extra == "dev"
+Requires-Dist: pyinstaller ; extra == "dev"
+Requires-Dist: pytest ; extra == "dev"
+Requires-Dist: pytest-cov ; extra == "dev"
+Requires-Dist: pytest-mock ; extra == "dev"
+Requires-Dist: pytest-monitor ; extra == "dev"
+Requires-Dist: pytest-rerunfailures ; extra == "dev"
+Requires-Dist: pytest-xdist ; extra == "dev"
+Requires-Dist: pyyaml (>=6.0.2)
+Requires-Dist: ruff ; extra == "dev"
+Requires-Dist: setproctitle (>=1.3.3)
+Requires-Dist: setuptools (>=75.5.0)
+Requires-Dist: sortedcontainers (>=2.4.0)
+Requires-Dist: tach ; extra == "dev"
+Requires-Dist: types-aiofiles ; extra == "dev"
+Requires-Dist: types-cryptography ; extra == "dev"
+Requires-Dist: types-pyyaml ; extra == "dev"
+Requires-Dist: types-setuptools ; extra == "dev"
+Requires-Dist: typing-extensions (>=4.12.2)
+Requires-Dist: watchdog (>=4.0.1)
+Requires-Dist: zstd (>=1.5.5.1) ; python_version < "3.12"
+Requires-Dist: zstd (>=1.5.5.1) ; python_version >= "3.12"
+Project-URL: changelog, https://github.com/Chia-Network/chia-blockchain/blob/main/CHANGELOG.md
+Project-URL: source, https://github.com/Chia-Network/chia-blockchain/
+Description-Content-Type: text/markdown
+
+# chia-blockchain
+
+[![Chia Network logo][logo-chia]][link-chia]
+
+| Releases                                                                                                                                        | Repo Stats                                                                                                                                                                                                           | Socials                                                                                                                                                                                   |
+| ----------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [![Latest Release][badge-release]][link-latest] <br /> [![Latest RC][badge-rc]][link-release] <br /> [![Latest Beta][badge-beta]][link-release] | [![Coverage][badge-coverage]][link-coverage] <br /> [![Downloads][badge-downloads]][link-downloads] <br /> [![Commits][badge-commits]][link-commits] <br /> [![Contributors][badge-contributors]][link-contributors] | [![Discord][badge-discord]][link-discord] <br /> [![YouTube][badge-youtube]][link-youtube] <br /> [![Reddit][badge-reddit]][link-reddit] <br /> [![Twitter][badge-twitter]][link-twitter] |
+
+Chia is a modern cryptocurrency built from scratch, designed to be efficient, decentralized, and secure. Here are some of the features and benefits:
+
+- [Proof of space and time][link-consensus] based consensus which allows anyone to farm with commodity hardware
+- Very easy to use full node and farmer GUI and cli (thousands of nodes active on mainnet)
+- [Chia seeder][link-seeder], which maintains a list of reliable nodes within the Chia network via a built-in DNS server.
+- Simplified UTXO based transaction model, with small on-chain state
+- Lisp-style Turing-complete functional [programming language][link-chialisp] for money related use cases
+- BLS keys and aggregate signatures (only one signature per block)
+- [Pooling protocol][link-pool] that allows farmers to have control of making blocks
+- Support for light clients with fast, objective syncing
+- A growing community of farmers and developers around the world
+
+Please check out the [Chia website][link-chia], the [Intro to Chia][link-intro], and [FAQ][link-faq] for information on this project.
+
+Python 3.10+ is required. Make sure your default python version is >=3.10 by typing `python3`.
+
+If you are behind a NAT, it can be difficult for peers outside your subnet to reach you when they start up. You can enable [UPnP][link-upnp]
+on your router or add a NAT (for IPv4 but not IPv6) and firewall rules to allow TCP port 8444 access to your peer.
+These methods tend to be router make/model specific.
+
+Most users should only install harvesters, farmers, plotter, full nodes, and wallets.
+Setting up a seeder is best left to more advanced users.
+Building Timelords and VDFs is for sophisticated users, in most environments.
+Chia Network and additional volunteers are running sufficient Timelords for consensus.
+
+## Installing
+
+Install instructions are available in the [Installation Details][link-install] section of the [Chia Docs][link-docs].
+
+## Running
+
+Once installed, an [Intro to Chia][link-intro] guide is available in the [Chia Docs][link-docs].
+
+[badge-beta]: https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fdownload.chia.net%2Flatest%2Fbadge-data-beta.json&query=%24.message&logo=chianetwork&logoColor=black&label=Latest%20Beta&labelColor=%23e9fbbc&color=%231e2b2e
+[badge-beta2]: https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fdownload.chia.net%2Flatest%2Fbadge-data-beta.json&query=%24.message&logo=chianetwork&logoColor=%23e9fbbc&label=Latest%20Beta&labelColor=%23474748&color=%231e2b2e&link=https%3A%2F%2Fgithub.com%2FChia-Network%2Fchia-blockchain%2Freleases&link=https%3A%2F%2Fgithub.com%2FChia-Network%2Fchia-blockchain%2Freleases
+[badge-commits]: https://img.shields.io/github/commit-activity/w/Chia-Network/chia-blockchain?logo=GitHub
+[badge-contributors]: https://img.shields.io/github/contributors/Chia-Network/chia-blockchain?logo=GitHub
+[badge-coverage]: https://img.shields.io/coverallsCoverage/github/Chia-Network/chia-blockchain?logo=Coveralls&logoColor=red&labelColor=%23212F39
+[badge-discord]: https://img.shields.io/badge/discord-Chia%20Network-green.svg
+[badge-discord2]: https://img.shields.io/discord/1034523881404370984.svg?label=Discord&logo=discord&colorB=1e2b2f
+[badge-downloads]: https://img.shields.io/github/downloads/Chia-Network/chia-blockchain/total?logo=GitHub
+[badge-rc]: https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fdownload.chia.net%2Flatest%2Fbadge-data-rc.json&query=%24.message&logo=chianetwork&logoColor=white&label=Latest%20RC&labelColor=%230d3349&color=%23474748
+[badge-reddit]: https://img.shields.io/reddit/subreddit-subscribers/chia?style=flat-square&logo=reddit&labelColor=%230b1416&color=%23222222
+[badge-release]: https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fdownload.chia.net%2Flatest%2Fbadge-data.json&query=%24.message&logo=chianetwork&label=Latest%20Release&labelColor=%231e2b2e&color=%230d3349
+[badge-twitter]: https://img.shields.io/twitter/follow/chia_project?style=flat-square&logo=x.org&logoColor=white&labelColor=black
+[badge-youtube]: https://img.shields.io/youtube/channel/subscribers/UChFkJ3OAUvnHZdiQISWdWPA?style=flat-square&logo=youtube&logoColor=%23ff0000&labelColor=%230f0f0f&color=%23272727
+[link-chia]: https://www.chia.net/
+[link-chialisp]: https://chialisp.com/
+[link-commits]: https://github.com/Chia-Network/chia-blockchain/commits/main/
+[link-consensus]: https://docs.chia.net/consensus-intro/
+[link-contributors]: https://github.com/Chia-Network/chia-blockchain/graphs/contributors
+[link-coverage]: https://coveralls.io/github/Chia-Network/chia-blockchain
+[link-discord]: https://discord.gg/chia
+[link-docs]: https://docs.chia.net/docs-home/
+[link-downloads]: https://www.chia.net/downloads/
+[link-faq]: https://docs.chia.net/faq/
+[link-install]: https://docs.chia.net/installation/
+[link-intro]: https://docs.chia.net/introduction/
+[link-latest]: https://github.com/Chia-Network/chia-blockchain/releases/latest
+[link-pool]: https://docs.chia.net/pool-farming/
+[link-reddit]: https://www.reddit.com/r/chia/
+[link-release]: https://github.com/Chia-Network/chia-blockchain/releases
+[link-seeder]: https://docs.chia.net/guides/seeder-user-guide/
+[link-twitter]: https://twitter.com/chia_project
+[link-upnp]: https://www.homenethowto.com/ports-and-nat/upnp-automatic-port-forward/
+[link-youtube]: https://www.youtube.com/chianetwork
+[logo-chia]: https://www.chia.net/wp-content/uploads/2022/09/chia-logo.svg "Chia logo"
+

chia_blockchain-2.5.8rc1/chia/__init__.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import sys
+from importlib.metadata import PackageNotFoundError, version
+
+__version__: str
+
+try:
+    __version__ = version("chia-blockchain")
+except (PackageNotFoundError, KeyError):
+    __version__ = "unknown"
+
+try:
+    assert False
+except AssertionError:
+    pass
+else:
+    raise Exception("asserts are not working and _must_ be enabled, do not run with an optimized build of python")
+
+if not getattr(sys, "_is_gil_enabled", lambda: True)():
+    raise Exception("freethreading is not supported, do not run with a freethreaded build of python")

chia_blockchain-2.5.8rc1/chia/_tests/blockchain/blockchain_test_utils.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+from chia_rs import FullBlock, SpendBundleConditions
+from chia_rs.sized_ints import uint32, uint64
+
+from chia.consensus.augmented_chain import AugmentedBlockchain
+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_block
+from chia.types.validation_state import ValidationState
+from chia.util.errors import Err
+
+
+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 bc.block_store.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: AddBlockResult | None = None,
+    expected_error: Err | None = None,
+    skip_prevalidation: bool = False,
+    fork_info: ForkInfo | None = None,
+) -> 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:
+        if block.transactions_generator is None:
+            conds = None
+        else:
+            # fake the signature validation. Just say True here.
+            conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, True, 0, 0, 0, 0, 0)
+        results = PreValidationResult(None, uint64(1), conds, uint32(0))
+    else:
+        future = await pre_validate_block(
+            blockchain.constants,
+            AugmentedBlockchain(blockchain),
+            block,
+            blockchain.pool,
+            None,
+            ValidationState(ssi, diff, prev_ses_block),
+        )
+        results = await future
+    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 fork_info is None:
+        fork_info = ForkInfo(block.height - 1, block.height - 1, block.prev_header_hash)
+
+    (
+        result,
+        err,
+        _,
+    ) = await blockchain.add_block(block, results, 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)
+    # Here we will enforce checking of the exact error
+    elif 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: ForkInfo | None = 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: ForkInfo | None = 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: ForkInfo | None = 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_blockchain-2.5.8rc1/chia/_tests/blockchain/test_augmented_chain.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, ClassVar, cast
+
+import pytest
+from chia_rs import BlockRecord, FullBlock
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32
+
+from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
+from chia._tests.util.blockchain import create_blockchain
+from chia.consensus.augmented_chain import AugmentedBlockchain
+from chia.simulator.block_tools import BlockTools
+from chia.util.errors import Err
+
+
+@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) -> BlockRecord | None:
+        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) -> BlockRecord | None:
+        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) -> bytes32 | None:
+        return self.heights.get(height)
+
+    def contains_block(self, header_hash: bytes32, height: uint32) -> 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=re.escape(Err.GENERATOR_REF_HAS_NO_GENERATOR.name)):
+        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=re.escape(Err.GENERATOR_REF_HAS_NO_GENERATOR.name)):
+        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=re.escape(Err.GENERATOR_REF_HAS_NO_GENERATOR.name)):
+        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.try_block_record(blocks[i].header_hash) is not None
+        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 abc.try_block_record(blocks[i].header_hash) is None
+        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]}
+
+
+@pytest.mark.anyio
+@pytest.mark.limit_consensus_modes(reason="save time")
+async def test_augmented_chain_contains_block(default_10000_blocks: list[FullBlock], bt: BlockTools) -> None:
+    blocks = default_10000_blocks[:50]
+    async with create_blockchain(bt.constants, 2) as (b1, _):
+        async with create_blockchain(bt.constants, 2) as (b2, _):
+            for block in blocks:
+                await _validate_and_add_block(b1, block)
+                await _validate_and_add_block(b2, block)
+
+            new_blocks = bt.get_consecutive_blocks(10, block_list_input=blocks)[50:]
+            abc = AugmentedBlockchain(b1)
+            for block in new_blocks:
+                await _validate_and_add_block(b2, block)
+                block_rec = b2.block_record(block.header_hash)
+                abc.add_extra_block(block, block_rec)
+
+            for block in blocks:
+                # check underlying contains block but augmented does not
+                assert abc.contains_block(block.header_hash, block.height) is True
+                assert block.height not in abc._height_to_hash
+
+            for block in new_blocks:
+                # check augmented contains block but augmented does not
+                assert abc.contains_block(block.header_hash, block.height) is True
+                assert not abc._underlying.contains_height(block.height)
+
+            for block in new_blocks:
+                await _validate_and_add_block(b1, block)
+
+            for block in new_blocks:
+                # check underlying contains block
+                assert abc._underlying.height_to_hash(block.height) == block.header_hash
+                # check augmented contains block
+                assert abc._height_to_hash[block.height] == block.header_hash
+
+            abc.remove_extra_block(new_blocks[-1].header_hash)
+
+            # check blocks removed from augmented
+            for block in new_blocks:
+                # check underlying contains block
+                assert abc._underlying.height_to_hash(block.height) == block.header_hash
+                # check augmented contains block
+                assert block.height not in abc._height_to_hash