more tests

Author: richardkiss

chia/_tests/blockchain/blockchain_test_utils.py

@@ -15,14 +15,9 @@
 
 
 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 bc.consensus_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:

chia/_tests/core/full_node/test_conditions.py

@@ -83,8 +83,8 @@ async def check_spend_bundle_validity(
 
         if expected_err is None:
             await _validate_and_add_block(blockchain, newest_block)
-            coins_added = await blockchain.coin_store.get_coins_added_at_height(uint32(len(blocks)))
-            coins_removed = await blockchain.coin_store.get_coins_removed_at_height(uint32(len(blocks)))
+            coins_added = await blockchain.consensus_store.get_coins_added_at_height(uint32(len(blocks)))
+            coins_removed = await blockchain.consensus_store.get_coins_removed_at_height(uint32(len(blocks)))
         else:
             await _validate_and_add_block(blockchain, newest_block, expected_error=expected_err)
             coins_added = []

chia/_tests/core/full_node/test_full_node.py

@@ -48,6 +48,7 @@
 from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.blockchain import Blockchain
 from chia.consensus.coin_store_protocol import CoinStoreProtocol
+from chia.consensus.consensus_store_protocol import ConsensusStoreProtocol
 from chia.consensus.get_block_challenge import get_block_challenge
 from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_block
 from chia.consensus.pot_iterations import is_overflow_block
@@ -2505,7 +2506,7 @@ def print_coin_records(records: dict[bytes32, CoinRecord]) -> None:  # pragma: n
         print(f"{rec}")
 
 
-async def validate_coin_set(coin_store: CoinStoreProtocol, blocks: list[FullBlock]) -> None:
+async def validate_coin_set(consensus_store: ConsensusStoreProtocol, blocks: list[FullBlock]) -> None:
     prev_height = blocks[0].height - 1
     prev_hash = blocks[0].prev_header_hash
     for block in blocks:
@@ -2514,7 +2515,7 @@ async def validate_coin_set(coin_store: CoinStoreProtocol, blocks: list[FullBloc
         prev_height = int(block.height)
         prev_hash = block.header_hash
         rewards = block.get_included_reward_coins()
-        records = {rec.coin.name(): rec for rec in await coin_store.get_coins_added_at_height(block.height)}
+        records = {rec.coin.name(): rec for rec in await consensus_store.get_coins_added_at_height(block.height)}
 
         # validate reward coins
         for reward in rewards:
@@ -2550,7 +2551,7 @@ async def validate_coin_set(coin_store: CoinStoreProtocol, blocks: list[FullBloc
             print_coin_records(records)
         assert records == {}
 
-        records = {rec.coin.name(): rec for rec in await coin_store.get_coins_removed_at_height(block.height)}
+        records = {rec.coin.name(): rec for rec in await consensus_store.get_coins_removed_at_height(block.height)}
         for name, rem in removals:
             rec = records.pop(name)
             assert rec is not None
@@ -2598,8 +2599,8 @@ async def test_long_reorg(
     assert reorg_blocks[fork_point] == default_10000_blocks[fork_point]
     assert reorg_blocks[fork_point + 1] != default_10000_blocks[fork_point + 1]
 
-    assert node.full_node._coin_store is not None
-    await validate_coin_set(node.full_node._coin_store, blocks)
+    assert node.full_node.blockchain.consensus_store is not None
+    await validate_coin_set(node.full_node.blockchain.consensus_store, blocks)
 
     # one aspect of this test is to make sure we can reorg blocks that are
     # not in the cache. We need to explicitly prune the cache to get that
@@ -2614,7 +2615,7 @@ async def test_long_reorg(
     chain_2_weight = peak.weight
     chain_2_peak = peak.header_hash
 
-    await validate_coin_set(node.full_node._coin_store, reorg_blocks)
+    await validate_coin_set(node.full_node.blockchain.consensus_store, reorg_blocks)
 
     # if the reorg chain has lighter blocks, once we've re-orged onto it, we
     # have a greater block height. If the reorg chain has heavier blocks, we
@@ -2639,7 +2640,7 @@ async def test_long_reorg(
     assert peak.header_hash != chain_2_peak
     assert peak.weight > chain_2_weight
 
-    await validate_coin_set(node.full_node._coin_store, blocks)
+    await validate_coin_set(node.full_node.blockchain.consensus_store, blocks)
 
 
 @pytest.mark.anyio
@@ -2665,9 +2666,9 @@ async def test_long_reorg_nodes(
 ) -> None:
     full_node_1, full_node_2, full_node_3 = three_nodes
 
-    assert full_node_1.full_node._coin_store is not None
-    assert full_node_2.full_node._coin_store is not None
-    assert full_node_3.full_node._coin_store is not None
+    assert full_node_1.full_node.blockchain.consensus_store is not None
+    assert full_node_2.full_node.blockchain.consensus_store is not None
+    assert full_node_3.full_node.blockchain.consensus_store is not None
 
     if light_blocks:
         if fork_point == 1500:
@@ -2725,8 +2726,8 @@ def check_nodes_in_sync() -> bool:
     assert p2 is not None
     assert p2.header_hash == reorg_blocks[-1].header_hash
 
-    await validate_coin_set(full_node_1.full_node._coin_store, reorg_blocks)
-    await validate_coin_set(full_node_2.full_node._coin_store, reorg_blocks)
+    await validate_coin_set(full_node_1.full_node.blockchain.consensus_store, reorg_blocks)
+    await validate_coin_set(full_node_2.full_node.blockchain.consensus_store, reorg_blocks)
 
     blocks = default_10000_blocks[:reorg_height]
 
@@ -2766,9 +2767,9 @@ def check_nodes_in_sync2() -> bool:
     print(f"reorg1 timing: {reorg1_timing:0.2f}s")
     print(f"reorg2 timing: {reorg2_timing:0.2f}s")
 
-    await validate_coin_set(full_node_1.full_node._coin_store, blocks)
-    await validate_coin_set(full_node_2.full_node._coin_store, blocks)
-    await validate_coin_set(full_node_3.full_node._coin_store, blocks)
+    await validate_coin_set(full_node_1.full_node.blockchain.consensus_store, blocks)
+    await validate_coin_set(full_node_2.full_node.blockchain.consensus_store, blocks)
+    await validate_coin_set(full_node_3.full_node.blockchain.consensus_store, blocks)
 
 
 @pytest.mark.anyio
@@ -2805,8 +2806,8 @@ def check_nodes_in_sync() -> bool:
         return p1 == p2
 
     await time_out_assert(10, check_nodes_in_sync)
-    await validate_coin_set(full_node_1.full_node.blockchain.coin_store, chain)
-    await validate_coin_set(full_node_2.full_node.blockchain.coin_store, chain)
+    await validate_coin_set(full_node_1.full_node.blockchain.consensus_store, chain)
+    await validate_coin_set(full_node_2.full_node.blockchain.consensus_store, chain)
 
     # we spend a coin in the next block
     spend_bundle = wallet_a.generate_signed_transaction(uint64(1_000), receiver_puzzlehash, all_coins.pop())
@@ -2838,8 +2839,8 @@ def check_nodes_in_sync() -> bool:
     await add_blocks_in_batches(chain_a[-1:], full_node_1.full_node)
 
     await time_out_assert(10, check_nodes_in_sync)
-    await validate_coin_set(full_node_1.full_node.blockchain.coin_store, chain_a)
-    await validate_coin_set(full_node_2.full_node.blockchain.coin_store, chain_a)
+    await validate_coin_set(full_node_1.full_node.blockchain.consensus_store, chain_a)
+    await validate_coin_set(full_node_2.full_node.blockchain.consensus_store, chain_a)
 
     await add_blocks_in_batches(chain_b[-1:], full_node_1.full_node)
 
@@ -2849,8 +2850,8 @@ def check_nodes_in_sync() -> bool:
     assert peak.header_hash == chain_b[-1].header_hash
 
     await time_out_assert(10, check_nodes_in_sync)
-    await validate_coin_set(full_node_1.full_node.blockchain.coin_store, chain_b)
-    await validate_coin_set(full_node_2.full_node.blockchain.coin_store, chain_b)
+    await validate_coin_set(full_node_1.full_node.blockchain.consensus_store, chain_b)
+    await validate_coin_set(full_node_2.full_node.blockchain.consensus_store, chain_b)
 
     # now continue building the chain on top of B
     # since spend_bundle was supposed to have been reorged-out, we should be
@@ -2885,8 +2886,8 @@ def check_nodes_in_sync() -> bool:
 
     await add_blocks_in_batches(chain[-4:], full_node_1.full_node)
     await time_out_assert(10, check_nodes_in_sync)
-    await validate_coin_set(full_node_1.full_node.blockchain.coin_store, chain)
-    await validate_coin_set(full_node_2.full_node.blockchain.coin_store, chain)
+    await validate_coin_set(full_node_1.full_node.blockchain.consensus_store, chain)
+    await validate_coin_set(full_node_2.full_node.blockchain.consensus_store, chain)
 
 
 @pytest.mark.anyio

chia/full_node/full_node_rpc_api.py

@@ -466,7 +466,7 @@ async def get_block_records(self, request: dict[str, Any]) -> EndpointResult:
             record: Optional[BlockRecord] = self.service.blockchain.try_block_record(header_hash)
             if record is None:
                 # Fetch from DB
-                record = await self.service.blockchain.block_store.get_block_record(header_hash)
+                record = await self.service.block_store.get_block_record(header_hash)
             if record is None:
                 raise ValueError(f"Block {header_hash.hex()} does not exist")
 
@@ -528,7 +528,7 @@ async def get_block_record_by_height(self, request: dict[str, Any]) -> EndpointR
         record: Optional[BlockRecord] = self.service.blockchain.try_block_record(header_hash)
         if record is None:
             # Fetch from DB
-            record = await self.service.blockchain.block_store.get_block_record(header_hash)
+            record = await self.service.block_store.get_block_record(header_hash)
         if record is None:
             raise ValueError(f"Block {header_hash} does not exist")
         return {"block_record": record}
@@ -541,7 +541,7 @@ async def get_block_record(self, request: dict[str, Any]) -> EndpointResult:
         record: Optional[BlockRecord] = self.service.blockchain.try_block_record(header_hash)
         if record is None:
             # Fetch from DB
-            record = await self.service.blockchain.block_store.get_block_record(header_hash)
+            record = await self.service.block_store.get_block_record(header_hash)
         if record is None:
             raise ValueError(f"Block {header_hash.hex()} does not exist")
 
@@ -624,7 +624,7 @@ async def get_coin_records_by_puzzle_hash(self, request: dict[str, Any]) -> Endp
         if "include_spent_coins" in request:
             kwargs["include_spent_coins"] = request["include_spent_coins"]
 
-        coin_records = await self.service.blockchain.coin_store.get_coin_records_by_puzzle_hash(**kwargs)
+        coin_records = await self.service.coin_store.get_coin_records_by_puzzle_hash(**kwargs)
 
         return {"coin_records": [coin_record_dict_backwards_compat(cr.to_json_dict()) for cr in coin_records]}
 
@@ -646,7 +646,7 @@ async def get_coin_records_by_puzzle_hashes(self, request: dict[str, Any]) -> En
         if "include_spent_coins" in request:
             kwargs["include_spent_coins"] = request["include_spent_coins"]
 
-        coin_records = await self.service.blockchain.coin_store.get_coin_records_by_puzzle_hashes(**kwargs)
+        coin_records = await self.service.coin_store.get_coin_records_by_puzzle_hashes(**kwargs)
 
         return {"coin_records": [coin_record_dict_backwards_compat(cr.to_json_dict()) for cr in coin_records]}
 
@@ -658,7 +658,7 @@ async def get_coin_record_by_name(self, request: dict[str, Any]) -> EndpointResu
             raise ValueError("Name not in request")
         name = bytes32.from_hexstr(request["name"])
 
-        coin_record: Optional[CoinRecord] = await self.service.blockchain.coin_store.get_coin_record(name)
+        coin_record: Optional[CoinRecord] = await self.service.coin_store.get_coin_record(name)
         if coin_record is None:
             raise ValueError(f"Coin record 0x{name.hex()} not found")
 
@@ -682,7 +682,7 @@ async def get_coin_records_by_names(self, request: dict[str, Any]) -> EndpointRe
         if "include_spent_coins" in request:
             kwargs["include_spent_coins"] = request["include_spent_coins"]
 
-        coin_records = await self.service.blockchain.coin_store.get_coin_records_by_names(**kwargs)
+        coin_records = await self.service.coin_store.get_coin_records_by_names(**kwargs)
 
         return {"coin_records": [coin_record_dict_backwards_compat(cr.to_json_dict()) for cr in coin_records]}
 
@@ -704,7 +704,7 @@ async def get_coin_records_by_parent_ids(self, request: dict[str, Any]) -> Endpo
         if "include_spent_coins" in request:
             kwargs["include_spent_coins"] = request["include_spent_coins"]
 
-        coin_records = await self.service.blockchain.coin_store.get_coin_records_by_parent_ids(**kwargs)
+        coin_records = await self.service.coin_store.get_coin_records_by_parent_ids(**kwargs)
 
         return {"coin_records": [coin_record_dict_backwards_compat(cr.to_json_dict()) for cr in coin_records]}
 
@@ -733,7 +733,7 @@ async def get_coin_records_by_hint(self, request: dict[str, Any]) -> EndpointRes
         if "include_spent_coins" in request:
             kwargs["include_spent_coins"] = request["include_spent_coins"]
 
-        coin_records = await self.service.blockchain.coin_store.get_coin_records_by_names(**kwargs)
+        coin_records = await self.service.coin_store.get_coin_records_by_names(**kwargs)
 
         return {"coin_records": [coin_record_dict_backwards_compat(cr.to_json_dict()) for cr in coin_records]}
 
@@ -1008,7 +1008,7 @@ async def get_fee_estimate(self, request: dict[str, Any]) -> dict[str, Any]:
             assert last_peak_timestamp is not None  # mypy
             assert last_tx_block.fees is not None  # mypy
 
-            record = await self.service.blockchain.block_store.get_full_block(last_tx_block.header_hash)
+            record = await self.service.block_store.get_full_block(last_tx_block.header_hash)
 
             last_block_cost = 0
             fee_rate_last_block = 0.0