bump chia_rs, cleanup

Author: almogdepaz

benchmarks/block_ref.py

@@ -62,7 +62,7 @@ async def main(db_path: Path) -> None:
         db_wrapper = DBWrapper2(connection, db_version=db_version)
         await db_wrapper.add_connection(await aiosqlite.connect(db_path))
 
-        block_store = await BlockStore.create(db_wrapper, DEFAULT_CONSTANTS)
+        block_store = await BlockStore.create(db_wrapper)
         coin_store = await CoinStore.create(db_wrapper)
 
         start_time = monotonic()

benchmarks/block_store.py

@@ -33,7 +33,6 @@
     rand_vdf_proof,
     rewards,
 )
-from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.block_store import BlockStore
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 
@@ -58,7 +57,7 @@ async def run_add_block_benchmark(version: int) -> None:
     header_hashes = []
 
     async with setup_db("block-store-benchmark.db", version) as db_wrapper:
-        block_store = await BlockStore.create(db_wrapper, DEFAULT_CONSTANTS)
+        block_store = await BlockStore.create(db_wrapper)
 
         block_height = 1
         timestamp = uint64(1631794488)
@@ -100,7 +99,7 @@ async def run_add_block_benchmark(version: int) -> None:
                     uint8(random.randint(0, 255)),  # num_blocks_overflow: uint8
                     None,  # new_difficulty: Optional[uint64]
                     None,  # new_sub_slot_iters: Optional[uint64]
-                    bytes32.zeros,  # challenge_merkle_root: bytes32
+                    None,  # challenge_merkle_root: Optional[bytes32]
                 )
 
             has_pool_pk = random.randint(0, 1)
@@ -128,7 +127,7 @@ async def run_add_block_benchmark(version: int) -> None:
                 rand_g2(),  # reward_chain_sp_signature
                 rand_vdf(),  # reward_chain_ip_vdf
                 rand_vdf() if deficit < 16 else None,
-                None,  # header_mmr_root - dummy for benchmark
+                None,  # header_mmr_root
                 is_transaction,
             )
 

chia/_tests/blockchain/test_block_commitments.py

@@ -5,17 +5,17 @@
 import pytest
 from chia_rs import FullBlock
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint32
+from chia_rs.sized_ints import uint8, uint32
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block, _validate_and_add_block_no_error
 from chia._tests.conftest import ConsensusMode
 from chia._tests.core.node_height import node_height_exactly
-from chia._tests.simulation.test_simulation import test_constants
 from chia._tests.util.blockchain import create_blockchain
 from chia._tests.util.setup_nodes import setup_two_nodes
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.consensus.get_block_challenge import pre_sp_tx_block_height
 from chia.protocols import full_node_protocol
+from chia.simulator.block_tools import test_constants
 from chia.types.peer_info import PeerInfo
 from chia.util.errors import Err
 
@@ -34,10 +34,8 @@ async def test_add_fork_height_zero_blocks(
         blocks = fork_height2_0_1000_blocks
         constants = test_constants.replace(
             HARD_FORK2_HEIGHT=uint32(0),
-            HARD_FORK_HEIGHT=uint32(2),
-            PLOT_FILTER_128_HEIGHT=uint32(10),
-            PLOT_FILTER_64_HEIGHT=uint32(15),
-            PLOT_FILTER_32_HEIGHT=uint32(20),
+            HARD_FORK_HEIGHT=uint32(0),
+            PLOT_V1_PHASE_OUT_EPOCH_BITS=uint8(8),
         )
         passed_sp_or_slot = False
         async with create_blockchain(constants, 2) as (blockchain, _):
@@ -87,10 +85,8 @@ async def test_verify_fork_transition_point(
         blocks = fork_height2_500_1000_blocks
         constants = test_constants.replace(
             HARD_FORK2_HEIGHT=uint32(500),
-            HARD_FORK_HEIGHT=uint32(2),
-            PLOT_FILTER_128_HEIGHT=uint32(10),
-            PLOT_FILTER_64_HEIGHT=uint32(15),
-            PLOT_FILTER_32_HEIGHT=uint32(20),
+            HARD_FORK_HEIGHT=uint32(0),
+            PLOT_V1_PHASE_OUT_EPOCH_BITS=uint8(8),
         )
 
         passed_fork = False
@@ -158,6 +154,8 @@ async def test_sync_fork_height_zero_blocks(
         blocks = fork_height2_0_1000_blocks
         constants = test_constants.replace(
             HARD_FORK2_HEIGHT=uint32(0),
+            HARD_FORK_HEIGHT=uint32(0),
+            PLOT_V1_PHASE_OUT_EPOCH_BITS=uint8(8),
         )
 
         async with setup_two_nodes(constants, db_version, self_hostname) as (
@@ -206,10 +204,8 @@ async def test_sync_fork_height_500_blocks(
         blocks = fork_height2_500_1000_blocks
         constants = test_constants.replace(
             HARD_FORK2_HEIGHT=uint32(500),
-            HARD_FORK_HEIGHT=uint32(2),
-            PLOT_FILTER_128_HEIGHT=uint32(10),
-            PLOT_FILTER_64_HEIGHT=uint32(15),
-            PLOT_FILTER_32_HEIGHT=uint32(20),
+            HARD_FORK_HEIGHT=uint32(0),
+            PLOT_V1_PHASE_OUT_EPOCH_BITS=uint8(8),
         )
 
         async with setup_two_nodes(constants, db_version, self_hostname) as (

chia/_tests/conftest.py

@@ -476,43 +476,36 @@ def default_10000_blocks_compact(bt, consensus_mode):
     )
 
 
-# Fixture for blocks with fork height = 0 (all blocks have new commitments)
 @pytest.fixture(scope="session")
 async def fork_height2_0_1000_blocks(consensus_mode, get_keychain, anyio_backend, testrun_uid: str):
     """Creates 1000 blocks with HARD_FORK2_HEIGHT=0 so all blocks contain new commitments"""
     from chia._tests.util.blockchain import persistent_blocks
     from chia.simulator.block_tools import create_block_tools_async
 
-    # Create custom constants with HARD_FORK2_HEIGHT=0
     constants = test_constants.replace(
         HARD_FORK2_HEIGHT=uint32(0),
+        HARD_FORK_HEIGHT=uint32(0),
+        PLOT_V1_PHASE_OUT_EPOCH_BITS=uint8(8),
     )
-
-    # Create custom block tools with these constants
     bt_fork_zero = await create_block_tools_async(constants=constants, keychain=get_keychain, testrun_uid=testrun_uid)
-
     version = "_fork_height_zero"
     if consensus_mode >= ConsensusMode.HARD_FORK_2_0:
         version += "_hardfork"
-
     return persistent_blocks(1000, f"test_blocks_1000{version}.db", bt_fork_zero, seed=b"fork_zero")
 
 
-# Fixture for blocks with fork height = 500 (transition from old to new commitments)
 @pytest.fixture(scope="session")
 async def fork_height2_500_1000_blocks(consensus_mode, get_keychain, anyio_backend, testrun_uid: str):
     """Creates 1000 blocks with HARD_FORK2_HEIGHT=500 so fork activates mid-chain"""
     from chia._tests.util.blockchain import persistent_blocks
     from chia.simulator.block_tools import create_block_tools_async
 
-    # Create custom constants with HARD_FORK2_HEIGHT=500
     constants = test_constants.replace(
         HARD_FORK2_HEIGHT=uint32(500),
+        HARD_FORK_HEIGHT=uint32(0),
+        PLOT_V1_PHASE_OUT_EPOCH_BITS=uint8(8),
     )
-
-    # Create custom block tools with these constants
     bt_fork_500 = await create_block_tools_async(constants=constants, keychain=get_keychain, testrun_uid=testrun_uid)
-
     version = "_fork_height_500"
     if consensus_mode >= ConsensusMode.HARD_FORK_2_0:
         version += "_hardfork"

chia/_tests/core/custom_types/test_sub_epoch_summary.py

@@ -13,7 +13,7 @@ def test_sub_epoch_summary_basic() -> None:
         num_blocks_overflow=uint8(7),
         new_difficulty=uint64(8),
         new_sub_slot_iters=uint64(9),
-        challenge_merkle_root=bytes32.zeros,  # placeholder
+        challenge_merkle_root=None,
     )
 
     # Test basic properties
@@ -22,7 +22,7 @@ def test_sub_epoch_summary_basic() -> None:
     assert ses.num_blocks_overflow == uint8(7)
     assert ses.new_difficulty == uint64(8)
     assert ses.new_sub_slot_iters == uint64(9)
-    assert ses.challenge_merkle_root == bytes32.zeros
+    assert ses.challenge_merkle_root is None
 
 
 def test_sub_epoch_summary_with_different_merkle_roots() -> None:
@@ -33,7 +33,7 @@ def test_sub_epoch_summary_with_different_merkle_roots() -> None:
         num_blocks_overflow=uint8(7),
         new_difficulty=uint64(8),
         new_sub_slot_iters=uint64(9),
-        challenge_merkle_root=bytes32.zeros,  # different value
+        challenge_merkle_root=bytes32([1] * 32),  # different value
     )
 
     ses2 = SubEpochSummary(
@@ -42,7 +42,7 @@ def test_sub_epoch_summary_with_different_merkle_roots() -> None:
         num_blocks_overflow=uint8(7),
         new_difficulty=uint64(8),
         new_sub_slot_iters=uint64(9),
-        challenge_merkle_root=bytes32([1] * 32),  # different value
+        challenge_merkle_root=bytes32([2] * 32),  # different value
     )
 
     # Different merkle roots should create different objects
@@ -57,7 +57,7 @@ def test_sub_epoch_summary_optional_fields() -> None:
         num_blocks_overflow=uint8(3),
         new_difficulty=None,
         new_sub_slot_iters=None,
-        challenge_merkle_root=bytes32.zeros,  # placeholder
+        challenge_merkle_root=bytes32([2] * 32),
     )
 
     assert ses.new_difficulty is None
@@ -70,7 +70,7 @@ def test_sub_epoch_summary_optional_fields() -> None:
         num_blocks_overflow=uint8(3),
         new_difficulty=uint64(4),
         new_sub_slot_iters=None,
-        challenge_merkle_root=bytes32.zeros,  # placeholder
+        challenge_merkle_root=bytes32([2] * 32),
     )
 
     assert ses2.new_difficulty == uint64(4)

chia/_tests/core/full_node/ram_db.py

@@ -20,7 +20,7 @@ async def create_ram_blockchain(
 ) -> AsyncIterator[tuple[DBWrapper2, Blockchain]]:
     uri = f"file:db_{random.randint(0, 99999999)}?mode=memory&cache=shared"
     async with DBWrapper2.managed(database=uri, uri=True, reader_count=1, db_version=2) as db_wrapper:
-        block_store = await BlockStore.create(db_wrapper, consensus_constants)
+        block_store = await BlockStore.create(db_wrapper)
         coin_store = await CoinStore.create(db_wrapper)
         height_map = await BlockHeightMap.create(Path("."), db_wrapper)
         blockchain = await Blockchain.create(coin_store, block_store, height_map, consensus_constants, 2)

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

@@ -73,12 +73,12 @@ async def test_block_store(tmp_dir: Path, db_version: int, bt: BlockTools, use_c
     async with DBConnection(db_version) as db_wrapper, DBConnection(db_version) as db_wrapper_2:
         # Use a different file for the blockchain
         coin_store_2 = await CoinStore.create(db_wrapper_2)
-        store_2 = await BlockStore.create(db_wrapper_2, bt.constants, use_cache=use_cache)
+        store_2 = await BlockStore.create(db_wrapper_2, use_cache=use_cache)
         height_map = await BlockHeightMap.create(tmp_dir, db_wrapper_2)
         bc = await Blockchain.create(coin_store_2, store_2, height_map, bt.constants, 2)
 
-        store = await BlockStore.create(db_wrapper, bt.constants, use_cache=use_cache)
-        await BlockStore.create(db_wrapper_2, bt.constants)
+        store = await BlockStore.create(db_wrapper, use_cache=use_cache)
+        await BlockStore.create(db_wrapper_2)
 
         # Save/get block
         for block in blocks:
@@ -149,7 +149,7 @@ async def test_get_full_blocks_at(
     async with DBConnection(2) as db_wrapper:
         # Use a different file for the blockchain
         coin_store = await CoinStore.create(db_wrapper)
-        block_store = await BlockStore.create(db_wrapper, bt.constants, use_cache=use_cache)
+        block_store = await BlockStore.create(db_wrapper, use_cache=use_cache)
         height_map = await BlockHeightMap.create(tmp_dir, db_wrapper)
         bc = await Blockchain.create(coin_store, block_store, height_map, bt.constants, 2)
 
@@ -177,7 +177,7 @@ async def test_get_block_records_in_range(
     async with DBConnection(2) as db_wrapper:
         # Use a different file for the blockchain
         coin_store = await CoinStore.create(db_wrapper)
-        block_store = await BlockStore.create(db_wrapper, bt.constants, use_cache=use_cache)
+        block_store = await BlockStore.create(db_wrapper, use_cache=use_cache)
         height_map = await BlockHeightMap.create(tmp_dir, db_wrapper)
         bc = await Blockchain.create(coin_store, block_store, height_map, bt.constants, 2)
 
@@ -207,7 +207,7 @@ async def test_get_block_bytes_in_range_in_main_chain(
     async with DBConnection(2) as db_wrapper:
         # Use a different file for the blockchain
         coin_store = await CoinStore.create(db_wrapper)
-        block_store = await BlockStore.create(db_wrapper, bt.constants, use_cache=use_cache)
+        block_store = await BlockStore.create(db_wrapper, use_cache=use_cache)
         height_map = await BlockHeightMap.create(tmp_dir, db_wrapper)
         bc = await Blockchain.create(coin_store, block_store, height_map, bt.constants, 2)
         count = 0
@@ -234,9 +234,9 @@ async def test_deadlock(tmp_dir: Path, db_version: int, bt: BlockTools, use_cach
     blocks = bt.get_consecutive_blocks(10)
 
     async with PathDBConnection(db_version) as wrapper, PathDBConnection(db_version) as wrapper_2:
-        store = await BlockStore.create(wrapper, bt.constants, use_cache=use_cache)
+        store = await BlockStore.create(wrapper, use_cache=use_cache)
         coin_store_2 = await CoinStore.create(wrapper_2)
-        store_2 = await BlockStore.create(wrapper_2, bt.constants)
+        store_2 = await BlockStore.create(wrapper_2)
         height_map = await BlockHeightMap.create(tmp_dir, wrapper_2)
         bc = await Blockchain.create(coin_store_2, store_2, height_map, bt.constants, 2)
         block_records = []
@@ -267,7 +267,7 @@ async def test_rollback(bt: BlockTools, tmp_dir: Path, use_cache: bool, default_
     async with DBConnection(2) as db_wrapper:
         # Use a different file for the blockchain
         coin_store = await CoinStore.create(db_wrapper)
-        block_store = await BlockStore.create(db_wrapper, bt.constants, use_cache=use_cache)
+        block_store = await BlockStore.create(db_wrapper, use_cache=use_cache)
         height_map = await BlockHeightMap.create(tmp_dir, db_wrapper)
         bc = await Blockchain.create(coin_store, block_store, height_map, bt.constants, 2)
 
@@ -330,7 +330,7 @@ async def test_count_compactified_blocks(bt: BlockTools, tmp_dir: Path, db_versi
 
     async with DBConnection(db_version) as db_wrapper:
         coin_store = await CoinStore.create(db_wrapper)
-        block_store = await BlockStore.create(db_wrapper, bt.constants, use_cache=use_cache)
+        block_store = await BlockStore.create(db_wrapper, use_cache=use_cache)
         height_map = await BlockHeightMap.create(tmp_dir, db_wrapper)
         bc = await Blockchain.create(coin_store, block_store, height_map, bt.constants, 2)
 
@@ -351,7 +351,7 @@ async def test_count_uncompactified_blocks(bt: BlockTools, tmp_dir: Path, db_ver
 
     async with DBConnection(db_version) as db_wrapper:
         coin_store = await CoinStore.create(db_wrapper)
-        block_store = await BlockStore.create(db_wrapper, bt.constants, use_cache=use_cache)
+        block_store = await BlockStore.create(db_wrapper, use_cache=use_cache)
         height_map = await BlockHeightMap.create(tmp_dir, db_wrapper)
         bc = await Blockchain.create(coin_store, block_store, height_map, bt.constants, 2)
 
@@ -379,7 +379,7 @@ def rand_vdf_proof() -> VDFProof:
 
     async with DBConnection(db_version) as db_wrapper:
         coin_store = await CoinStore.create(db_wrapper)
-        block_store = await BlockStore.create(db_wrapper, bt.constants, use_cache=use_cache)
+        block_store = await BlockStore.create(db_wrapper, use_cache=use_cache)
         height_map = await BlockHeightMap.create(tmp_dir, db_wrapper)
         bc = await Blockchain.create(coin_store, block_store, height_map, bt.constants, 2)
         for block in blocks:
@@ -416,7 +416,7 @@ def generator(i: int) -> SerializedProgram:
         return SerializedProgram.from_bytes(int_to_bytes(i + 1))
 
     async with DBConnection(db_version) as db_wrapper:
-        store = await BlockStore.create(db_wrapper, bt.constants, use_cache=use_cache)
+        store = await BlockStore.create(db_wrapper, use_cache=use_cache)
 
         new_blocks = []
         for i, original_block in enumerate(blocks):
@@ -460,12 +460,12 @@ async def test_get_blocks_by_hash(tmp_dir: Path, bt: BlockTools, db_version: int
     async with DBConnection(db_version) as db_wrapper, DBConnection(db_version) as db_wrapper_2:
         # Use a different file for the blockchain
         coin_store_2 = await CoinStore.create(db_wrapper_2)
-        store_2 = await BlockStore.create(db_wrapper_2, bt.constants, use_cache=use_cache)
+        store_2 = await BlockStore.create(db_wrapper_2, use_cache=use_cache)
         height_map = await BlockHeightMap.create(tmp_dir, db_wrapper_2)
         bc = await Blockchain.create(coin_store_2, store_2, height_map, bt.constants, 2)
 
-        store = await BlockStore.create(db_wrapper, bt.constants, use_cache=use_cache)
-        await BlockStore.create(db_wrapper_2, bt.constants)
+        store = await BlockStore.create(db_wrapper, use_cache=use_cache)
+        await BlockStore.create(db_wrapper_2)
 
         print("starting test")
         hashes = []
@@ -500,11 +500,11 @@ async def test_get_block_bytes_in_range(tmp_dir: Path, bt: BlockTools, db_versio
     async with DBConnection(db_version) as db_wrapper_2:
         # Use a different file for the blockchain
         coin_store_2 = await CoinStore.create(db_wrapper_2)
-        store_2 = await BlockStore.create(db_wrapper_2, bt.constants, use_cache=use_cache)
+        store_2 = await BlockStore.create(db_wrapper_2, use_cache=use_cache)
         height_map = await BlockHeightMap.create(tmp_dir, db_wrapper_2)
         bc = await Blockchain.create(coin_store_2, store_2, height_map, bt.constants, 2)
 
-        await BlockStore.create(db_wrapper_2, bt.constants)
+        await BlockStore.create(db_wrapper_2)
 
         # Save/get block
         for block in blocks:
@@ -525,13 +525,13 @@ async def test_get_block_bytes_in_range(tmp_dir: Path, bt: BlockTools, db_versio
 async def test_unsupported_version(tmp_dir: Path, use_cache: bool) -> None:
     with pytest.raises(RuntimeError, match="BlockStore does not support database schema v1"):
         async with DBConnection(1) as db_wrapper:
-            await BlockStore.create(db_wrapper, DEFAULT_CONSTANTS, use_cache=use_cache)
+            await BlockStore.create(db_wrapper, use_cache=use_cache)
 
 
 @pytest.mark.anyio
 async def test_get_peak(tmp_dir: Path, db_version: int, use_cache: bool) -> None:
     async with DBConnection(db_version) as db_wrapper:
-        store = await BlockStore.create(db_wrapper, DEFAULT_CONSTANTS, use_cache=use_cache)
+        store = await BlockStore.create(db_wrapper, use_cache=use_cache)
 
         assert await store.get_peak() is None
 
@@ -573,12 +573,12 @@ async def test_get_prev_hash(tmp_dir: Path, bt: BlockTools, db_version: int, use
     async with DBConnection(db_version) as db_wrapper, DBConnection(db_version) as db_wrapper_2:
         # Use a different file for the blockchain
         coin_store_2 = await CoinStore.create(db_wrapper_2)
-        store_2 = await BlockStore.create(db_wrapper_2, bt.constants, use_cache=use_cache)
+        store_2 = await BlockStore.create(db_wrapper_2, use_cache=use_cache)
         height_map = await BlockHeightMap.create(tmp_dir, db_wrapper_2)
         bc = await Blockchain.create(coin_store_2, store_2, height_map, bt.constants, 2)
 
-        store = await BlockStore.create(db_wrapper, bt.constants, use_cache=use_cache)
-        await BlockStore.create(db_wrapper_2, bt.constants)
+        store = await BlockStore.create(db_wrapper, use_cache=use_cache)
+        await BlockStore.create(db_wrapper_2)
 
         # Save/get block
         for block in blocks: