Bump chia rs >=0.24, <0.25 (#19615)

* bump chia_rs

* update db_graftroot test

* update SerializedProgram and Program use, to accommodate new chia_rs interface

* review comments

* review comments

---------

Co-authored-by: Matthew Howard <[email protected]>

Author: arvidn

chia/_tests/blockchain/test_blockchain.py

@@ -1156,7 +1156,7 @@ async def test_bad_pos(self, empty_blockchain: Blockchain, bt: BlockTools) -> No
         )
         await _validate_and_add_block(empty_blockchain, block_bad, expected_error=Err.INVALID_POSPACE)
 
-        block_bad = recursive_replace(blocks[-1], "reward_chain_block.proof_of_space.size", 62)
+        block_bad = recursive_replace(blocks[-1], "reward_chain_block.proof_of_space.version_and_size", 62)
         await _validate_and_add_block(empty_blockchain, block_bad, expected_error=Err.INVALID_POSPACE)
 
         block_bad = recursive_replace(
@@ -1167,14 +1167,14 @@ async def test_bad_pos(self, empty_blockchain: Blockchain, bt: BlockTools) -> No
         await _validate_and_add_block(empty_blockchain, block_bad, expected_error=Err.INVALID_POSPACE)
         block_bad = recursive_replace(
             blocks[-1],
-            "reward_chain_block.proof_of_space.size",
+            "reward_chain_block.proof_of_space.version_and_size",
             32,
         )
         await _validate_and_add_block(empty_blockchain, block_bad, expected_error=Err.INVALID_POSPACE)
         block_bad = recursive_replace(
             blocks[-1],
             "reward_chain_block.proof_of_space.proof",
-            bytes([1] * int(blocks[-1].reward_chain_block.proof_of_space.size * 64 / 8)),
+            bytes([1] * int((blocks[-1].reward_chain_block.proof_of_space.version_and_size & 0x7F) * 64 / 8)),
         )
         await _validate_and_add_block(empty_blockchain, block_bad, expected_error=Err.INVALID_POSPACE)
 

chia/_tests/conftest.py

@@ -1236,7 +1236,7 @@ async def farmer_harvester_2_simulators_zero_bits_plot_filter(
     ]
 ]:
     zero_bit_plot_filter_consts = test_constants_modified.replace(
-        NUMBER_ZERO_BITS_PLOT_FILTER=uint8(0),
+        NUMBER_ZERO_BITS_PLOT_FILTER_V1=uint8(0),
         NUM_SPS_SUB_SLOT=uint32(8),
     )
 

chia/_tests/core/custom_types/test_proof_of_space.py

@@ -27,6 +27,7 @@ class ProofOfSpaceCase:
     marks: Marks = ()
 
 
+# TODO: test v2 plots
 @datacases(
     ProofOfSpaceCase(
         id="Neither pool public key nor pool contract puzzle hash",
@@ -108,7 +109,7 @@ def test_verify_and_get_quality_string(caplog: pytest.LogCaptureFixture, case: P
         pool_public_key=case.pool_public_key,
         pool_contract_puzzle_hash=case.pool_contract_puzzle_hash,
         plot_public_key=case.plot_public_key,
-        size=case.plot_size,
+        version_and_size=case.plot_size,
         proof=b"1",
     )
     quality_string = verify_and_get_quality_string(
@@ -125,7 +126,7 @@ def test_verify_and_get_quality_string(caplog: pytest.LogCaptureFixture, case: P
 
 
 class TestProofOfSpace:
-    @pytest.mark.parametrize("prefix_bits", [DEFAULT_CONSTANTS.NUMBER_ZERO_BITS_PLOT_FILTER, 8, 7, 6, 5, 1, 0])
+    @pytest.mark.parametrize("prefix_bits", [DEFAULT_CONSTANTS.NUMBER_ZERO_BITS_PLOT_FILTER_V1, 8, 7, 6, 5, 1, 0])
     def test_can_create_proof(self, prefix_bits: int, seeded_random: random.Random) -> None:
         """
         Tests that the change of getting a correct proof is exactly 1/target_filter.

chia/_tests/core/full_node/test_conditions.py

@@ -104,7 +104,7 @@ async def check_conditions(
     blocks = await initial_blocks(bt)
     coin = blocks[spend_reward_index].get_included_reward_coins()[0]
 
-    coin_spend = make_spend(coin, EASY_PUZZLE, SerializedProgram.from_program(condition_solution))
+    coin_spend = make_spend(coin, EASY_PUZZLE, condition_solution)
     spend_bundle = SpendBundle([coin_spend], aggsig)
 
     # now let's try to create a block with the spend bundle and ensure that it doesn't validate

chia/_tests/core/full_node/test_full_node.py

@@ -1621,7 +1621,7 @@ async def test_unfinished_block_with_replaced_generator(
                 pos.pool_public_key,
                 pos.pool_contract_puzzle_hash,
                 public_key,
-                pos.size,
+                pos.version_and_size,
                 pos.proof,
             )
 

chia/_tests/core/make_block_generator.py

@@ -24,7 +24,7 @@ def int_to_public_key(index: int) -> G1Element:
 
 def puzzle_hash_for_index(index: int, puzzle_hash_db: dict[bytes32, SerializedProgram]) -> bytes32:
     public_key: G1Element = int_to_public_key(index)
-    puzzle = SerializedProgram.from_program(puzzle_for_pk(public_key))
+    puzzle = puzzle_for_pk(public_key).to_serialized()
     puzzle_hash: bytes32 = puzzle.get_tree_hash()
     puzzle_hash_db[puzzle_hash] = puzzle
     return puzzle_hash
@@ -56,7 +56,7 @@ def make_spend_bundle(count: int) -> SpendBundle:
     for coin in coins:
         puzzle_reveal = puzzle_hash_db[coin.puzzle_hash]
         conditions = conditions_for_payment(coin)
-        solution = SerializedProgram.from_program(solution_for_conditions(conditions))
+        solution = solution_for_conditions(conditions).to_serialized()
         coin_spend = make_spend(coin, puzzle_reveal, solution)
         coin_spends.append(coin_spend)
 

chia/_tests/core/mempool/test_mempool.py

@@ -2866,7 +2866,7 @@ async def test_invalid_coin_spend_coin(
         new_bundle = recursive_replace(spend_bundle, "coin_spends", [coin_spend_0, *spend_bundle.coin_spends[1:]])
         assert spend_bundle is not None
         res = await full_node_1.full_node.add_transaction(new_bundle, new_bundle.name(), test=True)
-        assert res == (MempoolInclusionStatus.FAILED, Err.INVALID_SPEND_BUNDLE)
+        assert res == (MempoolInclusionStatus.FAILED, Err.WRONG_PUZZLE_HASH)
 
 
 coins = make_test_coins()

chia/_tests/core/mempool/test_mempool_manager.py

@@ -2378,17 +2378,15 @@ def make_singleton_spend(
     from chia.wallet.lineage_proof import LineageProof
     from chia.wallet.puzzles.singleton_top_layer_v1_1 import puzzle_for_singleton, solution_for_singleton
 
-    singleton_puzzle = SerializedProgram.from_program(puzzle_for_singleton(launcher_id, Program.to(1)))
+    singleton_puzzle = puzzle_for_singleton(launcher_id, Program.to(1)).to_serialized()
 
     PARENT_COIN = Coin(parent_parent_id, singleton_puzzle.get_tree_hash(), uint64(1))
     COIN = Coin(PARENT_COIN.name(), singleton_puzzle.get_tree_hash(), uint64(1))
 
     lineage_proof = LineageProof(parent_parent_id, IDENTITY_PUZZLE_HASH, uint64(1))
 
     inner_solution = Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, uint64(child_amount)]])
-    singleton_solution = SerializedProgram.from_program(
-        solution_for_singleton(lineage_proof, uint64(1), inner_solution)
-    )
+    singleton_solution = solution_for_singleton(lineage_proof, uint64(1), inner_solution).to_serialized()
 
     ret = CoinSpend(COIN, singleton_puzzle, singleton_solution)
 

chia/_tests/core/mempool/test_singleton_fast_forward.py

@@ -257,9 +257,9 @@ def make_singleton_coin_spend(
     solution = singleton_top_layer.solution_for_singleton(lineage_proof, uint64(coin_to_spend.amount), inner_solution)
     if is_eve_spend:
         # Parent here is the launcher coin
-        puzzle_reveal = SerializedProgram.from_program(
-            singleton_top_layer.puzzle_for_singleton(parent_coin_spend.coin.name(), inner_puzzle)
-        )
+        puzzle_reveal = singleton_top_layer.puzzle_for_singleton(
+            parent_coin_spend.coin.name(), inner_puzzle
+        ).to_serialized()
     else:
         puzzle_reveal = parent_coin_spend.puzzle_reveal
     return make_spend(coin_to_spend, puzzle_reveal, solution), delegated_puzzle
@@ -413,8 +413,8 @@ async def test_singleton_fast_forward_different_block(is_eligible_for_ff: bool)
             eve_coin_spend, singleton, inner_puzzle, inner_conditions
         )
         # Spend also a remaining coin
-        remaining_spend_solution = SerializedProgram.from_program(
-            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]])
+        remaining_spend_solution = SerializedProgram.to(
+            [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]]
         )
         remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
         await make_and_send_spend_bundle(
@@ -435,8 +435,8 @@ async def test_singleton_fast_forward_different_block(is_eligible_for_ff: bool)
             coin_id=singleton_child.name(), parent_id=singleton.name(), parent_parent_id=eve_coin_spend.coin.name()
         )
         # Now let's spend the first version again (despite being already spent by now)
-        remaining_spend_solution = SerializedProgram.from_program(
-            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]])
+        remaining_spend_solution = SerializedProgram.to(
+            [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]]
         )
         remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
         status, error = await make_and_send_spend_bundle(
@@ -494,8 +494,8 @@ async def test_singleton_fast_forward_same_block() -> None:
         # Spend also a remaining coin. Change amount to create a new coin ID.
         # The test assumes any odd amount is a singleton, so we must keep it
         # even
-        remaining_spend_solution = SerializedProgram.from_program(
-            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount - 2]])
+        remaining_spend_solution = SerializedProgram.to(
+            [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount - 2]]
         )
         remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
         await make_and_send_spend_bundle(sim, sim_client, [remaining_coin_spend, singleton_coin_spend], aggsig=sig)
@@ -567,8 +567,8 @@ async def test_mempool_items_immutability_on_ff() -> None:
         singleton_coin_spend, singleton_signing_puzzle = make_singleton_coin_spend(
             eve_coin_spend, singleton, inner_puzzle, inner_conditions
         )
-        remaining_spend_solution = SerializedProgram.from_program(
-            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]])
+        remaining_spend_solution = SerializedProgram.to(
+            [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]]
         )
         remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
         await make_and_send_spend_bundle(
@@ -590,8 +590,8 @@ async def test_mempool_items_immutability_on_ff() -> None:
         )
         # Now let's spend the first version again (despite being already spent
         # by now) to exercise its fast forward.
-        remaining_spend_solution = SerializedProgram.from_program(
-            Program.to([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]])
+        remaining_spend_solution = SerializedProgram.to(
+            [[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, remaining_coin.amount]]
         )
         remaining_coin_spend = CoinSpend(remaining_coin, IDENTITY_PUZZLE, remaining_spend_solution)
         sb = SpendBundle([remaining_coin_spend, singleton_coin_spend], sig)

chia/_tests/core/test_cost_calculation.py

@@ -19,7 +19,7 @@
 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.program import Program, run_with_cost
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.generator_types import BlockGenerator
 from chia.wallet.puzzles import p2_delegated_puzzle_or_hidden_puzzle
@@ -171,7 +171,7 @@ async def test_mempool_mode(softfork_height: int, bt: BlockTools) -> None:
         uint64(300),
     )
     spend_info = get_puzzle_and_solution_for_coin(generator, coin, softfork_height, bt.constants)
-    assert spend_info.puzzle.to_program() == puzzle
+    assert spend_info.puzzle == puzzle.to_serialized()
 
 
 @pytest.mark.anyio
@@ -276,7 +276,7 @@ async def test_standard_tx(benchmark_runner: BenchmarkRunner) -> None:
     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)
+            cost, _result = run_with_cost(puzzle_program, test_constants.MAX_BLOCK_COST_CLVM, solution_program)
             total_cost += cost
 
 
@@ -287,8 +287,8 @@ async def test_get_puzzle_and_solution_for_coin_performance(benchmark_runner: Be
 
     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, []]
+    _, result = run_with_cost(
+        LARGE_BLOCK.transactions_generator, DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM, [DESERIALIZE_MOD, []]
     )
 
     coin_spends = result.first()