Import pot_iterations and pos_quality from chia_rs

chia/_tests/blockchain/test_blockchain.py

@@ -10,7 +10,7 @@
 from typing import Optional
 
 import pytest
-from chia_rs import AugSchemeMPL, G2Element, MerkleSet
+from chia_rs import AugSchemeMPL, G2Element, MerkleSet, is_overflow_block
 from clvm.casts import int_to_bytes
 
 from chia._tests.blockchain.blockchain_test_utils import (
@@ -34,7 +34,6 @@
 from chia.consensus.full_block_to_block_record import block_to_block_record
 from chia.consensus.get_block_generator import get_block_generator
 from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_block
-from chia.consensus.pot_iterations import is_overflow_block
 from chia.simulator.block_tools import BlockTools, create_block_tools_async
 from chia.simulator.keyring import TempKeyring
 from chia.simulator.wallet_tools import WalletTool
@@ -854,7 +853,11 @@ async def test_invalid_cc_sub_slot_vdf(self, empty_blockchain: Blockchain, bt: B
             block = blocks[-1]
             if (
                 len(block.finished_sub_slots)
-                and is_overflow_block(bt.constants, block.reward_chain_block.signage_point_index)
+                and is_overflow_block(
+                    bt.constants.NUM_SPS_SUB_SLOT,
+                    bt.constants.NUM_SP_INTERVALS_EXTRA,
+                    block.reward_chain_block.signage_point_index,
+                )
                 and block.finished_sub_slots[-1].challenge_chain.challenge_chain_end_of_slot_vdf.output
                 != ClassgroupElement.get_default_element()
             ):
@@ -1101,7 +1104,9 @@ async def test_no_ses_if_no_se(self, empty_blockchain: Blockchain, bt: BlockTool
         while True:
             blocks = bt.get_consecutive_blocks(1, block_list_input=blocks)
             if len(blocks[-1].finished_sub_slots) > 0 and is_overflow_block(
-                bt.constants, blocks[-1].reward_chain_block.signage_point_index
+                bt.constants.NUM_SPS_SUB_SLOT,
+                bt.constants.NUM_SP_INTERVALS_EXTRA,
+                blocks[-1].reward_chain_block.signage_point_index,
             ):
                 new_finished_ss: EndOfSubSlotBundle = recursive_replace(
                     blocks[-1].finished_sub_slots[0],
@@ -1206,7 +1211,11 @@ async def test_sp_0_no_sp(self, empty_blockchain: Blockchain, bt: BlockTools) ->
                 block_bad = recursive_replace(blocks[-1], "reward_chain_block.signage_point_index", uint8(1))
                 await _validate_and_add_block(empty_blockchain, block_bad, expected_error=Err.INVALID_SP_INDEX)
 
-            elif not is_overflow_block(bt.constants, blocks[-1].reward_chain_block.signage_point_index):
+            elif not is_overflow_block(
+                bt.constants.NUM_SPS_SUB_SLOT,
+                bt.constants.NUM_SP_INTERVALS_EXTRA,
+                blocks[-1].reward_chain_block.signage_point_index,
+            ):
                 case_2 = True
                 block_bad = recursive_replace(blocks[-1], "reward_chain_block.signage_point_index", uint8(0))
                 await _validate_and_add_block_multi_error(

chia/_tests/core/consensus/test_pot_iterations.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
+from chia_rs import (
+    calculate_ip_iters,
+    calculate_sp_iters,
+    is_overflow_block,
+)
+from chia_rs import expected_plot_size as _expected_plot_size
 from pytest import raises
 
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
-from chia.consensus.pos_quality import _expected_plot_size
 from chia.consensus.pot_iterations import (
-    calculate_ip_iters,
     calculate_iterations_quality,
-    calculate_sp_iters,
-    is_overflow_block,
 )
 from chia.util.hash import std_hash
 from chia.util.ints import uint8, uint16, uint32, uint64, uint128
@@ -18,59 +20,86 @@
 
 class TestPotIterations:
     def test_is_overflow_block(self):
-        assert not is_overflow_block(test_constants, uint8(27))
-        assert not is_overflow_block(test_constants, uint8(28))
-        assert is_overflow_block(test_constants, uint8(29))
-        assert is_overflow_block(test_constants, uint8(30))
-        assert is_overflow_block(test_constants, uint8(31))
+        assert not is_overflow_block(test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, uint8(27))
+        assert not is_overflow_block(test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, uint8(28))
+        assert is_overflow_block(test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, uint8(29))
+        assert is_overflow_block(test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, uint8(30))
+        assert is_overflow_block(test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, uint8(31))
         with raises(ValueError):
-            assert is_overflow_block(test_constants, uint8(32))
+            assert is_overflow_block(test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, uint8(32))
 
     def test_calculate_sp_iters(self):
         ssi: uint64 = uint64(100001 * 64 * 4)
         with raises(ValueError):
-            calculate_sp_iters(test_constants, ssi, uint8(32))
-        calculate_sp_iters(test_constants, ssi, uint8(31))
+            calculate_sp_iters(test_constants.NUM_SPS_SUB_SLOT, ssi, uint8(32))
+        calculate_sp_iters(test_constants.NUM_SPS_SUB_SLOT, ssi, uint8(31))
 
     def test_calculate_ip_iters(self):
         ssi: uint64 = uint64(100001 * 64 * 4)
         sp_interval_iters = ssi // test_constants.NUM_SPS_SUB_SLOT
 
         with raises(ValueError):
             # Invalid signage point index
-            calculate_ip_iters(test_constants, ssi, uint8(123), uint64(100000))
+            calculate_ip_iters(
+                test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, ssi, uint8(123), uint64(100000)
+            )
 
         sp_iters = sp_interval_iters * 13
 
         with raises(ValueError):
             # required_iters too high
-            calculate_ip_iters(test_constants, ssi, sp_interval_iters, sp_interval_iters)
+            calculate_ip_iters(
+                test_constants.NUM_SPS_SUB_SLOT,
+                test_constants.NUM_SP_INTERVALS_EXTRA,
+                ssi,
+                sp_interval_iters,
+                sp_interval_iters,
+            )
 
         with raises(ValueError):
             # required_iters too high
-            calculate_ip_iters(test_constants, ssi, sp_interval_iters, sp_interval_iters * 12)
+            calculate_ip_iters(
+                test_constants.NUM_SPS_SUB_SLOT,
+                test_constants.NUM_SP_INTERVALS_EXTRA,
+                ssi,
+                sp_interval_iters,
+                sp_interval_iters * 12,
+            )
 
         with raises(ValueError):
             # required_iters too low (0)
-            calculate_ip_iters(test_constants, ssi, sp_interval_iters, uint64(0))
+            calculate_ip_iters(
+                test_constants.NUM_SPS_SUB_SLOT,
+                test_constants.NUM_SP_INTERVALS_EXTRA,
+                ssi,
+                sp_interval_iters,
+                uint64(0),
+            )
 
         required_iters = sp_interval_iters - 1
-        ip_iters = calculate_ip_iters(test_constants, ssi, uint8(13), required_iters)
+        ip_iters = calculate_ip_iters(
+            test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, ssi, uint8(13), required_iters
+        )
         assert ip_iters == sp_iters + test_constants.NUM_SP_INTERVALS_EXTRA * sp_interval_iters + required_iters
 
         required_iters = uint64(1)
-        ip_iters = calculate_ip_iters(test_constants, ssi, uint8(13), required_iters)
+        ip_iters = calculate_ip_iters(
+            test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, ssi, uint8(13), required_iters
+        )
         assert ip_iters == sp_iters + test_constants.NUM_SP_INTERVALS_EXTRA * sp_interval_iters + required_iters
 
         required_iters = uint64(int(ssi * 4 / 300))
-        ip_iters = calculate_ip_iters(test_constants, ssi, uint8(13), required_iters)
+        ip_iters = calculate_ip_iters(
+            test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, ssi, uint8(13), required_iters
+        )
         assert ip_iters == sp_iters + test_constants.NUM_SP_INTERVALS_EXTRA * sp_interval_iters + required_iters
         assert sp_iters < ip_iters
 
         # Overflow
         sp_iters = sp_interval_iters * (test_constants.NUM_SPS_SUB_SLOT - 1)
         ip_iters = calculate_ip_iters(
-            test_constants,
+            test_constants.NUM_SPS_SUB_SLOT,
+            test_constants.NUM_SP_INTERVALS_EXTRA,
             ssi,
             uint8(test_constants.NUM_SPS_SUB_SLOT - 1),
             required_iters,

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

@@ -6,6 +6,7 @@
 from typing import Optional
 
 import pytest
+from chia_rs import is_overflow_block
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block, _validate_and_add_block_no_error
 from chia._tests.util.blockchain import create_blockchain
@@ -17,7 +18,6 @@
 from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty
 from chia.consensus.find_fork_point import find_fork_point_in_chain
 from chia.consensus.multiprocess_validation import PreValidationResult
-from chia.consensus.pot_iterations import is_overflow_block
 from chia.full_node.full_node_store import FullNodeStore, UnfinishedBlockEntry, find_best_block
 from chia.full_node.signage_point import SignagePoint
 from chia.protocols import timelord_protocol
@@ -817,7 +817,9 @@ async def test_basic_store(
         sb.signage_point_index + custom_block_tools.constants.NUM_SP_INTERVALS_EXTRA,
         custom_block_tools.constants.NUM_SPS_SUB_SLOT,
     ):
-        if is_overflow_block(custom_block_tools.constants, uint8(i)):
+        if is_overflow_block(
+            custom_block_tools.constants.NUM_SPS_SUB_SLOT, custom_block_tools.constants.NUM_SP_INTERVALS_EXTRA, uint8(i)
+        ):
             finished_sub_slots = blocks_5[-1].finished_sub_slots
         else:
             finished_sub_slots = []

chia/_tests/core/full_node/test_full_node.py

@@ -17,6 +17,7 @@
     SpendBundleConditions,
     additions_and_removals,
     get_flags_for_height_and_constants,
+    is_overflow_block,
 )
 from clvm.casts import int_to_bytes
 from packaging.version import Version
@@ -32,7 +33,6 @@
 from chia._tests.util.time_out_assert import time_out_assert, time_out_assert_custom_interval, time_out_messages
 from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_block
-from chia.consensus.pot_iterations import is_overflow_block
 from chia.full_node.coin_store import CoinStore
 from chia.full_node.full_node import WalletUpdate
 from chia.full_node.full_node_api import FullNodeAPI
@@ -1402,7 +1402,9 @@ async def test_unfinished_block_with_replaced_generator(wallet_nodes, self_hostn
 
     blocks = bt.get_consecutive_blocks(1, block_list_input=blocks)
     block: FullBlock = blocks[0]
-    overflow = is_overflow_block(bt.constants, block.reward_chain_block.signage_point_index)
+    overflow = is_overflow_block(
+        bt.constants.NUM_SPS_SUB_SLOT, bt.constants.NUM_SP_INTERVALS_EXTRA, block.reward_chain_block.signage_point_index
+    )
 
     replaced_generator = SerializedProgram.from_bytes(b"\x80")
 

chia/_tests/core/full_node/test_performance.py

@@ -4,6 +4,7 @@
 import random
 
 import pytest
+from chia_rs import is_overflow_block
 from clvm.casts import int_to_bytes
 
 from chia._tests.connection_utils import add_dummy_connection
@@ -12,7 +13,6 @@
 from chia._tests.util.misc import BenchmarkRunner
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.consensus.block_record import BlockRecord
-from chia.consensus.pot_iterations import is_overflow_block
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.protocols import full_node_protocol as fnp
 from chia.types.condition_opcodes import ConditionOpcode
@@ -150,7 +150,11 @@ async def test_full_block_performance(
             guarantee_transaction_block=True,
         )
         block = blocks[-1]
-        if is_overflow_block(bt.constants, block.reward_chain_block.signage_point_index):
+        if is_overflow_block(
+            bt.constants.NUM_SPS_SUB_SLOT,
+            bt.constants.NUM_SP_INTERVALS_EXTRA,
+            block.reward_chain_block.signage_point_index,
+        ):
             sub_slots = block.finished_sub_slots[:-1]
         else:
             sub_slots = block.finished_sub_slots

chia/_tests/core/test_full_node_rpc.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import pytest
-from chia_rs import AugSchemeMPL
+from chia_rs import AugSchemeMPL, is_overflow_block
 from clvm.casts import int_to_bytes
 
 from chia import __version__
@@ -10,7 +10,6 @@
 from chia._tests.util.rpc import validate_get_routes
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.consensus.block_record import BlockRecord
-from chia.consensus.pot_iterations import is_overflow_block
 from chia.full_node.signage_point import SignagePoint
 from chia.protocols import full_node_protocol
 from chia.rpc.full_node_rpc_api import get_average_block_time, get_nearest_transaction_block
@@ -61,7 +60,11 @@ async def test1(two_nodes_sim_and_wallets_services, self_hostname, consensus_mod
         assert len(await client.get_unfinished_block_headers()) == 0
         assert len(await client.get_block_records(0, 100)) == 0
         for block in blocks:
-            if is_overflow_block(bt.constants, block.reward_chain_block.signage_point_index):
+            if is_overflow_block(
+                bt.constants.NUM_SPS_SUB_SLOT,
+                bt.constants.NUM_SP_INTERVAL_EXTRA,
+                block.reward_chain_block.signage_point_index,
+            ):
                 finished_ss = block.finished_sub_slots[:-1]
             else:
                 finished_ss = block.finished_sub_slots

chia/_tests/plot_sync/test_receiver.py

@@ -8,9 +8,10 @@
 
 import pytest
 from chia_rs import G1Element
+from chia_rs import expected_plot_size as _expected_plot_size
 
 from chia._tests.plot_sync.util import get_dummy_connection
-from chia.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR, _expected_plot_size
+from chia.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR
 from chia.plot_sync.delta import Delta
 from chia.plot_sync.receiver import Receiver, Sync, get_list_or_len
 from chia.plot_sync.util import ErrorCodes, State

chia/consensus/block_header_validation.py

@@ -4,7 +4,13 @@
 import time
 from typing import Optional
 
-from chia_rs import AugSchemeMPL
+from chia_rs import (
+    AugSchemeMPL,
+    calculate_ip_iters,
+    calculate_sp_interval_iters,
+    calculate_sp_iters,
+    is_overflow_block,
+)
 
 from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
@@ -13,13 +19,7 @@
 from chia.consensus.difficulty_adjustment import can_finish_sub_and_full_epoch
 from chia.consensus.get_block_challenge import final_eos_is_already_included, get_block_challenge
 from chia.consensus.make_sub_epoch_summary import make_sub_epoch_summary
-from chia.consensus.pot_iterations import (
-    calculate_ip_iters,
-    calculate_iterations_quality,
-    calculate_sp_interval_iters,
-    calculate_sp_iters,
-    is_overflow_block,
-)
+from chia.consensus.pot_iterations import calculate_iterations_quality
 from chia.consensus.vdf_info_computation import get_signage_point_vdf_info
 from chia.types.blockchain_format.classgroup import ClassgroupElement
 from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string
@@ -66,7 +66,11 @@ def validate_unfinished_header_block(
     if genesis_block and header_block.prev_header_hash != constants.GENESIS_CHALLENGE:
         return None, ValidationError(Err.INVALID_PREV_BLOCK_HASH)
 
-    overflow = is_overflow_block(constants, header_block.reward_chain_block.signage_point_index)
+    overflow = is_overflow_block(
+        constants.NUM_SPS_SUB_SLOT,
+        constants.NUM_SP_INTERVALS_EXTRA,
+        header_block.reward_chain_block.signage_point_index,
+    )
     if skip_overflow_last_ss_validation and overflow:
         if final_eos_is_already_included(header_block, blocks, expected_vs.ssi):
             skip_overflow_last_ss_validation = False
@@ -508,7 +512,7 @@ def validate_unfinished_header_block(
     )
 
     # 7. check required iters
-    if required_iters >= calculate_sp_interval_iters(constants, expected_vs.ssi):
+    if required_iters >= calculate_sp_interval_iters(constants.NUM_SPS_SUB_SLOT, expected_vs.ssi):
         return None, ValidationError(Err.INVALID_REQUIRED_ITERS)
 
     # 8a. check signage point index 0 has no cc sp
@@ -524,13 +528,14 @@ def validate_unfinished_header_block(
         return None, ValidationError(Err.INVALID_SP_INDEX)
 
     sp_iters: uint64 = calculate_sp_iters(
-        constants,
+        constants.NUM_SPS_SUB_SLOT,
         expected_vs.ssi,
         header_block.reward_chain_block.signage_point_index,
     )
 
     ip_iters: uint64 = calculate_ip_iters(
-        constants,
+        constants.NUM_SPS_SUB_SLOT,
+        constants.NUM_SP_INTERVALS_EXTRA,
         expected_vs.ssi,
         header_block.reward_chain_block.signage_point_index,
         required_iters,
@@ -874,7 +879,8 @@ def validate_finished_header_block(
     new_sub_slot: bool = len(header_block.finished_sub_slots) > 0
 
     ip_iters: uint64 = calculate_ip_iters(
-        constants,
+        constants.NUM_SPS_SUB_SLOT,
+        constants.NUM_SP_INTERVALS_EXTRA,
         expected_vs.ssi,
         header_block.reward_chain_block.signage_point_index,
         required_iters,
@@ -983,7 +989,11 @@ def validate_finished_header_block(
 
     # 31. Check infused challenge chain infusion point VDF
     if not genesis_block:
-        overflow = is_overflow_block(constants, header_block.reward_chain_block.signage_point_index)
+        overflow = is_overflow_block(
+            constants.NUM_SPS_SUB_SLOT,
+            constants.NUM_SP_INTERVALS_EXTRA,
+            header_block.reward_chain_block.signage_point_index,
+        )
         deficit = calculate_deficit(
             constants,
             header_block.height,