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/blockchain/test_blockchain.py

@@ -4216,9 +4216,7 @@ async def get_fork_info(blockchain: Blockchain, block: FullBlock, peak: BlockRec
     counter = 0
     start = time.monotonic()
     for height in range(fork_info.fork_height + 1, block.height):
-        fork_block: Optional[FullBlock] = await blockchain.consensus_store.get_full_block(
-            fork_chain[uint32(height)]
-        )
+        fork_block: Optional[FullBlock] = await blockchain.consensus_store.get_full_block(fork_chain[uint32(height)])
         assert fork_block is not None
         assert fork_block.height - 1 == fork_info.peak_height
         assert fork_block.height == 0 or fork_block.prev_header_hash == fork_info.peak_hash

chia/_tests/core/full_node/stores/test_coin_store.py

@@ -340,9 +340,7 @@ async def test_basic_reorg(tmp_dir: Path, db_version: int, bt: BlockTools) -> No
                         assert record.confirmed_block_index == block.height
                         assert record.spent_block_index == 0
 
-            blocks_reorg_chain = bt.get_consecutive_blocks(
-                reorg_length, blocks[: initial_block_count - 10], seed=b"2"
-            )
+            blocks_reorg_chain = bt.get_consecutive_blocks(reorg_length, blocks[: initial_block_count - 10], seed=b"2")
 
             fork_info = ForkInfo(-1, -1, bt.constants.GENESIS_CHALLENGE)
             for reorg_block in blocks_reorg_chain:

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

@@ -47,7 +47,7 @@
 from chia.consensus.augmented_chain import AugmentedBlockchain
 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 +2505,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 +2514,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 +2550,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 +2598,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 +2614,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 +2639,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 +2665,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 +2725,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 +2766,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 +2805,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 +2838,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 +2849,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 +2885,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/_tests/util/blockchain.py

@@ -26,7 +26,6 @@ async def create_blockchain(
 ) -> AsyncIterator[tuple[Blockchain, DBWrapper2]]:
     db_uri = generate_in_memory_db_uri()
     async with DBWrapper2.managed(database=db_uri, uri=True, reader_count=1, db_version=db_version) as wrapper:
-
         block_store = await BlockStore.create(wrapper)
         coin_store = await CoinStore.create(wrapper)
         height_map = await BlockHeightMap.create(Path("."), wrapper, None)

chia/full_node/full_node.py

@@ -42,7 +42,6 @@
 from chia.consensus.block_height_map import BlockHeightMap
 from chia.consensus.blockchain import AddBlockResult, Blockchain, BlockchainMutexPriority, StateChangeSummary
 from chia.consensus.blockchain_interface import BlockchainInterface
-from chia.consensus.coin_store_protocol import CoinStoreProtocol
 from chia.consensus.condition_tools import pkm_pairs
 from chia.consensus.cost_calculator import NPCResult
 from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty
@@ -158,7 +157,7 @@ class FullNode:
     _db_wrapper: Optional[DBWrapper2] = None
     _hint_store: Optional[HintStore] = None
     _block_store: Optional[BlockStore] = None
-    _coin_store: Optional[CoinStoreProtocol] = None
+    _coin_store: Optional[CoinStore] = None
     _mempool_manager: Optional[MempoolManager] = None
     _init_weight_proof: Optional[asyncio.Task[None]] = None
     _blockchain: Optional[Blockchain] = None
@@ -419,7 +418,7 @@ def blockchain(self) -> Blockchain:
         return self._blockchain
 
     @property
-    def coin_store(self) -> CoinStoreProtocol:
+    def coin_store(self) -> CoinStore:
         assert self._coin_store is not None
         return self._coin_store
 

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