change v1 plot phase-out to not affect required iters, and to be quantized to epoch blocks

Author: arvidn

chia/_tests/core/consensus/test_pot_iterations.py

@@ -10,7 +10,6 @@
 from chia.consensus.pot_iterations import (
     calculate_ip_iters,
     calculate_iterations_quality,
-    calculate_phase_out,
     calculate_sp_interval_iters,
     calculate_sp_iters,
     is_overflow_block,
@@ -129,9 +128,7 @@ def test_win_percentage(self, height: uint32):
                         quality = std_hash(
                             slot_index.to_bytes(4, "big") + plot_k_val.to_bytes(1, "big") + bytes(farmer_index)
                         )
-                        required_iters = calculate_iterations_quality(
-                            constants, quality, k, difficulty, sp_hash, sub_slot_iters, height
-                        )
+                        required_iters = calculate_iterations_quality(constants, quality, k, difficulty, sp_hash)
                         if required_iters < sp_interval_iters:
                             wins[k] += 1
                             total_wins_in_slot += 1
@@ -152,36 +149,6 @@ def test_win_percentage(self, height: uint32):
             # Win rate is proportional to percentage of space
             assert abs(win_percentage[k] - percentage_space[k]) < 0.01
 
-    @pytest.mark.parametrize("sp_interval", [uint64(6250000000), uint64(1), uint64(2), uint64(10), uint64(10000000000)])
-    def test_calculate_phase_out(self, sp_interval: uint64):
-        constants = test_constants
-        sub_slot_iters = uint64(sp_interval * constants.NUM_SPS_SUB_SLOT)
-        # Before or at HARD_FORK2_HEIGHT, should return 0
-        assert calculate_phase_out(constants, sub_slot_iters, uint32(constants.HARD_FORK2_HEIGHT - 1)) == 0
-        assert calculate_phase_out(constants, sub_slot_iters, constants.HARD_FORK2_HEIGHT) == 0
-        # after HARD_FORK2_HEIGHT, should return value = delta/phase_out_period * sp_interval
-        assert (
-            calculate_phase_out(constants, sub_slot_iters, uint32(constants.HARD_FORK2_HEIGHT + 1))
-            == sp_interval // constants.PLOT_V1_PHASE_OUT
-        )
-        assert (
-            calculate_phase_out(
-                constants, sub_slot_iters, uint32(constants.HARD_FORK2_HEIGHT + constants.PLOT_V1_PHASE_OUT // 2)
-            )
-            == sp_interval // 2
-        )
-        assert (
-            calculate_phase_out(
-                constants, sub_slot_iters, uint32(constants.HARD_FORK2_HEIGHT + constants.PLOT_V1_PHASE_OUT)
-            )
-            == sp_interval
-        )
-
-        # Test with maximum uint32 height to ensure no overflow
-        max_uint32_height = uint32(0xFFFFFFFF)
-        result_max_height = calculate_phase_out(constants, sub_slot_iters, max_uint32_height)
-        assert result_max_height == sp_interval  # Should cap at sp_interval
-
 
 def test_expected_plot_size_v1() -> None:
     last_size = 2_400_000

chia/_tests/core/custom_types/test_proof_of_space.py

@@ -11,9 +11,11 @@
 
 from chia._tests.util.misc import Marks, datacases
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.simulator.block_tools import test_constants
 from chia.types.blockchain_format.proof_of_space import (
     calculate_prefix_bits,
     check_plot_size,
+    is_v1_phased_out,
     make_pos,
     passes_plot_filter,
     verify_and_get_quality_string,
@@ -150,6 +152,7 @@ def test_verify_and_get_quality_string(caplog: pytest.LogCaptureFixture, case: P
         original_challenge_hash=b32("0x73490e166d0b88347c37d921660b216c27316aae9a3450933d3ff3b854e5831a"),
         signage_point=b32("0x7b3e23dbd438f9aceefa9827e2c5538898189987f49b06eceb7a43067e77b531"),
         height=case.height,
+        prev_transaction_block_height=case.height,
     )
     assert quality_string is None
     assert len(caplog.text) == 0 if case.expected_error is None else case.expected_error in caplog.text
@@ -187,6 +190,7 @@ def test_verify_and_get_quality_string_v2(caplog: pytest.LogCaptureFixture, case
             original_challenge_hash=b32("0x73490e166d0b88347c37d921660b216c27316aae9a3450933d3ff3b854e5831a"),
             signage_point=b32("0x7b3e23dbd438f9aceefa9827e2c5538898189987f49b06eceb7a43067e77b531"),
             height=case.height,
+            prev_transaction_block_height=case.height,
         )
     except NotImplementedError as e:
         assert case.expected_error is not None
@@ -281,3 +285,30 @@ def test_calculate_prefix_bits_v1(height: uint32, expected: int) -> None:
 )
 def test_calculate_prefix_bits_v2(height: uint32, expected: int) -> None:
     assert calculate_prefix_bits(DEFAULT_CONSTANTS, height, PlotSize.make_v2(28)) == expected
+
+
+def test_v1_phase_out() -> None:
+    constants = test_constants
+    rng = random.Random()
+
+    phase_out_epochs = 1 << (constants.PLOT_V1_PHASE_OUT // constants.EPOCH_BLOCKS).bit_length()
+    print(f"phase-out epochs: {phase_out_epochs}")
+
+    for epoch in range(-5, phase_out_epochs + 5):
+        prev_tx_height = uint32(constants.HARD_FORK2_HEIGHT + epoch * constants.EPOCH_BLOCKS)
+        num_phased_out = 0
+        rng.seed(1337)
+        for i in range(1000):
+            proof = rng.randbytes(32)
+            if is_v1_phased_out(proof, prev_tx_height, constants):
+                num_phased_out += 1
+
+        expect = min(1.0, max(0.0, epoch / phase_out_epochs))
+
+        print(
+            f"height: {prev_tx_height} "
+            f"epoch: {epoch} "
+            f"phased-out: {num_phased_out / 10:0.2f}% "
+            f"expect: {expect * 100.0:0.2f}%"
+        )
+        assert abs((num_phased_out / 1000) - expect) < 0.05

chia/_tests/core/full_node/test_full_node.py

@@ -3224,12 +3224,15 @@ async def declare_pos_unfinished_block(
         include_signature_source_data=True,
     )
     await full_node_api.declare_proof_of_space(pospace, dummy_peer)
+    tx_peak = blockchain.get_tx_peak()
+    assert tx_peak is not None
     q_str: Optional[bytes32] = verify_and_get_quality_string(
         block.reward_chain_block.proof_of_space,
         blockchain.constants,
         challenge,
         challenge_chain_sp,
         height=block.reward_chain_block.height,
+        prev_transaction_block_height=tx_peak.height,
     )
     assert q_str is not None
     unfinised_block = None

chia/_tests/farmer_harvester/test_farmer.py

@@ -626,7 +626,14 @@ async def test_farmer_new_proof_of_space_for_pool_stats(
     }
 
     assert (
-        verify_and_get_quality_string(pos, DEFAULT_CONSTANTS, case.challenge_hash, case.sp_hash, height=uint32(1))
+        verify_and_get_quality_string(
+            pos,
+            DEFAULT_CONSTANTS,
+            case.challenge_hash,
+            case.sp_hash,
+            height=uint32(1),
+            prev_transaction_block_height=uint32(1),
+        )
         is not None
     )
 
@@ -883,7 +890,12 @@ async def test_farmer_pool_response(
 
     assert (
         verify_and_get_quality_string(
-            pos, DEFAULT_CONSTANTS, sp.challenge_hash, sp.challenge_chain_sp, height=uint32(1)
+            pos,
+            DEFAULT_CONSTANTS,
+            sp.challenge_hash,
+            sp.challenge_chain_sp,
+            height=uint32(1),
+            prev_transaction_block_height=uint32(1),
         )
         is not None
     )
@@ -1251,7 +1263,12 @@ async def test_farmer_additional_headers_on_partial_submit(
 
     assert (
         verify_and_get_quality_string(
-            pos, DEFAULT_CONSTANTS, sp.challenge_hash, sp.challenge_chain_sp, height=uint32(1)
+            pos,
+            DEFAULT_CONSTANTS,
+            sp.challenge_hash,
+            sp.challenge_chain_sp,
+            height=uint32(1),
+            prev_transaction_block_height=uint32(1),
         )
         is not None
     )

chia/_tests/weight_proof/test_weight_proof.py

@@ -47,7 +47,6 @@ async def load_blocks_dont_validate(
             cc_sp,
             block.height,
             difficulty,
-            sub_slot_iters,
             uint32(0),  # prev_tx_block(blocks, prev_b), todo need to get height of prev tx block somehow here
         )
         assert required_iters is not None

chia/consensus/block_header_validation.py

@@ -502,7 +502,6 @@ def validate_unfinished_header_block(
         cc_sp_hash,
         height,
         expected_vs.difficulty,
-        expected_vs.ssi,
         prev_tx_block(blocks, prev_b),
     )
     if required_iters is None:

chia/consensus/default_constants.py

@@ -84,7 +84,7 @@
     HARD_FORK2_HEIGHT=uint32(0xFFFFFFFA),
     # starting at the hard fork 2 height, v1 plots will gradually be phased out,
     # and stop working entirely after this many blocks
-    PLOT_V1_PHASE_OUT=uint32(1179648),
+    PLOT_V1_PHASE_OUT=uint32(255 * 4608),
     # June 2027
     PLOT_FILTER_128_HEIGHT=uint32(10542000),
     # June 2030

chia/consensus/multiprocess_validation.py

@@ -220,7 +220,6 @@ async def return_error(error_code: Err) -> PreValidationResult:
         cc_sp_hash,
         block.height,
         vs.difficulty,
-        vs.ssi,
         prev_tx_block(blockchain, prev_b),
     )
     if required_iters is None:

chia/consensus/pot_iterations.py

@@ -28,25 +28,6 @@ def calculate_sp_iters(constants: ConsensusConstants, sub_slot_iters: uint64, si
     return uint64(calculate_sp_interval_iters(constants, sub_slot_iters) * signage_point_index)
 
 
-def calculate_phase_out(
-    constants: ConsensusConstants,
-    sub_slot_iters: uint64,
-    prev_transaction_block_height: uint32,
-) -> uint64:
-    if prev_transaction_block_height <= constants.HARD_FORK2_HEIGHT:
-        return uint64(0)
-    elif uint32(prev_transaction_block_height - constants.HARD_FORK2_HEIGHT) >= constants.PLOT_V1_PHASE_OUT:
-        return uint64(calculate_sp_interval_iters(constants, sub_slot_iters))
-
-    return uint64(
-        (
-            uint32(prev_transaction_block_height - constants.HARD_FORK2_HEIGHT)
-            * calculate_sp_interval_iters(constants, sub_slot_iters)
-        )
-        // constants.PLOT_V1_PHASE_OUT
-    )
-
-
 def calculate_ip_iters(
     constants: ConsensusConstants,
     sub_slot_iters: uint64,
@@ -75,11 +56,15 @@ def validate_pospace_and_get_required_iters(
     cc_sp_hash: bytes32,
     height: uint32,
     difficulty: uint64,
-    sub_slot_iters: uint64,
     prev_transaction_block_height: uint32,  # this is the height of the last tx block before the current block SP
 ) -> Optional[uint64]:
     q_str: Optional[bytes32] = verify_and_get_quality_string(
-        proof_of_space, constants, challenge, cc_sp_hash, height=height
+        proof_of_space,
+        constants,
+        challenge,
+        cc_sp_hash,
+        height=height,
+        prev_transaction_block_height=prev_transaction_block_height,
     )
     if q_str is None:
         return None
@@ -90,8 +75,6 @@ def validate_pospace_and_get_required_iters(
         proof_of_space.size(),
         difficulty,
         cc_sp_hash,
-        sub_slot_iters,
-        prev_transaction_block_height,
     )
 
 
@@ -101,27 +84,17 @@ def calculate_iterations_quality(
     size: PlotSize,
     difficulty: uint64,
     cc_sp_output_hash: bytes32,
-    ssi: uint64,
-    prev_transaction_block_height: uint32,  # this is the height of the last tx block before the current block SP
 ) -> uint64:
     """
     Calculates the number of iterations from the quality. This is derives as the difficulty times the constant factor
     times a random number between 0 and 1 (based on quality string), divided by plot size.
     """
-    if size.size_v1 is not None:
-        assert size.size_v2 is None
-        phase_out = calculate_phase_out(constants, ssi, prev_transaction_block_height)
-    else:
-        phase_out = uint64(0)
 
     sp_quality_string: bytes32 = std_hash(quality_string + cc_sp_output_hash)
     iters = uint64(
-        (
-            int(difficulty)
-            * int(constants.DIFFICULTY_CONSTANT_FACTOR)
-            * int.from_bytes(sp_quality_string, "big", signed=False)
-            // (int(pow(2, 256)) * int(_expected_plot_size(size)))
-        )
-        + phase_out
+        int(difficulty)
+        * int(constants.DIFFICULTY_CONSTANT_FACTOR)
+        * int.from_bytes(sp_quality_string, "big", signed=False)
+        // (int(pow(2, 256)) * int(_expected_plot_size(size)))
     )
     return max(iters, uint64(1))

chia/farmer/farmer_api.py

@@ -111,6 +111,7 @@ async def new_proof_of_space(
                 new_proof_of_space.challenge_hash,
                 new_proof_of_space.sp_hash,
                 height=sp.peak_height,
+                prev_transaction_block_height=sp.last_tx_height,
             )
             if computed_quality_string is None:
                 plotid: bytes32 = get_plot_id(new_proof_of_space.proof)
@@ -125,8 +126,6 @@ async def new_proof_of_space(
                 new_proof_of_space.proof.size(),
                 sp.difficulty,
                 new_proof_of_space.sp_hash,
-                sp.sub_slot_iters,
-                sp.last_tx_height,
             )
 
             # If the iters are good enough to make a block, proceed with the block making flow
@@ -234,8 +233,6 @@ async def new_proof_of_space(
                     new_proof_of_space.proof.size(),
                     pool_state_dict["current_difficulty"],
                     new_proof_of_space.sp_hash,
-                    sp.sub_slot_iters,
-                    sp.last_tx_height,
                 )
                 if required_iters >= calculate_sp_interval_iters(
                     self.farmer.constants, self.farmer.constants.POOL_SUB_SLOT_ITERS
@@ -813,6 +810,7 @@ def _process_respond_signatures(
         is_sp_signatures: bool = False
         sps = self.farmer.sps[response.sp_hash]
         peak_height = sps[0].peak_height
+        last_tx_height = sps[0].last_tx_height
         signage_point_index = sps[0].signage_point_index
         found_sp_hash_debug = False
         for sp_candidate in sps:
@@ -831,7 +829,12 @@ def _process_respond_signatures(
         include_taproot: bool = pospace.pool_contract_puzzle_hash is not None
 
         computed_quality_string = verify_and_get_quality_string(
-            pospace, self.farmer.constants, response.challenge_hash, response.sp_hash, height=peak_height
+            pospace,
+            self.farmer.constants,
+            response.challenge_hash,
+            response.sp_hash,
+            height=peak_height,
+            prev_transaction_block_height=last_tx_height,
         )
         if computed_quality_string is None:
             self.farmer.log.warning(f"Have invalid PoSpace {pospace}")