chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/_tests/core/test_cost_calculation.py

@@ -0,0 +1,313 @@
+from __future__ import annotations
+
+import logging
+import pathlib
+
+import pytest
+from chia_rs import G1Element
+from clvm_tools import binutils
+
+from chia._tests.core.make_block_generator import make_block_generator
+from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
+from chia._tests.util.misc import BenchmarkRunner
+from chia.consensus.condition_costs import ConditionCost
+from chia.consensus.cost_calculator import NPCResult
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.full_node.bundle_tools import simple_solution_generator
+from chia.full_node.mempool_check_conditions import get_puzzle_and_solution_for_coin
+from chia.simulator.block_tools import BlockTools, test_constants
+from chia.types.blockchain_format.coin import Coin
+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
+from chia.types.generator_types import BlockGenerator
+from chia.util.ints import uint32, uint64
+from chia.wallet.puzzles import p2_delegated_puzzle_or_hidden_puzzle
+
+BURN_PUZZLE_HASH = bytes32(b"0" * 32)
+SMALL_BLOCK_GENERATOR = make_block_generator(1)
+
+log = logging.getLogger(__name__)
+
+
+def large_block_generator(size: int) -> bytes:
+    # make a small block and hash it
+    # use this in the name for the cached big block
+    # the idea is, if the algorithm for building the big block changes,
+    # the name of the cache file will also change
+
+    name = SMALL_BLOCK_GENERATOR.program.get_tree_hash().hex()[:16]
+
+    my_dir = pathlib.Path(__file__).absolute().parent
+    hex_path = my_dir / f"large-block-{name}-{size}.hex"
+    try:
+        with open(hex_path) as f:
+            hex_str = f.read()
+            return bytes.fromhex(hex_str)
+    except FileNotFoundError:
+        generator = make_block_generator(size)
+        blob = bytes(generator.program)
+        #  TODO: Re-enable large-block*.hex but cache in ~/.chia/subdir
+        #  with open(hex_path, "w") as f:
+        #      f.write(blob.hex())
+        return blob
+
+
+@pytest.mark.anyio
+async def test_basics(softfork_height: int, bt: BlockTools) -> None:
+    wallet_tool = bt.get_pool_wallet_tool()
+    ph = wallet_tool.get_new_puzzlehash()
+    num_blocks = 3
+    blocks = bt.get_consecutive_blocks(
+        num_blocks, [], guarantee_transaction_block=True, pool_reward_puzzle_hash=ph, farmer_reward_puzzle_hash=ph
+    )
+    coinbase = None
+    for coin in blocks[2].get_included_reward_coins():
+        if coin.puzzle_hash == ph and coin.amount == 250000000000:
+            coinbase = coin
+            break
+    assert coinbase is not None
+    spend_bundle = wallet_tool.generate_signed_transaction(
+        uint64(coinbase.amount),
+        BURN_PUZZLE_HASH,
+        coinbase,
+    )
+    assert spend_bundle is not None
+    program: BlockGenerator = simple_solution_generator(spend_bundle)
+
+    npc_result: NPCResult = get_name_puzzle_conditions(
+        program,
+        bt.constants.MAX_BLOCK_COST_CLVM,
+        mempool_mode=False,
+        height=uint32(softfork_height),
+        constants=bt.constants,
+    )
+
+    assert npc_result.error is None
+    assert len(bytes(program.program)) == 433
+
+    coin_spend = spend_bundle.coin_spends[0]
+    assert npc_result.conds is not None
+    assert coin_spend.coin.name() == npc_result.conds.spends[0].coin_id
+    spend_info = get_puzzle_and_solution_for_coin(program, coin_spend.coin, softfork_height, bt.constants)
+    assert spend_info.puzzle == coin_spend.puzzle_reveal
+    assert spend_info.solution == coin_spend.solution
+
+    if softfork_height >= bt.constants.HARD_FORK_HEIGHT:
+        clvm_cost = 27360
+    else:
+        clvm_cost = 404560
+    byte_cost = len(bytes(program.program)) * bt.constants.COST_PER_BYTE
+    assert (
+        npc_result.conds.cost == ConditionCost.CREATE_COIN.value + ConditionCost.AGG_SIG.value + clvm_cost + byte_cost
+    )
+
+    # Create condition + agg_sig_condition + length + cpu_cost
+    assert (
+        npc_result.conds.cost
+        == ConditionCost.CREATE_COIN.value
+        + ConditionCost.AGG_SIG.value
+        + len(bytes(program.program)) * bt.constants.COST_PER_BYTE
+        + clvm_cost
+    )
+
+
+@pytest.mark.anyio
+async def test_mempool_mode(softfork_height: int, bt: BlockTools) -> None:
+    wallet_tool = bt.get_pool_wallet_tool()
+    ph = wallet_tool.get_new_puzzlehash()
+
+    num_blocks = 3
+    blocks = bt.get_consecutive_blocks(
+        num_blocks, [], guarantee_transaction_block=True, pool_reward_puzzle_hash=ph, farmer_reward_puzzle_hash=ph
+    )
+
+    coinbase = None
+    for coin in blocks[2].get_included_reward_coins():
+        if coin.puzzle_hash == ph:
+            coinbase = coin
+            break
+    assert coinbase is not None
+    spend_bundle = wallet_tool.generate_signed_transaction(
+        uint64(coinbase.amount),
+        BURN_PUZZLE_HASH,
+        coinbase,
+    )
+    assert spend_bundle is not None
+
+    pk = bytes.fromhex(
+        "88bc9360319e7c54ab42e19e974288a2d7a817976f7633f4b43f36ce72074e59c4ab8ddac362202f3e366f0aebbb6280"
+    )
+    puzzle = p2_delegated_puzzle_or_hidden_puzzle.puzzle_for_pk(G1Element.from_bytes(pk))
+    disassembly = binutils.disassemble(puzzle)
+    unknown_opcode = "15"
+    program = SerializedProgram.from_bytes(
+        binutils.assemble(
+            f"(q ((0x3d2331635a58c0d49912bc1427d7db51afe3f20a7b4bcaffa17ee250dcbcbfaa {disassembly} 300"
+            f"  (() (q . (({unknown_opcode} '00000000000000000000000000000000' 0x0cbba106e000))) ()))))"
+        ).as_bin()
+    )
+    generator = BlockGenerator(program, [])
+    npc_result: NPCResult = get_name_puzzle_conditions(
+        generator,
+        bt.constants.MAX_BLOCK_COST_CLVM,
+        mempool_mode=True,
+        height=uint32(softfork_height),
+        constants=bt.constants,
+    )
+    assert npc_result.error is not None
+    npc_result = get_name_puzzle_conditions(
+        generator,
+        bt.constants.MAX_BLOCK_COST_CLVM,
+        mempool_mode=False,
+        height=uint32(softfork_height),
+        constants=bt.constants,
+    )
+    assert npc_result.error is None
+
+    coin = Coin(
+        bytes32.fromhex("3d2331635a58c0d49912bc1427d7db51afe3f20a7b4bcaffa17ee250dcbcbfaa"),
+        bytes32.fromhex("14947eb0e69ee8fc8279190fc2d38cb4bbb61ba28f1a270cfd643a0e8d759576"),
+        uint64(300),
+    )
+    spend_info = get_puzzle_and_solution_for_coin(generator, coin, softfork_height, bt.constants)
+    assert spend_info.puzzle.to_program() == puzzle
+
+
+@pytest.mark.anyio
+async def test_clvm_mempool_mode(softfork_height: int) -> None:
+    block = Program.from_bytes(bytes(SMALL_BLOCK_GENERATOR.program))
+    disassembly = binutils.disassemble(block)
+    # this is a valid generator program except the first clvm
+    # if-condition, that depends on executing an unknown operator
+    # ("0xfe"). In mempool mode, this should fail, but in non-mempool
+    # mode, the unknown operator should be treated as if it returns ().
+    program = SerializedProgram.from_bytes(binutils.assemble(f"(i (0xfe (q . 0)) (q . ()) {disassembly})").as_bin())
+    generator = BlockGenerator(program, [])
+    npc_result: NPCResult = get_name_puzzle_conditions(
+        generator,
+        test_constants.MAX_BLOCK_COST_CLVM,
+        mempool_mode=True,
+        height=uint32(softfork_height),
+        constants=test_constants,
+    )
+    assert npc_result.error is not None
+    npc_result = get_name_puzzle_conditions(
+        generator,
+        test_constants.MAX_BLOCK_COST_CLVM,
+        mempool_mode=False,
+        height=uint32(softfork_height),
+        constants=test_constants,
+    )
+    assert npc_result.error is None
+
+
+@pytest.mark.anyio
+async def test_tx_generator_speed(softfork_height: int, benchmark_runner: BenchmarkRunner) -> None:
+    LARGE_BLOCK_COIN_CONSUMED_COUNT = 687
+    generator_bytes = large_block_generator(LARGE_BLOCK_COIN_CONSUMED_COUNT)
+    program = SerializedProgram.from_bytes(generator_bytes)
+
+    with benchmark_runner.assert_runtime(seconds=1.25):
+        generator = BlockGenerator(program, [])
+        npc_result = get_name_puzzle_conditions(
+            generator,
+            test_constants.MAX_BLOCK_COST_CLVM,
+            mempool_mode=False,
+            height=uint32(softfork_height),
+            constants=test_constants,
+        )
+
+    assert npc_result.error is None
+    assert npc_result.conds is not None
+    assert len(npc_result.conds.spends) == LARGE_BLOCK_COIN_CONSUMED_COUNT
+
+
+@pytest.mark.anyio
+async def test_clvm_max_cost(softfork_height: int) -> None:
+    block = Program.from_bytes(bytes(SMALL_BLOCK_GENERATOR.program))
+    disassembly = binutils.disassemble(block)
+    # this is a valid generator program except the first clvm
+    # if-condition, that depends on executing an unknown operator
+    # ("0xfe"). In mempool mode, this should fail, but in non-mempool
+    # mode, the unknown operator should be treated as if it returns ().
+    # the CLVM program has a cost of 391969
+    program = SerializedProgram.from_bytes(
+        binutils.assemble(f"(i (softfork (q . 10000000)) (q . ()) {disassembly})").as_bin()
+    )
+
+    # ensure we fail if the program exceeds the cost
+    generator = BlockGenerator(program, [])
+    npc_result = get_name_puzzle_conditions(
+        generator, 10000000, mempool_mode=False, height=uint32(softfork_height), constants=test_constants
+    )
+
+    assert npc_result.error is not None
+    assert npc_result.conds is None
+
+    # raise the max cost to make sure this passes
+    # ensure we pass if the program does not exceeds the cost
+    npc_result = get_name_puzzle_conditions(
+        generator, 23000000, mempool_mode=False, height=uint32(softfork_height), constants=test_constants
+    )
+
+    assert npc_result.error is None
+    assert npc_result.conds is not None
+    assert npc_result.conds.cost > 10000000
+
+
+@pytest.mark.anyio
+async def test_standard_tx(benchmark_runner: BenchmarkRunner) -> None:
+    # this isn't a real public key, but we don't care
+    public_key = bytes.fromhex(
+        "af949b78fa6a957602c3593a3d6cb7711e08720415dad831ab18adacaa9b27ec3dda508ee32e24bc811c0abc5781ae21"
+    )
+    puzzle_program = SerializedProgram.from_bytes(
+        bytes(p2_delegated_puzzle_or_hidden_puzzle.puzzle_for_pk(G1Element.from_bytes(public_key)))
+    )
+    conditions = binutils.assemble(
+        "((51 0x699eca24f2b6f4b25b16f7a418d0dc4fc5fce3b9145aecdda184158927738e3e 10)"
+        " (51 0x847bb2385534070c39a39cc5dfdc7b35e2db472dc0ab10ab4dec157a2178adbf 0x00cbba106df6))"
+    )
+    solution_program = SerializedProgram.from_bytes(
+        bytes(p2_delegated_puzzle_or_hidden_puzzle.solution_for_conditions(conditions))
+    )
+
+    with benchmark_runner.assert_runtime(seconds=0.1):
+        total_cost = 0
+        for i in range(0, 1000):
+            cost, _result = puzzle_program.run_with_cost(test_constants.MAX_BLOCK_COST_CLVM, solution_program)
+            total_cost += cost
+
+
+@pytest.mark.anyio
+async def test_get_puzzle_and_solution_for_coin_performance(benchmark_runner: BenchmarkRunner) -> None:
+    from chia._tests.core.large_block import LARGE_BLOCK
+    from chia.full_node.mempool_check_conditions import DESERIALIZE_MOD
+
+    assert LARGE_BLOCK.transactions_generator is not None
+    # first, list all spent coins in the block
+    _, result = LARGE_BLOCK.transactions_generator.run_with_cost(
+        DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM, [DESERIALIZE_MOD, []]
+    )
+
+    coin_spends = result.first()
+    spent_coins: list[Coin] = []
+    for spend in coin_spends.as_iter():
+        parent, puzzle, amount_program, _ = spend.as_iter()
+        parent_coin_info = parent.as_atom()
+        puzzle_hash = puzzle.get_tree_hash()
+        amount = uint64(amount_program.as_int())
+        coin = Coin(parent_coin_info=parent_coin_info, puzzle_hash=puzzle_hash, amount=amount)
+        spent_coins.append(coin)
+
+    print(f"found {len(spent_coins)} spent coins in block")
+
+    # benchmark the function to pick out the puzzle and solution for a specific
+    # coin
+    generator = BlockGenerator(LARGE_BLOCK.transactions_generator, [])
+    with benchmark_runner.assert_runtime(seconds=8.5):
+        for _ in range(3):
+            for c in spent_coins:
+                spend_info = get_puzzle_and_solution_for_coin(generator, c, 0, test_constants)
+                assert spend_info.puzzle.get_tree_hash() == c.puzzle_hash

chia/_tests/core/test_crawler.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import logging
+import time
+from datetime import datetime, timedelta
+from typing import cast
+
+import pytest
+
+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 NewPeak
+from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.protocols.wallet_protocol import RequestChildren
+from chia.seeder.peer_record import PeerRecord, PeerReliability
+from chia.server.outbound_message import make_msg
+from chia.types.aliases import CrawlerService
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.peer_info import PeerInfo
+from chia.util.ints import uint32, uint64, uint128
+
+
+@pytest.mark.anyio
+async def test_crawler_loops_by_default(crawler_service: CrawlerService) -> None:
+    """
+    Ensures that when the crawler is started with all defaults, the crawling loop is started
+    """
+    crawler = crawler_service._node
+    assert crawler.crawl_task is not None
+
+
+@pytest.mark.anyio
+async def test_crawler_no_loops(crawler_service_no_loop: CrawlerService) -> None:
+    """
+    Ensures that when the crawler is call in no loop mode, there is no loop running
+    """
+    crawler = crawler_service_no_loop._node
+    assert crawler.crawl_task is None
+
+
+@pytest.mark.anyio
+async def test_unknown_messages(
+    self_hostname: str,
+    one_node: SimulatorsAndWalletsServices,
+    crawler_service_no_loop: CrawlerService,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    [full_node_service], _, _ = one_node
+    crawler = crawler_service_no_loop._node
+    full_node = full_node_service._node
+    assert await crawler.server.start_client(
+        PeerInfo(self_hostname, cast(FullNodeAPI, full_node_service._api).server.get_port()), None
+    )
+    connection = full_node.server.all_connections[crawler.server.node_id]
+
+    def receiving_failed() -> bool:
+        return "Non existing function: request_children" in caplog.text
+
+    with caplog.at_level(logging.ERROR):
+        msg = make_msg(ProtocolMessageTypes.request_children, RequestChildren(bytes32.zeros))
+        assert await connection.send_message(msg)
+        await time_out_assert(10, receiving_failed)
+
+
+@pytest.mark.anyio
+async def test_valid_message(
+    self_hostname: str,
+    one_node: SimulatorsAndWalletsServices,
+    crawler_service_no_loop: CrawlerService,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    [full_node_service], _, _ = one_node
+    crawler = crawler_service_no_loop._node
+    full_node = full_node_service._node
+    assert await crawler.server.start_client(
+        PeerInfo(self_hostname, cast(FullNodeAPI, full_node_service._api).server.get_port()), None
+    )
+    connection = full_node.server.all_connections[crawler.server.node_id]
+
+    def peer_added() -> bool:
+        return crawler.server.all_connections[full_node.server.node_id].get_peer_logging() in crawler.with_peak
+
+    msg = make_msg(
+        ProtocolMessageTypes.new_peak,
+        NewPeak(bytes32.zeros, uint32(2), uint128(1), uint32(1), bytes32(b"\1" * 32)),
+    )
+    assert await connection.send_message(msg)
+    await time_out_assert(10, peer_added)
+
+
+@pytest.mark.anyio
+async def test_crawler_to_db(crawler_service_no_loop: CrawlerService, one_node: SimulatorsAndWalletsServices) -> None:
+    """
+    This is a lot more of an integration test, but it tests the whole process. We add a node to the crawler, then we
+    save it to the db and validate.
+    """
+    [full_node_service], _, _ = one_node
+    full_node = full_node_service._node
+    crawler = crawler_service_no_loop._node
+    crawl_store = crawler.crawl_store
+    assert crawl_store is not None
+    peer_address = "127.0.0.1"
+
+    # create peer records
+    peer_record = PeerRecord(
+        peer_address,
+        peer_address,
+        uint32(full_node.server.get_port()),
+        False,
+        uint64(0),
+        uint32(0),
+        uint64(0),
+        uint64(int(time.time())),
+        uint64(0),
+        "undefined",
+        uint64(0),
+        tls_version="unknown",
+    )
+    peer_reliability = PeerReliability(peer_address, tries=1, successes=1)
+
+    # add peer to the db & mark it as connected
+    await crawl_store.add_peer(peer_record, peer_reliability)
+    assert peer_record == crawl_store.host_to_records[peer_address]
+    await crawler.save_to_db()
+    good_peers = await crawl_store.get_good_peers()
+    assert good_peers == [peer_address]
+
+
+@pytest.mark.anyio
+async def test_crawler_peer_cleanup(
+    crawler_service_no_loop: CrawlerService, one_node: SimulatorsAndWalletsServices
+) -> None:
+    """
+    This is a lot more of an integration test, but it tests the whole process. We add multiple nodes to the crawler,
+    then we save them to the db and validate. One of the nodes is older than the 90 day cutoff, so we also
+    call the prune function and ensure the node is deleted as expected
+    """
+    [full_node_service], _, _ = one_node
+    full_node = full_node_service._node
+    crawler = crawler_service_no_loop._node
+    crawl_store = crawler.crawl_store
+    assert crawl_store is not None
+    peer_addresses = ["10.0.0.1", "10.0.0.2", "10.0.0.3", "10.0.0.4", "10.0.0.5"]
+
+    for idx, peer_address in enumerate(peer_addresses):
+        # create peer records
+        peer_record = PeerRecord(
+            peer_address,
+            peer_address,
+            uint32(full_node.server.get_port()),
+            False,
+            uint64(0),
+            uint32(0),
+            uint64(0),
+            uint64(int(time.time())),
+            uint64(int((datetime.now() - timedelta(days=idx * 10)).timestamp())),
+            "undefined",
+            uint64(0),
+            tls_version="unknown",
+        )
+        peer_reliability = PeerReliability(peer_address, tries=1, successes=1)
+
+        # add peer to the db & mark it as connected
+        await crawl_store.add_peer(peer_record, peer_reliability)
+        assert peer_record == crawl_store.host_to_records[peer_address]
+
+    await crawler.save_to_db()
+    good_peers = await crawl_store.get_good_peers()
+    assert set(good_peers) == set(peer_addresses)
+
+    await crawl_store.prune_old_peers(older_than_days=31)
+    assert 4 == len(crawl_store.host_to_records)
+    good_peers = await crawl_store.get_good_peers()
+    assert set(good_peers) == {"10.0.0.1", "10.0.0.2", "10.0.0.3", "10.0.0.4"}, good_peers

chia/_tests/core/test_crawler_rpc.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import pytest
+
+from chia.rpc.crawler_rpc_api import CrawlerRpcApi
+from chia.seeder.crawler import Crawler
+
+
+@pytest.mark.anyio
+async def test_get_ips_after_timestamp(bt):
+    crawler = Crawler(bt.config.get("seeder", {}), bt.root_path, constants=bt.constants)
+    crawler_rpc_api = CrawlerRpcApi(crawler)
+
+    # Should raise ValueError when `after` is not supplied
+    with pytest.raises(ValueError):
+        await crawler_rpc_api.get_ips_after_timestamp({})
+
+    # Crawler isn't actually crawling, so this should return zero IPs
+    response = await crawler_rpc_api.get_ips_after_timestamp({"after": 0})
+    assert len(response["ips"]) == 0
+
+    # Add some known data
+    # IPs are listed here out of order (by time) to test consistent sorting
+    # Timestamps increase as the IP value increases
+    crawler.best_timestamp_per_peer["0.0.0.0"] = 0
+    crawler.best_timestamp_per_peer["2.2.2.2"] = 1644300000
+    crawler.best_timestamp_per_peer["1.1.1.1"] = 1644213600
+    crawler.best_timestamp_per_peer["7.7.7.7"] = 1644732000
+    crawler.best_timestamp_per_peer["3.3.3.3"] = 1644386400
+    crawler.best_timestamp_per_peer["4.4.4.4"] = 1644472800
+    crawler.best_timestamp_per_peer["9.9.9.9"] = 1644904800
+    crawler.best_timestamp_per_peer["5.5.5.5"] = 1644559200
+    crawler.best_timestamp_per_peer["6.6.6.6"] = 1644645600
+    crawler.best_timestamp_per_peer["8.8.8.8"] = 1644818400
+
+    response = await crawler_rpc_api.get_ips_after_timestamp({"after": 0})
+    assert len(response["ips"]) == 9
+
+    response = await crawler_rpc_api.get_ips_after_timestamp({"after": 1644473000})
+    assert len(response["ips"]) == 5
+
+    # Test offset/limit functionality
+    response = await crawler_rpc_api.get_ips_after_timestamp({"after": 0, "limit": 2})
+    assert len(response["ips"]) == 2
+    assert response["total"] == 9
+    assert response["ips"][0] == "1.1.1.1"
+    assert response["ips"][1] == "2.2.2.2"
+
+    response = await crawler_rpc_api.get_ips_after_timestamp({"after": 0, "offset": 2, "limit": 2})
+    assert len(response["ips"]) == 2
+    assert response["total"] == 9
+    assert response["ips"][0] == "3.3.3.3"
+    assert response["ips"][1] == "4.4.4.4"

chia/_tests/core/test_daemon_rpc.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import pytest
+
+from chia import __version__
+from chia.daemon.client import connect_to_daemon
+
+
+@pytest.mark.anyio
+async def test_get_version_rpc(get_daemon, bt):
+    ws_server = get_daemon
+    config = bt.config
+    client = await connect_to_daemon(
+        config["self_hostname"],
+        config["daemon_port"],
+        50 * 1000 * 1000,
+        bt.get_daemon_ssl_context(),
+        heartbeat=config["daemon_heartbeat"],
+    )
+    response = await client.get_version()
+
+    assert response["data"]["success"]
+    assert response["data"]["version"] == __version__
+    ws_server.stop()

chia/_tests/core/test_db_conversion.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import random
+from pathlib import Path
+
+import pytest
+
+from chia._tests.util.temp_file import TempFile
+from chia.cmds.db_upgrade_func import convert_v1_to_v2
+from chia.consensus.block_body_validation import ForkInfo
+from chia.consensus.blockchain import Blockchain
+from chia.consensus.multiprocess_validation import PreValidationResult
+from chia.full_node.block_store import BlockStore
+from chia.full_node.coin_store import CoinStore
+from chia.full_node.hint_store import HintStore
+from chia.simulator.block_tools import test_constants
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.db_wrapper import DBWrapper2
+from chia.util.ints import uint32, uint64
+
+
+def rand_bytes(num) -> bytes:
+    ret = bytearray(num)
+    for i in range(num):
+        ret[i] = random.getrandbits(8)
+    return bytes(ret)
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("with_hints", [True, False])
+@pytest.mark.skip("we no longer support DB v1")
+async def test_blocks(default_1000_blocks, with_hints: bool):
+    blocks = default_1000_blocks
+
+    hints: list[tuple[bytes32, bytes]] = []
+    for i in range(351):
+        hints.append((bytes32(rand_bytes(32)), rand_bytes(20)))
+
+    # the v1 schema allows duplicates in the hints table
+    for i in range(10):
+        coin_id = bytes32(rand_bytes(32))
+        hint = rand_bytes(20)
+        hints.append((coin_id, hint))
+        hints.append((coin_id, hint))
+
+    for i in range(2000):
+        hints.append((bytes32(rand_bytes(32)), rand_bytes(20)))
+
+    for i in range(5):
+        coin_id = bytes32(rand_bytes(32))
+        hint = rand_bytes(20)
+        hints.append((coin_id, hint))
+        hints.append((coin_id, hint))
+
+    with TempFile() as in_file, TempFile() as out_file:
+        async with DBWrapper2.managed(
+            database=in_file,
+            reader_count=1,
+            db_version=1,
+            journal_mode="OFF",
+            synchronous="OFF",
+        ) as db_wrapper1:
+            block_store1 = await BlockStore.create(db_wrapper1)
+            coin_store1 = await CoinStore.create(db_wrapper1)
+            hint_store1 = await HintStore.create(db_wrapper1)
+            if with_hints:
+                for h in hints:
+                    await hint_store1.add_hints([(h[0], h[1])])
+
+            bc = await Blockchain.create(coin_store1, block_store1, test_constants, Path("."), reserved_cores=0)
+            sub_slot_iters = test_constants.SUB_SLOT_ITERS_STARTING
+            for block in blocks:
+                if block.height != 0 and len(block.finished_sub_slots) > 0:
+                    if block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters is not None:
+                        sub_slot_iters = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters
+                # await _validate_and_add_block(bc, block)
+                results = PreValidationResult(None, uint64(1), None, uint32(0))
+                fork_info = ForkInfo(block.height - 1, block.height - 1, block.prev_header_hash)
+                _, err, _ = await bc.add_block(block, results, sub_slot_iters=sub_slot_iters, fork_info=fork_info)
+                assert err is None
+
+        # now, convert v1 in_file to v2 out_file
+        convert_v1_to_v2(in_file, out_file)
+
+        async with DBWrapper2.managed(database=in_file, reader_count=1, db_version=1) as db_wrapper1:
+            async with DBWrapper2.managed(database=out_file, reader_count=1, db_version=2) as db_wrapper2:
+                block_store1 = await BlockStore.create(db_wrapper1)
+                coin_store1 = await CoinStore.create(db_wrapper1)
+                hint_store1 = await HintStore.create(db_wrapper1)
+
+                block_store2 = await BlockStore.create(db_wrapper2)
+                coin_store2 = await CoinStore.create(db_wrapper2)
+                hint_store2 = await HintStore.create(db_wrapper2)
+
+                if with_hints:
+                    # check hints
+                    for h in hints:
+                        assert h[0] in await hint_store1.get_coin_ids(h[1])
+                        assert h[0] in await hint_store2.get_coin_ids(h[1])
+
+                # check peak
+                assert await block_store1.get_peak() == await block_store2.get_peak()
+
+                # check blocks
+                for block in blocks:
+                    hh = block.header_hash
+                    height = block.height
+                    assert await block_store1.get_full_block(hh) == await block_store2.get_full_block(hh)
+                    assert await block_store1.get_full_block_bytes(hh) == await block_store2.get_full_block_bytes(hh)
+                    assert await block_store1.get_full_blocks_at([height]) == await block_store2.get_full_blocks_at(
+                        [height]
+                    )
+                    assert await block_store1.get_block_records_by_hash(
+                        [hh]
+                    ) == await block_store2.get_block_records_by_hash([hh])
+                    assert await block_store1.get_block_record(hh) == await block_store2.get_block_record(hh)
+                    assert await block_store1.is_fully_compactified(hh) == await block_store2.is_fully_compactified(hh)
+
+                # check coins
+                for block in blocks:
+                    coins = await coin_store1.get_coins_added_at_height(block.height)
+                    coins2 = await coin_store2.get_coins_added_at_height(block.height)
+                    assert len(coins) == len(coins2)
+                    assert set(coins) == set(coins2)
+                    assert await coin_store1.get_coins_removed_at_height(
+                        block.height
+                    ) == await coin_store2.get_coins_removed_at_height(block.height)
+                    for c in coins:
+                        n = c.coin.name()
+                        assert await coin_store1.get_coin_record(n) == await coin_store2.get_coin_record(n)